From 0a122ba0d8b6a351ce736ca3a2a168cc00642828 Mon Sep 17 00:00:00 2001 From: CentOS Buildsys Date: Apr 02 2014 06:08:41 +0000 Subject: import qemu-kvm-1.5.3-60.el7.src.rpm --- diff --git a/.qemu-kvm.metadata b/.qemu-kvm.metadata index 5ed19e0..a4c878e 100644 --- a/.qemu-kvm.metadata +++ b/.qemu-kvm.metadata @@ -1,5 +1,7 @@ +a07ce6c2f11c692f70c80cea3345aefd20be8a7b SOURCES/rhel6-e1000.rom faac4c56f0ef593721edc66af965bac63760965b SOURCES/rhel6-ne2k_pci.rom ca79836ccce0ffbf25aac4687a3aa64bf281a3c1 SOURCES/rhel6-rtl8139.rom 82eda3fb78a792745e46bcbbea8290cc444ae6bf SOURCES/rhel6-virtio.rom +7c83cf03604d7db8ca5e7c8fce49b59cda240596 SOURCES/bios-256k.bin f5ddbc9701698bc4adc5e98c63ad438c3b8e8510 SOURCES/rhel6-pcnet.rom e5a40bb63de8445a465c507ce27e736cff35ec12 SOURCES/qemu-1.5.3.tar.bz2 diff --git a/SOURCES/README.rhel6-gpxe-source b/SOURCES/README.rhel6-gpxe-source new file mode 100644 index 0000000..bff3160 --- /dev/null +++ b/SOURCES/README.rhel6-gpxe-source @@ -0,0 +1,9 @@ +The ROM images on /usr/share/qemu-kvm/rhel6-*.rom come from the +Red Hat Enterprise Linux 6.4 package gpxe-roms-qemu-0.9.7-6.9.el6.noarch.rpm. + +The source code for those images can be downloaded from: +http://ftp.redhat.com/pub/redhat/linux/enterprise/6Server/en/os/SRPMS/gpxe-0.9.7-6.9.el6.src.rpm + +For more information on how to obtain source code for Red Hat Enterprise Linux +software, you can refer to Chapter 1. Obtaining Red Hat Enterprise Linux of the +Red Hat Enterprise Linux Installation Guide. diff --git a/SOURCES/change-path-from-qemu-to-qemu-kvm.patch b/SOURCES/change-path-from-qemu-to-qemu-kvm.patch index 4c0b87f..0c39da2 100644 --- a/SOURCES/change-path-from-qemu-to-qemu-kvm.patch +++ b/SOURCES/change-path-from-qemu-to-qemu-kvm.patch @@ -20,8 +20,6 @@ index d39261d..3a4678a 100644 #define BUILD_SUFFIX "/pc-bios" char *os_find_datadir(const char *argv0) { -diff --git a/redhat/qemu-kvm.spec.template b/redhat/qemu-kvm.spec.template -index 84088eb..646eb1a 100644 diff --git a/ui/vnc.c b/ui/vnc.c index dfc7459..3726352 100644 --- a/ui/vnc.c diff --git a/SOURCES/ksm.service b/SOURCES/ksm.service index ccc2767..35c6f1d 100644 --- a/SOURCES/ksm.service +++ b/SOURCES/ksm.service @@ -6,8 +6,8 @@ ConditionPathExists=/sys/kernel/mm/ksm Type=oneshot RemainAfterExit=yes EnvironmentFile=-/etc/sysconfig/ksm -ExecStart=/lib/systemd/ksmctl start -ExecStop=/lib/systemd/ksmctl stop +ExecStart=/usr/libexec/ksmctl start +ExecStop=/usr/libexec/ksmctl stop [Install] WantedBy=multi-user.target diff --git a/SOURCES/ksmtuned b/SOURCES/ksmtuned index c59dec0..320ce74 100644 --- a/SOURCES/ksmtuned +++ b/SOURCES/ksmtuned @@ -69,10 +69,11 @@ KSMCTL () { } committed_memory () { - # calculate how much memory is committed to running qemu processes - local progname - progname=${1:-qemu-kvm} - ps -C "$progname" -o rsz | awk '{ sum += $1 }; END { print sum }' + local pidlist + pidlist=$(pgrep -d ' ' -- '^qemu(-kvm|:.{1,11})$') + if [ -n "$pidlist" ]; then + ps -p "$pidlist" -o rsz= + fi | awk '{ sum += $1 }; END { print 0+sum }' } free_memory () { diff --git a/SOURCES/kvm-Add-back-no-hpet-but-ignore-it.patch b/SOURCES/kvm-Add-back-no-hpet-but-ignore-it.patch new file mode 100644 index 0000000..6b3bb08 --- /dev/null +++ b/SOURCES/kvm-Add-back-no-hpet-but-ignore-it.patch @@ -0,0 +1,69 @@ +From 0d436218d32002c29bde5d84a5b41abb915dc753 Mon Sep 17 00:00:00 2001 +From: "Dr. David Alan Gilbert (git)" +Date: Thu, 16 Jan 2014 16:15:05 -0500 +Subject: [PATCH 14/14] Add back -no-hpet but ignore it + +Message-id: <1389888905-31880-1-git-send-email-dgilbert@redhat.com> +Patchwork-id: 56754 +O-Subject: [RHEL-7.0 qemu-kvm PATCH 1/1] Add back -no-hpet but ignore it +Bugzilla: 1044742 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Markus Armbruster +RH-Acked-by: Jiri Denemark + +From: "Dr. David Alan Gilbert" + +BZ: 1044742 +Brew: https://brewweb.devel.redhat.com/taskinfo?taskID=6886373 +Upstream-status: Red Hat only + + Undoes some of bz947441, in that we keep the -no-hpet command line +option, for compatibility with libvirt since it has no way of knowing +that it was removed. + + Since hpet is disabled anyway, keeping the option does no harm. +--- + qemu-options.hx | 2 -- + vl.c | 2 -- + 2 files changed, 4 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + qemu-options.hx | 2 -- + vl.c | 2 -- + 2 files changed, 4 deletions(-) + +diff --git a/qemu-options.hx b/qemu-options.hx +index d9320b5..49b4bc2 100644 +--- a/qemu-options.hx ++++ b/qemu-options.hx +@@ -1280,10 +1280,8 @@ it if your guest OS complains about ACPI problems (PC target machine + only). + ETEXI + +-#if 0 /* Disabled for Red Hat Enterprise Linux */ + DEF("no-hpet", 0, QEMU_OPTION_no_hpet, + "-no-hpet disable HPET\n", QEMU_ARCH_I386) +-#endif + + DEF("acpitable", HAS_ARG, QEMU_OPTION_acpitable, + "-acpitable [sig=str][,rev=n][,oem_id=str][,oem_table_id=str][,oem_rev=n][,asl_compiler_id=str][,asl_compiler_rev=n][,{data|file}=file1[:file2]...]\n" +diff --git a/vl.c b/vl.c +index b70d107..deb5884 100644 +--- a/vl.c ++++ b/vl.c +@@ -3558,11 +3558,9 @@ int main(int argc, char **argv, char **envp) + case QEMU_OPTION_no_acpi: + acpi_enabled = 0; + break; +-#if 0 /* Disabled for Red Hat Enterprise Linux */ + case QEMU_OPTION_no_hpet: + no_hpet = 1; + break; +-#endif + case QEMU_OPTION_balloon: + if (balloon_parse(optarg) < 0) { + fprintf(stderr, "Unknown -balloon argument %s\n", optarg); +-- +1.8.3.1 + diff --git a/SOURCES/kvm-Add-check-for-cache-size-smaller-than-page-size.patch b/SOURCES/kvm-Add-check-for-cache-size-smaller-than-page-size.patch new file mode 100644 index 0000000..1d5720d --- /dev/null +++ b/SOURCES/kvm-Add-check-for-cache-size-smaller-than-page-size.patch @@ -0,0 +1,79 @@ +From 34f122742b3b75db66c9f2a022179136dbc534e4 Mon Sep 17 00:00:00 2001 +From: Orit Wasserman +Date: Tue, 11 Feb 2014 15:20:47 +0100 +Subject: [PATCH 13/28] Add check for cache size smaller than page size + +RH-Author: Orit Wasserman +Message-id: <1392132047-5103-1-git-send-email-owasserm@redhat.com> +Patchwork-id: 57207 +O-Subject: [RHEL7 qemu-kvm PATCH] Add check for cache size smaller than page size +Bugzilla: 1017096 +RH-Acked-by: Juan Quintela +RH-Acked-by: Dr. David Alan Gilbert (git) +RH-Acked-by: Markus Armbruster + +Bugzilla: 1017096 +Upstream: merged +Brew:http://brewweb.devel.redhat.com/brew/taskinfo?taskID=7028464 + +Signed-off-by: Orit Wasserman +Reviewed-by: Juan Quintela +Signed-off-by: Juan Quintela +(cherry picked from commit c91e681a558fc21073ffc491b5a022d5f340fa0b) +--- + arch_init.c | 4 ++++ + migration.c | 10 +++++++++- + 2 files changed, 13 insertions(+), 1 deletion(-) + +Signed-off-by: Miroslav Rezanina +--- + arch_init.c | 4 ++++ + migration.c | 10 +++++++++- + 2 files changed, 13 insertions(+), 1 deletions(-) + +diff --git a/arch_init.c b/arch_init.c +index 31aac84..c3207bf 100644 +--- a/arch_init.c ++++ b/arch_init.c +@@ -178,6 +178,10 @@ static struct { + + int64_t xbzrle_cache_resize(int64_t new_size) + { ++ if (new_size < TARGET_PAGE_SIZE) { ++ return -1; ++ } ++ + if (XBZRLE.cache != NULL) { + return cache_resize(XBZRLE.cache, new_size / TARGET_PAGE_SIZE) * + TARGET_PAGE_SIZE; +diff --git a/migration.c b/migration.c +index 21f7247..6487fe2 100644 +--- a/migration.c ++++ b/migration.c +@@ -474,6 +474,7 @@ void qmp_migrate_cancel(Error **errp) + void qmp_migrate_set_cache_size(int64_t value, Error **errp) + { + MigrationState *s = migrate_get_current(); ++ int64_t new_size; + + /* Check for truncation */ + if (value != (size_t)value) { +@@ -482,7 +483,14 @@ void qmp_migrate_set_cache_size(int64_t value, Error **errp) + return; + } + +- s->xbzrle_cache_size = xbzrle_cache_resize(value); ++ new_size = xbzrle_cache_resize(value); ++ if (new_size < 0) { ++ error_set(errp, QERR_INVALID_PARAMETER_VALUE, "cache size", ++ "is smaller than page size"); ++ return; ++ } ++ ++ s->xbzrle_cache_size = new_size; + } + + int64_t qmp_query_migrate_cache_size(Error **errp) +-- +1.7.1 + diff --git a/SOURCES/kvm-Add-support-statement-to-help-output.patch b/SOURCES/kvm-Add-support-statement-to-help-output.patch new file mode 100644 index 0000000..7979d34 --- /dev/null +++ b/SOURCES/kvm-Add-support-statement-to-help-output.patch @@ -0,0 +1,63 @@ +From a766091a8693181b77b0b1e3b5de9a05aab25c18 Mon Sep 17 00:00:00 2001 +From: Eduardo Habkost +Date: Wed, 4 Dec 2013 18:53:17 +0100 +Subject: [PATCH 01/16] Add support statement to -help output + +RH-Author: Eduardo Habkost +Message-id: <1386183197-27761-1-git-send-email-ehabkost@redhat.com> +Patchwork-id: 55994 +O-Subject: [qemu-kvm RHEL7 PATCH] Add support statement to -help output +Bugzilla: 972773 +RH-Acked-by: Miroslav Rezanina +RH-Acked-by: knoel@redhat.com +RH-Acked-by: Paolo Bonzini + +Bugzilla: 972773 +Brew scratch build: http://brewweb.devel.redhat.com/brew/taskinfo?taskID=6676272 + +Add support statement to -help output, reporting direct qemu-kvm usage +as unsupported by Red Hat, and advising users to use libvirt instead. + +Signed-off-by: Eduardo Habkost +--- + vl.c | 9 +++++++++ + 1 file changed, 9 insertions(+) + +Signed-off-by: Miroslav Rezanina +--- + vl.c | 9 +++++++++ + 1 files changed, 9 insertions(+), 0 deletions(-) + +diff --git a/vl.c b/vl.c +index 4a79f62..b9074c5 100644 +--- a/vl.c ++++ b/vl.c +@@ -1993,9 +1993,17 @@ static void version(void) + printf("QEMU emulator version " QEMU_VERSION QEMU_PKGVERSION ", Copyright (c) 2003-2008 Fabrice Bellard\n"); + } + ++static void print_rh_warning(void) ++{ ++ printf("\nWARNING: Direct use of qemu-kvm from the command line is not supported by Red Hat.\n" ++ "WARNING: Use libvirt as the stable management interface.\n" ++ "WARNING: Some command line options listed here may not be available in future releases.\n\n"); ++} ++ + static void help(int exitcode) + { + version(); ++ print_rh_warning(); + printf("usage: %s [options] [disk_image]\n\n" + "'disk_image' is a raw hard disk image for IDE hard disk 0\n\n", + error_get_progname()); +@@ -2010,6 +2018,7 @@ static void help(int exitcode) + "\n" + "When using -nographic, press 'ctrl-a h' to get some help.\n"); + ++ print_rh_warning(); + exit(exitcode); + } + +-- +1.7.1 + diff --git a/SOURCES/kvm-Documentation-qemu-img-Mention-SIGUSR1-progress-repo.patch b/SOURCES/kvm-Documentation-qemu-img-Mention-SIGUSR1-progress-repo.patch new file mode 100644 index 0000000..b439801 --- /dev/null +++ b/SOURCES/kvm-Documentation-qemu-img-Mention-SIGUSR1-progress-repo.patch @@ -0,0 +1,49 @@ +From 19b8051f791f74ed46a51fff8c74a51bf11dd23d Mon Sep 17 00:00:00 2001 +From: Kevin Wolf +Date: Tue, 11 Feb 2014 16:24:44 +0100 +Subject: [PATCH 27/28] Documentation: qemu-img: Mention SIGUSR1 progress report + +RH-Author: Kevin Wolf +Message-id: <1392135884-10508-4-git-send-email-kwolf@redhat.com> +Patchwork-id: 57224 +O-Subject: [RHEL-7.0 qemu-kvm PATCH 3/3] Documentation: qemu-img: Mention SIGUSR1 progress report +Bugzilla: 997878 +RH-Acked-by: Laszlo Ersek +RH-Acked-by: Jeffrey Cody +RH-Acked-by: Markus Armbruster + +Document the SIGUSR1 behaviour of qemu-img. Also, added compare to the +list of subcommands that support -p. + +Signed-off-by: Kevin Wolf +Reviewed-by: Benoit Canet +(cherry picked from commit 0e3bd9932f862c1c1e4926939b4d0c602ce214ef) + +Signed-off-by: Kevin Wolf +--- + qemu-img.texi | 4 +++- + 1 file changed, 3 insertions(+), 1 deletion(-) + +Signed-off-by: Miroslav Rezanina +--- + qemu-img.texi | 4 +++- + 1 files changed, 3 insertions(+), 1 deletions(-) + +diff --git a/qemu-img.texi b/qemu-img.texi +index d75a780..7c28759 100644 +--- a/qemu-img.texi ++++ b/qemu-img.texi +@@ -53,7 +53,9 @@ indicates that target image must be compressed (qcow format only) + @item -h + with or without a command shows help and lists the supported formats + @item -p +-display progress bar (convert and rebase commands only) ++display progress bar (compare, convert and rebase commands only). ++If the @var{-p} option is not used for a command that supports it, the ++progress is reported when the process receives a @code{SIGUSR1} signal. + @item -q + Quiet mode - do not print any output (except errors). There's no progress bar + in case both @var{-q} and @var{-p} options are used. +-- +1.7.1 + diff --git a/SOURCES/kvm-Don-t-abort-on-memory-allocation-error.patch b/SOURCES/kvm-Don-t-abort-on-memory-allocation-error.patch new file mode 100644 index 0000000..ab25f80 --- /dev/null +++ b/SOURCES/kvm-Don-t-abort-on-memory-allocation-error.patch @@ -0,0 +1,111 @@ +From b75b57e4a5b75f03c5d302ced1287f47de6c9ccc Mon Sep 17 00:00:00 2001 +From: Orit Wasserman +Date: Tue, 11 Feb 2014 15:32:37 +0100 +Subject: [PATCH 16/28] Don't abort on memory allocation error + +RH-Author: Orit Wasserman +Message-id: <1392132757-18587-4-git-send-email-owasserm@redhat.com> +Patchwork-id: 57211 +O-Subject: [RHEL7 qemu-kvm PATCH 3/3] Don't abort on memory allocation error +Bugzilla: 1047448 +RH-Acked-by: Dr. David Alan Gilbert (git) +RH-Acked-by: Juan Quintela +RH-Acked-by: Miroslav Rezanina + +It is better to fail migration in case of failure to +allocate new cache item + +Signed-off-by: Orit Wasserman +Reviewed-by: Dr. David Alan Gilbert +Signed-off-by: Juan Quintela +(cherry picked from commit 89db9987c07977bdb78d5d4b41d65e7acb9a5a2c) +--- + arch_init.c | 4 +++- + include/migration/page_cache.h | 4 +++- + page_cache.c | 16 +++++++++++----- + 3 files changed, 17 insertions(+), 7 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + arch_init.c | 4 +++- + include/migration/page_cache.h | 4 +++- + page_cache.c | 16 +++++++++++----- + 3 files changed, 17 insertions(+), 7 deletions(-) + +diff --git a/arch_init.c b/arch_init.c +index fc0f569..0aacdac 100644 +--- a/arch_init.c ++++ b/arch_init.c +@@ -286,7 +286,9 @@ static int save_xbzrle_page(QEMUFile *f, uint8_t *current_data, + + if (!cache_is_cached(XBZRLE.cache, current_addr)) { + if (!last_stage) { +- cache_insert(XBZRLE.cache, current_addr, current_data); ++ if (cache_insert(XBZRLE.cache, current_addr, current_data) == -1) { ++ return -1; ++ } + } + acct_info.xbzrle_cache_miss++; + return -1; +diff --git a/include/migration/page_cache.h b/include/migration/page_cache.h +index 87894fe..d156f0d 100644 +--- a/include/migration/page_cache.h ++++ b/include/migration/page_cache.h +@@ -60,11 +60,13 @@ uint8_t *get_cached_data(const PageCache *cache, uint64_t addr); + * cache_insert: insert the page into the cache. the page cache + * will dup the data on insert. the previous value will be overwritten + * ++ * Returns -1 on error ++ * + * @cache pointer to the PageCache struct + * @addr: page address + * @pdata: pointer to the page + */ +-void cache_insert(PageCache *cache, uint64_t addr, uint8_t *pdata); ++int cache_insert(PageCache *cache, uint64_t addr, uint8_t *pdata); + + /** + * cache_resize: resize the page cache. In case of size reduction the extra +diff --git a/page_cache.c b/page_cache.c +index 2920123..250772d 100644 +--- a/page_cache.c ++++ b/page_cache.c +@@ -151,7 +151,7 @@ uint8_t *get_cached_data(const PageCache *cache, uint64_t addr) + return cache_get_by_addr(cache, addr)->it_data; + } + +-void cache_insert(PageCache *cache, uint64_t addr, uint8_t *pdata) ++int cache_insert(PageCache *cache, uint64_t addr, uint8_t *pdata) + { + + CacheItem *it = NULL; +@@ -162,16 +162,22 @@ void cache_insert(PageCache *cache, uint64_t addr, uint8_t *pdata) + /* actual update of entry */ + it = cache_get_by_addr(cache, addr); + +- /* free old cached data if any */ +- g_free(it->it_data); +- ++ /* allocate page */ + if (!it->it_data) { ++ it->it_data = g_try_malloc(cache->page_size); ++ if (!it->it_data) { ++ DPRINTF("Error allocating page\n"); ++ return -1; ++ } + cache->num_items++; + } + +- it->it_data = g_memdup(pdata, cache->page_size); ++ memcpy(it->it_data, pdata, cache->page_size); ++ + it->it_age = ++cache->max_item_age; + it->it_addr = addr; ++ ++ return 0; + } + + int64_t cache_resize(PageCache *cache, int64_t new_num_pages) +-- +1.7.1 + diff --git a/SOURCES/kvm-Don-t-abort-on-out-of-memory-when-creating-page-cach.patch b/SOURCES/kvm-Don-t-abort-on-out-of-memory-when-creating-page-cach.patch new file mode 100644 index 0000000..2d60644 --- /dev/null +++ b/SOURCES/kvm-Don-t-abort-on-out-of-memory-when-creating-page-cach.patch @@ -0,0 +1,97 @@ +From f58c7c6f3574f28df445c67a378aec5a33285374 Mon Sep 17 00:00:00 2001 +From: Orit Wasserman +Date: Tue, 11 Feb 2014 15:32:36 +0100 +Subject: [PATCH 15/28] Don't abort on out of memory when creating page cache + +RH-Author: Orit Wasserman +Message-id: <1392132757-18587-3-git-send-email-owasserm@redhat.com> +Patchwork-id: 57210 +O-Subject: [RHEL7 qemu-kvm PATCH 2/3] Don't abort on out of memory when creating page cache +Bugzilla: 1047448 +RH-Acked-by: Dr. David Alan Gilbert (git) +RH-Acked-by: Juan Quintela +RH-Acked-by: Miroslav Rezanina + +Signed-off-by: Orit Wasserman +Reviewed-by: Dr. David Alan Gilbert +Signed-off-by: Juan Quintela +(cherry picked from commit a17b2fd3580d1da96e806c8b58e61255e8c57577) +--- + arch_init.c | 18 ++++++++++++++++-- + page_cache.c | 18 ++++++++++++++---- + 2 files changed, 30 insertions(+), 6 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + arch_init.c | 18 ++++++++++++++++-- + page_cache.c | 18 ++++++++++++++---- + 2 files changed, 30 insertions(+), 6 deletions(-) + +diff --git a/arch_init.c b/arch_init.c +index c3207bf..fc0f569 100644 +--- a/arch_init.c ++++ b/arch_init.c +@@ -659,8 +659,22 @@ static int ram_save_setup(QEMUFile *f, void *opaque) + DPRINTF("Error creating cache\n"); + return -1; + } +- XBZRLE.encoded_buf = g_malloc0(TARGET_PAGE_SIZE); +- XBZRLE.current_buf = g_malloc(TARGET_PAGE_SIZE); ++ ++ /* We prefer not to abort if there is no memory */ ++ XBZRLE.encoded_buf = g_try_malloc0(TARGET_PAGE_SIZE); ++ if (!XBZRLE.encoded_buf) { ++ DPRINTF("Error allocating encoded_buf\n"); ++ return -1; ++ } ++ ++ XBZRLE.current_buf = g_try_malloc(TARGET_PAGE_SIZE); ++ if (!XBZRLE.current_buf) { ++ DPRINTF("Error allocating current_buf\n"); ++ g_free(XBZRLE.encoded_buf); ++ XBZRLE.encoded_buf = NULL; ++ return -1; ++ } ++ + acct_clear(); + } + +diff --git a/page_cache.c b/page_cache.c +index 938a79c..2920123 100644 +--- a/page_cache.c ++++ b/page_cache.c +@@ -61,8 +61,12 @@ PageCache *cache_init(int64_t num_pages, unsigned int page_size) + return NULL; + } + +- cache = g_malloc(sizeof(*cache)); +- ++ /* We prefer not to abort if there is no memory */ ++ cache = g_try_malloc(sizeof(*cache)); ++ if (!cache) { ++ DPRINTF("Failed to allocate cache\n"); ++ return NULL; ++ } + /* round down to the nearest power of 2 */ + if (!is_power_of_2(num_pages)) { + num_pages = pow2floor(num_pages); +@@ -75,8 +79,14 @@ PageCache *cache_init(int64_t num_pages, unsigned int page_size) + + DPRINTF("Setting cache buckets to %" PRId64 "\n", cache->max_num_items); + +- cache->page_cache = g_malloc((cache->max_num_items) * +- sizeof(*cache->page_cache)); ++ /* We prefer not to abort if there is no memory */ ++ cache->page_cache = g_try_malloc((cache->max_num_items) * ++ sizeof(*cache->page_cache)); ++ if (!cache->page_cache) { ++ DPRINTF("Failed to allocate cache->page_cache\n"); ++ g_free(cache); ++ return NULL; ++ } + + for (i = 0; i < cache->max_num_items; i++) { + cache->page_cache[i].it_data = NULL; +-- +1.7.1 + diff --git a/SOURCES/kvm-Fix-two-XBZRLE-corruption-issues.patch b/SOURCES/kvm-Fix-two-XBZRLE-corruption-issues.patch new file mode 100644 index 0000000..939ec9f --- /dev/null +++ b/SOURCES/kvm-Fix-two-XBZRLE-corruption-issues.patch @@ -0,0 +1,200 @@ +From ccff61f6316a815aa4a538799e089dec7ce754c5 Mon Sep 17 00:00:00 2001 +From: Dr. David Alan Gilbert (git) +Date: Thu, 27 Feb 2014 14:53:37 +0100 +Subject: [PATCH 3/6] Fix two XBZRLE corruption issues + +RH-Author: Dr. David Alan Gilbert (git) +Message-id: <1393512817-21040-1-git-send-email-dgilbert@redhat.com> +Patchwork-id: 57921 +O-Subject: [RHEL-7.0 qemu-kvm PATCH 1/1] Fix two XBZRLE corruption issues +Bugzilla: 1063417 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Juan Quintela +RH-Acked-by: Amit Shah + +From: "Dr. David Alan Gilbert" + +Bugzilla: https://bugzilla.redhat.com/show_bug.cgi?id=1063417 +Brew: https://brewweb.devel.redhat.com/taskinfo?taskID=7115209 +Upstream: 6d3cb1f970ee85361618f7ff02869180394e012d + +Push zero'd pages into the XBZRLE cache + A page that was cached by XBZRLE, zero'd and then XBZRLE'd again + was being compared against a stale cache value + +Don't use 'qemu_put_buffer_async' to put pages from the XBZRLE cache + Since the cache might change before the data hits the wire + +Signed-off-by: Dr. David Alan Gilbert +Signed-off-by: Juan Quintela +(cherry picked from commit 6d3cb1f970ee85361618f7ff02869180394e012d) +--- + arch_init.c | 64 ++++++++++++++++++++++++++++++++---------- + include/migration/page_cache.h | 2 +- + page_cache.c | 2 +- + 3 files changed, 51 insertions(+), 17 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + arch_init.c | 64 ++++++++++++++++++++++++++++++--------- + include/migration/page_cache.h | 2 +- + page_cache.c | 2 +- + 3 files changed, 51 insertions(+), 17 deletions(-) + +diff --git a/arch_init.c b/arch_init.c +index 31bf690..f5d521a 100644 +--- a/arch_init.c ++++ b/arch_init.c +@@ -122,7 +122,6 @@ static void check_guest_throttling(void); + #define RAM_SAVE_FLAG_XBZRLE 0x40 + /* 0x80 is reserved in migration.h start with 0x100 next */ + +- + static struct defconfig_file { + const char *filename; + /* Indicates it is an user config file (disabled by -no-user-config) */ +@@ -133,6 +132,7 @@ static struct defconfig_file { + { NULL }, /* end of list */ + }; + ++static const uint8_t ZERO_TARGET_PAGE[TARGET_PAGE_SIZE]; + + int qemu_read_default_config_files(bool userconfig) + { +@@ -273,6 +273,34 @@ static size_t save_block_hdr(QEMUFile *f, RAMBlock *block, ram_addr_t offset, + return size; + } + ++/* This is the last block that we have visited serching for dirty pages ++ */ ++static RAMBlock *last_seen_block; ++/* This is the last block from where we have sent data */ ++static RAMBlock *last_sent_block; ++static ram_addr_t last_offset; ++static unsigned long *migration_bitmap; ++static uint64_t migration_dirty_pages; ++static uint32_t last_version; ++static bool ram_bulk_stage; ++ ++/* Update the xbzrle cache to reflect a page that's been sent as all 0. ++ * The important thing is that a stale (not-yet-0'd) page be replaced ++ * by the new data. ++ * As a bonus, if the page wasn't in the cache it gets added so that ++ * when a small write is made into the 0'd page it gets XBZRLE sent ++ */ ++static void xbzrle_cache_zero_page(ram_addr_t current_addr) ++{ ++ if (ram_bulk_stage || !migrate_use_xbzrle()) { ++ return; ++ } ++ ++ /* We don't care if this fails to allocate a new cache page ++ * as long as it updated an old one */ ++ cache_insert(XBZRLE.cache, current_addr, ZERO_TARGET_PAGE); ++} ++ + #define ENCODING_FLAG_XBZRLE 0x1 + + static int save_xbzrle_page(QEMUFile *f, uint8_t *current_data, +@@ -329,18 +357,6 @@ static int save_xbzrle_page(QEMUFile *f, uint8_t *current_data, + return bytes_sent; + } + +- +-/* This is the last block that we have visited serching for dirty pages +- */ +-static RAMBlock *last_seen_block; +-/* This is the last block from where we have sent data */ +-static RAMBlock *last_sent_block; +-static ram_addr_t last_offset; +-static unsigned long *migration_bitmap; +-static uint64_t migration_dirty_pages; +-static uint32_t last_version; +-static bool ram_bulk_stage; +- + static inline + ram_addr_t migration_bitmap_find_and_reset_dirty(MemoryRegion *mr, + ram_addr_t start) +@@ -512,6 +528,7 @@ static int ram_save_block(QEMUFile *f, bool last_stage) + } else { + int ret; + uint8_t *p; ++ bool send_async = true; + int cont = (block == last_sent_block) ? + RAM_SAVE_FLAG_CONTINUE : 0; + +@@ -522,6 +539,7 @@ static int ram_save_block(QEMUFile *f, bool last_stage) + ret = ram_control_save_page(f, block->offset, + offset, TARGET_PAGE_SIZE, &bytes_sent); + ++ current_addr = block->offset + offset; + if (ret != RAM_SAVE_CONTROL_NOT_SUPP) { + if (ret != RAM_SAVE_CONTROL_DELAYED) { + if (bytes_sent > 0) { +@@ -536,19 +554,35 @@ static int ram_save_block(QEMUFile *f, bool last_stage) + RAM_SAVE_FLAG_COMPRESS); + qemu_put_byte(f, 0); + bytes_sent++; ++ /* Must let xbzrle know, otherwise a previous (now 0'd) cached ++ * page would be stale ++ */ ++ xbzrle_cache_zero_page(current_addr); + } else if (!ram_bulk_stage && migrate_use_xbzrle()) { +- current_addr = block->offset + offset; + bytes_sent = save_xbzrle_page(f, p, current_addr, block, + offset, cont, last_stage); + if (!last_stage) { ++ /* We must send exactly what's in the xbzrle cache ++ * even if the page wasn't xbzrle compressed, so that ++ * it's right next time. ++ */ + p = get_cached_data(XBZRLE.cache, current_addr); ++ ++ /* Can't send this cached data async, since the cache page ++ * might get updated before it gets to the wire ++ */ ++ send_async = false; + } + } + + /* XBZRLE overflow or normal page */ + if (bytes_sent == -1) { + bytes_sent = save_block_hdr(f, block, offset, cont, RAM_SAVE_FLAG_PAGE); +- qemu_put_buffer_async(f, p, TARGET_PAGE_SIZE); ++ if (send_async) { ++ qemu_put_buffer_async(f, p, TARGET_PAGE_SIZE); ++ } else { ++ qemu_put_buffer(f, p, TARGET_PAGE_SIZE); ++ } + bytes_sent += TARGET_PAGE_SIZE; + acct_info.norm_pages++; + } +diff --git a/include/migration/page_cache.h b/include/migration/page_cache.h +index d156f0d..2d5ce2d 100644 +--- a/include/migration/page_cache.h ++++ b/include/migration/page_cache.h +@@ -66,7 +66,7 @@ uint8_t *get_cached_data(const PageCache *cache, uint64_t addr); + * @addr: page address + * @pdata: pointer to the page + */ +-int cache_insert(PageCache *cache, uint64_t addr, uint8_t *pdata); ++int cache_insert(PageCache *cache, uint64_t addr, const uint8_t *pdata); + + /** + * cache_resize: resize the page cache. In case of size reduction the extra +diff --git a/page_cache.c b/page_cache.c +index 250772d..5a763f9 100644 +--- a/page_cache.c ++++ b/page_cache.c +@@ -151,7 +151,7 @@ uint8_t *get_cached_data(const PageCache *cache, uint64_t addr) + return cache_get_by_addr(cache, addr)->it_data; + } + +-int cache_insert(PageCache *cache, uint64_t addr, uint8_t *pdata) ++int cache_insert(PageCache *cache, uint64_t addr, const uint8_t *pdata) + { + + CacheItem *it = NULL; +-- +1.7.1 + diff --git a/SOURCES/kvm-Fix-uninitialized-cpuid_data.patch b/SOURCES/kvm-Fix-uninitialized-cpuid_data.patch new file mode 100644 index 0000000..7de28e6 --- /dev/null +++ b/SOURCES/kvm-Fix-uninitialized-cpuid_data.patch @@ -0,0 +1,111 @@ +From 2f85f6c61990fd4d46e4980128ee8ba2d3cfaa37 Mon Sep 17 00:00:00 2001 +From: Vadim Rozenfeld +Date: Mon, 3 Mar 2014 12:09:14 +0100 +Subject: [PATCH 02/12] kvm: Fix uninitialized cpuid_data + +RH-Author: Vadim Rozenfeld +Message-id: <1393848564-10511-3-git-send-email-vrozenfe@redhat.com> +Patchwork-id: 57958 +O-Subject: [RHEL-7.0 qemu-kvm v4 PATCH 02/12] kvm: Fix uninitialized cpuid_data +Bugzilla: 1057173 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Igor Mammedov +RH-Acked-by: Juan Quintela +RH-Acked-by: Eduardo Habkost + +From: Stefan Weil + +This error was reported by valgrind when running qemu-system-x86_64 +with kvm: + +==975== Conditional jump or move depends on uninitialised value(s) +==975== at 0x521C38: cpuid_find_entry (kvm.c:176) +==975== by 0x5235BA: kvm_arch_init_vcpu (kvm.c:686) +==975== by 0x4D5175: kvm_init_vcpu (kvm-all.c:267) +==975== by 0x45035B: qemu_kvm_cpu_thread_fn (cpus.c:858) +==975== by 0xD361E0D: start_thread (pthread_create.c:311) +==975== by 0xD65E9EC: clone (clone.S:113) +==975== Uninitialised value was created by a stack allocation +==975== at 0x5226E4: kvm_arch_init_vcpu (kvm.c:446) + +Instead of adding more memset calls for parts of cpuid_data, the existing +calls were removed and cpuid_data is now initialized completely in one +call. + +Signed-off-by: Stefan Weil +Signed-off-by: Gleb Natapov +(cherry picked from commit ef4cbe14342c1f63b3c754e306218f004f4e26c4) +--- + target-i386/kvm.c | 9 ++------- + 1 file changed, 2 insertions(+), 7 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + target-i386/kvm.c | 9 ++------- + 1 files changed, 2 insertions(+), 7 deletions(-) + +diff --git a/target-i386/kvm.c b/target-i386/kvm.c +index c7fabd7..3a9e376 100644 +--- a/target-i386/kvm.c ++++ b/target-i386/kvm.c +@@ -453,11 +453,12 @@ int kvm_arch_init_vcpu(CPUState *cs) + uint32_t signature[3]; + int r; + ++ memset(&cpuid_data, 0, sizeof(cpuid_data)); ++ + cpuid_i = 0; + + /* Paravirtualization CPUIDs */ + c = &cpuid_data.entries[cpuid_i++]; +- memset(c, 0, sizeof(*c)); + c->function = KVM_CPUID_SIGNATURE; + if (!hyperv_enabled(cpu)) { + memcpy(signature, "KVMKVMKVM\0\0\0", 12); +@@ -471,7 +472,6 @@ int kvm_arch_init_vcpu(CPUState *cs) + c->edx = signature[2]; + + c = &cpuid_data.entries[cpuid_i++]; +- memset(c, 0, sizeof(*c)); + c->function = KVM_CPUID_FEATURES; + c->eax = env->features[FEAT_KVM]; + +@@ -480,13 +480,11 @@ int kvm_arch_init_vcpu(CPUState *cs) + c->eax = signature[0]; + + c = &cpuid_data.entries[cpuid_i++]; +- memset(c, 0, sizeof(*c)); + c->function = HYPERV_CPUID_VERSION; + c->eax = 0x00001bbc; + c->ebx = 0x00060001; + + c = &cpuid_data.entries[cpuid_i++]; +- memset(c, 0, sizeof(*c)); + c->function = HYPERV_CPUID_FEATURES; + if (cpu->hyperv_relaxed_timing) { + c->eax |= HV_X64_MSR_HYPERCALL_AVAILABLE; +@@ -497,7 +495,6 @@ int kvm_arch_init_vcpu(CPUState *cs) + } + + c = &cpuid_data.entries[cpuid_i++]; +- memset(c, 0, sizeof(*c)); + c->function = HYPERV_CPUID_ENLIGHTMENT_INFO; + if (cpu->hyperv_relaxed_timing) { + c->eax |= HV_X64_RELAXED_TIMING_RECOMMENDED; +@@ -508,13 +505,11 @@ int kvm_arch_init_vcpu(CPUState *cs) + c->ebx = cpu->hyperv_spinlock_attempts; + + c = &cpuid_data.entries[cpuid_i++]; +- memset(c, 0, sizeof(*c)); + c->function = HYPERV_CPUID_IMPLEMENT_LIMITS; + c->eax = 0x40; + c->ebx = 0x40; + + c = &cpuid_data.entries[cpuid_i++]; +- memset(c, 0, sizeof(*c)); + c->function = KVM_CPUID_SIGNATURE_NEXT; + memcpy(signature, "KVMKVMKVM\0\0\0", 12); + c->eax = 0; +-- +1.7.1 + diff --git a/SOURCES/kvm-HMP-Disable-drive_add-for-Red-Hat-Enterprise-Linux.patch b/SOURCES/kvm-HMP-Disable-drive_add-for-Red-Hat-Enterprise-Linux.patch new file mode 100644 index 0000000..3e5b594 --- /dev/null +++ b/SOURCES/kvm-HMP-Disable-drive_add-for-Red-Hat-Enterprise-Linux.patch @@ -0,0 +1,54 @@ +From 8bc60f9c097965e17f1cfa32e66461aacdb11083 Mon Sep 17 00:00:00 2001 +Message-Id: <8bc60f9c097965e17f1cfa32e66461aacdb11083.1387385974.git.minovotn@redhat.com> +In-Reply-To: <7cba796b16325e96d01e65bd265b4073ab103157.1387385974.git.minovotn@redhat.com> +References: <7cba796b16325e96d01e65bd265b4073ab103157.1387385974.git.minovotn@redhat.com> +From: Markus Armbruster +Date: Tue, 17 Dec 2013 06:46:39 +0100 +Subject: [PATCH 5/5] HMP: Disable drive_add for Red Hat Enterprise Linux + +RH-Author: Markus Armbruster +Message-id: <1387262799-10350-7-git-send-email-armbru@redhat.com> +Patchwork-id: 56297 +O-Subject: [PATCH v2 6/6] HMP: Disable drive_add for Red Hat Enterprise Linux +Bugzilla: 889051 +RH-Acked-by: Fam Zheng +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Luiz Capitulino + +From: Markus Armbruster + +Same as in RHEL-6; commit ed45bb8 there. + +Signed-off-by: Markus Armbruster +--- + hmp-commands.hx | 2 ++ + 1 file changed, 2 insertions(+) + +Signed-off-by: Michal Novotny +--- + hmp-commands.hx | 2 ++ + 1 file changed, 2 insertions(+) + +diff --git a/hmp-commands.hx b/hmp-commands.hx +index bfb565b..32cc33c 100644 +--- a/hmp-commands.hx ++++ b/hmp-commands.hx +@@ -1072,6 +1072,7 @@ using the specified target. + ETEXI + #endif + ++#if 0 /* Disabled for Red Hat Enterprise Linux */ + { + .name = "drive_add", + .args_type = "pci_addr:s,opts:s", +@@ -1084,6 +1085,7 @@ ETEXI + .help = "add drive to PCI storage controller", + .mhandler.cmd = drive_hot_add, + }, ++#endif + + STEXI + @item drive_add +-- +1.7.11.7 + diff --git a/SOURCES/kvm-HMP-Forward-port-__com.redhat_drive_add-from-RHEL-6.patch b/SOURCES/kvm-HMP-Forward-port-__com.redhat_drive_add-from-RHEL-6.patch new file mode 100644 index 0000000..9f13518 --- /dev/null +++ b/SOURCES/kvm-HMP-Forward-port-__com.redhat_drive_add-from-RHEL-6.patch @@ -0,0 +1,110 @@ +From c18bb5012af503e6ca0278cc5bd9457d853fa218 Mon Sep 17 00:00:00 2001 +Message-Id: +In-Reply-To: <7cba796b16325e96d01e65bd265b4073ab103157.1387385974.git.minovotn@redhat.com> +References: <7cba796b16325e96d01e65bd265b4073ab103157.1387385974.git.minovotn@redhat.com> +From: Markus Armbruster +Date: Tue, 17 Dec 2013 06:46:37 +0100 +Subject: [PATCH 3/5] HMP: Forward-port __com.redhat_drive_add from RHEL-6 + +RH-Author: Markus Armbruster +Message-id: <1387262799-10350-5-git-send-email-armbru@redhat.com> +Patchwork-id: 56295 +O-Subject: [PATCH v2 4/6] HMP: Forward-port __com.redhat_drive_add from RHEL-6 +Bugzilla: 889051 +RH-Acked-by: Fam Zheng +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Luiz Capitulino + +From: Markus Armbruster + +Signed-off-by: Markus Armbruster +--- + blockdev.c | 14 ++++++++++++++ + hmp-commands.hx | 15 +++++++++++++++ + include/sysemu/sysemu.h | 1 + + vl.c | 1 + + 4 files changed, 31 insertions(+) + +Signed-off-by: Michal Novotny +--- + blockdev.c | 14 ++++++++++++++ + hmp-commands.hx | 15 +++++++++++++++ + include/sysemu/sysemu.h | 1 + + vl.c | 1 + + 4 files changed, 31 insertions(+) + +diff --git a/blockdev.c b/blockdev.c +index f6d607c..93fb339 100644 +--- a/blockdev.c ++++ b/blockdev.c +@@ -1916,3 +1916,17 @@ QemuOptsList qemu_drive_opts = { + { /* end of list */ } + }, + }; ++ ++QemuOptsList qemu_simple_drive_opts = { ++ .name = "simple-drive", ++ .implied_opt_name = "format", ++ .head = QTAILQ_HEAD_INITIALIZER(qemu_simple_drive_opts.head), ++ .desc = { ++ /* ++ * no elements => accept any ++ * sanity checking will happen later ++ * when setting device properties ++ */ ++ { /* end if list */ } ++ } ++}; +diff --git a/hmp-commands.hx b/hmp-commands.hx +index c881e01..bfb565b 100644 +--- a/hmp-commands.hx ++++ b/hmp-commands.hx +@@ -1091,6 +1091,21 @@ STEXI + Add drive to PCI storage controller. + ETEXI + ++ { ++ .name = RFQDN_REDHAT "drive_add", ++ .args_type = "simple-drive:O", ++ .params = "id=name,[file=file][,format=f][,media=d]...", ++ .help = "Create a drive similar to -device if=none.", ++ .user_print = monitor_user_noop, ++ .mhandler.cmd_new = simple_drive_add, ++ }, ++ ++STEXI ++@item __com.redhat_drive_add ++@findex __com.redhat_drive_add ++Create a drive similar to -device if=none. ++ETEXI ++ + #if defined(TARGET_I386) && 0 /* Disabled for Red Hat Enterprise Linux */ + { + .name = "pci_add", +diff --git a/include/sysemu/sysemu.h b/include/sysemu/sysemu.h +index 8fbc818..c70d2dd 100644 +--- a/include/sysemu/sysemu.h ++++ b/include/sysemu/sysemu.h +@@ -192,6 +192,7 @@ QemuOpts *qemu_get_machine_opts(void); + bool usb_enabled(bool default_usb); + + extern QemuOptsList qemu_drive_opts; ++extern QemuOptsList qemu_simple_drive_opts; + extern QemuOptsList qemu_chardev_opts; + extern QemuOptsList qemu_device_opts; + extern QemuOptsList qemu_netdev_opts; +diff --git a/vl.c b/vl.c +index da12b90..4a79f62 100644 +--- a/vl.c ++++ b/vl.c +@@ -2837,6 +2837,7 @@ int main(int argc, char **argv, char **envp) + module_call_init(MODULE_INIT_QOM); + + qemu_add_opts(&qemu_drive_opts); ++ qemu_add_opts(&qemu_simple_drive_opts); + qemu_add_opts(&qemu_chardev_opts); + qemu_add_opts(&qemu_device_opts); + qemu_add_opts(&qemu_netdev_opts); +-- +1.7.11.7 + diff --git a/SOURCES/kvm-Partially-revert-rhel-Drop-cfi.pflash01-and-isa-ide-.patch b/SOURCES/kvm-Partially-revert-rhel-Drop-cfi.pflash01-and-isa-ide-.patch new file mode 100644 index 0000000..f8dcb31 --- /dev/null +++ b/SOURCES/kvm-Partially-revert-rhel-Drop-cfi.pflash01-and-isa-ide-.patch @@ -0,0 +1,43 @@ +From 5be39a8c30fba163b3f8358c1b7db02facecb538 Mon Sep 17 00:00:00 2001 +From: Laszlo Ersek +Date: Sat, 11 Jan 2014 17:59:51 +0100 +Subject: [PATCH 01/22] Partially revert "rhel: Drop "cfi.pflash01" and "isa-ide" device" + +RH-Author: Laszlo Ersek +Message-id: <1389463208-6278-2-git-send-email-lersek@redhat.com> +Patchwork-id: 56615 +O-Subject: [RHEL-7.0 qemu-kvm PATCH 01/18] Partially revert "rhel: Drop "cfi.pflash01" and "isa-ide" device" +Bugzilla: 1032346 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Amos Kong +RH-Acked-by: Andrew Jones +RH-Acked-by: Kevin Wolf + +This reverts the cfi.pflash01 elimination in +commit f6852e27575e095269a47f434d318b5fc8822e0a. + +Signed-off-by: Laszlo Ersek +--- + default-configs/x86_64-softmmu.mak | 1 + + 1 file changed, 1 insertion(+) + +Signed-off-by: Miroslav Rezanina +--- + default-configs/x86_64-softmmu.mak | 1 + + 1 files changed, 1 insertions(+), 0 deletions(-) + +diff --git a/default-configs/x86_64-softmmu.mak b/default-configs/x86_64-softmmu.mak +index e7c48ec..7b8b05c 100644 +--- a/default-configs/x86_64-softmmu.mak ++++ b/default-configs/x86_64-softmmu.mak +@@ -19,6 +19,7 @@ CONFIG_I8257=y + CONFIG_IDE_PIIX=y + CONFIG_PIIX_PCI=y + CONFIG_I8259=y ++CONFIG_PFLASH_CFI01=y + CONFIG_TPM_TIS=$(CONFIG_TPM) + CONFIG_PCI_HOTPLUG=y + CONFIG_MC146818RTC=y +-- +1.7.1 + diff --git a/SOURCES/kvm-QEMUBH-make-AioContext-s-bh-re-entrant.patch b/SOURCES/kvm-QEMUBH-make-AioContext-s-bh-re-entrant.patch new file mode 100644 index 0000000..321b803 --- /dev/null +++ b/SOURCES/kvm-QEMUBH-make-AioContext-s-bh-re-entrant.patch @@ -0,0 +1,188 @@ +From 0bf037188149824a8ae161ad9dea7d650b6f7346 Mon Sep 17 00:00:00 2001 +From: Gerd Hoffmann +Date: Tue, 21 Jan 2014 11:25:16 -0500 +Subject: [PATCH 5/6] QEMUBH: make AioContext's bh re-entrant + +Message-id: <1390303517-20167-2-git-send-email-kraxel@redhat.com> +Patchwork-id: 56866 +O-Subject: [RHEL-7 qemu-kvm PATCH 1/2] QEMUBH: make AioContext's bh re-entrant +Bugzilla: 1009297 +RH-Acked-by: Laszlo Ersek +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Miroslav Rezanina + +From: Liu Ping Fan + +BH will be used outside big lock, so introduce lock to protect +between the writers, ie, bh's adders and deleter. The lock only +affects the writers and bh's callback does not take this extra lock. +Note that for the same AioContext, aio_bh_poll() can not run in +parallel yet. + +Signed-off-by: Liu Ping Fan +Reviewed-by: Stefan Hajnoczi +Signed-off-by: Stefan Hajnoczi +(cherry picked from commit dcc772e2f2b7c2a68644133fea2b874f6751a57b) +--- + async.c | 33 +++++++++++++++++++++++++++++++-- + include/block/aio.h | 7 +++++++ + 2 files changed, 38 insertions(+), 2 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + async.c | 33 +++++++++++++++++++++++++++++++-- + include/block/aio.h | 7 +++++++ + 2 files changed, 38 insertions(+), 2 deletions(-) + +diff --git a/async.c b/async.c +index 90fe906..5ce3633 100644 +--- a/async.c ++++ b/async.c +@@ -47,11 +47,16 @@ QEMUBH *aio_bh_new(AioContext *ctx, QEMUBHFunc *cb, void *opaque) + bh->ctx = ctx; + bh->cb = cb; + bh->opaque = opaque; ++ qemu_mutex_lock(&ctx->bh_lock); + bh->next = ctx->first_bh; ++ /* Make sure that the members are ready before putting bh into list */ ++ smp_wmb(); + ctx->first_bh = bh; ++ qemu_mutex_unlock(&ctx->bh_lock); + return bh; + } + ++/* Multiple occurrences of aio_bh_poll cannot be called concurrently */ + int aio_bh_poll(AioContext *ctx) + { + QEMUBH *bh, **bhp, *next; +@@ -61,9 +66,15 @@ int aio_bh_poll(AioContext *ctx) + + ret = 0; + for (bh = ctx->first_bh; bh; bh = next) { ++ /* Make sure that fetching bh happens before accessing its members */ ++ smp_read_barrier_depends(); + next = bh->next; + if (!bh->deleted && bh->scheduled) { + bh->scheduled = 0; ++ /* Paired with write barrier in bh schedule to ensure reading for ++ * idle & callbacks coming after bh's scheduling. ++ */ ++ smp_rmb(); + if (!bh->idle) + ret = 1; + bh->idle = 0; +@@ -75,6 +86,7 @@ int aio_bh_poll(AioContext *ctx) + + /* remove deleted bhs */ + if (!ctx->walking_bh) { ++ qemu_mutex_lock(&ctx->bh_lock); + bhp = &ctx->first_bh; + while (*bhp) { + bh = *bhp; +@@ -85,6 +97,7 @@ int aio_bh_poll(AioContext *ctx) + bhp = &bh->next; + } + } ++ qemu_mutex_unlock(&ctx->bh_lock); + } + + return ret; +@@ -94,24 +107,38 @@ void qemu_bh_schedule_idle(QEMUBH *bh) + { + if (bh->scheduled) + return; +- bh->scheduled = 1; + bh->idle = 1; ++ /* Make sure that idle & any writes needed by the callback are done ++ * before the locations are read in the aio_bh_poll. ++ */ ++ smp_wmb(); ++ bh->scheduled = 1; + } + + void qemu_bh_schedule(QEMUBH *bh) + { + if (bh->scheduled) + return; +- bh->scheduled = 1; + bh->idle = 0; ++ /* Make sure that idle & any writes needed by the callback are done ++ * before the locations are read in the aio_bh_poll. ++ */ ++ smp_wmb(); ++ bh->scheduled = 1; + aio_notify(bh->ctx); + } + ++ ++/* This func is async. ++ */ + void qemu_bh_cancel(QEMUBH *bh) + { + bh->scheduled = 0; + } + ++/* This func is async.The bottom half will do the delete action at the finial ++ * end. ++ */ + void qemu_bh_delete(QEMUBH *bh) + { + bh->scheduled = 0; +@@ -176,6 +203,7 @@ aio_ctx_finalize(GSource *source) + thread_pool_free(ctx->thread_pool); + aio_set_event_notifier(ctx, &ctx->notifier, NULL, NULL); + event_notifier_cleanup(&ctx->notifier); ++ qemu_mutex_destroy(&ctx->bh_lock); + g_array_free(ctx->pollfds, TRUE); + } + +@@ -211,6 +239,7 @@ AioContext *aio_context_new(void) + ctx = (AioContext *) g_source_new(&aio_source_funcs, sizeof(AioContext)); + ctx->pollfds = g_array_new(FALSE, FALSE, sizeof(GPollFD)); + ctx->thread_pool = NULL; ++ qemu_mutex_init(&ctx->bh_lock); + event_notifier_init(&ctx->notifier, false); + aio_set_event_notifier(ctx, &ctx->notifier, + (EventNotifierHandler *) +diff --git a/include/block/aio.h b/include/block/aio.h +index 1836793..cc77771 100644 +--- a/include/block/aio.h ++++ b/include/block/aio.h +@@ -17,6 +17,7 @@ + #include "qemu-common.h" + #include "qemu/queue.h" + #include "qemu/event_notifier.h" ++#include "qemu/thread.h" + + typedef struct BlockDriverAIOCB BlockDriverAIOCB; + typedef void BlockDriverCompletionFunc(void *opaque, int ret); +@@ -53,6 +54,8 @@ typedef struct AioContext { + */ + int walking_handlers; + ++ /* lock to protect between bh's adders and deleter */ ++ QemuMutex bh_lock; + /* Anchor of the list of Bottom Halves belonging to the context */ + struct QEMUBH *first_bh; + +@@ -127,6 +130,8 @@ void aio_notify(AioContext *ctx); + * aio_bh_poll: Poll bottom halves for an AioContext. + * + * These are internal functions used by the QEMU main loop. ++ * And notice that multiple occurrences of aio_bh_poll cannot ++ * be called concurrently + */ + int aio_bh_poll(AioContext *ctx); + +@@ -163,6 +168,8 @@ void qemu_bh_cancel(QEMUBH *bh); + * Deleting a bottom half frees the memory that was allocated for it by + * qemu_bh_new. It also implies canceling the bottom half if it was + * scheduled. ++ * This func is async. The bottom half will do the delete action at the finial ++ * end. + * + * @bh: The bottom half to be deleted. + */ +-- +1.8.3.1 + diff --git a/SOURCES/kvm-QMP-Document-throttling-parameters-of-__com.redhat_d.patch b/SOURCES/kvm-QMP-Document-throttling-parameters-of-__com.redhat_d.patch new file mode 100644 index 0000000..4098edc --- /dev/null +++ b/SOURCES/kvm-QMP-Document-throttling-parameters-of-__com.redhat_d.patch @@ -0,0 +1,56 @@ +From 112d92118243fa1e430c021c6007ec4fcfcb930d Mon Sep 17 00:00:00 2001 +Message-Id: <112d92118243fa1e430c021c6007ec4fcfcb930d.1387385974.git.minovotn@redhat.com> +In-Reply-To: <7cba796b16325e96d01e65bd265b4073ab103157.1387385974.git.minovotn@redhat.com> +References: <7cba796b16325e96d01e65bd265b4073ab103157.1387385974.git.minovotn@redhat.com> +From: Markus Armbruster +Date: Tue, 17 Dec 2013 06:46:38 +0100 +Subject: [PATCH 4/5] QMP: Document throttling parameters of + __com.redhat_drive_add + +RH-Author: Markus Armbruster +Message-id: <1387262799-10350-6-git-send-email-armbru@redhat.com> +Patchwork-id: 56296 +O-Subject: [PATCH v2 5/6] QMP: Document throttling parameters of __com.redhat_drive_add +Bugzilla: 889051 +RH-Acked-by: Fam Zheng +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Luiz Capitulino + +From: Markus Armbruster + +The previous commit copied the code from RHEL-6, including the +throttling parameters added in RHEL-6 commit ea4348a "block: Allow IO +throttling fields in __com.redhat_drive_add". That commit neglected +to update documentation, then in qemu-monitor.hx, now in +qmp-commands.hx. Update it, so that qmp-commands.txt is complete. + +Signed-off-by: Markus Armbruster +--- + qmp-commands.hx | 6 ++++++ + 1 file changed, 6 insertions(+) + +Signed-off-by: Michal Novotny +--- + qmp-commands.hx | 6 ++++++ + 1 file changed, 6 insertions(+) + +diff --git a/qmp-commands.hx b/qmp-commands.hx +index 9e742d5..f6fae33 100644 +--- a/qmp-commands.hx ++++ b/qmp-commands.hx +@@ -137,6 +137,12 @@ Arguments: + - "serial": Drive serial number (json-string, optional) + - "snapshot": Enable snapshot mode (json-bool, optional) + - "copy-on-read": Enable copy-on-read mode (json-bool, optional) ++- "bps": total throughput limit in bytes per second is specified ++- "bps_rd": read throughput limit in bytes per second is specified ++- "bps_wr": write throughput limit in bytes per second is specified ++- "iops": total I/O operations per second is specified ++- "iops_rd": read I/O operations per second is specified ++- "iops_wr": write I/O operations per second is specified + + Example: + +-- +1.7.11.7 + diff --git a/SOURCES/kvm-QMP-Forward-port-__com.redhat_drive_add-from-RHEL-6.patch b/SOURCES/kvm-QMP-Forward-port-__com.redhat_drive_add-from-RHEL-6.patch new file mode 100644 index 0000000..f1c470b --- /dev/null +++ b/SOURCES/kvm-QMP-Forward-port-__com.redhat_drive_add-from-RHEL-6.patch @@ -0,0 +1,203 @@ +From 75ad257a1d23dcbde364ad736770d1bd01f157b6 Mon Sep 17 00:00:00 2001 +Message-Id: <75ad257a1d23dcbde364ad736770d1bd01f157b6.1387385974.git.minovotn@redhat.com> +In-Reply-To: <7cba796b16325e96d01e65bd265b4073ab103157.1387385974.git.minovotn@redhat.com> +References: <7cba796b16325e96d01e65bd265b4073ab103157.1387385974.git.minovotn@redhat.com> +From: Markus Armbruster +Date: Tue, 17 Dec 2013 06:46:36 +0100 +Subject: [PATCH 2/5] QMP: Forward-port __com.redhat_drive_add from RHEL-6 + +RH-Author: Markus Armbruster +Message-id: <1387262799-10350-4-git-send-email-armbru@redhat.com> +Patchwork-id: 56294 +O-Subject: [PATCH v2 3/6] QMP: Forward-port __com.redhat_drive_add from RHEL-6 +Bugzilla: 889051 +RH-Acked-by: Fam Zheng +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Luiz Capitulino + +From: Markus Armbruster + +Code taken from RHEL-6 as of qemu-kvm-0.12.1.2-2.418.el6, backported +and fixed up as follows: + +* Update simple_drive_add() for commit 4e89978 "qemu-option: + qemu_opts_from_qdict(): use error_set()". + +* Update simple_drive_add() for commit 2d0d283 "Support default block + interfaces per QEMUMachine". + +* Add comment explaining drive_init() error reporting hacks to + simple_drive_add(). + +* qemu-monitor.hx has been split into qmp-commands.hx and + hmp-commands.hx. Copy the QMP parts to qmp-commands.hx. Clean up + second example slightly. + +* Trailing whitespace cleaned up. + +Signed-off-by: Markus Armbruster +--- + device-hotplug.c | 73 +++++++++++++++++++++++++++++++++++++++++++++++ + include/sysemu/blockdev.h | 2 ++ + qmp-commands.hx | 46 +++++++++++++++++++++++++++++ + 3 files changed, 121 insertions(+) + +Signed-off-by: Michal Novotny +--- + device-hotplug.c | 73 +++++++++++++++++++++++++++++++++++++++++++++++ + include/sysemu/blockdev.h | 2 ++ + qmp-commands.hx | 46 +++++++++++++++++++++++++++++ + 3 files changed, 121 insertions(+) + +diff --git a/device-hotplug.c b/device-hotplug.c +index 103d34a..20f6b7f 100644 +--- a/device-hotplug.c ++++ b/device-hotplug.c +@@ -77,3 +77,76 @@ err: + drive_put_ref(dinfo); + } + } ++ ++static void check_parm(const char *key, QObject *obj, void *opaque) ++{ ++ static const char *valid_keys[] = { ++ "id", "cyls", "heads", "secs", "trans", "media", "snapshot", ++ "file", "cache", "aio", "format", "serial", "rerror", "werror", ++ "readonly", "copy-on-read", ++#ifdef CONFIG_BLOCK_IO_THROTTLING ++ "bps", "bps_rd", "bps_wr", "iops", "iops_rd", "iops_wr", ++#endif ++ NULL ++ ++ }; ++ int *stopped = opaque; ++ const char **p; ++ ++ if (*stopped) { ++ return; ++ } ++ ++ for (p = valid_keys; *p; p++) { ++ if (!strcmp(key, *p)) { ++ return; ++ } ++ } ++ ++ qerror_report(QERR_INVALID_PARAMETER, key); ++ *stopped = 1; ++} ++ ++int simple_drive_add(Monitor *mon, const QDict *qdict, QObject **ret_data) ++{ ++ int stopped; ++ Error *local_err = NULL; ++ QemuOpts *opts; ++ DriveInfo *dinfo; ++ ++ if (!qdict_haskey(qdict, "id")) { ++ qerror_report(QERR_MISSING_PARAMETER, "id"); ++ return -1; ++ } ++ ++ stopped = 0; ++ qdict_iter(qdict, check_parm, &stopped); ++ if (stopped) { ++ return -1; ++ } ++ ++ opts = qemu_opts_from_qdict(&qemu_drive_opts, qdict, &local_err); ++ if (!opts) { ++ qerror_report_err(local_err); ++ error_free(local_err); ++ return -1; ++ } ++ qemu_opt_set(opts, "if", "none"); ++ dinfo = drive_init(opts, current_machine->block_default_type); ++ if (!dinfo) { ++ /* ++ * drive_init() reports some errors with qerror_report_err(), ++ * and some with error_report(). The latter vanish without ++ * trace in monitor_vprintf(). See also the rather optimistic ++ * upstream commit 74ee59a. Emit a generic error here. If a ++ * prior error from qerror_report_err() is pending, it'll get ++ * ignored. ++ */ ++ qerror_report(QERR_DEVICE_INIT_FAILED, ++ qemu_opts_id(opts)); ++ qemu_opts_del(opts); ++ return -1; ++ } ++ ++ return 0; ++} +diff --git a/include/sysemu/blockdev.h b/include/sysemu/blockdev.h +index 1082091..74e1cea 100644 +--- a/include/sysemu/blockdev.h ++++ b/include/sysemu/blockdev.h +@@ -67,4 +67,6 @@ void qmp_change_blockdev(const char *device, const char *filename, + bool has_format, const char *format, Error **errp); + void do_commit(Monitor *mon, const QDict *qdict); + int do_drive_del(Monitor *mon, const QDict *qdict, QObject **ret_data); ++ ++int simple_drive_add(Monitor *mon, const QDict *qdict, QObject **ret_data); + #endif +diff --git a/qmp-commands.hx b/qmp-commands.hx +index 0ae9204..9e742d5 100644 +--- a/qmp-commands.hx ++++ b/qmp-commands.hx +@@ -106,6 +106,52 @@ Example: + Note: The "force" argument defaults to false. + + EQMP ++ { ++ .name = RFQDN_REDHAT "drive_add", ++ .args_type = "simple-drive:O", ++ .params = "id=name,[file=file][,format=f][,media=d]...", ++ .help = "Create a drive similar to -device if=none.", ++ .user_print = monitor_user_noop, ++ .mhandler.cmd_new = simple_drive_add, ++ }, ++ ++SQMP ++__com.redhat_drive_add ++---------------------- ++ ++Create a drive similar to -device if=none. ++ ++Arguments: ++ ++- "id": Drive ID, must be unique (json-string) ++- "file": Disk image (json-string, optional) ++- "format": Disk format (json-string, optional) ++- "aio": How to perform asynchronous disk I/O (json-string, optional) ++- "cache": Host cache use policy (json-string, optional) ++- "cyls", "heads", "secs": Disk geometry (json-int, optional) ++- "trans": BIOS translation mode (json-string, optional) ++- "media": Media type (json-string, optional) ++- "readonly": Open image read-only (json-bool, optional) ++- "rerror": What to do on read error (json-string, optional) ++- "werror": What to do on write error (json-string, optional) ++- "serial": Drive serial number (json-string, optional) ++- "snapshot": Enable snapshot mode (json-bool, optional) ++- "copy-on-read": Enable copy-on-read mode (json-bool, optional) ++ ++Example: ++ ++1. Add a drive without medium: ++ ++-> { "execute": "__com.redhat_drive_add", "arguments": { "id": "foo" } } ++<- {"return": {}} ++ ++2. Add a drive with medium: ++ ++-> { "execute": "__com.redhat_drive_add", ++ "arguments": { "id": "bar", "file": "tmp.qcow2", "format": "qcow2" } } ++<- {"return": {}} ++ ++EQMP + + { + .name = RFQDN_REDHAT "drive_del", +-- +1.7.11.7 + diff --git a/SOURCES/kvm-QMP-Forward-port-__com.redhat_drive_del-from-RHEL-6.patch b/SOURCES/kvm-QMP-Forward-port-__com.redhat_drive_del-from-RHEL-6.patch new file mode 100644 index 0000000..b7a0be6 --- /dev/null +++ b/SOURCES/kvm-QMP-Forward-port-__com.redhat_drive_del-from-RHEL-6.patch @@ -0,0 +1,88 @@ +From 7cba796b16325e96d01e65bd265b4073ab103157 Mon Sep 17 00:00:00 2001 +Message-Id: <7cba796b16325e96d01e65bd265b4073ab103157.1387385974.git.minovotn@redhat.com> +From: Markus Armbruster +Date: Tue, 17 Dec 2013 06:46:35 +0100 +Subject: [PATCH 1/5] QMP: Forward-port __com.redhat_drive_del from RHEL-6 + +RH-Author: Markus Armbruster +Message-id: <1387262799-10350-3-git-send-email-armbru@redhat.com> +Patchwork-id: 56292 +O-Subject: [PATCH v2 2/6] QMP: Forward-port __com.redhat_drive_del from RHEL-6 +Bugzilla: 889051 +RH-Acked-by: Fam Zheng +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Luiz Capitulino + +From: Markus Armbruster + +Upstream has drive_del, but only in HMP. The backport to RHEL-6 added +it to QMP as well. Since the QMP command is a downstream extension, +it needs the __com.redhat_ prefix. Since RHEL-6 doesn't have separate +definition of QMP and HMP commands, both the QMP and the HMP command +got the prefix. + +RHEL-7 inherits HMP command drive_del from upstream. Add QMP command +__com.redhat_drive_del for RHEL-6 compatibility. + +If we needed similar compatibility for the HMP command, we'd have to +add __com.redhat_drive_del as alias for drive_del. But we don't. + +Code copied from RHEL-6's qemu-monitor.hx as of +qemu-kvm-0.12.1.2-2.418.el6. It has a "drive_del" without the prefix +in the documentation. Fixed here. Hardly worth fixing in RHEL-6 now. + +Signed-off-by: Markus Armbruster +--- + qmp-commands.hx | 31 +++++++++++++++++++++++++++++++ + 1 file changed, 31 insertions(+) + +Signed-off-by: Michal Novotny +--- + qmp-commands.hx | 31 +++++++++++++++++++++++++++++++ + 1 file changed, 31 insertions(+) + +diff --git a/qmp-commands.hx b/qmp-commands.hx +index cedcd17..0ae9204 100644 +--- a/qmp-commands.hx ++++ b/qmp-commands.hx +@@ -108,6 +108,37 @@ Note: The "force" argument defaults to false. + EQMP + + { ++ .name = RFQDN_REDHAT "drive_del", ++ .args_type = "id:s", ++ .params = "device", ++ .help = "remove host block device", ++ .user_print = monitor_user_noop, ++ .mhandler.cmd_new = do_drive_del, ++ }, ++ ++SQMP ++__com.redhat_drive_del ++---------- ++ ++Remove host block device. The result is that guest generated IO is no longer ++submitted against the host device underlying the disk. Once a drive has ++been deleted, the QEMU Block layer returns -EIO which results in IO ++errors in the guest for applications that are reading/writing to the device. ++These errors are always reported to the guest, regardless of the drive's error ++actions (drive options rerror, werror). ++ ++Arguments: ++ ++- "id": the device's ID (json-string) ++ ++Example: ++ ++-> { "execute": "__com.redhat_drive_del", "arguments": { "id": "block1" } } ++<- { "return": {} } ++ ++EQMP ++ ++ { + .name = "change", + .args_type = "device:B,target:F,arg:s?", + .mhandler.cmd_new = qmp_marshal_input_change, +-- +1.7.11.7 + diff --git a/SOURCES/kvm-QMP-Relax-__com.redhat_drive_add-parameter-checking.patch b/SOURCES/kvm-QMP-Relax-__com.redhat_drive_add-parameter-checking.patch new file mode 100644 index 0000000..ec29cad --- /dev/null +++ b/SOURCES/kvm-QMP-Relax-__com.redhat_drive_add-parameter-checking.patch @@ -0,0 +1,85 @@ +From 5ed1e31ed43f8bdfe765c7c564d69fb437961d42 Mon Sep 17 00:00:00 2001 +From: Markus Armbruster +Date: Wed, 5 Mar 2014 17:32:58 +0100 +Subject: [PATCH 02/16] QMP: Relax __com.redhat_drive_add parameter checking + +RH-Author: Markus Armbruster +Message-id: <1394040778-1544-2-git-send-email-armbru@redhat.com> +Patchwork-id: 58021 +O-Subject: [PATCH 7.0 qemu-kvm 1/1] QMP: Relax __com.redhat_drive_add parameter checking +Bugzilla: 1057471 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Fam Zheng +RH-Acked-by: Amos Kong +RH-Acked-by: Kevin Wolf +RH-Acked-by: Stefan Hajnoczi + +I/O throttling and many new features are unavailable with this +command, because its parameter checking is overly restrictive. +Relax it. + +The command was forward-ported from RHEL-6 (commit 75ad257). It +provides access to drive_init() via QMP with the parameters restricted +to a subset of the ones recognized by drive_init(). We did that +because some parameters make sense only when configuring a frontend in +addition to a backend, and the command doesn't do that. + +The parameter filtering is implemented as a whitelist. The +forward-port neglected to update the whitelist for all the stuff that +has changed since RHEL-6. + +Due to new features like driver-specific parameters, a whitelist is no +longer convenient. Replace by a blacklist that contains exactly the +drive_init() parameters that are already filtered out on RHEL-6. + +Signed-off-by: Markus Armbruster +--- + device-hotplug.c | 15 +++++---------- + 1 file changed, 5 insertions(+), 10 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + device-hotplug.c | 15 +++++---------- + 1 files changed, 5 insertions(+), 10 deletions(-) + +diff --git a/device-hotplug.c b/device-hotplug.c +index 20f6b7f..78a18f2 100644 +--- a/device-hotplug.c ++++ b/device-hotplug.c +@@ -80,13 +80,8 @@ err: + + static void check_parm(const char *key, QObject *obj, void *opaque) + { +- static const char *valid_keys[] = { +- "id", "cyls", "heads", "secs", "trans", "media", "snapshot", +- "file", "cache", "aio", "format", "serial", "rerror", "werror", +- "readonly", "copy-on-read", +-#ifdef CONFIG_BLOCK_IO_THROTTLING +- "bps", "bps_rd", "bps_wr", "iops", "iops_rd", "iops_wr", +-#endif ++ static const char *unwanted_keys[] = { ++ "bus", "unit", "index", "if", "boot", "addr", + NULL + + }; +@@ -97,14 +92,14 @@ static void check_parm(const char *key, QObject *obj, void *opaque) + return; + } + +- for (p = valid_keys; *p; p++) { ++ for (p = unwanted_keys; *p; p++) { + if (!strcmp(key, *p)) { ++ qerror_report(QERR_INVALID_PARAMETER, key); ++ *stopped = 1; + return; + } + } + +- qerror_report(QERR_INVALID_PARAMETER, key); +- *stopped = 1; + } + + int simple_drive_add(Monitor *mon, const QDict *qdict, QObject **ret_data) +-- +1.7.1 + diff --git a/SOURCES/kvm-Query-KVM-for-available-memory-slots.patch b/SOURCES/kvm-Query-KVM-for-available-memory-slots.patch new file mode 100644 index 0000000..d229283 --- /dev/null +++ b/SOURCES/kvm-Query-KVM-for-available-memory-slots.patch @@ -0,0 +1,142 @@ +From f69bd1c99d908b9de5ba4f335a55597a3e8fd947 Mon Sep 17 00:00:00 2001 +Message-Id: +In-Reply-To: +References: +From: Alex Williamson +Date: Mon, 9 Dec 2013 17:52:56 +0100 +Subject: [PATCH 07/16] kvm: Query KVM for available memory slots + +RH-Author: Alex Williamson +Message-id: <20131209175223.22125.66085.stgit@bling.home> +Patchwork-id: 56092 +O-Subject: [RHEL7 qemu-kvm PATCH] kvm: Query KVM for available memory slots +Bugzilla: 921490 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Eduardo Habkost +RH-Acked-by: Bandan Das +RH-Acked-by: Amos Kong + +Bugzilla: https://bugzilla.redhat.com/show_bug.cgi?id=921490 +Brew: http://brewweb.devel.redhat.com/brew/taskinfo?taskID=6696277 +Upstream: fb541ca59c8b55911821c9f794c3dbe5de9ba9d8 + +KVM reports the number of available memory slots (KVM_CAP_NR_MEMSLOTS) +using the extension interface. Both x86 and s390 implement this, ARM +and powerpc do not yet enable it. Convert the static slots array to +be dynamically allocated, supporting more slots when available. +Default to 32 when KVM_CAP_NR_MEMSLOTS is not implemented. The +motivation for this change is to support more assigned devices, where +memory mapped PCI MMIO BARs typically take one slot each. + +Signed-off-by: Alex Williamson +Reviewed-by: Thomas Huth +Signed-off-by: Paolo Bonzini +--- + kvm-all.c | 30 +++++++++++++++++++++--------- + 1 file changed, 21 insertions(+), 9 deletions(-) + +Signed-off-by: Michal Novotny +--- + kvm-all.c | 30 +++++++++++++++++++++--------- + 1 file changed, 21 insertions(+), 9 deletions(-) + +diff --git a/kvm-all.c b/kvm-all.c +index f2f68d6..0e21494 100644 +--- a/kvm-all.c ++++ b/kvm-all.c +@@ -72,7 +72,8 @@ typedef struct kvm_dirty_log KVMDirtyLog; + + struct KVMState + { +- KVMSlot slots[32]; ++ KVMSlot *slots; ++ int nr_slots; + int fd; + int vmfd; + int coalesced_mmio; +@@ -122,7 +123,7 @@ static KVMSlot *kvm_alloc_slot(KVMState *s) + { + int i; + +- for (i = 0; i < ARRAY_SIZE(s->slots); i++) { ++ for (i = 0; i < s->nr_slots; i++) { + if (s->slots[i].memory_size == 0) { + return &s->slots[i]; + } +@@ -138,7 +139,7 @@ static KVMSlot *kvm_lookup_matching_slot(KVMState *s, + { + int i; + +- for (i = 0; i < ARRAY_SIZE(s->slots); i++) { ++ for (i = 0; i < s->nr_slots; i++) { + KVMSlot *mem = &s->slots[i]; + + if (start_addr == mem->start_addr && +@@ -160,7 +161,7 @@ static KVMSlot *kvm_lookup_overlapping_slot(KVMState *s, + KVMSlot *found = NULL; + int i; + +- for (i = 0; i < ARRAY_SIZE(s->slots); i++) { ++ for (i = 0; i < s->nr_slots; i++) { + KVMSlot *mem = &s->slots[i]; + + if (mem->memory_size == 0 || +@@ -182,7 +183,7 @@ int kvm_physical_memory_addr_from_host(KVMState *s, void *ram, + { + int i; + +- for (i = 0; i < ARRAY_SIZE(s->slots); i++) { ++ for (i = 0; i < s->nr_slots; i++) { + KVMSlot *mem = &s->slots[i]; + + if (ram >= mem->ram && ram < mem->ram + mem->memory_size) { +@@ -342,7 +343,7 @@ static int kvm_set_migration_log(int enable) + + s->migration_log = enable; + +- for (i = 0; i < ARRAY_SIZE(s->slots); i++) { ++ for (i = 0; i < s->nr_slots; i++) { + mem = &s->slots[i]; + + if (!mem->memory_size) { +@@ -1328,9 +1329,6 @@ int kvm_init(void) + #ifdef KVM_CAP_SET_GUEST_DEBUG + QTAILQ_INIT(&s->kvm_sw_breakpoints); + #endif +- for (i = 0; i < ARRAY_SIZE(s->slots); i++) { +- s->slots[i].slot = i; +- } + s->vmfd = -1; + s->fd = qemu_open("/dev/kvm", O_RDWR); + if (s->fd == -1) { +@@ -1354,6 +1352,19 @@ int kvm_init(void) + goto err; + } + ++ s->nr_slots = kvm_check_extension(s, KVM_CAP_NR_MEMSLOTS); ++ ++ /* If unspecified, use the default value */ ++ if (!s->nr_slots) { ++ s->nr_slots = 32; ++ } ++ ++ s->slots = g_malloc0(s->nr_slots * sizeof(KVMSlot)); ++ ++ for (i = 0; i < s->nr_slots; i++) { ++ s->slots[i].slot = i; ++ } ++ + /* check the vcpu limits */ + soft_vcpus_limit = kvm_recommended_vcpus(s); + hard_vcpus_limit = kvm_max_vcpus(s); +@@ -1467,6 +1478,7 @@ err: + if (s->fd != -1) { + close(s->fd); + } ++ g_free(s->slots); + g_free(s); + + return ret; +-- +1.7.11.7 + diff --git a/SOURCES/kvm-Revert-HMP-Disable-drive_add-for-Red-Hat-Enterprise-2.patch.patch b/SOURCES/kvm-Revert-HMP-Disable-drive_add-for-Red-Hat-Enterprise-2.patch.patch new file mode 100644 index 0000000..cf11949 --- /dev/null +++ b/SOURCES/kvm-Revert-HMP-Disable-drive_add-for-Red-Hat-Enterprise-2.patch.patch @@ -0,0 +1,37 @@ +From f873c32538f9b920c452354665e8957abaf3d63a Mon Sep 17 00:00:00 2001 +Message-Id: +From: Michal Novotny +Date: Wed, 18 Dec 2013 19:06:06 +0100 +Subject: [PATCH] Revert "HMP: Disable drive_add for Red Hat Enterprise Linux" + +This reverts commit 8bc60f9c097965e17f1cfa32e66461aacdb11083 because +it caused make check fail. + +Signed-off-by: Michal Novotny +--- + hmp-commands.hx | 2 -- + 1 file changed, 2 deletions(-) + +diff --git a/hmp-commands.hx b/hmp-commands.hx +index 32cc33c..bfb565b 100644 +--- a/hmp-commands.hx ++++ b/hmp-commands.hx +@@ -1072,7 +1072,6 @@ using the specified target. + ETEXI + #endif + +-#if 0 /* Disabled for Red Hat Enterprise Linux */ + { + .name = "drive_add", + .args_type = "pci_addr:s,opts:s", +@@ -1085,7 +1084,6 @@ ETEXI + .help = "add drive to PCI storage controller", + .mhandler.cmd = drive_hot_add, + }, +-#endif + + STEXI + @item drive_add +-- +1.7.11.7 + diff --git a/SOURCES/kvm-Revert-pc-Disable-the-use-flash-device-for-BIOS-unle.patch b/SOURCES/kvm-Revert-pc-Disable-the-use-flash-device-for-BIOS-unle.patch new file mode 100644 index 0000000..d3abef9 --- /dev/null +++ b/SOURCES/kvm-Revert-pc-Disable-the-use-flash-device-for-BIOS-unle.patch @@ -0,0 +1,125 @@ +From ba3bbcb7fe5b4bb2e8be8dee46cfb637333471f6 Mon Sep 17 00:00:00 2001 +From: Laszlo Ersek +Date: Sat, 11 Jan 2014 17:59:52 +0100 +Subject: [PATCH 02/22] Revert "pc: Disable the "use flash device for BIOS unless KVM" misfeature" + +RH-Author: Laszlo Ersek +Message-id: <1389463208-6278-3-git-send-email-lersek@redhat.com> +Patchwork-id: 56614 +O-Subject: [RHEL-7.0 qemu-kvm PATCH 02/18] Revert "pc: Disable the "use flash device for BIOS unless KVM" misfeature" +Bugzilla: 1032346 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Amos Kong +RH-Acked-by: Andrew Jones +RH-Acked-by: Kevin Wolf + +This reverts commit 23231f783d082bef74ba1d9fed6b07fdd058cb87. + +RHEL-7 note -- I'll quote Markus' awesome original, RHEL-7-specific commit +message here: + +> Use of a flash memory device for the BIOS was added in series "[PATCH +> v10 0/8] PC system flash support", commit 4732dca..1b89faf, v1.1. +> +> Flash vs. ROM is a guest-visible difference. Thus, flash use had to +> be suppressed for machine types pc-1.0 and older. This was +> accomplished by adding a dummy device "pc-sysfw" with property +> "rom_only": +> +> * Non-zero rom_only means "use ROM". Default for pc-1.0 and older. +> * Zero rom_only means "maybe use flash". Default for newer machines. +> +> Not only is the dummy device ugly, it was also retroactively added to +> the older machine types! Fortunately, it's not guest-visible (thus no +> immediate guest ABI breakage), and has no vmstate (thus no immediate +> migration breakage). Breakage occurs only if the user unwisely +> enables flash by setting rom_only to zero. Patch review FAIL #1. +> +> Why "maybe use flash"? Flash didn't work with KVM. Therefore, +> rom_only=0 really means "use flash, except when KVM is enabled, use +> ROM". This is a Bad Idea, because it makes enabling/ disabling KVM +> guest-visible. Patch review FAIL #2. +> +> Aside: it also precludes migrating between KVM on and off, but that's +> not possible for other reasons anyway. +> +> Upstream commit 9953f88 killed the misfeature for new machine types. +> Upstream commit 9e1c2ec reverted the kill, but left a dead variable +> behind. This is what's in RHEL-7 is before this patch. +> +> KVM has recently been made to support flash (KVM_CAP_READONLY_MEM), +> which permitted upstream QEMU to redo the flash vs. ROM switch +> properly (commit 338ea90..dafb82e). + +This commit range is Jordan's series that this backport is all about. + +> The required follow-up cleanup +> hasn't been committed, yet: Paolo's [PATCH v2 0/3] Remove legacy sysfw +> code. + +It has now, I'm including it in the series. + +> Instead of backporting all that, I'm simply ripping out the flash +> feature. ROM has been working just fine for us, and I don't think we +> should complicate RHEL-7 maintenance and support by having two ways to +> map BIOS, at least not without sufficient business reason. + +The business reason seems to be OVMF... + +> The result behaves just like upstream with the follow-up cleanup +> applied, except -pflash doesn't affect the BIOS mapping, but remains +> as it always was: it creates an unused drive. + +... and for it we need -pflash to create the real thing. + +Signed-off-by: Laszlo Ersek +--- + hw/block/pc_sysfw.c | 9 --------- + 1 file changed, 9 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + hw/block/pc_sysfw.c | 9 --------- + 1 files changed, 0 insertions(+), 9 deletions(-) + +diff --git a/hw/block/pc_sysfw.c b/hw/block/pc_sysfw.c +index 0bc5b7a..6149b20 100644 +--- a/hw/block/pc_sysfw.c ++++ b/hw/block/pc_sysfw.c +@@ -36,7 +36,6 @@ + + #define BIOS_FILENAME "bios.bin" + +-#if 0 /* Disabled for Red Hat Enterprise Linux */ + typedef struct PcSysFwDevice { + SysBusDevice busdev; + uint8_t rom_only; +@@ -136,7 +135,6 @@ static void pc_system_flash_init(MemoryRegion *rom_memory, + + pc_isa_bios_init(rom_memory, flash_mem, size); + } +-#endif /* Disabled for Red Hat Enterprise Linux */ + + static void old_pc_system_rom_init(MemoryRegion *rom_memory) + { +@@ -193,7 +191,6 @@ static void old_pc_system_rom_init(MemoryRegion *rom_memory) + bios); + } + +-#if 0 /* Disabled for Red Hat Enterprise Linux */ + /* + * Bug-compatible flash vs. ROM selection enabled? + * A few older machines enable this. +@@ -288,9 +285,3 @@ static void pcsysfw_register (void) + + type_init (pcsysfw_register); + +-#else /* Disabled for Red Hat Enterprise Linux */ +-void pc_system_firmware_init(MemoryRegion *rom_memory) +-{ +- old_pc_system_rom_init(rom_memory); +-} +-#endif +-- +1.7.1 + diff --git a/SOURCES/kvm-Revert-qdev-Do-not-let-the-user-try-to-device_add-wh.patch b/SOURCES/kvm-Revert-qdev-Do-not-let-the-user-try-to-device_add-wh.patch new file mode 100644 index 0000000..ad6b951 --- /dev/null +++ b/SOURCES/kvm-Revert-qdev-Do-not-let-the-user-try-to-device_add-wh.patch @@ -0,0 +1,54 @@ +From 54a8632d899d7a4fa6376c5f658c0da99e9e0b78 Mon Sep 17 00:00:00 2001 +From: Markus Armbruster +Date: Fri, 17 Jan 2014 17:07:52 +0100 +Subject: [PATCH 02/11] Revert "qdev: Do not let the user try to device_add when it cannot work" + +RH-Author: Markus Armbruster +Message-id: <1389978479-30595-3-git-send-email-armbru@redhat.com> +Patchwork-id: 56792 +O-Subject: [PATCH 7.0 qemu-kvm 2/9] Revert "qdev: Do not let the user try to device_add when it cannot work" +Bugzilla: 669524 +RH-Acked-by: Eduardo Habkost +RH-Acked-by: Michael S. Tsirkin +RH-Acked-by: Marcel Apfelbaum + +This reverts commit de651299014ae67b110a2abbff4a9e544b215b2b. + +This one is actually fine, but its non-trivial conflict resolution +would cause many more conflicts in the next few patches. I'm going to +reapply the upstream commit in a place where it applies cleanly. + +Signed-off-by: Markus Armbruster +--- + qdev-monitor.c | 6 +++--- + 1 file changed, 3 insertions(+), 3 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + qdev-monitor.c | 6 +++--- + 1 files changed, 3 insertions(+), 3 deletions(-) + +diff --git a/qdev-monitor.c b/qdev-monitor.c +index f78ff64..d187db5 100644 +--- a/qdev-monitor.c ++++ b/qdev-monitor.c +@@ -477,13 +477,13 @@ DeviceState *qdev_device_add(QemuOpts *opts) + } + } + +- k = DEVICE_CLASS(obj); +- +- if (!k || k->cannot_instantiate_with_device_add_yet) { ++ if (!obj) { + qerror_report(QERR_INVALID_PARAMETER_VALUE, "driver", "device type"); + return NULL; + } + ++ k = DEVICE_CLASS(obj); ++ + /* find bus */ + path = qemu_opt_get(opts, "bus"); + if (path != NULL) { +-- +1.7.1 + diff --git a/SOURCES/kvm-Revert-qdev-monitor-Fix-crash-when-device_add-is-cal.patch b/SOURCES/kvm-Revert-qdev-monitor-Fix-crash-when-device_add-is-cal.patch new file mode 100644 index 0000000..f6f2b0a --- /dev/null +++ b/SOURCES/kvm-Revert-qdev-monitor-Fix-crash-when-device_add-is-cal.patch @@ -0,0 +1,50 @@ +From 0a754547775c6fa99d339a18e07fc9bca013b3ca Mon Sep 17 00:00:00 2001 +From: Markus Armbruster +Date: Fri, 17 Jan 2014 17:07:51 +0100 +Subject: [PATCH 01/11] Revert "qdev-monitor: Fix crash when device_add is called with abstract driver" + +RH-Author: Markus Armbruster +Message-id: <1389978479-30595-2-git-send-email-armbru@redhat.com> +Patchwork-id: 56789 +O-Subject: [PATCH 7.0 qemu-kvm 1/9] Revert "qdev-monitor: Fix crash when device_add is called with abstract driver" +Bugzilla: 669524 +RH-Acked-by: Eduardo Habkost +RH-Acked-by: Michael S. Tsirkin +RH-Acked-by: Marcel Apfelbaum + +This reverts commit 3e97a22728afed3c77140486ec3863eba941535b. + +Reverting because it makes -device nonexistant crash. Incorrect +conflict resolution. I'm going to reapply the upstream commit in a +place where it applies cleanly, and actually works. + +Signed-off-by: Markus Armbruster +--- + qdev-monitor.c | 6 ------ + 1 file changed, 6 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + qdev-monitor.c | 6 ------ + 1 files changed, 0 insertions(+), 6 deletions(-) + +diff --git a/qdev-monitor.c b/qdev-monitor.c +index 979502e..f78ff64 100644 +--- a/qdev-monitor.c ++++ b/qdev-monitor.c +@@ -477,12 +477,6 @@ DeviceState *qdev_device_add(QemuOpts *opts) + } + } + +- if (object_class_is_abstract(obj)) { +- qerror_report(QERR_INVALID_PARAMETER_VALUE, "driver", +- "non-abstract device type"); +- return NULL; +- } +- + k = DEVICE_CLASS(obj); + + if (!k || k->cannot_instantiate_with_device_add_yet) { +-- +1.7.1 + diff --git a/SOURCES/kvm-Revert-usb-tablet-Don-t-claim-wakeup-capability-for-.patch b/SOURCES/kvm-Revert-usb-tablet-Don-t-claim-wakeup-capability-for-.patch new file mode 100644 index 0000000..9e12a50 --- /dev/null +++ b/SOURCES/kvm-Revert-usb-tablet-Don-t-claim-wakeup-capability-for-.patch @@ -0,0 +1,47 @@ +From 9c2b117313b85762b6e9e530596703bbfbe4b8e4 Mon Sep 17 00:00:00 2001 +Message-Id: <9c2b117313b85762b6e9e530596703bbfbe4b8e4.1387382496.git.minovotn@redhat.com> +In-Reply-To: +References: +From: Gerd Hoffmann +Date: Mon, 9 Dec 2013 12:19:21 +0100 +Subject: [PATCH 45/46] Revert "usb-tablet: Don't claim wakeup capability for + USB-2 version" + +RH-Author: Gerd Hoffmann +Message-id: <1386591561-21826-3-git-send-email-kraxel@redhat.com> +Patchwork-id: 56031 +O-Subject: [RHEL-7 qemu-kvm PATCH 2/2] Revert "usb-tablet: Don't claim wakeup capability for USB-2 version" +Bugzilla: 1039513 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Michael S. Tsirkin +RH-Acked-by: Marcel Apfelbaum + +This reverts commit aa1c9e971e80d25b92908dce3dec7c38b49480ea. + +Signed-off-by: Gerd Hoffmann +(cherry picked from commit 690af06aebdfd043a6222de96a535dcba2144caf) +--- + hw/usb/dev-hid.c | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +Signed-off-by: Michal Novotny +--- + hw/usb/dev-hid.c | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/hw/usb/dev-hid.c b/hw/usb/dev-hid.c +index 66c6331..6aadaa0 100644 +--- a/hw/usb/dev-hid.c ++++ b/hw/usb/dev-hid.c +@@ -236,7 +236,7 @@ static const USBDescDevice desc_device_tablet2 = { + .bNumInterfaces = 1, + .bConfigurationValue = 1, + .iConfiguration = STR_CONFIG_TABLET, +- .bmAttributes = 0x80, ++ .bmAttributes = 0xa0, + .bMaxPower = 50, + .nif = 1, + .ifs = &desc_iface_tablet2, +-- +1.7.11.7 + diff --git a/SOURCES/kvm-Set-xbzrle-buffers-to-NULL-after-freeing-them-to-avo.patch b/SOURCES/kvm-Set-xbzrle-buffers-to-NULL-after-freeing-them-to-avo.patch new file mode 100644 index 0000000..09aeee6 --- /dev/null +++ b/SOURCES/kvm-Set-xbzrle-buffers-to-NULL-after-freeing-them-to-avo.patch @@ -0,0 +1,45 @@ +From e8cafbffc5f3363548c13cc237883a3346cff1cf Mon Sep 17 00:00:00 2001 +From: Orit Wasserman +Date: Tue, 11 Feb 2014 14:56:36 +0100 +Subject: [PATCH 17/28] Set xbzrle buffers to NULL after freeing them to avoid double free errors + +RH-Author: Orit Wasserman +Message-id: <1392130597-23600-2-git-send-email-owasserm@redhat.com> +Patchwork-id: 57212 +O-Subject: [RHEL7 qemu-kvm PATCH 1/2] Set xbzrle buffers to NULL after freeing them to avoid double free errors +Bugzilla: 1038540 +RH-Acked-by: Marcel Apfelbaum +RH-Acked-by: Dr. David Alan Gilbert (git) +RH-Acked-by: Juan Quintela + +Signed-off-by: Orit Wasserman +Reviewed-by: Juan Quintela +Reviewed-by: Eric Blake +Signed-off-by: Juan Quintela +(cherry picked from commit f6c6483b259a2395ee44cfa966f622e0f2dbe2ae) +--- + arch_init.c | 3 +++ + 1 file changed, 3 insertions(+) + +Signed-off-by: Miroslav Rezanina +--- + arch_init.c | 3 +++ + 1 files changed, 3 insertions(+), 0 deletions(-) + +diff --git a/arch_init.c b/arch_init.c +index 0aacdac..65148d6 100644 +--- a/arch_init.c ++++ b/arch_init.c +@@ -623,6 +623,9 @@ static void migration_end(void) + g_free(XBZRLE.current_buf); + g_free(XBZRLE.decoded_buf); + XBZRLE.cache = NULL; ++ XBZRLE.encoded_buf = NULL; ++ XBZRLE.current_buf = NULL; ++ XBZRLE.decoded_buf = NULL; + } + } + +-- +1.7.1 + diff --git a/SOURCES/kvm-The-calculation-of-bytes_xfer-in-qemu_put_buffer-is-.patch b/SOURCES/kvm-The-calculation-of-bytes_xfer-in-qemu_put_buffer-is-.patch new file mode 100644 index 0000000..bfe45f6 --- /dev/null +++ b/SOURCES/kvm-The-calculation-of-bytes_xfer-in-qemu_put_buffer-is-.patch @@ -0,0 +1,47 @@ +From a1b552f36a3257593125f054a83c467915c65dc4 Mon Sep 17 00:00:00 2001 +From: "Dr. David Alan Gilbert (git)" +Date: Tue, 14 Jan 2014 15:27:11 -0500 +Subject: [PATCH 02/14] The calculation of bytes_xfer in qemu_put_buffer() is + wrong + +Message-id: <1389713232-30999-2-git-send-email-dgilbert@redhat.com> +Patchwork-id: 56697 +O-Subject: [RHEL-7.0 qemu-kvm PATCH 1/2] The calculation of bytes_xfer in qemu_put_buffer() is wrong +Bugzilla: 1003467 +RH-Acked-by: Orit Wasserman +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Laszlo Ersek + +From: "Wangting (Kathy)" + +In qemu_put_buffer(), bytes_xfer += size is wrong, it will be more +than expected, and should be bytes_xfer += l. + +Signed-off-by: zhangmin +Signed-off-by: Juan Quintela +(cherry picked from commit 8e86729a0e83b557c22808a2337252c969ca3986) +--- + savevm.c | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +Signed-off-by: Miroslav Rezanina +--- + savevm.c | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/savevm.c b/savevm.c +index a0d4e09..bd37959 100644 +--- a/savevm.c ++++ b/savevm.c +@@ -787,7 +787,7 @@ void qemu_put_buffer(QEMUFile *f, const uint8_t *buf, int size) + if (l > size) + l = size; + memcpy(f->buf + f->buf_index, buf, l); +- f->bytes_xfer += size; ++ f->bytes_xfer += l; + if (f->ops->writev_buffer) { + add_to_iovec(f, f->buf + f->buf_index, l); + } +-- +1.8.3.1 + diff --git a/SOURCES/kvm-XBZRLE-cache-size-should-not-be-larger-than-guest-me.patch b/SOURCES/kvm-XBZRLE-cache-size-should-not-be-larger-than-guest-me.patch new file mode 100644 index 0000000..27912e1 --- /dev/null +++ b/SOURCES/kvm-XBZRLE-cache-size-should-not-be-larger-than-guest-me.patch @@ -0,0 +1,48 @@ +From 34974722fc54eb326f5af4153dfa7f73dd7f4d70 Mon Sep 17 00:00:00 2001 +From: Orit Wasserman +Date: Tue, 11 Feb 2014 15:32:35 +0100 +Subject: [PATCH 14/28] XBZRLE cache size should not be larger than guest memory size + +RH-Author: Orit Wasserman +Message-id: <1392132757-18587-2-git-send-email-owasserm@redhat.com> +Patchwork-id: 57209 +O-Subject: [RHEL7 qemu-kvm PATCH 1/3] XBZRLE cache size should not be larger than guest memory size +Bugzilla: 1047448 +RH-Acked-by: Dr. David Alan Gilbert (git) +RH-Acked-by: Juan Quintela +RH-Acked-by: Miroslav Rezanina + +Signed-off-by: Orit Wasserman +Reviewed-by: Dr. David Alan Gilbert +Signed-off-by: Juan Quintela +(cherry picked from commit a5615b14a66e86f620e90c8f4b3537c28bb328d4) +--- + migration.c | 7 +++++++ + 1 file changed, 7 insertions(+) + +Signed-off-by: Miroslav Rezanina +--- + migration.c | 7 +++++++ + 1 files changed, 7 insertions(+), 0 deletions(-) + +diff --git a/migration.c b/migration.c +index 6487fe2..b6de990 100644 +--- a/migration.c ++++ b/migration.c +@@ -483,6 +483,13 @@ void qmp_migrate_set_cache_size(int64_t value, Error **errp) + return; + } + ++ /* Cache should not be larger than guest ram size */ ++ if (value > ram_bytes_total()) { ++ error_set(errp, QERR_INVALID_PARAMETER_VALUE, "cache size", ++ "exceeds guest ram size "); ++ return; ++ } ++ + new_size = xbzrle_cache_resize(value); + if (new_size < 0) { + error_set(errp, QERR_INVALID_PARAMETER_VALUE, "cache size", +-- +1.7.1 + diff --git a/SOURCES/kvm-__com.redhat_qxl_screendump-add-docs.patch b/SOURCES/kvm-__com.redhat_qxl_screendump-add-docs.patch new file mode 100644 index 0000000..4a0bb22 --- /dev/null +++ b/SOURCES/kvm-__com.redhat_qxl_screendump-add-docs.patch @@ -0,0 +1,100 @@ +From faf00a8c4d41c4927d8f296288b8fb5e80b1292c Mon Sep 17 00:00:00 2001 +From: Gerd Hoffmann +Date: Wed, 11 Dec 2013 09:36:11 +0100 +Subject: [PATCH 02/16] __com.redhat_qxl_screendump: add docs + +RH-Author: Gerd Hoffmann +Message-id: <1386754571-21520-2-git-send-email-kraxel@redhat.com> +Patchwork-id: 56149 +O-Subject: [RHEL-7 qemu-kvm PATCH 1/1] __com.redhat_qxl_screendump: add docs +Bugzilla: 903910 +RH-Acked-by: Markus Armbruster +RH-Acked-by: Orit Wasserman +RH-Acked-by: Juan Quintela + +$subject says all. +Patch by armbru, thanks. + +Signed-off-by: Gerd Hoffmann +--- + hmp-commands.hx | 13 ++++++++++--- + qmp-commands.hx | 19 ++++++++++++++----- + 2 files changed, 24 insertions(+), 8 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + hmp-commands.hx | 13 ++++++++++--- + qmp-commands.hx | 19 ++++++++++++++----- + 2 files changed, 24 insertions(+), 8 deletions(-) + +diff --git a/hmp-commands.hx b/hmp-commands.hx +index bfb565b..8e08ebf 100644 +--- a/hmp-commands.hx ++++ b/hmp-commands.hx +@@ -243,6 +243,13 @@ ETEXI + .help = "save screen into PPM image 'filename'", + .mhandler.cmd = hmp_screen_dump, + }, ++ ++STEXI ++@item screendump @var{filename} ++@findex screendump ++Save screen into PPM image @var{filename}. ++ETEXI ++ + { + .name = "__com.redhat_qxl_screendump", + .args_type = "id:s,filename:F", +@@ -252,9 +259,9 @@ ETEXI + }, + + STEXI +-@item screendump @var{filename} +-@findex screendump +-Save screen into PPM image @var{filename}. ++@item __com.redhat_screendump @var{id} @var{filename} ++@findex __com.redhat_screendump ++Save screen from qxl device @var{id} into PPM image @var{filename}. + ETEXI + + { +diff --git a/qmp-commands.hx b/qmp-commands.hx +index f6fae33..7a1bfd4 100644 +--- a/qmp-commands.hx ++++ b/qmp-commands.hx +@@ -231,11 +231,6 @@ EQMP + .args_type = "filename:F", + .mhandler.cmd_new = qmp_marshal_input_screendump, + }, +- { +- .name = "__com.redhat_qxl_screendump", +- .args_type = "id:s,filename:F", +- .mhandler.cmd_new = qmp_marshal_input___com_redhat_qxl_screendump, +- }, + + SQMP + screendump +@@ -255,6 +250,20 @@ Example: + EQMP + + { ++ .name = "__com.redhat_qxl_screendump", ++ .args_type = "id:s,filename:F", ++ .mhandler.cmd_new = qmp_marshal_input___com_redhat_qxl_screendump, ++ }, ++ ++SQMP ++__com.redhat_qxl_screendump ++--------------------------- ++ ++Save screen from qxl device @var{id} into PPM image @var{filename}. ++ ++EQMP ++ ++ { + .name = "stop", + .args_type = "", + .mhandler.cmd_new = qmp_marshal_input_stop, +-- +1.7.1 + diff --git a/SOURCES/kvm-acpi-Fix-PCI-hole-handling-on-build_srat.patch b/SOURCES/kvm-acpi-Fix-PCI-hole-handling-on-build_srat.patch new file mode 100644 index 0000000..1f3368b --- /dev/null +++ b/SOURCES/kvm-acpi-Fix-PCI-hole-handling-on-build_srat.patch @@ -0,0 +1,68 @@ +From fc20209d16cb8ce59b20f3e9b98f99044b8bebaa Mon Sep 17 00:00:00 2001 +From: Eduardo Habkost +Date: Tue, 11 Feb 2014 14:03:48 +0100 +Subject: [PATCH 12/28] acpi: Fix PCI hole handling on build_srat() + +RH-Author: Eduardo Habkost +Message-id: <1392127428-9286-3-git-send-email-ehabkost@redhat.com> +Patchwork-id: 57205 +O-Subject: [PATCH 2/2] acpi: Fix PCI hole handling on build_srat() +Bugzilla: 1048080 +RH-Acked-by: Marcel Apfelbaum +RH-Acked-by: Laszlo Ersek +RH-Acked-by: Michael S. Tsirkin + +Bugzilla: 1048080 +Brew scratch build: http://brewweb.devel.redhat.com/brew/taskinfo?taskID=7027865 + +The original SeaBIOS code used the RamSize variable, that was used by +SeaBIOS for the size of RAM below 4GB, not for all RAM. When copied to +QEMU, the code was changed to use the full RAM size, and this broke the +build_srat() code that handles the PCI hole. + +Change build_srat() to use ram_size_below_4g instead of ram_size, to +restore the original behavior from SeaBIOS. + +Signed-off-by: Eduardo Habkost +Reviewed-by: Michael S. Tsirkin +Signed-off-by: Michael S. Tsirkin +(cherry picked from commit 4c8a949b2416158a311abefc09a20153aa107e93) +Signed-off-by: Eduardo Habkost +--- + hw/i386/acpi-build.c | 10 +++++----- + 1 file changed, 5 insertions(+), 5 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + hw/i386/acpi-build.c | 10 +++++----- + 1 files changed, 5 insertions(+), 5 deletions(-) + +diff --git a/hw/i386/acpi-build.c b/hw/i386/acpi-build.c +index befc39f..33012c9 100644 +--- a/hw/i386/acpi-build.c ++++ b/hw/i386/acpi-build.c +@@ -867,16 +867,16 @@ build_srat(GArray *table_data, GArray *linker, + next_base = mem_base + mem_len; + + /* Cut out the ACPI_PCI hole */ +- if (mem_base <= guest_info->ram_size && +- next_base > guest_info->ram_size) { +- mem_len -= next_base - guest_info->ram_size; ++ if (mem_base <= guest_info->ram_size_below_4g && ++ next_base > guest_info->ram_size_below_4g) { ++ mem_len -= next_base - guest_info->ram_size_below_4g; + if (mem_len > 0) { + numamem = acpi_data_push(table_data, sizeof *numamem); + acpi_build_srat_memory(numamem, mem_base, mem_len, i-1, 1); + } + mem_base = 1ULL << 32; +- mem_len = next_base - guest_info->ram_size; +- next_base += (1ULL << 32) - guest_info->ram_size; ++ mem_len = next_base - guest_info->ram_size_below_4g; ++ next_base += (1ULL << 32) - guest_info->ram_size_below_4g; + } + numamem = acpi_data_push(table_data, sizeof *numamem); + acpi_build_srat_memory(numamem, mem_base, mem_len, i - 1, 1); +-- +1.7.1 + diff --git a/SOURCES/kvm-acpi-add-interface-to-access-user-installed-tables.patch b/SOURCES/kvm-acpi-add-interface-to-access-user-installed-tables.patch new file mode 100644 index 0000000..e119011 --- /dev/null +++ b/SOURCES/kvm-acpi-add-interface-to-access-user-installed-tables.patch @@ -0,0 +1,102 @@ +From 99ac82bfa364eef3e6aa27a12d4eb5e23c7ccfb1 Mon Sep 17 00:00:00 2001 +Message-Id: <99ac82bfa364eef3e6aa27a12d4eb5e23c7ccfb1.1387298827.git.minovotn@redhat.com> +In-Reply-To: <3ed0fb61a3dc912ef036d7ef450bed192090709e.1387298827.git.minovotn@redhat.com> +References: <3ed0fb61a3dc912ef036d7ef450bed192090709e.1387298827.git.minovotn@redhat.com> +From: "Michael S. Tsirkin" +Date: Tue, 17 Dec 2013 15:19:02 +0100 +Subject: [PATCH 46/56] acpi: add interface to access user-installed tables + +RH-Author: Michael S. Tsirkin +Message-id: <1387293161-4085-47-git-send-email-mst@redhat.com> +Patchwork-id: 56353 +O-Subject: [PATCH qemu-kvm RHEL7.0 v2 46/57] acpi: add interface to access user-installed tables +Bugzilla: 1034876 +RH-Acked-by: Igor Mammedov +RH-Acked-by: Marcel Apfelbaum +RH-Acked-by: Laszlo Ersek + +Also add a new API to install builtin tables, so +that we can distinguish between the two. + +Signed-off-by: Michael S. Tsirkin +(cherry picked from commit 60de1163d5b5013fe964ac0792e9a64a823e73a3) +--- + include/hw/acpi/acpi.h | 4 ++++ + hw/acpi/core.c | 40 ++++++++++++++++++++++++++++++++++++++++ + 2 files changed, 44 insertions(+) + +Signed-off-by: Michal Novotny +--- + hw/acpi/core.c | 40 ++++++++++++++++++++++++++++++++++++++++ + include/hw/acpi/acpi.h | 4 ++++ + 2 files changed, 44 insertions(+) + +diff --git a/hw/acpi/core.c b/hw/acpi/core.c +index 42eeace..3352d17 100644 +--- a/hw/acpi/core.c ++++ b/hw/acpi/core.c +@@ -309,6 +309,46 @@ out: + error_propagate(errp, err); + } + ++static bool acpi_table_builtin = false; ++ ++void acpi_table_add_builtin(const QemuOpts *opts, Error **errp) ++{ ++ acpi_table_builtin = true; ++ acpi_table_add(opts, errp); ++} ++ ++unsigned acpi_table_len(void *current) ++{ ++ struct acpi_table_header *hdr = current - sizeof(hdr->_length); ++ return hdr->_length; ++} ++ ++static ++void *acpi_table_hdr(void *h) ++{ ++ struct acpi_table_header *hdr = h; ++ return &hdr->sig; ++} ++ ++uint8_t *acpi_table_first(void) ++{ ++ if (acpi_table_builtin || !acpi_tables) { ++ return NULL; ++ } ++ return acpi_table_hdr(acpi_tables + ACPI_TABLE_PFX_SIZE); ++} ++ ++uint8_t *acpi_table_next(uint8_t *current) ++{ ++ uint8_t *next = current + acpi_table_len(current); ++ ++ if (next - acpi_tables >= acpi_tables_len) { ++ return NULL; ++ } else { ++ return acpi_table_hdr(next); ++ } ++} ++ + static void acpi_notify_wakeup(Notifier *notifier, void *data) + { + ACPIREGS *ar = container_of(notifier, ACPIREGS, wakeup); +diff --git a/include/hw/acpi/acpi.h b/include/hw/acpi/acpi.h +index 635be7b..bb7136d 100644 +--- a/include/hw/acpi/acpi.h ++++ b/include/hw/acpi/acpi.h +@@ -165,6 +165,10 @@ extern int acpi_enabled; + extern char unsigned *acpi_tables; + extern size_t acpi_tables_len; + ++uint8_t *acpi_table_first(void); ++uint8_t *acpi_table_next(uint8_t *current); ++unsigned acpi_table_len(void *current); + void acpi_table_add(const QemuOpts *opts, Error **errp); ++void acpi_table_add_builtin(const QemuOpts *opts, Error **errp); + + #endif /* !QEMU_HW_ACPI_H */ +-- +1.7.11.7 + diff --git a/SOURCES/kvm-acpi-add-rules-to-compile-ASL-source.patch b/SOURCES/kvm-acpi-add-rules-to-compile-ASL-source.patch new file mode 100644 index 0000000..99ce43f --- /dev/null +++ b/SOURCES/kvm-acpi-add-rules-to-compile-ASL-source.patch @@ -0,0 +1,141 @@ +From 4731e5c2fd12e1faf421d63b715c538d43c1dddb Mon Sep 17 00:00:00 2001 +Message-Id: <4731e5c2fd12e1faf421d63b715c538d43c1dddb.1387298827.git.minovotn@redhat.com> +In-Reply-To: <3ed0fb61a3dc912ef036d7ef450bed192090709e.1387298827.git.minovotn@redhat.com> +References: <3ed0fb61a3dc912ef036d7ef450bed192090709e.1387298827.git.minovotn@redhat.com> +From: "Michael S. Tsirkin" +Date: Tue, 17 Dec 2013 15:18:15 +0100 +Subject: [PATCH 33/56] acpi: add rules to compile ASL source + +RH-Author: Michael S. Tsirkin +Message-id: <1387293161-4085-34-git-send-email-mst@redhat.com> +Patchwork-id: 56339 +O-Subject: [PATCH qemu-kvm RHEL7.0 v2 33/57] acpi: add rules to compile ASL source +Bugzilla: 1034876 +RH-Acked-by: Igor Mammedov +RH-Acked-by: Marcel Apfelbaum +RH-Acked-by: Laszlo Ersek + +Detect presence of IASL compiler and use it +to process ASL source. If not there, use pre-compiled +files in-tree. Add script to update the in-tree files. + +Note: distros are known to silently update iasl +so detect correct iasl flags for the installed version on each run as +opposed to at configure time. + +Reviewed-by: Laszlo Ersek +Reviewed-by: Gerd Hoffmann +Tested-by: Gerd Hoffmann +Reviewed-by: Igor Mammedov +Tested-by: Igor Mammedov +Signed-off-by: Michael S. Tsirkin +(cherry picked from commit a31a864273bb501851a4d52a366c645d06a53991) + +Conflicts: + configure +--- + configure | 9 ++++++++- + hw/i386/Makefile.objs | 22 ++++++++++++++++++++++ + scripts/update-acpi.sh | 4 ++++ + 3 files changed, 34 insertions(+), 1 deletion(-) + create mode 100644 scripts/update-acpi.sh + +Signed-off-by: Michal Novotny +--- + configure | 9 ++++++++- + hw/i386/Makefile.objs | 22 ++++++++++++++++++++++ + scripts/update-acpi.sh | 4 ++++ + 3 files changed, 34 insertions(+), 1 deletion(-) + create mode 100644 scripts/update-acpi.sh + +diff --git a/configure b/configure +index 1af1079..f86793d 100755 +--- a/configure ++++ b/configure +@@ -119,6 +119,7 @@ path_of() { + # default parameters + source_path=`dirname "$0"` + cpu="" ++iasl="iasl" + interp_prefix="/usr/gnemul/qemu-%M" + static="no" + cross_prefix="" +@@ -252,6 +253,8 @@ for opt do + ;; + --cc=*) CC="$optarg" + ;; ++ --iasl=*) iasl="$optarg" ++ ;; + --source-path=*) source_path="$optarg" + ;; + --cpu=*) cpu="$optarg" +@@ -1074,6 +1077,7 @@ echo "Advanced options (experts only):" + echo " --source-path=PATH path of source code [$source_path]" + echo " --cross-prefix=PREFIX use PREFIX for compile tools [$cross_prefix]" + echo " --cc=CC use C compiler CC [$cc]" ++echo " --iasl=IASL use ACPI compiler IASL [$iasl]" + echo " --host-cc=CC use C compiler CC [$host_cc] for code run at" + echo " build time" + echo " --objcc=OBJCC use Objective-C compiler OBJCC [$objcc]" +@@ -4056,6 +4060,9 @@ else + fi + echo "PYTHON=$python" >> $config_host_mak + echo "CC=$cc" >> $config_host_mak ++if $iasl -h > /dev/null 2>&1; then ++ echo "IASL=$iasl" >> $config_host_mak ++fi + echo "CC_I386=$cc_i386" >> $config_host_mak + echo "HOST_CC=$host_cc" >> $config_host_mak + echo "OBJCC=$objcc" >> $config_host_mak +@@ -4544,7 +4551,7 @@ for rom in seabios vgabios ; do + echo "BCC=bcc" >> $config_mak + echo "CPP=$cpp" >> $config_mak + echo "OBJCOPY=objcopy" >> $config_mak +- echo "IASL=iasl" >> $config_mak ++ echo "IASL=$iasl" >> $config_mak + echo "LD=$ld" >> $config_mak + done + +diff --git a/hw/i386/Makefile.objs b/hw/i386/Makefile.objs +index 205d22e..013d250 100644 +--- a/hw/i386/Makefile.objs ++++ b/hw/i386/Makefile.objs +@@ -4,3 +4,25 @@ obj-y += pc.o pc_piix.o pc_q35.o + obj-$(CONFIG_XEN) += xen_domainbuild.o xen_machine_pv.o + + obj-y += kvmvapic.o ++ ++iasl-option=$(shell if test -z "`$(1) $(2) 2>&1 > /dev/null`" \ ++ ; then echo "$(2)"; else echo "$(3)"; fi ;) ++ ++ifdef IASL ++#IASL Present. Generate hex files from .dsl ++hw/i386/%.hex: $(SRC_PATH)/hw/i386/%.dsl $(SRC_PATH)/scripts/acpi_extract_preprocess.py $(SRC_PATH)/scripts/acpi_extract.py ++ $(call quiet-command, cpp -P $< -o $*.dsl.i.orig, " CPP $(TARGET_DIR)$*.dsl.i.orig") ++ $(call quiet-command, $(PYTHON) $(SRC_PATH)/scripts/acpi_extract_preprocess.py $*.dsl.i.orig > $*.dsl.i, " ACPI_PREPROCESS $(TARGET_DIR)$*.dsl.i") ++ $(call quiet-command, $(IASL) $(call iasl-option,$(IASL),-Pn,) -vs -l -tc -p $* $*.dsl.i $(if $(V), , > /dev/null) 2>&1 ," IASL $(TARGET_DIR)$*.dsl.i") ++ $(call quiet-command, $(SRC_PATH)/scripts/acpi_extract.py $*.lst > $*.off, " ACPI_EXTRACT $(TARGET_DIR)$*.off") ++ $(call quiet-command, cat $*.off > $@, " CAT $(TARGET_DIR)$@") ++else ++#IASL Not present. Restore pre-generated hex files. ++hw/i386/%.hex: $(SRC_PATH)/hw/i386/%.hex.generated ++ $(call quiet-command, cp -f $< $@, " CP $(TARGET_DIR)$@") ++endif ++ ++.PHONY: cleanhex ++cleanhex: ++ rm -f hw/i386/*hex ++clean: cleanhex +diff --git a/scripts/update-acpi.sh b/scripts/update-acpi.sh +new file mode 100644 +index 0000000..b5f05ff +--- /dev/null ++++ b/scripts/update-acpi.sh +@@ -0,0 +1,4 @@ ++cd x86_64-softmmu ++for file in hw/i386/*.hex; do ++ cp -f $file ../$file.generated ++done +-- +1.7.11.7 + diff --git a/SOURCES/kvm-acpi-build-Fix-compiler-warning-missing-gnu_printf-f.patch b/SOURCES/kvm-acpi-build-Fix-compiler-warning-missing-gnu_printf-f.patch new file mode 100644 index 0000000..d02e608 --- /dev/null +++ b/SOURCES/kvm-acpi-build-Fix-compiler-warning-missing-gnu_printf-f.patch @@ -0,0 +1,81 @@ +From e1826a5a94d53d337a0e0e18230d81b572173ba7 Mon Sep 17 00:00:00 2001 +Message-Id: +In-Reply-To: <3ed0fb61a3dc912ef036d7ef450bed192090709e.1387298827.git.minovotn@redhat.com> +References: <3ed0fb61a3dc912ef036d7ef450bed192090709e.1387298827.git.minovotn@redhat.com> +From: "Michael S. Tsirkin" +Date: Tue, 17 Dec 2013 15:19:27 +0100 +Subject: [PATCH 55/56] acpi-build: Fix compiler warning (missing gnu_printf + format attribute) +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +RH-Author: Michael S. Tsirkin +Message-id: <1387293161-4085-56-git-send-email-mst@redhat.com> +Patchwork-id: 56361 +O-Subject: [PATCH qemu-kvm RHEL7.0 v2 55/57] acpi-build: Fix compiler warning (missing gnu_printf format attribute) +Bugzilla: 1034876 +RH-Acked-by: Igor Mammedov +RH-Acked-by: Marcel Apfelbaum +RH-Acked-by: Laszlo Ersek + +From: Stefan Weil + +gcc 4.8.2 reports this warning when extra warnings are enabled (-Wextra): + + CC m68k-softmmu/hw/m68k/mcf5206.o +hw/i386/acpi-build.c: In function ‘build_append_nameseg’: +hw/i386/acpi-build.c:294:5: error: + function might be possible candidate for ‘gnu_printf’ format attribute [-Werror=suggest-attribute=format] + g_string_vprintf(s, format, args); + ^ + +When this warning is fixed, there is a new compiler warning: + + CC i386-softmmu/hw/i386/acpi-build.o +hw/i386/acpi-build.c: In function ‘build_append_notify’: +hw/i386/acpi-build.c:632:5: error: + format not a string literal and no format arguments [-Werror=format-security] + build_append_nameseg(method, name); + ^ + +This is fixed here, too. + +Signed-off-by: Stefan Weil +Signed-off-by: Michael Tokarev +(cherry picked from commit 867d898ccf50ef095b95c403d7dc809c188b14e2) +--- + hw/i386/acpi-build.c | 5 +++-- + 1 file changed, 3 insertions(+), 2 deletions(-) + +Signed-off-by: Michal Novotny +--- + hw/i386/acpi-build.c | 5 +++-- + 1 file changed, 3 insertions(+), 2 deletions(-) + +diff --git a/hw/i386/acpi-build.c b/hw/i386/acpi-build.c +index 316d6d3..2d008bd 100644 +--- a/hw/i386/acpi-build.c ++++ b/hw/i386/acpi-build.c +@@ -285,7 +285,8 @@ static inline void build_append_array(GArray *array, GArray *val) + g_array_append_vals(array, val->data, val->len); + } + +-static void build_append_nameseg(GArray *array, const char *format, ...) ++static void GCC_FMT_ATTR(2, 3) ++build_append_nameseg(GArray *array, const char *format, ...) + { + /* It would be nicer to use g_string_vprintf but it's only there in 2.22 */ + char s[] = "XXXX"; +@@ -630,7 +631,7 @@ build_append_notify(GArray *device, const char *name, + GArray *method = build_alloc_array(); + uint8_t op = 0x14; /* MethodOp */ + +- build_append_nameseg(method, name); ++ build_append_nameseg(method, "%s", name); + build_append_byte(method, 0x02); /* MethodFlags: ArgCount */ + for (i = skip; i < count; i++) { + GArray *target = build_alloc_array(); +-- +1.7.11.7 + diff --git a/SOURCES/kvm-acpi-build-disable-with-no-acpi.patch b/SOURCES/kvm-acpi-build-disable-with-no-acpi.patch new file mode 100644 index 0000000..f166ffa --- /dev/null +++ b/SOURCES/kvm-acpi-build-disable-with-no-acpi.patch @@ -0,0 +1,60 @@ +From 9c107e1c452bc40beac01fc01f208f76967cb36b Mon Sep 17 00:00:00 2001 +From: Michael S. Tsirkin +Date: Sun, 12 Jan 2014 11:54:00 +0100 +Subject: [PATCH 09/16] acpi-build: disable with -no-acpi + +RH-Author: Michael S. Tsirkin +Message-id: <1389527552-15015-1-git-send-email-mst@redhat.com> +Patchwork-id: 56637 +O-Subject: [PATCH qemu-kvm RHEL7.0] acpi-build: disable with -no-acpi +Bugzilla: 1045386 +RH-Acked-by: Amos Kong +RH-Acked-by: Marcel Apfelbaum +RH-Acked-by: Igor Mammedov +RH-Acked-by: Richard Jones + +QEMU will currently crash if started with -no-acpi flag +since acpi build code probes the PM device which isn't present +in this configuration. + +To fix, don't expose ACPI tables to guest when acpi has been +disabled from command line. + +Fixes LP# 1248854 +https://bugs.launchpad.net/qemu/+bug/1248854 + +Reported-by: chao zhou +Signed-off-by: Michael S. Tsirkin +Reviewed-by: Gerd Hoffmann +(cherry picked from commit 81adc5131534ca7554cebe64cd8f86bac28dbd1b) + +Bugzilla: https://bugzilla.redhat.com/show_bug.cgi?id=1045386 +Brew build: http://brewweb.devel.redhat.com/brew/taskinfo?taskID=6854545 +--- + hw/i386/acpi-build.c | 5 +++++ + 1 file changed, 5 insertions(+) + +Signed-off-by: Miroslav Rezanina +--- + hw/i386/acpi-build.c | 5 +++++ + 1 files changed, 5 insertions(+), 0 deletions(-) + +diff --git a/hw/i386/acpi-build.c b/hw/i386/acpi-build.c +index 2d008bd..befc39f 100644 +--- a/hw/i386/acpi-build.c ++++ b/hw/i386/acpi-build.c +@@ -1185,6 +1185,11 @@ void acpi_setup(PcGuestInfo *guest_info) + return; + } + ++ if (!acpi_enabled) { ++ ACPI_BUILD_DPRINTF(3, "ACPI disabled. Bailing out.\n"); ++ return; ++ } ++ + build_state = g_malloc0(sizeof *build_state); + + build_state->guest_info = guest_info; +-- +1.7.1 + diff --git a/SOURCES/kvm-acpi-build-fix-build-on-glib-2.14.patch b/SOURCES/kvm-acpi-build-fix-build-on-glib-2.14.patch new file mode 100644 index 0000000..9ee8a48 --- /dev/null +++ b/SOURCES/kvm-acpi-build-fix-build-on-glib-2.14.patch @@ -0,0 +1,95 @@ +From 80522ccccfe378cb1b9ff1d6fb468f275aa69c86 Mon Sep 17 00:00:00 2001 +Message-Id: <80522ccccfe378cb1b9ff1d6fb468f275aa69c86.1387298827.git.minovotn@redhat.com> +In-Reply-To: <3ed0fb61a3dc912ef036d7ef450bed192090709e.1387298827.git.minovotn@redhat.com> +References: <3ed0fb61a3dc912ef036d7ef450bed192090709e.1387298827.git.minovotn@redhat.com> +From: "Michael S. Tsirkin" +Date: Tue, 17 Dec 2013 15:19:21 +0100 +Subject: [PATCH 53/56] acpi-build: fix build on glib < 2.14 + +RH-Author: Michael S. Tsirkin +Message-id: <1387293161-4085-54-git-send-email-mst@redhat.com> +Patchwork-id: 56359 +O-Subject: [PATCH qemu-kvm RHEL7.0 v2 53/57] acpi-build: fix build on glib < 2.14 +Bugzilla: 1034876 +RH-Acked-by: Igor Mammedov +RH-Acked-by: Marcel Apfelbaum +RH-Acked-by: Laszlo Ersek + +g_array_get_element_size was only added in glib 2.14. +Fortunately we don't use it for any arrays where +element size is > 1, so just add an assert. + +Reported-by: Richard Henderson +Signed-off-by: Michael S. Tsirkin +Reviewed-by: Paolo Bonzini +Message-id: 1385036128-8753-2-git-send-email-mst@redhat.com +Signed-off-by: Anthony Liguori +(cherry picked from commit b15654c21acef4d2bc17e6ac528c6c93abbb7e1e) +--- + hw/i386/acpi-build.c | 5 ++++- + hw/i386/bios-linker-loader.c | 8 ++++---- + 2 files changed, 8 insertions(+), 5 deletions(-) + +Signed-off-by: Michal Novotny +--- + hw/i386/acpi-build.c | 5 ++++- + hw/i386/bios-linker-loader.c | 8 ++++---- + 2 files changed, 8 insertions(+), 5 deletions(-) + +diff --git a/hw/i386/acpi-build.c b/hw/i386/acpi-build.c +index 4e2d709..4074350 100644 +--- a/hw/i386/acpi-build.c ++++ b/hw/i386/acpi-build.c +@@ -425,7 +425,10 @@ static inline void *acpi_data_push(GArray *table_data, unsigned size) + + static unsigned acpi_data_len(GArray *table) + { +- return table->len * g_array_get_element_size(table); ++#if GLIB_CHECK_VERSION(2, 14, 0) ++ assert(g_array_get_element_size(table) == 1); ++#endif ++ return table->len; + } + + static void acpi_align_size(GArray *blob, unsigned align) +diff --git a/hw/i386/bios-linker-loader.c b/hw/i386/bios-linker-loader.c +index 0833853..fd23611 100644 +--- a/hw/i386/bios-linker-loader.c ++++ b/hw/i386/bios-linker-loader.c +@@ -90,7 +90,7 @@ enum { + + GArray *bios_linker_loader_init(void) + { +- return g_array_new(false, true /* clear */, sizeof(BiosLinkerLoaderEntry)); ++ return g_array_new(false, true /* clear */, 1); + } + + /* Free linker wrapper and return the linker array. */ +@@ -115,7 +115,7 @@ void bios_linker_loader_alloc(GArray *linker, + BIOS_LINKER_LOADER_ALLOC_ZONE_HIGH); + + /* Alloc entries must come first, so prepend them */ +- g_array_prepend_val(linker, entry); ++ g_array_prepend_vals(linker, &entry, sizeof entry); + } + + void bios_linker_loader_add_checksum(GArray *linker, const char *file, +@@ -132,7 +132,7 @@ void bios_linker_loader_add_checksum(GArray *linker, const char *file, + entry.cksum.start = cpu_to_le32((uint8_t *)start - (uint8_t *)table); + entry.cksum.length = cpu_to_le32(size); + +- g_array_append_val(linker, entry); ++ g_array_append_vals(linker, &entry, sizeof entry); + } + + void bios_linker_loader_add_pointer(GArray *linker, +@@ -154,5 +154,5 @@ void bios_linker_loader_add_pointer(GArray *linker, + assert(pointer_size == 1 || pointer_size == 2 || + pointer_size == 4 || pointer_size == 8); + +- g_array_append_val(linker, entry); ++ g_array_append_vals(linker, &entry, sizeof entry); + } +-- +1.7.11.7 + diff --git a/SOURCES/kvm-acpi-build-fix-build-on-glib-2.22.patch b/SOURCES/kvm-acpi-build-fix-build-on-glib-2.22.patch new file mode 100644 index 0000000..d6ceabd --- /dev/null +++ b/SOURCES/kvm-acpi-build-fix-build-on-glib-2.22.patch @@ -0,0 +1,66 @@ +From 5a4f3ccc420f7b6cdce3fc1065119a33e5b0b997 Mon Sep 17 00:00:00 2001 +Message-Id: <5a4f3ccc420f7b6cdce3fc1065119a33e5b0b997.1387298827.git.minovotn@redhat.com> +In-Reply-To: <3ed0fb61a3dc912ef036d7ef450bed192090709e.1387298827.git.minovotn@redhat.com> +References: <3ed0fb61a3dc912ef036d7ef450bed192090709e.1387298827.git.minovotn@redhat.com> +From: "Michael S. Tsirkin" +Date: Tue, 17 Dec 2013 15:19:18 +0100 +Subject: [PATCH 52/56] acpi-build: fix build on glib < 2.22 + +RH-Author: Michael S. Tsirkin +Message-id: <1387293161-4085-53-git-send-email-mst@redhat.com> +Patchwork-id: 56358 +O-Subject: [PATCH qemu-kvm RHEL7.0 v2 52/57] acpi-build: fix build on glib < 2.22 +Bugzilla: 1034876 +RH-Acked-by: Igor Mammedov +RH-Acked-by: Marcel Apfelbaum +RH-Acked-by: Laszlo Ersek + +g_string_vprintf was only introduced in 2.24 so switch to vsnprintf +instead. A bit uglier but name size is fixed at 4 bytes here so it's +easy. + +Reported-by: Richard Henderson +Signed-off-by: Michael S. Tsirkin +Reviewed-by: Paolo Bonzini +Message-id: 1385036128-8753-1-git-send-email-mst@redhat.com +Signed-off-by: Anthony Liguori +(cherry picked from commit 542da88f0013ebb2b2d8ca10becbfebd9948abba) +--- + hw/i386/acpi-build.c | 11 ++++++----- + 1 file changed, 6 insertions(+), 5 deletions(-) + +Signed-off-by: Michal Novotny +--- + hw/i386/acpi-build.c | 11 ++++++----- + 1 file changed, 6 insertions(+), 5 deletions(-) + +diff --git a/hw/i386/acpi-build.c b/hw/i386/acpi-build.c +index 6cfa044..4e2d709 100644 +--- a/hw/i386/acpi-build.c ++++ b/hw/i386/acpi-build.c +@@ -287,16 +287,17 @@ static inline void build_append_array(GArray *array, GArray *val) + + static void build_append_nameseg(GArray *array, const char *format, ...) + { +- GString *s = g_string_new(""); ++ /* It would be nicer to use g_string_vprintf but it's only there in 2.22 */ ++ char s[] = "XXXX"; ++ int len; + va_list args; + + va_start(args, format); +- g_string_vprintf(s, format, args); ++ len = vsnprintf(s, sizeof s, format, args); + va_end(args); + +- assert(s->len == 4); +- g_array_append_vals(array, s->str, s->len); +- g_string_free(s, true); ++ assert(len == 4); ++ g_array_append_vals(array, s, len); + } + + /* 5.4 Definition Block Encoding */ +-- +1.7.11.7 + diff --git a/SOURCES/kvm-acpi-build-fix-support-for-glib-2.22.patch b/SOURCES/kvm-acpi-build-fix-support-for-glib-2.22.patch new file mode 100644 index 0000000..bf6fcf5 --- /dev/null +++ b/SOURCES/kvm-acpi-build-fix-support-for-glib-2.22.patch @@ -0,0 +1,66 @@ +From 6fa0fc12221718bb405d01683acf635a24c34daf Mon Sep 17 00:00:00 2001 +Message-Id: <6fa0fc12221718bb405d01683acf635a24c34daf.1387298827.git.minovotn@redhat.com> +In-Reply-To: <3ed0fb61a3dc912ef036d7ef450bed192090709e.1387298827.git.minovotn@redhat.com> +References: <3ed0fb61a3dc912ef036d7ef450bed192090709e.1387298827.git.minovotn@redhat.com> +From: "Michael S. Tsirkin" +Date: Tue, 17 Dec 2013 15:19:24 +0100 +Subject: [PATCH 54/56] acpi-build: fix support for glib < 2.22 + +RH-Author: Michael S. Tsirkin +Message-id: <1387293161-4085-55-git-send-email-mst@redhat.com> +Patchwork-id: 56360 +O-Subject: [PATCH qemu-kvm RHEL7.0 v2 54/57] acpi-build: fix support for glib < 2.22 +Bugzilla: 1034876 +RH-Acked-by: Igor Mammedov +RH-Acked-by: Marcel Apfelbaum +RH-Acked-by: Laszlo Ersek + +glib < 2.22 does not have g_array_get_element_size, +limit it's use (to check all elements are 1 byte +in size) to newer glib. + +This fixes build on RHEL 5.3. + +Reported-by: Richard Henderson +Reported-by: Erik Rull +Tested-by: Richard Henderson +Signed-off-by: Michael S. Tsirkin +Message-id: 20131125220039.GA16386@redhat.com +Signed-off-by: Anthony Liguori +(cherry picked from commit 134d42d614768b2803e551621f6654dab1fdc2d2) +--- + hw/i386/acpi-build.c | 6 ++---- + 1 file changed, 2 insertions(+), 4 deletions(-) + +Signed-off-by: Michal Novotny +--- + hw/i386/acpi-build.c | 6 ++---- + 1 file changed, 2 insertions(+), 4 deletions(-) + +diff --git a/hw/i386/acpi-build.c b/hw/i386/acpi-build.c +index 4074350..316d6d3 100644 +--- a/hw/i386/acpi-build.c ++++ b/hw/i386/acpi-build.c +@@ -425,7 +425,7 @@ static inline void *acpi_data_push(GArray *table_data, unsigned size) + + static unsigned acpi_data_len(GArray *table) + { +-#if GLIB_CHECK_VERSION(2, 14, 0) ++#if GLIB_CHECK_VERSION(2, 22, 0) + assert(g_array_get_element_size(table) == 1); + #endif + return table->len; +@@ -436,9 +436,7 @@ static void acpi_align_size(GArray *blob, unsigned align) + /* Align size to multiple of given size. This reduces the chance + * we need to change size in the future (breaking cross version migration). + */ +- g_array_set_size(blob, (ROUND_UP(acpi_data_len(blob), align) + +- g_array_get_element_size(blob) - 1) / +- g_array_get_element_size(blob)); ++ g_array_set_size(blob, ROUND_UP(acpi_data_len(blob), align)); + } + + /* Get pointer within table in a safe manner */ +-- +1.7.11.7 + diff --git a/SOURCES/kvm-acpi-piix-add-macros-for-acpi-property-names.patch b/SOURCES/kvm-acpi-piix-add-macros-for-acpi-property-names.patch new file mode 100644 index 0000000..6e806a1 --- /dev/null +++ b/SOURCES/kvm-acpi-piix-add-macros-for-acpi-property-names.patch @@ -0,0 +1,78 @@ +From 4fef4ae9f3fb3f884d5eee74d3cc2272bff900f8 Mon Sep 17 00:00:00 2001 +Message-Id: <4fef4ae9f3fb3f884d5eee74d3cc2272bff900f8.1387298827.git.minovotn@redhat.com> +In-Reply-To: <3ed0fb61a3dc912ef036d7ef450bed192090709e.1387298827.git.minovotn@redhat.com> +References: <3ed0fb61a3dc912ef036d7ef450bed192090709e.1387298827.git.minovotn@redhat.com> +From: "Michael S. Tsirkin" +Date: Tue, 17 Dec 2013 15:18:47 +0100 +Subject: [PATCH 40/56] acpi/piix: add macros for acpi property names + +RH-Author: Michael S. Tsirkin +Message-id: <1387293161-4085-41-git-send-email-mst@redhat.com> +Patchwork-id: 56346 +O-Subject: [PATCH qemu-kvm RHEL7.0 v2 40/57] acpi/piix: add macros for acpi property names +Bugzilla: 1034876 +RH-Acked-by: Igor Mammedov +RH-Acked-by: Marcel Apfelbaum +RH-Acked-by: Laszlo Ersek + +Reviewed-by: Gerd Hoffmann +Tested-by: Gerd Hoffmann +Reviewed-by: Igor Mammedov +Tested-by: Igor Mammedov +Signed-off-by: Michael S. Tsirkin +(cherry picked from commit f854ecc79957e588bed8ed7e8c1c24ded55fc1e9) + +Conflicts: + hw/acpi/piix4.c +--- + include/hw/i386/pc.h | 10 ++++++++++ + hw/acpi/piix4.c | 6 +++--- + 2 files changed, 13 insertions(+), 3 deletions(-) + +Signed-off-by: Michal Novotny +--- + hw/acpi/piix4.c | 6 +++--- + include/hw/i386/pc.h | 10 ++++++++++ + 2 files changed, 13 insertions(+), 3 deletions(-) + +diff --git a/hw/acpi/piix4.c b/hw/acpi/piix4.c +index 6882937..18b1300 100644 +--- a/hw/acpi/piix4.c ++++ b/hw/acpi/piix4.c +@@ -475,9 +475,9 @@ i2c_bus *piix4_pm_init(PCIBus *bus, int devfn, uint32_t smb_io_base, + + static Property piix4_pm_properties[] = { + DEFINE_PROP_UINT32("smb_io_base", PIIX4PMState, smb_io_base, 0), +- DEFINE_PROP_UINT8("disable_s3", PIIX4PMState, disable_s3, 1), +- DEFINE_PROP_UINT8("disable_s4", PIIX4PMState, disable_s4, 1), +- DEFINE_PROP_UINT8("s4_val", PIIX4PMState, s4_val, 2), ++ DEFINE_PROP_UINT8(ACPI_PM_PROP_S3_DISABLED, PIIX4PMState, disable_s3, 1), ++ DEFINE_PROP_UINT8(ACPI_PM_PROP_S4_DISABLED, PIIX4PMState, disable_s4, 1), ++ DEFINE_PROP_UINT8(ACPI_PM_PROP_S4_VAL, PIIX4PMState, s4_val, 2), + DEFINE_PROP_END_OF_LIST(), + }; + +diff --git a/include/hw/i386/pc.h b/include/hw/i386/pc.h +index ec91fae..5011c87 100644 +--- a/include/hw/i386/pc.h ++++ b/include/hw/i386/pc.h +@@ -22,6 +22,16 @@ typedef struct PcPciInfo { + Range w64; + } PcPciInfo; + ++#define ACPI_PM_PROP_S3_DISABLED "disable_s3" ++#define ACPI_PM_PROP_S4_DISABLED "disable_s4" ++#define ACPI_PM_PROP_S4_VAL "s4_val" ++#define ACPI_PM_PROP_SCI_INT "sci_int" ++#define ACPI_PM_PROP_ACPI_ENABLE_CMD "acpi_enable_cmd" ++#define ACPI_PM_PROP_ACPI_DISABLE_CMD "acpi_disable_cmd" ++#define ACPI_PM_PROP_PM_IO_BASE "pm_io_base" ++#define ACPI_PM_PROP_GPE0_BLK "gpe0_blk" ++#define ACPI_PM_PROP_GPE0_BLK_LEN "gpe0_blk_len" ++ + struct PcGuestInfo { + bool has_pci_info; + hwaddr ram_size; +-- +1.7.11.7 + diff --git a/SOURCES/kvm-acpi-pre-compiled-ASL-files.patch b/SOURCES/kvm-acpi-pre-compiled-ASL-files.patch new file mode 100644 index 0000000..98848ac --- /dev/null +++ b/SOURCES/kvm-acpi-pre-compiled-ASL-files.patch @@ -0,0 +1,12469 @@ +From 474309ccd09c707c5a111dcbd56f95fb93354037 Mon Sep 17 00:00:00 2001 +Message-Id: <474309ccd09c707c5a111dcbd56f95fb93354037.1387298827.git.minovotn@redhat.com> +In-Reply-To: <3ed0fb61a3dc912ef036d7ef450bed192090709e.1387298827.git.minovotn@redhat.com> +References: <3ed0fb61a3dc912ef036d7ef450bed192090709e.1387298827.git.minovotn@redhat.com> +From: "Michael S. Tsirkin" +Date: Tue, 17 Dec 2013 15:18:17 +0100 +Subject: [PATCH 34/56] acpi: pre-compiled ASL files + +RH-Author: Michael S. Tsirkin +Message-id: <1387293161-4085-35-git-send-email-mst@redhat.com> +Patchwork-id: 56340 +O-Subject: [PATCH qemu-kvm RHEL7.0 v2 34/57] acpi: pre-compiled ASL files +Bugzilla: 1034876 +RH-Acked-by: Igor Mammedov +RH-Acked-by: Marcel Apfelbaum +RH-Acked-by: Laszlo Ersek + +Add pre-compiled ASL files. Useful for systems that +do not have IASL. + +Reviewed-by: Gerd Hoffmann +Tested-by: Gerd Hoffmann +Reviewed-by: Igor Mammedov +Tested-by: Igor Mammedov +Signed-off-by: Michael S. Tsirkin +(cherry picked from commit d512d0d723cc3a08ac0409e1ab13edfa1cc04c70) +--- + hw/i386/acpi-dsdt.hex.generated | 4409 +++++++++++++++++++++ + hw/i386/q35-acpi-dsdt.hex.generated | 7346 +++++++++++++++++++++++++++++++++++ + hw/i386/ssdt-misc.hex.generated | 386 ++ + hw/i386/ssdt-pcihp.hex.generated | 108 + + hw/i386/ssdt-proc.hex.generated | 134 + + 5 files changed, 12383 insertions(+) + create mode 100644 hw/i386/acpi-dsdt.hex.generated + create mode 100644 hw/i386/q35-acpi-dsdt.hex.generated + create mode 100644 hw/i386/ssdt-misc.hex.generated + create mode 100644 hw/i386/ssdt-pcihp.hex.generated + create mode 100644 hw/i386/ssdt-proc.hex.generated + +Signed-off-by: Michal Novotny +--- + hw/i386/acpi-dsdt.hex.generated | 4409 +++++++++++++++++++++ + hw/i386/q35-acpi-dsdt.hex.generated | 7346 +++++++++++++++++++++++++++++++++++ + hw/i386/ssdt-misc.hex.generated | 386 ++ + hw/i386/ssdt-pcihp.hex.generated | 108 + + hw/i386/ssdt-proc.hex.generated | 134 + + 5 files changed, 12383 insertions(+) + create mode 100644 hw/i386/acpi-dsdt.hex.generated + create mode 100644 hw/i386/q35-acpi-dsdt.hex.generated + create mode 100644 hw/i386/ssdt-misc.hex.generated + create mode 100644 hw/i386/ssdt-pcihp.hex.generated + create mode 100644 hw/i386/ssdt-proc.hex.generated + +diff --git a/hw/i386/acpi-dsdt.hex.generated b/hw/i386/acpi-dsdt.hex.generated +new file mode 100644 +index 0000000..2c01107 +--- /dev/null ++++ b/hw/i386/acpi-dsdt.hex.generated +@@ -0,0 +1,4409 @@ ++static unsigned char AcpiDsdtAmlCode[] = { ++0x44, ++0x53, ++0x44, ++0x54, ++0x37, ++0x11, ++0x0, ++0x0, ++0x1, ++0xe0, ++0x42, ++0x58, ++0x50, ++0x43, ++0x0, ++0x0, ++0x42, ++0x58, ++0x44, ++0x53, ++0x44, ++0x54, ++0x0, ++0x0, ++0x1, ++0x0, ++0x0, ++0x0, ++0x49, ++0x4e, ++0x54, ++0x4c, ++0x23, ++0x8, ++0x13, ++0x20, ++0x10, ++0x49, ++0x4, ++0x5c, ++0x0, ++0x5b, ++0x80, ++0x44, ++0x42, ++0x47, ++0x5f, ++0x1, ++0xb, ++0x2, ++0x4, ++0x1, ++0x5b, ++0x81, ++0xb, ++0x44, ++0x42, ++0x47, ++0x5f, ++0x1, ++0x44, ++0x42, ++0x47, ++0x42, ++0x8, ++0x14, ++0x2c, ++0x44, ++0x42, ++0x55, ++0x47, ++0x1, ++0x98, ++0x68, ++0x60, ++0x96, ++0x60, ++0x60, ++0x74, ++0x87, ++0x60, ++0x1, ++0x61, ++0x70, ++0x0, ++0x62, ++0xa2, ++0x10, ++0x95, ++0x62, ++0x61, ++0x70, ++0x83, ++0x88, ++0x60, ++0x62, ++0x0, ++0x44, ++0x42, ++0x47, ++0x42, ++0x75, ++0x62, ++0x70, ++0xa, ++0xa, ++0x44, ++0x42, ++0x47, ++0x42, ++0x10, ++0x22, ++0x5f, ++0x53, ++0x42, ++0x5f, ++0x5b, ++0x82, ++0x1b, ++0x50, ++0x43, ++0x49, ++0x30, ++0x8, ++0x5f, ++0x48, ++0x49, ++0x44, ++0xc, ++0x41, ++0xd0, ++0xa, ++0x3, ++0x8, ++0x5f, ++0x41, ++0x44, ++0x52, ++0x0, ++0x8, ++0x5f, ++0x55, ++0x49, ++0x44, ++0x1, ++0x10, ++0x4e, ++0x15, ++0x2e, ++0x5f, ++0x53, ++0x42, ++0x5f, ++0x50, ++0x43, ++0x49, ++0x30, ++0x8, ++0x43, ++0x52, ++0x45, ++0x53, ++0x11, ++0x42, ++0x7, ++0xa, ++0x6e, ++0x88, ++0xd, ++0x0, ++0x2, ++0xc, ++0x0, ++0x0, ++0x0, ++0x0, ++0x0, ++0xff, ++0x0, ++0x0, ++0x0, ++0x0, ++0x1, ++0x47, ++0x1, ++0xf8, ++0xc, ++0xf8, ++0xc, ++0x1, ++0x8, ++0x88, ++0xd, ++0x0, ++0x1, ++0xc, ++0x3, ++0x0, ++0x0, ++0x0, ++0x0, ++0xf7, ++0xc, ++0x0, ++0x0, ++0xf8, ++0xc, ++0x88, ++0xd, ++0x0, ++0x1, ++0xc, ++0x3, ++0x0, ++0x0, ++0x0, ++0xd, ++0xff, ++0xff, ++0x0, ++0x0, ++0x0, ++0xf3, ++0x87, ++0x17, ++0x0, ++0x0, ++0xc, ++0x3, ++0x0, ++0x0, ++0x0, ++0x0, ++0x0, ++0x0, ++0xa, ++0x0, ++0xff, ++0xff, ++0xb, ++0x0, ++0x0, ++0x0, ++0x0, ++0x0, ++0x0, ++0x0, ++0x2, ++0x0, ++0x87, ++0x17, ++0x0, ++0x0, ++0xc, ++0x1, ++0x0, ++0x0, ++0x0, ++0x0, ++0x0, ++0x0, ++0x0, ++0xe0, ++0xff, ++0xff, ++0xbf, ++0xfe, ++0x0, ++0x0, ++0x0, ++0x0, ++0x0, ++0x0, ++0xc0, ++0x1e, ++0x79, ++0x0, ++0x8, ++0x43, ++0x52, ++0x36, ++0x34, ++0x11, ++0x33, ++0xa, ++0x30, ++0x8a, ++0x2b, ++0x0, ++0x0, ++0xc, ++0x3, ++0x0, ++0x0, ++0x0, ++0x0, ++0x0, ++0x0, ++0x0, ++0x0, ++0x0, ++0x0, ++0x0, ++0x0, ++0x80, ++0x0, ++0x0, ++0x0, ++0xff, ++0xff, ++0xff, ++0xff, ++0xff, ++0x0, ++0x0, ++0x0, ++0x0, ++0x0, ++0x0, ++0x0, ++0x0, ++0x0, ++0x0, ++0x0, ++0x0, ++0x0, ++0x0, ++0x0, ++0x80, ++0x0, ++0x0, ++0x0, ++0x79, ++0x0, ++0x14, ++0x41, ++0xa, ++0x5f, ++0x43, ++0x52, ++0x53, ++0x0, ++0x8a, ++0x43, ++0x52, ++0x45, ++0x53, ++0xa, ++0x5c, ++0x50, ++0x53, ++0x33, ++0x32, ++0x8a, ++0x43, ++0x52, ++0x45, ++0x53, ++0xa, ++0x60, ++0x50, ++0x45, ++0x33, ++0x32, ++0x8a, ++0x43, ++0x52, ++0x45, ++0x53, ++0xa, ++0x68, ++0x50, ++0x4c, ++0x33, ++0x32, ++0x70, ++0x50, ++0x30, ++0x53, ++0x5f, ++0x50, ++0x53, ++0x33, ++0x32, ++0x70, ++0x50, ++0x30, ++0x45, ++0x5f, ++0x50, ++0x45, ++0x33, ++0x32, ++0x70, ++0x72, ++0x74, ++0x50, ++0x30, ++0x45, ++0x5f, ++0x50, ++0x30, ++0x53, ++0x5f, ++0x0, ++0x1, ++0x0, ++0x50, ++0x4c, ++0x33, ++0x32, ++0xa0, ++0xc, ++0x93, ++0x50, ++0x31, ++0x56, ++0x5f, ++0x0, ++0xa4, ++0x43, ++0x52, ++0x45, ++0x53, ++0x8f, ++0x43, ++0x52, ++0x36, ++0x34, ++0xa, ++0xe, ++0x50, ++0x53, ++0x36, ++0x34, ++0x8f, ++0x43, ++0x52, ++0x36, ++0x34, ++0xa, ++0x16, ++0x50, ++0x45, ++0x36, ++0x34, ++0x8f, ++0x43, ++0x52, ++0x36, ++0x34, ++0xa, ++0x26, ++0x50, ++0x4c, ++0x36, ++0x34, ++0x70, ++0x50, ++0x31, ++0x53, ++0x5f, ++0x50, ++0x53, ++0x36, ++0x34, ++0x70, ++0x50, ++0x31, ++0x45, ++0x5f, ++0x50, ++0x45, ++0x36, ++0x34, ++0x70, ++0x50, ++0x31, ++0x4c, ++0x5f, ++0x50, ++0x4c, ++0x36, ++0x34, ++0x84, ++0x43, ++0x52, ++0x45, ++0x53, ++0x43, ++0x52, ++0x36, ++0x34, ++0x60, ++0xa4, ++0x60, ++0x10, ++0x4d, ++0x8, ++0x5f, ++0x53, ++0x42, ++0x5f, ++0x5b, ++0x82, ++0x45, ++0x8, ++0x48, ++0x50, ++0x45, ++0x54, ++0x8, ++0x5f, ++0x48, ++0x49, ++0x44, ++0xc, ++0x41, ++0xd0, ++0x1, ++0x3, ++0x8, ++0x5f, ++0x55, ++0x49, ++0x44, ++0x0, ++0x5b, ++0x80, ++0x48, ++0x50, ++0x54, ++0x4d, ++0x0, ++0xc, ++0x0, ++0x0, ++0xd0, ++0xfe, ++0xb, ++0x0, ++0x4, ++0x5b, ++0x81, ++0x10, ++0x48, ++0x50, ++0x54, ++0x4d, ++0x13, ++0x56, ++0x45, ++0x4e, ++0x44, ++0x20, ++0x50, ++0x52, ++0x44, ++0x5f, ++0x20, ++0x14, ++0x36, ++0x5f, ++0x53, ++0x54, ++0x41, ++0x0, ++0x70, ++0x56, ++0x45, ++0x4e, ++0x44, ++0x60, ++0x70, ++0x50, ++0x52, ++0x44, ++0x5f, ++0x61, ++0x7a, ++0x60, ++0xa, ++0x10, ++0x60, ++0xa0, ++0xc, ++0x91, ++0x93, ++0x60, ++0x0, ++0x93, ++0x60, ++0xb, ++0xff, ++0xff, ++0xa4, ++0x0, ++0xa0, ++0xe, ++0x91, ++0x93, ++0x61, ++0x0, ++0x94, ++0x61, ++0xc, ++0x0, ++0xe1, ++0xf5, ++0x5, ++0xa4, ++0x0, ++0xa4, ++0xa, ++0xf, ++0x8, ++0x5f, ++0x43, ++0x52, ++0x53, ++0x11, ++0x11, ++0xa, ++0xe, ++0x86, ++0x9, ++0x0, ++0x0, ++0x0, ++0x0, ++0xd0, ++0xfe, ++0x0, ++0x4, ++0x0, ++0x0, ++0x79, ++0x0, ++0x10, ++0x40, ++0x6, ++0x2e, ++0x5f, ++0x53, ++0x42, ++0x5f, ++0x50, ++0x43, ++0x49, ++0x30, ++0x5b, ++0x82, ++0x43, ++0x5, ++0x56, ++0x47, ++0x41, ++0x5f, ++0x8, ++0x5f, ++0x41, ++0x44, ++0x52, ++0xc, ++0x0, ++0x0, ++0x2, ++0x0, ++0x5b, ++0x80, ++0x50, ++0x43, ++0x49, ++0x43, ++0x2, ++0x0, ++0xa, ++0x4, ++0x5b, ++0x81, ++0xb, ++0x50, ++0x43, ++0x49, ++0x43, ++0x3, ++0x56, ++0x45, ++0x4e, ++0x44, ++0x20, ++0x14, ++0x8, ++0x5f, ++0x53, ++0x31, ++0x44, ++0x0, ++0xa4, ++0x0, ++0x14, ++0x8, ++0x5f, ++0x53, ++0x32, ++0x44, ++0x0, ++0xa4, ++0x0, ++0x14, ++0x19, ++0x5f, ++0x53, ++0x33, ++0x44, ++0x0, ++0xa0, ++0xe, ++0x93, ++0x56, ++0x45, ++0x4e, ++0x44, ++0xc, ++0x36, ++0x1b, ++0x0, ++0x1, ++0xa4, ++0xa, ++0x3, ++0xa1, ++0x3, ++0xa4, ++0x0, ++0x10, ++0x25, ++0x2e, ++0x5f, ++0x53, ++0x42, ++0x5f, ++0x50, ++0x43, ++0x49, ++0x30, ++0x5b, ++0x82, ++0x19, ++0x50, ++0x58, ++0x31, ++0x33, ++0x8, ++0x5f, ++0x41, ++0x44, ++0x52, ++0xc, ++0x3, ++0x0, ++0x1, ++0x0, ++0x5b, ++0x80, ++0x50, ++0x31, ++0x33, ++0x43, ++0x2, ++0x0, ++0xa, ++0xff, ++0x10, ++0x46, ++0x5, ++0x2e, ++0x5f, ++0x53, ++0x42, ++0x5f, ++0x50, ++0x43, ++0x49, ++0x30, ++0x5b, ++0x82, ++0x49, ++0x4, ++0x49, ++0x53, ++0x41, ++0x5f, ++0x8, ++0x5f, ++0x41, ++0x44, ++0x52, ++0xc, ++0x0, ++0x0, ++0x1, ++0x0, ++0x5b, ++0x80, ++0x50, ++0x34, ++0x30, ++0x43, ++0x2, ++0xa, ++0x60, ++0xa, ++0x4, ++0x5b, ++0x81, ++0x26, ++0x5e, ++0x2e, ++0x50, ++0x58, ++0x31, ++0x33, ++0x50, ++0x31, ++0x33, ++0x43, ++0x0, ++0x0, ++0x48, ++0x2f, ++0x0, ++0x7, ++0x4c, ++0x50, ++0x45, ++0x4e, ++0x1, ++0x0, ++0x38, ++0x0, ++0x3, ++0x43, ++0x41, ++0x45, ++0x4e, ++0x1, ++0x0, ++0x3, ++0x43, ++0x42, ++0x45, ++0x4e, ++0x1, ++0x8, ++0x46, ++0x44, ++0x45, ++0x4e, ++0x1, ++0x10, ++0x4c, ++0x1b, ++0x2f, ++0x3, ++0x5f, ++0x53, ++0x42, ++0x5f, ++0x50, ++0x43, ++0x49, ++0x30, ++0x49, ++0x53, ++0x41, ++0x5f, ++0x5b, ++0x82, ++0x2d, ++0x52, ++0x54, ++0x43, ++0x5f, ++0x8, ++0x5f, ++0x48, ++0x49, ++0x44, ++0xc, ++0x41, ++0xd0, ++0xb, ++0x0, ++0x8, ++0x5f, ++0x43, ++0x52, ++0x53, ++0x11, ++0x18, ++0xa, ++0x15, ++0x47, ++0x1, ++0x70, ++0x0, ++0x70, ++0x0, ++0x10, ++0x2, ++0x22, ++0x0, ++0x1, ++0x47, ++0x1, ++0x72, ++0x0, ++0x72, ++0x0, ++0x2, ++0x6, ++0x79, ++0x0, ++0x5b, ++0x82, ++0x37, ++0x4b, ++0x42, ++0x44, ++0x5f, ++0x8, ++0x5f, ++0x48, ++0x49, ++0x44, ++0xc, ++0x41, ++0xd0, ++0x3, ++0x3, ++0x14, ++0x9, ++0x5f, ++0x53, ++0x54, ++0x41, ++0x0, ++0xa4, ++0xa, ++0xf, ++0x8, ++0x5f, ++0x43, ++0x52, ++0x53, ++0x11, ++0x18, ++0xa, ++0x15, ++0x47, ++0x1, ++0x60, ++0x0, ++0x60, ++0x0, ++0x1, ++0x1, ++0x47, ++0x1, ++0x64, ++0x0, ++0x64, ++0x0, ++0x1, ++0x1, ++0x22, ++0x2, ++0x0, ++0x79, ++0x0, ++0x5b, ++0x82, ++0x27, ++0x4d, ++0x4f, ++0x55, ++0x5f, ++0x8, ++0x5f, ++0x48, ++0x49, ++0x44, ++0xc, ++0x41, ++0xd0, ++0xf, ++0x13, ++0x14, ++0x9, ++0x5f, ++0x53, ++0x54, ++0x41, ++0x0, ++0xa4, ++0xa, ++0xf, ++0x8, ++0x5f, ++0x43, ++0x52, ++0x53, ++0x11, ++0x8, ++0xa, ++0x5, ++0x22, ++0x0, ++0x10, ++0x79, ++0x0, ++0x5b, ++0x82, ++0x4a, ++0x4, ++0x46, ++0x44, ++0x43, ++0x30, ++0x8, ++0x5f, ++0x48, ++0x49, ++0x44, ++0xc, ++0x41, ++0xd0, ++0x7, ++0x0, ++0x14, ++0x18, ++0x5f, ++0x53, ++0x54, ++0x41, ++0x0, ++0x70, ++0x46, ++0x44, ++0x45, ++0x4e, ++0x60, ++0xa0, ++0x6, ++0x93, ++0x60, ++0x0, ++0xa4, ++0x0, ++0xa1, ++0x4, ++0xa4, ++0xa, ++0xf, ++0x8, ++0x5f, ++0x43, ++0x52, ++0x53, ++0x11, ++0x1b, ++0xa, ++0x18, ++0x47, ++0x1, ++0xf2, ++0x3, ++0xf2, ++0x3, ++0x0, ++0x4, ++0x47, ++0x1, ++0xf7, ++0x3, ++0xf7, ++0x3, ++0x0, ++0x1, ++0x22, ++0x40, ++0x0, ++0x2a, ++0x4, ++0x0, ++0x79, ++0x0, ++0x5b, ++0x82, ++0x3e, ++0x4c, ++0x50, ++0x54, ++0x5f, ++0x8, ++0x5f, ++0x48, ++0x49, ++0x44, ++0xc, ++0x41, ++0xd0, ++0x4, ++0x0, ++0x14, ++0x18, ++0x5f, ++0x53, ++0x54, ++0x41, ++0x0, ++0x70, ++0x4c, ++0x50, ++0x45, ++0x4e, ++0x60, ++0xa0, ++0x6, ++0x93, ++0x60, ++0x0, ++0xa4, ++0x0, ++0xa1, ++0x4, ++0xa4, ++0xa, ++0xf, ++0x8, ++0x5f, ++0x43, ++0x52, ++0x53, ++0x11, ++0x10, ++0xa, ++0xd, ++0x47, ++0x1, ++0x78, ++0x3, ++0x78, ++0x3, ++0x8, ++0x8, ++0x22, ++0x80, ++0x0, ++0x79, ++0x0, ++0x5b, ++0x82, ++0x45, ++0x4, ++0x43, ++0x4f, ++0x4d, ++0x31, ++0x8, ++0x5f, ++0x48, ++0x49, ++0x44, ++0xc, ++0x41, ++0xd0, ++0x5, ++0x1, ++0x8, ++0x5f, ++0x55, ++0x49, ++0x44, ++0x1, ++0x14, ++0x18, ++0x5f, ++0x53, ++0x54, ++0x41, ++0x0, ++0x70, ++0x43, ++0x41, ++0x45, ++0x4e, ++0x60, ++0xa0, ++0x6, ++0x93, ++0x60, ++0x0, ++0xa4, ++0x0, ++0xa1, ++0x4, ++0xa4, ++0xa, ++0xf, ++0x8, ++0x5f, ++0x43, ++0x52, ++0x53, ++0x11, ++0x10, ++0xa, ++0xd, ++0x47, ++0x1, ++0xf8, ++0x3, ++0xf8, ++0x3, ++0x0, ++0x8, ++0x22, ++0x10, ++0x0, ++0x79, ++0x0, ++0x5b, ++0x82, ++0x46, ++0x4, ++0x43, ++0x4f, ++0x4d, ++0x32, ++0x8, ++0x5f, ++0x48, ++0x49, ++0x44, ++0xc, ++0x41, ++0xd0, ++0x5, ++0x1, ++0x8, ++0x5f, ++0x55, ++0x49, ++0x44, ++0xa, ++0x2, ++0x14, ++0x18, ++0x5f, ++0x53, ++0x54, ++0x41, ++0x0, ++0x70, ++0x43, ++0x42, ++0x45, ++0x4e, ++0x60, ++0xa0, ++0x6, ++0x93, ++0x60, ++0x0, ++0xa4, ++0x0, ++0xa1, ++0x4, ++0xa4, ++0xa, ++0xf, ++0x8, ++0x5f, ++0x43, ++0x52, ++0x53, ++0x11, ++0x10, ++0xa, ++0xd, ++0x47, ++0x1, ++0xf8, ++0x2, ++0xf8, ++0x2, ++0x0, ++0x8, ++0x22, ++0x8, ++0x0, ++0x79, ++0x0, ++0x10, ++0x4b, ++0x8, ++0x2e, ++0x5f, ++0x53, ++0x42, ++0x5f, ++0x50, ++0x43, ++0x49, ++0x30, ++0x5b, ++0x80, ++0x50, ++0x43, ++0x53, ++0x54, ++0x1, ++0xb, ++0x0, ++0xae, ++0xa, ++0x8, ++0x5b, ++0x81, ++0x10, ++0x50, ++0x43, ++0x53, ++0x54, ++0x43, ++0x50, ++0x43, ++0x49, ++0x55, ++0x20, ++0x50, ++0x43, ++0x49, ++0x44, ++0x20, ++0x5b, ++0x80, ++0x53, ++0x45, ++0x4a, ++0x5f, ++0x1, ++0xb, ++0x8, ++0xae, ++0xa, ++0x4, ++0x5b, ++0x81, ++0xb, ++0x53, ++0x45, ++0x4a, ++0x5f, ++0x43, ++0x42, ++0x30, ++0x45, ++0x4a, ++0x20, ++0x14, ++0x11, ++0x50, ++0x43, ++0x45, ++0x4a, ++0x1, ++0x70, ++0x79, ++0x1, ++0x68, ++0x0, ++0x42, ++0x30, ++0x45, ++0x4a, ++0xa4, ++0x0, ++0x14, ++0x36, ++0x50, ++0x43, ++0x4e, ++0x46, ++0x0, ++0x70, ++0x0, ++0x60, ++0xa2, ++0x2c, ++0x95, ++0x60, ++0xa, ++0x1f, ++0x75, ++0x60, ++0xa0, ++0x11, ++0x7b, ++0x50, ++0x43, ++0x49, ++0x55, ++0x79, ++0x1, ++0x60, ++0x0, ++0x0, ++0x50, ++0x43, ++0x4e, ++0x54, ++0x60, ++0x1, ++0xa0, ++0x12, ++0x7b, ++0x50, ++0x43, ++0x49, ++0x44, ++0x79, ++0x1, ++0x60, ++0x0, ++0x0, ++0x50, ++0x43, ++0x4e, ++0x54, ++0x60, ++0xa, ++0x3, ++0x10, ++0x4a, ++0xa0, ++0x5f, ++0x53, ++0x42, ++0x5f, ++0x10, ++0x47, ++0x74, ++0x50, ++0x43, ++0x49, ++0x30, ++0x8, ++0x5f, ++0x50, ++0x52, ++0x54, ++0x12, ++0x4b, ++0x73, ++0x80, ++0x12, ++0xb, ++0x4, ++0xb, ++0xff, ++0xff, ++0x0, ++0x4c, ++0x4e, ++0x4b, ++0x44, ++0x0, ++0x12, ++0xb, ++0x4, ++0xb, ++0xff, ++0xff, ++0x1, ++0x4c, ++0x4e, ++0x4b, ++0x41, ++0x0, ++0x12, ++0xc, ++0x4, ++0xb, ++0xff, ++0xff, ++0xa, ++0x2, ++0x4c, ++0x4e, ++0x4b, ++0x42, ++0x0, ++0x12, ++0xc, ++0x4, ++0xb, ++0xff, ++0xff, ++0xa, ++0x3, ++0x4c, ++0x4e, ++0x4b, ++0x43, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x1, ++0x0, ++0x0, ++0x4c, ++0x4e, ++0x4b, ++0x53, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x1, ++0x0, ++0x1, ++0x4c, ++0x4e, ++0x4b, ++0x42, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x1, ++0x0, ++0xa, ++0x2, ++0x4c, ++0x4e, ++0x4b, ++0x43, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x1, ++0x0, ++0xa, ++0x3, ++0x4c, ++0x4e, ++0x4b, ++0x44, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x2, ++0x0, ++0x0, ++0x4c, ++0x4e, ++0x4b, ++0x42, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x2, ++0x0, ++0x1, ++0x4c, ++0x4e, ++0x4b, ++0x43, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x2, ++0x0, ++0xa, ++0x2, ++0x4c, ++0x4e, ++0x4b, ++0x44, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x2, ++0x0, ++0xa, ++0x3, ++0x4c, ++0x4e, ++0x4b, ++0x41, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x3, ++0x0, ++0x0, ++0x4c, ++0x4e, ++0x4b, ++0x43, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x3, ++0x0, ++0x1, ++0x4c, ++0x4e, ++0x4b, ++0x44, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x3, ++0x0, ++0xa, ++0x2, ++0x4c, ++0x4e, ++0x4b, ++0x41, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x3, ++0x0, ++0xa, ++0x3, ++0x4c, ++0x4e, ++0x4b, ++0x42, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x4, ++0x0, ++0x0, ++0x4c, ++0x4e, ++0x4b, ++0x44, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x4, ++0x0, ++0x1, ++0x4c, ++0x4e, ++0x4b, ++0x41, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x4, ++0x0, ++0xa, ++0x2, ++0x4c, ++0x4e, ++0x4b, ++0x42, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x4, ++0x0, ++0xa, ++0x3, ++0x4c, ++0x4e, ++0x4b, ++0x43, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x5, ++0x0, ++0x0, ++0x4c, ++0x4e, ++0x4b, ++0x41, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x5, ++0x0, ++0x1, ++0x4c, ++0x4e, ++0x4b, ++0x42, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x5, ++0x0, ++0xa, ++0x2, ++0x4c, ++0x4e, ++0x4b, ++0x43, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x5, ++0x0, ++0xa, ++0x3, ++0x4c, ++0x4e, ++0x4b, ++0x44, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x6, ++0x0, ++0x0, ++0x4c, ++0x4e, ++0x4b, ++0x42, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x6, ++0x0, ++0x1, ++0x4c, ++0x4e, ++0x4b, ++0x43, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x6, ++0x0, ++0xa, ++0x2, ++0x4c, ++0x4e, ++0x4b, ++0x44, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x6, ++0x0, ++0xa, ++0x3, ++0x4c, ++0x4e, ++0x4b, ++0x41, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x7, ++0x0, ++0x0, ++0x4c, ++0x4e, ++0x4b, ++0x43, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x7, ++0x0, ++0x1, ++0x4c, ++0x4e, ++0x4b, ++0x44, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x7, ++0x0, ++0xa, ++0x2, ++0x4c, ++0x4e, ++0x4b, ++0x41, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x7, ++0x0, ++0xa, ++0x3, ++0x4c, ++0x4e, ++0x4b, ++0x42, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x8, ++0x0, ++0x0, ++0x4c, ++0x4e, ++0x4b, ++0x44, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x8, ++0x0, ++0x1, ++0x4c, ++0x4e, ++0x4b, ++0x41, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x8, ++0x0, ++0xa, ++0x2, ++0x4c, ++0x4e, ++0x4b, ++0x42, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x8, ++0x0, ++0xa, ++0x3, ++0x4c, ++0x4e, ++0x4b, ++0x43, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x9, ++0x0, ++0x0, ++0x4c, ++0x4e, ++0x4b, ++0x41, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x9, ++0x0, ++0x1, ++0x4c, ++0x4e, ++0x4b, ++0x42, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x9, ++0x0, ++0xa, ++0x2, ++0x4c, ++0x4e, ++0x4b, ++0x43, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x9, ++0x0, ++0xa, ++0x3, ++0x4c, ++0x4e, ++0x4b, ++0x44, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0xa, ++0x0, ++0x0, ++0x4c, ++0x4e, ++0x4b, ++0x42, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0xa, ++0x0, ++0x1, ++0x4c, ++0x4e, ++0x4b, ++0x43, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0xa, ++0x0, ++0xa, ++0x2, ++0x4c, ++0x4e, ++0x4b, ++0x44, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0xa, ++0x0, ++0xa, ++0x3, ++0x4c, ++0x4e, ++0x4b, ++0x41, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0xb, ++0x0, ++0x0, ++0x4c, ++0x4e, ++0x4b, ++0x43, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0xb, ++0x0, ++0x1, ++0x4c, ++0x4e, ++0x4b, ++0x44, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0xb, ++0x0, ++0xa, ++0x2, ++0x4c, ++0x4e, ++0x4b, ++0x41, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0xb, ++0x0, ++0xa, ++0x3, ++0x4c, ++0x4e, ++0x4b, ++0x42, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0xc, ++0x0, ++0x0, ++0x4c, ++0x4e, ++0x4b, ++0x44, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0xc, ++0x0, ++0x1, ++0x4c, ++0x4e, ++0x4b, ++0x41, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0xc, ++0x0, ++0xa, ++0x2, ++0x4c, ++0x4e, ++0x4b, ++0x42, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0xc, ++0x0, ++0xa, ++0x3, ++0x4c, ++0x4e, ++0x4b, ++0x43, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0xd, ++0x0, ++0x0, ++0x4c, ++0x4e, ++0x4b, ++0x41, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0xd, ++0x0, ++0x1, ++0x4c, ++0x4e, ++0x4b, ++0x42, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0xd, ++0x0, ++0xa, ++0x2, ++0x4c, ++0x4e, ++0x4b, ++0x43, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0xd, ++0x0, ++0xa, ++0x3, ++0x4c, ++0x4e, ++0x4b, ++0x44, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0xe, ++0x0, ++0x0, ++0x4c, ++0x4e, ++0x4b, ++0x42, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0xe, ++0x0, ++0x1, ++0x4c, ++0x4e, ++0x4b, ++0x43, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0xe, ++0x0, ++0xa, ++0x2, ++0x4c, ++0x4e, ++0x4b, ++0x44, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0xe, ++0x0, ++0xa, ++0x3, ++0x4c, ++0x4e, ++0x4b, ++0x41, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0xf, ++0x0, ++0x0, ++0x4c, ++0x4e, ++0x4b, ++0x43, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0xf, ++0x0, ++0x1, ++0x4c, ++0x4e, ++0x4b, ++0x44, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0xf, ++0x0, ++0xa, ++0x2, ++0x4c, ++0x4e, ++0x4b, ++0x41, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0xf, ++0x0, ++0xa, ++0x3, ++0x4c, ++0x4e, ++0x4b, ++0x42, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x10, ++0x0, ++0x0, ++0x4c, ++0x4e, ++0x4b, ++0x44, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x10, ++0x0, ++0x1, ++0x4c, ++0x4e, ++0x4b, ++0x41, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x10, ++0x0, ++0xa, ++0x2, ++0x4c, ++0x4e, ++0x4b, ++0x42, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x10, ++0x0, ++0xa, ++0x3, ++0x4c, ++0x4e, ++0x4b, ++0x43, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x11, ++0x0, ++0x0, ++0x4c, ++0x4e, ++0x4b, ++0x41, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x11, ++0x0, ++0x1, ++0x4c, ++0x4e, ++0x4b, ++0x42, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x11, ++0x0, ++0xa, ++0x2, ++0x4c, ++0x4e, ++0x4b, ++0x43, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x11, ++0x0, ++0xa, ++0x3, ++0x4c, ++0x4e, ++0x4b, ++0x44, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x12, ++0x0, ++0x0, ++0x4c, ++0x4e, ++0x4b, ++0x42, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x12, ++0x0, ++0x1, ++0x4c, ++0x4e, ++0x4b, ++0x43, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x12, ++0x0, ++0xa, ++0x2, ++0x4c, ++0x4e, ++0x4b, ++0x44, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x12, ++0x0, ++0xa, ++0x3, ++0x4c, ++0x4e, ++0x4b, ++0x41, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x13, ++0x0, ++0x0, ++0x4c, ++0x4e, ++0x4b, ++0x43, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x13, ++0x0, ++0x1, ++0x4c, ++0x4e, ++0x4b, ++0x44, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x13, ++0x0, ++0xa, ++0x2, ++0x4c, ++0x4e, ++0x4b, ++0x41, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x13, ++0x0, ++0xa, ++0x3, ++0x4c, ++0x4e, ++0x4b, ++0x42, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x14, ++0x0, ++0x0, ++0x4c, ++0x4e, ++0x4b, ++0x44, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x14, ++0x0, ++0x1, ++0x4c, ++0x4e, ++0x4b, ++0x41, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x14, ++0x0, ++0xa, ++0x2, ++0x4c, ++0x4e, ++0x4b, ++0x42, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x14, ++0x0, ++0xa, ++0x3, ++0x4c, ++0x4e, ++0x4b, ++0x43, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x15, ++0x0, ++0x0, ++0x4c, ++0x4e, ++0x4b, ++0x41, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x15, ++0x0, ++0x1, ++0x4c, ++0x4e, ++0x4b, ++0x42, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x15, ++0x0, ++0xa, ++0x2, ++0x4c, ++0x4e, ++0x4b, ++0x43, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x15, ++0x0, ++0xa, ++0x3, ++0x4c, ++0x4e, ++0x4b, ++0x44, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x16, ++0x0, ++0x0, ++0x4c, ++0x4e, ++0x4b, ++0x42, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x16, ++0x0, ++0x1, ++0x4c, ++0x4e, ++0x4b, ++0x43, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x16, ++0x0, ++0xa, ++0x2, ++0x4c, ++0x4e, ++0x4b, ++0x44, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x16, ++0x0, ++0xa, ++0x3, ++0x4c, ++0x4e, ++0x4b, ++0x41, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x17, ++0x0, ++0x0, ++0x4c, ++0x4e, ++0x4b, ++0x43, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x17, ++0x0, ++0x1, ++0x4c, ++0x4e, ++0x4b, ++0x44, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x17, ++0x0, ++0xa, ++0x2, ++0x4c, ++0x4e, ++0x4b, ++0x41, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x17, ++0x0, ++0xa, ++0x3, ++0x4c, ++0x4e, ++0x4b, ++0x42, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x18, ++0x0, ++0x0, ++0x4c, ++0x4e, ++0x4b, ++0x44, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x18, ++0x0, ++0x1, ++0x4c, ++0x4e, ++0x4b, ++0x41, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x18, ++0x0, ++0xa, ++0x2, ++0x4c, ++0x4e, ++0x4b, ++0x42, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x18, ++0x0, ++0xa, ++0x3, ++0x4c, ++0x4e, ++0x4b, ++0x43, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x19, ++0x0, ++0x0, ++0x4c, ++0x4e, ++0x4b, ++0x41, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x19, ++0x0, ++0x1, ++0x4c, ++0x4e, ++0x4b, ++0x42, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x19, ++0x0, ++0xa, ++0x2, ++0x4c, ++0x4e, ++0x4b, ++0x43, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x19, ++0x0, ++0xa, ++0x3, ++0x4c, ++0x4e, ++0x4b, ++0x44, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x1a, ++0x0, ++0x0, ++0x4c, ++0x4e, ++0x4b, ++0x42, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x1a, ++0x0, ++0x1, ++0x4c, ++0x4e, ++0x4b, ++0x43, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x1a, ++0x0, ++0xa, ++0x2, ++0x4c, ++0x4e, ++0x4b, ++0x44, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x1a, ++0x0, ++0xa, ++0x3, ++0x4c, ++0x4e, ++0x4b, ++0x41, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x1b, ++0x0, ++0x0, ++0x4c, ++0x4e, ++0x4b, ++0x43, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x1b, ++0x0, ++0x1, ++0x4c, ++0x4e, ++0x4b, ++0x44, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x1b, ++0x0, ++0xa, ++0x2, ++0x4c, ++0x4e, ++0x4b, ++0x41, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x1b, ++0x0, ++0xa, ++0x3, ++0x4c, ++0x4e, ++0x4b, ++0x42, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x1c, ++0x0, ++0x0, ++0x4c, ++0x4e, ++0x4b, ++0x44, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x1c, ++0x0, ++0x1, ++0x4c, ++0x4e, ++0x4b, ++0x41, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x1c, ++0x0, ++0xa, ++0x2, ++0x4c, ++0x4e, ++0x4b, ++0x42, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x1c, ++0x0, ++0xa, ++0x3, ++0x4c, ++0x4e, ++0x4b, ++0x43, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x1d, ++0x0, ++0x0, ++0x4c, ++0x4e, ++0x4b, ++0x41, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x1d, ++0x0, ++0x1, ++0x4c, ++0x4e, ++0x4b, ++0x42, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x1d, ++0x0, ++0xa, ++0x2, ++0x4c, ++0x4e, ++0x4b, ++0x43, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x1d, ++0x0, ++0xa, ++0x3, ++0x4c, ++0x4e, ++0x4b, ++0x44, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x1e, ++0x0, ++0x0, ++0x4c, ++0x4e, ++0x4b, ++0x42, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x1e, ++0x0, ++0x1, ++0x4c, ++0x4e, ++0x4b, ++0x43, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x1e, ++0x0, ++0xa, ++0x2, ++0x4c, ++0x4e, ++0x4b, ++0x44, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x1e, ++0x0, ++0xa, ++0x3, ++0x4c, ++0x4e, ++0x4b, ++0x41, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x1f, ++0x0, ++0x0, ++0x4c, ++0x4e, ++0x4b, ++0x43, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x1f, ++0x0, ++0x1, ++0x4c, ++0x4e, ++0x4b, ++0x44, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x1f, ++0x0, ++0xa, ++0x2, ++0x4c, ++0x4e, ++0x4b, ++0x41, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x1f, ++0x0, ++0xa, ++0x3, ++0x4c, ++0x4e, ++0x4b, ++0x42, ++0x0, ++0x5b, ++0x81, ++0x24, ++0x2f, ++0x3, ++0x50, ++0x43, ++0x49, ++0x30, ++0x49, ++0x53, ++0x41, ++0x5f, ++0x50, ++0x34, ++0x30, ++0x43, ++0x1, ++0x50, ++0x52, ++0x51, ++0x30, ++0x8, ++0x50, ++0x52, ++0x51, ++0x31, ++0x8, ++0x50, ++0x52, ++0x51, ++0x32, ++0x8, ++0x50, ++0x52, ++0x51, ++0x33, ++0x8, ++0x14, ++0x13, ++0x49, ++0x51, ++0x53, ++0x54, ++0x1, ++0xa0, ++0x9, ++0x7b, ++0xa, ++0x80, ++0x68, ++0x0, ++0xa4, ++0xa, ++0x9, ++0xa4, ++0xa, ++0xb, ++0x14, ++0x36, ++0x49, ++0x51, ++0x43, ++0x52, ++0x1, ++0x8, ++0x50, ++0x52, ++0x52, ++0x30, ++0x11, ++0xe, ++0xa, ++0xb, ++0x89, ++0x6, ++0x0, ++0x9, ++0x1, ++0x0, ++0x0, ++0x0, ++0x0, ++0x79, ++0x0, ++0x8a, ++0x50, ++0x52, ++0x52, ++0x30, ++0xa, ++0x5, ++0x50, ++0x52, ++0x52, ++0x49, ++0xa0, ++0xb, ++0x95, ++0x68, ++0xa, ++0x80, ++0x70, ++0x68, ++0x50, ++0x52, ++0x52, ++0x49, ++0xa4, ++0x50, ++0x52, ++0x52, ++0x30, ++0x5b, ++0x82, ++0x4c, ++0x7, ++0x4c, ++0x4e, ++0x4b, ++0x41, ++0x8, ++0x5f, ++0x48, ++0x49, ++0x44, ++0xc, ++0x41, ++0xd0, ++0xc, ++0xf, ++0x8, ++0x5f, ++0x55, ++0x49, ++0x44, ++0x0, ++0x8, ++0x5f, ++0x50, ++0x52, ++0x53, ++0x11, ++0x16, ++0xa, ++0x13, ++0x89, ++0xe, ++0x0, ++0x9, ++0x3, ++0x5, ++0x0, ++0x0, ++0x0, ++0xa, ++0x0, ++0x0, ++0x0, ++0xb, ++0x0, ++0x0, ++0x0, ++0x79, ++0x0, ++0x14, ++0xf, ++0x5f, ++0x53, ++0x54, ++0x41, ++0x0, ++0xa4, ++0x49, ++0x51, ++0x53, ++0x54, ++0x50, ++0x52, ++0x51, ++0x30, ++0x14, ++0x11, ++0x5f, ++0x44, ++0x49, ++0x53, ++0x0, ++0x7d, ++0x50, ++0x52, ++0x51, ++0x30, ++0xa, ++0x80, ++0x50, ++0x52, ++0x51, ++0x30, ++0x14, ++0xf, ++0x5f, ++0x43, ++0x52, ++0x53, ++0x0, ++0xa4, ++0x49, ++0x51, ++0x43, ++0x52, ++0x50, ++0x52, ++0x51, ++0x30, ++0x14, ++0x17, ++0x5f, ++0x53, ++0x52, ++0x53, ++0x1, ++0x8a, ++0x68, ++0xa, ++0x5, ++0x50, ++0x52, ++0x52, ++0x49, ++0x70, ++0x50, ++0x52, ++0x52, ++0x49, ++0x50, ++0x52, ++0x51, ++0x30, ++0x5b, ++0x82, ++0x4c, ++0x7, ++0x4c, ++0x4e, ++0x4b, ++0x42, ++0x8, ++0x5f, ++0x48, ++0x49, ++0x44, ++0xc, ++0x41, ++0xd0, ++0xc, ++0xf, ++0x8, ++0x5f, ++0x55, ++0x49, ++0x44, ++0x1, ++0x8, ++0x5f, ++0x50, ++0x52, ++0x53, ++0x11, ++0x16, ++0xa, ++0x13, ++0x89, ++0xe, ++0x0, ++0x9, ++0x3, ++0x5, ++0x0, ++0x0, ++0x0, ++0xa, ++0x0, ++0x0, ++0x0, ++0xb, ++0x0, ++0x0, ++0x0, ++0x79, ++0x0, ++0x14, ++0xf, ++0x5f, ++0x53, ++0x54, ++0x41, ++0x0, ++0xa4, ++0x49, ++0x51, ++0x53, ++0x54, ++0x50, ++0x52, ++0x51, ++0x31, ++0x14, ++0x11, ++0x5f, ++0x44, ++0x49, ++0x53, ++0x0, ++0x7d, ++0x50, ++0x52, ++0x51, ++0x31, ++0xa, ++0x80, ++0x50, ++0x52, ++0x51, ++0x31, ++0x14, ++0xf, ++0x5f, ++0x43, ++0x52, ++0x53, ++0x0, ++0xa4, ++0x49, ++0x51, ++0x43, ++0x52, ++0x50, ++0x52, ++0x51, ++0x31, ++0x14, ++0x17, ++0x5f, ++0x53, ++0x52, ++0x53, ++0x1, ++0x8a, ++0x68, ++0xa, ++0x5, ++0x50, ++0x52, ++0x52, ++0x49, ++0x70, ++0x50, ++0x52, ++0x52, ++0x49, ++0x50, ++0x52, ++0x51, ++0x31, ++0x5b, ++0x82, ++0x4d, ++0x7, ++0x4c, ++0x4e, ++0x4b, ++0x43, ++0x8, ++0x5f, ++0x48, ++0x49, ++0x44, ++0xc, ++0x41, ++0xd0, ++0xc, ++0xf, ++0x8, ++0x5f, ++0x55, ++0x49, ++0x44, ++0xa, ++0x2, ++0x8, ++0x5f, ++0x50, ++0x52, ++0x53, ++0x11, ++0x16, ++0xa, ++0x13, ++0x89, ++0xe, ++0x0, ++0x9, ++0x3, ++0x5, ++0x0, ++0x0, ++0x0, ++0xa, ++0x0, ++0x0, ++0x0, ++0xb, ++0x0, ++0x0, ++0x0, ++0x79, ++0x0, ++0x14, ++0xf, ++0x5f, ++0x53, ++0x54, ++0x41, ++0x0, ++0xa4, ++0x49, ++0x51, ++0x53, ++0x54, ++0x50, ++0x52, ++0x51, ++0x32, ++0x14, ++0x11, ++0x5f, ++0x44, ++0x49, ++0x53, ++0x0, ++0x7d, ++0x50, ++0x52, ++0x51, ++0x32, ++0xa, ++0x80, ++0x50, ++0x52, ++0x51, ++0x32, ++0x14, ++0xf, ++0x5f, ++0x43, ++0x52, ++0x53, ++0x0, ++0xa4, ++0x49, ++0x51, ++0x43, ++0x52, ++0x50, ++0x52, ++0x51, ++0x32, ++0x14, ++0x17, ++0x5f, ++0x53, ++0x52, ++0x53, ++0x1, ++0x8a, ++0x68, ++0xa, ++0x5, ++0x50, ++0x52, ++0x52, ++0x49, ++0x70, ++0x50, ++0x52, ++0x52, ++0x49, ++0x50, ++0x52, ++0x51, ++0x32, ++0x5b, ++0x82, ++0x4d, ++0x7, ++0x4c, ++0x4e, ++0x4b, ++0x44, ++0x8, ++0x5f, ++0x48, ++0x49, ++0x44, ++0xc, ++0x41, ++0xd0, ++0xc, ++0xf, ++0x8, ++0x5f, ++0x55, ++0x49, ++0x44, ++0xa, ++0x3, ++0x8, ++0x5f, ++0x50, ++0x52, ++0x53, ++0x11, ++0x16, ++0xa, ++0x13, ++0x89, ++0xe, ++0x0, ++0x9, ++0x3, ++0x5, ++0x0, ++0x0, ++0x0, ++0xa, ++0x0, ++0x0, ++0x0, ++0xb, ++0x0, ++0x0, ++0x0, ++0x79, ++0x0, ++0x14, ++0xf, ++0x5f, ++0x53, ++0x54, ++0x41, ++0x0, ++0xa4, ++0x49, ++0x51, ++0x53, ++0x54, ++0x50, ++0x52, ++0x51, ++0x33, ++0x14, ++0x11, ++0x5f, ++0x44, ++0x49, ++0x53, ++0x0, ++0x7d, ++0x50, ++0x52, ++0x51, ++0x33, ++0xa, ++0x80, ++0x50, ++0x52, ++0x51, ++0x33, ++0x14, ++0xf, ++0x5f, ++0x43, ++0x52, ++0x53, ++0x0, ++0xa4, ++0x49, ++0x51, ++0x43, ++0x52, ++0x50, ++0x52, ++0x51, ++0x33, ++0x14, ++0x17, ++0x5f, ++0x53, ++0x52, ++0x53, ++0x1, ++0x8a, ++0x68, ++0xa, ++0x5, ++0x50, ++0x52, ++0x52, ++0x49, ++0x70, ++0x50, ++0x52, ++0x52, ++0x49, ++0x50, ++0x52, ++0x51, ++0x33, ++0x5b, ++0x82, ++0x4f, ++0x4, ++0x4c, ++0x4e, ++0x4b, ++0x53, ++0x8, ++0x5f, ++0x48, ++0x49, ++0x44, ++0xc, ++0x41, ++0xd0, ++0xc, ++0xf, ++0x8, ++0x5f, ++0x55, ++0x49, ++0x44, ++0xa, ++0x4, ++0x8, ++0x5f, ++0x50, ++0x52, ++0x53, ++0x11, ++0xe, ++0xa, ++0xb, ++0x89, ++0x6, ++0x0, ++0x9, ++0x1, ++0x9, ++0x0, ++0x0, ++0x0, ++0x79, ++0x0, ++0x14, ++0x9, ++0x5f, ++0x53, ++0x54, ++0x41, ++0x0, ++0xa4, ++0xa, ++0xb, ++0x14, ++0x6, ++0x5f, ++0x44, ++0x49, ++0x53, ++0x0, ++0x14, ++0xb, ++0x5f, ++0x43, ++0x52, ++0x53, ++0x0, ++0xa4, ++0x5f, ++0x50, ++0x52, ++0x53, ++0x14, ++0x6, ++0x5f, ++0x53, ++0x52, ++0x53, ++0x1, ++0x10, ++0x47, ++0xe, ++0x5f, ++0x53, ++0x42, ++0x5f, ++0x14, ++0x35, ++0x43, ++0x50, ++0x4d, ++0x41, ++0x1, ++0x70, ++0x83, ++0x88, ++0x43, ++0x50, ++0x4f, ++0x4e, ++0x68, ++0x0, ++0x60, ++0x70, ++0x11, ++0xb, ++0xa, ++0x8, ++0x0, ++0x8, ++0x0, ++0x0, ++0x0, ++0x0, ++0x0, ++0x0, ++0x61, ++0x70, ++0x68, ++0x88, ++0x61, ++0xa, ++0x2, ++0x0, ++0x70, ++0x68, ++0x88, ++0x61, ++0xa, ++0x3, ++0x0, ++0x70, ++0x60, ++0x88, ++0x61, ++0xa, ++0x4, ++0x0, ++0xa4, ++0x61, ++0x14, ++0x1a, ++0x43, ++0x50, ++0x53, ++0x54, ++0x1, ++0x70, ++0x83, ++0x88, ++0x43, ++0x50, ++0x4f, ++0x4e, ++0x68, ++0x0, ++0x60, ++0xa0, ++0x5, ++0x60, ++0xa4, ++0xa, ++0xf, ++0xa1, ++0x3, ++0xa4, ++0x0, ++0x14, ++0xa, ++0x43, ++0x50, ++0x45, ++0x4a, ++0x2, ++0x5b, ++0x22, ++0xa, ++0xc8, ++0x5b, ++0x80, ++0x50, ++0x52, ++0x53, ++0x54, ++0x1, ++0xb, ++0x0, ++0xaf, ++0xa, ++0x20, ++0x5b, ++0x81, ++0xc, ++0x50, ++0x52, ++0x53, ++0x54, ++0x1, ++0x50, ++0x52, ++0x53, ++0x5f, ++0x40, ++0x10, ++0x14, ++0x4a, ++0x6, ++0x50, ++0x52, ++0x53, ++0x43, ++0x0, ++0x70, ++0x50, ++0x52, ++0x53, ++0x5f, ++0x65, ++0x70, ++0x0, ++0x62, ++0x70, ++0x0, ++0x60, ++0xa2, ++0x46, ++0x5, ++0x95, ++0x60, ++0x87, ++0x43, ++0x50, ++0x4f, ++0x4e, ++0x70, ++0x83, ++0x88, ++0x43, ++0x50, ++0x4f, ++0x4e, ++0x60, ++0x0, ++0x61, ++0xa0, ++0xa, ++0x7b, ++0x60, ++0xa, ++0x7, ++0x0, ++0x7a, ++0x62, ++0x1, ++0x62, ++0xa1, ++0xc, ++0x70, ++0x83, ++0x88, ++0x65, ++0x7a, ++0x60, ++0xa, ++0x3, ++0x0, ++0x0, ++0x62, ++0x70, ++0x7b, ++0x62, ++0x1, ++0x0, ++0x63, ++0xa0, ++0x22, ++0x92, ++0x93, ++0x61, ++0x63, ++0x70, ++0x63, ++0x88, ++0x43, ++0x50, ++0x4f, ++0x4e, ++0x60, ++0x0, ++0xa0, ++0xa, ++0x93, ++0x63, ++0x1, ++0x4e, ++0x54, ++0x46, ++0x59, ++0x60, ++0x1, ++0xa1, ++0x8, ++0x4e, ++0x54, ++0x46, ++0x59, ++0x60, ++0xa, ++0x3, ++0x75, ++0x60, ++0x10, ++0x4e, ++0x9, ++0x5f, ++0x47, ++0x50, ++0x45, ++0x8, ++0x5f, ++0x48, ++0x49, ++0x44, ++0xd, ++0x41, ++0x43, ++0x50, ++0x49, ++0x30, ++0x30, ++0x30, ++0x36, ++0x0, ++0x14, ++0x6, ++0x5f, ++0x4c, ++0x30, ++0x30, ++0x0, ++0x14, ++0x15, ++0x5f, ++0x45, ++0x30, ++0x31, ++0x0, ++0x5c, ++0x2f, ++0x3, ++0x5f, ++0x53, ++0x42, ++0x5f, ++0x50, ++0x43, ++0x49, ++0x30, ++0x50, ++0x43, ++0x4e, ++0x46, ++0x14, ++0x10, ++0x5f, ++0x45, ++0x30, ++0x32, ++0x0, ++0x5c, ++0x2e, ++0x5f, ++0x53, ++0x42, ++0x5f, ++0x50, ++0x52, ++0x53, ++0x43, ++0x14, ++0x6, ++0x5f, ++0x4c, ++0x30, ++0x33, ++0x0, ++0x14, ++0x6, ++0x5f, ++0x4c, ++0x30, ++0x34, ++0x0, ++0x14, ++0x6, ++0x5f, ++0x4c, ++0x30, ++0x35, ++0x0, ++0x14, ++0x6, ++0x5f, ++0x4c, ++0x30, ++0x36, ++0x0, ++0x14, ++0x6, ++0x5f, ++0x4c, ++0x30, ++0x37, ++0x0, ++0x14, ++0x6, ++0x5f, ++0x4c, ++0x30, ++0x38, ++0x0, ++0x14, ++0x6, ++0x5f, ++0x4c, ++0x30, ++0x39, ++0x0, ++0x14, ++0x6, ++0x5f, ++0x4c, ++0x30, ++0x41, ++0x0, ++0x14, ++0x6, ++0x5f, ++0x4c, ++0x30, ++0x42, ++0x0, ++0x14, ++0x6, ++0x5f, ++0x4c, ++0x30, ++0x43, ++0x0, ++0x14, ++0x6, ++0x5f, ++0x4c, ++0x30, ++0x44, ++0x0, ++0x14, ++0x6, ++0x5f, ++0x4c, ++0x30, ++0x45, ++0x0, ++0x14, ++0x6, ++0x5f, ++0x4c, ++0x30, ++0x46, ++0x0 ++}; +diff --git a/hw/i386/q35-acpi-dsdt.hex.generated b/hw/i386/q35-acpi-dsdt.hex.generated +new file mode 100644 +index 0000000..32c16ff +--- /dev/null ++++ b/hw/i386/q35-acpi-dsdt.hex.generated +@@ -0,0 +1,7346 @@ ++static unsigned char Q35AcpiDsdtAmlCode[] = { ++0x44, ++0x53, ++0x44, ++0x54, ++0xb0, ++0x1c, ++0x0, ++0x0, ++0x1, ++0x6, ++0x42, ++0x58, ++0x50, ++0x43, ++0x0, ++0x0, ++0x42, ++0x58, ++0x44, ++0x53, ++0x44, ++0x54, ++0x0, ++0x0, ++0x2, ++0x0, ++0x0, ++0x0, ++0x49, ++0x4e, ++0x54, ++0x4c, ++0x23, ++0x8, ++0x13, ++0x20, ++0x10, ++0x49, ++0x4, ++0x5c, ++0x0, ++0x5b, ++0x80, ++0x44, ++0x42, ++0x47, ++0x5f, ++0x1, ++0xb, ++0x2, ++0x4, ++0x1, ++0x5b, ++0x81, ++0xb, ++0x44, ++0x42, ++0x47, ++0x5f, ++0x1, ++0x44, ++0x42, ++0x47, ++0x42, ++0x8, ++0x14, ++0x2c, ++0x44, ++0x42, ++0x55, ++0x47, ++0x1, ++0x98, ++0x68, ++0x60, ++0x96, ++0x60, ++0x60, ++0x74, ++0x87, ++0x60, ++0x1, ++0x61, ++0x70, ++0x0, ++0x62, ++0xa2, ++0x10, ++0x95, ++0x62, ++0x61, ++0x70, ++0x83, ++0x88, ++0x60, ++0x62, ++0x0, ++0x44, ++0x42, ++0x47, ++0x42, ++0x75, ++0x62, ++0x70, ++0xa, ++0xa, ++0x44, ++0x42, ++0x47, ++0x42, ++0x10, ++0x29, ++0x5f, ++0x53, ++0x42, ++0x5f, ++0x5b, ++0x80, ++0x50, ++0x43, ++0x53, ++0x54, ++0x1, ++0xb, ++0x0, ++0xae, ++0xa, ++0xc, ++0x5b, ++0x80, ++0x50, ++0x43, ++0x53, ++0x42, ++0x1, ++0xb, ++0xc, ++0xae, ++0x1, ++0x5b, ++0x81, ++0xb, ++0x50, ++0x43, ++0x53, ++0x42, ++0x40, ++0x50, ++0x43, ++0x49, ++0x42, ++0x8, ++0x10, ++0x4f, ++0xc, ++0x5f, ++0x53, ++0x42, ++0x5f, ++0x5b, ++0x82, ++0x47, ++0xc, ++0x50, ++0x43, ++0x49, ++0x30, ++0x8, ++0x5f, ++0x48, ++0x49, ++0x44, ++0xc, ++0x41, ++0xd0, ++0xa, ++0x8, ++0x8, ++0x5f, ++0x43, ++0x49, ++0x44, ++0xc, ++0x41, ++0xd0, ++0xa, ++0x3, ++0x8, ++0x5f, ++0x41, ++0x44, ++0x52, ++0x0, ++0x8, ++0x5f, ++0x55, ++0x49, ++0x44, ++0x1, ++0x8, ++0x53, ++0x55, ++0x50, ++0x50, ++0x0, ++0x8, ++0x43, ++0x54, ++0x52, ++0x4c, ++0x0, ++0x14, ++0x44, ++0x9, ++0x5f, ++0x4f, ++0x53, ++0x43, ++0x4, ++0x8a, ++0x6b, ++0x0, ++0x43, ++0x44, ++0x57, ++0x31, ++0xa0, ++0x46, ++0x7, ++0x93, ++0x68, ++0x11, ++0x13, ++0xa, ++0x10, ++0x5b, ++0x4d, ++0xdb, ++0x33, ++0xf7, ++0x1f, ++0x1c, ++0x40, ++0x96, ++0x57, ++0x74, ++0x41, ++0xc0, ++0x3d, ++0xd7, ++0x66, ++0x8a, ++0x6b, ++0xa, ++0x4, ++0x43, ++0x44, ++0x57, ++0x32, ++0x8a, ++0x6b, ++0xa, ++0x8, ++0x43, ++0x44, ++0x57, ++0x33, ++0x70, ++0x43, ++0x44, ++0x57, ++0x32, ++0x53, ++0x55, ++0x50, ++0x50, ++0x70, ++0x43, ++0x44, ++0x57, ++0x33, ++0x43, ++0x54, ++0x52, ++0x4c, ++0x7b, ++0x43, ++0x54, ++0x52, ++0x4c, ++0xa, ++0x1d, ++0x43, ++0x54, ++0x52, ++0x4c, ++0xa0, ++0x10, ++0x92, ++0x93, ++0x69, ++0x1, ++0x7d, ++0x43, ++0x44, ++0x57, ++0x31, ++0xa, ++0x8, ++0x43, ++0x44, ++0x57, ++0x31, ++0xa0, ++0x16, ++0x92, ++0x93, ++0x43, ++0x44, ++0x57, ++0x33, ++0x43, ++0x54, ++0x52, ++0x4c, ++0x7d, ++0x43, ++0x44, ++0x57, ++0x31, ++0xa, ++0x10, ++0x43, ++0x44, ++0x57, ++0x31, ++0x70, ++0x43, ++0x54, ++0x52, ++0x4c, ++0x43, ++0x44, ++0x57, ++0x33, ++0xa1, ++0xc, ++0x7d, ++0x43, ++0x44, ++0x57, ++0x31, ++0xa, ++0x4, ++0x43, ++0x44, ++0x57, ++0x31, ++0xa4, ++0x6b, ++0x10, ++0x4e, ++0x15, ++0x2e, ++0x5f, ++0x53, ++0x42, ++0x5f, ++0x50, ++0x43, ++0x49, ++0x30, ++0x8, ++0x43, ++0x52, ++0x45, ++0x53, ++0x11, ++0x42, ++0x7, ++0xa, ++0x6e, ++0x88, ++0xd, ++0x0, ++0x2, ++0xc, ++0x0, ++0x0, ++0x0, ++0x0, ++0x0, ++0xff, ++0x0, ++0x0, ++0x0, ++0x0, ++0x1, ++0x47, ++0x1, ++0xf8, ++0xc, ++0xf8, ++0xc, ++0x1, ++0x8, ++0x88, ++0xd, ++0x0, ++0x1, ++0xc, ++0x3, ++0x0, ++0x0, ++0x0, ++0x0, ++0xf7, ++0xc, ++0x0, ++0x0, ++0xf8, ++0xc, ++0x88, ++0xd, ++0x0, ++0x1, ++0xc, ++0x3, ++0x0, ++0x0, ++0x0, ++0xd, ++0xff, ++0xff, ++0x0, ++0x0, ++0x0, ++0xf3, ++0x87, ++0x17, ++0x0, ++0x0, ++0xc, ++0x3, ++0x0, ++0x0, ++0x0, ++0x0, ++0x0, ++0x0, ++0xa, ++0x0, ++0xff, ++0xff, ++0xb, ++0x0, ++0x0, ++0x0, ++0x0, ++0x0, ++0x0, ++0x0, ++0x2, ++0x0, ++0x87, ++0x17, ++0x0, ++0x0, ++0xc, ++0x1, ++0x0, ++0x0, ++0x0, ++0x0, ++0x0, ++0x0, ++0x0, ++0xe0, ++0xff, ++0xff, ++0xbf, ++0xfe, ++0x0, ++0x0, ++0x0, ++0x0, ++0x0, ++0x0, ++0xc0, ++0x1e, ++0x79, ++0x0, ++0x8, ++0x43, ++0x52, ++0x36, ++0x34, ++0x11, ++0x33, ++0xa, ++0x30, ++0x8a, ++0x2b, ++0x0, ++0x0, ++0xc, ++0x3, ++0x0, ++0x0, ++0x0, ++0x0, ++0x0, ++0x0, ++0x0, ++0x0, ++0x0, ++0x0, ++0x0, ++0x0, ++0x80, ++0x0, ++0x0, ++0x0, ++0xff, ++0xff, ++0xff, ++0xff, ++0xff, ++0x0, ++0x0, ++0x0, ++0x0, ++0x0, ++0x0, ++0x0, ++0x0, ++0x0, ++0x0, ++0x0, ++0x0, ++0x0, ++0x0, ++0x0, ++0x80, ++0x0, ++0x0, ++0x0, ++0x79, ++0x0, ++0x14, ++0x41, ++0xa, ++0x5f, ++0x43, ++0x52, ++0x53, ++0x0, ++0x8a, ++0x43, ++0x52, ++0x45, ++0x53, ++0xa, ++0x5c, ++0x50, ++0x53, ++0x33, ++0x32, ++0x8a, ++0x43, ++0x52, ++0x45, ++0x53, ++0xa, ++0x60, ++0x50, ++0x45, ++0x33, ++0x32, ++0x8a, ++0x43, ++0x52, ++0x45, ++0x53, ++0xa, ++0x68, ++0x50, ++0x4c, ++0x33, ++0x32, ++0x70, ++0x50, ++0x30, ++0x53, ++0x5f, ++0x50, ++0x53, ++0x33, ++0x32, ++0x70, ++0x50, ++0x30, ++0x45, ++0x5f, ++0x50, ++0x45, ++0x33, ++0x32, ++0x70, ++0x72, ++0x74, ++0x50, ++0x30, ++0x45, ++0x5f, ++0x50, ++0x30, ++0x53, ++0x5f, ++0x0, ++0x1, ++0x0, ++0x50, ++0x4c, ++0x33, ++0x32, ++0xa0, ++0xc, ++0x93, ++0x50, ++0x31, ++0x56, ++0x5f, ++0x0, ++0xa4, ++0x43, ++0x52, ++0x45, ++0x53, ++0x8f, ++0x43, ++0x52, ++0x36, ++0x34, ++0xa, ++0xe, ++0x50, ++0x53, ++0x36, ++0x34, ++0x8f, ++0x43, ++0x52, ++0x36, ++0x34, ++0xa, ++0x16, ++0x50, ++0x45, ++0x36, ++0x34, ++0x8f, ++0x43, ++0x52, ++0x36, ++0x34, ++0xa, ++0x26, ++0x50, ++0x4c, ++0x36, ++0x34, ++0x70, ++0x50, ++0x31, ++0x53, ++0x5f, ++0x50, ++0x53, ++0x36, ++0x34, ++0x70, ++0x50, ++0x31, ++0x45, ++0x5f, ++0x50, ++0x45, ++0x36, ++0x34, ++0x70, ++0x50, ++0x31, ++0x4c, ++0x5f, ++0x50, ++0x4c, ++0x36, ++0x34, ++0x84, ++0x43, ++0x52, ++0x45, ++0x53, ++0x43, ++0x52, ++0x36, ++0x34, ++0x60, ++0xa4, ++0x60, ++0x10, ++0x4d, ++0x8, ++0x5f, ++0x53, ++0x42, ++0x5f, ++0x5b, ++0x82, ++0x45, ++0x8, ++0x48, ++0x50, ++0x45, ++0x54, ++0x8, ++0x5f, ++0x48, ++0x49, ++0x44, ++0xc, ++0x41, ++0xd0, ++0x1, ++0x3, ++0x8, ++0x5f, ++0x55, ++0x49, ++0x44, ++0x0, ++0x5b, ++0x80, ++0x48, ++0x50, ++0x54, ++0x4d, ++0x0, ++0xc, ++0x0, ++0x0, ++0xd0, ++0xfe, ++0xb, ++0x0, ++0x4, ++0x5b, ++0x81, ++0x10, ++0x48, ++0x50, ++0x54, ++0x4d, ++0x13, ++0x56, ++0x45, ++0x4e, ++0x44, ++0x20, ++0x50, ++0x52, ++0x44, ++0x5f, ++0x20, ++0x14, ++0x36, ++0x5f, ++0x53, ++0x54, ++0x41, ++0x0, ++0x70, ++0x56, ++0x45, ++0x4e, ++0x44, ++0x60, ++0x70, ++0x50, ++0x52, ++0x44, ++0x5f, ++0x61, ++0x7a, ++0x60, ++0xa, ++0x10, ++0x60, ++0xa0, ++0xc, ++0x91, ++0x93, ++0x60, ++0x0, ++0x93, ++0x60, ++0xb, ++0xff, ++0xff, ++0xa4, ++0x0, ++0xa0, ++0xe, ++0x91, ++0x93, ++0x61, ++0x0, ++0x94, ++0x61, ++0xc, ++0x0, ++0xe1, ++0xf5, ++0x5, ++0xa4, ++0x0, ++0xa4, ++0xa, ++0xf, ++0x8, ++0x5f, ++0x43, ++0x52, ++0x53, ++0x11, ++0x11, ++0xa, ++0xe, ++0x86, ++0x9, ++0x0, ++0x0, ++0x0, ++0x0, ++0xd0, ++0xfe, ++0x0, ++0x4, ++0x0, ++0x0, ++0x79, ++0x0, ++0x10, ++0x36, ++0x2e, ++0x5f, ++0x53, ++0x42, ++0x5f, ++0x50, ++0x43, ++0x49, ++0x30, ++0x5b, ++0x82, ++0x2a, ++0x56, ++0x47, ++0x41, ++0x5f, ++0x8, ++0x5f, ++0x41, ++0x44, ++0x52, ++0xc, ++0x0, ++0x0, ++0x1, ++0x0, ++0x14, ++0x8, ++0x5f, ++0x53, ++0x31, ++0x44, ++0x0, ++0xa4, ++0x0, ++0x14, ++0x8, ++0x5f, ++0x53, ++0x32, ++0x44, ++0x0, ++0xa4, ++0x0, ++0x14, ++0x8, ++0x5f, ++0x53, ++0x33, ++0x44, ++0x0, ++0xa4, ++0x0, ++0x10, ++0x4c, ++0x7, ++0x2e, ++0x5f, ++0x53, ++0x42, ++0x5f, ++0x50, ++0x43, ++0x49, ++0x30, ++0x5b, ++0x82, ++0x4f, ++0x6, ++0x49, ++0x53, ++0x41, ++0x5f, ++0x8, ++0x5f, ++0x41, ++0x44, ++0x52, ++0xc, ++0x0, ++0x0, ++0x1f, ++0x0, ++0x5b, ++0x80, ++0x50, ++0x49, ++0x52, ++0x51, ++0x2, ++0xa, ++0x60, ++0xa, ++0xc, ++0x5b, ++0x80, ++0x4c, ++0x50, ++0x43, ++0x44, ++0x2, ++0xa, ++0x80, ++0xa, ++0x2, ++0x5b, ++0x81, ++0x20, ++0x4c, ++0x50, ++0x43, ++0x44, ++0x0, ++0x43, ++0x4f, ++0x4d, ++0x41, ++0x3, ++0x0, ++0x1, ++0x43, ++0x4f, ++0x4d, ++0x42, ++0x3, ++0x0, ++0x1, ++0x4c, ++0x50, ++0x54, ++0x44, ++0x2, ++0x0, ++0x2, ++0x46, ++0x44, ++0x43, ++0x44, ++0x2, ++0x5b, ++0x80, ++0x4c, ++0x50, ++0x43, ++0x45, ++0x2, ++0xa, ++0x82, ++0xa, ++0x2, ++0x5b, ++0x81, ++0x1a, ++0x4c, ++0x50, ++0x43, ++0x45, ++0x0, ++0x43, ++0x41, ++0x45, ++0x4e, ++0x1, ++0x43, ++0x42, ++0x45, ++0x4e, ++0x1, ++0x4c, ++0x50, ++0x45, ++0x4e, ++0x1, ++0x46, ++0x44, ++0x45, ++0x4e, ++0x1, ++0x10, ++0x4c, ++0x1b, ++0x2f, ++0x3, ++0x5f, ++0x53, ++0x42, ++0x5f, ++0x50, ++0x43, ++0x49, ++0x30, ++0x49, ++0x53, ++0x41, ++0x5f, ++0x5b, ++0x82, ++0x2d, ++0x52, ++0x54, ++0x43, ++0x5f, ++0x8, ++0x5f, ++0x48, ++0x49, ++0x44, ++0xc, ++0x41, ++0xd0, ++0xb, ++0x0, ++0x8, ++0x5f, ++0x43, ++0x52, ++0x53, ++0x11, ++0x18, ++0xa, ++0x15, ++0x47, ++0x1, ++0x70, ++0x0, ++0x70, ++0x0, ++0x10, ++0x2, ++0x22, ++0x0, ++0x1, ++0x47, ++0x1, ++0x72, ++0x0, ++0x72, ++0x0, ++0x2, ++0x6, ++0x79, ++0x0, ++0x5b, ++0x82, ++0x37, ++0x4b, ++0x42, ++0x44, ++0x5f, ++0x8, ++0x5f, ++0x48, ++0x49, ++0x44, ++0xc, ++0x41, ++0xd0, ++0x3, ++0x3, ++0x14, ++0x9, ++0x5f, ++0x53, ++0x54, ++0x41, ++0x0, ++0xa4, ++0xa, ++0xf, ++0x8, ++0x5f, ++0x43, ++0x52, ++0x53, ++0x11, ++0x18, ++0xa, ++0x15, ++0x47, ++0x1, ++0x60, ++0x0, ++0x60, ++0x0, ++0x1, ++0x1, ++0x47, ++0x1, ++0x64, ++0x0, ++0x64, ++0x0, ++0x1, ++0x1, ++0x22, ++0x2, ++0x0, ++0x79, ++0x0, ++0x5b, ++0x82, ++0x27, ++0x4d, ++0x4f, ++0x55, ++0x5f, ++0x8, ++0x5f, ++0x48, ++0x49, ++0x44, ++0xc, ++0x41, ++0xd0, ++0xf, ++0x13, ++0x14, ++0x9, ++0x5f, ++0x53, ++0x54, ++0x41, ++0x0, ++0xa4, ++0xa, ++0xf, ++0x8, ++0x5f, ++0x43, ++0x52, ++0x53, ++0x11, ++0x8, ++0xa, ++0x5, ++0x22, ++0x0, ++0x10, ++0x79, ++0x0, ++0x5b, ++0x82, ++0x4a, ++0x4, ++0x46, ++0x44, ++0x43, ++0x30, ++0x8, ++0x5f, ++0x48, ++0x49, ++0x44, ++0xc, ++0x41, ++0xd0, ++0x7, ++0x0, ++0x14, ++0x18, ++0x5f, ++0x53, ++0x54, ++0x41, ++0x0, ++0x70, ++0x46, ++0x44, ++0x45, ++0x4e, ++0x60, ++0xa0, ++0x6, ++0x93, ++0x60, ++0x0, ++0xa4, ++0x0, ++0xa1, ++0x4, ++0xa4, ++0xa, ++0xf, ++0x8, ++0x5f, ++0x43, ++0x52, ++0x53, ++0x11, ++0x1b, ++0xa, ++0x18, ++0x47, ++0x1, ++0xf2, ++0x3, ++0xf2, ++0x3, ++0x0, ++0x4, ++0x47, ++0x1, ++0xf7, ++0x3, ++0xf7, ++0x3, ++0x0, ++0x1, ++0x22, ++0x40, ++0x0, ++0x2a, ++0x4, ++0x0, ++0x79, ++0x0, ++0x5b, ++0x82, ++0x3e, ++0x4c, ++0x50, ++0x54, ++0x5f, ++0x8, ++0x5f, ++0x48, ++0x49, ++0x44, ++0xc, ++0x41, ++0xd0, ++0x4, ++0x0, ++0x14, ++0x18, ++0x5f, ++0x53, ++0x54, ++0x41, ++0x0, ++0x70, ++0x4c, ++0x50, ++0x45, ++0x4e, ++0x60, ++0xa0, ++0x6, ++0x93, ++0x60, ++0x0, ++0xa4, ++0x0, ++0xa1, ++0x4, ++0xa4, ++0xa, ++0xf, ++0x8, ++0x5f, ++0x43, ++0x52, ++0x53, ++0x11, ++0x10, ++0xa, ++0xd, ++0x47, ++0x1, ++0x78, ++0x3, ++0x78, ++0x3, ++0x8, ++0x8, ++0x22, ++0x80, ++0x0, ++0x79, ++0x0, ++0x5b, ++0x82, ++0x45, ++0x4, ++0x43, ++0x4f, ++0x4d, ++0x31, ++0x8, ++0x5f, ++0x48, ++0x49, ++0x44, ++0xc, ++0x41, ++0xd0, ++0x5, ++0x1, ++0x8, ++0x5f, ++0x55, ++0x49, ++0x44, ++0x1, ++0x14, ++0x18, ++0x5f, ++0x53, ++0x54, ++0x41, ++0x0, ++0x70, ++0x43, ++0x41, ++0x45, ++0x4e, ++0x60, ++0xa0, ++0x6, ++0x93, ++0x60, ++0x0, ++0xa4, ++0x0, ++0xa1, ++0x4, ++0xa4, ++0xa, ++0xf, ++0x8, ++0x5f, ++0x43, ++0x52, ++0x53, ++0x11, ++0x10, ++0xa, ++0xd, ++0x47, ++0x1, ++0xf8, ++0x3, ++0xf8, ++0x3, ++0x0, ++0x8, ++0x22, ++0x10, ++0x0, ++0x79, ++0x0, ++0x5b, ++0x82, ++0x46, ++0x4, ++0x43, ++0x4f, ++0x4d, ++0x32, ++0x8, ++0x5f, ++0x48, ++0x49, ++0x44, ++0xc, ++0x41, ++0xd0, ++0x5, ++0x1, ++0x8, ++0x5f, ++0x55, ++0x49, ++0x44, ++0xa, ++0x2, ++0x14, ++0x18, ++0x5f, ++0x53, ++0x54, ++0x41, ++0x0, ++0x70, ++0x43, ++0x42, ++0x45, ++0x4e, ++0x60, ++0xa0, ++0x6, ++0x93, ++0x60, ++0x0, ++0xa4, ++0x0, ++0xa1, ++0x4, ++0xa4, ++0xa, ++0xf, ++0x8, ++0x5f, ++0x43, ++0x52, ++0x53, ++0x11, ++0x10, ++0xa, ++0xd, ++0x47, ++0x1, ++0xf8, ++0x2, ++0xf8, ++0x2, ++0x0, ++0x8, ++0x22, ++0x8, ++0x0, ++0x79, ++0x0, ++0x8, ++0x50, ++0x49, ++0x43, ++0x46, ++0x0, ++0x14, ++0xc, ++0x5f, ++0x50, ++0x49, ++0x43, ++0x1, ++0x70, ++0x68, ++0x50, ++0x49, ++0x43, ++0x46, ++0x10, ++0x8e, ++0x55, ++0x1, ++0x5f, ++0x53, ++0x42, ++0x5f, ++0x10, ++0x43, ++0xea, ++0x50, ++0x43, ++0x49, ++0x30, ++0x8, ++0x50, ++0x52, ++0x54, ++0x50, ++0x12, ++0x4b, ++0x73, ++0x80, ++0x12, ++0xb, ++0x4, ++0xb, ++0xff, ++0xff, ++0x0, ++0x4c, ++0x4e, ++0x4b, ++0x45, ++0x0, ++0x12, ++0xb, ++0x4, ++0xb, ++0xff, ++0xff, ++0x1, ++0x4c, ++0x4e, ++0x4b, ++0x46, ++0x0, ++0x12, ++0xc, ++0x4, ++0xb, ++0xff, ++0xff, ++0xa, ++0x2, ++0x4c, ++0x4e, ++0x4b, ++0x47, ++0x0, ++0x12, ++0xc, ++0x4, ++0xb, ++0xff, ++0xff, ++0xa, ++0x3, ++0x4c, ++0x4e, ++0x4b, ++0x48, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x1, ++0x0, ++0x0, ++0x4c, ++0x4e, ++0x4b, ++0x46, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x1, ++0x0, ++0x1, ++0x4c, ++0x4e, ++0x4b, ++0x47, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x1, ++0x0, ++0xa, ++0x2, ++0x4c, ++0x4e, ++0x4b, ++0x48, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x1, ++0x0, ++0xa, ++0x3, ++0x4c, ++0x4e, ++0x4b, ++0x45, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x2, ++0x0, ++0x0, ++0x4c, ++0x4e, ++0x4b, ++0x47, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x2, ++0x0, ++0x1, ++0x4c, ++0x4e, ++0x4b, ++0x48, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x2, ++0x0, ++0xa, ++0x2, ++0x4c, ++0x4e, ++0x4b, ++0x45, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x2, ++0x0, ++0xa, ++0x3, ++0x4c, ++0x4e, ++0x4b, ++0x46, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x3, ++0x0, ++0x0, ++0x4c, ++0x4e, ++0x4b, ++0x48, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x3, ++0x0, ++0x1, ++0x4c, ++0x4e, ++0x4b, ++0x45, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x3, ++0x0, ++0xa, ++0x2, ++0x4c, ++0x4e, ++0x4b, ++0x46, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x3, ++0x0, ++0xa, ++0x3, ++0x4c, ++0x4e, ++0x4b, ++0x47, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x4, ++0x0, ++0x0, ++0x4c, ++0x4e, ++0x4b, ++0x45, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x4, ++0x0, ++0x1, ++0x4c, ++0x4e, ++0x4b, ++0x46, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x4, ++0x0, ++0xa, ++0x2, ++0x4c, ++0x4e, ++0x4b, ++0x47, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x4, ++0x0, ++0xa, ++0x3, ++0x4c, ++0x4e, ++0x4b, ++0x48, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x5, ++0x0, ++0x0, ++0x4c, ++0x4e, ++0x4b, ++0x46, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x5, ++0x0, ++0x1, ++0x4c, ++0x4e, ++0x4b, ++0x47, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x5, ++0x0, ++0xa, ++0x2, ++0x4c, ++0x4e, ++0x4b, ++0x48, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x5, ++0x0, ++0xa, ++0x3, ++0x4c, ++0x4e, ++0x4b, ++0x45, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x6, ++0x0, ++0x0, ++0x4c, ++0x4e, ++0x4b, ++0x47, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x6, ++0x0, ++0x1, ++0x4c, ++0x4e, ++0x4b, ++0x48, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x6, ++0x0, ++0xa, ++0x2, ++0x4c, ++0x4e, ++0x4b, ++0x45, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x6, ++0x0, ++0xa, ++0x3, ++0x4c, ++0x4e, ++0x4b, ++0x46, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x7, ++0x0, ++0x0, ++0x4c, ++0x4e, ++0x4b, ++0x48, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x7, ++0x0, ++0x1, ++0x4c, ++0x4e, ++0x4b, ++0x45, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x7, ++0x0, ++0xa, ++0x2, ++0x4c, ++0x4e, ++0x4b, ++0x46, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x7, ++0x0, ++0xa, ++0x3, ++0x4c, ++0x4e, ++0x4b, ++0x47, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x8, ++0x0, ++0x0, ++0x4c, ++0x4e, ++0x4b, ++0x45, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x8, ++0x0, ++0x1, ++0x4c, ++0x4e, ++0x4b, ++0x46, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x8, ++0x0, ++0xa, ++0x2, ++0x4c, ++0x4e, ++0x4b, ++0x47, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x8, ++0x0, ++0xa, ++0x3, ++0x4c, ++0x4e, ++0x4b, ++0x48, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x9, ++0x0, ++0x0, ++0x4c, ++0x4e, ++0x4b, ++0x46, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x9, ++0x0, ++0x1, ++0x4c, ++0x4e, ++0x4b, ++0x47, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x9, ++0x0, ++0xa, ++0x2, ++0x4c, ++0x4e, ++0x4b, ++0x48, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x9, ++0x0, ++0xa, ++0x3, ++0x4c, ++0x4e, ++0x4b, ++0x45, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0xa, ++0x0, ++0x0, ++0x4c, ++0x4e, ++0x4b, ++0x47, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0xa, ++0x0, ++0x1, ++0x4c, ++0x4e, ++0x4b, ++0x48, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0xa, ++0x0, ++0xa, ++0x2, ++0x4c, ++0x4e, ++0x4b, ++0x45, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0xa, ++0x0, ++0xa, ++0x3, ++0x4c, ++0x4e, ++0x4b, ++0x46, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0xb, ++0x0, ++0x0, ++0x4c, ++0x4e, ++0x4b, ++0x48, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0xb, ++0x0, ++0x1, ++0x4c, ++0x4e, ++0x4b, ++0x45, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0xb, ++0x0, ++0xa, ++0x2, ++0x4c, ++0x4e, ++0x4b, ++0x46, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0xb, ++0x0, ++0xa, ++0x3, ++0x4c, ++0x4e, ++0x4b, ++0x47, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0xc, ++0x0, ++0x0, ++0x4c, ++0x4e, ++0x4b, ++0x45, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0xc, ++0x0, ++0x1, ++0x4c, ++0x4e, ++0x4b, ++0x46, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0xc, ++0x0, ++0xa, ++0x2, ++0x4c, ++0x4e, ++0x4b, ++0x47, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0xc, ++0x0, ++0xa, ++0x3, ++0x4c, ++0x4e, ++0x4b, ++0x48, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0xd, ++0x0, ++0x0, ++0x4c, ++0x4e, ++0x4b, ++0x46, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0xd, ++0x0, ++0x1, ++0x4c, ++0x4e, ++0x4b, ++0x47, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0xd, ++0x0, ++0xa, ++0x2, ++0x4c, ++0x4e, ++0x4b, ++0x48, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0xd, ++0x0, ++0xa, ++0x3, ++0x4c, ++0x4e, ++0x4b, ++0x45, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0xe, ++0x0, ++0x0, ++0x4c, ++0x4e, ++0x4b, ++0x47, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0xe, ++0x0, ++0x1, ++0x4c, ++0x4e, ++0x4b, ++0x48, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0xe, ++0x0, ++0xa, ++0x2, ++0x4c, ++0x4e, ++0x4b, ++0x45, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0xe, ++0x0, ++0xa, ++0x3, ++0x4c, ++0x4e, ++0x4b, ++0x46, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0xf, ++0x0, ++0x0, ++0x4c, ++0x4e, ++0x4b, ++0x48, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0xf, ++0x0, ++0x1, ++0x4c, ++0x4e, ++0x4b, ++0x45, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0xf, ++0x0, ++0xa, ++0x2, ++0x4c, ++0x4e, ++0x4b, ++0x46, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0xf, ++0x0, ++0xa, ++0x3, ++0x4c, ++0x4e, ++0x4b, ++0x47, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x10, ++0x0, ++0x0, ++0x4c, ++0x4e, ++0x4b, ++0x45, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x10, ++0x0, ++0x1, ++0x4c, ++0x4e, ++0x4b, ++0x46, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x10, ++0x0, ++0xa, ++0x2, ++0x4c, ++0x4e, ++0x4b, ++0x47, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x10, ++0x0, ++0xa, ++0x3, ++0x4c, ++0x4e, ++0x4b, ++0x48, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x11, ++0x0, ++0x0, ++0x4c, ++0x4e, ++0x4b, ++0x46, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x11, ++0x0, ++0x1, ++0x4c, ++0x4e, ++0x4b, ++0x47, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x11, ++0x0, ++0xa, ++0x2, ++0x4c, ++0x4e, ++0x4b, ++0x48, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x11, ++0x0, ++0xa, ++0x3, ++0x4c, ++0x4e, ++0x4b, ++0x45, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x12, ++0x0, ++0x0, ++0x4c, ++0x4e, ++0x4b, ++0x47, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x12, ++0x0, ++0x1, ++0x4c, ++0x4e, ++0x4b, ++0x48, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x12, ++0x0, ++0xa, ++0x2, ++0x4c, ++0x4e, ++0x4b, ++0x45, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x12, ++0x0, ++0xa, ++0x3, ++0x4c, ++0x4e, ++0x4b, ++0x46, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x13, ++0x0, ++0x0, ++0x4c, ++0x4e, ++0x4b, ++0x48, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x13, ++0x0, ++0x1, ++0x4c, ++0x4e, ++0x4b, ++0x45, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x13, ++0x0, ++0xa, ++0x2, ++0x4c, ++0x4e, ++0x4b, ++0x46, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x13, ++0x0, ++0xa, ++0x3, ++0x4c, ++0x4e, ++0x4b, ++0x47, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x14, ++0x0, ++0x0, ++0x4c, ++0x4e, ++0x4b, ++0x45, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x14, ++0x0, ++0x1, ++0x4c, ++0x4e, ++0x4b, ++0x46, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x14, ++0x0, ++0xa, ++0x2, ++0x4c, ++0x4e, ++0x4b, ++0x47, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x14, ++0x0, ++0xa, ++0x3, ++0x4c, ++0x4e, ++0x4b, ++0x48, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x15, ++0x0, ++0x0, ++0x4c, ++0x4e, ++0x4b, ++0x46, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x15, ++0x0, ++0x1, ++0x4c, ++0x4e, ++0x4b, ++0x47, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x15, ++0x0, ++0xa, ++0x2, ++0x4c, ++0x4e, ++0x4b, ++0x48, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x15, ++0x0, ++0xa, ++0x3, ++0x4c, ++0x4e, ++0x4b, ++0x45, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x16, ++0x0, ++0x0, ++0x4c, ++0x4e, ++0x4b, ++0x47, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x16, ++0x0, ++0x1, ++0x4c, ++0x4e, ++0x4b, ++0x48, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x16, ++0x0, ++0xa, ++0x2, ++0x4c, ++0x4e, ++0x4b, ++0x45, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x16, ++0x0, ++0xa, ++0x3, ++0x4c, ++0x4e, ++0x4b, ++0x46, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x17, ++0x0, ++0x0, ++0x4c, ++0x4e, ++0x4b, ++0x48, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x17, ++0x0, ++0x1, ++0x4c, ++0x4e, ++0x4b, ++0x45, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x17, ++0x0, ++0xa, ++0x2, ++0x4c, ++0x4e, ++0x4b, ++0x46, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x17, ++0x0, ++0xa, ++0x3, ++0x4c, ++0x4e, ++0x4b, ++0x47, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x18, ++0x0, ++0x0, ++0x4c, ++0x4e, ++0x4b, ++0x45, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x18, ++0x0, ++0x1, ++0x4c, ++0x4e, ++0x4b, ++0x46, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x18, ++0x0, ++0xa, ++0x2, ++0x4c, ++0x4e, ++0x4b, ++0x47, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x18, ++0x0, ++0xa, ++0x3, ++0x4c, ++0x4e, ++0x4b, ++0x48, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x19, ++0x0, ++0x0, ++0x4c, ++0x4e, ++0x4b, ++0x41, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x19, ++0x0, ++0x1, ++0x4c, ++0x4e, ++0x4b, ++0x42, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x19, ++0x0, ++0xa, ++0x2, ++0x4c, ++0x4e, ++0x4b, ++0x43, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x19, ++0x0, ++0xa, ++0x3, ++0x4c, ++0x4e, ++0x4b, ++0x44, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x1a, ++0x0, ++0x0, ++0x4c, ++0x4e, ++0x4b, ++0x41, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x1a, ++0x0, ++0x1, ++0x4c, ++0x4e, ++0x4b, ++0x42, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x1a, ++0x0, ++0xa, ++0x2, ++0x4c, ++0x4e, ++0x4b, ++0x43, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x1a, ++0x0, ++0xa, ++0x3, ++0x4c, ++0x4e, ++0x4b, ++0x44, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x1b, ++0x0, ++0x0, ++0x4c, ++0x4e, ++0x4b, ++0x41, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x1b, ++0x0, ++0x1, ++0x4c, ++0x4e, ++0x4b, ++0x42, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x1b, ++0x0, ++0xa, ++0x2, ++0x4c, ++0x4e, ++0x4b, ++0x43, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x1b, ++0x0, ++0xa, ++0x3, ++0x4c, ++0x4e, ++0x4b, ++0x44, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x1c, ++0x0, ++0x0, ++0x4c, ++0x4e, ++0x4b, ++0x41, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x1c, ++0x0, ++0x1, ++0x4c, ++0x4e, ++0x4b, ++0x42, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x1c, ++0x0, ++0xa, ++0x2, ++0x4c, ++0x4e, ++0x4b, ++0x43, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x1c, ++0x0, ++0xa, ++0x3, ++0x4c, ++0x4e, ++0x4b, ++0x44, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x1d, ++0x0, ++0x0, ++0x4c, ++0x4e, ++0x4b, ++0x41, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x1d, ++0x0, ++0x1, ++0x4c, ++0x4e, ++0x4b, ++0x42, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x1d, ++0x0, ++0xa, ++0x2, ++0x4c, ++0x4e, ++0x4b, ++0x43, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x1d, ++0x0, ++0xa, ++0x3, ++0x4c, ++0x4e, ++0x4b, ++0x44, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x1e, ++0x0, ++0x0, ++0x4c, ++0x4e, ++0x4b, ++0x45, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x1e, ++0x0, ++0x1, ++0x4c, ++0x4e, ++0x4b, ++0x46, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x1e, ++0x0, ++0xa, ++0x2, ++0x4c, ++0x4e, ++0x4b, ++0x47, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x1e, ++0x0, ++0xa, ++0x3, ++0x4c, ++0x4e, ++0x4b, ++0x48, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x1f, ++0x0, ++0x0, ++0x4c, ++0x4e, ++0x4b, ++0x41, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x1f, ++0x0, ++0x1, ++0x4c, ++0x4e, ++0x4b, ++0x42, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x1f, ++0x0, ++0xa, ++0x2, ++0x4c, ++0x4e, ++0x4b, ++0x43, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x1f, ++0x0, ++0xa, ++0x3, ++0x4c, ++0x4e, ++0x4b, ++0x44, ++0x0, ++0x8, ++0x50, ++0x52, ++0x54, ++0x41, ++0x12, ++0x4b, ++0x73, ++0x80, ++0x12, ++0xb, ++0x4, ++0xb, ++0xff, ++0xff, ++0x0, ++0x47, ++0x53, ++0x49, ++0x45, ++0x0, ++0x12, ++0xb, ++0x4, ++0xb, ++0xff, ++0xff, ++0x1, ++0x47, ++0x53, ++0x49, ++0x46, ++0x0, ++0x12, ++0xc, ++0x4, ++0xb, ++0xff, ++0xff, ++0xa, ++0x2, ++0x47, ++0x53, ++0x49, ++0x47, ++0x0, ++0x12, ++0xc, ++0x4, ++0xb, ++0xff, ++0xff, ++0xa, ++0x3, ++0x47, ++0x53, ++0x49, ++0x48, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x1, ++0x0, ++0x0, ++0x47, ++0x53, ++0x49, ++0x46, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x1, ++0x0, ++0x1, ++0x47, ++0x53, ++0x49, ++0x47, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x1, ++0x0, ++0xa, ++0x2, ++0x47, ++0x53, ++0x49, ++0x48, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x1, ++0x0, ++0xa, ++0x3, ++0x47, ++0x53, ++0x49, ++0x45, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x2, ++0x0, ++0x0, ++0x47, ++0x53, ++0x49, ++0x47, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x2, ++0x0, ++0x1, ++0x47, ++0x53, ++0x49, ++0x48, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x2, ++0x0, ++0xa, ++0x2, ++0x47, ++0x53, ++0x49, ++0x45, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x2, ++0x0, ++0xa, ++0x3, ++0x47, ++0x53, ++0x49, ++0x46, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x3, ++0x0, ++0x0, ++0x47, ++0x53, ++0x49, ++0x48, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x3, ++0x0, ++0x1, ++0x47, ++0x53, ++0x49, ++0x45, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x3, ++0x0, ++0xa, ++0x2, ++0x47, ++0x53, ++0x49, ++0x46, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x3, ++0x0, ++0xa, ++0x3, ++0x47, ++0x53, ++0x49, ++0x47, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x4, ++0x0, ++0x0, ++0x47, ++0x53, ++0x49, ++0x45, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x4, ++0x0, ++0x1, ++0x47, ++0x53, ++0x49, ++0x46, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x4, ++0x0, ++0xa, ++0x2, ++0x47, ++0x53, ++0x49, ++0x47, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x4, ++0x0, ++0xa, ++0x3, ++0x47, ++0x53, ++0x49, ++0x48, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x5, ++0x0, ++0x0, ++0x47, ++0x53, ++0x49, ++0x46, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x5, ++0x0, ++0x1, ++0x47, ++0x53, ++0x49, ++0x47, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x5, ++0x0, ++0xa, ++0x2, ++0x47, ++0x53, ++0x49, ++0x48, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x5, ++0x0, ++0xa, ++0x3, ++0x47, ++0x53, ++0x49, ++0x45, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x6, ++0x0, ++0x0, ++0x47, ++0x53, ++0x49, ++0x47, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x6, ++0x0, ++0x1, ++0x47, ++0x53, ++0x49, ++0x48, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x6, ++0x0, ++0xa, ++0x2, ++0x47, ++0x53, ++0x49, ++0x45, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x6, ++0x0, ++0xa, ++0x3, ++0x47, ++0x53, ++0x49, ++0x46, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x7, ++0x0, ++0x0, ++0x47, ++0x53, ++0x49, ++0x48, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x7, ++0x0, ++0x1, ++0x47, ++0x53, ++0x49, ++0x45, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x7, ++0x0, ++0xa, ++0x2, ++0x47, ++0x53, ++0x49, ++0x46, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x7, ++0x0, ++0xa, ++0x3, ++0x47, ++0x53, ++0x49, ++0x47, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x8, ++0x0, ++0x0, ++0x47, ++0x53, ++0x49, ++0x45, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x8, ++0x0, ++0x1, ++0x47, ++0x53, ++0x49, ++0x46, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x8, ++0x0, ++0xa, ++0x2, ++0x47, ++0x53, ++0x49, ++0x47, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x8, ++0x0, ++0xa, ++0x3, ++0x47, ++0x53, ++0x49, ++0x48, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x9, ++0x0, ++0x0, ++0x47, ++0x53, ++0x49, ++0x46, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x9, ++0x0, ++0x1, ++0x47, ++0x53, ++0x49, ++0x47, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x9, ++0x0, ++0xa, ++0x2, ++0x47, ++0x53, ++0x49, ++0x48, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x9, ++0x0, ++0xa, ++0x3, ++0x47, ++0x53, ++0x49, ++0x45, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0xa, ++0x0, ++0x0, ++0x47, ++0x53, ++0x49, ++0x47, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0xa, ++0x0, ++0x1, ++0x47, ++0x53, ++0x49, ++0x48, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0xa, ++0x0, ++0xa, ++0x2, ++0x47, ++0x53, ++0x49, ++0x45, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0xa, ++0x0, ++0xa, ++0x3, ++0x47, ++0x53, ++0x49, ++0x46, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0xb, ++0x0, ++0x0, ++0x47, ++0x53, ++0x49, ++0x48, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0xb, ++0x0, ++0x1, ++0x47, ++0x53, ++0x49, ++0x45, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0xb, ++0x0, ++0xa, ++0x2, ++0x47, ++0x53, ++0x49, ++0x46, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0xb, ++0x0, ++0xa, ++0x3, ++0x47, ++0x53, ++0x49, ++0x47, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0xc, ++0x0, ++0x0, ++0x47, ++0x53, ++0x49, ++0x45, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0xc, ++0x0, ++0x1, ++0x47, ++0x53, ++0x49, ++0x46, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0xc, ++0x0, ++0xa, ++0x2, ++0x47, ++0x53, ++0x49, ++0x47, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0xc, ++0x0, ++0xa, ++0x3, ++0x47, ++0x53, ++0x49, ++0x48, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0xd, ++0x0, ++0x0, ++0x47, ++0x53, ++0x49, ++0x46, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0xd, ++0x0, ++0x1, ++0x47, ++0x53, ++0x49, ++0x47, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0xd, ++0x0, ++0xa, ++0x2, ++0x47, ++0x53, ++0x49, ++0x48, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0xd, ++0x0, ++0xa, ++0x3, ++0x47, ++0x53, ++0x49, ++0x45, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0xe, ++0x0, ++0x0, ++0x47, ++0x53, ++0x49, ++0x47, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0xe, ++0x0, ++0x1, ++0x47, ++0x53, ++0x49, ++0x48, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0xe, ++0x0, ++0xa, ++0x2, ++0x47, ++0x53, ++0x49, ++0x45, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0xe, ++0x0, ++0xa, ++0x3, ++0x47, ++0x53, ++0x49, ++0x46, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0xf, ++0x0, ++0x0, ++0x47, ++0x53, ++0x49, ++0x48, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0xf, ++0x0, ++0x1, ++0x47, ++0x53, ++0x49, ++0x45, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0xf, ++0x0, ++0xa, ++0x2, ++0x47, ++0x53, ++0x49, ++0x46, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0xf, ++0x0, ++0xa, ++0x3, ++0x47, ++0x53, ++0x49, ++0x47, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x10, ++0x0, ++0x0, ++0x47, ++0x53, ++0x49, ++0x45, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x10, ++0x0, ++0x1, ++0x47, ++0x53, ++0x49, ++0x46, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x10, ++0x0, ++0xa, ++0x2, ++0x47, ++0x53, ++0x49, ++0x47, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x10, ++0x0, ++0xa, ++0x3, ++0x47, ++0x53, ++0x49, ++0x48, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x11, ++0x0, ++0x0, ++0x47, ++0x53, ++0x49, ++0x46, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x11, ++0x0, ++0x1, ++0x47, ++0x53, ++0x49, ++0x47, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x11, ++0x0, ++0xa, ++0x2, ++0x47, ++0x53, ++0x49, ++0x48, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x11, ++0x0, ++0xa, ++0x3, ++0x47, ++0x53, ++0x49, ++0x45, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x12, ++0x0, ++0x0, ++0x47, ++0x53, ++0x49, ++0x47, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x12, ++0x0, ++0x1, ++0x47, ++0x53, ++0x49, ++0x48, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x12, ++0x0, ++0xa, ++0x2, ++0x47, ++0x53, ++0x49, ++0x45, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x12, ++0x0, ++0xa, ++0x3, ++0x47, ++0x53, ++0x49, ++0x46, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x13, ++0x0, ++0x0, ++0x47, ++0x53, ++0x49, ++0x48, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x13, ++0x0, ++0x1, ++0x47, ++0x53, ++0x49, ++0x45, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x13, ++0x0, ++0xa, ++0x2, ++0x47, ++0x53, ++0x49, ++0x46, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x13, ++0x0, ++0xa, ++0x3, ++0x47, ++0x53, ++0x49, ++0x47, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x14, ++0x0, ++0x0, ++0x47, ++0x53, ++0x49, ++0x45, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x14, ++0x0, ++0x1, ++0x47, ++0x53, ++0x49, ++0x46, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x14, ++0x0, ++0xa, ++0x2, ++0x47, ++0x53, ++0x49, ++0x47, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x14, ++0x0, ++0xa, ++0x3, ++0x47, ++0x53, ++0x49, ++0x48, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x15, ++0x0, ++0x0, ++0x47, ++0x53, ++0x49, ++0x46, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x15, ++0x0, ++0x1, ++0x47, ++0x53, ++0x49, ++0x47, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x15, ++0x0, ++0xa, ++0x2, ++0x47, ++0x53, ++0x49, ++0x48, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x15, ++0x0, ++0xa, ++0x3, ++0x47, ++0x53, ++0x49, ++0x45, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x16, ++0x0, ++0x0, ++0x47, ++0x53, ++0x49, ++0x47, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x16, ++0x0, ++0x1, ++0x47, ++0x53, ++0x49, ++0x48, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x16, ++0x0, ++0xa, ++0x2, ++0x47, ++0x53, ++0x49, ++0x45, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x16, ++0x0, ++0xa, ++0x3, ++0x47, ++0x53, ++0x49, ++0x46, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x17, ++0x0, ++0x0, ++0x47, ++0x53, ++0x49, ++0x48, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x17, ++0x0, ++0x1, ++0x47, ++0x53, ++0x49, ++0x45, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x17, ++0x0, ++0xa, ++0x2, ++0x47, ++0x53, ++0x49, ++0x46, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x17, ++0x0, ++0xa, ++0x3, ++0x47, ++0x53, ++0x49, ++0x47, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x18, ++0x0, ++0x0, ++0x47, ++0x53, ++0x49, ++0x45, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x18, ++0x0, ++0x1, ++0x47, ++0x53, ++0x49, ++0x46, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x18, ++0x0, ++0xa, ++0x2, ++0x47, ++0x53, ++0x49, ++0x47, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x18, ++0x0, ++0xa, ++0x3, ++0x47, ++0x53, ++0x49, ++0x48, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x19, ++0x0, ++0x0, ++0x47, ++0x53, ++0x49, ++0x41, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x19, ++0x0, ++0x1, ++0x47, ++0x53, ++0x49, ++0x42, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x19, ++0x0, ++0xa, ++0x2, ++0x47, ++0x53, ++0x49, ++0x43, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x19, ++0x0, ++0xa, ++0x3, ++0x47, ++0x53, ++0x49, ++0x44, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x1a, ++0x0, ++0x0, ++0x47, ++0x53, ++0x49, ++0x41, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x1a, ++0x0, ++0x1, ++0x47, ++0x53, ++0x49, ++0x42, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x1a, ++0x0, ++0xa, ++0x2, ++0x47, ++0x53, ++0x49, ++0x43, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x1a, ++0x0, ++0xa, ++0x3, ++0x47, ++0x53, ++0x49, ++0x44, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x1b, ++0x0, ++0x0, ++0x47, ++0x53, ++0x49, ++0x41, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x1b, ++0x0, ++0x1, ++0x47, ++0x53, ++0x49, ++0x42, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x1b, ++0x0, ++0xa, ++0x2, ++0x47, ++0x53, ++0x49, ++0x43, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x1b, ++0x0, ++0xa, ++0x3, ++0x47, ++0x53, ++0x49, ++0x44, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x1c, ++0x0, ++0x0, ++0x47, ++0x53, ++0x49, ++0x41, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x1c, ++0x0, ++0x1, ++0x47, ++0x53, ++0x49, ++0x42, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x1c, ++0x0, ++0xa, ++0x2, ++0x47, ++0x53, ++0x49, ++0x43, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x1c, ++0x0, ++0xa, ++0x3, ++0x47, ++0x53, ++0x49, ++0x44, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x1d, ++0x0, ++0x0, ++0x47, ++0x53, ++0x49, ++0x41, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x1d, ++0x0, ++0x1, ++0x47, ++0x53, ++0x49, ++0x42, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x1d, ++0x0, ++0xa, ++0x2, ++0x47, ++0x53, ++0x49, ++0x43, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x1d, ++0x0, ++0xa, ++0x3, ++0x47, ++0x53, ++0x49, ++0x44, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x1e, ++0x0, ++0x0, ++0x47, ++0x53, ++0x49, ++0x45, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x1e, ++0x0, ++0x1, ++0x47, ++0x53, ++0x49, ++0x46, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x1e, ++0x0, ++0xa, ++0x2, ++0x47, ++0x53, ++0x49, ++0x47, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x1e, ++0x0, ++0xa, ++0x3, ++0x47, ++0x53, ++0x49, ++0x48, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x1f, ++0x0, ++0x0, ++0x47, ++0x53, ++0x49, ++0x41, ++0x0, ++0x12, ++0xd, ++0x4, ++0xc, ++0xff, ++0xff, ++0x1f, ++0x0, ++0x1, ++0x47, ++0x53, ++0x49, ++0x42, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x1f, ++0x0, ++0xa, ++0x2, ++0x47, ++0x53, ++0x49, ++0x43, ++0x0, ++0x12, ++0xe, ++0x4, ++0xc, ++0xff, ++0xff, ++0x1f, ++0x0, ++0xa, ++0x3, ++0x47, ++0x53, ++0x49, ++0x44, ++0x0, ++0x14, ++0x1a, ++0x5f, ++0x50, ++0x52, ++0x54, ++0x0, ++0xa0, ++0xc, ++0x93, ++0x50, ++0x49, ++0x43, ++0x46, ++0x0, ++0xa4, ++0x50, ++0x52, ++0x54, ++0x50, ++0xa1, ++0x6, ++0xa4, ++0x50, ++0x52, ++0x54, ++0x41, ++0x5b, ++0x81, ++0x3a, ++0x2f, ++0x3, ++0x50, ++0x43, ++0x49, ++0x30, ++0x49, ++0x53, ++0x41, ++0x5f, ++0x50, ++0x49, ++0x52, ++0x51, ++0x1, ++0x50, ++0x52, ++0x51, ++0x41, ++0x8, ++0x50, ++0x52, ++0x51, ++0x42, ++0x8, ++0x50, ++0x52, ++0x51, ++0x43, ++0x8, ++0x50, ++0x52, ++0x51, ++0x44, ++0x8, ++0x0, ++0x20, ++0x50, ++0x52, ++0x51, ++0x45, ++0x8, ++0x50, ++0x52, ++0x51, ++0x46, ++0x8, ++0x50, ++0x52, ++0x51, ++0x47, ++0x8, ++0x50, ++0x52, ++0x51, ++0x48, ++0x8, ++0x14, ++0x13, ++0x49, ++0x51, ++0x53, ++0x54, ++0x1, ++0xa0, ++0x9, ++0x7b, ++0xa, ++0x80, ++0x68, ++0x0, ++0xa4, ++0xa, ++0x9, ++0xa4, ++0xa, ++0xb, ++0x14, ++0x34, ++0x49, ++0x51, ++0x43, ++0x52, ++0x1, ++0x8, ++0x50, ++0x52, ++0x52, ++0x30, ++0x11, ++0xe, ++0xa, ++0xb, ++0x89, ++0x6, ++0x0, ++0x9, ++0x1, ++0x0, ++0x0, ++0x0, ++0x0, ++0x79, ++0x0, ++0x8a, ++0x50, ++0x52, ++0x52, ++0x30, ++0xa, ++0x5, ++0x50, ++0x52, ++0x52, ++0x49, ++0x70, ++0x7b, ++0x68, ++0xa, ++0xf, ++0x0, ++0x50, ++0x52, ++0x52, ++0x49, ++0xa4, ++0x50, ++0x52, ++0x52, ++0x30, ++0x5b, ++0x82, ++0x4c, ++0x7, ++0x4c, ++0x4e, ++0x4b, ++0x41, ++0x8, ++0x5f, ++0x48, ++0x49, ++0x44, ++0xc, ++0x41, ++0xd0, ++0xc, ++0xf, ++0x8, ++0x5f, ++0x55, ++0x49, ++0x44, ++0x0, ++0x8, ++0x5f, ++0x50, ++0x52, ++0x53, ++0x11, ++0x16, ++0xa, ++0x13, ++0x89, ++0xe, ++0x0, ++0x9, ++0x3, ++0x5, ++0x0, ++0x0, ++0x0, ++0xa, ++0x0, ++0x0, ++0x0, ++0xb, ++0x0, ++0x0, ++0x0, ++0x79, ++0x0, ++0x14, ++0xf, ++0x5f, ++0x53, ++0x54, ++0x41, ++0x0, ++0xa4, ++0x49, ++0x51, ++0x53, ++0x54, ++0x50, ++0x52, ++0x51, ++0x41, ++0x14, ++0x11, ++0x5f, ++0x44, ++0x49, ++0x53, ++0x0, ++0x7d, ++0x50, ++0x52, ++0x51, ++0x41, ++0xa, ++0x80, ++0x50, ++0x52, ++0x51, ++0x41, ++0x14, ++0xf, ++0x5f, ++0x43, ++0x52, ++0x53, ++0x0, ++0xa4, ++0x49, ++0x51, ++0x43, ++0x52, ++0x50, ++0x52, ++0x51, ++0x41, ++0x14, ++0x17, ++0x5f, ++0x53, ++0x52, ++0x53, ++0x1, ++0x8a, ++0x68, ++0xa, ++0x5, ++0x50, ++0x52, ++0x52, ++0x49, ++0x70, ++0x50, ++0x52, ++0x52, ++0x49, ++0x50, ++0x52, ++0x51, ++0x41, ++0x5b, ++0x82, ++0x4c, ++0x7, ++0x4c, ++0x4e, ++0x4b, ++0x42, ++0x8, ++0x5f, ++0x48, ++0x49, ++0x44, ++0xc, ++0x41, ++0xd0, ++0xc, ++0xf, ++0x8, ++0x5f, ++0x55, ++0x49, ++0x44, ++0x1, ++0x8, ++0x5f, ++0x50, ++0x52, ++0x53, ++0x11, ++0x16, ++0xa, ++0x13, ++0x89, ++0xe, ++0x0, ++0x9, ++0x3, ++0x5, ++0x0, ++0x0, ++0x0, ++0xa, ++0x0, ++0x0, ++0x0, ++0xb, ++0x0, ++0x0, ++0x0, ++0x79, ++0x0, ++0x14, ++0xf, ++0x5f, ++0x53, ++0x54, ++0x41, ++0x0, ++0xa4, ++0x49, ++0x51, ++0x53, ++0x54, ++0x50, ++0x52, ++0x51, ++0x42, ++0x14, ++0x11, ++0x5f, ++0x44, ++0x49, ++0x53, ++0x0, ++0x7d, ++0x50, ++0x52, ++0x51, ++0x42, ++0xa, ++0x80, ++0x50, ++0x52, ++0x51, ++0x42, ++0x14, ++0xf, ++0x5f, ++0x43, ++0x52, ++0x53, ++0x0, ++0xa4, ++0x49, ++0x51, ++0x43, ++0x52, ++0x50, ++0x52, ++0x51, ++0x42, ++0x14, ++0x17, ++0x5f, ++0x53, ++0x52, ++0x53, ++0x1, ++0x8a, ++0x68, ++0xa, ++0x5, ++0x50, ++0x52, ++0x52, ++0x49, ++0x70, ++0x50, ++0x52, ++0x52, ++0x49, ++0x50, ++0x52, ++0x51, ++0x42, ++0x5b, ++0x82, ++0x4d, ++0x7, ++0x4c, ++0x4e, ++0x4b, ++0x43, ++0x8, ++0x5f, ++0x48, ++0x49, ++0x44, ++0xc, ++0x41, ++0xd0, ++0xc, ++0xf, ++0x8, ++0x5f, ++0x55, ++0x49, ++0x44, ++0xa, ++0x2, ++0x8, ++0x5f, ++0x50, ++0x52, ++0x53, ++0x11, ++0x16, ++0xa, ++0x13, ++0x89, ++0xe, ++0x0, ++0x9, ++0x3, ++0x5, ++0x0, ++0x0, ++0x0, ++0xa, ++0x0, ++0x0, ++0x0, ++0xb, ++0x0, ++0x0, ++0x0, ++0x79, ++0x0, ++0x14, ++0xf, ++0x5f, ++0x53, ++0x54, ++0x41, ++0x0, ++0xa4, ++0x49, ++0x51, ++0x53, ++0x54, ++0x50, ++0x52, ++0x51, ++0x43, ++0x14, ++0x11, ++0x5f, ++0x44, ++0x49, ++0x53, ++0x0, ++0x7d, ++0x50, ++0x52, ++0x51, ++0x43, ++0xa, ++0x80, ++0x50, ++0x52, ++0x51, ++0x43, ++0x14, ++0xf, ++0x5f, ++0x43, ++0x52, ++0x53, ++0x0, ++0xa4, ++0x49, ++0x51, ++0x43, ++0x52, ++0x50, ++0x52, ++0x51, ++0x43, ++0x14, ++0x17, ++0x5f, ++0x53, ++0x52, ++0x53, ++0x1, ++0x8a, ++0x68, ++0xa, ++0x5, ++0x50, ++0x52, ++0x52, ++0x49, ++0x70, ++0x50, ++0x52, ++0x52, ++0x49, ++0x50, ++0x52, ++0x51, ++0x43, ++0x5b, ++0x82, ++0x4d, ++0x7, ++0x4c, ++0x4e, ++0x4b, ++0x44, ++0x8, ++0x5f, ++0x48, ++0x49, ++0x44, ++0xc, ++0x41, ++0xd0, ++0xc, ++0xf, ++0x8, ++0x5f, ++0x55, ++0x49, ++0x44, ++0xa, ++0x3, ++0x8, ++0x5f, ++0x50, ++0x52, ++0x53, ++0x11, ++0x16, ++0xa, ++0x13, ++0x89, ++0xe, ++0x0, ++0x9, ++0x3, ++0x5, ++0x0, ++0x0, ++0x0, ++0xa, ++0x0, ++0x0, ++0x0, ++0xb, ++0x0, ++0x0, ++0x0, ++0x79, ++0x0, ++0x14, ++0xf, ++0x5f, ++0x53, ++0x54, ++0x41, ++0x0, ++0xa4, ++0x49, ++0x51, ++0x53, ++0x54, ++0x50, ++0x52, ++0x51, ++0x44, ++0x14, ++0x11, ++0x5f, ++0x44, ++0x49, ++0x53, ++0x0, ++0x7d, ++0x50, ++0x52, ++0x51, ++0x44, ++0xa, ++0x80, ++0x50, ++0x52, ++0x51, ++0x44, ++0x14, ++0xf, ++0x5f, ++0x43, ++0x52, ++0x53, ++0x0, ++0xa4, ++0x49, ++0x51, ++0x43, ++0x52, ++0x50, ++0x52, ++0x51, ++0x44, ++0x14, ++0x17, ++0x5f, ++0x53, ++0x52, ++0x53, ++0x1, ++0x8a, ++0x68, ++0xa, ++0x5, ++0x50, ++0x52, ++0x52, ++0x49, ++0x70, ++0x50, ++0x52, ++0x52, ++0x49, ++0x50, ++0x52, ++0x51, ++0x44, ++0x5b, ++0x82, ++0x4d, ++0x7, ++0x4c, ++0x4e, ++0x4b, ++0x45, ++0x8, ++0x5f, ++0x48, ++0x49, ++0x44, ++0xc, ++0x41, ++0xd0, ++0xc, ++0xf, ++0x8, ++0x5f, ++0x55, ++0x49, ++0x44, ++0xa, ++0x4, ++0x8, ++0x5f, ++0x50, ++0x52, ++0x53, ++0x11, ++0x16, ++0xa, ++0x13, ++0x89, ++0xe, ++0x0, ++0x9, ++0x3, ++0x5, ++0x0, ++0x0, ++0x0, ++0xa, ++0x0, ++0x0, ++0x0, ++0xb, ++0x0, ++0x0, ++0x0, ++0x79, ++0x0, ++0x14, ++0xf, ++0x5f, ++0x53, ++0x54, ++0x41, ++0x0, ++0xa4, ++0x49, ++0x51, ++0x53, ++0x54, ++0x50, ++0x52, ++0x51, ++0x45, ++0x14, ++0x11, ++0x5f, ++0x44, ++0x49, ++0x53, ++0x0, ++0x7d, ++0x50, ++0x52, ++0x51, ++0x45, ++0xa, ++0x80, ++0x50, ++0x52, ++0x51, ++0x45, ++0x14, ++0xf, ++0x5f, ++0x43, ++0x52, ++0x53, ++0x0, ++0xa4, ++0x49, ++0x51, ++0x43, ++0x52, ++0x50, ++0x52, ++0x51, ++0x45, ++0x14, ++0x17, ++0x5f, ++0x53, ++0x52, ++0x53, ++0x1, ++0x8a, ++0x68, ++0xa, ++0x5, ++0x50, ++0x52, ++0x52, ++0x49, ++0x70, ++0x50, ++0x52, ++0x52, ++0x49, ++0x50, ++0x52, ++0x51, ++0x45, ++0x5b, ++0x82, ++0x4d, ++0x7, ++0x4c, ++0x4e, ++0x4b, ++0x46, ++0x8, ++0x5f, ++0x48, ++0x49, ++0x44, ++0xc, ++0x41, ++0xd0, ++0xc, ++0xf, ++0x8, ++0x5f, ++0x55, ++0x49, ++0x44, ++0xa, ++0x5, ++0x8, ++0x5f, ++0x50, ++0x52, ++0x53, ++0x11, ++0x16, ++0xa, ++0x13, ++0x89, ++0xe, ++0x0, ++0x9, ++0x3, ++0x5, ++0x0, ++0x0, ++0x0, ++0xa, ++0x0, ++0x0, ++0x0, ++0xb, ++0x0, ++0x0, ++0x0, ++0x79, ++0x0, ++0x14, ++0xf, ++0x5f, ++0x53, ++0x54, ++0x41, ++0x0, ++0xa4, ++0x49, ++0x51, ++0x53, ++0x54, ++0x50, ++0x52, ++0x51, ++0x46, ++0x14, ++0x11, ++0x5f, ++0x44, ++0x49, ++0x53, ++0x0, ++0x7d, ++0x50, ++0x52, ++0x51, ++0x46, ++0xa, ++0x80, ++0x50, ++0x52, ++0x51, ++0x46, ++0x14, ++0xf, ++0x5f, ++0x43, ++0x52, ++0x53, ++0x0, ++0xa4, ++0x49, ++0x51, ++0x43, ++0x52, ++0x50, ++0x52, ++0x51, ++0x46, ++0x14, ++0x17, ++0x5f, ++0x53, ++0x52, ++0x53, ++0x1, ++0x8a, ++0x68, ++0xa, ++0x5, ++0x50, ++0x52, ++0x52, ++0x49, ++0x70, ++0x50, ++0x52, ++0x52, ++0x49, ++0x50, ++0x52, ++0x51, ++0x46, ++0x5b, ++0x82, ++0x4d, ++0x7, ++0x4c, ++0x4e, ++0x4b, ++0x47, ++0x8, ++0x5f, ++0x48, ++0x49, ++0x44, ++0xc, ++0x41, ++0xd0, ++0xc, ++0xf, ++0x8, ++0x5f, ++0x55, ++0x49, ++0x44, ++0xa, ++0x6, ++0x8, ++0x5f, ++0x50, ++0x52, ++0x53, ++0x11, ++0x16, ++0xa, ++0x13, ++0x89, ++0xe, ++0x0, ++0x9, ++0x3, ++0x5, ++0x0, ++0x0, ++0x0, ++0xa, ++0x0, ++0x0, ++0x0, ++0xb, ++0x0, ++0x0, ++0x0, ++0x79, ++0x0, ++0x14, ++0xf, ++0x5f, ++0x53, ++0x54, ++0x41, ++0x0, ++0xa4, ++0x49, ++0x51, ++0x53, ++0x54, ++0x50, ++0x52, ++0x51, ++0x47, ++0x14, ++0x11, ++0x5f, ++0x44, ++0x49, ++0x53, ++0x0, ++0x7d, ++0x50, ++0x52, ++0x51, ++0x47, ++0xa, ++0x80, ++0x50, ++0x52, ++0x51, ++0x47, ++0x14, ++0xf, ++0x5f, ++0x43, ++0x52, ++0x53, ++0x0, ++0xa4, ++0x49, ++0x51, ++0x43, ++0x52, ++0x50, ++0x52, ++0x51, ++0x47, ++0x14, ++0x17, ++0x5f, ++0x53, ++0x52, ++0x53, ++0x1, ++0x8a, ++0x68, ++0xa, ++0x5, ++0x50, ++0x52, ++0x52, ++0x49, ++0x70, ++0x50, ++0x52, ++0x52, ++0x49, ++0x50, ++0x52, ++0x51, ++0x47, ++0x5b, ++0x82, ++0x4d, ++0x7, ++0x4c, ++0x4e, ++0x4b, ++0x48, ++0x8, ++0x5f, ++0x48, ++0x49, ++0x44, ++0xc, ++0x41, ++0xd0, ++0xc, ++0xf, ++0x8, ++0x5f, ++0x55, ++0x49, ++0x44, ++0xa, ++0x7, ++0x8, ++0x5f, ++0x50, ++0x52, ++0x53, ++0x11, ++0x16, ++0xa, ++0x13, ++0x89, ++0xe, ++0x0, ++0x9, ++0x3, ++0x5, ++0x0, ++0x0, ++0x0, ++0xa, ++0x0, ++0x0, ++0x0, ++0xb, ++0x0, ++0x0, ++0x0, ++0x79, ++0x0, ++0x14, ++0xf, ++0x5f, ++0x53, ++0x54, ++0x41, ++0x0, ++0xa4, ++0x49, ++0x51, ++0x53, ++0x54, ++0x50, ++0x52, ++0x51, ++0x48, ++0x14, ++0x11, ++0x5f, ++0x44, ++0x49, ++0x53, ++0x0, ++0x7d, ++0x50, ++0x52, ++0x51, ++0x48, ++0xa, ++0x80, ++0x50, ++0x52, ++0x51, ++0x48, ++0x14, ++0xf, ++0x5f, ++0x43, ++0x52, ++0x53, ++0x0, ++0xa4, ++0x49, ++0x51, ++0x43, ++0x52, ++0x50, ++0x52, ++0x51, ++0x48, ++0x14, ++0x17, ++0x5f, ++0x53, ++0x52, ++0x53, ++0x1, ++0x8a, ++0x68, ++0xa, ++0x5, ++0x50, ++0x52, ++0x52, ++0x49, ++0x70, ++0x50, ++0x52, ++0x52, ++0x49, ++0x50, ++0x52, ++0x51, ++0x48, ++0x5b, ++0x82, ++0x45, ++0x4, ++0x47, ++0x53, ++0x49, ++0x41, ++0x8, ++0x5f, ++0x48, ++0x49, ++0x44, ++0xc, ++0x41, ++0xd0, ++0xc, ++0xf, ++0x8, ++0x5f, ++0x55, ++0x49, ++0x44, ++0x0, ++0x8, ++0x5f, ++0x50, ++0x52, ++0x53, ++0x11, ++0xe, ++0xa, ++0xb, ++0x89, ++0x6, ++0x0, ++0x9, ++0x1, ++0x10, ++0x0, ++0x0, ++0x0, ++0x79, ++0x0, ++0x8, ++0x5f, ++0x43, ++0x52, ++0x53, ++0x11, ++0xe, ++0xa, ++0xb, ++0x89, ++0x6, ++0x0, ++0x9, ++0x1, ++0x10, ++0x0, ++0x0, ++0x0, ++0x79, ++0x0, ++0x14, ++0x6, ++0x5f, ++0x53, ++0x52, ++0x53, ++0x1, ++0x5b, ++0x82, ++0x45, ++0x4, ++0x47, ++0x53, ++0x49, ++0x42, ++0x8, ++0x5f, ++0x48, ++0x49, ++0x44, ++0xc, ++0x41, ++0xd0, ++0xc, ++0xf, ++0x8, ++0x5f, ++0x55, ++0x49, ++0x44, ++0x0, ++0x8, ++0x5f, ++0x50, ++0x52, ++0x53, ++0x11, ++0xe, ++0xa, ++0xb, ++0x89, ++0x6, ++0x0, ++0x9, ++0x1, ++0x11, ++0x0, ++0x0, ++0x0, ++0x79, ++0x0, ++0x8, ++0x5f, ++0x43, ++0x52, ++0x53, ++0x11, ++0xe, ++0xa, ++0xb, ++0x89, ++0x6, ++0x0, ++0x9, ++0x1, ++0x11, ++0x0, ++0x0, ++0x0, ++0x79, ++0x0, ++0x14, ++0x6, ++0x5f, ++0x53, ++0x52, ++0x53, ++0x1, ++0x5b, ++0x82, ++0x45, ++0x4, ++0x47, ++0x53, ++0x49, ++0x43, ++0x8, ++0x5f, ++0x48, ++0x49, ++0x44, ++0xc, ++0x41, ++0xd0, ++0xc, ++0xf, ++0x8, ++0x5f, ++0x55, ++0x49, ++0x44, ++0x0, ++0x8, ++0x5f, ++0x50, ++0x52, ++0x53, ++0x11, ++0xe, ++0xa, ++0xb, ++0x89, ++0x6, ++0x0, ++0x9, ++0x1, ++0x12, ++0x0, ++0x0, ++0x0, ++0x79, ++0x0, ++0x8, ++0x5f, ++0x43, ++0x52, ++0x53, ++0x11, ++0xe, ++0xa, ++0xb, ++0x89, ++0x6, ++0x0, ++0x9, ++0x1, ++0x12, ++0x0, ++0x0, ++0x0, ++0x79, ++0x0, ++0x14, ++0x6, ++0x5f, ++0x53, ++0x52, ++0x53, ++0x1, ++0x5b, ++0x82, ++0x45, ++0x4, ++0x47, ++0x53, ++0x49, ++0x44, ++0x8, ++0x5f, ++0x48, ++0x49, ++0x44, ++0xc, ++0x41, ++0xd0, ++0xc, ++0xf, ++0x8, ++0x5f, ++0x55, ++0x49, ++0x44, ++0x0, ++0x8, ++0x5f, ++0x50, ++0x52, ++0x53, ++0x11, ++0xe, ++0xa, ++0xb, ++0x89, ++0x6, ++0x0, ++0x9, ++0x1, ++0x13, ++0x0, ++0x0, ++0x0, ++0x79, ++0x0, ++0x8, ++0x5f, ++0x43, ++0x52, ++0x53, ++0x11, ++0xe, ++0xa, ++0xb, ++0x89, ++0x6, ++0x0, ++0x9, ++0x1, ++0x13, ++0x0, ++0x0, ++0x0, ++0x79, ++0x0, ++0x14, ++0x6, ++0x5f, ++0x53, ++0x52, ++0x53, ++0x1, ++0x5b, ++0x82, ++0x45, ++0x4, ++0x47, ++0x53, ++0x49, ++0x45, ++0x8, ++0x5f, ++0x48, ++0x49, ++0x44, ++0xc, ++0x41, ++0xd0, ++0xc, ++0xf, ++0x8, ++0x5f, ++0x55, ++0x49, ++0x44, ++0x0, ++0x8, ++0x5f, ++0x50, ++0x52, ++0x53, ++0x11, ++0xe, ++0xa, ++0xb, ++0x89, ++0x6, ++0x0, ++0x9, ++0x1, ++0x14, ++0x0, ++0x0, ++0x0, ++0x79, ++0x0, ++0x8, ++0x5f, ++0x43, ++0x52, ++0x53, ++0x11, ++0xe, ++0xa, ++0xb, ++0x89, ++0x6, ++0x0, ++0x9, ++0x1, ++0x14, ++0x0, ++0x0, ++0x0, ++0x79, ++0x0, ++0x14, ++0x6, ++0x5f, ++0x53, ++0x52, ++0x53, ++0x1, ++0x5b, ++0x82, ++0x45, ++0x4, ++0x47, ++0x53, ++0x49, ++0x46, ++0x8, ++0x5f, ++0x48, ++0x49, ++0x44, ++0xc, ++0x41, ++0xd0, ++0xc, ++0xf, ++0x8, ++0x5f, ++0x55, ++0x49, ++0x44, ++0x0, ++0x8, ++0x5f, ++0x50, ++0x52, ++0x53, ++0x11, ++0xe, ++0xa, ++0xb, ++0x89, ++0x6, ++0x0, ++0x9, ++0x1, ++0x15, ++0x0, ++0x0, ++0x0, ++0x79, ++0x0, ++0x8, ++0x5f, ++0x43, ++0x52, ++0x53, ++0x11, ++0xe, ++0xa, ++0xb, ++0x89, ++0x6, ++0x0, ++0x9, ++0x1, ++0x15, ++0x0, ++0x0, ++0x0, ++0x79, ++0x0, ++0x14, ++0x6, ++0x5f, ++0x53, ++0x52, ++0x53, ++0x1, ++0x5b, ++0x82, ++0x45, ++0x4, ++0x47, ++0x53, ++0x49, ++0x47, ++0x8, ++0x5f, ++0x48, ++0x49, ++0x44, ++0xc, ++0x41, ++0xd0, ++0xc, ++0xf, ++0x8, ++0x5f, ++0x55, ++0x49, ++0x44, ++0x0, ++0x8, ++0x5f, ++0x50, ++0x52, ++0x53, ++0x11, ++0xe, ++0xa, ++0xb, ++0x89, ++0x6, ++0x0, ++0x9, ++0x1, ++0x16, ++0x0, ++0x0, ++0x0, ++0x79, ++0x0, ++0x8, ++0x5f, ++0x43, ++0x52, ++0x53, ++0x11, ++0xe, ++0xa, ++0xb, ++0x89, ++0x6, ++0x0, ++0x9, ++0x1, ++0x16, ++0x0, ++0x0, ++0x0, ++0x79, ++0x0, ++0x14, ++0x6, ++0x5f, ++0x53, ++0x52, ++0x53, ++0x1, ++0x5b, ++0x82, ++0x45, ++0x4, ++0x47, ++0x53, ++0x49, ++0x48, ++0x8, ++0x5f, ++0x48, ++0x49, ++0x44, ++0xc, ++0x41, ++0xd0, ++0xc, ++0xf, ++0x8, ++0x5f, ++0x55, ++0x49, ++0x44, ++0x0, ++0x8, ++0x5f, ++0x50, ++0x52, ++0x53, ++0x11, ++0xe, ++0xa, ++0xb, ++0x89, ++0x6, ++0x0, ++0x9, ++0x1, ++0x17, ++0x0, ++0x0, ++0x0, ++0x79, ++0x0, ++0x8, ++0x5f, ++0x43, ++0x52, ++0x53, ++0x11, ++0xe, ++0xa, ++0xb, ++0x89, ++0x6, ++0x0, ++0x9, ++0x1, ++0x17, ++0x0, ++0x0, ++0x0, ++0x79, ++0x0, ++0x14, ++0x6, ++0x5f, ++0x53, ++0x52, ++0x53, ++0x1, ++0x10, ++0x47, ++0xe, ++0x5f, ++0x53, ++0x42, ++0x5f, ++0x14, ++0x35, ++0x43, ++0x50, ++0x4d, ++0x41, ++0x1, ++0x70, ++0x83, ++0x88, ++0x43, ++0x50, ++0x4f, ++0x4e, ++0x68, ++0x0, ++0x60, ++0x70, ++0x11, ++0xb, ++0xa, ++0x8, ++0x0, ++0x8, ++0x0, ++0x0, ++0x0, ++0x0, ++0x0, ++0x0, ++0x61, ++0x70, ++0x68, ++0x88, ++0x61, ++0xa, ++0x2, ++0x0, ++0x70, ++0x68, ++0x88, ++0x61, ++0xa, ++0x3, ++0x0, ++0x70, ++0x60, ++0x88, ++0x61, ++0xa, ++0x4, ++0x0, ++0xa4, ++0x61, ++0x14, ++0x1a, ++0x43, ++0x50, ++0x53, ++0x54, ++0x1, ++0x70, ++0x83, ++0x88, ++0x43, ++0x50, ++0x4f, ++0x4e, ++0x68, ++0x0, ++0x60, ++0xa0, ++0x5, ++0x60, ++0xa4, ++0xa, ++0xf, ++0xa1, ++0x3, ++0xa4, ++0x0, ++0x14, ++0xa, ++0x43, ++0x50, ++0x45, ++0x4a, ++0x2, ++0x5b, ++0x22, ++0xa, ++0xc8, ++0x5b, ++0x80, ++0x50, ++0x52, ++0x53, ++0x54, ++0x1, ++0xb, ++0x0, ++0xaf, ++0xa, ++0x20, ++0x5b, ++0x81, ++0xc, ++0x50, ++0x52, ++0x53, ++0x54, ++0x1, ++0x50, ++0x52, ++0x53, ++0x5f, ++0x40, ++0x10, ++0x14, ++0x4a, ++0x6, ++0x50, ++0x52, ++0x53, ++0x43, ++0x0, ++0x70, ++0x50, ++0x52, ++0x53, ++0x5f, ++0x65, ++0x70, ++0x0, ++0x62, ++0x70, ++0x0, ++0x60, ++0xa2, ++0x46, ++0x5, ++0x95, ++0x60, ++0x87, ++0x43, ++0x50, ++0x4f, ++0x4e, ++0x70, ++0x83, ++0x88, ++0x43, ++0x50, ++0x4f, ++0x4e, ++0x60, ++0x0, ++0x61, ++0xa0, ++0xa, ++0x7b, ++0x60, ++0xa, ++0x7, ++0x0, ++0x7a, ++0x62, ++0x1, ++0x62, ++0xa1, ++0xc, ++0x70, ++0x83, ++0x88, ++0x65, ++0x7a, ++0x60, ++0xa, ++0x3, ++0x0, ++0x0, ++0x62, ++0x70, ++0x7b, ++0x62, ++0x1, ++0x0, ++0x63, ++0xa0, ++0x22, ++0x92, ++0x93, ++0x61, ++0x63, ++0x70, ++0x63, ++0x88, ++0x43, ++0x50, ++0x4f, ++0x4e, ++0x60, ++0x0, ++0xa0, ++0xa, ++0x93, ++0x63, ++0x1, ++0x4e, ++0x54, ++0x46, ++0x59, ++0x60, ++0x1, ++0xa1, ++0x8, ++0x4e, ++0x54, ++0x46, ++0x59, ++0x60, ++0xa, ++0x3, ++0x75, ++0x60, ++0x10, ++0x4f, ++0x8, ++0x5f, ++0x47, ++0x50, ++0x45, ++0x8, ++0x5f, ++0x48, ++0x49, ++0x44, ++0xd, ++0x41, ++0x43, ++0x50, ++0x49, ++0x30, ++0x30, ++0x30, ++0x36, ++0x0, ++0x14, ++0x6, ++0x5f, ++0x4c, ++0x30, ++0x30, ++0x0, ++0x14, ++0x10, ++0x5f, ++0x4c, ++0x30, ++0x31, ++0x0, ++0x5c, ++0x2e, ++0x5f, ++0x53, ++0x42, ++0x5f, ++0x50, ++0x52, ++0x53, ++0x43, ++0x14, ++0x6, ++0x5f, ++0x4c, ++0x30, ++0x32, ++0x0, ++0x14, ++0x6, ++0x5f, ++0x4c, ++0x30, ++0x33, ++0x0, ++0x14, ++0x6, ++0x5f, ++0x4c, ++0x30, ++0x34, ++0x0, ++0x14, ++0x6, ++0x5f, ++0x4c, ++0x30, ++0x35, ++0x0, ++0x14, ++0x6, ++0x5f, ++0x4c, ++0x30, ++0x36, ++0x0, ++0x14, ++0x6, ++0x5f, ++0x4c, ++0x30, ++0x37, ++0x0, ++0x14, ++0x6, ++0x5f, ++0x4c, ++0x30, ++0x38, ++0x0, ++0x14, ++0x6, ++0x5f, ++0x4c, ++0x30, ++0x39, ++0x0, ++0x14, ++0x6, ++0x5f, ++0x4c, ++0x30, ++0x41, ++0x0, ++0x14, ++0x6, ++0x5f, ++0x4c, ++0x30, ++0x42, ++0x0, ++0x14, ++0x6, ++0x5f, ++0x4c, ++0x30, ++0x43, ++0x0, ++0x14, ++0x6, ++0x5f, ++0x4c, ++0x30, ++0x44, ++0x0, ++0x14, ++0x6, ++0x5f, ++0x4c, ++0x30, ++0x45, ++0x0, ++0x14, ++0x6, ++0x5f, ++0x4c, ++0x30, ++0x46, ++0x0 ++}; +diff --git a/hw/i386/ssdt-misc.hex.generated b/hw/i386/ssdt-misc.hex.generated +new file mode 100644 +index 0000000..55e3bd2 +--- /dev/null ++++ b/hw/i386/ssdt-misc.hex.generated +@@ -0,0 +1,386 @@ ++static unsigned char acpi_pci64_length[] = { ++0x6f ++}; ++static unsigned char acpi_s4_pkg[] = { ++0x8f ++}; ++static unsigned char acpi_s3_name[] = { ++0x7c ++}; ++static unsigned char acpi_pci32_start[] = { ++0x2f ++}; ++static unsigned char acpi_pci64_valid[] = { ++0x43 ++}; ++static unsigned char ssdp_misc_aml[] = { ++0x53, ++0x53, ++0x44, ++0x54, ++0x62, ++0x1, ++0x0, ++0x0, ++0x1, ++0x76, ++0x42, ++0x58, ++0x50, ++0x43, ++0x0, ++0x0, ++0x42, ++0x58, ++0x53, ++0x53, ++0x44, ++0x54, ++0x53, ++0x55, ++0x1, ++0x0, ++0x0, ++0x0, ++0x49, ++0x4e, ++0x54, ++0x4c, ++0x23, ++0x8, ++0x13, ++0x20, ++0x10, ++0x42, ++0x5, ++0x5c, ++0x0, ++0x8, ++0x50, ++0x30, ++0x53, ++0x5f, ++0xc, ++0x78, ++0x56, ++0x34, ++0x12, ++0x8, ++0x50, ++0x30, ++0x45, ++0x5f, ++0xc, ++0x78, ++0x56, ++0x34, ++0x12, ++0x8, ++0x50, ++0x31, ++0x56, ++0x5f, ++0xa, ++0x12, ++0x8, ++0x50, ++0x31, ++0x53, ++0x5f, ++0x11, ++0xb, ++0xa, ++0x8, ++0x0, ++0x0, ++0x0, ++0x0, ++0x0, ++0x0, ++0x0, ++0x0, ++0x8, ++0x50, ++0x31, ++0x45, ++0x5f, ++0x11, ++0xb, ++0xa, ++0x8, ++0x0, ++0x0, ++0x0, ++0x0, ++0x0, ++0x0, ++0x0, ++0x0, ++0x8, ++0x50, ++0x31, ++0x4c, ++0x5f, ++0x11, ++0xb, ++0xa, ++0x8, ++0x0, ++0x0, ++0x0, ++0x0, ++0x0, ++0x0, ++0x0, ++0x0, ++0x10, ++0x29, ++0x5c, ++0x0, ++0x8, ++0x5f, ++0x53, ++0x33, ++0x5f, ++0x12, ++0x6, ++0x4, ++0x1, ++0x1, ++0x0, ++0x0, ++0x8, ++0x5f, ++0x53, ++0x34, ++0x5f, ++0x12, ++0x8, ++0x4, ++0xa, ++0x2, ++0xa, ++0x2, ++0x0, ++0x0, ++0x8, ++0x5f, ++0x53, ++0x35, ++0x5f, ++0x12, ++0x6, ++0x4, ++0x0, ++0x0, ++0x0, ++0x0, ++0x10, ++0x40, ++0xc, ++0x5c, ++0x2f, ++0x3, ++0x5f, ++0x53, ++0x42, ++0x5f, ++0x50, ++0x43, ++0x49, ++0x30, ++0x49, ++0x53, ++0x41, ++0x5f, ++0x5b, ++0x82, ++0x4d, ++0xa, ++0x50, ++0x45, ++0x56, ++0x54, ++0x8, ++0x5f, ++0x48, ++0x49, ++0x44, ++0xd, ++0x51, ++0x45, ++0x4d, ++0x55, ++0x30, ++0x30, ++0x30, ++0x31, ++0x0, ++0x8, ++0x50, ++0x45, ++0x53, ++0x54, ++0xb, ++0xff, ++0xff, ++0x5b, ++0x80, ++0x50, ++0x45, ++0x4f, ++0x52, ++0x1, ++0x50, ++0x45, ++0x53, ++0x54, ++0x1, ++0x5b, ++0x81, ++0xb, ++0x50, ++0x45, ++0x4f, ++0x52, ++0x1, ++0x50, ++0x45, ++0x50, ++0x54, ++0x8, ++0x14, ++0x18, ++0x5f, ++0x53, ++0x54, ++0x41, ++0x0, ++0x70, ++0x50, ++0x45, ++0x53, ++0x54, ++0x60, ++0xa0, ++0x6, ++0x93, ++0x60, ++0x0, ++0xa4, ++0x0, ++0xa1, ++0x4, ++0xa4, ++0xa, ++0xf, ++0x14, ++0xe, ++0x52, ++0x44, ++0x50, ++0x54, ++0x0, ++0x70, ++0x50, ++0x45, ++0x50, ++0x54, ++0x60, ++0xa4, ++0x60, ++0x14, ++0xc, ++0x57, ++0x52, ++0x50, ++0x54, ++0x1, ++0x70, ++0x68, ++0x50, ++0x45, ++0x50, ++0x54, ++0x8, ++0x5f, ++0x43, ++0x52, ++0x53, ++0x11, ++0xd, ++0xa, ++0xa, ++0x47, ++0x1, ++0x0, ++0x0, ++0x0, ++0x0, ++0x1, ++0x1, ++0x79, ++0x0, ++0x8b, ++0x5f, ++0x43, ++0x52, ++0x53, ++0xa, ++0x2, ++0x49, ++0x4f, ++0x4d, ++0x4e, ++0x8b, ++0x5f, ++0x43, ++0x52, ++0x53, ++0xa, ++0x4, ++0x49, ++0x4f, ++0x4d, ++0x58, ++0x14, ++0x18, ++0x5f, ++0x49, ++0x4e, ++0x49, ++0x0, ++0x70, ++0x50, ++0x45, ++0x53, ++0x54, ++0x49, ++0x4f, ++0x4d, ++0x4e, ++0x70, ++0x50, ++0x45, ++0x53, ++0x54, ++0x49, ++0x4f, ++0x4d, ++0x58 ++}; ++static unsigned char ssdt_isa_pest[] = { ++0xd0 ++}; ++static unsigned char acpi_s4_name[] = { ++0x88 ++}; ++static unsigned char acpi_pci64_start[] = { ++0x4d ++}; ++static unsigned char acpi_pci64_end[] = { ++0x5e ++}; ++static unsigned char acpi_pci32_end[] = { ++0x39 ++}; +diff --git a/hw/i386/ssdt-pcihp.hex.generated b/hw/i386/ssdt-pcihp.hex.generated +new file mode 100644 +index 0000000..0d32a27 +--- /dev/null ++++ b/hw/i386/ssdt-pcihp.hex.generated +@@ -0,0 +1,108 @@ ++static unsigned char ssdt_pcihp_name[] = { ++0x33 ++}; ++static unsigned char ssdt_pcihp_adr[] = { ++0x44 ++}; ++static unsigned char ssdt_pcihp_end[] = { ++0x58 ++}; ++static unsigned char ssdp_pcihp_aml[] = { ++0x53, ++0x53, ++0x44, ++0x54, ++0x58, ++0x0, ++0x0, ++0x0, ++0x1, ++0x77, ++0x42, ++0x58, ++0x50, ++0x43, ++0x0, ++0x0, ++0x42, ++0x58, ++0x53, ++0x53, ++0x44, ++0x54, ++0x50, ++0x43, ++0x1, ++0x0, ++0x0, ++0x0, ++0x49, ++0x4e, ++0x54, ++0x4c, ++0x28, ++0x5, ++0x10, ++0x20, ++0x10, ++0x33, ++0x5c, ++0x2e, ++0x5f, ++0x53, ++0x42, ++0x5f, ++0x50, ++0x43, ++0x49, ++0x30, ++0x5b, ++0x82, ++0x26, ++0x53, ++0x41, ++0x41, ++0x5f, ++0x8, ++0x5f, ++0x53, ++0x55, ++0x4e, ++0xa, ++0xaa, ++0x8, ++0x5f, ++0x41, ++0x44, ++0x52, ++0xc, ++0x0, ++0x0, ++0xaa, ++0x0, ++0x14, ++0xf, ++0x5f, ++0x45, ++0x4a, ++0x30, ++0x1, ++0xa4, ++0x50, ++0x43, ++0x45, ++0x4a, ++0x5f, ++0x53, ++0x55, ++0x4e ++}; ++static unsigned char ssdt_pcihp_start[] = { ++0x30 ++}; ++static unsigned char ssdt_pcihp_id[] = { ++0x3d ++}; ++static unsigned char ssdt_pcihp_ej0[] = { ++0x4a ++}; +diff --git a/hw/i386/ssdt-proc.hex.generated b/hw/i386/ssdt-proc.hex.generated +new file mode 100644 +index 0000000..a28172e +--- /dev/null ++++ b/hw/i386/ssdt-proc.hex.generated +@@ -0,0 +1,134 @@ ++static unsigned char ssdt_proc_name[] = { ++0x28 ++}; ++static unsigned char ssdp_proc_aml[] = { ++0x53, ++0x53, ++0x44, ++0x54, ++0x78, ++0x0, ++0x0, ++0x0, ++0x1, ++0xb3, ++0x42, ++0x58, ++0x50, ++0x43, ++0x0, ++0x0, ++0x42, ++0x58, ++0x53, ++0x53, ++0x44, ++0x54, ++0x0, ++0x0, ++0x1, ++0x0, ++0x0, ++0x0, ++0x49, ++0x4e, ++0x54, ++0x4c, ++0x28, ++0x5, ++0x10, ++0x20, ++0x5b, ++0x83, ++0x42, ++0x5, ++0x43, ++0x50, ++0x41, ++0x41, ++0xaa, ++0x10, ++0xb0, ++0x0, ++0x0, ++0x6, ++0x8, ++0x49, ++0x44, ++0x5f, ++0x5f, ++0xa, ++0xaa, ++0x8, ++0x5f, ++0x48, ++0x49, ++0x44, ++0xd, ++0x41, ++0x43, ++0x50, ++0x49, ++0x30, ++0x30, ++0x30, ++0x37, ++0x0, ++0x14, ++0xf, ++0x5f, ++0x4d, ++0x41, ++0x54, ++0x0, ++0xa4, ++0x43, ++0x50, ++0x4d, ++0x41, ++0x49, ++0x44, ++0x5f, ++0x5f, ++0x14, ++0xf, ++0x5f, ++0x53, ++0x54, ++0x41, ++0x0, ++0xa4, ++0x43, ++0x50, ++0x53, ++0x54, ++0x49, ++0x44, ++0x5f, ++0x5f, ++0x14, ++0xf, ++0x5f, ++0x45, ++0x4a, ++0x30, ++0x1, ++0x43, ++0x50, ++0x45, ++0x4a, ++0x49, ++0x44, ++0x5f, ++0x5f, ++0x68 ++}; ++static unsigned char ssdt_proc_id[] = { ++0x38 ++}; ++static unsigned char ssdt_proc_end[] = { ++0x78 ++}; ++static unsigned char ssdt_proc_start[] = { ++0x24 ++}; +-- +1.7.11.7 + diff --git a/SOURCES/kvm-acpi-ssdt-pcihp-updat-generated-file.patch b/SOURCES/kvm-acpi-ssdt-pcihp-updat-generated-file.patch new file mode 100644 index 0000000..f8cd9f4 --- /dev/null +++ b/SOURCES/kvm-acpi-ssdt-pcihp-updat-generated-file.patch @@ -0,0 +1,63 @@ +From 0cc4d584c9b4d4b73f16cfaf35056eadf70cf09a Mon Sep 17 00:00:00 2001 +Message-Id: <0cc4d584c9b4d4b73f16cfaf35056eadf70cf09a.1387298827.git.minovotn@redhat.com> +In-Reply-To: <3ed0fb61a3dc912ef036d7ef450bed192090709e.1387298827.git.minovotn@redhat.com> +References: <3ed0fb61a3dc912ef036d7ef450bed192090709e.1387298827.git.minovotn@redhat.com> +From: "Michael S. Tsirkin" +Date: Tue, 17 Dec 2013 15:18:23 +0100 +Subject: [PATCH 35/56] acpi: ssdt pcihp: updat generated file + +RH-Author: Michael S. Tsirkin +Message-id: <1387293161-4085-36-git-send-email-mst@redhat.com> +Patchwork-id: 56341 +O-Subject: [PATCH qemu-kvm RHEL7.0 v2 35/57] acpi: ssdt pcihp: updat generated file +Bugzilla: 1034876 +RH-Acked-by: Igor Mammedov +RH-Acked-by: Marcel Apfelbaum +RH-Acked-by: Laszlo Ersek + +update generated file, not sure what changed + +Reviewed-by: Gerd Hoffmann +Tested-by: Gerd Hoffmann +Reviewed-by: Igor Mammedov +Tested-by: Igor Mammedov +Signed-off-by: Michael S. Tsirkin +(cherry picked from commit 544d2bfa84c43f9d4c70ca2202a6113d686b8999) +--- + hw/i386/ssdt-pcihp.hex.generated | 8 ++++---- + 1 file changed, 4 insertions(+), 4 deletions(-) + +Signed-off-by: Michal Novotny +--- + hw/i386/ssdt-pcihp.hex.generated | 8 ++++---- + 1 file changed, 4 insertions(+), 4 deletions(-) + +diff --git a/hw/i386/ssdt-pcihp.hex.generated b/hw/i386/ssdt-pcihp.hex.generated +index 0d32a27..b3c2cd5 100644 +--- a/hw/i386/ssdt-pcihp.hex.generated ++++ b/hw/i386/ssdt-pcihp.hex.generated +@@ -17,7 +17,7 @@ static unsigned char ssdp_pcihp_aml[] = { + 0x0, + 0x0, + 0x1, +-0x77, ++0x76, + 0x42, + 0x58, + 0x50, +@@ -40,9 +40,9 @@ static unsigned char ssdp_pcihp_aml[] = { + 0x4e, + 0x54, + 0x4c, +-0x28, +-0x5, +-0x10, ++0x23, ++0x8, ++0x13, + 0x20, + 0x10, + 0x33, +-- +1.7.11.7 + diff --git a/SOURCES/kvm-add-a-header-file-for-atomic-operations.patch b/SOURCES/kvm-add-a-header-file-for-atomic-operations.patch new file mode 100644 index 0000000..924e4cf --- /dev/null +++ b/SOURCES/kvm-add-a-header-file-for-atomic-operations.patch @@ -0,0 +1,745 @@ +From c5386144fbf09f628148101bc674e2421cdd16e3 Mon Sep 17 00:00:00 2001 +Message-Id: +From: Nigel Croxon +Date: Thu, 14 Nov 2013 22:52:37 +0100 +Subject: [PATCH 01/46] add a header file for atomic operations + +RH-Author: Nigel Croxon +Message-id: <1384469598-13137-2-git-send-email-ncroxon@redhat.com> +Patchwork-id: 55686 +O-Subject: [RHEL7.0 PATCH 01/42] add a header file for atomic operations +Bugzilla: 1011720 +RH-Acked-by: Orit Wasserman +RH-Acked-by: Amit Shah +RH-Acked-by: Paolo Bonzini + +Bugzilla: 1011720 +https://bugzilla.redhat.com/show_bug.cgi?id=1011720 + +>From commit ID: +commit 5444e768ee1abe6e021bece19a9a932351f88c88 +Author: Paolo Bonzini +Date: Mon May 13 13:29:47 2013 +0200 + + add a header file for atomic operations + + We're already using them in several places, but __sync builtins are just + too ugly to type, and do not provide seqcst load/store operations. + + Reviewed-by: Richard Henderson + Signed-off-by: Paolo Bonzini +--- + docs/atomics.txt | 352 ++++++++++++++++++++++++++++++++++++++++++++++ + hw/display/qxl.c | 3 +- + hw/virtio/vhost.c | 9 +- + include/qemu/atomic.h | 198 ++++++++++++++++++++++---- + migration.c | 3 +- + tests/test-thread-pool.c | 8 +- + 6 files changed, 529 insertions(+), 44 deletions(-) + create mode 100644 docs/atomics.txt + +Signed-off-by: Michal Novotny +--- + docs/atomics.txt | 352 +++++++++++++++++++++++++++++++++++++++++++++++ + hw/display/qxl.c | 3 +- + hw/virtio/vhost.c | 9 +- + include/qemu/atomic.h | 198 +++++++++++++++++++++----- + migration.c | 3 +- + tests/test-thread-pool.c | 8 +- + 6 files changed, 529 insertions(+), 44 deletions(-) + create mode 100644 docs/atomics.txt + +diff --git a/docs/atomics.txt b/docs/atomics.txt +new file mode 100644 +index 0000000..6f2997b +--- /dev/null ++++ b/docs/atomics.txt +@@ -0,0 +1,352 @@ ++CPUs perform independent memory operations effectively in random order. ++but this can be a problem for CPU-CPU interaction (including interactions ++between QEMU and the guest). Multi-threaded programs use various tools ++to instruct the compiler and the CPU to restrict the order to something ++that is consistent with the expectations of the programmer. ++ ++The most basic tool is locking. Mutexes, condition variables and ++semaphores are used in QEMU, and should be the default approach to ++synchronization. Anything else is considerably harder, but it's ++also justified more often than one would like. The two tools that ++are provided by qemu/atomic.h are memory barriers and atomic operations. ++ ++Macros defined by qemu/atomic.h fall in three camps: ++ ++- compiler barriers: barrier(); ++ ++- weak atomic access and manual memory barriers: atomic_read(), ++ atomic_set(), smp_rmb(), smp_wmb(), smp_mb(), smp_read_barrier_depends(); ++ ++- sequentially consistent atomic access: everything else. ++ ++ ++COMPILER MEMORY BARRIER ++======================= ++ ++barrier() prevents the compiler from moving the memory accesses either ++side of it to the other side. The compiler barrier has no direct effect ++on the CPU, which may then reorder things however it wishes. ++ ++barrier() is mostly used within qemu/atomic.h itself. On some ++architectures, CPU guarantees are strong enough that blocking compiler ++optimizations already ensures the correct order of execution. In this ++case, qemu/atomic.h will reduce stronger memory barriers to simple ++compiler barriers. ++ ++Still, barrier() can be useful when writing code that can be interrupted ++by signal handlers. ++ ++ ++SEQUENTIALLY CONSISTENT ATOMIC ACCESS ++===================================== ++ ++Most of the operations in the qemu/atomic.h header ensure *sequential ++consistency*, where "the result of any execution is the same as if the ++operations of all the processors were executed in some sequential order, ++and the operations of each individual processor appear in this sequence ++in the order specified by its program". ++ ++qemu/atomic.h provides the following set of atomic read-modify-write ++operations: ++ ++ void atomic_inc(ptr) ++ void atomic_dec(ptr) ++ void atomic_add(ptr, val) ++ void atomic_sub(ptr, val) ++ void atomic_and(ptr, val) ++ void atomic_or(ptr, val) ++ ++ typeof(*ptr) atomic_fetch_inc(ptr) ++ typeof(*ptr) atomic_fetch_dec(ptr) ++ typeof(*ptr) atomic_fetch_add(ptr, val) ++ typeof(*ptr) atomic_fetch_sub(ptr, val) ++ typeof(*ptr) atomic_fetch_and(ptr, val) ++ typeof(*ptr) atomic_fetch_or(ptr, val) ++ typeof(*ptr) atomic_xchg(ptr, val ++ typeof(*ptr) atomic_cmpxchg(ptr, old, new) ++ ++all of which return the old value of *ptr. These operations are ++polymorphic; they operate on any type that is as wide as an int. ++ ++Sequentially consistent loads and stores can be done using: ++ ++ atomic_fetch_add(ptr, 0) for loads ++ atomic_xchg(ptr, val) for stores ++ ++However, they are quite expensive on some platforms, notably POWER and ++ARM. Therefore, qemu/atomic.h provides two primitives with slightly ++weaker constraints: ++ ++ typeof(*ptr) atomic_mb_read(ptr) ++ void atomic_mb_set(ptr, val) ++ ++The semantics of these primitives map to Java volatile variables, ++and are strongly related to memory barriers as used in the Linux ++kernel (see below). ++ ++As long as you use atomic_mb_read and atomic_mb_set, accesses cannot ++be reordered with each other, and it is also not possible to reorder ++"normal" accesses around them. ++ ++However, and this is the important difference between ++atomic_mb_read/atomic_mb_set and sequential consistency, it is important ++for both threads to access the same volatile variable. It is not the ++case that everything visible to thread A when it writes volatile field f ++becomes visible to thread B after it reads volatile field g. The store ++and load have to "match" (i.e., be performed on the same volatile ++field) to achieve the right semantics. ++ ++ ++These operations operate on any type that is as wide as an int or smaller. ++ ++ ++WEAK ATOMIC ACCESS AND MANUAL MEMORY BARRIERS ++============================================= ++ ++Compared to sequentially consistent atomic access, programming with ++weaker consistency models can be considerably more complicated. ++In general, if the algorithm you are writing includes both writes ++and reads on the same side, it is generally simpler to use sequentially ++consistent primitives. ++ ++When using this model, variables are accessed with atomic_read() and ++atomic_set(), and restrictions to the ordering of accesses is enforced ++using the smp_rmb(), smp_wmb(), smp_mb() and smp_read_barrier_depends() ++memory barriers. ++ ++atomic_read() and atomic_set() prevents the compiler from using ++optimizations that might otherwise optimize accesses out of existence ++on the one hand, or that might create unsolicited accesses on the other. ++In general this should not have any effect, because the same compiler ++barriers are already implied by memory barriers. However, it is useful ++to do so, because it tells readers which variables are shared with ++other threads, and which are local to the current thread or protected ++by other, more mundane means. ++ ++Memory barriers control the order of references to shared memory. ++They come in four kinds: ++ ++- smp_rmb() guarantees that all the LOAD operations specified before ++ the barrier will appear to happen before all the LOAD operations ++ specified after the barrier with respect to the other components of ++ the system. ++ ++ In other words, smp_rmb() puts a partial ordering on loads, but is not ++ required to have any effect on stores. ++ ++- smp_wmb() guarantees that all the STORE operations specified before ++ the barrier will appear to happen before all the STORE operations ++ specified after the barrier with respect to the other components of ++ the system. ++ ++ In other words, smp_wmb() puts a partial ordering on stores, but is not ++ required to have any effect on loads. ++ ++- smp_mb() guarantees that all the LOAD and STORE operations specified ++ before the barrier will appear to happen before all the LOAD and ++ STORE operations specified after the barrier with respect to the other ++ components of the system. ++ ++ smp_mb() puts a partial ordering on both loads and stores. It is ++ stronger than both a read and a write memory barrier; it implies both ++ smp_rmb() and smp_wmb(), but it also prevents STOREs coming before the ++ barrier from overtaking LOADs coming after the barrier and vice versa. ++ ++- smp_read_barrier_depends() is a weaker kind of read barrier. On ++ most processors, whenever two loads are performed such that the ++ second depends on the result of the first (e.g., the first load ++ retrieves the address to which the second load will be directed), ++ the processor will guarantee that the first LOAD will appear to happen ++ before the second with respect to the other components of the system. ++ However, this is not always true---for example, it was not true on ++ Alpha processors. Whenever this kind of access happens to shared ++ memory (that is not protected by a lock), a read barrier is needed, ++ and smp_read_barrier_depends() can be used instead of smp_rmb(). ++ ++ Note that the first load really has to have a _data_ dependency and not ++ a control dependency. If the address for the second load is dependent ++ on the first load, but the dependency is through a conditional rather ++ than actually loading the address itself, then it's a _control_ ++ dependency and a full read barrier or better is required. ++ ++ ++This is the set of barriers that is required *between* two atomic_read() ++and atomic_set() operations to achieve sequential consistency: ++ ++ | 2nd operation | ++ |-----------------------------------------| ++ 1st operation | (after last) | atomic_read | atomic_set | ++ ---------------+--------------+-------------+------------| ++ (before first) | | none | smp_wmb() | ++ ---------------+--------------+-------------+------------| ++ atomic_read | smp_rmb() | smp_rmb()* | ** | ++ ---------------+--------------+-------------+------------| ++ atomic_set | none | smp_mb()*** | smp_wmb() | ++ ---------------+--------------+-------------+------------| ++ ++ * Or smp_read_barrier_depends(). ++ ++ ** This requires a load-store barrier. How to achieve this varies ++ depending on the machine, but in practice smp_rmb()+smp_wmb() ++ should have the desired effect. For example, on PowerPC the ++ lwsync instruction is a combined load-load, load-store and ++ store-store barrier. ++ ++ *** This requires a store-load barrier. On most machines, the only ++ way to achieve this is a full barrier. ++ ++ ++You can see that the two possible definitions of atomic_mb_read() ++and atomic_mb_set() are the following: ++ ++ 1) atomic_mb_read(p) = atomic_read(p); smp_rmb() ++ atomic_mb_set(p, v) = smp_wmb(); atomic_set(p, v); smp_mb() ++ ++ 2) atomic_mb_read(p) = smp_mb() atomic_read(p); smp_rmb() ++ atomic_mb_set(p, v) = smp_wmb(); atomic_set(p, v); ++ ++Usually the former is used, because smp_mb() is expensive and a program ++normally has more reads than writes. Therefore it makes more sense to ++make atomic_mb_set() the more expensive operation. ++ ++There are two common cases in which atomic_mb_read and atomic_mb_set ++generate too many memory barriers, and thus it can be useful to manually ++place barriers instead: ++ ++- when a data structure has one thread that is always a writer ++ and one thread that is always a reader, manual placement of ++ memory barriers makes the write side faster. Furthermore, ++ correctness is easy to check for in this case using the "pairing" ++ trick that is explained below: ++ ++ thread 1 thread 1 ++ ------------------------- ------------------------ ++ (other writes) ++ smp_wmb() ++ atomic_mb_set(&a, x) atomic_set(&a, x) ++ smp_wmb() ++ atomic_mb_set(&b, y) atomic_set(&b, y) ++ ++ => ++ thread 2 thread 2 ++ ------------------------- ------------------------ ++ y = atomic_mb_read(&b) y = atomic_read(&b) ++ smp_rmb() ++ x = atomic_mb_read(&a) x = atomic_read(&a) ++ smp_rmb() ++ ++- sometimes, a thread is accessing many variables that are otherwise ++ unrelated to each other (for example because, apart from the current ++ thread, exactly one other thread will read or write each of these ++ variables). In this case, it is possible to "hoist" the implicit ++ barriers provided by atomic_mb_read() and atomic_mb_set() outside ++ a loop. For example, the above definition atomic_mb_read() gives ++ the following transformation: ++ ++ n = 0; n = 0; ++ for (i = 0; i < 10; i++) => for (i = 0; i < 10; i++) ++ n += atomic_mb_read(&a[i]); n += atomic_read(&a[i]); ++ smp_rmb(); ++ ++ Similarly, atomic_mb_set() can be transformed as follows: ++ smp_mb(): ++ ++ smp_wmb(); ++ for (i = 0; i < 10; i++) => for (i = 0; i < 10; i++) ++ atomic_mb_set(&a[i], false); atomic_set(&a[i], false); ++ smp_mb(); ++ ++ ++The two tricks can be combined. In this case, splitting a loop in ++two lets you hoist the barriers out of the loops _and_ eliminate the ++expensive smp_mb(): ++ ++ smp_wmb(); ++ for (i = 0; i < 10; i++) { => for (i = 0; i < 10; i++) ++ atomic_mb_set(&a[i], false); atomic_set(&a[i], false); ++ atomic_mb_set(&b[i], false); smb_wmb(); ++ } for (i = 0; i < 10; i++) ++ atomic_set(&a[i], false); ++ smp_mb(); ++ ++ The other thread can still use atomic_mb_read()/atomic_mb_set() ++ ++ ++Memory barrier pairing ++---------------------- ++ ++A useful rule of thumb is that memory barriers should always, or almost ++always, be paired with another barrier. In the case of QEMU, however, ++note that the other barrier may actually be in a driver that runs in ++the guest! ++ ++For the purposes of pairing, smp_read_barrier_depends() and smp_rmb() ++both count as read barriers. A read barriers shall pair with a write ++barrier or a full barrier; a write barrier shall pair with a read ++barrier or a full barrier. A full barrier can pair with anything. ++For example: ++ ++ thread 1 thread 2 ++ =============== =============== ++ a = 1; ++ smp_wmb(); ++ b = 2; x = b; ++ smp_rmb(); ++ y = a; ++ ++Note that the "writing" thread are accessing the variables in the ++opposite order as the "reading" thread. This is expected: stores ++before the write barrier will normally match the loads after the ++read barrier, and vice versa. The same is true for more than 2 ++access and for data dependency barriers: ++ ++ thread 1 thread 2 ++ =============== =============== ++ b[2] = 1; ++ smp_wmb(); ++ x->i = 2; ++ smp_wmb(); ++ a = x; x = a; ++ smp_read_barrier_depends(); ++ y = x->i; ++ smp_read_barrier_depends(); ++ z = b[y]; ++ ++smp_wmb() also pairs with atomic_mb_read(), and smp_rmb() also pairs ++with atomic_mb_set(). ++ ++ ++COMPARISON WITH LINUX KERNEL MEMORY BARRIERS ++============================================ ++ ++Here is a list of differences between Linux kernel atomic operations ++and memory barriers, and the equivalents in QEMU: ++ ++- atomic operations in Linux are always on a 32-bit int type and ++ use a boxed atomic_t type; atomic operations in QEMU are polymorphic ++ and use normal C types. ++ ++- atomic_read and atomic_set in Linux give no guarantee at all; ++ atomic_read and atomic_set in QEMU include a compiler barrier ++ (similar to the ACCESS_ONCE macro in Linux). ++ ++- most atomic read-modify-write operations in Linux return void; ++ in QEMU, all of them return the old value of the variable. ++ ++- different atomic read-modify-write operations in Linux imply ++ a different set of memory barriers; in QEMU, all of them enforce ++ sequential consistency, which means they imply full memory barriers ++ before and after the operation. ++ ++- Linux does not have an equivalent of atomic_mb_read() and ++ atomic_mb_set(). In particular, note that set_mb() is a little ++ weaker than atomic_mb_set(). ++ ++ ++SOURCES ++======= ++ ++* Documentation/memory-barriers.txt from the Linux kernel ++ ++* "The JSR-133 Cookbook for Compiler Writers", available at ++ http://g.oswego.edu/dl/jmm/cookbook.html +diff --git a/hw/display/qxl.c b/hw/display/qxl.c +index ea985d2..830b3c5 100644 +--- a/hw/display/qxl.c ++++ b/hw/display/qxl.c +@@ -23,6 +23,7 @@ + #include "qemu-common.h" + #include "qemu/timer.h" + #include "qemu/queue.h" ++#include "qemu/atomic.h" + #include "monitor/monitor.h" + #include "sysemu/sysemu.h" + #include "trace.h" +@@ -1726,7 +1727,7 @@ static void qxl_send_events(PCIQXLDevice *d, uint32_t events) + trace_qxl_send_events_vm_stopped(d->id, events); + return; + } +- old_pending = __sync_fetch_and_or(&d->ram->int_pending, le_events); ++ old_pending = atomic_fetch_or(&d->ram->int_pending, le_events); + if ((old_pending & le_events) == le_events) { + return; + } +diff --git a/hw/virtio/vhost.c b/hw/virtio/vhost.c +index 0dabf26..54aa569 100644 +--- a/hw/virtio/vhost.c ++++ b/hw/virtio/vhost.c +@@ -16,6 +16,7 @@ + #include + #include "hw/virtio/vhost.h" + #include "hw/hw.h" ++#include "qemu/atomic.h" + #include "qemu/range.h" + #include + #include "exec/address-spaces.h" +@@ -47,11 +48,9 @@ static void vhost_dev_sync_region(struct vhost_dev *dev, + addr += VHOST_LOG_CHUNK; + continue; + } +- /* Data must be read atomically. We don't really +- * need the barrier semantics of __sync +- * builtins, but it's easier to use them than +- * roll our own. */ +- log = __sync_fetch_and_and(from, 0); ++ /* Data must be read atomically. We don't really need barrier semantics ++ * but it's easier to use atomic_* than roll our own. */ ++ log = atomic_xchg(from, 0); + while ((bit = sizeof(log) > sizeof(int) ? + ffsll(log) : ffs(log))) { + hwaddr page_addr; +diff --git a/include/qemu/atomic.h b/include/qemu/atomic.h +index 10becb6..0aa8913 100644 +--- a/include/qemu/atomic.h ++++ b/include/qemu/atomic.h +@@ -1,68 +1,202 @@ +-#ifndef __QEMU_BARRIER_H +-#define __QEMU_BARRIER_H 1 ++/* ++ * Simple interface for atomic operations. ++ * ++ * Copyright (C) 2013 Red Hat, Inc. ++ * ++ * Author: Paolo Bonzini ++ * ++ * This work is licensed under the terms of the GNU GPL, version 2 or later. ++ * See the COPYING file in the top-level directory. ++ * ++ */ + +-/* Compiler barrier */ +-#define barrier() asm volatile("" ::: "memory") ++#ifndef __QEMU_ATOMIC_H ++#define __QEMU_ATOMIC_H 1 + +-#if defined(__i386__) ++#include "qemu/compiler.h" + +-#include "qemu/compiler.h" /* QEMU_GNUC_PREREQ */ ++/* For C11 atomic ops */ + +-/* +- * Because of the strongly ordered x86 storage model, wmb() and rmb() are nops +- * on x86(well, a compiler barrier only). Well, at least as long as +- * qemu doesn't do accesses to write-combining memory or non-temporal +- * load/stores from C code. +- */ +-#define smp_wmb() barrier() +-#define smp_rmb() barrier() ++/* Compiler barrier */ ++#define barrier() ({ asm volatile("" ::: "memory"); (void)0; }) ++ ++#ifndef __ATOMIC_RELAXED + + /* +- * We use GCC builtin if it's available, as that can use +- * mfence on 32 bit as well, e.g. if built with -march=pentium-m. +- * However, on i386, there seem to be known bugs as recently as 4.3. +- * */ +-#if QEMU_GNUC_PREREQ(4, 4) +-#define smp_mb() __sync_synchronize() ++ * We use GCC builtin if it's available, as that can use mfence on ++ * 32-bit as well, e.g. if built with -march=pentium-m. However, on ++ * i386 the spec is buggy, and the implementation followed it until ++ * 4.3 (http://gcc.gnu.org/bugzilla/show_bug.cgi?id=36793). ++ */ ++#if defined(__i386__) || defined(__x86_64__) ++#if !QEMU_GNUC_PREREQ(4, 4) ++#if defined __x86_64__ ++#define smp_mb() ({ asm volatile("mfence" ::: "memory"); (void)0; }) + #else +-#define smp_mb() asm volatile("lock; addl $0,0(%%esp) " ::: "memory") ++#define smp_mb() ({ asm volatile("lock; addl $0,0(%%esp) " ::: "memory"); (void)0; }) ++#endif ++#endif ++#endif ++ ++ ++#ifdef __alpha__ ++#define smp_read_barrier_depends() asm volatile("mb":::"memory") + #endif + +-#elif defined(__x86_64__) ++#if defined(__i386__) || defined(__x86_64__) || defined(__s390x__) + ++/* ++ * Because of the strongly ordered storage model, wmb() and rmb() are nops ++ * here (a compiler barrier only). QEMU doesn't do accesses to write-combining ++ * qemu memory or non-temporal load/stores from C code. ++ */ + #define smp_wmb() barrier() + #define smp_rmb() barrier() +-#define smp_mb() asm volatile("mfence" ::: "memory") ++ ++/* ++ * __sync_lock_test_and_set() is documented to be an acquire barrier only, ++ * but it is a full barrier at the hardware level. Add a compiler barrier ++ * to make it a full barrier also at the compiler level. ++ */ ++#define atomic_xchg(ptr, i) (barrier(), __sync_lock_test_and_set(ptr, i)) ++ ++/* ++ * Load/store with Java volatile semantics. ++ */ ++#define atomic_mb_set(ptr, i) ((void)atomic_xchg(ptr, i)) + + #elif defined(_ARCH_PPC) + + /* + * We use an eieio() for wmb() on powerpc. This assumes we don't + * need to order cacheable and non-cacheable stores with respect to +- * each other ++ * each other. ++ * ++ * smp_mb has the same problem as on x86 for not-very-new GCC ++ * (http://patchwork.ozlabs.org/patch/126184/, Nov 2011). + */ +-#define smp_wmb() asm volatile("eieio" ::: "memory") +- ++#define smp_wmb() ({ asm volatile("eieio" ::: "memory"); (void)0; }) + #if defined(__powerpc64__) +-#define smp_rmb() asm volatile("lwsync" ::: "memory") ++#define smp_rmb() ({ asm volatile("lwsync" ::: "memory"); (void)0; }) + #else +-#define smp_rmb() asm volatile("sync" ::: "memory") ++#define smp_rmb() ({ asm volatile("sync" ::: "memory"); (void)0; }) + #endif ++#define smp_mb() ({ asm volatile("sync" ::: "memory"); (void)0; }) + +-#define smp_mb() asm volatile("sync" ::: "memory") ++#endif /* _ARCH_PPC */ + +-#else ++#endif /* C11 atomics */ + + /* + * For (host) platforms we don't have explicit barrier definitions + * for, we use the gcc __sync_synchronize() primitive to generate a + * full barrier. This should be safe on all platforms, though it may +- * be overkill for wmb() and rmb(). ++ * be overkill for smp_wmb() and smp_rmb(). + */ ++#ifndef smp_mb ++#define smp_mb() __sync_synchronize() ++#endif ++ ++#ifndef smp_wmb ++#ifdef __ATOMIC_RELEASE ++#define smp_wmb() __atomic_thread_fence(__ATOMIC_RELEASE) ++#else + #define smp_wmb() __sync_synchronize() +-#define smp_mb() __sync_synchronize() ++#endif ++#endif ++ ++#ifndef smp_rmb ++#ifdef __ATOMIC_ACQUIRE ++#define smp_rmb() __atomic_thread_fence(__ATOMIC_ACQUIRE) ++#else + #define smp_rmb() __sync_synchronize() ++#endif ++#endif ++ ++#ifndef smp_read_barrier_depends ++#ifdef __ATOMIC_CONSUME ++#define smp_read_barrier_depends() __atomic_thread_fence(__ATOMIC_CONSUME) ++#else ++#define smp_read_barrier_depends() barrier() ++#endif ++#endif + ++#ifndef atomic_read ++#define atomic_read(ptr) (*(__typeof__(*ptr) *volatile) (ptr)) + #endif + ++#ifndef atomic_set ++#define atomic_set(ptr, i) ((*(__typeof__(*ptr) *volatile) (ptr)) = (i)) ++#endif ++ ++/* These have the same semantics as Java volatile variables. ++ * See http://gee.cs.oswego.edu/dl/jmm/cookbook.html: ++ * "1. Issue a StoreStore barrier (wmb) before each volatile store." ++ * 2. Issue a StoreLoad barrier after each volatile store. ++ * Note that you could instead issue one before each volatile load, but ++ * this would be slower for typical programs using volatiles in which ++ * reads greatly outnumber writes. Alternatively, if available, you ++ * can implement volatile store as an atomic instruction (for example ++ * XCHG on x86) and omit the barrier. This may be more efficient if ++ * atomic instructions are cheaper than StoreLoad barriers. ++ * 3. Issue LoadLoad and LoadStore barriers after each volatile load." ++ * ++ * If you prefer to think in terms of "pairing" of memory barriers, ++ * an atomic_mb_read pairs with an atomic_mb_set. ++ * ++ * And for the few ia64 lovers that exist, an atomic_mb_read is a ld.acq, ++ * while an atomic_mb_set is a st.rel followed by a memory barrier. ++ * ++ * These are a bit weaker than __atomic_load/store with __ATOMIC_SEQ_CST ++ * (see docs/atomics.txt), and I'm not sure that __ATOMIC_ACQ_REL is enough. ++ * Just always use the barriers manually by the rules above. ++ */ ++#ifndef atomic_mb_read ++#define atomic_mb_read(ptr) ({ \ ++ typeof(*ptr) _val = atomic_read(ptr); \ ++ smp_rmb(); \ ++ _val; \ ++}) ++#endif ++ ++#ifndef atomic_mb_set ++#define atomic_mb_set(ptr, i) do { \ ++ smp_wmb(); \ ++ atomic_set(ptr, i); \ ++ smp_mb(); \ ++} while (0) ++#endif ++ ++#ifndef atomic_xchg ++#ifdef __ATOMIC_SEQ_CST ++#define atomic_xchg(ptr, i) ({ \ ++ typeof(*ptr) _new = (i), _old; \ ++ __atomic_exchange(ptr, &_new, &_old, __ATOMIC_SEQ_CST); \ ++ _old; \ ++}) ++#elif defined __clang__ ++#define atomic_xchg(ptr, i) __sync_exchange(ptr, i) ++#else ++/* __sync_lock_test_and_set() is documented to be an acquire barrier only. */ ++#define atomic_xchg(ptr, i) (smp_mb(), __sync_lock_test_and_set(ptr, i)) ++#endif ++#endif ++ ++/* Provide shorter names for GCC atomic builtins. */ ++#define atomic_fetch_inc(ptr) __sync_fetch_and_add(ptr, 1) ++#define atomic_fetch_dec(ptr) __sync_fetch_and_add(ptr, -1) ++#define atomic_fetch_add __sync_fetch_and_add ++#define atomic_fetch_sub __sync_fetch_and_sub ++#define atomic_fetch_and __sync_fetch_and_and ++#define atomic_fetch_or __sync_fetch_and_or ++#define atomic_cmpxchg __sync_val_compare_and_swap ++ ++/* And even shorter names that return void. */ ++#define atomic_inc(ptr) ((void) __sync_fetch_and_add(ptr, 1)) ++#define atomic_dec(ptr) ((void) __sync_fetch_and_add(ptr, -1)) ++#define atomic_add(ptr, n) ((void) __sync_fetch_and_add(ptr, n)) ++#define atomic_sub(ptr, n) ((void) __sync_fetch_and_sub(ptr, n)) ++#define atomic_and(ptr, n) ((void) __sync_fetch_and_and(ptr, n)) ++#define atomic_or(ptr, n) ((void) __sync_fetch_and_or(ptr, n)) ++ + #endif +diff --git a/migration.c b/migration.c +index 46c633a..d91e702 100644 +--- a/migration.c ++++ b/migration.c +@@ -291,8 +291,7 @@ static void migrate_fd_cleanup(void *opaque) + + static void migrate_finish_set_state(MigrationState *s, int new_state) + { +- if (__sync_val_compare_and_swap(&s->state, MIG_STATE_ACTIVE, +- new_state) == new_state) { ++ if (atomic_cmpxchg(&s->state, MIG_STATE_ACTIVE, new_state) == new_state) { + trace_migrate_set_state(new_state); + } + } +diff --git a/tests/test-thread-pool.c b/tests/test-thread-pool.c +index 22915aa..b62338f 100644 +--- a/tests/test-thread-pool.c ++++ b/tests/test-thread-pool.c +@@ -17,15 +17,15 @@ typedef struct { + static int worker_cb(void *opaque) + { + WorkerTestData *data = opaque; +- return __sync_fetch_and_add(&data->n, 1); ++ return atomic_fetch_inc(&data->n); + } + + static int long_cb(void *opaque) + { + WorkerTestData *data = opaque; +- __sync_fetch_and_add(&data->n, 1); ++ atomic_inc(&data->n); + g_usleep(2000000); +- __sync_fetch_and_add(&data->n, 1); ++ atomic_inc(&data->n); + return 0; + } + +@@ -169,7 +169,7 @@ static void test_cancel(void) + /* Cancel the jobs that haven't been started yet. */ + num_canceled = 0; + for (i = 0; i < 100; i++) { +- if (__sync_val_compare_and_swap(&data[i].n, 0, 3) == 0) { ++ if (atomic_cmpxchg(&data[i].n, 0, 3) == 0) { + data[i].ret = -ECANCELED; + bdrv_aio_cancel(data[i].aiocb); + active--; +-- +1.7.11.7 + diff --git a/SOURCES/kvm-add-firmware-to-machine-options.patch b/SOURCES/kvm-add-firmware-to-machine-options.patch new file mode 100644 index 0000000..9d8ecc9 --- /dev/null +++ b/SOURCES/kvm-add-firmware-to-machine-options.patch @@ -0,0 +1,65 @@ +From 5129a1337bbbac935b8d17205eb9131645fc5831 Mon Sep 17 00:00:00 2001 +From: Gerd Hoffmann +Date: Thu, 16 Jan 2014 09:31:58 -0500 +Subject: [PATCH 08/14] add firmware to machine options + +Message-id: <1389864720-14128-2-git-send-email-kraxel@redhat.com> +Patchwork-id: 56739 +O-Subject: [RHEL-7 qemu-kvm PATCH 1/3] add firmware to machine options +Bugzilla: 1038603 +RH-Acked-by: Orit Wasserman +RH-Acked-by: Miroslav Rezanina +RH-Acked-by: Laszlo Ersek + +This patch adds firmware to the machine options. -bios becomes a +shortcut for -machine firmware=. Advantage is that the firmware +can be specified via config file as -machine is parsed using QemuOpts +and it is also possible to use different defaults for different +machine types (via QEMUMachine->default_machine_opts). + +Signed-off-by: Gerd Hoffmann +(cherry picked from commit 1442d3e6912d7ec88480099503cfa0aeaedf5634) +--- + vl.c | 7 ++++++- + 1 file changed, 6 insertions(+), 1 deletion(-) + +Signed-off-by: Miroslav Rezanina +--- + vl.c | 7 ++++++- + 1 file changed, 6 insertions(+), 1 deletion(-) + +diff --git a/vl.c b/vl.c +index 5aea00c..b70d107 100644 +--- a/vl.c ++++ b/vl.c +@@ -428,6 +428,10 @@ static QemuOptsList qemu_machine_opts = { + .name = "usb", + .type = QEMU_OPT_BOOL, + .help = "Set on/off to enable/disable usb", ++ },{ ++ .name = "firmware", ++ .type = QEMU_OPT_STRING, ++ .help = "firmware image", + }, + { /* End of list */ } + }, +@@ -3204,7 +3208,7 @@ int main(int argc, char **argv, char **envp) + } + break; + case QEMU_OPTION_bios: +- bios_name = optarg; ++ qemu_opts_set(qemu_find_opts("machine"), 0, "firmware", optarg); + break; + case QEMU_OPTION_singlestep: + singlestep = 1; +@@ -4035,6 +4039,7 @@ int main(int argc, char **argv, char **envp) + kernel_filename = qemu_opt_get(machine_opts, "kernel"); + initrd_filename = qemu_opt_get(machine_opts, "initrd"); + kernel_cmdline = qemu_opt_get(machine_opts, "append"); ++ bios_name = qemu_opt_get(machine_opts, "firmware"); + + if (!boot_order) { + boot_order = machine->boot_order; +-- +1.8.3.1 + diff --git a/SOURCES/kvm-add-kvm_readonly_mem_enabled.patch b/SOURCES/kvm-add-kvm_readonly_mem_enabled.patch new file mode 100644 index 0000000..698b7c0 --- /dev/null +++ b/SOURCES/kvm-add-kvm_readonly_mem_enabled.patch @@ -0,0 +1,109 @@ +From 11f30b4e8f2e939fe2cb061e8ae70d77ef582b63 Mon Sep 17 00:00:00 2001 +From: Laszlo Ersek +Date: Sat, 11 Jan 2014 17:59:56 +0100 +Subject: [PATCH 06/22] kvm: add kvm_readonly_mem_enabled + +RH-Author: Laszlo Ersek +Message-id: <1389463208-6278-7-git-send-email-lersek@redhat.com> +Patchwork-id: 56620 +O-Subject: [RHEL-7.0 qemu-kvm PATCH 06/18] kvm: add kvm_readonly_mem_enabled +Bugzilla: 1032346 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Amos Kong +RH-Acked-by: Andrew Jones + +From: Jordan Justen + +Signed-off-by: Jordan Justen +Reviewed-by: Paolo Bonzini +Message-id: 1369816047-16384-3-git-send-email-jordan.l.justen@intel.com +Signed-off-by: Anthony Liguori +(cherry picked from commit df9c8b758a04825e23f82427001028342b92d0cf) +Signed-off-by: Laszlo Ersek +--- + include/sysemu/kvm.h | 10 ++++++++++ + kvm-all.c | 6 ++++++ + kvm-stub.c | 1 + + 3 files changed, 17 insertions(+) + +Signed-off-by: Miroslav Rezanina +--- + include/sysemu/kvm.h | 10 ++++++++++ + kvm-all.c | 6 ++++++ + kvm-stub.c | 1 + + 3 files changed, 17 insertions(+), 0 deletions(-) + +diff --git a/include/sysemu/kvm.h b/include/sysemu/kvm.h +index 7fc3844..e722027 100644 +--- a/include/sysemu/kvm.h ++++ b/include/sysemu/kvm.h +@@ -45,6 +45,7 @@ extern bool kvm_async_interrupts_allowed; + extern bool kvm_irqfds_allowed; + extern bool kvm_msi_via_irqfd_allowed; + extern bool kvm_gsi_routing_allowed; ++extern bool kvm_readonly_mem_allowed; + + #if defined CONFIG_KVM || !defined NEED_CPU_H + #define kvm_enabled() (kvm_allowed) +@@ -97,6 +98,14 @@ extern bool kvm_gsi_routing_allowed; + */ + #define kvm_gsi_routing_enabled() (kvm_gsi_routing_allowed) + ++/** ++ * kvm_readonly_mem_enabled: ++ * ++ * Returns: true if KVM readonly memory is enabled (ie the kernel ++ * supports it and we're running in a configuration that permits it). ++ */ ++#define kvm_readonly_mem_enabled() (kvm_readonly_mem_allowed) ++ + #else + #define kvm_enabled() (0) + #define kvm_irqchip_in_kernel() (false) +@@ -104,6 +113,7 @@ extern bool kvm_gsi_routing_allowed; + #define kvm_irqfds_enabled() (false) + #define kvm_msi_via_irqfd_enabled() (false) + #define kvm_gsi_routing_allowed() (false) ++#define kvm_readonly_mem_enabled() (false) + #endif + + struct kvm_run; +diff --git a/kvm-all.c b/kvm-all.c +index 603bd4b..0a70ca1 100644 +--- a/kvm-all.c ++++ b/kvm-all.c +@@ -113,6 +113,7 @@ bool kvm_irqfds_allowed; + bool kvm_msi_via_irqfd_allowed; + bool kvm_gsi_routing_allowed; + bool kvm_allowed; ++bool kvm_readonly_mem_allowed; + + static const KVMCapabilityInfo kvm_required_capabilites[] = { + KVM_CAP_INFO(USER_MEMORY), +@@ -1435,6 +1436,11 @@ int kvm_init(void) + s->irq_set_ioctl = KVM_IRQ_LINE_STATUS; + } + ++#ifdef KVM_CAP_READONLY_MEM ++ kvm_readonly_mem_allowed = ++ (kvm_check_extension(s, KVM_CAP_READONLY_MEM) > 0); ++#endif ++ + ret = kvm_arch_init(s); + if (ret < 0) { + goto err; +diff --git a/kvm-stub.c b/kvm-stub.c +index b2c8f9b..22eaff0 100644 +--- a/kvm-stub.c ++++ b/kvm-stub.c +@@ -26,6 +26,7 @@ bool kvm_irqfds_allowed; + bool kvm_msi_via_irqfd_allowed; + bool kvm_gsi_routing_allowed; + bool kvm_allowed; ++bool kvm_readonly_mem_allowed; + + int kvm_init_vcpu(CPUState *cpu) + { +-- +1.7.1 + diff --git a/SOURCES/kvm-add-support-for-hyper-v-timers.patch b/SOURCES/kvm-add-support-for-hyper-v-timers.patch new file mode 100644 index 0000000..2936bd0 --- /dev/null +++ b/SOURCES/kvm-add-support-for-hyper-v-timers.patch @@ -0,0 +1,220 @@ +From b0ac5450a5fcb7e0c9cd5baf511283af375cc18f Mon Sep 17 00:00:00 2001 +From: Vadim Rozenfeld +Date: Mon, 3 Mar 2014 12:09:24 +0100 +Subject: [PATCH 12/12] kvm: add support for hyper-v timers + +RH-Author: Vadim Rozenfeld +Message-id: <1393848564-10511-13-git-send-email-vrozenfe@redhat.com> +Patchwork-id: 57968 +O-Subject: [RHEL-7.0 qemu-kvm v4 PATCH 12/12] kvm: add support for hyper-v timers +Bugzilla: 1057173 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Igor Mammedov +RH-Acked-by: Eduardo Habkost +RH-Acked-by: Juan Quintela + +http://msdn.microsoft.com/en-us/library/windows/hardware/ff541625%28v=vs.85%29.aspx + +This code is generic for activating reference time counter or virtual reference time stamp counter + +Signed-off-by: Vadim Rozenfeld +Reviewed-by: Marcelo Tosatti +Signed-off-by: Paolo Bonzini +(cherry picked from commit 48a5f3bcbbbe59a3120a39106bfda59fd1933fbc) + +Conflicts: + linux-headers/asm-x86/hyperv.h + linux-headers/linux/kvm.h + target-i386/kvm.c +--- + linux-headers/asm-x86/hyperv.h | 3 +++ + linux-headers/linux/kvm.h | 1 + + target-i386/cpu-qom.h | 1 + + target-i386/cpu.c | 1 + + target-i386/cpu.h | 1 + + target-i386/kvm.c | 20 +++++++++++++++++++- + target-i386/machine.c | 22 ++++++++++++++++++++++ + 7 files changed, 48 insertions(+), 1 deletion(-) + +Signed-off-by: Miroslav Rezanina +--- + linux-headers/asm-x86/hyperv.h | 3 +++ + linux-headers/linux/kvm.h | 1 + + target-i386/cpu-qom.h | 1 + + target-i386/cpu.c | 1 + + target-i386/cpu.h | 1 + + target-i386/kvm.c | 20 +++++++++++++++++++- + target-i386/machine.c | 22 ++++++++++++++++++++++ + 7 files changed, 48 insertions(+), 1 deletions(-) + +diff --git a/linux-headers/asm-x86/hyperv.h b/linux-headers/asm-x86/hyperv.h +index b80420b..9711819 100644 +--- a/linux-headers/asm-x86/hyperv.h ++++ b/linux-headers/asm-x86/hyperv.h +@@ -136,6 +136,9 @@ + /* MSR used to read the per-partition time reference counter */ + #define HV_X64_MSR_TIME_REF_COUNT 0x40000020 + ++/* A partition's reference time stamp counter (TSC) page */ ++#define HV_X64_MSR_REFERENCE_TSC 0x40000021 ++ + /* Define the virtual APIC registers */ + #define HV_X64_MSR_EOI 0x40000070 + #define HV_X64_MSR_ICR 0x40000071 +diff --git a/linux-headers/linux/kvm.h b/linux-headers/linux/kvm.h +index e32ef4a..4b93099 100644 +--- a/linux-headers/linux/kvm.h ++++ b/linux-headers/linux/kvm.h +@@ -666,6 +666,7 @@ struct kvm_ppc_smmu_info { + #define KVM_CAP_IRQ_MPIC 90 + #define KVM_CAP_PPC_RTAS 91 + #define KVM_CAP_IRQ_XICS 92 ++#define KVM_CAP_HYPERV_TIME 96 + + #ifdef KVM_CAP_IRQ_ROUTING + +diff --git a/target-i386/cpu-qom.h b/target-i386/cpu-qom.h +index 99ba65f..0b01e8f 100644 +--- a/target-i386/cpu-qom.h ++++ b/target-i386/cpu-qom.h +@@ -69,6 +69,7 @@ typedef struct X86CPU { + bool hyperv_vapic; + bool hyperv_relaxed_timing; + int hyperv_spinlock_attempts; ++ bool hyperv_time; + bool check_cpuid; + bool enforce_cpuid; + +diff --git a/target-i386/cpu.c b/target-i386/cpu.c +index 8421dfc..005e190 100644 +--- a/target-i386/cpu.c ++++ b/target-i386/cpu.c +@@ -2621,6 +2621,7 @@ static Property x86_cpu_properties[] = { + { .name = "hv-spinlocks", .info = &qdev_prop_spinlocks }, + DEFINE_PROP_BOOL("hv-relaxed", X86CPU, hyperv_relaxed_timing, false), + DEFINE_PROP_BOOL("hv-vapic", X86CPU, hyperv_vapic, false), ++ DEFINE_PROP_BOOL("hv-time", X86CPU, hyperv_time, false), + DEFINE_PROP_BOOL("check", X86CPU, check_cpuid, false), + DEFINE_PROP_BOOL("enforce", X86CPU, enforce_cpuid, false), + DEFINE_PROP_END_OF_LIST() +diff --git a/target-i386/cpu.h b/target-i386/cpu.h +index 0773499..ad40aab 100644 +--- a/target-i386/cpu.h ++++ b/target-i386/cpu.h +@@ -847,6 +847,7 @@ typedef struct CPUX86State { + uint64_t msr_hv_hypercall; + uint64_t msr_hv_guest_os_id; + uint64_t msr_hv_vapic; ++ uint64_t msr_hv_tsc; + + /* exception/interrupt handling */ + int error_code; +diff --git a/target-i386/kvm.c b/target-i386/kvm.c +index a2946c4..ba2cd7f 100644 +--- a/target-i386/kvm.c ++++ b/target-i386/kvm.c +@@ -72,6 +72,7 @@ static bool has_msr_kvm_steal_time; + static int lm_capable_kernel; + static bool has_msr_hv_hypercall; + static bool has_msr_hv_vapic; ++static bool has_msr_hv_tsc; + + static bool has_msr_architectural_pmu; + static uint32_t num_architectural_pmu_counters; +@@ -438,6 +439,7 @@ static bool hyperv_enabled(X86CPU *cpu) + CPUState *cs = CPU(cpu); + return kvm_check_extension(cs->kvm_state, KVM_CAP_HYPERV) > 0 && + (hyperv_hypercall_available(cpu) || ++ cpu->hyperv_time || + cpu->hyperv_relaxed_timing); + } + +@@ -495,7 +497,13 @@ int kvm_arch_init_vcpu(CPUState *cs) + c->eax |= HV_X64_MSR_APIC_ACCESS_AVAILABLE; + has_msr_hv_vapic = true; + } +- ++ if (cpu->hyperv_time && ++ kvm_check_extension(cs->kvm_state, KVM_CAP_HYPERV_TIME) > 0) { ++ c->eax |= HV_X64_MSR_HYPERCALL_AVAILABLE; ++ c->eax |= HV_X64_MSR_TIME_REF_COUNT_AVAILABLE; ++ c->eax |= 0x200; ++ has_msr_hv_tsc = true; ++ } + c = &cpuid_data.entries[cpuid_i++]; + c->function = HYPERV_CPUID_ENLIGHTMENT_INFO; + if (cpu->hyperv_relaxed_timing) { +@@ -1207,6 +1215,10 @@ static int kvm_put_msrs(X86CPU *cpu, int level) + kvm_msr_entry_set(&msrs[n++], HV_X64_MSR_APIC_ASSIST_PAGE, + env->msr_hv_vapic); + } ++ if (has_msr_hv_tsc) { ++ kvm_msr_entry_set(&msrs[n++], HV_X64_MSR_REFERENCE_TSC, ++ env->msr_hv_tsc); ++ } + } + if (env->mcg_cap) { + int i; +@@ -1485,6 +1497,9 @@ static int kvm_get_msrs(X86CPU *cpu) + if (has_msr_hv_vapic) { + msrs[n++].index = HV_X64_MSR_APIC_ASSIST_PAGE; + } ++ if (has_msr_hv_tsc) { ++ msrs[n++].index = HV_X64_MSR_REFERENCE_TSC; ++ } + + msr_data.info.nmsrs = n; + ret = kvm_vcpu_ioctl(CPU(cpu), KVM_GET_MSRS, &msr_data); +@@ -1596,6 +1611,9 @@ static int kvm_get_msrs(X86CPU *cpu) + case HV_X64_MSR_APIC_ASSIST_PAGE: + env->msr_hv_vapic = msrs[i].data; + break; ++ case HV_X64_MSR_REFERENCE_TSC: ++ env->msr_hv_tsc = msrs[i].data; ++ break; + } + } + +diff --git a/target-i386/machine.c b/target-i386/machine.c +index 021390b..42b049b 100644 +--- a/target-i386/machine.c ++++ b/target-i386/machine.c +@@ -545,6 +545,25 @@ static const VMStateDescription vmstate_msr_hyperv_vapic = { + } + }; + ++static bool hyperv_time_enable_needed(void *opaque) ++{ ++ X86CPU *cpu = opaque; ++ CPUX86State *env = &cpu->env; ++ ++ return env->msr_hv_tsc != 0; ++} ++ ++static const VMStateDescription vmstate_msr_hyperv_time = { ++ .name = "cpu/msr_hyperv_time", ++ .version_id = 1, ++ .minimum_version_id = 1, ++ .minimum_version_id_old = 1, ++ .fields = (VMStateField []) { ++ VMSTATE_UINT64(env.msr_hv_tsc, X86CPU), ++ VMSTATE_END_OF_LIST() ++ } ++}; ++ + const VMStateDescription vmstate_x86_cpu = { + .name = "cpu", + .version_id = 12, +@@ -682,6 +701,9 @@ const VMStateDescription vmstate_x86_cpu = { + }, { + .vmsd = &vmstate_msr_hyperv_vapic, + .needed = hyperv_vapic_enable_needed, ++ }, { ++ .vmsd = &vmstate_msr_hyperv_time, ++ .needed = hyperv_time_enable_needed, + } , { + /* empty */ + } +-- +1.7.1 + diff --git a/SOURCES/kvm-all-exit-in-case-max-vcpus-exceeded.patch b/SOURCES/kvm-all-exit-in-case-max-vcpus-exceeded.patch new file mode 100644 index 0000000..51635be --- /dev/null +++ b/SOURCES/kvm-all-exit-in-case-max-vcpus-exceeded.patch @@ -0,0 +1,46 @@ +From 7e144af26a2f0f8b5b972d60c32e55824bcc60b4 Mon Sep 17 00:00:00 2001 +From: Marcelo Tosatti +Date: Thu, 6 Mar 2014 02:29:12 +0100 +Subject: [PATCH 03/16] kvm-all: exit in case max vcpus exceeded + +RH-Author: Marcelo Tosatti +Message-id: <20140306022912.GC4955@amt.cnet> +Patchwork-id: 58024 +O-Subject: [RHEL7.0 qemu-kvm PATCH] kvm-all: exit in case max vcpus exceeded +Bugzilla: 993429 +RH-Acked-by: Amos Kong +RH-Acked-by: Andrew Jones +RH-Acked-by: Paolo Bonzini + +Rather than fall back to TCG (so the user has to discover +whats happening, in case of no access to qemu stdout/stderr). +(cherry-picked from 9ba3cf540fb9 from uq/master) + +Signed-off-by: Marcelo Tosatti +Signed-off-by: Paolo Bonzini +BZ: 993429 +Signed-off-by: Miroslav Rezanina +--- + kvm-all.c | 3 +-- + 1 files changed, 1 insertions(+), 2 deletions(-) + +diff --git a/kvm-all.c b/kvm-all.c +index 16e4f65..adc0a8e 100644 +--- a/kvm-all.c ++++ b/kvm-all.c +@@ -1382,11 +1382,10 @@ int kvm_init(void) + nc->name, nc->num, soft_vcpus_limit); + + if (nc->num > hard_vcpus_limit) { +- ret = -EINVAL; + fprintf(stderr, "Number of %s cpus requested (%d) exceeds " + "the maximum cpus supported by KVM (%d)\n", + nc->name, nc->num, hard_vcpus_limit); +- goto err; ++ exit(1); + } + } + nc++; +-- +1.7.1 + diff --git a/SOURCES/kvm-arch_init-align-MR-size-to-target-page-size.patch b/SOURCES/kvm-arch_init-align-MR-size-to-target-page-size.patch new file mode 100644 index 0000000..96e9264 --- /dev/null +++ b/SOURCES/kvm-arch_init-align-MR-size-to-target-page-size.patch @@ -0,0 +1,57 @@ +From be5e59136ca2d08576c189ae008e0ae806065e62 Mon Sep 17 00:00:00 2001 +Message-Id: +In-Reply-To: <3ed0fb61a3dc912ef036d7ef450bed192090709e.1387298827.git.minovotn@redhat.com> +References: <3ed0fb61a3dc912ef036d7ef450bed192090709e.1387298827.git.minovotn@redhat.com> +From: "Michael S. Tsirkin" +Date: Tue, 17 Dec 2013 15:17:16 +0100 +Subject: [PATCH 11/56] arch_init: align MR size to target page size + +RH-Author: Michael S. Tsirkin +Message-id: <1387293161-4085-12-git-send-email-mst@redhat.com> +Patchwork-id: 56316 +O-Subject: [PATCH qemu-kvm RHEL7.0 v2 11/57] arch_init: align MR size to target page size +Bugzilla: 1034876 +RH-Acked-by: Igor Mammedov +RH-Acked-by: Marcel Apfelbaum +RH-Acked-by: Laszlo Ersek + +Migration code assumes that each MR is a multiple of TARGET_PAGE_SIZE: +MR size is divided by TARGET_PAGE_SIZE, so if it isn't migration +never completes. +But this isn't really required for regions set up with +memory_region_init_ram, since that calls qemu_ram_alloc +which aligns size up using TARGET_PAGE_ALIGN. + +Align MR size up to full target page sizes, this way +migration completes even if we create a RAM MR +which is not a full target page size. + +Signed-off-by: Michael S. Tsirkin +Reviewed-by: Laszlo Ersek +(cherry picked from commit 0851c9f75ccb0baf28f5bf901b9ffe3c91fcf969) +--- + arch_init.c | 3 ++- + 1 file changed, 2 insertions(+), 1 deletion(-) + +Signed-off-by: Michal Novotny +--- + arch_init.c | 3 ++- + 1 file changed, 2 insertions(+), 1 deletion(-) + +diff --git a/arch_init.c b/arch_init.c +index 5301cfd..2c0ea1b 100644 +--- a/arch_init.c ++++ b/arch_init.c +@@ -341,7 +341,8 @@ ram_addr_t migration_bitmap_find_and_reset_dirty(MemoryRegion *mr, + { + unsigned long base = mr->ram_addr >> TARGET_PAGE_BITS; + unsigned long nr = base + (start >> TARGET_PAGE_BITS); +- unsigned long size = base + (int128_get64(mr->size) >> TARGET_PAGE_BITS); ++ uint64_t mr_size = TARGET_PAGE_ALIGN(memory_region_size(mr)); ++ unsigned long size = base + (mr_size >> TARGET_PAGE_BITS); + + unsigned long next; + +-- +1.7.11.7 + diff --git a/SOURCES/kvm-arch_init-make-is_zero_page-accept-size.patch b/SOURCES/kvm-arch_init-make-is_zero_page-accept-size.patch new file mode 100644 index 0000000..b5756d2 --- /dev/null +++ b/SOURCES/kvm-arch_init-make-is_zero_page-accept-size.patch @@ -0,0 +1,80 @@ +From c964e085dac5d2e47974f1275a0557ec841aeaba Mon Sep 17 00:00:00 2001 +Message-Id: +In-Reply-To: +References: +From: Nigel Croxon +Date: Thu, 14 Nov 2013 22:53:15 +0100 +Subject: [PATCH 39/46] arch_init: make is_zero_page accept size + +RH-Author: Nigel Croxon +Message-id: <1384469598-13137-40-git-send-email-ncroxon@redhat.com> +Patchwork-id: 55717 +O-Subject: [RHEL7.0 PATCH 39/42] arch_init: make is_zero_page accept size +Bugzilla: 1011720 +RH-Acked-by: Orit Wasserman +RH-Acked-by: Amit Shah +RH-Acked-by: Paolo Bonzini + +Bugzilla: 1011720 +https://bugzilla.redhat.com/show_bug.cgi?id=1011720 + +>From commit ID: +commit dc3c26a479e5bd19c1b3c04f696b8f70ad57f0b7 +Author: Isaku Yamahata +Date: Sat Sep 21 01:23:36 2013 +0900 + + arch_init: make is_zero_page accept size + + Later is_zero_page will be used for non TARGET_PAGE_SIZE + range. + And rename it to is_zero_range as it isn't page size any more. + + Signed-off-by: Isaku Yamahata + Signed-off-by: Juan Quintela +--- + arch_init.c | 9 ++++----- + 1 files changed, 4 insertions(+), 5 deletions(-) + +Signed-off-by: Michal Novotny +--- + arch_init.c | 9 ++++----- + 1 file changed, 4 insertions(+), 5 deletions(-) + +diff --git a/arch_init.c b/arch_init.c +index 26d0374..5ce9c61 100644 +--- a/arch_init.c ++++ b/arch_init.c +@@ -150,10 +150,9 @@ int qemu_read_default_config_files(bool userconfig) + return 0; + } + +-static inline bool is_zero_page(uint8_t *p) ++static inline bool is_zero_range(uint8_t *p, uint64_t size) + { +- return buffer_find_nonzero_offset(p, TARGET_PAGE_SIZE) == +- TARGET_PAGE_SIZE; ++ return buffer_find_nonzero_offset(p, size) == size; + } + + /* struct contains XBZRLE cache and a static page +@@ -497,7 +496,7 @@ static int ram_save_block(QEMUFile *f, bool last_stage) + acct_info.dup_pages++; + } + } +- } else if (is_zero_page(p)) { ++ } else if (is_zero_range(p, TARGET_PAGE_SIZE)) { + acct_info.dup_pages++; + bytes_sent = save_block_hdr(f, block, offset, cont, + RAM_SAVE_FLAG_COMPRESS); +@@ -849,7 +848,7 @@ static inline void *host_from_stream_offset(QEMUFile *f, + */ + void ram_handle_compressed(void *host, uint8_t ch, uint64_t size) + { +- if (ch != 0 || !is_zero_page(host)) { ++ if (ch != 0 || !is_zero_range(host, TARGET_PAGE_SIZE)) { + memset(host, ch, size); + #ifndef _WIN32 + if (ch == 0 && +-- +1.7.11.7 + diff --git a/SOURCES/kvm-arch_init-right-return-for-ram_save_iterate.patch b/SOURCES/kvm-arch_init-right-return-for-ram_save_iterate.patch new file mode 100644 index 0000000..1bc662d --- /dev/null +++ b/SOURCES/kvm-arch_init-right-return-for-ram_save_iterate.patch @@ -0,0 +1,77 @@ +From bf95edfa1eee98775de7daac87304ceb50be7874 Mon Sep 17 00:00:00 2001 +Message-Id: +In-Reply-To: +References: +From: Nigel Croxon +Date: Thu, 14 Nov 2013 22:53:11 +0100 +Subject: [PATCH 35/46] arch_init: right return for ram_save_iterate + +RH-Author: Nigel Croxon +Message-id: <1384469598-13137-36-git-send-email-ncroxon@redhat.com> +Patchwork-id: 55719 +O-Subject: [RHEL7.0 PATCH 35/42] arch_init: right return for ram_save_iterate +Bugzilla: 1011720 +RH-Acked-by: Orit Wasserman +RH-Acked-by: Amit Shah +RH-Acked-by: Paolo Bonzini + +Bugzilla: 1011720 +https://bugzilla.redhat.com/show_bug.cgi?id=1011720 + +>From commit ID: +commit 6cd0beda2c3c21fd7575e944764f392be7ef50c1 +Author: Lei Li +Date: Wed Sep 4 17:02:36 2013 +0800 + + arch_init: right return for ram_save_iterate + + qemu_file_rate_limit() never return negative value since the refactor + by Commit 1964a39, this patch gets rid of the negative check for it, + adjust bytes_transferred and return value correspondingly in + ram_save_iterate(). + + Signed-off-by: Lei Li + Signed-off-by: Paolo Bonzini + Signed-off-by: Juan Quintela +--- + arch_init.c | 15 ++++++++++----- + 1 files changed, 10 insertions(+), 5 deletions(-) + +Signed-off-by: Michal Novotny +--- + arch_init.c | 15 ++++++++++----- + 1 file changed, 10 insertions(+), 5 deletions(-) + +diff --git a/arch_init.c b/arch_init.c +index 034341c..26d0374 100644 +--- a/arch_init.c ++++ b/arch_init.c +@@ -710,15 +710,20 @@ static int ram_save_iterate(QEMUFile *f, void *opaque) + */ + ram_control_after_iterate(f, RAM_CONTROL_ROUND); + ++ bytes_transferred += total_sent; ++ ++ /* ++ * Do not count these 8 bytes into total_sent, so that we can ++ * return 0 if no page had been dirtied. ++ */ ++ qemu_put_be64(f, RAM_SAVE_FLAG_EOS); ++ bytes_transferred += 8; ++ ++ ret = qemu_file_get_error(f); + if (ret < 0) { +- bytes_transferred += total_sent; + return ret; + } + +- qemu_put_be64(f, RAM_SAVE_FLAG_EOS); +- total_sent += 8; +- bytes_transferred += total_sent; +- + return total_sent; + } + +-- +1.7.11.7 + diff --git a/SOURCES/kvm-audio-Lower-default-wakeup-rate-to-100-times-second.patch b/SOURCES/kvm-audio-Lower-default-wakeup-rate-to-100-times-second.patch new file mode 100644 index 0000000..d6767f4 --- /dev/null +++ b/SOURCES/kvm-audio-Lower-default-wakeup-rate-to-100-times-second.patch @@ -0,0 +1,49 @@ +From c67b37a75c6b76da744853a24d029f8b5fde9177 Mon Sep 17 00:00:00 2001 +From: Miroslav Rezanina +Date: Wed, 15 Jan 2014 09:14:32 -0500 +Subject: [PATCH 05/14] audio: Lower default wakeup rate to 100 times / second + +Message-id: +Patchwork-id: 56720 +O-Subject: [RHEL7 qemu-kvm PATCH 2/3] audio: Lower default wakeup rate to 100 times / second +Bugzilla: 1017636 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Gerd Hoffmann +RH-Acked-by: Laszlo Ersek + +From: Hans de Goede + +This is more then plenty to keep audio card fifos filles / emptied. + +This drops host cpu-load for audio playback inside a linux vm from +13% to 9%. + +Signed-off-by: Hans de Goede +Signed-off-by: Gerd Hoffmann +(cherry picked from commit 40a814b0b1789b94c483190b3208729b5182e5bd) +Signed-off-by: Miroslav Rezanina +--- + audio/audio.c | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +Signed-off-by: Miroslav Rezanina +--- + audio/audio.c | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/audio/audio.c b/audio/audio.c +index ebf7d3f..33b3fb6 100644 +--- a/audio/audio.c ++++ b/audio/audio.c +@@ -95,7 +95,7 @@ static struct { + } + }, + +- .period = { .hertz = 250 }, ++ .period = { .hertz = 100 }, + .plive = 0, + .log_to_monitor = 0, + .try_poll_in = 1, +-- +1.8.3.1 + diff --git a/SOURCES/kvm-audio-adjust-pulse-to-100Hz-wakeup-rate.patch b/SOURCES/kvm-audio-adjust-pulse-to-100Hz-wakeup-rate.patch new file mode 100644 index 0000000..7d900a7 --- /dev/null +++ b/SOURCES/kvm-audio-adjust-pulse-to-100Hz-wakeup-rate.patch @@ -0,0 +1,50 @@ +From 269456948b6a1aa7d7c63cf0d4a39bd623eb6f0c Mon Sep 17 00:00:00 2001 +From: Miroslav Rezanina +Date: Wed, 15 Jan 2014 09:14:33 -0500 +Subject: [PATCH 06/14] audio: adjust pulse to 100Hz wakeup rate + +Message-id: <83102d05b6ab8140cc893407509ca55fd6dd4d72.1389776721.git.mrezanin@redhat.com> +Patchwork-id: 56722 +O-Subject: [RHEL7 qemu-kvm PATCH 3/3] audio: adjust pulse to 100Hz wakeup rate +Bugzilla: 1017636 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Gerd Hoffmann +RH-Acked-by: Laszlo Ersek + +From: Gerd Hoffmann + +Signed-off-by: Gerd Hoffmann +(cherry picked from commit 0e8ae611bda0dfb038da2d865801d8adbd692bad) +Signed-off-by: Miroslav Rezanina +--- + audio/paaudio.c | 8 ++++---- + 1 file changed, 4 insertions(+), 4 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + audio/paaudio.c | 8 ++++---- + 1 file changed, 4 insertions(+), 4 deletions(-) + +diff --git a/audio/paaudio.c b/audio/paaudio.c +index 8b69778..90ff245 100644 +--- a/audio/paaudio.c ++++ b/audio/paaudio.c +@@ -547,11 +547,11 @@ static int qpa_init_out (HWVoiceOut *hw, struct audsettings *as) + ss.rate = as->freq; + + /* +- * qemu audio tick runs at 250 Hz (by default), so processing +- * data chunks worth 4 ms of sound should be a good fit. ++ * qemu audio tick runs at 100 Hz (by default), so processing ++ * data chunks worth 10 ms of sound should be a good fit. + */ +- ba.tlength = pa_usec_to_bytes (4 * 1000, &ss); +- ba.minreq = pa_usec_to_bytes (2 * 1000, &ss); ++ ba.tlength = pa_usec_to_bytes (10 * 1000, &ss); ++ ba.minreq = pa_usec_to_bytes (5 * 1000, &ss); + ba.maxlength = -1; + ba.prebuf = -1; + +-- +1.8.3.1 + diff --git a/SOURCES/kvm-audio-honor-QEMU_AUDIO_TIMER_PERIOD-instead-of-wakin.patch b/SOURCES/kvm-audio-honor-QEMU_AUDIO_TIMER_PERIOD-instead-of-wakin.patch new file mode 100644 index 0000000..326045a --- /dev/null +++ b/SOURCES/kvm-audio-honor-QEMU_AUDIO_TIMER_PERIOD-instead-of-wakin.patch @@ -0,0 +1,63 @@ +From 0bdb440567cacd42675c39d97fb19b20e77d93da Mon Sep 17 00:00:00 2001 +From: Miroslav Rezanina +Date: Wed, 15 Jan 2014 09:14:31 -0500 +Subject: [PATCH 04/14] audio: honor QEMU_AUDIO_TIMER_PERIOD instead of waking + up every *nano* second. + +Message-id: <23a0c5622fb294ab7cbcf3a812f5ab2f2e47b461.1389776721.git.mrezanin@redhat.com> +Patchwork-id: 56719 +O-Subject: [RHEL7 qemu-kvm PATCH 1/3] audio: honor QEMU_AUDIO_TIMER_PERIOD instead of waking up every *nano* second. +Bugzilla: 1017636 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Gerd Hoffmann +RH-Acked-by: Laszlo Ersek + +From: Miroslav Rezanina + +This is manual backport of upstream commit b4350deed: + + Now that we no longer have MIN_REARM_TIMER_NS a bug in the audio subsys has + clearly shown it self by trying to make a timer fire every nano second. + + Note we have a similar problem in 1.6, 1.5 and older but there + MIN_REARM_TIMER_NS limits the wakeups caused by audio being active to + 4000 times / second. This still causes a host cpu load of 50 % for simply + playing audio, where as with this patch git master is at 13%, so we should + backport this to 1.5 and 1.6 too. + + Note this will not apply to 1.5 and 1.6 as is. + + Cc: qemu-stable@nongnu.org + Signed-off-by: Hans de Goede + Signed-off-by: Gerd Hoffmann + +RHEL does not use new timer api so patch couldn't be cherry picked. + +Signed-off-by: Miroslav Rezanina +Upstream: b4350deed67b95651896ddb60cf9f765093a4848 +--- + audio/audio.c | 3 ++- + 1 file changed, 2 insertions(+), 1 deletion(-) + +Signed-off-by: Miroslav Rezanina +--- + audio/audio.c | 3 ++- + 1 file changed, 2 insertions(+), 1 deletion(-) + +diff --git a/audio/audio.c b/audio/audio.c +index 02bb886..ebf7d3f 100644 +--- a/audio/audio.c ++++ b/audio/audio.c +@@ -1124,7 +1124,8 @@ static int audio_is_timer_needed (void) + static void audio_reset_timer (AudioState *s) + { + if (audio_is_timer_needed ()) { +- qemu_mod_timer (s->ts, qemu_get_clock_ns (vm_clock) + 1); ++ qemu_mod_timer (s->ts, ++ qemu_get_clock_ns (vm_clock) + conf.period.ticks); + } + else { + qemu_del_timer (s->ts); +-- +1.8.3.1 + diff --git a/SOURCES/kvm-avoid-a-bogus-COMPLETED-CANCELLED-transition.patch b/SOURCES/kvm-avoid-a-bogus-COMPLETED-CANCELLED-transition.patch new file mode 100644 index 0000000..fcad994 --- /dev/null +++ b/SOURCES/kvm-avoid-a-bogus-COMPLETED-CANCELLED-transition.patch @@ -0,0 +1,58 @@ +From 089e31ac09be32fce980da9b76da856ce83fe4ff Mon Sep 17 00:00:00 2001 +From: Dr. David Alan Gilbert (git) +Date: Wed, 15 Jan 2014 19:42:27 +0100 +Subject: [PATCH 01/34] avoid a bogus COMPLETED->CANCELLED transition + +RH-Author: Dr. David Alan Gilbert (git) +Message-id: <1389814948-3983-2-git-send-email-dgilbert@redhat.com> +Patchwork-id: 56730 +O-Subject: [RHEL-7.0 qemu-kvm PATCH 1/2] avoid a bogus COMPLETED->CANCELLED transition +Bugzilla: 1053699 +RH-Acked-by: Orit Wasserman +RH-Acked-by: Juan Quintela +RH-Acked-by: Laszlo Ersek + +From: "Zhanghaoyu (A)" + +Avoid a bogus COMPLETED->CANCELLED transition. +There is a period of time from the timing of setting COMPLETED state to that of migration thread exits, so during which it's problematic in COMPLETED->CANCELLED transition. + +Signed-off-by: Zeng Junliang +Signed-off-by: Zhang Haoyu +Reviewed-by: Paolo Bonzini +Signed-off-by: Juan Quintela +(cherry picked from commit 6f2b811a61810a7fd9f9a5085de223f66b823342) +--- + migration.c | 9 ++++++++- + 1 file changed, 8 insertions(+), 1 deletion(-) + +Signed-off-by: Miroslav Rezanina +--- + migration.c | 9 ++++++++- + 1 files changed, 8 insertions(+), 1 deletions(-) + +diff --git a/migration.c b/migration.c +index ef9a61f..735f7ca 100644 +--- a/migration.c ++++ b/migration.c +@@ -324,9 +324,16 @@ void migrate_fd_error(MigrationState *s) + + static void migrate_fd_cancel(MigrationState *s) + { ++ int old_state ; + DPRINTF("cancelling migration\n"); + +- migrate_set_state(s, s->state, MIG_STATE_CANCELLED); ++ do { ++ old_state = s->state; ++ if (old_state != MIG_STATE_SETUP && old_state != MIG_STATE_ACTIVE) { ++ break; ++ } ++ migrate_set_state(s, old_state, MIG_STATE_CANCELLED); ++ } while (s->state != MIG_STATE_CANCELLED); + } + + void add_migration_state_change_notifier(Notifier *notify) +-- +1.7.1 + diff --git a/SOURCES/kvm-bitmap-Add-bitmap_zero_extend-operation.patch b/SOURCES/kvm-bitmap-Add-bitmap_zero_extend-operation.patch new file mode 100644 index 0000000..e59df1c --- /dev/null +++ b/SOURCES/kvm-bitmap-Add-bitmap_zero_extend-operation.patch @@ -0,0 +1,49 @@ +From ff40b201543aff558f2bf681da3093bce82c6eba Mon Sep 17 00:00:00 2001 +From: Juan Quintela +Date: Tue, 14 Jan 2014 15:07:28 +0100 +Subject: [PATCH 17/40] bitmap: Add bitmap_zero_extend operation + +RH-Author: Juan Quintela +Message-id: <1389712071-23303-18-git-send-email-quintela@redhat.com> +Patchwork-id: 56671 +O-Subject: [RHEL7 qemu-kvm PATCH 17/40] bitmap: Add bitmap_zero_extend operation +Bugzilla: 997559 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Orit Wasserman +RH-Acked-by: Dr. David Alan Gilbert (git) + +Signed-off-by: Juan Quintela +Reviewed-by: Eric Blake +Reviewed-by: Orit Wasserman +(cherry picked from commit 164590a60fd685399da259ac41b338d9a0b9d6c0) +Signed-off-by: Juan Quintela +--- + include/qemu/bitmap.h | 9 +++++++++ + 1 file changed, 9 insertions(+) + +Signed-off-by: Miroslav Rezanina +--- + include/qemu/bitmap.h | 9 +++++++++ + 1 files changed, 9 insertions(+), 0 deletions(-) + +diff --git a/include/qemu/bitmap.h b/include/qemu/bitmap.h +index afdd257..1babd5d 100644 +--- a/include/qemu/bitmap.h ++++ b/include/qemu/bitmap.h +@@ -220,4 +220,13 @@ unsigned long bitmap_find_next_zero_area(unsigned long *map, + unsigned long nr, + unsigned long align_mask); + ++static inline unsigned long *bitmap_zero_extend(unsigned long *old, ++ long old_nbits, long new_nbits) ++{ ++ long new_len = BITS_TO_LONGS(new_nbits) * sizeof(unsigned long); ++ unsigned long *new = g_realloc(old, new_len); ++ bitmap_clear(new, old_nbits, new_nbits - old_nbits); ++ return new; ++} ++ + #endif /* BITMAP_H */ +-- +1.7.1 + diff --git a/SOURCES/kvm-bitmap-use-long-as-index.patch b/SOURCES/kvm-bitmap-use-long-as-index.patch new file mode 100644 index 0000000..c7e261b --- /dev/null +++ b/SOURCES/kvm-bitmap-use-long-as-index.patch @@ -0,0 +1,468 @@ +From 3995e6984ffbdd018622ab2f31b59aec78eea17c Mon Sep 17 00:00:00 2001 +From: Juan Quintela +Date: Tue, 14 Jan 2014 15:07:12 +0100 +Subject: [PATCH 01/40] bitmap: use long as index + +RH-Author: Juan Quintela +Message-id: <1389712071-23303-2-git-send-email-quintela@redhat.com> +Patchwork-id: 56656 +O-Subject: [RHEL7 qemu-kvm PATCH 01/40] bitmap: use long as index +Bugzilla: 997559 +RH-Acked-by: Orit Wasserman +RH-Acked-by: Dr. David Alan Gilbert (git) +RH-Acked-by: Paolo Bonzini + +Move index and size fields from int to long. We need that for +migration. long is 64 bits on sane architectures, and 32bits should +be enough on all the 32bits architectures. + +Signed-off-by: Juan Quintela +Reviewed-by: Eric Blake +Reviewed-by: Orit Wasserman +(cherry picked from commit 9c22687ea8c1a2644a41a683ff0a291adc9a657c) +Signed-off-by: Juan Quintela +--- + include/qemu/bitmap.h | 77 ++++++++++++++++++++++++++------------------------- + include/qemu/bitops.h | 14 +++++----- + util/bitmap.c | 60 +++++++++++++++++++-------------------- + 3 files changed, 76 insertions(+), 75 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + include/qemu/bitmap.h | 77 +++++++++++++++++++++++++------------------------ + include/qemu/bitops.h | 14 ++++---- + util/bitmap.c | 60 +++++++++++++++++++------------------- + 3 files changed, 76 insertions(+), 75 deletions(-) + +diff --git a/include/qemu/bitmap.h b/include/qemu/bitmap.h +index 308bbb7..afdd257 100644 +--- a/include/qemu/bitmap.h ++++ b/include/qemu/bitmap.h +@@ -31,7 +31,7 @@ + * bitmap_andnot(dst, src1, src2, nbits) *dst = *src1 & ~(*src2) + * bitmap_complement(dst, src, nbits) *dst = ~(*src) + * bitmap_equal(src1, src2, nbits) Are *src1 and *src2 equal? +- * bitmap_intersects(src1, src2, nbits) Do *src1 and *src2 overlap? ++ * bitmap_intersects(src1, src2, nbits) Do *src1 and *src2 overlap? + * bitmap_empty(src, nbits) Are all bits zero in *src? + * bitmap_full(src, nbits) Are all bits set in *src? + * bitmap_set(dst, pos, nbits) Set specified bit area +@@ -62,71 +62,71 @@ + ) + + #define DECLARE_BITMAP(name,bits) \ +- unsigned long name[BITS_TO_LONGS(bits)] ++ unsigned long name[BITS_TO_LONGS(bits)] + + #define small_nbits(nbits) \ +- ((nbits) <= BITS_PER_LONG) ++ ((nbits) <= BITS_PER_LONG) + +-int slow_bitmap_empty(const unsigned long *bitmap, int bits); +-int slow_bitmap_full(const unsigned long *bitmap, int bits); ++int slow_bitmap_empty(const unsigned long *bitmap, long bits); ++int slow_bitmap_full(const unsigned long *bitmap, long bits); + int slow_bitmap_equal(const unsigned long *bitmap1, +- const unsigned long *bitmap2, int bits); ++ const unsigned long *bitmap2, long bits); + void slow_bitmap_complement(unsigned long *dst, const unsigned long *src, +- int bits); ++ long bits); + void slow_bitmap_shift_right(unsigned long *dst, +- const unsigned long *src, int shift, int bits); ++ const unsigned long *src, int shift, long bits); + void slow_bitmap_shift_left(unsigned long *dst, +- const unsigned long *src, int shift, int bits); ++ const unsigned long *src, int shift, long bits); + int slow_bitmap_and(unsigned long *dst, const unsigned long *bitmap1, +- const unsigned long *bitmap2, int bits); ++ const unsigned long *bitmap2, long bits); + void slow_bitmap_or(unsigned long *dst, const unsigned long *bitmap1, +- const unsigned long *bitmap2, int bits); ++ const unsigned long *bitmap2, long bits); + void slow_bitmap_xor(unsigned long *dst, const unsigned long *bitmap1, +- const unsigned long *bitmap2, int bits); ++ const unsigned long *bitmap2, long bits); + int slow_bitmap_andnot(unsigned long *dst, const unsigned long *bitmap1, +- const unsigned long *bitmap2, int bits); ++ const unsigned long *bitmap2, long bits); + int slow_bitmap_intersects(const unsigned long *bitmap1, +- const unsigned long *bitmap2, int bits); ++ const unsigned long *bitmap2, long bits); + +-static inline unsigned long *bitmap_new(int nbits) ++static inline unsigned long *bitmap_new(long nbits) + { +- int len = BITS_TO_LONGS(nbits) * sizeof(unsigned long); ++ long len = BITS_TO_LONGS(nbits) * sizeof(unsigned long); + return g_malloc0(len); + } + +-static inline void bitmap_zero(unsigned long *dst, int nbits) ++static inline void bitmap_zero(unsigned long *dst, long nbits) + { + if (small_nbits(nbits)) { + *dst = 0UL; + } else { +- int len = BITS_TO_LONGS(nbits) * sizeof(unsigned long); ++ long len = BITS_TO_LONGS(nbits) * sizeof(unsigned long); + memset(dst, 0, len); + } + } + +-static inline void bitmap_fill(unsigned long *dst, int nbits) ++static inline void bitmap_fill(unsigned long *dst, long nbits) + { + size_t nlongs = BITS_TO_LONGS(nbits); + if (!small_nbits(nbits)) { +- int len = (nlongs - 1) * sizeof(unsigned long); ++ long len = (nlongs - 1) * sizeof(unsigned long); + memset(dst, 0xff, len); + } + dst[nlongs - 1] = BITMAP_LAST_WORD_MASK(nbits); + } + + static inline void bitmap_copy(unsigned long *dst, const unsigned long *src, +- int nbits) ++ long nbits) + { + if (small_nbits(nbits)) { + *dst = *src; + } else { +- int len = BITS_TO_LONGS(nbits) * sizeof(unsigned long); ++ long len = BITS_TO_LONGS(nbits) * sizeof(unsigned long); + memcpy(dst, src, len); + } + } + + static inline int bitmap_and(unsigned long *dst, const unsigned long *src1, +- const unsigned long *src2, int nbits) ++ const unsigned long *src2, long nbits) + { + if (small_nbits(nbits)) { + return (*dst = *src1 & *src2) != 0; +@@ -135,7 +135,7 @@ static inline int bitmap_and(unsigned long *dst, const unsigned long *src1, + } + + static inline void bitmap_or(unsigned long *dst, const unsigned long *src1, +- const unsigned long *src2, int nbits) ++ const unsigned long *src2, long nbits) + { + if (small_nbits(nbits)) { + *dst = *src1 | *src2; +@@ -145,7 +145,7 @@ static inline void bitmap_or(unsigned long *dst, const unsigned long *src1, + } + + static inline void bitmap_xor(unsigned long *dst, const unsigned long *src1, +- const unsigned long *src2, int nbits) ++ const unsigned long *src2, long nbits) + { + if (small_nbits(nbits)) { + *dst = *src1 ^ *src2; +@@ -155,7 +155,7 @@ static inline void bitmap_xor(unsigned long *dst, const unsigned long *src1, + } + + static inline int bitmap_andnot(unsigned long *dst, const unsigned long *src1, +- const unsigned long *src2, int nbits) ++ const unsigned long *src2, long nbits) + { + if (small_nbits(nbits)) { + return (*dst = *src1 & ~(*src2)) != 0; +@@ -163,8 +163,9 @@ static inline int bitmap_andnot(unsigned long *dst, const unsigned long *src1, + return slow_bitmap_andnot(dst, src1, src2, nbits); + } + +-static inline void bitmap_complement(unsigned long *dst, const unsigned long *src, +- int nbits) ++static inline void bitmap_complement(unsigned long *dst, ++ const unsigned long *src, ++ long nbits) + { + if (small_nbits(nbits)) { + *dst = ~(*src) & BITMAP_LAST_WORD_MASK(nbits); +@@ -174,7 +175,7 @@ static inline void bitmap_complement(unsigned long *dst, const unsigned long *sr + } + + static inline int bitmap_equal(const unsigned long *src1, +- const unsigned long *src2, int nbits) ++ const unsigned long *src2, long nbits) + { + if (small_nbits(nbits)) { + return ! ((*src1 ^ *src2) & BITMAP_LAST_WORD_MASK(nbits)); +@@ -183,7 +184,7 @@ static inline int bitmap_equal(const unsigned long *src1, + } + } + +-static inline int bitmap_empty(const unsigned long *src, int nbits) ++static inline int bitmap_empty(const unsigned long *src, long nbits) + { + if (small_nbits(nbits)) { + return ! (*src & BITMAP_LAST_WORD_MASK(nbits)); +@@ -192,7 +193,7 @@ static inline int bitmap_empty(const unsigned long *src, int nbits) + } + } + +-static inline int bitmap_full(const unsigned long *src, int nbits) ++static inline int bitmap_full(const unsigned long *src, long nbits) + { + if (small_nbits(nbits)) { + return ! (~(*src) & BITMAP_LAST_WORD_MASK(nbits)); +@@ -202,7 +203,7 @@ static inline int bitmap_full(const unsigned long *src, int nbits) + } + + static inline int bitmap_intersects(const unsigned long *src1, +- const unsigned long *src2, int nbits) ++ const unsigned long *src2, long nbits) + { + if (small_nbits(nbits)) { + return ((*src1 & *src2) & BITMAP_LAST_WORD_MASK(nbits)) != 0; +@@ -211,12 +212,12 @@ static inline int bitmap_intersects(const unsigned long *src1, + } + } + +-void bitmap_set(unsigned long *map, int i, int len); +-void bitmap_clear(unsigned long *map, int start, int nr); ++void bitmap_set(unsigned long *map, long i, long len); ++void bitmap_clear(unsigned long *map, long start, long nr); + unsigned long bitmap_find_next_zero_area(unsigned long *map, +- unsigned long size, +- unsigned long start, +- unsigned int nr, +- unsigned long align_mask); ++ unsigned long size, ++ unsigned long start, ++ unsigned long nr, ++ unsigned long align_mask); + + #endif /* BITMAP_H */ +diff --git a/include/qemu/bitops.h b/include/qemu/bitops.h +index affcc96..5866115 100644 +--- a/include/qemu/bitops.h ++++ b/include/qemu/bitops.h +@@ -28,7 +28,7 @@ + * @nr: the bit to set + * @addr: the address to start counting from + */ +-static inline void set_bit(int nr, unsigned long *addr) ++static inline void set_bit(long nr, unsigned long *addr) + { + unsigned long mask = BIT_MASK(nr); + unsigned long *p = addr + BIT_WORD(nr); +@@ -41,7 +41,7 @@ static inline void set_bit(int nr, unsigned long *addr) + * @nr: Bit to clear + * @addr: Address to start counting from + */ +-static inline void clear_bit(int nr, unsigned long *addr) ++static inline void clear_bit(long nr, unsigned long *addr) + { + unsigned long mask = BIT_MASK(nr); + unsigned long *p = addr + BIT_WORD(nr); +@@ -54,7 +54,7 @@ static inline void clear_bit(int nr, unsigned long *addr) + * @nr: Bit to change + * @addr: Address to start counting from + */ +-static inline void change_bit(int nr, unsigned long *addr) ++static inline void change_bit(long nr, unsigned long *addr) + { + unsigned long mask = BIT_MASK(nr); + unsigned long *p = addr + BIT_WORD(nr); +@@ -67,7 +67,7 @@ static inline void change_bit(int nr, unsigned long *addr) + * @nr: Bit to set + * @addr: Address to count from + */ +-static inline int test_and_set_bit(int nr, unsigned long *addr) ++static inline int test_and_set_bit(long nr, unsigned long *addr) + { + unsigned long mask = BIT_MASK(nr); + unsigned long *p = addr + BIT_WORD(nr); +@@ -82,7 +82,7 @@ static inline int test_and_set_bit(int nr, unsigned long *addr) + * @nr: Bit to clear + * @addr: Address to count from + */ +-static inline int test_and_clear_bit(int nr, unsigned long *addr) ++static inline int test_and_clear_bit(long nr, unsigned long *addr) + { + unsigned long mask = BIT_MASK(nr); + unsigned long *p = addr + BIT_WORD(nr); +@@ -97,7 +97,7 @@ static inline int test_and_clear_bit(int nr, unsigned long *addr) + * @nr: Bit to change + * @addr: Address to count from + */ +-static inline int test_and_change_bit(int nr, unsigned long *addr) ++static inline int test_and_change_bit(long nr, unsigned long *addr) + { + unsigned long mask = BIT_MASK(nr); + unsigned long *p = addr + BIT_WORD(nr); +@@ -112,7 +112,7 @@ static inline int test_and_change_bit(int nr, unsigned long *addr) + * @nr: bit number to test + * @addr: Address to start counting from + */ +-static inline int test_bit(int nr, const unsigned long *addr) ++static inline int test_bit(long nr, const unsigned long *addr) + { + return 1UL & (addr[BIT_WORD(nr)] >> (nr & (BITS_PER_LONG-1))); + } +diff --git a/util/bitmap.c b/util/bitmap.c +index 687841d..9c6bb52 100644 +--- a/util/bitmap.c ++++ b/util/bitmap.c +@@ -36,9 +36,9 @@ + * endian architectures. + */ + +-int slow_bitmap_empty(const unsigned long *bitmap, int bits) ++int slow_bitmap_empty(const unsigned long *bitmap, long bits) + { +- int k, lim = bits/BITS_PER_LONG; ++ long k, lim = bits/BITS_PER_LONG; + + for (k = 0; k < lim; ++k) { + if (bitmap[k]) { +@@ -54,9 +54,9 @@ int slow_bitmap_empty(const unsigned long *bitmap, int bits) + return 1; + } + +-int slow_bitmap_full(const unsigned long *bitmap, int bits) ++int slow_bitmap_full(const unsigned long *bitmap, long bits) + { +- int k, lim = bits/BITS_PER_LONG; ++ long k, lim = bits/BITS_PER_LONG; + + for (k = 0; k < lim; ++k) { + if (~bitmap[k]) { +@@ -74,9 +74,9 @@ int slow_bitmap_full(const unsigned long *bitmap, int bits) + } + + int slow_bitmap_equal(const unsigned long *bitmap1, +- const unsigned long *bitmap2, int bits) ++ const unsigned long *bitmap2, long bits) + { +- int k, lim = bits/BITS_PER_LONG; ++ long k, lim = bits/BITS_PER_LONG; + + for (k = 0; k < lim; ++k) { + if (bitmap1[k] != bitmap2[k]) { +@@ -94,9 +94,9 @@ int slow_bitmap_equal(const unsigned long *bitmap1, + } + + void slow_bitmap_complement(unsigned long *dst, const unsigned long *src, +- int bits) ++ long bits) + { +- int k, lim = bits/BITS_PER_LONG; ++ long k, lim = bits/BITS_PER_LONG; + + for (k = 0; k < lim; ++k) { + dst[k] = ~src[k]; +@@ -108,10 +108,10 @@ void slow_bitmap_complement(unsigned long *dst, const unsigned long *src, + } + + int slow_bitmap_and(unsigned long *dst, const unsigned long *bitmap1, +- const unsigned long *bitmap2, int bits) ++ const unsigned long *bitmap2, long bits) + { +- int k; +- int nr = BITS_TO_LONGS(bits); ++ long k; ++ long nr = BITS_TO_LONGS(bits); + unsigned long result = 0; + + for (k = 0; k < nr; k++) { +@@ -121,10 +121,10 @@ int slow_bitmap_and(unsigned long *dst, const unsigned long *bitmap1, + } + + void slow_bitmap_or(unsigned long *dst, const unsigned long *bitmap1, +- const unsigned long *bitmap2, int bits) ++ const unsigned long *bitmap2, long bits) + { +- int k; +- int nr = BITS_TO_LONGS(bits); ++ long k; ++ long nr = BITS_TO_LONGS(bits); + + for (k = 0; k < nr; k++) { + dst[k] = bitmap1[k] | bitmap2[k]; +@@ -132,10 +132,10 @@ void slow_bitmap_or(unsigned long *dst, const unsigned long *bitmap1, + } + + void slow_bitmap_xor(unsigned long *dst, const unsigned long *bitmap1, +- const unsigned long *bitmap2, int bits) ++ const unsigned long *bitmap2, long bits) + { +- int k; +- int nr = BITS_TO_LONGS(bits); ++ long k; ++ long nr = BITS_TO_LONGS(bits); + + for (k = 0; k < nr; k++) { + dst[k] = bitmap1[k] ^ bitmap2[k]; +@@ -143,10 +143,10 @@ void slow_bitmap_xor(unsigned long *dst, const unsigned long *bitmap1, + } + + int slow_bitmap_andnot(unsigned long *dst, const unsigned long *bitmap1, +- const unsigned long *bitmap2, int bits) ++ const unsigned long *bitmap2, long bits) + { +- int k; +- int nr = BITS_TO_LONGS(bits); ++ long k; ++ long nr = BITS_TO_LONGS(bits); + unsigned long result = 0; + + for (k = 0; k < nr; k++) { +@@ -157,10 +157,10 @@ int slow_bitmap_andnot(unsigned long *dst, const unsigned long *bitmap1, + + #define BITMAP_FIRST_WORD_MASK(start) (~0UL << ((start) % BITS_PER_LONG)) + +-void bitmap_set(unsigned long *map, int start, int nr) ++void bitmap_set(unsigned long *map, long start, long nr) + { + unsigned long *p = map + BIT_WORD(start); +- const int size = start + nr; ++ const long size = start + nr; + int bits_to_set = BITS_PER_LONG - (start % BITS_PER_LONG); + unsigned long mask_to_set = BITMAP_FIRST_WORD_MASK(start); + +@@ -177,10 +177,10 @@ void bitmap_set(unsigned long *map, int start, int nr) + } + } + +-void bitmap_clear(unsigned long *map, int start, int nr) ++void bitmap_clear(unsigned long *map, long start, long nr) + { + unsigned long *p = map + BIT_WORD(start); +- const int size = start + nr; ++ const long size = start + nr; + int bits_to_clear = BITS_PER_LONG - (start % BITS_PER_LONG); + unsigned long mask_to_clear = BITMAP_FIRST_WORD_MASK(start); + +@@ -212,10 +212,10 @@ void bitmap_clear(unsigned long *map, int start, int nr) + * power of 2. A @align_mask of 0 means no alignment is required. + */ + unsigned long bitmap_find_next_zero_area(unsigned long *map, +- unsigned long size, +- unsigned long start, +- unsigned int nr, +- unsigned long align_mask) ++ unsigned long size, ++ unsigned long start, ++ unsigned long nr, ++ unsigned long align_mask) + { + unsigned long index, end, i; + again: +@@ -237,9 +237,9 @@ again: + } + + int slow_bitmap_intersects(const unsigned long *bitmap1, +- const unsigned long *bitmap2, int bits) ++ const unsigned long *bitmap2, long bits) + { +- int k, lim = bits/BITS_PER_LONG; ++ long k, lim = bits/BITS_PER_LONG; + + for (k = 0; k < lim; ++k) { + if (bitmap1[k] & bitmap2[k]) { +-- +1.7.1 + diff --git a/SOURCES/kvm-blkdebug-Don-t-leak-bs-file-on-failure.patch b/SOURCES/kvm-blkdebug-Don-t-leak-bs-file-on-failure.patch new file mode 100644 index 0000000..4630272 --- /dev/null +++ b/SOURCES/kvm-blkdebug-Don-t-leak-bs-file-on-failure.patch @@ -0,0 +1,90 @@ +From 66e996f40abbca9c62a262beeefb93b7b4c6e64f Mon Sep 17 00:00:00 2001 +From: Kevin Wolf +Date: Sat, 8 Feb 2014 09:53:22 +0100 +Subject: [PATCH 32/37] blkdebug: Don't leak bs->file on failure + +Message-id: <1392117622-28812-33-git-send-email-kwolf@redhat.com> +Patchwork-id: 57197 +O-Subject: [RHEL-7.0 qemu-kvm PATCH v2 32/37] blkdebug: Don't leak bs->file on failure +Bugzilla: 748906 +RH-Acked-by: Laszlo Ersek +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Max Reitz + +Reported-by: Laszlo Ersek +Signed-off-by: Kevin Wolf +Reviewed-by: Laszlo Ersek + +Conflicts: + block/blkdebug.c + +Conflicts because RHEL 7 doesn't have the blockdev-add support +series for blkdebug. + +Signed-off-by: Kevin Wolf +--- + block/blkdebug.c | 16 ++++++++++------ + 1 file changed, 10 insertions(+), 6 deletions(-) +--- + block/blkdebug.c | 16 ++++++++++------ + 1 files changed, 10 insertions(+), 6 deletions(-) + +diff --git a/block/blkdebug.c b/block/blkdebug.c +index ccb562b..1e772a5 100644 +--- a/block/blkdebug.c ++++ b/block/blkdebug.c +@@ -367,7 +367,7 @@ static int blkdebug_open(BlockDriverState *bs, QDict *options, int flags, + if (error_is_set(&local_err)) { + error_propagate(errp, local_err); + ret = -EINVAL; +- goto fail; ++ goto out; + } + + /* Read rules from config file */ +@@ -376,7 +376,7 @@ static int blkdebug_open(BlockDriverState *bs, QDict *options, int flags, + ret = read_config(s, config); + if (ret < 0) { + error_setg_errno(errp, -ret, "Could not read blkdebug config file"); +- goto fail; ++ goto out; + } + } + +@@ -388,13 +388,13 @@ static int blkdebug_open(BlockDriverState *bs, QDict *options, int flags, + if (filename == NULL) { + error_setg(errp, "Could not retrieve image file name"); + ret = -EINVAL; +- goto fail; ++ goto out; + } + + ret = bdrv_file_open(&bs->file, filename, NULL, flags, &local_err); + if (ret < 0) { + error_propagate(errp, local_err); +- goto fail; ++ goto out; + } + + /* Set request alignment */ +@@ -404,11 +404,15 @@ static int blkdebug_open(BlockDriverState *bs, QDict *options, int flags, + } else { + error_setg(errp, "Invalid alignment"); + ret = -EINVAL; +- goto fail; ++ goto fail_unref; + } + + ret = 0; +-fail: ++ goto out; ++ ++fail_unref: ++ bdrv_unref(bs->file); ++out: + qemu_opts_del(opts); + return ret; + } +-- +1.7.1 + diff --git a/SOURCES/kvm-blkdebug-Make-required-alignment-configurable.patch b/SOURCES/kvm-blkdebug-Make-required-alignment-configurable.patch new file mode 100644 index 0000000..d49b75b --- /dev/null +++ b/SOURCES/kvm-blkdebug-Make-required-alignment-configurable.patch @@ -0,0 +1,79 @@ +From 9f8b66d561d7b77338f79f2adf7a7d1102ad9d24 Mon Sep 17 00:00:00 2001 +From: Kevin Wolf +Date: Tue, 14 Jan 2014 13:44:35 +0100 +Subject: [PATCH 31/37] blkdebug: Make required alignment configurable + +Message-id: <1392117622-28812-32-git-send-email-kwolf@redhat.com> +Patchwork-id: 57196 +O-Subject: [RHEL-7.0 qemu-kvm PATCH v2 31/37] blkdebug: Make required alignment configurable +Bugzilla: 748906 +RH-Acked-by: Laszlo Ersek +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Max Reitz + +The new 'align' option of blkdebug can be used in order to emulate +backends with a required 4k alignment on hosts which only really require +512 byte alignment. + +Signed-off-by: Kevin Wolf +(cherry picked from commit b35ee7fb2308e09092488029b5a9e456ce61bbe6) + +Conflicts: + block/blkdebug.c + qapi-schema.json + +Conflicts because RHEL 7 doesn't have the blockdev-add support series +for blkdebug. + +Signed-off-by: Kevin Wolf +--- + block/blkdebug.c | 16 ++++++++++++++++ + 1 file changed, 16 insertions(+) +--- + block/blkdebug.c | 16 ++++++++++++++++ + 1 files changed, 16 insertions(+), 0 deletions(-) + +diff --git a/block/blkdebug.c b/block/blkdebug.c +index 9ee4fbb..ccb562b 100644 +--- a/block/blkdebug.c ++++ b/block/blkdebug.c +@@ -343,6 +343,11 @@ static QemuOptsList runtime_opts = { + .type = QEMU_OPT_STRING, + .help = "[internal use only, will be removed]", + }, ++ { ++ .name = "align", ++ .type = QEMU_OPT_SIZE, ++ .help = "Required alignment in bytes", ++ }, + { /* end of list */ } + }, + }; +@@ -354,6 +359,7 @@ static int blkdebug_open(BlockDriverState *bs, QDict *options, int flags, + QemuOpts *opts; + Error *local_err = NULL; + const char *filename, *config; ++ uint64_t align; + int ret; + + opts = qemu_opts_create_nofail(&runtime_opts); +@@ -391,6 +397,16 @@ static int blkdebug_open(BlockDriverState *bs, QDict *options, int flags, + goto fail; + } + ++ /* Set request alignment */ ++ align = qemu_opt_get_size(opts, "align", bs->request_alignment); ++ if (align > 0 && align < INT_MAX && !(align & (align - 1))) { ++ bs->request_alignment = align; ++ } else { ++ error_setg(errp, "Invalid alignment"); ++ ret = -EINVAL; ++ goto fail; ++ } ++ + ret = 0; + fail: + qemu_opts_del(opts); +-- +1.7.1 + diff --git a/SOURCES/kvm-block-Add-commit_active_start.patch b/SOURCES/kvm-block-Add-commit_active_start.patch new file mode 100644 index 0000000..86d0909 --- /dev/null +++ b/SOURCES/kvm-block-Add-commit_active_start.patch @@ -0,0 +1,197 @@ +From d432da3600bfb48139ee10373122c250a9f5a003 Mon Sep 17 00:00:00 2001 +From: Fam Zheng +Date: Fri, 17 Jan 2014 03:07:59 +0100 +Subject: [PATCH 16/34] block: Add commit_active_start() + +RH-Author: Fam Zheng +Message-id: <1389928083-8921-15-git-send-email-famz@redhat.com> +Patchwork-id: 56776 +O-Subject: [RHEL-7 qemu-kvm PATCH 14/18] block: Add commit_active_start() +Bugzilla: 1041301 +RH-Acked-by: Jeffrey Cody +RH-Acked-by: Kevin Wolf +RH-Acked-by: Stefan Hajnoczi + +commit_active_start is implemented in block/mirror.c, It will create a +job with "commit" type and designated base in block-commit command. This +will be used for committing active layer of device. + +Sync mode is removed from MirrorBlockJob because there's no proper type +for commit. The used information is is_none_mode. + +The common part of mirror_start and commit_active_start is moved to +mirror_start_job(). + +Fix the comment wording for commit_start. + +Signed-off-by: Fam Zheng +Reviewed-by: Kevin Wolf +Signed-off-by: Stefan Hajnoczi +(cherry picked from commit 03544a6e9ecc1be115e8a29bd929f83b467d4816) +Signed-off-by: Fam Zheng +--- + block/mirror.c | 66 +++++++++++++++++++++++++++++++++++------------ + include/block/block_int.h | 22 +++++++++++++--- + 2 files changed, 69 insertions(+), 19 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + block/mirror.c | 66 ++++++++++++++++++++++++++++++++++----------- + include/block/block_int.h | 22 +++++++++++++-- + 2 files changed, 69 insertions(+), 19 deletions(-) + +diff --git a/block/mirror.c b/block/mirror.c +index 8ccde2f..01fe379 100644 +--- a/block/mirror.c ++++ b/block/mirror.c +@@ -32,7 +32,7 @@ typedef struct MirrorBlockJob { + RateLimit limit; + BlockDriverState *target; + BlockDriverState *base; +- MirrorSyncMode mode; ++ bool is_none_mode; + BlockdevOnError on_source_error, on_target_error; + bool synced; + bool should_complete; +@@ -333,7 +333,7 @@ static void coroutine_fn mirror_run(void *opaque) + sectors_per_chunk = s->granularity >> BDRV_SECTOR_BITS; + mirror_free_init(s); + +- if (s->mode != MIRROR_SYNC_MODE_NONE) { ++ if (!s->is_none_mode) { + /* First part, loop on the sectors and initialize the dirty bitmap. */ + BlockDriverState *base = s->base; + for (sector_num = 0; sector_num < end; ) { +@@ -532,15 +532,26 @@ static const BlockJobDriver mirror_job_driver = { + .complete = mirror_complete, + }; + +-void mirror_start(BlockDriverState *bs, BlockDriverState *target, +- int64_t speed, int64_t granularity, int64_t buf_size, +- MirrorSyncMode mode, BlockdevOnError on_source_error, +- BlockdevOnError on_target_error, +- BlockDriverCompletionFunc *cb, +- void *opaque, Error **errp) ++static const BlockJobDriver commit_active_job_driver = { ++ .instance_size = sizeof(MirrorBlockJob), ++ .job_type = BLOCK_JOB_TYPE_COMMIT, ++ .set_speed = mirror_set_speed, ++ .iostatus_reset ++ = mirror_iostatus_reset, ++ .complete = mirror_complete, ++}; ++ ++static void mirror_start_job(BlockDriverState *bs, BlockDriverState *target, ++ int64_t speed, int64_t granularity, ++ int64_t buf_size, ++ BlockdevOnError on_source_error, ++ BlockdevOnError on_target_error, ++ BlockDriverCompletionFunc *cb, ++ void *opaque, Error **errp, ++ const BlockJobDriver *driver, ++ bool is_none_mode, BlockDriverState *base) + { + MirrorBlockJob *s; +- BlockDriverState *base = NULL; + + if (granularity == 0) { + /* Choose the default granularity based on the target file's cluster +@@ -563,13 +574,8 @@ void mirror_start(BlockDriverState *bs, BlockDriverState *target, + return; + } + +- if (mode == MIRROR_SYNC_MODE_TOP) { +- base = bs->backing_hd; +- } else { +- base = NULL; +- } + +- s = block_job_create(&mirror_job_driver, bs, speed, cb, opaque, errp); ++ s = block_job_create(driver, bs, speed, cb, opaque, errp); + if (!s) { + return; + } +@@ -577,7 +583,7 @@ void mirror_start(BlockDriverState *bs, BlockDriverState *target, + s->on_source_error = on_source_error; + s->on_target_error = on_target_error; + s->target = target; +- s->mode = mode; ++ s->is_none_mode = is_none_mode; + s->base = base; + s->granularity = granularity; + s->buf_size = MAX(buf_size, granularity); +@@ -590,3 +596,31 @@ void mirror_start(BlockDriverState *bs, BlockDriverState *target, + trace_mirror_start(bs, s, s->common.co, opaque); + qemu_coroutine_enter(s->common.co, s); + } ++ ++void mirror_start(BlockDriverState *bs, BlockDriverState *target, ++ int64_t speed, int64_t granularity, int64_t buf_size, ++ MirrorSyncMode mode, BlockdevOnError on_source_error, ++ BlockdevOnError on_target_error, ++ BlockDriverCompletionFunc *cb, ++ void *opaque, Error **errp) ++{ ++ bool is_none_mode; ++ BlockDriverState *base; ++ ++ is_none_mode = mode == MIRROR_SYNC_MODE_NONE; ++ base = mode == MIRROR_SYNC_MODE_TOP ? bs->backing_hd : NULL; ++ mirror_start_job(bs, target, speed, granularity, buf_size, ++ on_source_error, on_target_error, cb, opaque, errp, ++ &mirror_job_driver, is_none_mode, base); ++} ++ ++void commit_active_start(BlockDriverState *bs, BlockDriverState *base, ++ int64_t speed, ++ BlockdevOnError on_error, ++ BlockDriverCompletionFunc *cb, ++ void *opaque, Error **errp) ++{ ++ mirror_start_job(bs, base, speed, 0, 0, ++ on_error, on_error, cb, opaque, errp, ++ &commit_active_job_driver, false, base); ++} +diff --git a/include/block/block_int.h b/include/block/block_int.h +index fbfdab7..c8f30fd 100644 +--- a/include/block/block_int.h ++++ b/include/block/block_int.h +@@ -374,8 +374,9 @@ void stream_start(BlockDriverState *bs, BlockDriverState *base, + + /** + * commit_start: +- * @bs: Top Block device +- * @base: Block device that will be written into, and become the new top ++ * @bs: Active block device. ++ * @top: Top block device to be committed. ++ * @base: Block device that will be written into, and become the new top. + * @speed: The maximum speed, in bytes per second, or 0 for unlimited. + * @on_error: The action to take upon error. + * @cb: Completion function for the job. +@@ -387,7 +388,22 @@ void commit_start(BlockDriverState *bs, BlockDriverState *base, + BlockDriverState *top, int64_t speed, + BlockdevOnError on_error, BlockDriverCompletionFunc *cb, + void *opaque, Error **errp); +- ++/** ++ * commit_active_start: ++ * @bs: Active block device to be committed. ++ * @base: Block device that will be written into, and become the new top. ++ * @speed: The maximum speed, in bytes per second, or 0 for unlimited. ++ * @on_error: The action to take upon error. ++ * @cb: Completion function for the job. ++ * @opaque: Opaque pointer value passed to @cb. ++ * @errp: Error object. ++ * ++ */ ++void commit_active_start(BlockDriverState *bs, BlockDriverState *base, ++ int64_t speed, ++ BlockdevOnError on_error, ++ BlockDriverCompletionFunc *cb, ++ void *opaque, Error **errp); + /* + * mirror_start: + * @bs: Block device to operate on. +-- +1.7.1 + diff --git a/SOURCES/kvm-block-Align-requests-in-bdrv_co_do_pwritev.patch b/SOURCES/kvm-block-Align-requests-in-bdrv_co_do_pwritev.patch new file mode 100644 index 0000000..8a99189 --- /dev/null +++ b/SOURCES/kvm-block-Align-requests-in-bdrv_co_do_pwritev.patch @@ -0,0 +1,143 @@ +From ddaa3bc746bdf8974337f176e3841b7c27d7253e Mon Sep 17 00:00:00 2001 +From: Kevin Wolf +Date: Tue, 3 Dec 2013 16:34:41 +0100 +Subject: [PATCH 24/37] block: Align requests in bdrv_co_do_pwritev() + +Message-id: <1392117622-28812-25-git-send-email-kwolf@redhat.com> +Patchwork-id: 57189 +O-Subject: [RHEL-7.0 qemu-kvm PATCH v2 24/37] block: Align requests in bdrv_co_do_pwritev() +Bugzilla: 748906 +RH-Acked-by: Laszlo Ersek +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Max Reitz + +This patch changes bdrv_co_do_pwritev() to actually be what its name +promises. If requests aren't properly aligned, it performs a RMW. + +Requests touching the same block are serialised against the RMW request. +Further optimisation of this is possible by differentiating types of +requests (concurrent reads should actually be okay here). + +Signed-off-by: Kevin Wolf +Reviewed-by: Max Reitz +Reviewed-by: Benoit Canet +(cherry picked from commit 3b8242e0ea2a2c201ef3d1bd24080490dae33080) + +Signed-off-by: Kevin Wolf +--- + block.c | 86 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++- + 1 file changed, 85 insertions(+), 1 deletion(-) +--- + block.c | 86 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++- + 1 files changed, 85 insertions(+), 1 deletions(-) + +diff --git a/block.c b/block.c +index fd37037..3ec3949 100644 +--- a/block.c ++++ b/block.c +@@ -3078,6 +3078,12 @@ static int coroutine_fn bdrv_co_do_pwritev(BlockDriverState *bs, + BdrvRequestFlags flags) + { + BdrvTrackedRequest req; ++ /* TODO Lift BDRV_SECTOR_SIZE restriction in BlockDriver interface */ ++ uint64_t align = MAX(BDRV_SECTOR_SIZE, bs->request_alignment); ++ uint8_t *head_buf = NULL; ++ uint8_t *tail_buf = NULL; ++ QEMUIOVector local_qiov; ++ bool use_local_qiov = false; + int ret; + + if (!bs->drv) { +@@ -3096,10 +3102,88 @@ static int coroutine_fn bdrv_co_do_pwritev(BlockDriverState *bs, + bdrv_io_limits_intercept(bs, true, bytes >> BDRV_SECTOR_BITS); + } + ++ /* ++ * Align write if necessary by performing a read-modify-write cycle. ++ * Pad qiov with the read parts and be sure to have a tracked request not ++ * only for bdrv_aligned_pwritev, but also for the reads of the RMW cycle. ++ */ + tracked_request_begin(&req, bs, offset, bytes, true); +- ret = bdrv_aligned_pwritev(bs, &req, offset, bytes, qiov, flags); ++ ++ if (offset & (align - 1)) { ++ QEMUIOVector head_qiov; ++ struct iovec head_iov; ++ ++ mark_request_serialising(&req, align); ++ wait_serialising_requests(&req); ++ ++ head_buf = qemu_blockalign(bs, align); ++ head_iov = (struct iovec) { ++ .iov_base = head_buf, ++ .iov_len = align, ++ }; ++ qemu_iovec_init_external(&head_qiov, &head_iov, 1); ++ ++ ret = bdrv_aligned_preadv(bs, &req, offset & ~(align - 1), align, ++ align, &head_qiov, 0); ++ if (ret < 0) { ++ goto fail; ++ } ++ ++ qemu_iovec_init(&local_qiov, qiov->niov + 2); ++ qemu_iovec_add(&local_qiov, head_buf, offset & (align - 1)); ++ qemu_iovec_concat(&local_qiov, qiov, 0, qiov->size); ++ use_local_qiov = true; ++ ++ bytes += offset & (align - 1); ++ offset = offset & ~(align - 1); ++ } ++ ++ if ((offset + bytes) & (align - 1)) { ++ QEMUIOVector tail_qiov; ++ struct iovec tail_iov; ++ size_t tail_bytes; ++ ++ mark_request_serialising(&req, align); ++ wait_serialising_requests(&req); ++ ++ tail_buf = qemu_blockalign(bs, align); ++ tail_iov = (struct iovec) { ++ .iov_base = tail_buf, ++ .iov_len = align, ++ }; ++ qemu_iovec_init_external(&tail_qiov, &tail_iov, 1); ++ ++ ret = bdrv_aligned_preadv(bs, &req, (offset + bytes) & ~(align - 1), align, ++ align, &tail_qiov, 0); ++ if (ret < 0) { ++ goto fail; ++ } ++ ++ if (!use_local_qiov) { ++ qemu_iovec_init(&local_qiov, qiov->niov + 1); ++ qemu_iovec_concat(&local_qiov, qiov, 0, qiov->size); ++ use_local_qiov = true; ++ } ++ ++ tail_bytes = (offset + bytes) & (align - 1); ++ qemu_iovec_add(&local_qiov, tail_buf + tail_bytes, align - tail_bytes); ++ ++ bytes = ROUND_UP(bytes, align); ++ } ++ ++ ret = bdrv_aligned_pwritev(bs, &req, offset, bytes, ++ use_local_qiov ? &local_qiov : qiov, ++ flags); ++ ++fail: + tracked_request_end(&req); + ++ if (use_local_qiov) { ++ qemu_iovec_destroy(&local_qiov); ++ qemu_vfree(head_buf); ++ qemu_vfree(tail_buf); ++ } ++ + return ret; + } + +-- +1.7.1 + diff --git a/SOURCES/kvm-block-Allow-wait_serialising_requests-at-any-point.patch b/SOURCES/kvm-block-Allow-wait_serialising_requests-at-any-point.patch new file mode 100644 index 0000000..cac1b19 --- /dev/null +++ b/SOURCES/kvm-block-Allow-wait_serialising_requests-at-any-point.patch @@ -0,0 +1,76 @@ +From 0bbe9e3a205c48c32f41ddd79292761cc625c747 Mon Sep 17 00:00:00 2001 +From: Kevin Wolf +Date: Fri, 13 Dec 2013 13:04:35 +0100 +Subject: [PATCH 23/37] block: Allow wait_serialising_requests() at any point + +Message-id: <1392117622-28812-24-git-send-email-kwolf@redhat.com> +Patchwork-id: 57188 +O-Subject: [RHEL-7.0 qemu-kvm PATCH v2 23/37] block: Allow wait_serialising_requests() at any point +Bugzilla: 748906 +RH-Acked-by: Laszlo Ersek +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Max Reitz + +We can only have a single wait_serialising_requests() call per request +because otherwise we can run into deadlocks where requests are waiting +for each other. The same is true when wait_serialising_requests() is not +at the very beginning of a request, so that other requests can be issued +between the start of the tracking and wait_serialising_requests(). + +Fix this by changing wait_serialising_requests() to ignore requests that +are already (directly or indirectly) waiting for the calling request. + +Signed-off-by: Kevin Wolf +Reviewed-by: Max Reitz +Reviewed-by: Benoit Canet +(cherry picked from commit 6460440f34c709461b84375cfd8a86b27d433225) + +Conflicts: + include/block/block_int.h + +Conflicts because in RHEL 7 BdrvTrackedRequest is in block.c + +Signed-off-by: Kevin Wolf +--- + block.c | 15 ++++++++++++--- + 1 file changed, 12 insertions(+), 3 deletions(-) +--- + block.c | 15 ++++++++++++--- + 1 files changed, 12 insertions(+), 3 deletions(-) + +diff --git a/block.c b/block.c +index 94fd702..fd37037 100644 +--- a/block.c ++++ b/block.c +@@ -2047,6 +2047,8 @@ struct BdrvTrackedRequest { + QLIST_ENTRY(BdrvTrackedRequest) list; + Coroutine *co; /* owner, used for deadlock detection */ + CoQueue wait_queue; /* coroutines blocked on this request */ ++ ++ struct BdrvTrackedRequest *waiting_for; + }; + + /** +@@ -2176,9 +2178,16 @@ static void coroutine_fn wait_serialising_requests(BdrvTrackedRequest *self) + */ + assert(qemu_coroutine_self() != req->co); + +- qemu_co_queue_wait(&req->wait_queue); +- retry = true; +- break; ++ /* If the request is already (indirectly) waiting for us, or ++ * will wait for us as soon as it wakes up, then just go on ++ * (instead of producing a deadlock in the former case). */ ++ if (!req->waiting_for) { ++ self->waiting_for = req; ++ qemu_co_queue_wait(&req->wait_queue); ++ self->waiting_for = NULL; ++ retry = true; ++ break; ++ } + } + } + } while (retry); +-- +1.7.1 + diff --git a/SOURCES/kvm-block-Allow-waiting-for-overlapping-requests-between.patch b/SOURCES/kvm-block-Allow-waiting-for-overlapping-requests-between.patch new file mode 100644 index 0000000..d5b3287 --- /dev/null +++ b/SOURCES/kvm-block-Allow-waiting-for-overlapping-requests-between.patch @@ -0,0 +1,174 @@ +From 971e56af33f89b4e11a2e6b07b389d729756b9ed Mon Sep 17 00:00:00 2001 +From: Kevin Wolf +Date: Tue, 3 Dec 2013 14:55:55 +0100 +Subject: [PATCH 17/37] block: Allow waiting for overlapping requests between begin/end + +Message-id: <1392117622-28812-18-git-send-email-kwolf@redhat.com> +Patchwork-id: 57182 +O-Subject: [RHEL-7.0 qemu-kvm PATCH v2 17/37] block: Allow waiting for overlapping requests between begin/end +Bugzilla: 748906 +RH-Acked-by: Laszlo Ersek +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Max Reitz + +Previously, it was not possible to use wait_for_overlapping_requests() +between tracked_request_begin()/end() because it would wait for itself. + +Ignore the current request in the overlap check and run more of the +bdrv_co_do_preadv/pwritev code with a BdrvTrackedRequest present. + +Signed-off-by: Kevin Wolf +Reviewed-by: Max Reitz +Reviewed-by: Benoit Canet +(cherry picked from commit 65afd211c71fc91750d8a18f9604c1e57a5202fb) + +Conflicts: + block.c + +Conflicts because in RHEL 7 write notifiers don't exist. + +Signed-off-by: Kevin Wolf +--- + block.c | 36 +++++++++++++++++++----------------- + 1 file changed, 19 insertions(+), 17 deletions(-) +--- + block.c | 36 +++++++++++++++++++----------------- + 1 files changed, 19 insertions(+), 17 deletions(-) + +diff --git a/block.c b/block.c +index 09bb127..645bcd0 100644 +--- a/block.c ++++ b/block.c +@@ -2129,7 +2129,7 @@ static bool tracked_request_overlaps(BdrvTrackedRequest *req, + } + + static void coroutine_fn wait_for_overlapping_requests(BlockDriverState *bs, +- int64_t offset, unsigned int bytes) ++ BdrvTrackedRequest *self, int64_t offset, unsigned int bytes) + { + BdrvTrackedRequest *req; + int64_t cluster_offset; +@@ -2147,6 +2147,9 @@ static void coroutine_fn wait_for_overlapping_requests(BlockDriverState *bs, + do { + retry = false; + QLIST_FOREACH(req, &bs->tracked_requests, list) { ++ if (req == self) { ++ continue; ++ } + if (tracked_request_overlaps(req, cluster_offset, cluster_bytes)) { + /* Hitting this means there was a reentrant request, for + * example, a block driver issuing nested requests. This must +@@ -2744,10 +2747,10 @@ err: + * implemented by the caller. + */ + static int coroutine_fn bdrv_aligned_preadv(BlockDriverState *bs, +- int64_t offset, unsigned int bytes, QEMUIOVector *qiov, int flags) ++ BdrvTrackedRequest *req, int64_t offset, unsigned int bytes, ++ QEMUIOVector *qiov, int flags) + { + BlockDriver *drv = bs->drv; +- BdrvTrackedRequest req; + int ret; + + int64_t sector_num = offset >> BDRV_SECTOR_BITS; +@@ -2762,11 +2765,9 @@ static int coroutine_fn bdrv_aligned_preadv(BlockDriverState *bs, + } + + if (bs->copy_on_read_in_flight) { +- wait_for_overlapping_requests(bs, offset, bytes); ++ wait_for_overlapping_requests(bs, req, offset, bytes); + } + +- tracked_request_begin(&req, bs, offset, bytes, false); +- + if (flags & BDRV_REQ_COPY_ON_READ) { + int pnum; + +@@ -2813,8 +2814,6 @@ static int coroutine_fn bdrv_aligned_preadv(BlockDriverState *bs, + } + + out: +- tracked_request_end(&req); +- + if (flags & BDRV_REQ_COPY_ON_READ) { + bs->copy_on_read_in_flight--; + } +@@ -2830,6 +2829,8 @@ static int coroutine_fn bdrv_co_do_preadv(BlockDriverState *bs, + BdrvRequestFlags flags) + { + BlockDriver *drv = bs->drv; ++ BdrvTrackedRequest req; ++ + /* TODO Lift BDRV_SECTOR_SIZE restriction in BlockDriver interface */ + uint64_t align = MAX(BDRV_SECTOR_SIZE, bs->request_alignment); + uint8_t *head_buf = NULL; +@@ -2880,9 +2881,11 @@ static int coroutine_fn bdrv_co_do_preadv(BlockDriverState *bs, + bytes = ROUND_UP(bytes, align); + } + +- ret = bdrv_aligned_preadv(bs, offset, bytes, ++ tracked_request_begin(&req, bs, offset, bytes, false); ++ ret = bdrv_aligned_preadv(bs, &req, offset, bytes, + use_local_qiov ? &local_qiov : qiov, + flags); ++ tracked_request_end(&req); + + if (use_local_qiov) { + qemu_iovec_destroy(&local_qiov); +@@ -3001,10 +3004,10 @@ static int coroutine_fn bdrv_co_do_write_zeroes(BlockDriverState *bs, + * Forwards an already correctly aligned write request to the BlockDriver. + */ + static int coroutine_fn bdrv_aligned_pwritev(BlockDriverState *bs, +- int64_t offset, unsigned int bytes, QEMUIOVector *qiov, int flags) ++ BdrvTrackedRequest *req, int64_t offset, unsigned int bytes, ++ QEMUIOVector *qiov, int flags) + { + BlockDriver *drv = bs->drv; +- BdrvTrackedRequest req; + int ret; + + int64_t sector_num = offset >> BDRV_SECTOR_BITS; +@@ -3014,11 +3017,9 @@ static int coroutine_fn bdrv_aligned_pwritev(BlockDriverState *bs, + assert((bytes & (BDRV_SECTOR_SIZE - 1)) == 0); + + if (bs->copy_on_read_in_flight) { +- wait_for_overlapping_requests(bs, offset, bytes); ++ wait_for_overlapping_requests(bs, req, offset, bytes); + } + +- tracked_request_begin(&req, bs, offset, bytes, true); +- + if (flags & BDRV_REQ_ZERO_WRITE) { + ret = bdrv_co_do_write_zeroes(bs, sector_num, nb_sectors, flags); + } else { +@@ -3040,8 +3041,6 @@ static int coroutine_fn bdrv_aligned_pwritev(BlockDriverState *bs, + bs->total_sectors = MAX(bs->total_sectors, sector_num + nb_sectors); + } + +- tracked_request_end(&req); +- + return ret; + } + +@@ -3052,6 +3051,7 @@ static int coroutine_fn bdrv_co_do_pwritev(BlockDriverState *bs, + int64_t offset, unsigned int bytes, QEMUIOVector *qiov, + BdrvRequestFlags flags) + { ++ BdrvTrackedRequest req; + int ret; + + if (!bs->drv) { +@@ -3070,7 +3070,9 @@ static int coroutine_fn bdrv_co_do_pwritev(BlockDriverState *bs, + bdrv_io_limits_intercept(bs, true, bytes >> BDRV_SECTOR_BITS); + } + +- ret = bdrv_aligned_pwritev(bs, offset, bytes, qiov, flags); ++ tracked_request_begin(&req, bs, offset, bytes, true); ++ ret = bdrv_aligned_pwritev(bs, &req, offset, bytes, qiov, flags); ++ tracked_request_end(&req); + + return ret; + } +-- +1.7.1 + diff --git a/SOURCES/kvm-block-Assert-serialisation-assumptions-in-pwritev.patch b/SOURCES/kvm-block-Assert-serialisation-assumptions-in-pwritev.patch new file mode 100644 index 0000000..3e8c6a3 --- /dev/null +++ b/SOURCES/kvm-block-Assert-serialisation-assumptions-in-pwritev.patch @@ -0,0 +1,110 @@ +From e3fa109f29c42631c5f0f29e6f0167043fbd7a8d Mon Sep 17 00:00:00 2001 +From: Kevin Wolf +Date: Tue, 14 Jan 2014 11:41:35 +0100 +Subject: [PATCH 26/37] block: Assert serialisation assumptions in pwritev + +Message-id: <1392117622-28812-27-git-send-email-kwolf@redhat.com> +Patchwork-id: 57191 +O-Subject: [RHEL-7.0 qemu-kvm PATCH v2 26/37] block: Assert serialisation assumptions in pwritev +Bugzilla: 748906 +RH-Acked-by: Laszlo Ersek +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Max Reitz + +If a request calls wait_serialising_requests() and actually has to wait +in this function (i.e. a coroutine yield), other requests can run and +previously read data (like the head or tail buffer) could become +outdated. In this case, we would have to restart from the beginning to +read in the updated data. + +However, we're lucky and don't actually need to do that: A request can +only wait in the first call of wait_serialising_requests() because we +mark it as serialising before that call, so any later requests would +wait. So as we don't wait in practice, we don't have to reload the data. + +This is an important assumption that may not be broken or data +corruption will happen. Document it with some assertions. + +Signed-off-by: Kevin Wolf +Reviewed-by: Max Reitz +(cherry picked from commit 28de2dcd88de31f50bbd43d9c2fcb046c3a727cb) + +Signed-off-by: Kevin Wolf +--- + block.c | 16 ++++++++++++---- + 1 file changed, 12 insertions(+), 4 deletions(-) +--- + block.c | 16 ++++++++++++---- + 1 files changed, 12 insertions(+), 4 deletions(-) + +diff --git a/block.c b/block.c +index 9eeb072..76de7d2 100644 +--- a/block.c ++++ b/block.c +@@ -2153,14 +2153,15 @@ static bool tracked_request_overlaps(BdrvTrackedRequest *req, + return true; + } + +-static void coroutine_fn wait_serialising_requests(BdrvTrackedRequest *self) ++static bool coroutine_fn wait_serialising_requests(BdrvTrackedRequest *self) + { + BlockDriverState *bs = self->bs; + BdrvTrackedRequest *req; + bool retry; ++ bool waited = false; + + if (!bs->serialising_in_flight) { +- return; ++ return false; + } + + do { +@@ -2186,11 +2187,14 @@ static void coroutine_fn wait_serialising_requests(BdrvTrackedRequest *self) + qemu_co_queue_wait(&req->wait_queue); + self->waiting_for = NULL; + retry = true; ++ waited = true; + break; + } + } + } + } while (retry); ++ ++ return waited; + } + + /* +@@ -3036,6 +3040,7 @@ static int coroutine_fn bdrv_aligned_pwritev(BlockDriverState *bs, + QEMUIOVector *qiov, int flags) + { + BlockDriver *drv = bs->drv; ++ bool waited; + int ret; + + int64_t sector_num = offset >> BDRV_SECTOR_BITS; +@@ -3044,7 +3049,8 @@ static int coroutine_fn bdrv_aligned_pwritev(BlockDriverState *bs, + assert((offset & (BDRV_SECTOR_SIZE - 1)) == 0); + assert((bytes & (BDRV_SECTOR_SIZE - 1)) == 0); + +- wait_serialising_requests(req); ++ waited = wait_serialising_requests(req); ++ assert(!waited || !req->serialising); + + if (flags & BDRV_REQ_ZERO_WRITE) { + ret = bdrv_co_do_write_zeroes(bs, sector_num, nb_sectors, flags); +@@ -3142,9 +3148,11 @@ static int coroutine_fn bdrv_co_do_pwritev(BlockDriverState *bs, + QEMUIOVector tail_qiov; + struct iovec tail_iov; + size_t tail_bytes; ++ bool waited; + + mark_request_serialising(&req, align); +- wait_serialising_requests(&req); ++ waited = wait_serialising_requests(&req); ++ assert(!waited || !use_local_qiov); + + tail_buf = qemu_blockalign(bs, align); + tail_iov = (struct iovec) { +-- +1.7.1 + diff --git a/SOURCES/kvm-block-Avoid-unecessary-drv-bdrv_getlength-calls.patch b/SOURCES/kvm-block-Avoid-unecessary-drv-bdrv_getlength-calls.patch new file mode 100644 index 0000000..04c4472 --- /dev/null +++ b/SOURCES/kvm-block-Avoid-unecessary-drv-bdrv_getlength-calls.patch @@ -0,0 +1,166 @@ +From 4308c37b2fdabc82803dc9d2d521f564e2f34807 Mon Sep 17 00:00:00 2001 +From: Fam Zheng +Date: Wed, 20 Nov 2013 09:16:43 +0100 +Subject: [PATCH 04/14] block: Avoid unecessary drv->bdrv_getlength() calls + +RH-Author: Fam Zheng +Message-id: <1384939004-30831-2-git-send-email-famz@redhat.com> +Patchwork-id: 55784 +O-Subject: [RHEL-7 qemu-kvm PATCH 1/2] block: Avoid unecessary drv->bdrv_getlength() calls +Bugzilla: 1025138 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Kevin Wolf +RH-Acked-by: Stefan Hajnoczi + +From: Kevin Wolf + +The block layer generally keeps the size of an image cached in +bs->total_sectors so that it doesn't have to perform expensive +operations to get the size whenever it needs it. + +This doesn't work however when using a backend that can change its size +without qemu being aware of it, i.e. passthrough of removable media like +CD-ROMs or floppy disks. For this reason, the caching is disabled when a +removable device is used. + +It is obvious that checking whether the _guest_ device has removable +media isn't the right thing to do when we want to know whether the size +of the host backend can change. To make things worse, non-top-level +BlockDriverStates never have any device attached, which makes qemu +assume they are removable, so drv->bdrv_getlength() is always called on +the protocol layer. In the case of raw-posix, this causes unnecessary +lseek() system calls, which turned out to be rather expensive. + +This patch completely changes the logic and disables bs->total_sectors +caching only for certain block driver types, for which a size change is +expected: host_cdrom and host_floppy on POSIX, host_device on win32; also +the raw format in case it sits on top of one of these protocols, but in +the common case the nested bdrv_getlength() call on the protocol driver +will use the cache again and avoid an expensive drv->bdrv_getlength() +call. + +Signed-off-by: Kevin Wolf +Reviewed-by: Paolo Bonzini +(cherry picked from commit b94a2610573cd9314f244207c8b04cb75e42d7f8) + +Conflicts: + block/raw_bsd.c + +Conflict because only have block/raw.c. + +Signed-off-by: Fam Zheng +--- + block.c | 7 ++++--- + block/raw-posix.c | 9 ++++++--- + block/raw-win32.c | 4 +++- + block/raw.c | 1 + + include/block/block_int.h | 3 +++ + 5 files changed, 17 insertions(+), 7 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + block.c | 7 ++++--- + block/raw-posix.c | 9 ++++++--- + block/raw-win32.c | 4 +++- + block/raw.c | 1 + + include/block/block_int.h | 3 +++ + 5 files changed, 17 insertions(+), 7 deletions(-) + +diff --git a/block.c b/block.c +index 6913799..301c4fb 100644 +--- a/block.c ++++ b/block.c +@@ -2838,9 +2838,10 @@ int64_t bdrv_getlength(BlockDriverState *bs) + if (!drv) + return -ENOMEDIUM; + +- if (bdrv_dev_has_removable_media(bs)) { +- if (drv->bdrv_getlength) { +- return drv->bdrv_getlength(bs); ++ if (drv->has_variable_length) { ++ int ret = refresh_total_sectors(bs, bs->total_sectors); ++ if (ret < 0) { ++ return ret; + } + } + return bs->total_sectors * BDRV_SECTOR_SIZE; +diff --git a/block/raw-posix.c b/block/raw-posix.c +index 74b15da..eae1b40 100644 +--- a/block/raw-posix.c ++++ b/block/raw-posix.c +@@ -1718,7 +1718,8 @@ static BlockDriver bdrv_host_floppy = { + .bdrv_aio_flush = raw_aio_flush, + + .bdrv_truncate = raw_truncate, +- .bdrv_getlength = raw_getlength, ++ .bdrv_getlength = raw_getlength, ++ .has_variable_length = true, + .bdrv_get_allocated_file_size + = raw_get_allocated_file_size, + +@@ -1827,7 +1828,8 @@ static BlockDriver bdrv_host_cdrom = { + .bdrv_aio_flush = raw_aio_flush, + + .bdrv_truncate = raw_truncate, +- .bdrv_getlength = raw_getlength, ++ .bdrv_getlength = raw_getlength, ++ .has_variable_length = true, + .bdrv_get_allocated_file_size + = raw_get_allocated_file_size, + +@@ -1954,7 +1956,8 @@ static BlockDriver bdrv_host_cdrom = { + .bdrv_aio_flush = raw_aio_flush, + + .bdrv_truncate = raw_truncate, +- .bdrv_getlength = raw_getlength, ++ .bdrv_getlength = raw_getlength, ++ .has_variable_length = true, + .bdrv_get_allocated_file_size + = raw_get_allocated_file_size, + +diff --git a/block/raw-win32.c b/block/raw-win32.c +index 3e0251f..584790f 100644 +--- a/block/raw-win32.c ++++ b/block/raw-win32.c +@@ -618,7 +618,9 @@ static BlockDriver bdrv_host_device = { + .bdrv_aio_writev = raw_aio_writev, + .bdrv_aio_flush = raw_aio_flush, + +- .bdrv_getlength = raw_getlength, ++ .bdrv_getlength = raw_getlength, ++ .has_variable_length = true, ++ + .bdrv_get_allocated_file_size + = raw_get_allocated_file_size, + }; +diff --git a/block/raw.c b/block/raw.c +index 66eda91..e1ed8cc 100644 +--- a/block/raw.c ++++ b/block/raw.c +@@ -151,6 +151,7 @@ static BlockDriver bdrv_raw = { + + .bdrv_probe = raw_probe, + .bdrv_getlength = raw_getlength, ++ .has_variable_length = true, + .bdrv_truncate = raw_truncate, + + .bdrv_is_inserted = raw_is_inserted, +diff --git a/include/block/block_int.h b/include/block/block_int.h +index 0dbc34f..54708c6 100644 +--- a/include/block/block_int.h ++++ b/include/block/block_int.h +@@ -151,8 +151,11 @@ struct BlockDriver { + + const char *protocol_name; + int (*bdrv_truncate)(BlockDriverState *bs, int64_t offset); ++ + int64_t (*bdrv_getlength)(BlockDriverState *bs); ++ bool has_variable_length; + int64_t (*bdrv_get_allocated_file_size)(BlockDriverState *bs); ++ + int (*bdrv_write_compressed)(BlockDriverState *bs, int64_t sector_num, + const uint8_t *buf, int nb_sectors); + +-- +1.7.1 + diff --git a/SOURCES/kvm-block-Change-coroutine-wrapper-to-byte-granularity.patch b/SOURCES/kvm-block-Change-coroutine-wrapper-to-byte-granularity.patch new file mode 100644 index 0000000..52da4a2 --- /dev/null +++ b/SOURCES/kvm-block-Change-coroutine-wrapper-to-byte-granularity.patch @@ -0,0 +1,148 @@ +From 72bba55d794ac3e3ecaadb8e0bc382947b6f17ea Mon Sep 17 00:00:00 2001 +From: Kevin Wolf +Date: Thu, 5 Dec 2013 12:09:38 +0100 +Subject: [PATCH 27/37] block: Change coroutine wrapper to byte granularity + +Message-id: <1392117622-28812-28-git-send-email-kwolf@redhat.com> +Patchwork-id: 57192 +O-Subject: [RHEL-7.0 qemu-kvm PATCH v2 27/37] block: Change coroutine wrapper to byte granularity +Bugzilla: 748906 +RH-Acked-by: Laszlo Ersek +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Max Reitz + +Signed-off-by: Kevin Wolf +Reviewed-by: Max Reitz +(cherry picked from commit 775aa8b6e0ea25f8cca74d0fcb1e30a764cf624f) + +Signed-off-by: Kevin Wolf +--- + block.c | 48 ++++++++++++++++++++++++++---------------------- + 1 file changed, 26 insertions(+), 22 deletions(-) +--- + block.c | 48 ++++++++++++++++++++++++++---------------------- + 1 files changed, 26 insertions(+), 22 deletions(-) + +diff --git a/block.c b/block.c +index 76de7d2..3b5b706 100644 +--- a/block.c ++++ b/block.c +@@ -64,11 +64,11 @@ static int coroutine_fn bdrv_co_readv_em(BlockDriverState *bs, + static int coroutine_fn bdrv_co_writev_em(BlockDriverState *bs, + int64_t sector_num, int nb_sectors, + QEMUIOVector *iov); +-static int coroutine_fn bdrv_co_do_readv(BlockDriverState *bs, +- int64_t sector_num, int nb_sectors, QEMUIOVector *qiov, ++static int coroutine_fn bdrv_co_do_preadv(BlockDriverState *bs, ++ int64_t offset, unsigned int bytes, QEMUIOVector *qiov, + BdrvRequestFlags flags); +-static int coroutine_fn bdrv_co_do_writev(BlockDriverState *bs, +- int64_t sector_num, int nb_sectors, QEMUIOVector *qiov, ++static int coroutine_fn bdrv_co_do_pwritev(BlockDriverState *bs, ++ int64_t offset, unsigned int bytes, QEMUIOVector *qiov, + BdrvRequestFlags flags); + static BlockDriverAIOCB *bdrv_co_aio_rw_vector(BlockDriverState *bs, + int64_t sector_num, +@@ -2404,8 +2404,7 @@ static int bdrv_check_request(BlockDriverState *bs, int64_t sector_num, + + typedef struct RwCo { + BlockDriverState *bs; +- int64_t sector_num; +- int nb_sectors; ++ int64_t offset; + QEMUIOVector *qiov; + bool is_write; + int ret; +@@ -2417,34 +2416,32 @@ static void coroutine_fn bdrv_rw_co_entry(void *opaque) + RwCo *rwco = opaque; + + if (!rwco->is_write) { +- rwco->ret = bdrv_co_do_readv(rwco->bs, rwco->sector_num, +- rwco->nb_sectors, rwco->qiov, +- rwco->flags); +- } else { +- rwco->ret = bdrv_co_do_writev(rwco->bs, rwco->sector_num, +- rwco->nb_sectors, rwco->qiov, ++ rwco->ret = bdrv_co_do_preadv(rwco->bs, rwco->offset, ++ rwco->qiov->size, rwco->qiov, + rwco->flags); ++ } else { ++ rwco->ret = bdrv_co_do_pwritev(rwco->bs, rwco->offset, ++ rwco->qiov->size, rwco->qiov, ++ rwco->flags); + } + } + + /* + * Process a vectored synchronous request using coroutines + */ +-static int bdrv_rwv_co(BlockDriverState *bs, int64_t sector_num, +- QEMUIOVector *qiov, bool is_write, +- BdrvRequestFlags flags) ++static int bdrv_prwv_co(BlockDriverState *bs, int64_t offset, ++ QEMUIOVector *qiov, bool is_write, ++ BdrvRequestFlags flags) + { + Coroutine *co; + RwCo rwco = { + .bs = bs, +- .sector_num = sector_num, +- .nb_sectors = qiov->size >> BDRV_SECTOR_BITS, ++ .offset = offset, + .qiov = qiov, + .is_write = is_write, + .ret = NOT_DONE, + .flags = flags, + }; +- assert((qiov->size & (BDRV_SECTOR_SIZE - 1)) == 0); + + /** + * In sync call context, when the vcpu is blocked, this throttling timer +@@ -2483,7 +2480,8 @@ static int bdrv_rw_co(BlockDriverState *bs, int64_t sector_num, uint8_t *buf, + }; + + qemu_iovec_init_external(&qiov, &iov, 1); +- return bdrv_rwv_co(bs, sector_num, &qiov, is_write, flags); ++ return bdrv_prwv_co(bs, sector_num << BDRV_SECTOR_BITS, ++ &qiov, is_write, flags); + } + + /* return < 0 if error. See bdrv_write() for the return codes */ +@@ -2521,7 +2519,7 @@ int bdrv_write(BlockDriverState *bs, int64_t sector_num, + + int bdrv_writev(BlockDriverState *bs, int64_t sector_num, QEMUIOVector *qiov) + { +- return bdrv_rwv_co(bs, sector_num, qiov, true, 0); ++ return bdrv_prwv_co(bs, sector_num << BDRV_SECTOR_BITS, qiov, true, 0); + } + + int bdrv_write_zeroes(BlockDriverState *bs, int64_t sector_num, +@@ -4793,9 +4791,15 @@ int bdrv_flush(BlockDriverState *bs) + return rwco.ret; + } + ++typedef struct DiscardCo { ++ BlockDriverState *bs; ++ int64_t sector_num; ++ int nb_sectors; ++ int ret; ++} DiscardCo; + static void coroutine_fn bdrv_discard_co_entry(void *opaque) + { +- RwCo *rwco = opaque; ++ DiscardCo *rwco = opaque; + + rwco->ret = bdrv_co_discard(rwco->bs, rwco->sector_num, rwco->nb_sectors); + } +@@ -4881,7 +4885,7 @@ int coroutine_fn bdrv_co_discard(BlockDriverState *bs, int64_t sector_num, + int bdrv_discard(BlockDriverState *bs, int64_t sector_num, int nb_sectors) + { + Coroutine *co; +- RwCo rwco = { ++ DiscardCo rwco = { + .bs = bs, + .sector_num = sector_num, + .nb_sectors = nb_sectors, +-- +1.7.1 + diff --git a/SOURCES/kvm-block-Detect-unaligned-length-in-bdrv_qiov_is_aligne.patch b/SOURCES/kvm-block-Detect-unaligned-length-in-bdrv_qiov_is_aligne.patch new file mode 100644 index 0000000..930728f --- /dev/null +++ b/SOURCES/kvm-block-Detect-unaligned-length-in-bdrv_qiov_is_aligne.patch @@ -0,0 +1,47 @@ +From 3015984eb6778214d381cf7de32d8ab81e277728 Mon Sep 17 00:00:00 2001 +From: Kevin Wolf +Date: Thu, 5 Dec 2013 13:01:46 +0100 +Subject: [PATCH 07/37] block: Detect unaligned length in bdrv_qiov_is_aligned() + +Message-id: <1392117622-28812-8-git-send-email-kwolf@redhat.com> +Patchwork-id: 57172 +O-Subject: [RHEL-7.0 qemu-kvm PATCH v2 07/37] block: Detect unaligned length in bdrv_qiov_is_aligned() +Bugzilla: 748906 +RH-Acked-by: Laszlo Ersek +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Max Reitz + +For an O_DIRECT request to succeed, it's not only necessary that all +base addresses in the qiov are aligned, but also that each length in it +is aligned. + +Signed-off-by: Kevin Wolf +Reviewed-by: Wenchao Xia +Reviewed-by: Max Reitz +(cherry picked from commit 1ff735bdc417945bc6df1857861b127644b3f461) + +Signed-off-by: Kevin Wolf +--- + block.c | 3 +++ + 1 file changed, 3 insertions(+) +--- + block.c | 3 +++ + 1 files changed, 3 insertions(+), 0 deletions(-) + +diff --git a/block.c b/block.c +index f62acbd..6c98ff7 100644 +--- a/block.c ++++ b/block.c +@@ -4743,6 +4743,9 @@ bool bdrv_qiov_is_aligned(BlockDriverState *bs, QEMUIOVector *qiov) + if ((uintptr_t) qiov->iov[i].iov_base % bs->buffer_alignment) { + return false; + } ++ if (qiov->iov[i].iov_len % bs->buffer_alignment) { ++ return false; ++ } + } + + return true; +-- +1.7.1 + diff --git a/SOURCES/kvm-block-Don-t-call-ROUND_UP-with-negative-values.patch b/SOURCES/kvm-block-Don-t-call-ROUND_UP-with-negative-values.patch new file mode 100644 index 0000000..f46646a --- /dev/null +++ b/SOURCES/kvm-block-Don-t-call-ROUND_UP-with-negative-values.patch @@ -0,0 +1,46 @@ +From d133282ff639fd022fe64172f89b203cf8669114 Mon Sep 17 00:00:00 2001 +From: Kevin Wolf +Date: Fri, 7 Feb 2014 16:00:09 +0100 +Subject: [PATCH 37/37] block: Don't call ROUND_UP with negative values + +Message-id: <1392117622-28812-37-git-send-email-kwolf@redhat.com> +Patchwork-id: 57201 +O-Subject: [RHEL-7.0 qemu-kvm PATCH v2 37/37] block: Don't call ROUND_UP with negative values +Bugzilla: 748906 +RH-Acked-by: Laszlo Ersek +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Max Reitz + +The behaviour of the ROUND_UP macro with negative numbers isn't obvious. +It happens to do the right thing in this please, but better avoid it. + +Suggested-by: Laszlo Ersek +Signed-off-by: Kevin Wolf +Reviewed-by: Eric Blake +Reviewed-by: Laszlo Ersek +Signed-off-by: Kevin Wolf +--- + block.c | 4 ++-- + 1 file changed, 2 insertions(+), 2 deletions(-) +--- + block.c | 4 ++-- + 1 files changed, 2 insertions(+), 2 deletions(-) + +diff --git a/block.c b/block.c +index b878c8b..1b57236 100644 +--- a/block.c ++++ b/block.c +@@ -2760,8 +2760,8 @@ static int coroutine_fn bdrv_aligned_preadv(BlockDriverState *bs, + } + + total_sectors = DIV_ROUND_UP(len, BDRV_SECTOR_SIZE); +- max_nb_sectors = MAX(0, ROUND_UP(total_sectors - sector_num, +- align >> BDRV_SECTOR_BITS)); ++ max_nb_sectors = ROUND_UP(MAX(0, total_sectors - sector_num), ++ align >> BDRV_SECTOR_BITS); + if (max_nb_sectors > 0) { + ret = drv->bdrv_co_readv(bs, sector_num, + MIN(nb_sectors, max_nb_sectors), qiov); +-- +1.7.1 + diff --git a/SOURCES/kvm-block-Don-t-use-guest-sector-size-for-qemu_blockalig.patch b/SOURCES/kvm-block-Don-t-use-guest-sector-size-for-qemu_blockalig.patch new file mode 100644 index 0000000..2a84238 --- /dev/null +++ b/SOURCES/kvm-block-Don-t-use-guest-sector-size-for-qemu_blockalig.patch @@ -0,0 +1,148 @@ +From 8603c409443521f98a73652ebf30233da879c7de Mon Sep 17 00:00:00 2001 +From: Kevin Wolf +Date: Thu, 28 Nov 2013 10:23:32 +0100 +Subject: [PATCH 08/37] block: Don't use guest sector size for qemu_blockalign() + +Message-id: <1392117622-28812-9-git-send-email-kwolf@redhat.com> +Patchwork-id: 57173 +O-Subject: [RHEL-7.0 qemu-kvm PATCH v2 08/37] block: Don't use guest sector size for qemu_blockalign() +Bugzilla: 748906 +RH-Acked-by: Laszlo Ersek +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Max Reitz + +bs->buffer_alignment is set by the device emulation and contains the +logical block size of the guest device. This isn't something that the +block layer should know, and even less something to use for determining +the right alignment of buffers to be used for the host. + +The new BlockLimits field opt_mem_alignment tells the qemu block layer +the optimal alignment to be used so that no bounce buffer must be used +in the driver. + +This patch may change the buffer alignment from 4k to 512 for all +callers that used qemu_blockalign() with the top-level image format +BlockDriverState. The value was never propagated to other levels in the +tree, so in particular raw-posix never required anything else than 512. + +While on disks with 4k sectors direct I/O requires a 4k alignment, +memory may still be okay when aligned to 512 byte boundaries. This is +what must have happened in practice, because otherwise this would +already have failed earlier. Therefore I don't expect regressions even +with this intermediate state. Later, raw-posix can implement the hook +and expose a different memory alignment requirement. + +Signed-off-by: Kevin Wolf +Reviewed-by: Wenchao Xia +Reviewed-by: Max Reitz +(cherry picked from commit 339064d5063924e5176842abbf6c8089f3479c5b) + +Signed-off-by: Kevin Wolf +--- + block.c | 23 ++++++++++++++++++++--- + include/block/block.h | 3 +++ + include/block/block_int.h | 3 +++ + 3 files changed, 26 insertions(+), 3 deletions(-) +--- + block.c | 23 ++++++++++++++++++++--- + include/block/block.h | 3 +++ + include/block/block_int.h | 3 +++ + 3 files changed, 26 insertions(+), 3 deletions(-) + +diff --git a/block.c b/block.c +index 6c98ff7..c85f43e 100644 +--- a/block.c ++++ b/block.c +@@ -185,6 +185,16 @@ static void bdrv_io_limits_intercept(BlockDriverState *bs, + qemu_co_queue_next(&bs->throttled_reqs); + } + ++size_t bdrv_opt_mem_align(BlockDriverState *bs) ++{ ++ if (!bs || !bs->drv) { ++ /* 4k should be on the safe side */ ++ return 4096; ++ } ++ ++ return bs->bl.opt_mem_alignment; ++} ++ + /* check if the path starts with ":" */ + static int path_has_protocol(const char *path) + { +@@ -460,6 +470,9 @@ int bdrv_refresh_limits(BlockDriverState *bs) + if (bs->file) { + bdrv_refresh_limits(bs->file); + bs->bl.opt_transfer_length = bs->file->bl.opt_transfer_length; ++ bs->bl.opt_mem_alignment = bs->file->bl.opt_mem_alignment; ++ } else { ++ bs->bl.opt_mem_alignment = 512; + } + + if (bs->backing_hd) { +@@ -467,6 +480,9 @@ int bdrv_refresh_limits(BlockDriverState *bs) + bs->bl.opt_transfer_length = + MAX(bs->bl.opt_transfer_length, + bs->backing_hd->bl.opt_transfer_length); ++ bs->bl.opt_mem_alignment = ++ MAX(bs->bl.opt_mem_alignment, ++ bs->backing_hd->bl.opt_mem_alignment); + } + + /* Then let the driver override it */ +@@ -4729,7 +4745,7 @@ void bdrv_set_buffer_alignment(BlockDriverState *bs, int align) + + void *qemu_blockalign(BlockDriverState *bs, size_t size) + { +- return qemu_memalign((bs && bs->buffer_alignment) ? bs->buffer_alignment : 512, size); ++ return qemu_memalign(bdrv_opt_mem_align(bs), size); + } + + /* +@@ -4738,12 +4754,13 @@ void *qemu_blockalign(BlockDriverState *bs, size_t size) + bool bdrv_qiov_is_aligned(BlockDriverState *bs, QEMUIOVector *qiov) + { + int i; ++ size_t alignment = bdrv_opt_mem_align(bs); + + for (i = 0; i < qiov->niov; i++) { +- if ((uintptr_t) qiov->iov[i].iov_base % bs->buffer_alignment) { ++ if ((uintptr_t) qiov->iov[i].iov_base % alignment) { + return false; + } +- if (qiov->iov[i].iov_len % bs->buffer_alignment) { ++ if (qiov->iov[i].iov_len % alignment) { + return false; + } + } +diff --git a/include/block/block.h b/include/block/block.h +index 3e22fc2..9d1ce59 100644 +--- a/include/block/block.h ++++ b/include/block/block.h +@@ -406,6 +406,9 @@ void bdrv_img_create(const char *filename, const char *fmt, + char *options, uint64_t img_size, int flags, + Error **errp, bool quiet); + ++/* Returns the alignment in bytes that is required so that no bounce buffer ++ * is required throughout the stack */ ++size_t bdrv_opt_mem_align(BlockDriverState *bs); + void bdrv_set_buffer_alignment(BlockDriverState *bs, int align); + void *qemu_blockalign(BlockDriverState *bs, size_t size); + bool bdrv_qiov_is_aligned(BlockDriverState *bs, QEMUIOVector *qiov); +diff --git a/include/block/block_int.h b/include/block/block_int.h +index 13a52e8..ddbd53d 100644 +--- a/include/block/block_int.h ++++ b/include/block/block_int.h +@@ -239,6 +239,9 @@ typedef struct BlockLimits { + + /* optimal transfer length in sectors */ + int opt_transfer_length; ++ ++ /* memory alignment so that no bounce buffer is needed */ ++ size_t opt_mem_alignment; + } BlockLimits; + + /* +-- +1.7.1 + diff --git a/SOURCES/kvm-block-Dont-ignore-previously-set-bdrv_flags.patch b/SOURCES/kvm-block-Dont-ignore-previously-set-bdrv_flags.patch new file mode 100644 index 0000000..d214982 --- /dev/null +++ b/SOURCES/kvm-block-Dont-ignore-previously-set-bdrv_flags.patch @@ -0,0 +1,55 @@ +From 914cc2a5576cd45afa5f6d6f5327da9cc4d3bbac Mon Sep 17 00:00:00 2001 +Message-Id: <914cc2a5576cd45afa5f6d6f5327da9cc4d3bbac.1387276076.git.minovotn@redhat.com> +In-Reply-To: +References: +From: Paolo Bonzini +Date: Tue, 10 Dec 2013 14:33:38 +0100 +Subject: [PATCH 08/16] block: Dont ignore previously set bdrv_flags + +RH-Author: Paolo Bonzini +Message-id: <1386686018-11942-1-git-send-email-pbonzini@redhat.com> +Patchwork-id: 56109 +O-Subject: [RHEL 7.0 qemu-kvm PATCH] block: Dont ignore previously set bdrv_flags +Bugzilla: 1039501 +RH-Acked-by: Kevin Wolf +RH-Acked-by: Fam Zheng +RH-Acked-by: Markus Armbruster +RH-Acked-by: Stefan Hajnoczi + +From: "M. Mohan Kumar" + +Bugzilla: 1039501 + +Brew build: 6700417 + +bdrv_flags is set by bdrv_parse_discard_flags(), but later it is reset +to zero. + +Signed-off-by: M. Mohan Kumar +Message-id: 1376483201-13466-1-git-send-email-mohan@in.ibm.com +Signed-off-by: Anthony Liguori +(cherry picked from commit 8b7a5415f9297c1fbae5bff28dcb059d50c1b045) +--- + blockdev.c | 1 - + 1 file changed, 1 deletion(-) + +Signed-off-by: Michal Novotny +--- + blockdev.c | 1 - + 1 file changed, 1 deletion(-) + +diff --git a/blockdev.c b/blockdev.c +index a9c5d32..cdd453a 100644 +--- a/blockdev.c ++++ b/blockdev.c +@@ -384,7 +384,6 @@ static DriveInfo *blockdev_init(QDict *bs_opts, + } + } + +- bdrv_flags = 0; + if (qemu_opt_get_bool(opts, "cache.writeback", true)) { + bdrv_flags |= BDRV_O_CACHE_WB; + } +-- +1.7.11.7 + diff --git a/SOURCES/kvm-block-Fix-32-bit-truncation-in-mark_request_serialis.patch b/SOURCES/kvm-block-Fix-32-bit-truncation-in-mark_request_serialis.patch new file mode 100644 index 0000000..268eeb5 --- /dev/null +++ b/SOURCES/kvm-block-Fix-32-bit-truncation-in-mark_request_serialis.patch @@ -0,0 +1,51 @@ +From 68dbc9269577747455be55f209066926d1994d3c Mon Sep 17 00:00:00 2001 +From: Kevin Wolf +Date: Sat, 8 Feb 2014 10:42:18 +0100 +Subject: [PATCH 22/37] block: Fix 32 bit truncation in mark_request_serialising() + +Message-id: <1392117622-28812-23-git-send-email-kwolf@redhat.com> +Patchwork-id: 57187 +O-Subject: [RHEL-7.0 qemu-kvm PATCH v2 22/37] block: Fix 32 bit truncation in mark_request_serialising() +Bugzilla: 748906 +RH-Acked-by: Laszlo Ersek +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Max Reitz + +On 32 bit hosts, size_t is too small for align as the bitmask +~(align - 1) will zero out the higher 32 bits of the offset. + +While at it, change the local overlap_bytes variable to unsigned to +match the field in BdrvTrackedRequest. + +Signed-off-by: Kevin Wolf +Reviewed-by: Laszlo Ersek +Signed-off-by: Kevin Wolf +--- + block.c | 6 +++--- + 1 file changed, 3 insertions(+), 3 deletions(-) +--- + block.c | 6 +++--- + 1 files changed, 3 insertions(+), 3 deletions(-) + +diff --git a/block.c b/block.c +index 24e94e6..94fd702 100644 +--- a/block.c ++++ b/block.c +@@ -2088,11 +2088,11 @@ static void tracked_request_begin(BdrvTrackedRequest *req, + QLIST_INSERT_HEAD(&bs->tracked_requests, req, list); + } + +-static void mark_request_serialising(BdrvTrackedRequest *req, size_t align) ++static void mark_request_serialising(BdrvTrackedRequest *req, uint64_t align) + { + int64_t overlap_offset = req->offset & ~(align - 1); +- int overlap_bytes = ROUND_UP(req->offset + req->bytes, align) +- - overlap_offset; ++ unsigned int overlap_bytes = ROUND_UP(req->offset + req->bytes, align) ++ - overlap_offset; + + if (!req->serialising) { + req->bs->serialising_in_flight++; +-- +1.7.1 + diff --git a/SOURCES/kvm-block-Fix-bdrv_commit-return-value.patch b/SOURCES/kvm-block-Fix-bdrv_commit-return-value.patch new file mode 100644 index 0000000..ed3f2dd --- /dev/null +++ b/SOURCES/kvm-block-Fix-bdrv_commit-return-value.patch @@ -0,0 +1,86 @@ +From 89bdd1d20e9ccde41f271fe5dc22c355cbbc822a Mon Sep 17 00:00:00 2001 +From: Jeffrey Cody +Date: Tue, 11 Feb 2014 16:14:28 +0100 +Subject: [PATCH 22/28] block: Fix bdrv_commit return value + +RH-Author: Jeffrey Cody +Message-id: <5019e17d0114b49c58c42415e79b81abdcb648d3.1392134912.git.jcody@redhat.com> +Patchwork-id: 57218 +O-Subject: [RHEL7 qemu-kvm PATCH 4/6] block: Fix bdrv_commit return value +Bugzilla: 1047254 +RH-Acked-by: Kevin Wolf +RH-Acked-by: Markus Armbruster +RH-Acked-by: Miroslav Rezanina + +From: Kevin Wolf + +bdrv_commit() could return 0 or 1 on success, depending on whether or +not the last sector was allocated in the overlay and whether the overlay +format had a .bdrv_make_empty callback. + +Most callers ignored it, but qemu-img commit would print an error +message while the operation actually succeeded. + +Also clean up the handling of I/O errors to return the real error code +instead of -EIO. + +Signed-off-by: Kevin Wolf +Reviewed-by: Benoit Canet +(cherry picked from commit dabfa6cc2e2a06269026fcb42772894f67bd0c3e) +--- + block.c | 15 ++++++++++----- + 1 file changed, 10 insertions(+), 5 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + block.c | 15 ++++++++++----- + 1 files changed, 10 insertions(+), 5 deletions(-) + +diff --git a/block.c b/block.c +index c7aa285..642e8d6 100644 +--- a/block.c ++++ b/block.c +@@ -2006,13 +2006,13 @@ int bdrv_commit(BlockDriverState *bs) + goto ro_cleanup; + } + if (ret) { +- if (bdrv_read(bs, sector, buf, n) != 0) { +- ret = -EIO; ++ ret = bdrv_read(bs, sector, buf, n); ++ if (ret < 0) { + goto ro_cleanup; + } + +- if (bdrv_write(bs->backing_hd, sector, buf, n) != 0) { +- ret = -EIO; ++ ret = bdrv_write(bs->backing_hd, sector, buf, n); ++ if (ret < 0) { + goto ro_cleanup; + } + } +@@ -2020,6 +2020,9 @@ int bdrv_commit(BlockDriverState *bs) + + if (drv->bdrv_make_empty) { + ret = drv->bdrv_make_empty(bs); ++ if (ret < 0) { ++ goto ro_cleanup; ++ } + bdrv_flush(bs); + } + +@@ -2027,9 +2030,11 @@ int bdrv_commit(BlockDriverState *bs) + * Make sure all data we wrote to the backing device is actually + * stable on disk. + */ +- if (bs->backing_hd) ++ if (bs->backing_hd) { + bdrv_flush(bs->backing_hd); ++ } + ++ ret = 0; + ro_cleanup: + g_free(buf); + +-- +1.7.1 + diff --git a/SOURCES/kvm-block-Fix-bs-request_alignment-assertion-for-bs-sg-1.patch b/SOURCES/kvm-block-Fix-bs-request_alignment-assertion-for-bs-sg-1.patch new file mode 100644 index 0000000..91d678b --- /dev/null +++ b/SOURCES/kvm-block-Fix-bs-request_alignment-assertion-for-bs-sg-1.patch @@ -0,0 +1,47 @@ +From bac8088573d7f0a60e8e785aeaa442a1d90de0e4 Mon Sep 17 00:00:00 2001 +From: Kevin Wolf +Date: Mon, 10 Mar 2014 11:07:22 +0100 +Subject: [PATCH 14/16] block: Fix bs->request_alignment assertion for bs->sg=1 + +RH-Author: Kevin Wolf +Message-id: <1394449642-13562-3-git-send-email-kwolf@redhat.com> +Patchwork-id: 58064 +O-Subject: [RHEL-7.0 qemu-kvm PATCH 2/2] block: Fix bs->request_alignment assertion for bs->sg=1 +Bugzilla: 1067784 +RH-Acked-by: Juan Quintela +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Paolo Bonzini + +For sg backends, bs->request_alignment is meaningless and may be 0. + +Signed-off-by: Kevin Wolf +Reviewed-by: Benoit Canet +Acked-by: Paolo Bonzini +(cherry picked from commit 47ea2de2d68b6c5319308b7de1980f463b7c125c) + +Signed-off-by: Kevin Wolf +--- + block.c | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +Signed-off-by: Miroslav Rezanina +--- + block.c | 2 +- + 1 files changed, 1 insertions(+), 1 deletions(-) + +diff --git a/block.c b/block.c +index 642e8d6..ec8dc90 100644 +--- a/block.c ++++ b/block.c +@@ -847,7 +847,7 @@ static int bdrv_open_common(BlockDriverState *bs, BlockDriverState *file, + + bdrv_refresh_limits(bs); + assert(bdrv_opt_mem_align(bs) != 0); +- assert(bs->request_alignment != 0); ++ assert((bs->request_alignment != 0) || bs->sg); + + #ifndef _WIN32 + if (bs->is_temporary) { +-- +1.7.1 + diff --git a/SOURCES/kvm-block-Generalise-and-optimise-COR-serialisation.patch b/SOURCES/kvm-block-Generalise-and-optimise-COR-serialisation.patch new file mode 100644 index 0000000..4bea776 --- /dev/null +++ b/SOURCES/kvm-block-Generalise-and-optimise-COR-serialisation.patch @@ -0,0 +1,190 @@ +From 045f704f819575af1bf69b59ffe73db5ba0cf19b Mon Sep 17 00:00:00 2001 +From: Kevin Wolf +Date: Wed, 4 Dec 2013 16:43:44 +0100 +Subject: [PATCH 20/37] block: Generalise and optimise COR serialisation + +Message-id: <1392117622-28812-21-git-send-email-kwolf@redhat.com> +Patchwork-id: 57185 +O-Subject: [RHEL-7.0 qemu-kvm PATCH v2 20/37] block: Generalise and optimise COR serialisation +Bugzilla: 748906 +RH-Acked-by: Laszlo Ersek +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Max Reitz + +Change the API so that specific requests can be marked serialising. Only +these requests are checked for overlaps then. + +This means that during a Copy on Read operation, not all requests +overlapping other requests are serialised any more, but only those that +actually overlap with the specific COR request. + +Also remove COR from function and variable names because this +functionality can be useful in other contexts. + +Signed-off-by: Kevin Wolf +Reviewed-by: Max Reitz +Reviewed-by: Benoit Canet +(cherry picked from commit 2dbafdc012d3ea81a97fec6226ca82d644539c9a) + +Conflicts: + include/block/block_int.h + +Conflicts because in RHEL 7... +- ...write notifiers don't exist (context only) +- ...BdrvTrackRequest is in block.c rather than block_int.h + +Signed-off-by: Kevin Wolf +--- + block.c | 49 +++++++++++++++++++++++++++++------------------ + include/block/block_int.h | 4 ++-- + 2 files changed, 32 insertions(+), 21 deletions(-) +--- + block.c | 49 +++++++++++++++++++++++++++----------------- + include/block/block_int.h | 4 +- + 2 files changed, 32 insertions(+), 21 deletions(-) + +diff --git a/block.c b/block.c +index 6317321..7b30bb3 100644 +--- a/block.c ++++ b/block.c +@@ -2039,6 +2039,7 @@ struct BdrvTrackedRequest { + int64_t offset; + unsigned int bytes; + bool is_write; ++ bool serialising; + QLIST_ENTRY(BdrvTrackedRequest) list; + Coroutine *co; /* owner, used for deadlock detection */ + CoQueue wait_queue; /* coroutines blocked on this request */ +@@ -2051,6 +2052,10 @@ struct BdrvTrackedRequest { + */ + static void tracked_request_end(BdrvTrackedRequest *req) + { ++ if (req->serialising) { ++ req->bs->serialising_in_flight--; ++ } ++ + QLIST_REMOVE(req, list); + qemu_co_queue_restart_all(&req->wait_queue); + } +@@ -2065,10 +2070,11 @@ static void tracked_request_begin(BdrvTrackedRequest *req, + { + *req = (BdrvTrackedRequest){ + .bs = bs, +- .offset = offset, +- .bytes = bytes, +- .is_write = is_write, +- .co = qemu_coroutine_self(), ++ .offset = offset, ++ .bytes = bytes, ++ .is_write = is_write, ++ .co = qemu_coroutine_self(), ++ .serialising = false, + }; + + qemu_co_queue_init(&req->wait_queue); +@@ -2076,6 +2082,14 @@ static void tracked_request_begin(BdrvTrackedRequest *req, + QLIST_INSERT_HEAD(&bs->tracked_requests, req, list); + } + ++static void mark_request_serialising(BdrvTrackedRequest *req) ++{ ++ if (!req->serialising) { ++ req->bs->serialising_in_flight++; ++ req->serialising = true; ++ } ++} ++ + /** + * Round a region to cluster boundaries + */ +@@ -2128,26 +2142,31 @@ static bool tracked_request_overlaps(BdrvTrackedRequest *req, + return true; + } + +-static void coroutine_fn wait_for_overlapping_requests(BlockDriverState *bs, +- BdrvTrackedRequest *self, int64_t offset, unsigned int bytes) ++static void coroutine_fn wait_serialising_requests(BdrvTrackedRequest *self) + { ++ BlockDriverState *bs = self->bs; + BdrvTrackedRequest *req; + int64_t cluster_offset; + unsigned int cluster_bytes; + bool retry; + ++ if (!bs->serialising_in_flight) { ++ return; ++ } ++ + /* If we touch the same cluster it counts as an overlap. This guarantees + * that allocating writes will be serialized and not race with each other + * for the same cluster. For example, in copy-on-read it ensures that the + * CoR read and write operations are atomic and guest writes cannot + * interleave between them. + */ +- round_bytes_to_clusters(bs, offset, bytes, &cluster_offset, &cluster_bytes); ++ round_bytes_to_clusters(bs, self->offset, self->bytes, ++ &cluster_offset, &cluster_bytes); + + do { + retry = false; + QLIST_FOREACH(req, &bs->tracked_requests, list) { +- if (req == self) { ++ if (req == self || (!req->serialising && !self->serialising)) { + continue; + } + if (tracked_request_overlaps(req, cluster_offset, cluster_bytes)) { +@@ -2761,12 +2780,10 @@ static int coroutine_fn bdrv_aligned_preadv(BlockDriverState *bs, + + /* Handle Copy on Read and associated serialisation */ + if (flags & BDRV_REQ_COPY_ON_READ) { +- bs->copy_on_read_in_flight++; ++ mark_request_serialising(req); + } + +- if (bs->copy_on_read_in_flight) { +- wait_for_overlapping_requests(bs, req, offset, bytes); +- } ++ wait_serialising_requests(req); + + if (flags & BDRV_REQ_COPY_ON_READ) { + int pnum; +@@ -2815,10 +2832,6 @@ static int coroutine_fn bdrv_aligned_preadv(BlockDriverState *bs, + } + + out: +- if (flags & BDRV_REQ_COPY_ON_READ) { +- bs->copy_on_read_in_flight--; +- } +- + return ret; + } + +@@ -3017,9 +3030,7 @@ static int coroutine_fn bdrv_aligned_pwritev(BlockDriverState *bs, + assert((offset & (BDRV_SECTOR_SIZE - 1)) == 0); + assert((bytes & (BDRV_SECTOR_SIZE - 1)) == 0); + +- if (bs->copy_on_read_in_flight) { +- wait_for_overlapping_requests(bs, req, offset, bytes); +- } ++ wait_serialising_requests(req); + + if (flags & BDRV_REQ_ZERO_WRITE) { + ret = bdrv_co_do_write_zeroes(bs, sector_num, nb_sectors, flags); +diff --git a/include/block/block_int.h b/include/block/block_int.h +index e66bd5f..2ec4bb2 100644 +--- a/include/block/block_int.h ++++ b/include/block/block_int.h +@@ -280,8 +280,8 @@ struct BlockDriverState { + + NotifierList close_notifiers; + +- /* number of in-flight copy-on-read requests */ +- unsigned int copy_on_read_in_flight; ++ /* number of in-flight serialising requests */ ++ unsigned int serialising_in_flight; + + /* the time for latest disk I/O */ + int64_t slice_start; +-- +1.7.1 + diff --git a/SOURCES/kvm-block-Image-file-option-amendment.patch b/SOURCES/kvm-block-Image-file-option-amendment.patch new file mode 100644 index 0000000..f691b0b --- /dev/null +++ b/SOURCES/kvm-block-Image-file-option-amendment.patch @@ -0,0 +1,230 @@ +From 5fcb6627be0a9a6744546adab5e638d4a265d2b7 Mon Sep 17 00:00:00 2001 +From: Max Reitz +Date: Tue, 7 Jan 2014 21:57:09 +0100 +Subject: [PATCH 04/14] block: Image file option amendment + +RH-Author: Max Reitz +Message-id: <1389131839-12920-5-git-send-email-mreitz@redhat.com> +Patchwork-id: 56540 +O-Subject: [RHEL-7.0 qemu-kvm PATCH v2 04/14] block: Image file option amendment +Bugzilla: 1033490 +RH-Acked-by: Kevin Wolf +RH-Acked-by: Fam Zheng +RH-Acked-by: Stefan Hajnoczi + +BZ: 1033490 + +This patch adds the "amend" option to qemu-img which allows changing +image options on existing image files. It also adds the generic bdrv +implementation which is basically just a wrapper for the image format +specific function. + +Signed-off-by: Max Reitz +Signed-off-by: Kevin Wolf +(cherry picked from commit 6f176b48f9f98820ed192a1355cc1c7c08ddf46b) + +Signed-off-by: Max Reitz + +Conflicts: + block.c + qemu-img.c + +Conflicts because d616b224745b2c522f965cf8de7da17b553b959a has not yet +been backported. This is a single additional function which is missing +from the context in this case, therefore later backporting of that +commit would be trivial and obvious to resolve. + +Conflicts in qemu-img.c, because it is bdrv_delete() downstream for now, +rather than bdrv_unref(). +--- + block.c | 8 +++++ + include/block/block.h | 2 ++ + include/block/block_int.h | 3 ++ + qemu-img-cmds.hx | 6 ++++ + qemu-img.c | 84 +++++++++++++++++++++++++++++++++++++++++++++++ + qemu-img.texi | 5 +++ + 6 files changed, 108 insertions(+) + +Signed-off-by: Miroslav Rezanina +--- + block.c | 8 ++++ + include/block/block.h | 2 + + include/block/block_int.h | 3 ++ + qemu-img-cmds.hx | 6 +++ + qemu-img.c | 84 +++++++++++++++++++++++++++++++++++++++++++++ + qemu-img.texi | 5 +++ + 6 files changed, 108 insertions(+), 0 deletions(-) + +diff --git a/block.c b/block.c +index 1ac1ab3..cc7afd4 100644 +--- a/block.c ++++ b/block.c +@@ -4980,3 +4980,11 @@ AioContext *bdrv_get_aio_context(BlockDriverState *bs) + /* Currently BlockDriverState always uses the main loop AioContext */ + return qemu_get_aio_context(); + } ++ ++int bdrv_amend_options(BlockDriverState *bs, QEMUOptionParameter *options) ++{ ++ if (bs->drv->bdrv_amend_options == NULL) { ++ return -ENOTSUP; ++ } ++ return bs->drv->bdrv_amend_options(bs, options); ++} +diff --git a/include/block/block.h b/include/block/block.h +index bcf71e2..e7f718c 100644 +--- a/include/block/block.h ++++ b/include/block/block.h +@@ -280,6 +280,8 @@ typedef enum { + + int bdrv_check(BlockDriverState *bs, BdrvCheckResult *res, BdrvCheckMode fix); + ++int bdrv_amend_options(BlockDriverState *bs_new, QEMUOptionParameter *options); ++ + /* async block I/O */ + typedef void BlockDriverDirtyHandler(BlockDriverState *bs, int64_t sector, + int sector_num); +diff --git a/include/block/block_int.h b/include/block/block_int.h +index 71c8b53..d49a317 100644 +--- a/include/block/block_int.h ++++ b/include/block/block_int.h +@@ -202,6 +202,9 @@ struct BlockDriver { + int (*bdrv_check)(BlockDriverState* bs, BdrvCheckResult *result, + BdrvCheckMode fix); + ++ int (*bdrv_amend_options)(BlockDriverState *bs, ++ QEMUOptionParameter *options); ++ + void (*bdrv_debug_event)(BlockDriverState *bs, BlkDebugEvent event); + + /* TODO Better pass a option string/QDict/QemuOpts to add any rule? */ +diff --git a/qemu-img-cmds.hx b/qemu-img-cmds.hx +index 0c36e59..da1d965 100644 +--- a/qemu-img-cmds.hx ++++ b/qemu-img-cmds.hx +@@ -67,5 +67,11 @@ DEF("resize", img_resize, + "resize [-q] filename [+ | -]size") + STEXI + @item resize [-q] @var{filename} [+ | -]@var{size} ++ETEXI ++ ++DEF("amend", img_amend, ++ "amend [-q] [-f fmt] -o options filename") ++STEXI ++@item amend [-q] [-f @var{fmt}] -o @var{options} @var{filename} + @end table + ETEXI +diff --git a/qemu-img.c b/qemu-img.c +index 1fe175b..f0f70e4 100644 +--- a/qemu-img.c ++++ b/qemu-img.c +@@ -2566,6 +2566,90 @@ out: + return 0; + } + ++static int img_amend(int argc, char **argv) ++{ ++ int c, ret = 0; ++ char *options = NULL; ++ QEMUOptionParameter *create_options = NULL, *options_param = NULL; ++ const char *fmt = NULL, *filename; ++ bool quiet = false; ++ BlockDriverState *bs = NULL; ++ ++ for (;;) { ++ c = getopt(argc, argv, "hqf:o:"); ++ if (c == -1) { ++ break; ++ } ++ ++ switch (c) { ++ case 'h': ++ case '?': ++ help(); ++ break; ++ case 'o': ++ options = optarg; ++ break; ++ case 'f': ++ fmt = optarg; ++ break; ++ case 'q': ++ quiet = true; ++ break; ++ } ++ } ++ ++ if (optind != argc - 1) { ++ help(); ++ } ++ ++ if (!options) { ++ help(); ++ } ++ ++ filename = argv[argc - 1]; ++ ++ bs = bdrv_new_open(filename, fmt, BDRV_O_FLAGS | BDRV_O_RDWR, true, quiet); ++ if (!bs) { ++ error_report("Could not open image '%s'", filename); ++ ret = -1; ++ goto out; ++ } ++ ++ fmt = bs->drv->format_name; ++ ++ if (is_help_option(options)) { ++ ret = print_block_option_help(filename, fmt); ++ goto out; ++ } ++ ++ create_options = append_option_parameters(create_options, ++ bs->drv->create_options); ++ options_param = parse_option_parameters(options, create_options, ++ options_param); ++ if (options_param == NULL) { ++ error_report("Invalid options for file format '%s'", fmt); ++ ret = -1; ++ goto out; ++ } ++ ++ ret = bdrv_amend_options(bs, options_param); ++ if (ret < 0) { ++ error_report("Error while amending options: %s", strerror(-ret)); ++ goto out; ++ } ++ ++out: ++ if (bs) { ++ bdrv_delete(bs); ++ } ++ free_option_parameters(create_options); ++ free_option_parameters(options_param); ++ if (ret) { ++ return 1; ++ } ++ return 0; ++} ++ + static const img_cmd_t img_cmds[] = { + #define DEF(option, callback, arg_string) \ + { option, callback }, +diff --git a/qemu-img.texi b/qemu-img.texi +index dc578bb..da36975 100644 +--- a/qemu-img.texi ++++ b/qemu-img.texi +@@ -356,6 +356,11 @@ sizes accordingly. Failure to do so will result in data loss! + After using this command to grow a disk image, you must use file system and + partitioning tools inside the VM to actually begin using the new space on the + device. ++ ++@item amend [-f @var{fmt}] -o @var{options} @var{filename} ++ ++Amends the image format specific @var{options} for the image file ++@var{filename}. Not all file formats support this operation. + @end table + @c man end + +-- +1.7.1 + diff --git a/SOURCES/kvm-block-Inherit-opt_transfer_length.patch b/SOURCES/kvm-block-Inherit-opt_transfer_length.patch new file mode 100644 index 0000000..42ccd34 --- /dev/null +++ b/SOURCES/kvm-block-Inherit-opt_transfer_length.patch @@ -0,0 +1,69 @@ +From 56adc601b22b81ae4c681af6b13f38e560f16867 Mon Sep 17 00:00:00 2001 +From: Kevin Wolf +Date: Wed, 11 Dec 2013 19:50:32 +0100 +Subject: [PATCH 04/37] block: Inherit opt_transfer_length +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +Message-id: <1392117622-28812-5-git-send-email-kwolf@redhat.com> +Patchwork-id: 57169 +O-Subject: [RHEL-7.0 qemu-kvm PATCH v2 04/37] block: Inherit opt_transfer_length +Bugzilla: 748906 +RH-Acked-by: Laszlo Ersek +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Max Reitz + +When there is a format driver between the backend, it's not guaranteed +that exposing the opt_transfer_length for the format driver results in +the optimal requests (because of fragmentation etc.), but it can't make +things worse, so let's just do it. + +Signed-off-by: Kevin Wolf +Reviewed-by: Wenchao Xia +Reviewed-by: Max Reitz +Reviewed-by: Benoît Canet +(cherry picked from commit 466ad822deef3a03757d505218a52993c5d56b5d) + +Signed-off-by: Kevin Wolf +--- + block.c | 20 +++++++++++++++++++- + 1 file changed, 19 insertions(+), 1 deletion(-) +--- + block.c | 20 +++++++++++++++++++- + 1 files changed, 19 insertions(+), 1 deletions(-) + +diff --git a/block.c b/block.c +index 26eebcc..8b36d05 100644 +--- a/block.c ++++ b/block.c +@@ -452,7 +452,25 @@ static int bdrv_refresh_limits(BlockDriverState *bs) + + memset(&bs->bl, 0, sizeof(bs->bl)); + +- if (drv && drv->bdrv_refresh_limits) { ++ if (!drv) { ++ return 0; ++ } ++ ++ /* Take some limits from the children as a default */ ++ if (bs->file) { ++ bdrv_refresh_limits(bs->file); ++ bs->bl.opt_transfer_length = bs->file->bl.opt_transfer_length; ++ } ++ ++ if (bs->backing_hd) { ++ bdrv_refresh_limits(bs->backing_hd); ++ bs->bl.opt_transfer_length = ++ MAX(bs->bl.opt_transfer_length, ++ bs->backing_hd->bl.opt_transfer_length); ++ } ++ ++ /* Then let the driver override it */ ++ if (drv->bdrv_refresh_limits) { + return drv->bdrv_refresh_limits(bs); + } + +-- +1.7.1 + diff --git a/SOURCES/kvm-block-Introduce-bdrv_aligned_preadv.patch b/SOURCES/kvm-block-Introduce-bdrv_aligned_preadv.patch new file mode 100644 index 0000000..b869dca --- /dev/null +++ b/SOURCES/kvm-block-Introduce-bdrv_aligned_preadv.patch @@ -0,0 +1,131 @@ +From d5b3c858d7d2d96cf89495c95c2f07eb246b6730 Mon Sep 17 00:00:00 2001 +From: Kevin Wolf +Date: Mon, 2 Dec 2013 15:07:48 +0100 +Subject: [PATCH 11/37] block: Introduce bdrv_aligned_preadv() + +Message-id: <1392117622-28812-12-git-send-email-kwolf@redhat.com> +Patchwork-id: 57176 +O-Subject: [RHEL-7.0 qemu-kvm PATCH v2 11/37] block: Introduce bdrv_aligned_preadv() +Bugzilla: 748906 +RH-Acked-by: Laszlo Ersek +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Max Reitz + +This separates the part of bdrv_co_do_readv() that needs to happen +before the request is modified to match the backend alignment, and a +part that needs to be executed afterwards and passes the request to the +BlockDriver. + +Signed-off-by: Kevin Wolf +Reviewed-by: Wenchao Xia +Reviewed-by: Max Reitz +(cherry picked from commit d0c7f642f5eb2cb21d0c3acf766cb375eaaf4666) + +Conflicts: + block.c + +Conflicts because RHEL 7 still has the old I/O throttling code. + +Signed-off-by: Kevin Wolf +--- + block.c | 59 ++++++++++++++++++++++++++++++++++++++++++----------------- + 1 file changed, 42 insertions(+), 17 deletions(-) +--- + block.c | 59 ++++++++++++++++++++++++++++++++++++++++++----------------- + 1 files changed, 42 insertions(+), 17 deletions(-) + +diff --git a/block.c b/block.c +index 40a4a34..1787ab0 100644 +--- a/block.c ++++ b/block.c +@@ -2723,31 +2723,24 @@ err: + } + + /* +- * Handle a read request in coroutine context ++ * Forwards an already correctly aligned request to the BlockDriver. This ++ * handles copy on read and zeroing after EOF; any other features must be ++ * implemented by the caller. + */ +-static int coroutine_fn bdrv_co_do_readv(BlockDriverState *bs, +- int64_t sector_num, int nb_sectors, QEMUIOVector *qiov, +- BdrvRequestFlags flags) ++static int coroutine_fn bdrv_aligned_preadv(BlockDriverState *bs, ++ int64_t offset, unsigned int bytes, QEMUIOVector *qiov, int flags) + { + BlockDriver *drv = bs->drv; + BdrvTrackedRequest req; + int ret; + +- if (!drv) { +- return -ENOMEDIUM; +- } +- if (bdrv_check_request(bs, sector_num, nb_sectors)) { +- return -EIO; +- } ++ int64_t sector_num = offset >> BDRV_SECTOR_BITS; ++ unsigned int nb_sectors = bytes >> BDRV_SECTOR_BITS; + +- /* throttling disk read I/O */ +- if (bs->io_limits_enabled) { +- bdrv_io_limits_intercept(bs, false, nb_sectors); +- } ++ assert((offset & (BDRV_SECTOR_SIZE - 1)) == 0); ++ assert((bytes & (BDRV_SECTOR_SIZE - 1)) == 0); + +- if (bs->copy_on_read) { +- flags |= BDRV_REQ_COPY_ON_READ; +- } ++ /* Handle Copy on Read and associated serialisation */ + if (flags & BDRV_REQ_COPY_ON_READ) { + bs->copy_on_read_in_flight++; + } +@@ -2772,6 +2765,7 @@ static int coroutine_fn bdrv_co_do_readv(BlockDriverState *bs, + } + } + ++ /* Forward the request to the BlockDriver */ + if (!(bs->zero_beyond_eof && bs->growable)) { + ret = drv->bdrv_co_readv(bs, sector_num, nb_sectors, qiov); + } else { +@@ -2812,6 +2806,37 @@ out: + return ret; + } + ++/* ++ * Handle a read request in coroutine context ++ */ ++static int coroutine_fn bdrv_co_do_readv(BlockDriverState *bs, ++ int64_t sector_num, int nb_sectors, QEMUIOVector *qiov, ++ BdrvRequestFlags flags) ++{ ++ BlockDriver *drv = bs->drv; ++ int ret; ++ ++ if (!drv) { ++ return -ENOMEDIUM; ++ } ++ if (bdrv_check_request(bs, sector_num, nb_sectors)) { ++ return -EIO; ++ } ++ ++ if (bs->copy_on_read) { ++ flags |= BDRV_REQ_COPY_ON_READ; ++ } ++ ++ /* throttling disk I/O */ ++ if (bs->io_limits_enabled) { ++ bdrv_io_limits_intercept(bs, false, nb_sectors); ++ } ++ ++ ret = bdrv_aligned_preadv(bs, sector_num << BDRV_SECTOR_BITS, ++ nb_sectors << BDRV_SECTOR_BITS, qiov, flags); ++ return ret; ++} ++ + int coroutine_fn bdrv_co_readv(BlockDriverState *bs, int64_t sector_num, + int nb_sectors, QEMUIOVector *qiov) + { +-- +1.7.1 + diff --git a/SOURCES/kvm-block-Introduce-bdrv_aligned_pwritev.patch b/SOURCES/kvm-block-Introduce-bdrv_aligned_pwritev.patch new file mode 100644 index 0000000..c9cb9e3 --- /dev/null +++ b/SOURCES/kvm-block-Introduce-bdrv_aligned_pwritev.patch @@ -0,0 +1,126 @@ +From d6a03733e6755d4b59f8009239af8f0a3e12c171 Mon Sep 17 00:00:00 2001 +From: Kevin Wolf +Date: Tue, 3 Dec 2013 14:02:23 +0100 +Subject: [PATCH 13/37] block: Introduce bdrv_aligned_pwritev() + +Message-id: <1392117622-28812-14-git-send-email-kwolf@redhat.com> +Patchwork-id: 57178 +O-Subject: [RHEL-7.0 qemu-kvm PATCH v2 13/37] block: Introduce bdrv_aligned_pwritev() +Bugzilla: 748906 +RH-Acked-by: Laszlo Ersek +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Max Reitz + +This separates the part of bdrv_co_do_writev() that needs to happen +before the request is modified to match the backend alignment, and a +part that needs to be executed afterwards and passes the request to the +BlockDriver. + +Signed-off-by: Kevin Wolf +Reviewed-by: Max Reitz +Reviewed-by: Benoit Canet +(cherry picked from commit b404f72036716ab8ace04b83a8f0a93be4739a6a) + +Conflicts: + block.c + +Conflict because RHEL 7 still has the old I/O throttling code. + +Signed-off-by: Kevin Wolf +--- + block.c | 62 +++++++++++++++++++++++++++++++++++++++++--------------------- + 1 file changed, 41 insertions(+), 21 deletions(-) +--- + block.c | 62 +++++++++++++++++++++++++++++++++++++++++--------------------- + 1 files changed, 41 insertions(+), 21 deletions(-) + +diff --git a/block.c b/block.c +index ce3edb0..e6b6ed4 100644 +--- a/block.c ++++ b/block.c +@@ -2982,34 +2982,20 @@ static int coroutine_fn bdrv_co_do_write_zeroes(BlockDriverState *bs, + } + + /* +- * Handle a write request in coroutine context ++ * Forwards an already correctly aligned write request to the BlockDriver. + */ +-static int coroutine_fn bdrv_co_do_writev(BlockDriverState *bs, +- int64_t sector_num, int nb_sectors, QEMUIOVector *qiov, +- BdrvRequestFlags flags) ++static int coroutine_fn bdrv_aligned_pwritev(BlockDriverState *bs, ++ int64_t offset, unsigned int bytes, QEMUIOVector *qiov, int flags) + { + BlockDriver *drv = bs->drv; + BdrvTrackedRequest req; + int ret; + +- if (!bs->drv) { +- return -ENOMEDIUM; +- } +- if (bs->read_only) { +- return -EACCES; +- } +- if (bdrv_check_request(bs, sector_num, nb_sectors)) { +- return -EIO; +- } +- +- /* throttling disk write I/O */ +- if (bs->io_limits_enabled) { +- bdrv_io_limits_intercept(bs, true, nb_sectors); +- } ++ int64_t sector_num = offset >> BDRV_SECTOR_BITS; ++ unsigned int nb_sectors = bytes >> BDRV_SECTOR_BITS; + +- if (bs->copy_on_read_in_flight) { +- wait_for_overlapping_requests(bs, sector_num, nb_sectors); +- } ++ assert((offset & (BDRV_SECTOR_SIZE - 1)) == 0); ++ assert((bytes & (BDRV_SECTOR_SIZE - 1)) == 0); + + tracked_request_begin(&req, bs, sector_num, nb_sectors, true); + +@@ -3039,6 +3025,40 @@ static int coroutine_fn bdrv_co_do_writev(BlockDriverState *bs, + return ret; + } + ++/* ++ * Handle a write request in coroutine context ++ */ ++static int coroutine_fn bdrv_co_do_writev(BlockDriverState *bs, ++ int64_t sector_num, int nb_sectors, QEMUIOVector *qiov, ++ BdrvRequestFlags flags) ++{ ++ int ret; ++ ++ if (!bs->drv) { ++ return -ENOMEDIUM; ++ } ++ if (bs->read_only) { ++ return -EACCES; ++ } ++ if (bdrv_check_request(bs, sector_num, nb_sectors)) { ++ return -EIO; ++ } ++ ++ if (bs->copy_on_read_in_flight) { ++ wait_for_overlapping_requests(bs, sector_num, nb_sectors); ++ } ++ ++ /* throttling disk I/O */ ++ if (bs->io_limits_enabled) { ++ bdrv_io_limits_intercept(bs, true, nb_sectors); ++ } ++ ++ ret = bdrv_aligned_pwritev(bs, sector_num << BDRV_SECTOR_BITS, ++ nb_sectors << BDRV_SECTOR_BITS, qiov, flags); ++ ++ return ret; ++} ++ + int coroutine_fn bdrv_co_writev(BlockDriverState *bs, int64_t sector_num, + int nb_sectors, QEMUIOVector *qiov) + { +-- +1.7.1 + diff --git a/SOURCES/kvm-block-Introduce-bdrv_co_do_preadv.patch b/SOURCES/kvm-block-Introduce-bdrv_co_do_preadv.patch new file mode 100644 index 0000000..8621aa1 --- /dev/null +++ b/SOURCES/kvm-block-Introduce-bdrv_co_do_preadv.patch @@ -0,0 +1,128 @@ +From 39ee3b773c08395007137198542c2012e11295f5 Mon Sep 17 00:00:00 2001 +From: Kevin Wolf +Date: Mon, 2 Dec 2013 16:09:46 +0100 +Subject: [PATCH 12/37] block: Introduce bdrv_co_do_preadv() + +Message-id: <1392117622-28812-13-git-send-email-kwolf@redhat.com> +Patchwork-id: 57177 +O-Subject: [RHEL-7.0 qemu-kvm PATCH v2 12/37] block: Introduce bdrv_co_do_preadv() +Bugzilla: 748906 +RH-Acked-by: Laszlo Ersek +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Max Reitz + +Similar to bdrv_pread(), which aligns byte-aligned request to 512 byte +sectors, bdrv_co_do_preadv() takes a byte-aligned request and aligns it +to the alignment specified in bs->request_alignment. + +Signed-off-by: Kevin Wolf +Reviewed-by: Max Reitz +Reviewed-by: Benoit Canet +(cherry picked from commit 1b0288ae7fc695a8e652973f75e92464bbc13416) + +Signed-off-by: Kevin Wolf +--- + block.c | 64 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++------ + 1 file changed, 58 insertions(+), 6 deletions(-) +--- + block.c | 64 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++----- + 1 files changed, 58 insertions(+), 6 deletions(-) + +diff --git a/block.c b/block.c +index 1787ab0..ce3edb0 100644 +--- a/block.c ++++ b/block.c +@@ -2809,17 +2809,23 @@ out: + /* + * Handle a read request in coroutine context + */ +-static int coroutine_fn bdrv_co_do_readv(BlockDriverState *bs, +- int64_t sector_num, int nb_sectors, QEMUIOVector *qiov, ++static int coroutine_fn bdrv_co_do_preadv(BlockDriverState *bs, ++ int64_t offset, unsigned int bytes, QEMUIOVector *qiov, + BdrvRequestFlags flags) + { + BlockDriver *drv = bs->drv; ++ /* TODO Lift BDRV_SECTOR_SIZE restriction in BlockDriver interface */ ++ uint64_t align = MAX(BDRV_SECTOR_SIZE, bs->request_alignment); ++ uint8_t *head_buf = NULL; ++ uint8_t *tail_buf = NULL; ++ QEMUIOVector local_qiov; ++ bool use_local_qiov = false; + int ret; + + if (!drv) { + return -ENOMEDIUM; + } +- if (bdrv_check_request(bs, sector_num, nb_sectors)) { ++ if (bdrv_check_byte_request(bs, offset, bytes)) { + return -EIO; + } + +@@ -2829,14 +2835,60 @@ static int coroutine_fn bdrv_co_do_readv(BlockDriverState *bs, + + /* throttling disk I/O */ + if (bs->io_limits_enabled) { +- bdrv_io_limits_intercept(bs, false, nb_sectors); ++ /* TODO Switch to byte granularity */ ++ bdrv_io_limits_intercept(bs, false, bytes >> BDRV_SECTOR_BITS); ++ } ++ ++ /* Align read if necessary by padding qiov */ ++ if (offset & (align - 1)) { ++ head_buf = qemu_blockalign(bs, align); ++ qemu_iovec_init(&local_qiov, qiov->niov + 2); ++ qemu_iovec_add(&local_qiov, head_buf, offset & (align - 1)); ++ qemu_iovec_concat(&local_qiov, qiov, 0, qiov->size); ++ use_local_qiov = true; ++ ++ bytes += offset & (align - 1); ++ offset = offset & ~(align - 1); ++ } ++ ++ if ((offset + bytes) & (align - 1)) { ++ if (!use_local_qiov) { ++ qemu_iovec_init(&local_qiov, qiov->niov + 1); ++ qemu_iovec_concat(&local_qiov, qiov, 0, qiov->size); ++ use_local_qiov = true; ++ } ++ tail_buf = qemu_blockalign(bs, align); ++ qemu_iovec_add(&local_qiov, tail_buf, ++ align - ((offset + bytes) & (align - 1))); ++ ++ bytes = ROUND_UP(bytes, align); ++ } ++ ++ ret = bdrv_aligned_preadv(bs, offset, bytes, ++ use_local_qiov ? &local_qiov : qiov, ++ flags); ++ ++ if (use_local_qiov) { ++ qemu_iovec_destroy(&local_qiov); ++ qemu_vfree(head_buf); ++ qemu_vfree(tail_buf); + } + +- ret = bdrv_aligned_preadv(bs, sector_num << BDRV_SECTOR_BITS, +- nb_sectors << BDRV_SECTOR_BITS, qiov, flags); + return ret; + } + ++static int coroutine_fn bdrv_co_do_readv(BlockDriverState *bs, ++ int64_t sector_num, int nb_sectors, QEMUIOVector *qiov, ++ BdrvRequestFlags flags) ++{ ++ if (nb_sectors < 0 || nb_sectors > (UINT_MAX >> BDRV_SECTOR_BITS)) { ++ return -EINVAL; ++ } ++ ++ return bdrv_co_do_preadv(bs, sector_num << BDRV_SECTOR_BITS, ++ nb_sectors << BDRV_SECTOR_BITS, qiov, flags); ++} ++ + int coroutine_fn bdrv_co_readv(BlockDriverState *bs, int64_t sector_num, + int nb_sectors, QEMUIOVector *qiov) + { +-- +1.7.1 + diff --git a/SOURCES/kvm-block-Introduce-bdrv_co_do_pwritev.patch b/SOURCES/kvm-block-Introduce-bdrv_co_do_pwritev.patch new file mode 100644 index 0000000..c7d1f81 --- /dev/null +++ b/SOURCES/kvm-block-Introduce-bdrv_co_do_pwritev.patch @@ -0,0 +1,86 @@ +From f1f339c365d7e68790ba8f84d0e16daac462d627 Mon Sep 17 00:00:00 2001 +From: Kevin Wolf +Date: Tue, 3 Dec 2013 14:40:18 +0100 +Subject: [PATCH 15/37] block: Introduce bdrv_co_do_pwritev() + +Message-id: <1392117622-28812-16-git-send-email-kwolf@redhat.com> +Patchwork-id: 57180 +O-Subject: [RHEL-7.0 qemu-kvm PATCH v2 15/37] block: Introduce bdrv_co_do_pwritev() +Bugzilla: 748906 +RH-Acked-by: Laszlo Ersek +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Max Reitz + +This is going to become the bdrv_co_do_preadv() equivalent for writes. +In this patch, however, just a function taking byte offsets is created, +it doesn't align anything yet. + +Signed-off-by: Kevin Wolf +Reviewed-by: Max Reitz +Reviewed-by: Benoit Canet +(cherry picked from commit 6601553e27091ffe240bea69227adce941fe12e8) + +Signed-off-by: Kevin Wolf +--- + block.c | 24 ++++++++++++++++++------ + 1 file changed, 18 insertions(+), 6 deletions(-) +--- + block.c | 24 ++++++++++++++++++------ + 1 files changed, 18 insertions(+), 6 deletions(-) + +diff --git a/block.c b/block.c +index d8168f5..7b8131c 100644 +--- a/block.c ++++ b/block.c +@@ -3032,8 +3032,8 @@ static int coroutine_fn bdrv_aligned_pwritev(BlockDriverState *bs, + /* + * Handle a write request in coroutine context + */ +-static int coroutine_fn bdrv_co_do_writev(BlockDriverState *bs, +- int64_t sector_num, int nb_sectors, QEMUIOVector *qiov, ++static int coroutine_fn bdrv_co_do_pwritev(BlockDriverState *bs, ++ int64_t offset, unsigned int bytes, QEMUIOVector *qiov, + BdrvRequestFlags flags) + { + int ret; +@@ -3044,21 +3044,33 @@ static int coroutine_fn bdrv_co_do_writev(BlockDriverState *bs, + if (bs->read_only) { + return -EACCES; + } +- if (bdrv_check_request(bs, sector_num, nb_sectors)) { ++ if (bdrv_check_byte_request(bs, offset, bytes)) { + return -EIO; + } + + /* throttling disk I/O */ + if (bs->io_limits_enabled) { +- bdrv_io_limits_intercept(bs, true, nb_sectors); ++ /* TODO Switch to byte granularity */ ++ bdrv_io_limits_intercept(bs, true, bytes >> BDRV_SECTOR_BITS); + } + +- ret = bdrv_aligned_pwritev(bs, sector_num << BDRV_SECTOR_BITS, +- nb_sectors << BDRV_SECTOR_BITS, qiov, flags); ++ ret = bdrv_aligned_pwritev(bs, offset, bytes, qiov, flags); + + return ret; + } + ++static int coroutine_fn bdrv_co_do_writev(BlockDriverState *bs, ++ int64_t sector_num, int nb_sectors, QEMUIOVector *qiov, ++ BdrvRequestFlags flags) ++{ ++ if (nb_sectors < 0 || nb_sectors > (INT_MAX >> BDRV_SECTOR_BITS)) { ++ return -EINVAL; ++ } ++ ++ return bdrv_co_do_pwritev(bs, sector_num << BDRV_SECTOR_BITS, ++ nb_sectors << BDRV_SECTOR_BITS, qiov, flags); ++} ++ + int coroutine_fn bdrv_co_writev(BlockDriverState *bs, int64_t sector_num, + int nb_sectors, QEMUIOVector *qiov) + { +-- +1.7.1 + diff --git a/SOURCES/kvm-block-Limit-request-size-CVE-2014-0143.patch b/SOURCES/kvm-block-Limit-request-size-CVE-2014-0143.patch new file mode 100644 index 0000000..f85ebbf --- /dev/null +++ b/SOURCES/kvm-block-Limit-request-size-CVE-2014-0143.patch @@ -0,0 +1,45 @@ +From 6d68fdd3f1fa51b2f1524f1984089057e6d1b081 Mon Sep 17 00:00:00 2001 +From: Kevin Wolf +Date: Tue, 25 Mar 2014 14:23:48 +0100 +Subject: [PATCH 41/49] block: Limit request size (CVE-2014-0143) + +RH-Author: Kevin Wolf +Message-id: <1395753835-7591-42-git-send-email-kwolf@redhat.com> +Patchwork-id: n/a +O-Subject: [virt-devel] [EMBARGOED RHEL-7.0 qemu-kvm PATCH 41/48] block: Limit request size (CVE-2014-0143) +Bugzilla: 1079320 +RH-Acked-by: Jeff Cody +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Paolo Bonzini + +Bugzilla: https://bugzilla.redhat.com/show_bug.cgi?id=1079320 +Upstream status: Embargoed + +Limiting the size of a single request to INT_MAX not only fixes a +direct integer overflow in bdrv_check_request() (which would only +trigger bad behaviour with ridiculously huge images, as in close to +2^64 bytes), but can also prevent overflows in all block drivers. + +Signed-off-by: Kevin Wolf +--- + block.c | 4 ++++ + 1 files changed, 4 insertions(+), 0 deletions(-) + +diff --git a/block.c b/block.c +index 0321c74..4906f6b 100644 +--- a/block.c ++++ b/block.c +@@ -2425,6 +2425,10 @@ static int bdrv_check_byte_request(BlockDriverState *bs, int64_t offset, + static int bdrv_check_request(BlockDriverState *bs, int64_t sector_num, + int nb_sectors) + { ++ if (nb_sectors > INT_MAX / BDRV_SECTOR_SIZE) { ++ return -EIO; ++ } ++ + return bdrv_check_byte_request(bs, sector_num * BDRV_SECTOR_SIZE, + nb_sectors * BDRV_SECTOR_SIZE); + } +-- +1.7.1 + diff --git a/SOURCES/kvm-block-Make-BlockJobTypes-const.patch b/SOURCES/kvm-block-Make-BlockJobTypes-const.patch new file mode 100644 index 0000000..09c94fc --- /dev/null +++ b/SOURCES/kvm-block-Make-BlockJobTypes-const.patch @@ -0,0 +1,74 @@ +From 7bd51b7f1ea911e7a85f1965495c4299701b5f7c Mon Sep 17 00:00:00 2001 +From: Fam Zheng +Date: Fri, 17 Jan 2014 03:07:53 +0100 +Subject: [PATCH 10/34] block: Make BlockJobTypes const + +RH-Author: Fam Zheng +Message-id: <1389928083-8921-9-git-send-email-famz@redhat.com> +Patchwork-id: 56770 +O-Subject: [RHEL-7 qemu-kvm PATCH 08/18] block: Make BlockJobTypes const +Bugzilla: 1041301 +RH-Acked-by: Jeffrey Cody +RH-Acked-by: Kevin Wolf +RH-Acked-by: Stefan Hajnoczi + +From: Kevin Wolf + +Signed-off-by: Kevin Wolf +(cherry picked from commit f59fee8d509b446df24843c1145a99b740492725) +Signed-off-by: Fam Zheng +--- + block/commit.c | 2 +- + block/mirror.c | 2 +- + block/stream.c | 2 +- + 3 files changed, 3 insertions(+), 3 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + block/commit.c | 2 +- + block/mirror.c | 2 +- + block/stream.c | 2 +- + 3 files changed, 3 insertions(+), 3 deletions(-) + +diff --git a/block/commit.c b/block/commit.c +index 74c209a..37572f0 100644 +--- a/block/commit.c ++++ b/block/commit.c +@@ -173,7 +173,7 @@ static void commit_set_speed(BlockJob *job, int64_t speed, Error **errp) + ratelimit_set_speed(&s->limit, speed / BDRV_SECTOR_SIZE, SLICE_TIME); + } + +-static BlockJobType commit_job_type = { ++static const BlockJobType commit_job_type = { + .instance_size = sizeof(CommitBlockJob), + .job_type = "commit", + .set_speed = commit_set_speed, +diff --git a/block/mirror.c b/block/mirror.c +index 6843e70..342c90d 100644 +--- a/block/mirror.c ++++ b/block/mirror.c +@@ -525,7 +525,7 @@ static void mirror_complete(BlockJob *job, Error **errp) + block_job_resume(job); + } + +-static BlockJobType mirror_job_type = { ++static const BlockJobType mirror_job_type = { + .instance_size = sizeof(MirrorBlockJob), + .job_type = "mirror", + .set_speed = mirror_set_speed, +diff --git a/block/stream.c b/block/stream.c +index 82fb179..ce16b0b 100644 +--- a/block/stream.c ++++ b/block/stream.c +@@ -204,7 +204,7 @@ static void stream_set_speed(BlockJob *job, int64_t speed, Error **errp) + ratelimit_set_speed(&s->limit, speed / BDRV_SECTOR_SIZE, SLICE_TIME); + } + +-static BlockJobType stream_job_type = { ++static const BlockJobType stream_job_type = { + .instance_size = sizeof(StreamBlockJob), + .job_type = "stream", + .set_speed = stream_set_speed, +-- +1.7.1 + diff --git a/SOURCES/kvm-block-Make-bdrv_pread-a-bdrv_prwv_co-wrapper.patch b/SOURCES/kvm-block-Make-bdrv_pread-a-bdrv_prwv_co-wrapper.patch new file mode 100644 index 0000000..1da76fb --- /dev/null +++ b/SOURCES/kvm-block-Make-bdrv_pread-a-bdrv_prwv_co-wrapper.patch @@ -0,0 +1,98 @@ +From 94789223da7e51599209395f167a95026e707ab8 Mon Sep 17 00:00:00 2001 +From: Kevin Wolf +Date: Thu, 5 Dec 2013 12:29:59 +0100 +Subject: [PATCH 28/37] block: Make bdrv_pread() a bdrv_prwv_co() wrapper + +Message-id: <1392117622-28812-29-git-send-email-kwolf@redhat.com> +Patchwork-id: 57193 +O-Subject: [RHEL-7.0 qemu-kvm PATCH v2 28/37] block: Make bdrv_pread() a bdrv_prwv_co() wrapper +Bugzilla: 748906 +RH-Acked-by: Laszlo Ersek +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Max Reitz + +Instead of implementing the alignment adjustment here, use the now +existing functionality of bdrv_co_do_preadv(). + +Signed-off-by: Kevin Wolf +Reviewed-by: Max Reitz +(cherry picked from commit a3ef65718506fb94cb9e5a903ef9bf9ad8fbe6de) + +Signed-off-by: Kevin Wolf +--- + block.c | 49 +++++++++++++------------------------------------ + 1 file changed, 13 insertions(+), 36 deletions(-) +--- + block.c | 51 ++++++++++++++------------------------------------- + 1 files changed, 14 insertions(+), 37 deletions(-) + +diff --git a/block.c b/block.c +index 3b5b706..e76dec6 100644 +--- a/block.c ++++ b/block.c +@@ -2566,49 +2566,26 @@ int bdrv_make_zero(BlockDriverState *bs, BdrvRequestFlags flags) + } + } + +-int bdrv_pread(BlockDriverState *bs, int64_t offset, +- void *buf, int count1) ++int bdrv_pread(BlockDriverState *bs, int64_t offset, void *buf, int bytes) + { +- uint8_t tmp_buf[BDRV_SECTOR_SIZE]; +- int len, nb_sectors, count; +- int64_t sector_num; ++ QEMUIOVector qiov; ++ struct iovec iov = { ++ .iov_base = (void *)buf, ++ .iov_len = bytes, ++ }; + int ret; + +- count = count1; +- /* first read to align to sector start */ +- len = (BDRV_SECTOR_SIZE - offset) & (BDRV_SECTOR_SIZE - 1); +- if (len > count) +- len = count; +- sector_num = offset >> BDRV_SECTOR_BITS; +- if (len > 0) { +- if ((ret = bdrv_read(bs, sector_num, tmp_buf, 1)) < 0) +- return ret; +- memcpy(buf, tmp_buf + (offset & (BDRV_SECTOR_SIZE - 1)), len); +- count -= len; +- if (count == 0) +- return count1; +- sector_num++; +- buf += len; ++ if (bytes < 0) { ++ return -EINVAL; + } + +- /* read the sectors "in place" */ +- nb_sectors = count >> BDRV_SECTOR_BITS; +- if (nb_sectors > 0) { +- if ((ret = bdrv_read(bs, sector_num, buf, nb_sectors)) < 0) +- return ret; +- sector_num += nb_sectors; +- len = nb_sectors << BDRV_SECTOR_BITS; +- buf += len; +- count -= len; ++ qemu_iovec_init_external(&qiov, &iov, 1); ++ ret = bdrv_prwv_co(bs, offset, &qiov, false, 0); ++ if (ret < 0) { ++ return ret; + } + +- /* add data from the last sector */ +- if (count > 0) { +- if ((ret = bdrv_read(bs, sector_num, tmp_buf, 1)) < 0) +- return ret; +- memcpy(buf, tmp_buf, count); +- } +- return count1; ++ return bytes; + } + + int bdrv_pwritev(BlockDriverState *bs, int64_t offset, QEMUIOVector *qiov) +-- +1.7.1 + diff --git a/SOURCES/kvm-block-Make-bdrv_pwrite-a-bdrv_prwv_co-wrapper.patch b/SOURCES/kvm-block-Make-bdrv_pwrite-a-bdrv_prwv_co-wrapper.patch new file mode 100644 index 0000000..a21ba3a --- /dev/null +++ b/SOURCES/kvm-block-Make-bdrv_pwrite-a-bdrv_prwv_co-wrapper.patch @@ -0,0 +1,141 @@ +From 571796285399dce82633b305dd9e03bcb8ac5634 Mon Sep 17 00:00:00 2001 +From: Kevin Wolf +Date: Thu, 5 Dec 2013 12:34:02 +0100 +Subject: [PATCH 29/37] block: Make bdrv_pwrite() a bdrv_prwv_co() wrapper + +Message-id: <1392117622-28812-30-git-send-email-kwolf@redhat.com> +Patchwork-id: 57194 +O-Subject: [RHEL-7.0 qemu-kvm PATCH v2 29/37] block: Make bdrv_pwrite() a bdrv_prwv_co() wrapper +Bugzilla: 748906 +RH-Acked-by: Laszlo Ersek +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Max Reitz + +Instead of implementing the alignment adjustment here, use the now +existing functionality of bdrv_co_do_pwritev(). + +Signed-off-by: Kevin Wolf +Reviewed-by: Max Reitz +(cherry picked from commit 8407d5d7e265911b05949ee2ffd9e45c97bf0505) + +Signed-off-by: Kevin Wolf +--- + block.c | 64 ++++++++------------------------------------------- + include/block/block.h | 1 - + 2 files changed, 9 insertions(+), 56 deletions(-) +--- + block.c | 64 +++++++------------------------------------------ + include/block/block.h | 1 - + 2 files changed, 9 insertions(+), 56 deletions(-) + +diff --git a/block.c b/block.c +index e76dec6..d18c2df 100644 +--- a/block.c ++++ b/block.c +@@ -2517,11 +2517,6 @@ int bdrv_write(BlockDriverState *bs, int64_t sector_num, + return bdrv_rw_co(bs, sector_num, (uint8_t *)buf, nb_sectors, true, 0); + } + +-int bdrv_writev(BlockDriverState *bs, int64_t sector_num, QEMUIOVector *qiov) +-{ +- return bdrv_prwv_co(bs, sector_num << BDRV_SECTOR_BITS, qiov, true, 0); +-} +- + int bdrv_write_zeroes(BlockDriverState *bs, int64_t sector_num, + int nb_sectors, BdrvRequestFlags flags) + { +@@ -2590,70 +2585,29 @@ int bdrv_pread(BlockDriverState *bs, int64_t offset, void *buf, int bytes) + + int bdrv_pwritev(BlockDriverState *bs, int64_t offset, QEMUIOVector *qiov) + { +- uint8_t tmp_buf[BDRV_SECTOR_SIZE]; +- int len, nb_sectors, count; +- int64_t sector_num; + int ret; + +- count = qiov->size; +- +- /* first write to align to sector start */ +- len = (BDRV_SECTOR_SIZE - offset) & (BDRV_SECTOR_SIZE - 1); +- if (len > count) +- len = count; +- sector_num = offset >> BDRV_SECTOR_BITS; +- if (len > 0) { +- if ((ret = bdrv_read(bs, sector_num, tmp_buf, 1)) < 0) +- return ret; +- qemu_iovec_to_buf(qiov, 0, tmp_buf + (offset & (BDRV_SECTOR_SIZE - 1)), +- len); +- if ((ret = bdrv_write(bs, sector_num, tmp_buf, 1)) < 0) +- return ret; +- count -= len; +- if (count == 0) +- return qiov->size; +- sector_num++; +- } +- +- /* write the sectors "in place" */ +- nb_sectors = count >> BDRV_SECTOR_BITS; +- if (nb_sectors > 0) { +- QEMUIOVector qiov_inplace; +- +- qemu_iovec_init(&qiov_inplace, qiov->niov); +- qemu_iovec_concat(&qiov_inplace, qiov, len, +- nb_sectors << BDRV_SECTOR_BITS); +- ret = bdrv_writev(bs, sector_num, &qiov_inplace); +- qemu_iovec_destroy(&qiov_inplace); +- if (ret < 0) { +- return ret; +- } +- +- sector_num += nb_sectors; +- len = nb_sectors << BDRV_SECTOR_BITS; +- count -= len; ++ ret = bdrv_prwv_co(bs, offset, qiov, true, 0); ++ if (ret < 0) { ++ return ret; + } + +- /* add data from the last sector */ +- if (count > 0) { +- if ((ret = bdrv_read(bs, sector_num, tmp_buf, 1)) < 0) +- return ret; +- qemu_iovec_to_buf(qiov, qiov->size - count, tmp_buf, count); +- if ((ret = bdrv_write(bs, sector_num, tmp_buf, 1)) < 0) +- return ret; +- } + return qiov->size; + } + + int bdrv_pwrite(BlockDriverState *bs, int64_t offset, +- const void *buf, int count1) ++ const void *buf, int bytes) + { + QEMUIOVector qiov; + struct iovec iov = { + .iov_base = (void *) buf, +- .iov_len = count1, ++ .iov_len = bytes, + }; + ++ if (bytes < 0) { ++ return -EINVAL; ++ } ++ + qemu_iovec_init_external(&qiov, &iov, 1); + return bdrv_pwritev(bs, offset, &qiov); + } +diff --git a/include/block/block.h b/include/block/block.h +index 2a9aa5b..feb1926 100644 +--- a/include/block/block.h ++++ b/include/block/block.h +@@ -221,7 +221,6 @@ BlockDriverAIOCB *bdrv_aio_write_zeroes(BlockDriverState *bs, int64_t sector_num + int nb_sectors, BdrvRequestFlags flags, + BlockDriverCompletionFunc *cb, void *opaque); + int bdrv_make_zero(BlockDriverState *bs, BdrvRequestFlags flags); +-int bdrv_writev(BlockDriverState *bs, int64_t sector_num, QEMUIOVector *qiov); + int bdrv_pread(BlockDriverState *bs, int64_t offset, + void *buf, int count); + int bdrv_pwrite(BlockDriverState *bs, int64_t offset, +-- +1.7.1 + diff --git a/SOURCES/kvm-block-Make-overlap-range-for-serialisation-dynamic.patch b/SOURCES/kvm-block-Make-overlap-range-for-serialisation-dynamic.patch new file mode 100644 index 0000000..ac619b4 --- /dev/null +++ b/SOURCES/kvm-block-Make-overlap-range-for-serialisation-dynamic.patch @@ -0,0 +1,174 @@ +From d8c60f4fc2bb0fb0e5b363cd61230e103fbff3ab Mon Sep 17 00:00:00 2001 +From: Kevin Wolf +Date: Wed, 4 Dec 2013 17:08:50 +0100 +Subject: [PATCH 21/37] block: Make overlap range for serialisation dynamic + +Message-id: <1392117622-28812-22-git-send-email-kwolf@redhat.com> +Patchwork-id: 57186 +O-Subject: [RHEL-7.0 qemu-kvm PATCH v2 21/37] block: Make overlap range for serialisation dynamic +Bugzilla: 748906 +RH-Acked-by: Laszlo Ersek +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Max Reitz + +Copy on Read wants to serialise with all requests touching the same +cluster, so wait_serialising_requests() rounded to cluster boundaries. +Other users like alignment RMW will have different requirements, though +(requests touching the same sector), so make it dynamic. + +Signed-off-by: Kevin Wolf +Reviewed-by: Max Reitz +Reviewed-by: Benoit Canet +(cherry picked from commit 7327145f63a224c9ba9c16d0c29781feffef8dc6) + +Conflicts: + include/block/block_int.h + +Conflicts because in RHEL 7 BdrvTrackedRequest is in block.c + +Signed-off-by: Kevin Wolf +--- + block.c | 57 +++++++++++++++++++++++++++++++-------------------------- + 1 file changed, 31 insertions(+), 26 deletions(-) +--- + block.c | 57 +++++++++++++++++++++++++++++++-------------------------- + 1 files changed, 31 insertions(+), 26 deletions(-) + +diff --git a/block.c b/block.c +index 7b30bb3..24e94e6 100644 +--- a/block.c ++++ b/block.c +@@ -2039,7 +2039,11 @@ struct BdrvTrackedRequest { + int64_t offset; + unsigned int bytes; + bool is_write; ++ + bool serialising; ++ int64_t overlap_offset; ++ unsigned int overlap_bytes; ++ + QLIST_ENTRY(BdrvTrackedRequest) list; + Coroutine *co; /* owner, used for deadlock detection */ + CoQueue wait_queue; /* coroutines blocked on this request */ +@@ -2075,6 +2079,8 @@ static void tracked_request_begin(BdrvTrackedRequest *req, + .is_write = is_write, + .co = qemu_coroutine_self(), + .serialising = false, ++ .overlap_offset = offset, ++ .overlap_bytes = bytes, + }; + + qemu_co_queue_init(&req->wait_queue); +@@ -2082,12 +2088,19 @@ static void tracked_request_begin(BdrvTrackedRequest *req, + QLIST_INSERT_HEAD(&bs->tracked_requests, req, list); + } + +-static void mark_request_serialising(BdrvTrackedRequest *req) ++static void mark_request_serialising(BdrvTrackedRequest *req, size_t align) + { ++ int64_t overlap_offset = req->offset & ~(align - 1); ++ int overlap_bytes = ROUND_UP(req->offset + req->bytes, align) ++ - overlap_offset; ++ + if (!req->serialising) { + req->bs->serialising_in_flight++; + req->serialising = true; + } ++ ++ req->overlap_offset = MIN(req->overlap_offset, overlap_offset); ++ req->overlap_bytes = MAX(req->overlap_bytes, overlap_bytes); + } + + /** +@@ -2111,20 +2124,16 @@ void bdrv_round_to_clusters(BlockDriverState *bs, + } + } + +-static void round_bytes_to_clusters(BlockDriverState *bs, +- int64_t offset, unsigned int bytes, +- int64_t *cluster_offset, +- unsigned int *cluster_bytes) ++static int bdrv_get_cluster_size(BlockDriverState *bs) + { + BlockDriverInfo bdi; ++ int ret; + +- if (bdrv_get_info(bs, &bdi) < 0 || bdi.cluster_size == 0) { +- *cluster_offset = offset; +- *cluster_bytes = bytes; ++ ret = bdrv_get_info(bs, &bdi); ++ if (ret < 0 || bdi.cluster_size == 0) { ++ return bs->request_alignment; + } else { +- *cluster_offset = QEMU_ALIGN_DOWN(offset, bdi.cluster_size); +- *cluster_bytes = QEMU_ALIGN_UP(offset - *cluster_offset + bytes, +- bdi.cluster_size); ++ return bdi.cluster_size; + } + } + +@@ -2132,11 +2141,11 @@ static bool tracked_request_overlaps(BdrvTrackedRequest *req, + int64_t offset, unsigned int bytes) + { + /* aaaa bbbb */ +- if (offset >= req->offset + req->bytes) { ++ if (offset >= req->overlap_offset + req->overlap_bytes) { + return false; + } + /* bbbb aaaa */ +- if (req->offset >= offset + bytes) { ++ if (req->overlap_offset >= offset + bytes) { + return false; + } + return true; +@@ -2146,30 +2155,21 @@ static void coroutine_fn wait_serialising_requests(BdrvTrackedRequest *self) + { + BlockDriverState *bs = self->bs; + BdrvTrackedRequest *req; +- int64_t cluster_offset; +- unsigned int cluster_bytes; + bool retry; + + if (!bs->serialising_in_flight) { + return; + } + +- /* If we touch the same cluster it counts as an overlap. This guarantees +- * that allocating writes will be serialized and not race with each other +- * for the same cluster. For example, in copy-on-read it ensures that the +- * CoR read and write operations are atomic and guest writes cannot +- * interleave between them. +- */ +- round_bytes_to_clusters(bs, self->offset, self->bytes, +- &cluster_offset, &cluster_bytes); +- + do { + retry = false; + QLIST_FOREACH(req, &bs->tracked_requests, list) { + if (req == self || (!req->serialising && !self->serialising)) { + continue; + } +- if (tracked_request_overlaps(req, cluster_offset, cluster_bytes)) { ++ if (tracked_request_overlaps(req, self->overlap_offset, ++ self->overlap_bytes)) ++ { + /* Hitting this means there was a reentrant request, for + * example, a block driver issuing nested requests. This must + * never happen since it means deadlock. +@@ -2780,7 +2780,12 @@ static int coroutine_fn bdrv_aligned_preadv(BlockDriverState *bs, + + /* Handle Copy on Read and associated serialisation */ + if (flags & BDRV_REQ_COPY_ON_READ) { +- mark_request_serialising(req); ++ /* If we touch the same cluster it counts as an overlap. This ++ * guarantees that allocating writes will be serialized and not race ++ * with each other for the same cluster. For example, in copy-on-read ++ * it ensures that the CoR read and write operations are atomic and ++ * guest writes cannot interleave between them. */ ++ mark_request_serialising(req, bdrv_get_cluster_size(bs)); + } + + wait_serialising_requests(req); +-- +1.7.1 + diff --git a/SOURCES/kvm-block-Make-zero-after-EOF-work-with-larger-alignment.patch b/SOURCES/kvm-block-Make-zero-after-EOF-work-with-larger-alignment.patch new file mode 100644 index 0000000..900192d --- /dev/null +++ b/SOURCES/kvm-block-Make-zero-after-EOF-work-with-larger-alignment.patch @@ -0,0 +1,65 @@ +From 4b6c9d80b06057886e35650b904fe332ae14d0bd Mon Sep 17 00:00:00 2001 +From: Kevin Wolf +Date: Wed, 4 Dec 2013 12:13:10 +0100 +Subject: [PATCH 19/37] block: Make zero-after-EOF work with larger alignment + +Message-id: <1392117622-28812-20-git-send-email-kwolf@redhat.com> +Patchwork-id: 57184 +O-Subject: [RHEL-7.0 qemu-kvm PATCH v2 19/37] block: Make zero-after-EOF work with larger alignment +Bugzilla: 748906 +RH-Acked-by: Laszlo Ersek +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Max Reitz + +Odd file sizes could make bdrv_aligned_preadv() shorten the request in +non-aligned ways. Fix it by rounding to the required alignment instead +of 512 bytes. + +Signed-off-by: Kevin Wolf +Reviewed-by: Max Reitz +Reviewed-by: Benoit Canet +(cherry picked from commit ec746e10cb2e6276a8d2e036454792fe0674864a) + +Signed-off-by: Kevin Wolf +--- + block.c | 7 ++++--- + 1 file changed, 4 insertions(+), 3 deletions(-) +--- + block.c | 7 ++++--- + 1 files changed, 4 insertions(+), 3 deletions(-) + +diff --git a/block.c b/block.c +index feeab4e..6317321 100644 +--- a/block.c ++++ b/block.c +@@ -2748,7 +2748,7 @@ err: + */ + static int coroutine_fn bdrv_aligned_preadv(BlockDriverState *bs, + BdrvTrackedRequest *req, int64_t offset, unsigned int bytes, +- QEMUIOVector *qiov, int flags) ++ int64_t align, QEMUIOVector *qiov, int flags) + { + BlockDriver *drv = bs->drv; + int ret; +@@ -2796,7 +2796,8 @@ static int coroutine_fn bdrv_aligned_preadv(BlockDriverState *bs, + } + + total_sectors = DIV_ROUND_UP(len, BDRV_SECTOR_SIZE); +- max_nb_sectors = MAX(0, total_sectors - sector_num); ++ max_nb_sectors = MAX(0, ROUND_UP(total_sectors - sector_num, ++ align >> BDRV_SECTOR_BITS)); + if (max_nb_sectors > 0) { + ret = drv->bdrv_co_readv(bs, sector_num, + MIN(nb_sectors, max_nb_sectors), qiov); +@@ -2882,7 +2883,7 @@ static int coroutine_fn bdrv_co_do_preadv(BlockDriverState *bs, + } + + tracked_request_begin(&req, bs, offset, bytes, false); +- ret = bdrv_aligned_preadv(bs, &req, offset, bytes, ++ ret = bdrv_aligned_preadv(bs, &req, offset, bytes, align, + use_local_qiov ? &local_qiov : qiov, + flags); + tracked_request_end(&req); +-- +1.7.1 + diff --git a/SOURCES/kvm-block-Move-initialisation-of-BlockLimits-to-bdrv_ref.patch b/SOURCES/kvm-block-Move-initialisation-of-BlockLimits-to-bdrv_ref.patch new file mode 100644 index 0000000..3e0f8be --- /dev/null +++ b/SOURCES/kvm-block-Move-initialisation-of-BlockLimits-to-bdrv_ref.patch @@ -0,0 +1,294 @@ +From 69a283009c8736d5e063b6721b47f4b453595c15 Mon Sep 17 00:00:00 2001 +From: Kevin Wolf +Date: Wed, 11 Dec 2013 19:26:16 +0100 +Subject: [PATCH 02/37] block: Move initialisation of BlockLimits to bdrv_refresh_limits() + +Message-id: <1392117622-28812-3-git-send-email-kwolf@redhat.com> +Patchwork-id: 57167 +O-Subject: [RHEL-7.0 qemu-kvm PATCH v2 02/37] block: Move initialisation of BlockLimits to bdrv_refresh_limits() +Bugzilla: 748906 +RH-Acked-by: Laszlo Ersek +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Max Reitz + +This function separates filling the BlockLimits from bdrv_open(), which +allows it to call it from other operations which may change the limits +(e.g. modifications to the backing file chain or bdrv_reopen) + +Signed-off-by: Kevin Wolf +Reviewed-by: Max Reitz +Reviewed-by: Benoit Canet +(cherry picked from commit d34682cd4a06efe9ee3fc8cb7e8a0ea445299989) + +Conflicts: + block/qed.c + +Trivial context-only conflict. + +Signed-off-by: Kevin Wolf +--- + block.c | 18 ++++++++++++++++++ + block/iscsi.c | 46 +++++++++++++++++++++++++++++----------------- + block/qcow2.c | 11 ++++++++++- + block/qed.c | 11 ++++++++++- + block/vmdk.c | 22 ++++++++++++++++++---- + include/block/block_int.h | 2 ++ + 6 files changed, 87 insertions(+), 23 deletions(-) +--- + block.c | 18 +++++++++++++++++ + block/iscsi.c | 46 ++++++++++++++++++++++++++++---------------- + block/qcow2.c | 11 +++++++++- + block/qed.c | 11 +++++++++- + block/vmdk.c | 22 +++++++++++++++++--- + include/block/block_int.h | 2 + + 6 files changed, 87 insertions(+), 23 deletions(-) + +diff --git a/block.c b/block.c +index df0adf3..26eebcc 100644 +--- a/block.c ++++ b/block.c +@@ -446,6 +446,19 @@ int bdrv_create_file(const char* filename, QEMUOptionParameter *options, + return ret; + } + ++static int bdrv_refresh_limits(BlockDriverState *bs) ++{ ++ BlockDriver *drv = bs->drv; ++ ++ memset(&bs->bl, 0, sizeof(bs->bl)); ++ ++ if (drv && drv->bdrv_refresh_limits) { ++ return drv->bdrv_refresh_limits(bs); ++ } ++ ++ return 0; ++} ++ + /* + * Create a uniquely-named empty temporary file. + * Return 0 upon success, otherwise a negative errno value. +@@ -797,6 +810,8 @@ static int bdrv_open_common(BlockDriverState *bs, BlockDriverState *file, + goto free_and_fail; + } + ++ bdrv_refresh_limits(bs); ++ + #ifndef _WIN32 + if (bs->is_temporary) { + assert(filename != NULL); +@@ -984,6 +999,9 @@ int bdrv_open_backing_file(BlockDriverState *bs, QDict *options, Error **errp) + bs->backing_hd->file->filename); + } + ++ /* Recalculate the BlockLimits with the backing file */ ++ bdrv_refresh_limits(bs); ++ + return 0; + } + +diff --git a/block/iscsi.c b/block/iscsi.c +index 1c5b0a2..83e4f15 100644 +--- a/block/iscsi.c ++++ b/block/iscsi.c +@@ -1445,23 +1445,6 @@ static int iscsi_open(BlockDriverState *bs, QDict *options, int flags, + sizeof(struct scsi_inquiry_block_limits)); + scsi_free_scsi_task(task); + task = NULL; +- +- if (iscsilun->bl.max_unmap < 0xffffffff) { +- bs->bl.max_discard = sector_lun2qemu(iscsilun->bl.max_unmap, +- iscsilun); +- } +- bs->bl.discard_alignment = sector_lun2qemu(iscsilun->bl.opt_unmap_gran, +- iscsilun); +- +- if (iscsilun->bl.max_ws_len < 0xffffffff) { +- bs->bl.max_write_zeroes = sector_lun2qemu(iscsilun->bl.max_ws_len, +- iscsilun); +- } +- bs->bl.write_zeroes_alignment = sector_lun2qemu(iscsilun->bl.opt_unmap_gran, +- iscsilun); +- +- bs->bl.opt_transfer_length = sector_lun2qemu(iscsilun->bl.opt_xfer_len, +- iscsilun); + } + + #if defined(LIBISCSI_FEATURE_NOP_COUNTER) +@@ -1506,6 +1489,34 @@ static void iscsi_close(BlockDriverState *bs) + memset(iscsilun, 0, sizeof(IscsiLun)); + } + ++static int iscsi_refresh_limits(BlockDriverState *bs) ++{ ++ IscsiLun *iscsilun = bs->opaque; ++ ++ /* We don't actually refresh here, but just return data queried in ++ * iscsi_open(): iscsi targets don't change their limits. */ ++ if (iscsilun->lbp.lbpu || iscsilun->lbp.lbpws) { ++ if (iscsilun->bl.max_unmap < 0xffffffff) { ++ bs->bl.max_discard = sector_lun2qemu(iscsilun->bl.max_unmap, ++ iscsilun); ++ } ++ bs->bl.discard_alignment = sector_lun2qemu(iscsilun->bl.opt_unmap_gran, ++ iscsilun); ++ ++ if (iscsilun->bl.max_ws_len < 0xffffffff) { ++ bs->bl.max_write_zeroes = sector_lun2qemu(iscsilun->bl.max_ws_len, ++ iscsilun); ++ } ++ bs->bl.write_zeroes_alignment = sector_lun2qemu(iscsilun->bl.opt_unmap_gran, ++ iscsilun); ++ ++ bs->bl.opt_transfer_length = sector_lun2qemu(iscsilun->bl.opt_xfer_len, ++ iscsilun); ++ } ++ ++ return 0; ++} ++ + /* We have nothing to do for iSCSI reopen, stub just returns + * success */ + static int iscsi_reopen_prepare(BDRVReopenState *state, +@@ -1626,6 +1637,7 @@ static BlockDriver bdrv_iscsi = { + .bdrv_getlength = iscsi_getlength, + .bdrv_get_info = iscsi_get_info, + .bdrv_truncate = iscsi_truncate, ++ .bdrv_refresh_limits = iscsi_refresh_limits, + + .bdrv_co_get_block_status = iscsi_co_get_block_status, + .bdrv_co_discard = iscsi_co_discard, +diff --git a/block/qcow2.c b/block/qcow2.c +index f6307af..05ea0cd 100644 +--- a/block/qcow2.c ++++ b/block/qcow2.c +@@ -718,7 +718,6 @@ static int qcow2_open(BlockDriverState *bs, QDict *options, int flags, + } + + qemu_opts_del(opts); +- bs->bl.write_zeroes_alignment = s->cluster_sectors; + + if (s->use_lazy_refcounts && s->qcow_version < 3) { + error_setg(errp, "Lazy refcounts require a qcow2 image with at least " +@@ -751,6 +750,15 @@ static int qcow2_open(BlockDriverState *bs, QDict *options, int flags, + return ret; + } + ++static int qcow2_refresh_limits(BlockDriverState *bs) ++{ ++ BDRVQcowState *s = bs->opaque; ++ ++ bs->bl.write_zeroes_alignment = s->cluster_sectors; ++ ++ return 0; ++} ++ + static int qcow2_set_key(BlockDriverState *bs, const char *key) + { + BDRVQcowState *s = bs->opaque; +@@ -2262,6 +2270,7 @@ static BlockDriver bdrv_qcow2 = { + + .bdrv_change_backing_file = qcow2_change_backing_file, + ++ .bdrv_refresh_limits = qcow2_refresh_limits, + .bdrv_invalidate_cache = qcow2_invalidate_cache, + + .create_options = qcow2_create_options, +diff --git a/block/qed.c b/block/qed.c +index fb8ccd5..da68152 100644 +--- a/block/qed.c ++++ b/block/qed.c +@@ -495,7 +495,6 @@ static int bdrv_qed_open(BlockDriverState *bs, QDict *options, int flags, + } + } + +- bs->bl.write_zeroes_alignment = s->header.cluster_size >> BDRV_SECTOR_BITS; + s->need_check_timer = qemu_new_timer_ns(vm_clock, + qed_need_check_timer_cb, s); + +@@ -507,6 +506,15 @@ out: + return ret; + } + ++static int bdrv_qed_refresh_limits(BlockDriverState *bs) ++{ ++ BDRVQEDState *s = bs->opaque; ++ ++ bs->bl.write_zeroes_alignment = s->header.cluster_size >> BDRV_SECTOR_BITS; ++ ++ return 0; ++} ++ + /* We have nothing to do for QED reopen, stubs just return + * success */ + static int bdrv_qed_reopen_prepare(BDRVReopenState *state, +@@ -1616,6 +1624,7 @@ static BlockDriver bdrv_qed = { + .bdrv_truncate = bdrv_qed_truncate, + .bdrv_getlength = bdrv_qed_getlength, + .bdrv_get_info = bdrv_qed_get_info, ++ .bdrv_refresh_limits = bdrv_qed_refresh_limits, + .bdrv_change_backing_file = bdrv_qed_change_backing_file, + .bdrv_invalidate_cache = bdrv_qed_invalidate_cache, + .bdrv_check = bdrv_qed_check, +diff --git a/block/vmdk.c b/block/vmdk.c +index a1994a4..a966715 100644 +--- a/block/vmdk.c ++++ b/block/vmdk.c +@@ -428,10 +428,6 @@ static int vmdk_add_extent(BlockDriverState *bs, + extent->l2_size = l2_size; + extent->cluster_sectors = flat ? sectors : cluster_sectors; + +- if (!flat) { +- bs->bl.write_zeroes_alignment = +- MAX(bs->bl.write_zeroes_alignment, cluster_sectors); +- } + if (s->num_extents > 1) { + extent->end_sector = (*(extent - 1)).end_sector + extent->sectors; + } else { +@@ -886,6 +882,23 @@ fail: + return ret; + } + ++ ++static int vmdk_refresh_limits(BlockDriverState *bs) ++{ ++ BDRVVmdkState *s = bs->opaque; ++ int i; ++ ++ for (i = 0; i < s->num_extents; i++) { ++ if (!s->extents[i].flat) { ++ bs->bl.write_zeroes_alignment = ++ MAX(bs->bl.write_zeroes_alignment, ++ s->extents[i].cluster_sectors); ++ } ++ } ++ ++ return 0; ++} ++ + static int get_whole_cluster(BlockDriverState *bs, + VmdkExtent *extent, + uint64_t cluster_offset, +@@ -1957,6 +1970,7 @@ static BlockDriver bdrv_vmdk = { + .bdrv_get_allocated_file_size = vmdk_get_allocated_file_size, + .bdrv_has_zero_init = vmdk_has_zero_init, + .bdrv_get_specific_info = vmdk_get_specific_info, ++ .bdrv_refresh_limits = vmdk_refresh_limits, + + .create_options = vmdk_create_options, + }; +diff --git a/include/block/block_int.h b/include/block/block_int.h +index c8f30fd..13a52e8 100644 +--- a/include/block/block_int.h ++++ b/include/block/block_int.h +@@ -213,6 +213,8 @@ struct BlockDriver { + int (*bdrv_debug_resume)(BlockDriverState *bs, const char *tag); + bool (*bdrv_debug_is_suspended)(BlockDriverState *bs, const char *tag); + ++ int (*bdrv_refresh_limits)(BlockDriverState *bs); ++ + /* + * Returns 1 if newly created images are guaranteed to contain only + * zeros, 0 otherwise. +-- +1.7.1 + diff --git a/SOURCES/kvm-block-Round-up-total_sectors.patch b/SOURCES/kvm-block-Round-up-total_sectors.patch new file mode 100644 index 0000000..4797343 --- /dev/null +++ b/SOURCES/kvm-block-Round-up-total_sectors.patch @@ -0,0 +1,56 @@ +From 67a51a2fa1212326602dac399027ca94e382a7f2 Mon Sep 17 00:00:00 2001 +From: Fam Zheng +Date: Wed, 20 Nov 2013 09:16:44 +0100 +Subject: [PATCH 05/14] block: Round up total_sectors + +RH-Author: Fam Zheng +Message-id: <1384939004-30831-3-git-send-email-famz@redhat.com> +Patchwork-id: 55785 +O-Subject: [RHEL-7 qemu-kvm PATCH 2/2] block: Round up total_sectors +Bugzilla: 1025138 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Kevin Wolf +RH-Acked-by: Stefan Hajnoczi + +Since b94a2610, bdrv_getlength() is omitted when probing image. VMDK +monolithicFlat is broken by that because a file < 512 bytes can't be +read with its total_sectors truncated to 0. This patch round up the size +to BDRV_SECTOR_SIZE, when a image size is not sector aligned. + +Signed-off-by: Fam Zheng +Reviewed-by: Benoit Canet +Signed-off-by: Stefan Hajnoczi +(cherry picked from commit 7e382003f1bd9d8a441ecc5ac8a74bad3564d943) +Signed-off-by: Fam Zheng + +--- + block.c | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +Signed-off-by: Miroslav Rezanina +Signed-off-by: Fam Zheng +--- + block.c | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +Signed-off-by: Miroslav Rezanina +--- + block.c | 2 +- + 1 files changed, 1 insertions(+), 1 deletions(-) + +diff --git a/block.c b/block.c +index 301c4fb..72ab36c 100644 +--- a/block.c ++++ b/block.c +@@ -612,7 +612,7 @@ static int refresh_total_sectors(BlockDriverState *bs, int64_t hint) + if (length < 0) { + return length; + } +- hint = length >> BDRV_SECTOR_BITS; ++ hint = DIV_ROUND_UP(length, BDRV_SECTOR_SIZE); + } + + bs->total_sectors = hint; +-- +1.7.1 + diff --git a/SOURCES/kvm-block-Set-block-filename-sizes-to-PATH_MAX-instead-o.patch b/SOURCES/kvm-block-Set-block-filename-sizes-to-PATH_MAX-instead-o.patch new file mode 100644 index 0000000..00f6d6e --- /dev/null +++ b/SOURCES/kvm-block-Set-block-filename-sizes-to-PATH_MAX-instead-o.patch @@ -0,0 +1,155 @@ +From 339b5cbcea1d459d2a0fc4d289e17fc71622be23 Mon Sep 17 00:00:00 2001 +From: Jeffrey Cody +Date: Tue, 4 Mar 2014 19:38:27 +0100 +Subject: [PATCH 6/6] block: Set block filename sizes to PATH_MAX instead of 1024 +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +RH-Author: Jeffrey Cody +Message-id: +Patchwork-id: 58013 +O-Subject: [RHEL7 qemu-kvm PATCH] block: Set block filename sizes to PATH_MAX instead of 1024 +Bugzilla: 1072339 +RH-Acked-by: Eric Blake +RH-Acked-by: Amos Kong +RH-Acked-by: Stefan Hajnoczi + +This is an interim fix for a regression introduced by: + + commit dc5a137125d6ac641c566f10e68bf6e1fe31bcb5 + qemu-img: make "info" backing file output correct and easier to use + +In that commit, bdrv_get_full_backing_filename() was introduced, +which replaced calling path_combine() manually. The difference +is that rather than using the filename string as passed to +bdrv_open(), it uses the filename string attached to the BDS. + +Both the backing_file and filename strings in the BDS are limited to +1024 characters. The backing_file string built up in bdrv_open(), +however, has a limit of PATH_MAX, which is 4096 under Linux. + +This difference comes into play when using an image chain that has +a medium-to-large number of images, all of which have relative-pathed +backing file references to the parent directory. + +For instance, consider the following backing chain: + +tstA +├── base.qcow2 +├── sn1.qcow2 (backing file ../tstA/base.qcow2) +├── sn2.qcow2 (backing file ../tstA/sn1.qcow2) +└── sn3.qcow2 (backing file ../tstA/sn2.qcow2) + +The backing filename string is built up with the relative paths intact, +like so: + + base.qcow2: ../tstA../tstA../tstA/base.qcow2 + +The backing filename is then passed into the bdrv_open() call to open +the backing file. + +When using lv volume names, the snapshot and pathname ends up longer, +and after ~23 snapshots we have hit or exceeded the 1024 byte limit +for the BDS filename. + +This fix is different then the approach for RHEL6.6/6.5.z, because in +those it was trivial to modify bdrv_get_full_backing_filename(). In +RHEL7, there are places that use bdrv_get_backing_filename(), which +call bdrv_get_full_backing_filename(), yet do not have access to a +filename string that does not originate from the BDS. The simplest +approach, that should yield identical results, is to set all of the +filename and backing_file string sizes to PATH_MAX instead of 1024. + +This is not a long-term solution, because a character limit of 4096 +bytes will be hit with additional images. The proper long-term +solution should happen upstream first, and consist of: + +1) dynamically allocated filename strings in the BDS +2) flattening redundant relative pathname strings + +This is a bug that was reported in RHEL6, that also occurs in RHEL7. To +prevent a regression in RHEL7.0, this temporary solution will prevent +the regression, while not eliminating the ultimate problem. + +Since this is not the final solution, and the fix really is relevant +just to undo a regression, the fix is downstream only. It will be +replaced by the final upstream fix, once complete. + +BZ 1072339 +RHEL Brew: http://brewweb.devel.redhat.com/brew/taskinfo?taskID=7140291 +RHEV Brew: http://brewweb.devel.redhat.com/brew/taskinfo?taskID=7140320 +--- + block/mirror.c | 2 +- + block/qapi.c | 2 +- + block/stream.c | 2 +- + include/block/block_int.h | 6 +++--- + 4 files changed, 6 insertions(+), 6 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + block/mirror.c | 2 +- + block/qapi.c | 2 +- + block/stream.c | 2 +- + include/block/block_int.h | 6 +++--- + 4 files changed, 6 insertions(+), 6 deletions(-) + +diff --git a/block/mirror.c b/block/mirror.c +index ba1428b..47e14cd 100644 +--- a/block/mirror.c ++++ b/block/mirror.c +@@ -297,7 +297,7 @@ static void coroutine_fn mirror_run(void *opaque) + int64_t sector_num, end, sectors_per_chunk, length; + uint64_t last_pause_ns; + BlockDriverInfo bdi; +- char backing_filename[1024]; ++ char backing_filename[PATH_MAX]; + int ret = 0; + int n; + +diff --git a/block/qapi.c b/block/qapi.c +index 77e1719..2d4bdcd 100644 +--- a/block/qapi.c ++++ b/block/qapi.c +@@ -112,7 +112,7 @@ void bdrv_query_image_info(BlockDriverState *bs, + { + uint64_t total_sectors; + const char *backing_filename; +- char backing_filename2[1024]; ++ char backing_filename2[PATH_MAX]; + BlockDriverInfo bdi; + int ret; + Error *err = NULL; +diff --git a/block/stream.c b/block/stream.c +index 3a7d8f3..2a6f533 100644 +--- a/block/stream.c ++++ b/block/stream.c +@@ -32,7 +32,7 @@ typedef struct StreamBlockJob { + RateLimit limit; + BlockDriverState *base; + BlockdevOnError on_error; +- char backing_file_id[1024]; ++ char backing_file_id[PATH_MAX]; + } StreamBlockJob; + + static int coroutine_fn stream_populate(BlockDriverState *bs, +diff --git a/include/block/block_int.h b/include/block/block_int.h +index 2ec4bb2..53fc98c 100644 +--- a/include/block/block_int.h ++++ b/include/block/block_int.h +@@ -269,9 +269,9 @@ struct BlockDriverState { + const BlockDevOps *dev_ops; + void *dev_opaque; + +- char filename[1024]; +- char backing_file[1024]; /* if non zero, the image is a diff of +- this file image */ ++ char filename[PATH_MAX]; ++ char backing_file[PATH_MAX]; /* if non zero, the image is a diff of ++ this file image */ + char backing_format[16]; /* if non-zero and backing_file exists */ + int is_temporary; + +-- +1.7.1 + diff --git a/SOURCES/kvm-block-Switch-BdrvTrackedRequest-to-byte-granularity.patch b/SOURCES/kvm-block-Switch-BdrvTrackedRequest-to-byte-granularity.patch new file mode 100644 index 0000000..f8039af --- /dev/null +++ b/SOURCES/kvm-block-Switch-BdrvTrackedRequest-to-byte-granularity.patch @@ -0,0 +1,163 @@ +From e0f594c3eac9fb0a89c76de3b77bce03c235b36e Mon Sep 17 00:00:00 2001 +From: Kevin Wolf +Date: Tue, 3 Dec 2013 15:31:25 +0100 +Subject: [PATCH 16/37] block: Switch BdrvTrackedRequest to byte granularity + +Message-id: <1392117622-28812-17-git-send-email-kwolf@redhat.com> +Patchwork-id: 57181 +O-Subject: [RHEL-7.0 qemu-kvm PATCH v2 16/37] block: Switch BdrvTrackedRequest to byte granularity +Bugzilla: 748906 +RH-Acked-by: Laszlo Ersek +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Max Reitz + +Signed-off-by: Kevin Wolf +Reviewed-by: Max Reitz +Reviewed-by: Benoit Canet +(cherry picked from commit 793ed47a7a2b09b67cb2a8863dff531436532b5c) + +Conflicts: + block/backup.c + include/block/block_int.h + +Conflicts because in RHEL 7... +- ...block-backup doesn't exist +- ...BdrvTrackedRequest is in block.c rather than block_int.h + +Signed-off-by: Kevin Wolf +--- + block.c | 56 ++++++++++++++++++++++++++++++++++++-------------------- + 1 file changed, 36 insertions(+), 20 deletions(-) +--- + block.c | 56 ++++++++++++++++++++++++++++++++++++-------------------- + 1 files changed, 36 insertions(+), 20 deletions(-) + +diff --git a/block.c b/block.c +index 7b8131c..09bb127 100644 +--- a/block.c ++++ b/block.c +@@ -2036,8 +2036,8 @@ int bdrv_commit_all(void) + + struct BdrvTrackedRequest { + BlockDriverState *bs; +- int64_t sector_num; +- int nb_sectors; ++ int64_t offset; ++ unsigned int bytes; + bool is_write; + QLIST_ENTRY(BdrvTrackedRequest) list; + Coroutine *co; /* owner, used for deadlock detection */ +@@ -2060,13 +2060,13 @@ static void tracked_request_end(BdrvTrackedRequest *req) + */ + static void tracked_request_begin(BdrvTrackedRequest *req, + BlockDriverState *bs, +- int64_t sector_num, +- int nb_sectors, bool is_write) ++ int64_t offset, ++ unsigned int bytes, bool is_write) + { + *req = (BdrvTrackedRequest){ + .bs = bs, +- .sector_num = sector_num, +- .nb_sectors = nb_sectors, ++ .offset = offset, ++ .bytes = bytes, + .is_write = is_write, + .co = qemu_coroutine_self(), + }; +@@ -2097,25 +2097,43 @@ void bdrv_round_to_clusters(BlockDriverState *bs, + } + } + ++static void round_bytes_to_clusters(BlockDriverState *bs, ++ int64_t offset, unsigned int bytes, ++ int64_t *cluster_offset, ++ unsigned int *cluster_bytes) ++{ ++ BlockDriverInfo bdi; ++ ++ if (bdrv_get_info(bs, &bdi) < 0 || bdi.cluster_size == 0) { ++ *cluster_offset = offset; ++ *cluster_bytes = bytes; ++ } else { ++ *cluster_offset = QEMU_ALIGN_DOWN(offset, bdi.cluster_size); ++ *cluster_bytes = QEMU_ALIGN_UP(offset - *cluster_offset + bytes, ++ bdi.cluster_size); ++ } ++} ++ + static bool tracked_request_overlaps(BdrvTrackedRequest *req, +- int64_t sector_num, int nb_sectors) { ++ int64_t offset, unsigned int bytes) ++{ + /* aaaa bbbb */ +- if (sector_num >= req->sector_num + req->nb_sectors) { ++ if (offset >= req->offset + req->bytes) { + return false; + } + /* bbbb aaaa */ +- if (req->sector_num >= sector_num + nb_sectors) { ++ if (req->offset >= offset + bytes) { + return false; + } + return true; + } + + static void coroutine_fn wait_for_overlapping_requests(BlockDriverState *bs, +- int64_t sector_num, int nb_sectors) ++ int64_t offset, unsigned int bytes) + { + BdrvTrackedRequest *req; +- int64_t cluster_sector_num; +- int cluster_nb_sectors; ++ int64_t cluster_offset; ++ unsigned int cluster_bytes; + bool retry; + + /* If we touch the same cluster it counts as an overlap. This guarantees +@@ -2124,14 +2142,12 @@ static void coroutine_fn wait_for_overlapping_requests(BlockDriverState *bs, + * CoR read and write operations are atomic and guest writes cannot + * interleave between them. + */ +- bdrv_round_to_clusters(bs, sector_num, nb_sectors, +- &cluster_sector_num, &cluster_nb_sectors); ++ round_bytes_to_clusters(bs, offset, bytes, &cluster_offset, &cluster_bytes); + + do { + retry = false; + QLIST_FOREACH(req, &bs->tracked_requests, list) { +- if (tracked_request_overlaps(req, cluster_sector_num, +- cluster_nb_sectors)) { ++ if (tracked_request_overlaps(req, cluster_offset, cluster_bytes)) { + /* Hitting this means there was a reentrant request, for + * example, a block driver issuing nested requests. This must + * never happen since it means deadlock. +@@ -2746,10 +2762,10 @@ static int coroutine_fn bdrv_aligned_preadv(BlockDriverState *bs, + } + + if (bs->copy_on_read_in_flight) { +- wait_for_overlapping_requests(bs, sector_num, nb_sectors); ++ wait_for_overlapping_requests(bs, offset, bytes); + } + +- tracked_request_begin(&req, bs, sector_num, nb_sectors, false); ++ tracked_request_begin(&req, bs, offset, bytes, false); + + if (flags & BDRV_REQ_COPY_ON_READ) { + int pnum; +@@ -2998,10 +3014,10 @@ static int coroutine_fn bdrv_aligned_pwritev(BlockDriverState *bs, + assert((bytes & (BDRV_SECTOR_SIZE - 1)) == 0); + + if (bs->copy_on_read_in_flight) { +- wait_for_overlapping_requests(bs, sector_num, nb_sectors); ++ wait_for_overlapping_requests(bs, offset, bytes); + } + +- tracked_request_begin(&req, bs, sector_num, nb_sectors, true); ++ tracked_request_begin(&req, bs, offset, bytes, true); + + if (flags & BDRV_REQ_ZERO_WRITE) { + ret = bdrv_co_do_write_zeroes(bs, sector_num, nb_sectors, flags); +-- +1.7.1 + diff --git a/SOURCES/kvm-block-Update-BlockLimits-when-they-might-have-change.patch b/SOURCES/kvm-block-Update-BlockLimits-when-they-might-have-change.patch new file mode 100644 index 0000000..1e06421 --- /dev/null +++ b/SOURCES/kvm-block-Update-BlockLimits-when-they-might-have-change.patch @@ -0,0 +1,101 @@ +From 39fd66a311ade8aa330c6c32f1b2a3669e6db44f Mon Sep 17 00:00:00 2001 +From: Kevin Wolf +Date: Wed, 11 Dec 2013 20:14:09 +0100 +Subject: [PATCH 05/37] block: Update BlockLimits when they might have changed +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +Message-id: <1392117622-28812-6-git-send-email-kwolf@redhat.com> +Patchwork-id: 57170 +O-Subject: [RHEL-7.0 qemu-kvm PATCH v2 05/37] block: Update BlockLimits when they might have changed +Bugzilla: 748906 +RH-Acked-by: Laszlo Ersek +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Max Reitz + +When reopening with different flags, or when backing files disappear +from the chain, the limits may change. Make sure they get updated in +these cases. + +Signed-off-by: Kevin Wolf +Reviewed-by: Wenchao Xia +Reviewed-by: Max Reitz +Reviewed-by: Benoît Canet +(cherry picked from commit 355ef4ac95a7a47d5c7201ccd910056a100d2fdf) + +Conflicts: + block/stream.c + +Trivial context-only conflict. + +Signed-off-by: Kevin Wolf +--- + block.c | 5 ++++- + block/stream.c | 2 ++ + include/block/block.h | 1 + + 3 files changed, 7 insertions(+), 1 deletion(-) +--- + block.c | 5 ++++- + block/stream.c | 2 ++ + include/block/block.h | 1 + + 3 files changed, 7 insertions(+), 1 deletions(-) + +diff --git a/block.c b/block.c +index 8b36d05..f62acbd 100644 +--- a/block.c ++++ b/block.c +@@ -446,7 +446,7 @@ int bdrv_create_file(const char* filename, QEMUOptionParameter *options, + return ret; + } + +-static int bdrv_refresh_limits(BlockDriverState *bs) ++int bdrv_refresh_limits(BlockDriverState *bs) + { + BlockDriver *drv = bs->drv; + +@@ -1452,6 +1452,8 @@ void bdrv_reopen_commit(BDRVReopenState *reopen_state) + reopen_state->bs->enable_write_cache = !!(reopen_state->flags & + BDRV_O_CACHE_WB); + reopen_state->bs->read_only = !(reopen_state->flags & BDRV_O_RDWR); ++ ++ bdrv_refresh_limits(reopen_state->bs); + } + + /* +@@ -2284,6 +2286,7 @@ int bdrv_drop_intermediate(BlockDriverState *active, BlockDriverState *top, + } + new_top_bs->backing_hd = base_bs; + ++ bdrv_refresh_limits(new_top_bs); + + QSIMPLEQ_FOREACH_SAFE(intermediate_state, &states_to_delete, entry, next) { + /* so that bdrv_close() does not recursively close the chain */ +diff --git a/block/stream.c b/block/stream.c +index 1420d09..3a7d8f3 100644 +--- a/block/stream.c ++++ b/block/stream.c +@@ -71,6 +71,8 @@ static void close_unused_images(BlockDriverState *top, BlockDriverState *base, + bdrv_unref(unused); + } + top->backing_hd = base; ++ ++ bdrv_refresh_limits(top); + } + + static void coroutine_fn stream_run(void *opaque) +diff --git a/include/block/block.h b/include/block/block.h +index d20d63e..3e22fc2 100644 +--- a/include/block/block.h ++++ b/include/block/block.h +@@ -250,6 +250,7 @@ int bdrv_truncate(BlockDriverState *bs, int64_t offset); + int64_t bdrv_getlength(BlockDriverState *bs); + int64_t bdrv_get_allocated_file_size(BlockDriverState *bs); + void bdrv_get_geometry(BlockDriverState *bs, uint64_t *nb_sectors_ptr); ++int bdrv_refresh_limits(BlockDriverState *bs); + int bdrv_commit(BlockDriverState *bs); + int bdrv_commit_all(void); + int bdrv_change_backing_file(BlockDriverState *bs, +-- +1.7.1 + diff --git a/SOURCES/kvm-block-Update-image-size-in-bdrv_invalidate_cache.patch b/SOURCES/kvm-block-Update-image-size-in-bdrv_invalidate_cache.patch new file mode 100644 index 0000000..0962a9b --- /dev/null +++ b/SOURCES/kvm-block-Update-image-size-in-bdrv_invalidate_cache.patch @@ -0,0 +1,98 @@ +From ceea60585e2975d7860725bb8c6c860b791a4b72 Mon Sep 17 00:00:00 2001 +From: Kevin Wolf +Date: Mon, 17 Mar 2014 13:29:26 +0100 +Subject: [PATCH 2/6] block: Update image size in bdrv_invalidate_cache() + +RH-Author: Kevin Wolf +Message-id: <1395062967-16867-2-git-send-email-kwolf@redhat.com> +Patchwork-id: 58111 +O-Subject: [RHEL-7.0 qemu-kvm PATCH 1/2] block: Update image size in bdrv_invalidate_cache() +Bugzilla: 1048575 +RH-Acked-by: Max Reitz +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Fam Zheng + +After migration has completed, we call bdrv_invalidate_cache() so that +drivers which cache some data drop their stale copy of the data and +reread it from the image file to get a new version of data that the +source modified while the migration was running. + +Reloading metadata from the image file is useless, though, if the size +of the image file stays stale (this is a value that is cached for all +image formats in block.c). Reads from (meta)data after the old EOF +return only zeroes, causing image corruption. + +We need to update bs->total_sectors in all layers that could potentially +have changed their size (i.e. backing files are not a concern - if they +are changed, we're in bigger trouble) + +Signed-off-by: Kevin Wolf +Signed-off-by: Stefan Hajnoczi +(cherry picked from commit 3456a8d1852e970688b73d03fdc44dde851759e1) +Signed-off-by: Kevin Wolf +--- + block.c | 10 +++++++++- + block/qcow2.c | 2 ++ + block/qed.c | 3 +++ + 3 files changed, 14 insertions(+), 1 deletion(-) + +Signed-off-by: Miroslav Rezanina +--- + block.c | 10 +++++++++- + block/qcow2.c | 2 ++ + block/qed.c | 3 +++ + 3 files changed, 14 insertions(+), 1 deletions(-) + +diff --git a/block.c b/block.c +index ec8dc90..ae55535 100644 +--- a/block.c ++++ b/block.c +@@ -4713,9 +4713,17 @@ flush_parent: + + void bdrv_invalidate_cache(BlockDriverState *bs) + { +- if (bs->drv && bs->drv->bdrv_invalidate_cache) { ++ if (!bs->drv) { ++ return; ++ } ++ ++ if (bs->drv->bdrv_invalidate_cache) { + bs->drv->bdrv_invalidate_cache(bs); ++ } else if (bs->file) { ++ bdrv_invalidate_cache(bs->file); + } ++ ++ refresh_total_sectors(bs, bs->total_sectors); + } + + void bdrv_invalidate_cache_all(void) +diff --git a/block/qcow2.c b/block/qcow2.c +index daad932..e9bd9c9 100644 +--- a/block/qcow2.c ++++ b/block/qcow2.c +@@ -1176,6 +1176,8 @@ static void qcow2_invalidate_cache(BlockDriverState *bs) + + qcow2_close(bs); + ++ bdrv_invalidate_cache(bs->file); ++ + options = qdict_new(); + qdict_put(options, QCOW2_OPT_LAZY_REFCOUNTS, + qbool_from_int(s->use_lazy_refcounts)); +diff --git a/block/qed.c b/block/qed.c +index be5945b..619f2d0 100644 +--- a/block/qed.c ++++ b/block/qed.c +@@ -1561,6 +1561,9 @@ static void bdrv_qed_invalidate_cache(BlockDriverState *bs) + BDRVQEDState *s = bs->opaque; + + bdrv_qed_close(bs); ++ ++ bdrv_invalidate_cache(bs->file); ++ + memset(s, 0, sizeof(BDRVQEDState)); + bdrv_qed_open(bs, NULL, bs->open_flags, NULL); + } +-- +1.7.1 + diff --git a/SOURCES/kvm-block-add-.bdrv_reopen_prepare-stub-for-iscsi.patch b/SOURCES/kvm-block-add-.bdrv_reopen_prepare-stub-for-iscsi.patch new file mode 100644 index 0000000..6541d64 --- /dev/null +++ b/SOURCES/kvm-block-add-.bdrv_reopen_prepare-stub-for-iscsi.patch @@ -0,0 +1,66 @@ +From 865f21e1199cf38bc461b91c30d97bf1baceb8ba Mon Sep 17 00:00:00 2001 +From: Jeffrey Cody +Date: Tue, 28 Jan 2014 14:21:57 +0100 +Subject: [PATCH 22/22] block: add .bdrv_reopen_prepare() stub for iscsi + +RH-Author: Jeffrey Cody +Message-id: <884dd65be83603e336fac7a2fd2640ec52fe095d.1390918756.git.jcody@redhat.com> +Patchwork-id: 57003 +O-Subject: [RHEL7 qemu-kvm PATCH v2 1/1] block: add .bdrv_reopen_prepare() stub for iscsi +Bugzilla: 1030301 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Kevin Wolf + +To suppport reopen(), the .bdrv_reopen_prepare() stub must exist. +iSCSI does not have anything that needs to be done to support reopen, +so we can just implement the _prepare() stub. + +Signed-off-by: Jeff Cody +Signed-off-by: Paolo Bonzini +(cherry picked from commit dc6afb99b39a78cf416c6d19e35f680f202016be) + +RHEL7 Note: It should be noted that this _prepare() empty stub + is all that is needed when performing a reopen, because + the bdrv flags are ignored by iscsi_open. Specifically, in + this form, reopen will not reconnect to an iSCSI target. + +--- + block/iscsi.c | 9 +++++++++ + 1 file changed, 9 insertions(+) + +Signed-off-by: Miroslav Rezanina +--- + block/iscsi.c | 9 +++++++++ + 1 files changed, 9 insertions(+), 0 deletions(-) + +diff --git a/block/iscsi.c b/block/iscsi.c +index fa6f7c4..1c5b0a2 100644 +--- a/block/iscsi.c ++++ b/block/iscsi.c +@@ -1506,6 +1506,14 @@ static void iscsi_close(BlockDriverState *bs) + memset(iscsilun, 0, sizeof(IscsiLun)); + } + ++/* We have nothing to do for iSCSI reopen, stub just returns ++ * success */ ++static int iscsi_reopen_prepare(BDRVReopenState *state, ++ BlockReopenQueue *queue, Error **errp) ++{ ++ return 0; ++} ++ + static int iscsi_truncate(BlockDriverState *bs, int64_t offset) + { + IscsiLun *iscsilun = bs->opaque; +@@ -1613,6 +1621,7 @@ static BlockDriver bdrv_iscsi = { + .bdrv_close = iscsi_close, + .bdrv_create = iscsi_create, + .create_options = iscsi_create_options, ++ .bdrv_reopen_prepare = iscsi_reopen_prepare, + + .bdrv_getlength = iscsi_getlength, + .bdrv_get_info = iscsi_get_info, +-- +1.7.1 + diff --git a/SOURCES/kvm-block-add-BlockLimits-structure-to-BlockDriverState.patch.patch.patch b/SOURCES/kvm-block-add-BlockLimits-structure-to-BlockDriverState.patch.patch.patch new file mode 100644 index 0000000..bbe7512 --- /dev/null +++ b/SOURCES/kvm-block-add-BlockLimits-structure-to-BlockDriverState.patch.patch.patch @@ -0,0 +1,72 @@ +From ef41c637feebd279b017838b46dc5cfdb52c1ef6 Mon Sep 17 00:00:00 2001 +Message-Id: +In-Reply-To: +References: +From: Paolo Bonzini +Date: Mon, 9 Dec 2013 14:09:00 +0100 +Subject: [PATCH 12/50] block: add BlockLimits structure to BlockDriverState + +RH-Author: Paolo Bonzini +Message-id: <1386598178-11845-15-git-send-email-pbonzini@redhat.com> +Patchwork-id: 56049 +O-Subject: [RHEL 7.0 qemu-kvm PATCH 14/52] block: add BlockLimits structure to BlockDriverState +Bugzilla: 1007815 +RH-Acked-by: Jeffrey Cody +RH-Acked-by: Fam Zheng +RH-Acked-by: Stefan Hajnoczi + +From: Peter Lieven + +this patch adds BlockLimits which introduces discard and write_zeroes +limits and alignment information to the BlockDriverState. + +Signed-off-by: Peter Lieven +Signed-off-by: Stefan Hajnoczi +(cherry picked from commit fe81c2cca6dc69a5e423f6d8b235606b7f3ca7b7) +--- + include/block/block_int.h | 17 +++++++++++++++++ + 1 file changed, 17 insertions(+) + +Signed-off-by: Michal Novotny +--- + include/block/block_int.h | 17 +++++++++++++++++ + 1 file changed, 17 insertions(+) + +diff --git a/include/block/block_int.h b/include/block/block_int.h +index 236c0c2..ab98c07 100644 +--- a/include/block/block_int.h ++++ b/include/block/block_int.h +@@ -219,6 +219,20 @@ struct BlockDriver { + QLIST_ENTRY(BlockDriver) list; + }; + ++typedef struct BlockLimits { ++ /* maximum number of sectors that can be discarded at once */ ++ int max_discard; ++ ++ /* optimal alignment for discard requests in sectors */ ++ int64_t discard_alignment; ++ ++ /* maximum number of sectors that can zeroized at once */ ++ int max_write_zeroes; ++ ++ /* optimal alignment for write zeroes requests in sectors */ ++ int64_t write_zeroes_alignment; ++} BlockLimits; ++ + /* + * Note: the function bdrv_append() copies and swaps contents of + * BlockDriverStates, so if you add new fields to this struct, please +@@ -273,6 +287,9 @@ struct BlockDriverState { + uint64_t total_time_ns[BDRV_MAX_IOTYPE]; + uint64_t wr_highest_sector; + ++ /* I/O Limits */ ++ BlockLimits bl; ++ + /* Whether the disk can expand beyond total_sectors */ + int growable; + +-- +1.7.11.7 + diff --git a/SOURCES/kvm-block-add-bdrv_aio_write_zeroes.patch.patch.patch b/SOURCES/kvm-block-add-bdrv_aio_write_zeroes.patch.patch.patch new file mode 100644 index 0000000..809da4c --- /dev/null +++ b/SOURCES/kvm-block-add-bdrv_aio_write_zeroes.patch.patch.patch @@ -0,0 +1,87 @@ +From 0e36c36c95c2616d020321782d4c8164c561eaec Mon Sep 17 00:00:00 2001 +Message-Id: <0e36c36c95c2616d020321782d4c8164c561eaec.1389014116.git.minovotn@redhat.com> +In-Reply-To: +References: +From: Paolo Bonzini +Date: Mon, 9 Dec 2013 14:09:14 +0100 +Subject: [PATCH 26/50] block: add bdrv_aio_write_zeroes + +RH-Author: Paolo Bonzini +Message-id: <1386598178-11845-29-git-send-email-pbonzini@redhat.com> +Patchwork-id: 56065 +O-Subject: [RHEL 7.0 qemu-kvm PATCH 28/52] block: add bdrv_aio_write_zeroes +Bugzilla: 1007815 +RH-Acked-by: Jeffrey Cody +RH-Acked-by: Fam Zheng +RH-Acked-by: Stefan Hajnoczi + +This will be used by the SCSI layer. + +Signed-off-by: Paolo Bonzini +Reviewed-by: Peter Lieven +Signed-off-by: Stefan Hajnoczi +(cherry picked from commit d5ef94d43da8c57a2d597efbdec3d9a54d97fdf7) +--- + block.c | 11 +++++++++++ + include/block/block.h | 3 +++ + trace-events | 1 + + 3 files changed, 15 insertions(+) + +Signed-off-by: Michal Novotny +--- + block.c | 11 +++++++++++ + include/block/block.h | 3 +++ + trace-events | 1 + + 3 files changed, 15 insertions(+) + +diff --git a/block.c b/block.c +index c6cad55..fc15370 100644 +--- a/block.c ++++ b/block.c +@@ -3690,6 +3690,17 @@ BlockDriverAIOCB *bdrv_aio_writev(BlockDriverState *bs, int64_t sector_num, + cb, opaque, true); + } + ++BlockDriverAIOCB *bdrv_aio_write_zeroes(BlockDriverState *bs, ++ int64_t sector_num, int nb_sectors, BdrvRequestFlags flags, ++ BlockDriverCompletionFunc *cb, void *opaque) ++{ ++ trace_bdrv_aio_write_zeroes(bs, sector_num, nb_sectors, flags, opaque); ++ ++ return bdrv_co_aio_rw_vector(bs, sector_num, NULL, nb_sectors, ++ BDRV_REQ_ZERO_WRITE | flags, ++ cb, opaque, true); ++} ++ + + typedef struct MultiwriteCB { + int error; +diff --git a/include/block/block.h b/include/block/block.h +index 6042e10..bcf71e2 100644 +--- a/include/block/block.h ++++ b/include/block/block.h +@@ -218,6 +218,9 @@ int bdrv_write(BlockDriverState *bs, int64_t sector_num, + const uint8_t *buf, int nb_sectors); + int bdrv_write_zeroes(BlockDriverState *bs, int64_t sector_num, + int nb_sectors, BdrvRequestFlags flags); ++BlockDriverAIOCB *bdrv_aio_write_zeroes(BlockDriverState *bs, int64_t sector_num, ++ int nb_sectors, BdrvRequestFlags flags, ++ BlockDriverCompletionFunc *cb, void *opaque); + int bdrv_make_zero(BlockDriverState *bs, BdrvRequestFlags flags); + int bdrv_writev(BlockDriverState *bs, int64_t sector_num, QEMUIOVector *qiov); + int bdrv_pread(BlockDriverState *bs, int64_t offset, +diff --git a/trace-events b/trace-events +index fa5a65c..40d4312 100644 +--- a/trace-events ++++ b/trace-events +@@ -60,6 +60,7 @@ bdrv_aio_discard(void *bs, int64_t sector_num, int nb_sectors, void *opaque) "bs + bdrv_aio_flush(void *bs, void *opaque) "bs %p opaque %p" + bdrv_aio_readv(void *bs, int64_t sector_num, int nb_sectors, void *opaque) "bs %p sector_num %"PRId64" nb_sectors %d opaque %p" + bdrv_aio_writev(void *bs, int64_t sector_num, int nb_sectors, void *opaque) "bs %p sector_num %"PRId64" nb_sectors %d opaque %p" ++bdrv_aio_write_zeroes(void *bs, int64_t sector_num, int nb_sectors, int flags, void *opaque) "bs %p sector_num %"PRId64" nb_sectors %d flags %#x opaque %p" + bdrv_lock_medium(void *bs, bool locked) "bs %p locked %d" + bdrv_co_readv(void *bs, int64_t sector_num, int nb_sector) "bs %p sector_num %"PRId64" nb_sectors %d" + bdrv_co_copy_on_readv(void *bs, int64_t sector_num, int nb_sector) "bs %p sector_num %"PRId64" nb_sectors %d" +-- +1.7.11.7 + diff --git a/SOURCES/kvm-block-add-flags-argument-to-bdrv_co_write_zeroes-tra.patch.patch.patch b/SOURCES/kvm-block-add-flags-argument-to-bdrv_co_write_zeroes-tra.patch.patch.patch new file mode 100644 index 0000000..3231782 --- /dev/null +++ b/SOURCES/kvm-block-add-flags-argument-to-bdrv_co_write_zeroes-tra.patch.patch.patch @@ -0,0 +1,62 @@ +From 04f210211997117a226e6deef0b3c062058fa5d6 Mon Sep 17 00:00:00 2001 +Message-Id: <04f210211997117a226e6deef0b3c062058fa5d6.1389014116.git.minovotn@redhat.com> +In-Reply-To: +References: +From: Paolo Bonzini +Date: Mon, 9 Dec 2013 14:09:13 +0100 +Subject: [PATCH 25/50] block: add flags argument to bdrv_co_write_zeroes + tracepoint + +RH-Author: Paolo Bonzini +Message-id: <1386598178-11845-28-git-send-email-pbonzini@redhat.com> +Patchwork-id: 56064 +O-Subject: [RHEL 7.0 qemu-kvm PATCH 27/52] block: add flags argument to bdrv_co_write_zeroes tracepoint +Bugzilla: 1007815 +RH-Acked-by: Jeffrey Cody +RH-Acked-by: Fam Zheng +RH-Acked-by: Stefan Hajnoczi + +Signed-off-by: Paolo Bonzini +Reviewed-by: Peter Lieven +Signed-off-by: Stefan Hajnoczi +(cherry picked from commit 94d6ff21f48c8c98e6e9eef58cc6f6346c9dd851) +--- + block.c | 2 +- + trace-events | 2 +- + 2 files changed, 2 insertions(+), 2 deletions(-) + +Signed-off-by: Michal Novotny +--- + block.c | 2 +- + trace-events | 2 +- + 2 files changed, 2 insertions(+), 2 deletions(-) + +diff --git a/block.c b/block.c +index 1f70913..c6cad55 100644 +--- a/block.c ++++ b/block.c +@@ -2896,7 +2896,7 @@ int coroutine_fn bdrv_co_write_zeroes(BlockDriverState *bs, + int64_t sector_num, int nb_sectors, + BdrvRequestFlags flags) + { +- trace_bdrv_co_write_zeroes(bs, sector_num, nb_sectors); ++ trace_bdrv_co_write_zeroes(bs, sector_num, nb_sectors, flags); + + if (!(bs->open_flags & BDRV_O_UNMAP)) { + flags &= ~BDRV_REQ_MAY_UNMAP; +diff --git a/trace-events b/trace-events +index b72a72f..fa5a65c 100644 +--- a/trace-events ++++ b/trace-events +@@ -64,7 +64,7 @@ bdrv_lock_medium(void *bs, bool locked) "bs %p locked %d" + bdrv_co_readv(void *bs, int64_t sector_num, int nb_sector) "bs %p sector_num %"PRId64" nb_sectors %d" + bdrv_co_copy_on_readv(void *bs, int64_t sector_num, int nb_sector) "bs %p sector_num %"PRId64" nb_sectors %d" + bdrv_co_writev(void *bs, int64_t sector_num, int nb_sector) "bs %p sector_num %"PRId64" nb_sectors %d" +-bdrv_co_write_zeroes(void *bs, int64_t sector_num, int nb_sector) "bs %p sector_num %"PRId64" nb_sectors %d" ++bdrv_co_write_zeroes(void *bs, int64_t sector_num, int nb_sector, int flags) "bs %p sector_num %"PRId64" nb_sectors %d flags %#x" + bdrv_co_io_em(void *bs, int64_t sector_num, int nb_sectors, int is_write, void *acb) "bs %p sector_num %"PRId64" nb_sectors %d is_write %d acb %p" + bdrv_co_do_copy_on_readv(void *bs, int64_t sector_num, int nb_sectors, int64_t cluster_sector_num, int cluster_nb_sectors) "bs %p sector_num %"PRId64" nb_sectors %d cluster_sector_num %"PRId64" cluster_nb_sectors %d" + +-- +1.7.11.7 + diff --git a/SOURCES/kvm-block-add-flags-to-BlockRequest.patch.patch.patch b/SOURCES/kvm-block-add-flags-to-BlockRequest.patch.patch.patch new file mode 100644 index 0000000..210c611 --- /dev/null +++ b/SOURCES/kvm-block-add-flags-to-BlockRequest.patch.patch.patch @@ -0,0 +1,122 @@ +From 566788cb4c4f066daf10354edd8d9d497bb0043c Mon Sep 17 00:00:00 2001 +Message-Id: <566788cb4c4f066daf10354edd8d9d497bb0043c.1389014116.git.minovotn@redhat.com> +In-Reply-To: +References: +From: Paolo Bonzini +Date: Mon, 9 Dec 2013 14:09:12 +0100 +Subject: [PATCH 24/50] block: add flags to BlockRequest + +RH-Author: Paolo Bonzini +Message-id: <1386598178-11845-27-git-send-email-pbonzini@redhat.com> +Patchwork-id: 56063 +O-Subject: [RHEL 7.0 qemu-kvm PATCH 26/52] block: add flags to BlockRequest +Bugzilla: 1007815 +RH-Acked-by: Jeffrey Cody +RH-Acked-by: Fam Zheng +RH-Acked-by: Stefan Hajnoczi + +This lets bdrv_co_do_rw receive flags, so that it can be used for +zero writes. + +Signed-off-by: Paolo Bonzini +Reviewed-by: Peter Lieven +Signed-off-by: Stefan Hajnoczi +(cherry picked from commit d20d9b7c6723d0123b7d60dd5557aa0a6599f471) +--- + block.c | 17 +++++++++++------ + include/block/block.h | 1 + + 2 files changed, 12 insertions(+), 6 deletions(-) + +Signed-off-by: Michal Novotny +--- + block.c | 17 +++++++++++------ + include/block/block.h | 1 + + 2 files changed, 12 insertions(+), 6 deletions(-) + +diff --git a/block.c b/block.c +index 8dfc207..1f70913 100644 +--- a/block.c ++++ b/block.c +@@ -74,6 +74,7 @@ static BlockDriverAIOCB *bdrv_co_aio_rw_vector(BlockDriverState *bs, + int64_t sector_num, + QEMUIOVector *qiov, + int nb_sectors, ++ BdrvRequestFlags flags, + BlockDriverCompletionFunc *cb, + void *opaque, + bool is_write); +@@ -3675,7 +3676,7 @@ BlockDriverAIOCB *bdrv_aio_readv(BlockDriverState *bs, int64_t sector_num, + { + trace_bdrv_aio_readv(bs, sector_num, nb_sectors, opaque); + +- return bdrv_co_aio_rw_vector(bs, sector_num, qiov, nb_sectors, ++ return bdrv_co_aio_rw_vector(bs, sector_num, qiov, nb_sectors, 0, + cb, opaque, false); + } + +@@ -3685,7 +3686,7 @@ BlockDriverAIOCB *bdrv_aio_writev(BlockDriverState *bs, int64_t sector_num, + { + trace_bdrv_aio_writev(bs, sector_num, nb_sectors, opaque); + +- return bdrv_co_aio_rw_vector(bs, sector_num, qiov, nb_sectors, ++ return bdrv_co_aio_rw_vector(bs, sector_num, qiov, nb_sectors, 0, + cb, opaque, true); + } + +@@ -3857,8 +3858,10 @@ int bdrv_aio_multiwrite(BlockDriverState *bs, BlockRequest *reqs, int num_reqs) + /* Run the aio requests. */ + mcb->num_requests = num_reqs; + for (i = 0; i < num_reqs; i++) { +- bdrv_aio_writev(bs, reqs[i].sector, reqs[i].qiov, +- reqs[i].nb_sectors, multiwrite_cb, mcb); ++ bdrv_co_aio_rw_vector(bs, reqs[i].sector, reqs[i].qiov, ++ reqs[i].nb_sectors, reqs[i].flags, ++ multiwrite_cb, mcb, ++ true); + } + + return 0; +@@ -4163,10 +4166,10 @@ static void coroutine_fn bdrv_co_do_rw(void *opaque) + + if (!acb->is_write) { + acb->req.error = bdrv_co_do_readv(bs, acb->req.sector, +- acb->req.nb_sectors, acb->req.qiov, 0); ++ acb->req.nb_sectors, acb->req.qiov, acb->req.flags); + } else { + acb->req.error = bdrv_co_do_writev(bs, acb->req.sector, +- acb->req.nb_sectors, acb->req.qiov, 0); ++ acb->req.nb_sectors, acb->req.qiov, acb->req.flags); + } + + acb->bh = qemu_bh_new(bdrv_co_em_bh, acb); +@@ -4177,6 +4180,7 @@ static BlockDriverAIOCB *bdrv_co_aio_rw_vector(BlockDriverState *bs, + int64_t sector_num, + QEMUIOVector *qiov, + int nb_sectors, ++ BdrvRequestFlags flags, + BlockDriverCompletionFunc *cb, + void *opaque, + bool is_write) +@@ -4188,6 +4192,7 @@ static BlockDriverAIOCB *bdrv_co_aio_rw_vector(BlockDriverState *bs, + acb->req.sector = sector_num; + acb->req.nb_sectors = nb_sectors; + acb->req.qiov = qiov; ++ acb->req.flags = flags; + acb->is_write = is_write; + acb->done = NULL; + +diff --git a/include/block/block.h b/include/block/block.h +index b87ed3a..6042e10 100644 +--- a/include/block/block.h ++++ b/include/block/block.h +@@ -297,6 +297,7 @@ typedef struct BlockRequest { + /* Fields to be filled by multiwrite caller */ + int64_t sector; + int nb_sectors; ++ int flags; + QEMUIOVector *qiov; + BlockDriverCompletionFunc *cb; + void *opaque; +-- +1.7.11.7 + diff --git a/SOURCES/kvm-block-add-flags-to-bdrv_-_write_zeroes.patch.patch.patch b/SOURCES/kvm-block-add-flags-to-bdrv_-_write_zeroes.patch.patch.patch new file mode 100644 index 0000000..8b8c4cf --- /dev/null +++ b/SOURCES/kvm-block-add-flags-to-bdrv_-_write_zeroes.patch.patch.patch @@ -0,0 +1,256 @@ +From 0f795e4e9e128f9ff88a128ed8590d2357228b80 Mon Sep 17 00:00:00 2001 +Message-Id: <0f795e4e9e128f9ff88a128ed8590d2357228b80.1389014116.git.minovotn@redhat.com> +In-Reply-To: +References: +From: Paolo Bonzini +Date: Mon, 9 Dec 2013 14:08:55 +0100 +Subject: [PATCH 07/50] block: add flags to bdrv_*_write_zeroes + +RH-Author: Paolo Bonzini +Message-id: <1386598178-11845-10-git-send-email-pbonzini@redhat.com> +Patchwork-id: 56046 +O-Subject: [RHEL 7.0 qemu-kvm PATCH 09/52] block: add flags to bdrv_*_write_zeroes +Bugzilla: 1007815 +RH-Acked-by: Jeffrey Cody +RH-Acked-by: Fam Zheng +RH-Acked-by: Stefan Hajnoczi + +From: Peter Lieven + +Reviewed-by: Eric Blake +Signed-off-by: Peter Lieven +Signed-off-by: Stefan Hajnoczi +(cherry picked from commit aa7bfbfff792538a9eeefe879fc4c629aa0b4203) + +Conflicts: + block.c [missing before_write notifier] + block/backup.c [missing] + block/qcow2-cluster.c [missing function to expand zero clusters] + block/raw_bsd.c [replaced by block/raw.c] + qemu-io-cmds.c [replaced by qemu-io.c] +--- + block-migration.c | 2 +- + block.c | 20 +++++++++++--------- + block/qcow2.c | 2 +- + block/qed.c | 3 ++- + block/raw.c | 5 +++-- + block/vmdk.c | 3 ++- + include/block/block.h | 4 ++-- + include/block/block_int.h | 2 +- + qemu-io.c | 2 +- + 9 files changed, 24 insertions(+), 19 deletions(-) + +Signed-off-by: Michal Novotny +--- + block-migration.c | 2 +- + block.c | 20 +++++++++++--------- + block/qcow2.c | 2 +- + block/qed.c | 3 ++- + block/raw.c | 5 +++-- + block/vmdk.c | 3 ++- + include/block/block.h | 4 ++-- + include/block/block_int.h | 2 +- + qemu-io.c | 2 +- + 9 files changed, 24 insertions(+), 19 deletions(-) + +diff --git a/block-migration.c b/block-migration.c +index f803f20..3b22db6 100644 +--- a/block-migration.c ++++ b/block-migration.c +@@ -780,7 +780,7 @@ static int block_load(QEMUFile *f, void *opaque, int version_id) + } + + if (flags & BLK_MIG_FLAG_ZERO_BLOCK) { +- ret = bdrv_write_zeroes(bs, addr, nr_sectors); ++ ret = bdrv_write_zeroes(bs, addr, nr_sectors, 0); + } else { + buf = g_malloc(BLOCK_SIZE); + qemu_get_buffer(f, buf, BLOCK_SIZE); +diff --git a/block.c b/block.c +index b7ca799..698334a 100644 +--- a/block.c ++++ b/block.c +@@ -79,7 +79,7 @@ static BlockDriverAIOCB *bdrv_co_aio_rw_vector(BlockDriverState *bs, + bool is_write); + static void coroutine_fn bdrv_co_do_rw(void *opaque); + static int coroutine_fn bdrv_co_do_write_zeroes(BlockDriverState *bs, +- int64_t sector_num, int nb_sectors); ++ int64_t sector_num, int nb_sectors, BdrvRequestFlags flags); + + static bool bdrv_exceed_bps_limits(BlockDriverState *bs, int nb_sectors, + bool is_write, double elapsed_time, uint64_t *wait); +@@ -2405,10 +2405,11 @@ int bdrv_writev(BlockDriverState *bs, int64_t sector_num, QEMUIOVector *qiov) + return bdrv_rwv_co(bs, sector_num, qiov, true, 0); + } + +-int bdrv_write_zeroes(BlockDriverState *bs, int64_t sector_num, int nb_sectors) ++int bdrv_write_zeroes(BlockDriverState *bs, int64_t sector_num, ++ int nb_sectors, BdrvRequestFlags flags) + { + return bdrv_rw_co(bs, sector_num, NULL, nb_sectors, true, +- BDRV_REQ_ZERO_WRITE); ++ BDRV_REQ_ZERO_WRITE | flags); + } + + int bdrv_pread(BlockDriverState *bs, int64_t offset, +@@ -2590,7 +2591,7 @@ static int coroutine_fn bdrv_co_do_copy_on_readv(BlockDriverState *bs, + if (drv->bdrv_co_write_zeroes && + buffer_is_zero(bounce_buffer, iov.iov_len)) { + ret = bdrv_co_do_write_zeroes(bs, cluster_sector_num, +- cluster_nb_sectors); ++ cluster_nb_sectors, 0); + } else { + /* This does not change the data on the disk, it is not necessary + * to flush even in cache=writethrough mode. +@@ -2724,7 +2725,7 @@ int coroutine_fn bdrv_co_copy_on_readv(BlockDriverState *bs, + } + + static int coroutine_fn bdrv_co_do_write_zeroes(BlockDriverState *bs, +- int64_t sector_num, int nb_sectors) ++ int64_t sector_num, int nb_sectors, BdrvRequestFlags flags) + { + BlockDriver *drv = bs->drv; + QEMUIOVector qiov; +@@ -2736,7 +2737,7 @@ static int coroutine_fn bdrv_co_do_write_zeroes(BlockDriverState *bs, + + /* First try the efficient write zeroes operation */ + if (drv->bdrv_co_write_zeroes) { +- ret = drv->bdrv_co_write_zeroes(bs, sector_num, nb_sectors); ++ ret = drv->bdrv_co_write_zeroes(bs, sector_num, nb_sectors, flags); + if (ret != -ENOTSUP) { + return ret; + } +@@ -2787,7 +2788,7 @@ static int coroutine_fn bdrv_co_do_writev(BlockDriverState *bs, + tracked_request_begin(&req, bs, sector_num, nb_sectors, true); + + if (flags & BDRV_REQ_ZERO_WRITE) { +- ret = bdrv_co_do_write_zeroes(bs, sector_num, nb_sectors); ++ ret = bdrv_co_do_write_zeroes(bs, sector_num, nb_sectors, flags); + } else { + ret = drv->bdrv_co_writev(bs, sector_num, nb_sectors, qiov); + } +@@ -2821,12 +2822,13 @@ int coroutine_fn bdrv_co_writev(BlockDriverState *bs, int64_t sector_num, + } + + int coroutine_fn bdrv_co_write_zeroes(BlockDriverState *bs, +- int64_t sector_num, int nb_sectors) ++ int64_t sector_num, int nb_sectors, ++ BdrvRequestFlags flags) + { + trace_bdrv_co_write_zeroes(bs, sector_num, nb_sectors); + + return bdrv_co_do_writev(bs, sector_num, nb_sectors, NULL, +- BDRV_REQ_ZERO_WRITE); ++ BDRV_REQ_ZERO_WRITE | flags); + } + + /** +diff --git a/block/qcow2.c b/block/qcow2.c +index 8de8892..c109646 100644 +--- a/block/qcow2.c ++++ b/block/qcow2.c +@@ -1685,7 +1685,7 @@ static int qcow2_make_empty(BlockDriverState *bs) + } + + static coroutine_fn int qcow2_co_write_zeroes(BlockDriverState *bs, +- int64_t sector_num, int nb_sectors) ++ int64_t sector_num, int nb_sectors, BdrvRequestFlags flags) + { + int ret; + BDRVQcowState *s = bs->opaque; +diff --git a/block/qed.c b/block/qed.c +index 084dc0a..e163372 100644 +--- a/block/qed.c ++++ b/block/qed.c +@@ -1397,7 +1397,8 @@ static void coroutine_fn qed_co_write_zeroes_cb(void *opaque, int ret) + + static int coroutine_fn bdrv_qed_co_write_zeroes(BlockDriverState *bs, + int64_t sector_num, +- int nb_sectors) ++ int nb_sectors, ++ BdrvRequestFlags flags) + { + BlockDriverAIOCB *blockacb; + BDRVQEDState *s = bs->opaque; +diff --git a/block/raw.c b/block/raw.c +index e1ed8cc..67d6445 100644 +--- a/block/raw.c ++++ b/block/raw.c +@@ -47,9 +47,10 @@ static int64_t coroutine_fn raw_co_get_block_status(BlockDriverState *bs, + + static int coroutine_fn raw_co_write_zeroes(BlockDriverState *bs, + int64_t sector_num, +- int nb_sectors) ++ int nb_sectors, ++ BdrvRequestFlags flags) + { +- return bdrv_co_write_zeroes(bs->file, sector_num, nb_sectors); ++ return bdrv_co_write_zeroes(bs->file, sector_num, nb_sectors, flags); + } + + static int64_t raw_getlength(BlockDriverState *bs) +diff --git a/block/vmdk.c b/block/vmdk.c +index 7ec6427..6d676e4 100644 +--- a/block/vmdk.c ++++ b/block/vmdk.c +@@ -1426,7 +1426,8 @@ static coroutine_fn int vmdk_co_write(BlockDriverState *bs, int64_t sector_num, + + static int coroutine_fn vmdk_co_write_zeroes(BlockDriverState *bs, + int64_t sector_num, +- int nb_sectors) ++ int nb_sectors, ++ BdrvRequestFlags flags) + { + int ret; + BDRVVmdkState *s = bs->opaque; +diff --git a/include/block/block.h b/include/block/block.h +index ce6e897..2d78a84 100644 +--- a/include/block/block.h ++++ b/include/block/block.h +@@ -194,7 +194,7 @@ int bdrv_read_unthrottled(BlockDriverState *bs, int64_t sector_num, + int bdrv_write(BlockDriverState *bs, int64_t sector_num, + const uint8_t *buf, int nb_sectors); + int bdrv_write_zeroes(BlockDriverState *bs, int64_t sector_num, +- int nb_sectors); ++ int nb_sectors, BdrvRequestFlags flags); + int bdrv_writev(BlockDriverState *bs, int64_t sector_num, QEMUIOVector *qiov); + int bdrv_pread(BlockDriverState *bs, int64_t offset, + void *buf, int count); +@@ -216,7 +216,7 @@ int coroutine_fn bdrv_co_writev(BlockDriverState *bs, int64_t sector_num, + * because it may allocate memory for the entire region. + */ + int coroutine_fn bdrv_co_write_zeroes(BlockDriverState *bs, int64_t sector_num, +- int nb_sectors); ++ int nb_sectors, BdrvRequestFlags flags); + BlockDriverState *bdrv_find_backing_image(BlockDriverState *bs, + const char *backing_file); + int bdrv_get_backing_file_depth(BlockDriverState *bs); +diff --git a/include/block/block_int.h b/include/block/block_int.h +index 8223f5b..236c0c2 100644 +--- a/include/block/block_int.h ++++ b/include/block/block_int.h +@@ -125,7 +125,7 @@ struct BlockDriver { + * instead. + */ + int coroutine_fn (*bdrv_co_write_zeroes)(BlockDriverState *bs, +- int64_t sector_num, int nb_sectors); ++ int64_t sector_num, int nb_sectors, BdrvRequestFlags flags); + int coroutine_fn (*bdrv_co_discard)(BlockDriverState *bs, + int64_t sector_num, int nb_sectors); + int64_t coroutine_fn (*bdrv_co_get_block_status)(BlockDriverState *bs, +diff --git a/qemu-io.c b/qemu-io.c +index df21022..393c2c8 100644 +--- a/qemu-io.c ++++ b/qemu-io.c +@@ -234,7 +234,7 @@ static void coroutine_fn co_write_zeroes_entry(void *opaque) + CoWriteZeroes *data = opaque; + + data->ret = bdrv_co_write_zeroes(bs, data->offset / BDRV_SECTOR_SIZE, +- data->count / BDRV_SECTOR_SIZE); ++ data->count / BDRV_SECTOR_SIZE, 0); + data->done = true; + if (data->ret < 0) { + *data->total = data->ret; +-- +1.7.11.7 + diff --git a/SOURCES/kvm-block-add-logical-block-provisioning-info-to-BlockDr.patch.patch.patch b/SOURCES/kvm-block-add-logical-block-provisioning-info-to-BlockDr.patch.patch.patch new file mode 100644 index 0000000..f806041 --- /dev/null +++ b/SOURCES/kvm-block-add-logical-block-provisioning-info-to-BlockDr.patch.patch.patch @@ -0,0 +1,63 @@ +From 1eae92fe23ff0e5ba28374220417a44920192ee4 Mon Sep 17 00:00:00 2001 +Message-Id: <1eae92fe23ff0e5ba28374220417a44920192ee4.1389014116.git.minovotn@redhat.com> +In-Reply-To: +References: +From: Paolo Bonzini +Date: Mon, 9 Dec 2013 14:08:57 +0100 +Subject: [PATCH 09/50] block: add logical block provisioning info to + BlockDriverInfo + +RH-Author: Paolo Bonzini +Message-id: <1386598178-11845-12-git-send-email-pbonzini@redhat.com> +Patchwork-id: 56051 +O-Subject: [RHEL 7.0 qemu-kvm PATCH 11/52] block: add logical block provisioning info to BlockDriverInfo +Bugzilla: 1007815 +RH-Acked-by: Jeffrey Cody +RH-Acked-by: Fam Zheng +RH-Acked-by: Stefan Hajnoczi + +From: Peter Lieven + +Reviewed-by: Eric Blake +Signed-off-by: Peter Lieven +Signed-off-by: Stefan Hajnoczi +(cherry picked from commit e1a5c4bed44bc23f69f53883c657e31e150cab30) +--- + include/block/block.h | 16 ++++++++++++++++ + 1 file changed, 16 insertions(+) + +Signed-off-by: Michal Novotny +--- + include/block/block.h | 16 ++++++++++++++++ + 1 file changed, 16 insertions(+) + +diff --git a/include/block/block.h b/include/block/block.h +index 10abc00..ab3044e 100644 +--- a/include/block/block.h ++++ b/include/block/block.h +@@ -18,6 +18,22 @@ typedef struct BlockDriverInfo { + /* offset at which the VM state can be saved (0 if not possible) */ + int64_t vm_state_offset; + bool is_dirty; ++ /* ++ * True if unallocated blocks read back as zeroes. This is equivalent ++ * to the the LBPRZ flag in the SCSI logical block provisioning page. ++ */ ++ bool unallocated_blocks_are_zero; ++ /* ++ * True if the driver can optimize writing zeroes by unmapping ++ * sectors. This is equivalent to the BLKDISCARDZEROES ioctl in Linux ++ * with the difference that in qemu a discard is allowed to silently ++ * fail. Therefore we have to use bdrv_write_zeroes with the ++ * BDRV_REQ_MAY_UNMAP flag for an optimized zero write with unmapping. ++ * After this call the driver has to guarantee that the contents read ++ * back as zero. It is additionally required that the block device is ++ * opened with BDRV_O_UNMAP flag for this to work. ++ */ ++ bool can_write_zeroes_with_unmap; + } BlockDriverInfo; + + typedef struct BlockFragInfo { +-- +1.7.11.7 + diff --git a/SOURCES/kvm-block-add-opt_transfer_length-to-BlockLimits.patch.patch b/SOURCES/kvm-block-add-opt_transfer_length-to-BlockLimits.patch.patch new file mode 100644 index 0000000..9f3f4cf --- /dev/null +++ b/SOURCES/kvm-block-add-opt_transfer_length-to-BlockLimits.patch.patch @@ -0,0 +1,49 @@ +From e8ab7aeb0b874fa5f2dfecb9826154d3ab0e35ee Mon Sep 17 00:00:00 2001 +Message-Id: +In-Reply-To: +References: +From: Paolo Bonzini +Date: Mon, 9 Dec 2013 14:09:34 +0100 +Subject: [PATCH 46/50] block: add opt_transfer_length to BlockLimits + +RH-Author: Paolo Bonzini +Message-id: <1386598178-11845-49-git-send-email-pbonzini@redhat.com> +Patchwork-id: 56085 +O-Subject: [RHEL 7.0 qemu-kvm PATCH 48/52] block: add opt_transfer_length to BlockLimits +Bugzilla: 1039557 +RH-Acked-by: Jeffrey Cody +RH-Acked-by: Fam Zheng +RH-Acked-by: Stefan Hajnoczi + +From: Peter Lieven + +Reviewed-by: Paolo Bonzini +Signed-off-by: Peter Lieven +Signed-off-by: Stefan Hajnoczi +(cherry picked from commit 7337acaf219fc988e7ba91780b11770ff95169b4) +--- + include/block/block_int.h | 3 +++ + 1 file changed, 3 insertions(+) + +Signed-off-by: Michal Novotny +--- + include/block/block_int.h | 3 +++ + 1 file changed, 3 insertions(+) + +diff --git a/include/block/block_int.h b/include/block/block_int.h +index ab98c07..71c8b53 100644 +--- a/include/block/block_int.h ++++ b/include/block/block_int.h +@@ -231,6 +231,9 @@ typedef struct BlockLimits { + + /* optimal alignment for write zeroes requests in sectors */ + int64_t write_zeroes_alignment; ++ ++ /* optimal transfer length in sectors */ ++ int opt_transfer_length; + } BlockLimits; + + /* +-- +1.7.11.7 + diff --git a/SOURCES/kvm-block-add-wrappers-for-logical-block-provisioning-in.patch.patch.patch b/SOURCES/kvm-block-add-wrappers-for-logical-block-provisioning-in.patch.patch.patch new file mode 100644 index 0000000..65848d8 --- /dev/null +++ b/SOURCES/kvm-block-add-wrappers-for-logical-block-provisioning-in.patch.patch.patch @@ -0,0 +1,97 @@ +From 53d8964bc0e80e99d5ccb15100ecb93a7b5f74b0 Mon Sep 17 00:00:00 2001 +Message-Id: <53d8964bc0e80e99d5ccb15100ecb93a7b5f74b0.1389014116.git.minovotn@redhat.com> +In-Reply-To: +References: +From: Paolo Bonzini +Date: Mon, 9 Dec 2013 14:08:58 +0100 +Subject: [PATCH 10/50] block: add wrappers for logical block provisioning + information + +RH-Author: Paolo Bonzini +Message-id: <1386598178-11845-13-git-send-email-pbonzini@redhat.com> +Patchwork-id: 56050 +O-Subject: [RHEL 7.0 qemu-kvm PATCH 12/52] block: add wrappers for logical block provisioning information +Bugzilla: 1007815 +RH-Acked-by: Jeffrey Cody +RH-Acked-by: Fam Zheng +RH-Acked-by: Stefan Hajnoczi + +From: Peter Lieven + +This adds 2 wrappers to read the unallocated_blocks_are_zero and +can_write_zeroes_with_unmap info from the BDI. The wrappers are +required to check for the existence of a backing_hd and +if the devices are opened with the correct flags. + +Reviewed-by: Eric Blake +Signed-off-by: Peter Lieven +Signed-off-by: Stefan Hajnoczi +(cherry picked from commit 4ce786914b745a144a9eda1ea33f3ff98328c527) +--- + block.c | 30 ++++++++++++++++++++++++++++++ + include/block/block.h | 2 ++ + 2 files changed, 32 insertions(+) + +Signed-off-by: Michal Novotny +--- + block.c | 30 ++++++++++++++++++++++++++++++ + include/block/block.h | 2 ++ + 2 files changed, 32 insertions(+) + +diff --git a/block.c b/block.c +index 77167f0..2fae459 100644 +--- a/block.c ++++ b/block.c +@@ -3121,6 +3121,36 @@ int bdrv_has_zero_init(BlockDriverState *bs) + return 0; + } + ++bool bdrv_unallocated_blocks_are_zero(BlockDriverState *bs) ++{ ++ BlockDriverInfo bdi; ++ ++ if (bs->backing_hd) { ++ return false; ++ } ++ ++ if (bdrv_get_info(bs, &bdi) == 0) { ++ return bdi.unallocated_blocks_are_zero; ++ } ++ ++ return false; ++} ++ ++bool bdrv_can_write_zeroes_with_unmap(BlockDriverState *bs) ++{ ++ BlockDriverInfo bdi; ++ ++ if (bs->backing_hd || !(bs->open_flags & BDRV_O_UNMAP)) { ++ return false; ++ } ++ ++ if (bdrv_get_info(bs, &bdi) == 0) { ++ return bdi.can_write_zeroes_with_unmap; ++ } ++ ++ return false; ++} ++ + typedef struct BdrvCoGetBlockStatusData { + BlockDriverState *bs; + BlockDriverState *base; +diff --git a/include/block/block.h b/include/block/block.h +index ab3044e..1958d98 100644 +--- a/include/block/block.h ++++ b/include/block/block.h +@@ -330,6 +330,8 @@ int bdrv_discard(BlockDriverState *bs, int64_t sector_num, int nb_sectors); + int bdrv_co_discard(BlockDriverState *bs, int64_t sector_num, int nb_sectors); + int bdrv_has_zero_init_1(BlockDriverState *bs); + int bdrv_has_zero_init(BlockDriverState *bs); ++bool bdrv_unallocated_blocks_are_zero(BlockDriverState *bs); ++bool bdrv_can_write_zeroes_with_unmap(BlockDriverState *bs); + int64_t bdrv_get_block_status(BlockDriverState *bs, int64_t sector_num, + int nb_sectors, int *pnum); + int bdrv_is_allocated(BlockDriverState *bs, int64_t sector_num, int nb_sectors, +-- +1.7.11.7 + diff --git a/SOURCES/kvm-block-bdrv_aligned_pwritev-Assert-overlap-range.patch b/SOURCES/kvm-block-bdrv_aligned_pwritev-Assert-overlap-range.patch new file mode 100644 index 0000000..a0b3daf --- /dev/null +++ b/SOURCES/kvm-block-bdrv_aligned_pwritev-Assert-overlap-range.patch @@ -0,0 +1,46 @@ +From 34593324ec77e3f92e27645540ed935767283dc5 Mon Sep 17 00:00:00 2001 +From: Kevin Wolf +Date: Fri, 7 Feb 2014 15:35:56 +0100 +Subject: [PATCH 36/37] block: bdrv_aligned_pwritev: Assert overlap range + +Message-id: <1392117622-28812-36-git-send-email-kwolf@redhat.com> +Patchwork-id: 57200 +O-Subject: [RHEL-7.0 qemu-kvm PATCH v2 36/37] block: bdrv_aligned_pwritev: Assert overlap range +Bugzilla: 748906 +RH-Acked-by: Laszlo Ersek +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Max Reitz + +This adds assertions that the request that we actually end up passing to +the block driver (which includes RMW data and has therefore potentially +been rounded to alignment boundaries) is fully covered by the +overlap_{offset,size} fields of the associated BdrvTrackedRequest. + +Suggested-by: Laszlo Ersek +Signed-off-by: Kevin Wolf +Reviewed-by: Eric Blake +Reviewed-by: Laszlo Ersek +Signed-off-by: Kevin Wolf +--- + block.c | 2 ++ + 1 file changed, 2 insertions(+) +--- + block.c | 2 ++ + 1 files changed, 2 insertions(+), 0 deletions(-) + +diff --git a/block.c b/block.c +index d063924..b878c8b 100644 +--- a/block.c ++++ b/block.c +@@ -2980,6 +2980,8 @@ static int coroutine_fn bdrv_aligned_pwritev(BlockDriverState *bs, + + waited = wait_serialising_requests(req); + assert(!waited || !req->serialising); ++ assert(req->overlap_offset <= offset); ++ assert(offset + bytes <= req->overlap_offset + req->overlap_bytes); + + if (flags & BDRV_REQ_ZERO_WRITE) { + BLKDBG_EVENT(bs, BLKDBG_PWRITEV_ZERO); +-- +1.7.1 + diff --git a/SOURCES/kvm-block-bs-drv-may-be-NULL-in-bdrv_debug_resume.patch b/SOURCES/kvm-block-bs-drv-may-be-NULL-in-bdrv_debug_resume.patch new file mode 100644 index 0000000..998a8b3 --- /dev/null +++ b/SOURCES/kvm-block-bs-drv-may-be-NULL-in-bdrv_debug_resume.patch @@ -0,0 +1,53 @@ +From cd67eba4f11bb3d188df01dd9c30b96c7665f8f3 Mon Sep 17 00:00:00 2001 +From: Max Reitz +Date: Mon, 17 Mar 2014 22:45:30 +0100 +Subject: [PATCH 5/6] block: bs->drv may be NULL in bdrv_debug_resume() + +RH-Author: Max Reitz +Message-id: <1395096331-12610-3-git-send-email-mreitz@redhat.com> +Patchwork-id: 58120 +O-Subject: [RHEL-7.0 qemu-kvm PATCH 2/3] block: bs->drv may be NULL in bdrv_debug_resume() +Bugzilla: 1048575 +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Kevin Wolf +RH-Acked-by: Fam Zheng + +BZ: 1048575 + +Currently, bdrv_debug_resume() requires every bs->drv in the BDS stack +to be NULL until a bs->drv with an implementation of bdrv_debug_resume() +is found. For a normal function, this would be fine, but this is a +function for debugging purposes and should therefore allow intermediate +BDS not to have a driver (i.e., be "ejected"). Otherwise, it is hard to +debug such situations. + +Signed-off-by: Max Reitz +Signed-off-by: Stefan Hajnoczi +(cherry picked from commit 938789ea92b3073ad1113b3e1bdf90d469ea4bf4) + +Signed-off-by: Max Reitz +--- + block.c | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +Signed-off-by: Miroslav Rezanina +--- + block.c | 2 +- + 1 files changed, 1 insertions(+), 1 deletions(-) + +diff --git a/block.c b/block.c +index ae55535..0321c74 100644 +--- a/block.c ++++ b/block.c +@@ -3831,7 +3831,7 @@ int bdrv_debug_breakpoint(BlockDriverState *bs, const char *event, + + int bdrv_debug_resume(BlockDriverState *bs, const char *tag) + { +- while (bs && bs->drv && !bs->drv->bdrv_debug_resume) { ++ while (bs && (!bs->drv || !bs->drv->bdrv_debug_resume)) { + bs = bs->file; + } + +-- +1.7.1 + diff --git a/SOURCES/kvm-block-change-default-of-.has_zero_init-to-0.patch.patch b/SOURCES/kvm-block-change-default-of-.has_zero_init-to-0.patch.patch new file mode 100644 index 0000000..a0b5dee --- /dev/null +++ b/SOURCES/kvm-block-change-default-of-.has_zero_init-to-0.patch.patch @@ -0,0 +1,295 @@ +From c8cc35838d42aa286242772d97e3a9be7bb786ba Mon Sep 17 00:00:00 2001 +Message-Id: +From: Paolo Bonzini +Date: Mon, 9 Dec 2013 14:08:49 +0100 +Subject: [PATCH 01/50] block: change default of .has_zero_init to 0 + +RH-Author: Paolo Bonzini +Message-id: <1386598178-11845-4-git-send-email-pbonzini@redhat.com> +Patchwork-id: 56040 +O-Subject: [RHEL 7.0 qemu-kvm PATCH 03/52] block: change default of .has_zero_init to 0 +Bugzilla: 1007815 +RH-Acked-by: Jeffrey Cody +RH-Acked-by: Fam Zheng +RH-Acked-by: Stefan Hajnoczi + +From: Peter Lieven + +.has_zero_init defaults to 1 for all formats and protocols. + +this is a dangerous default since this means that all +new added drivers need to manually overwrite it to 0 if +they do not ensure that a device is zero initialized +after bdrv_create(). + +if a driver needs to explicitly set this value to +1 its easier to verify the correctness in the review process. + +during review of the existing drivers it turned out +that ssh and gluster had a wrong default of 1. +both protocols support host_devices as backend +which are not by default zero initialized. this +wrong assumption will lead to possible corruption +if qemu-img convert is used to write to such a backend. + +vpc and vmdk also defaulted to 1 altough they support +fixed respectively flat extends. this has to be addresses +in separate patches. both formats as well as the mentioned +ssh and gluster are turned to the default of 0 with this +patch for safety. + +a similar problem with the wrong default existed for +iscsi most likely because the driver developer did +oversee the default value of 1. + +Signed-off-by: Peter Lieven +Signed-off-by: Kevin Wolf +(cherry picked from commit 3ac216270a62418519c08e88c17005a8f1539cf2) + +Conflicts: [due to get_block_status going in RHEL7 before this patch] + block/qcow2.c + block/qed.c + block/raw-posix.c + block/vdi.c +--- + block.c | 8 +++++++- + block/cow.c | 1 + + block/qcow.c | 1 + + block/qcow2.c | 1 + + block/qed.c | 1 + + block/raw-posix.c | 10 +--------- + block/raw-win32.c | 7 +------ + block/rbd.c | 1 + + block/sheepdog.c | 1 + + block/vdi.c | 1 + + include/block/block.h | 1 + + 11 files changed, 17 insertions(+), 16 deletions(-) + +Signed-off-by: Michal Novotny +--- + block.c | 8 +++++++- + block/cow.c | 1 + + block/qcow.c | 1 + + block/qcow2.c | 1 + + block/qed.c | 1 + + block/raw-posix.c | 10 +--------- + block/raw-win32.c | 7 +------ + block/rbd.c | 1 + + block/sheepdog.c | 1 + + block/vdi.c | 1 + + include/block/block.h | 1 + + 11 files changed, 17 insertions(+), 16 deletions(-) + +diff --git a/block.c b/block.c +index 8ef07bb..02994ec 100644 +--- a/block.c ++++ b/block.c +@@ -3098,6 +3098,11 @@ int bdrv_flush_all(void) + return result; + } + ++int bdrv_has_zero_init_1(BlockDriverState *bs) ++{ ++ return 1; ++} ++ + int bdrv_has_zero_init(BlockDriverState *bs) + { + assert(bs->drv); +@@ -3111,7 +3116,8 @@ int bdrv_has_zero_init(BlockDriverState *bs) + return bs->drv->bdrv_has_zero_init(bs); + } + +- return 1; ++ /* safe default */ ++ return 0; + } + + typedef struct BdrvCoGetBlockStatusData { +diff --git a/block/cow.c b/block/cow.c +index cd78129..cb9a3b0 100644 +--- a/block/cow.c ++++ b/block/cow.c +@@ -386,6 +386,7 @@ static BlockDriver bdrv_cow = { + .bdrv_open = cow_open, + .bdrv_close = cow_close, + .bdrv_create = cow_create, ++ .bdrv_has_zero_init = bdrv_has_zero_init_1, + + .bdrv_read = cow_co_read, + .bdrv_write = cow_co_write, +diff --git a/block/qcow.c b/block/qcow.c +index 6d029cc..6bc2358 100644 +--- a/block/qcow.c ++++ b/block/qcow.c +@@ -906,6 +906,7 @@ static BlockDriver bdrv_qcow = { + .bdrv_close = qcow_close, + .bdrv_reopen_prepare = qcow_reopen_prepare, + .bdrv_create = qcow_create, ++ .bdrv_has_zero_init = bdrv_has_zero_init_1, + + .bdrv_co_readv = qcow_co_readv, + .bdrv_co_writev = qcow_co_writev, +diff --git a/block/qcow2.c b/block/qcow2.c +index 850d1c2..8de8892 100644 +--- a/block/qcow2.c ++++ b/block/qcow2.c +@@ -2034,6 +2034,7 @@ static BlockDriver bdrv_qcow2 = { + .bdrv_close = qcow2_close, + .bdrv_reopen_prepare = qcow2_reopen_prepare, + .bdrv_create = qcow2_create, ++ .bdrv_has_zero_init = bdrv_has_zero_init_1, + .bdrv_co_get_block_status = qcow2_co_get_block_status, + .bdrv_set_key = qcow2_set_key, + .bdrv_make_empty = qcow2_make_empty, +diff --git a/block/qed.c b/block/qed.c +index 7b13bb5..084dc0a 100644 +--- a/block/qed.c ++++ b/block/qed.c +@@ -1603,6 +1603,7 @@ static BlockDriver bdrv_qed = { + .bdrv_close = bdrv_qed_close, + .bdrv_reopen_prepare = bdrv_qed_reopen_prepare, + .bdrv_create = bdrv_qed_create, ++ .bdrv_has_zero_init = bdrv_has_zero_init_1, + .bdrv_co_get_block_status = bdrv_qed_co_get_block_status, + .bdrv_make_empty = bdrv_qed_make_empty, + .bdrv_aio_readv = bdrv_qed_aio_readv, +diff --git a/block/raw-posix.c b/block/raw-posix.c +index eae1b40..c2b3dfd 100644 +--- a/block/raw-posix.c ++++ b/block/raw-posix.c +@@ -1220,6 +1220,7 @@ static BlockDriver bdrv_file = { + .bdrv_reopen_abort = raw_reopen_abort, + .bdrv_close = raw_close, + .bdrv_create = raw_create, ++ .bdrv_has_zero_init = bdrv_has_zero_init_1, + .bdrv_co_get_block_status = raw_co_get_block_status, + + .bdrv_aio_readv = raw_aio_readv, +@@ -1563,11 +1564,6 @@ static int hdev_create(const char *filename, QEMUOptionParameter *options, + return ret; + } + +-static int hdev_has_zero_init(BlockDriverState *bs) +-{ +- return 0; +-} +- + static BlockDriver bdrv_host_device = { + .format_name = "host_device", + .protocol_name = "host_device", +@@ -1580,7 +1576,6 @@ static BlockDriver bdrv_host_device = { + .bdrv_reopen_abort = raw_reopen_abort, + .bdrv_create = hdev_create, + .create_options = raw_create_options, +- .bdrv_has_zero_init = hdev_has_zero_init, + + .bdrv_aio_readv = raw_aio_readv, + .bdrv_aio_writev = raw_aio_writev, +@@ -1711,7 +1706,6 @@ static BlockDriver bdrv_host_floppy = { + .bdrv_reopen_abort = raw_reopen_abort, + .bdrv_create = hdev_create, + .create_options = raw_create_options, +- .bdrv_has_zero_init = hdev_has_zero_init, + + .bdrv_aio_readv = raw_aio_readv, + .bdrv_aio_writev = raw_aio_writev, +@@ -1821,7 +1815,6 @@ static BlockDriver bdrv_host_cdrom = { + .bdrv_reopen_abort = raw_reopen_abort, + .bdrv_create = hdev_create, + .create_options = raw_create_options, +- .bdrv_has_zero_init = hdev_has_zero_init, + + .bdrv_aio_readv = raw_aio_readv, + .bdrv_aio_writev = raw_aio_writev, +@@ -1949,7 +1942,6 @@ static BlockDriver bdrv_host_cdrom = { + .bdrv_reopen_abort = raw_reopen_abort, + .bdrv_create = hdev_create, + .create_options = raw_create_options, +- .bdrv_has_zero_init = hdev_has_zero_init, + + .bdrv_aio_readv = raw_aio_readv, + .bdrv_aio_writev = raw_aio_writev, +diff --git a/block/raw-win32.c b/block/raw-win32.c +index 584790f..6ac3797 100644 +--- a/block/raw-win32.c ++++ b/block/raw-win32.c +@@ -465,6 +465,7 @@ static BlockDriver bdrv_file = { + .bdrv_file_open = raw_open, + .bdrv_close = raw_close, + .bdrv_create = raw_create, ++ .bdrv_has_zero_init = bdrv_has_zero_init_1, + + .bdrv_aio_readv = raw_aio_readv, + .bdrv_aio_writev = raw_aio_writev, +@@ -600,11 +601,6 @@ done: + return ret; + } + +-static int hdev_has_zero_init(BlockDriverState *bs) +-{ +- return 0; +-} +- + static BlockDriver bdrv_host_device = { + .format_name = "host_device", + .protocol_name = "host_device", +@@ -612,7 +608,6 @@ static BlockDriver bdrv_host_device = { + .bdrv_probe_device = hdev_probe_device, + .bdrv_file_open = hdev_open, + .bdrv_close = raw_close, +- .bdrv_has_zero_init = hdev_has_zero_init, + + .bdrv_aio_readv = raw_aio_readv, + .bdrv_aio_writev = raw_aio_writev, +diff --git a/block/rbd.c b/block/rbd.c +index 169d3cf..b870401 100644 +--- a/block/rbd.c ++++ b/block/rbd.c +@@ -974,6 +974,7 @@ static BlockDriver bdrv_rbd = { + .bdrv_file_open = qemu_rbd_open, + .bdrv_close = qemu_rbd_close, + .bdrv_create = qemu_rbd_create, ++ .bdrv_has_zero_init = bdrv_has_zero_init_1, + .bdrv_get_info = qemu_rbd_getinfo, + .create_options = qemu_rbd_create_options, + .bdrv_getlength = qemu_rbd_getlength, +diff --git a/block/sheepdog.c b/block/sheepdog.c +index e7c4448..09203ad 100644 +--- a/block/sheepdog.c ++++ b/block/sheepdog.c +@@ -2411,6 +2411,7 @@ static BlockDriver bdrv_sheepdog_unix = { + .bdrv_file_open = sd_open, + .bdrv_close = sd_close, + .bdrv_create = sd_create, ++ .bdrv_has_zero_init = bdrv_has_zero_init_1, + .bdrv_getlength = sd_getlength, + .bdrv_truncate = sd_truncate, + +diff --git a/block/vdi.c b/block/vdi.c +index 84860fe..dcbc27c 100644 +--- a/block/vdi.c ++++ b/block/vdi.c +@@ -792,6 +792,7 @@ static BlockDriver bdrv_vdi = { + .bdrv_close = vdi_close, + .bdrv_reopen_prepare = vdi_reopen_prepare, + .bdrv_create = vdi_create, ++ .bdrv_has_zero_init = bdrv_has_zero_init_1, + .bdrv_co_get_block_status = vdi_co_get_block_status, + .bdrv_make_empty = vdi_make_empty, + +diff --git a/include/block/block.h b/include/block/block.h +index 656570e..15ffbd2 100644 +--- a/include/block/block.h ++++ b/include/block/block.h +@@ -300,6 +300,7 @@ void bdrv_drain_all(void); + + int bdrv_discard(BlockDriverState *bs, int64_t sector_num, int nb_sectors); + int bdrv_co_discard(BlockDriverState *bs, int64_t sector_num, int nb_sectors); ++int bdrv_has_zero_init_1(BlockDriverState *bs); + int bdrv_has_zero_init(BlockDriverState *bs); + int64_t bdrv_get_block_status(BlockDriverState *bs, int64_t sector_num, + int nb_sectors, int *pnum); +-- +1.7.11.7 + diff --git a/SOURCES/kvm-block-cloop-prevent-offsets_size-integer-overflow-CV.patch b/SOURCES/kvm-block-cloop-prevent-offsets_size-integer-overflow-CV.patch new file mode 100644 index 0000000..0afde63 --- /dev/null +++ b/SOURCES/kvm-block-cloop-prevent-offsets_size-integer-overflow-CV.patch @@ -0,0 +1,112 @@ +From f0b6df5c7146425c80ab72928aa8848c8f1a93a9 Mon Sep 17 00:00:00 2001 +From: Stefan Hajnoczi +Date: Tue, 25 Mar 2014 14:23:12 +0100 +Subject: [PATCH 05/49] block/cloop: prevent offsets_size integer overflow (CVE-2014-0143) + +RH-Author: Kevin Wolf +Message-id: <1395753835-7591-6-git-send-email-kwolf@redhat.com> +Patchwork-id: n/a +O-Subject: [virt-devel] [EMBARGOED RHEL-7.0 qemu-kvm PATCH 05/48] block/cloop: prevent offsets_size integer overflow (CVE-2014-0143) +Bugzilla: 1079320 +RH-Acked-by: Jeff Cody +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Paolo Bonzini + +From: Stefan Hajnoczi + +Bugzilla: https://bugzilla.redhat.com/show_bug.cgi?id=1079320 +Upstream status: Embargoed + +The following integer overflow in offsets_size can lead to out-of-bounds +memory stores when n_blocks has a huge value: + +uint32_t n_blocks, offsets_size; +[...] +ret = bdrv_pread(bs->file, 128 + 4, &s->n_blocks, 4); +[...] +s->n_blocks = be32_to_cpu(s->n_blocks); + +/bin /boot /cgroup /dev /etc /home /lib /lib64 /lost+found /media /misc /mnt /net /opt /proc /root /sbin /selinux /srv /sys /tmp /usr /var read offsets audio/ backends/ block/ bsd-user/ default-configs/ disas/ docs/ dtc/ fpu/ fsdev/ gdb-xml/ hw/ include/ ldscripts/ libcacard/ linux-headers/ linux-user/ net/ pc-bios/ pixman/ po/ qapi/ qga/ QMP/ qobject/ qom/ redhat/ roms/ scripts/ slirp/ stubs/ sysconfigs/ target-alpha/ target-arm/ target-cris/ target-i386/ target-lm32/ target-m68k/ target-microblaze/ target-mips/ target-moxie/ target-openrisc/ target-ppc/ target-s390x/ target-sh4/ target-sparc/ target-unicore32/ target-xtensa/ tcg/ tests/ trace/ ui/ util/ +offsets_size = s->n_blocks 0001-usb-host-move-legacy-cmd-line-bits.patch 0002-usb-host-remove-usb_host_device_close.patch 0003-use-libusb-for-usb-host.patch 0004-libusb-spec-file-windup.patch aio-posix.c aio-win32.c arch_init.c async.c audio backends balloon.c block block.c blockdev.c blockdev-nbd.c blockjob.c block-migration.c bsd-user bt-host.c bt-vhci.c Changelog cmd.c cmd.h CODING_STYLE configure COPYING COPYING.LIB coroutine-gthread.c coroutine-sigaltstack.c coroutine-ucontext.c coroutine-win32.c cpu-exec.c cpus.c cputlb.c default-configs device-hotplug.c device_tree.c disas disas.c dma-helpers.c docs dtc dump.c exec.c fpu fsdev gdbstub.c gdb-xml HACKING hmp.c hmp-commands.hx hmp.h hw include iohandler.c ioport.c kvm-all.c kvm-stub.c kvmvapic-add-ioport-read-accessor.patch ldscripts libcacard LICENSE linux-headers linux-user main-loop.c MAINTAINERS Makefile Makefile.objs Makefile.target memory.c memory_mapping.c memory_mapping-stub.c migration.c migration-exec.c migration-fd.c migration-rdma.c migration-tcp.c migration-unix.c monitor.c nbd.c net os-posix.c os-win32.c page_cache.c pc-bios pixman po qapi qapi-schema.json qdev-monitor.c qdict-test-data.txt qemu-bridge-helper.c qemu-char.c qemu-coroutine.c qemu-coroutine-io.c qemu-coroutine-lock.c qemu-coroutine-sleep.c qemu-doc.texi qemu-img.c qemu-img-cmds.hx qemu-img.texi qemu-io.c qemu-log.c qemu-nbd.c qemu-nbd.texi qemu-options.h qemu-options.hx qemu-options-wrapper.h qemu.sasl qemu-seccomp.c qemu-tech.texi qemu-timer.c qga QMP qmp.c qmp-commands.hx qobject qom qtest.c readline.c README redhat roms rules.mak savevm.c scripts slirp spice-qemu-char.c stubs sysconfigs target-alpha target-arm target-cris target-i386 target-lm32 target-m68k target-microblaze target-mips target-moxie target-openrisc target-ppc target-s390x target-sh4 target-sparc target-unicore32 target-xtensa tcg tcg-runtime.c tci.c tests thread-pool.c thunk.c tpm.c trace trace-events translate-all.c translate-all.h ui user-exec.c util VERSION version.rc vl.c vl.c.orig xbzrle.c xen-all.c xen-mapcache.c xen-stub.c sizeof(uint64_t); +s->offsets = g_malloc(offsets_size); + +[...] + +for(i=0;in_blocks;i++) { +s->offsets[i] = be64_to_cpu(s->offsets[i]); + +offsets_size can be smaller than n_blocks due to integer overflow. +Therefore s->offsets[] is too small when the for loop byteswaps offsets. + +This patch refuses to open files if offsets_size would overflow. + +Note that changing the type of offsets_size is not a fix since 32-bit +hosts still only have 32-bit size_t. + +Signed-off-by: Stefan Hajnoczi +Signed-off-by: Kevin Wolf +--- + block/cloop.c | 7 +++++++ + tests/qemu-iotests/075 | 7 +++++++ + tests/qemu-iotests/075.out | 4 ++++ + 3 files changed, 18 insertions(+), 0 deletions(-) + +diff --git a/block/cloop.c b/block/cloop.c +index f021663..563e916 100644 +--- a/block/cloop.c ++++ b/block/cloop.c +@@ -99,6 +99,13 @@ static int cloop_open(BlockDriverState *bs, QDict *options, int flags, + s->n_blocks = be32_to_cpu(s->n_blocks); + + /* read offsets */ ++ if (s->n_blocks > UINT32_MAX / sizeof(uint64_t)) { ++ /* Prevent integer overflow */ ++ error_setg(errp, "n_blocks %u must be %zu or less", ++ s->n_blocks, ++ UINT32_MAX / sizeof(uint64_t)); ++ return -EINVAL; ++ } + offsets_size = s->n_blocks * sizeof(uint64_t); + s->offsets = g_malloc(offsets_size); + +diff --git a/tests/qemu-iotests/075 b/tests/qemu-iotests/075 +index 8f54a99..9ce6b1f 100755 +--- a/tests/qemu-iotests/075 ++++ b/tests/qemu-iotests/075 +@@ -43,6 +43,7 @@ _supported_proto generic + _supported_os Linux + + block_size_offset=128 ++n_blocks_offset=132 + + echo + echo "== check that the first sector can be read ==" +@@ -67,6 +68,12 @@ _use_sample_img simple-pattern.cloop.bz2 + poke_file "$TEST_IMG" "$block_size_offset" "\xff\xff\xfe\x00" + $QEMU_IO -c "read 0 512" $TEST_IMG 2>&1 | _filter_qemu_io | _filter_testdir + ++echo ++echo "== offsets_size overflow ===" ++_use_sample_img simple-pattern.cloop.bz2 ++poke_file "$TEST_IMG" "$n_blocks_offset" "\xff\xff\xff\xff" ++$QEMU_IO -c "read 0 512" $TEST_IMG 2>&1 | _filter_qemu_io | _filter_testdir ++ + # success, all done + echo "*** done" + rm -f $seq.full +diff --git a/tests/qemu-iotests/075.out b/tests/qemu-iotests/075.out +index d362c95..a771789 100644 +--- a/tests/qemu-iotests/075.out ++++ b/tests/qemu-iotests/075.out +@@ -15,4 +15,8 @@ no file open, try 'help open' + == huge block_size === + qemu-io: can't open device TEST_DIR/simple-pattern.cloop: block_size 4294966784 must be 64 MB or less + no file open, try 'help open' ++ ++== offsets_size overflow === ++qemu-io: can't open device TEST_DIR/simple-pattern.cloop: n_blocks 4294967295 must be 536870911 or less ++no file open, try 'help open' + *** done +-- +1.7.1 + diff --git a/SOURCES/kvm-block-cloop-refuse-images-with-bogus-offsets-CVE-201.patch b/SOURCES/kvm-block-cloop-refuse-images-with-bogus-offsets-CVE-201.patch new file mode 100644 index 0000000..a80222c --- /dev/null +++ b/SOURCES/kvm-block-cloop-refuse-images-with-bogus-offsets-CVE-201.patch @@ -0,0 +1,133 @@ +From cba6c4e21a8dce857af0ed08d26801ebd5d5598a Mon Sep 17 00:00:00 2001 +From: Stefan Hajnoczi +Date: Tue, 25 Mar 2014 14:23:14 +0100 +Subject: [PATCH 07/49] block/cloop: refuse images with bogus offsets (CVE-2014-0144) + +RH-Author: Kevin Wolf +Message-id: <1395753835-7591-8-git-send-email-kwolf@redhat.com> +Patchwork-id: n/a +O-Subject: [virt-devel] [EMBARGOED RHEL-7.0 qemu-kvm PATCH 07/48] block/cloop: refuse images with bogus offsets (CVE-2014-0144) +Bugzilla: 1079455 +RH-Acked-by: Jeff Cody +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Paolo Bonzini + +From: Stefan Hajnoczi + +Bugzilla: https://bugzilla.redhat.com/show_bug.cgi?id=1079455 +Upstream status: Embargoed + +The offsets[] array allows efficient seeking and tells us the maximum +compressed data size. If the offsets are bogus the maximum compressed +data size will be unrealistic. + +This could cause g_malloc() to abort and bogus offsets mean the image is +broken anyway. Therefore we should refuse such images. + +Signed-off-by: Stefan Hajnoczi +Signed-off-by: Kevin Wolf +--- + block/cloop.c | 34 +++++++++++++++++++++++++++++----- + tests/qemu-iotests/075 | 15 +++++++++++++++ + tests/qemu-iotests/075.out | 8 ++++++++ + 3 files changed, 52 insertions(+), 5 deletions(-) + +diff --git a/block/cloop.c b/block/cloop.c +index 844665e..55a804f 100644 +--- a/block/cloop.c ++++ b/block/cloop.c +@@ -124,12 +124,36 @@ static int cloop_open(BlockDriverState *bs, QDict *options, int flags, + } + + for(i=0;in_blocks;i++) { ++ uint64_t size; ++ + s->offsets[i] = be64_to_cpu(s->offsets[i]); +- if (i > 0) { +- uint32_t size = s->offsets[i] - s->offsets[i - 1]; +- if (size > max_compressed_block_size) { +- max_compressed_block_size = size; +- } ++ if (i == 0) { ++ continue; ++ } ++ ++ if (s->offsets[i] < s->offsets[i - 1]) { ++ error_setg(errp, "offsets not monotonically increasing at " ++ "index %u, image file is corrupt", i); ++ ret = -EINVAL; ++ goto fail; ++ } ++ ++ size = s->offsets[i] - s->offsets[i - 1]; ++ ++ /* Compressed blocks should be smaller than the uncompressed block size ++ * but maybe compression performed poorly so the compressed block is ++ * actually bigger. Clamp down on unrealistic values to prevent ++ * ridiculous s->compressed_block allocation. ++ */ ++ if (size > 2 * MAX_BLOCK_SIZE) { ++ error_setg(errp, "invalid compressed block size at index %u, " ++ "image file is corrupt", i); ++ ret = -EINVAL; ++ goto fail; ++ } ++ ++ if (size > max_compressed_block_size) { ++ max_compressed_block_size = size; + } + } + +diff --git a/tests/qemu-iotests/075 b/tests/qemu-iotests/075 +index 9c00fa8..d74fb33 100755 +--- a/tests/qemu-iotests/075 ++++ b/tests/qemu-iotests/075 +@@ -44,6 +44,7 @@ _supported_os Linux + + block_size_offset=128 + n_blocks_offset=132 ++offsets_offset=136 + + echo + echo "== check that the first sector can be read ==" +@@ -80,6 +81,20 @@ _use_sample_img simple-pattern.cloop.bz2 + poke_file "$TEST_IMG" "$n_blocks_offset" "\x04\x00\x00\x01" + $QEMU_IO -c "read 0 512" $TEST_IMG 2>&1 | _filter_qemu_io | _filter_testdir + ++echo ++echo "== refuse images with non-monotonically increasing offsets ==" ++_use_sample_img simple-pattern.cloop.bz2 ++poke_file "$TEST_IMG" "$offsets_offset" "\x00\x00\x00\x00\xff\xff\xff\xff" ++poke_file "$TEST_IMG" $((offsets_offset + 8)) "\x00\x00\x00\x00\xff\xfe\x00\x00" ++$QEMU_IO -c "read 0 512" $TEST_IMG 2>&1 | _filter_qemu_io | _filter_testdir ++ ++echo ++echo "== refuse images with invalid compressed block size ==" ++_use_sample_img simple-pattern.cloop.bz2 ++poke_file "$TEST_IMG" "$offsets_offset" "\x00\x00\x00\x00\x00\x00\x00\x00" ++poke_file "$TEST_IMG" $((offsets_offset + 8)) "\xff\xff\xff\xff\xff\xff\xff\xff" ++$QEMU_IO -c "read 0 512" $TEST_IMG 2>&1 | _filter_qemu_io | _filter_testdir ++ + # success, all done + echo "*** done" + rm -f $seq.full +diff --git a/tests/qemu-iotests/075.out b/tests/qemu-iotests/075.out +index 7cdaee1..911cd3b 100644 +--- a/tests/qemu-iotests/075.out ++++ b/tests/qemu-iotests/075.out +@@ -23,4 +23,12 @@ no file open, try 'help open' + == refuse images that require too many offsets === + qemu-io: can't open device TEST_DIR/simple-pattern.cloop: image requires too many offsets, try increasing block size + no file open, try 'help open' ++ ++== refuse images with non-monotonically increasing offsets == ++qemu-io: can't open device TEST_DIR/simple-pattern.cloop: offsets not monotonically increasing at index 1, image file is corrupt ++no file open, try 'help open' ++ ++== refuse images with invalid compressed block size == ++qemu-io: can't open device TEST_DIR/simple-pattern.cloop: invalid compressed block size at index 1, image file is corrupt ++no file open, try 'help open' + *** done +-- +1.7.1 + diff --git a/SOURCES/kvm-block-cloop-refuse-images-with-huge-offsets-arrays-C.patch b/SOURCES/kvm-block-cloop-refuse-images-with-huge-offsets-arrays-C.patch new file mode 100644 index 0000000..6b8a31d --- /dev/null +++ b/SOURCES/kvm-block-cloop-refuse-images-with-huge-offsets-arrays-C.patch @@ -0,0 +1,88 @@ +From 54e639827c618c74ecb47690754f0299c2e35750 Mon Sep 17 00:00:00 2001 +From: Stefan Hajnoczi +Date: Tue, 25 Mar 2014 14:23:13 +0100 +Subject: [PATCH 06/49] block/cloop: refuse images with huge offsets arrays (CVE-2014-0144) + +RH-Author: Kevin Wolf +Message-id: <1395753835-7591-7-git-send-email-kwolf@redhat.com> +Patchwork-id: n/a +O-Subject: [virt-devel] [EMBARGOED RHEL-7.0 qemu-kvm PATCH 06/48] block/cloop: refuse images with huge offsets arrays (CVE-2014-0144) +Bugzilla: 1079455 +RH-Acked-by: Jeff Cody +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Paolo Bonzini + +From: Stefan Hajnoczi + +Bugzilla: https://bugzilla.redhat.com/show_bug.cgi?id=1079455 +Upstream status: Embargoed + +Limit offsets_size to 512 MB so that: + +1. g_malloc() does not abort due to an unreasonable size argument. + +2. offsets_size does not overflow the bdrv_pread() int size argument. + +This limit imposes a maximum image size of 16 TB at 256 KB block size. + +Signed-off-by: Stefan Hajnoczi +Signed-off-by: Kevin Wolf +--- + block/cloop.c | 9 +++++++++ + tests/qemu-iotests/075 | 6 ++++++ + tests/qemu-iotests/075.out | 4 ++++ + 3 files changed, 19 insertions(+), 0 deletions(-) + +diff --git a/block/cloop.c b/block/cloop.c +index 563e916..844665e 100644 +--- a/block/cloop.c ++++ b/block/cloop.c +@@ -107,6 +107,15 @@ static int cloop_open(BlockDriverState *bs, QDict *options, int flags, + return -EINVAL; + } + offsets_size = s->n_blocks * sizeof(uint64_t); ++ if (offsets_size > 512 * 1024 * 1024) { ++ /* Prevent ridiculous offsets_size which causes memory allocation to ++ * fail or overflows bdrv_pread() size. In practice the 512 MB ++ * offsets[] limit supports 16 TB images at 256 KB block size. ++ */ ++ error_setg(errp, "image requires too many offsets, " ++ "try increasing block size"); ++ return -EINVAL; ++ } + s->offsets = g_malloc(offsets_size); + + ret = bdrv_pread(bs->file, 128 + 4 + 4, s->offsets, offsets_size); +diff --git a/tests/qemu-iotests/075 b/tests/qemu-iotests/075 +index 9ce6b1f..9c00fa8 100755 +--- a/tests/qemu-iotests/075 ++++ b/tests/qemu-iotests/075 +@@ -74,6 +74,12 @@ _use_sample_img simple-pattern.cloop.bz2 + poke_file "$TEST_IMG" "$n_blocks_offset" "\xff\xff\xff\xff" + $QEMU_IO -c "read 0 512" $TEST_IMG 2>&1 | _filter_qemu_io | _filter_testdir + ++echo ++echo "== refuse images that require too many offsets ===" ++_use_sample_img simple-pattern.cloop.bz2 ++poke_file "$TEST_IMG" "$n_blocks_offset" "\x04\x00\x00\x01" ++$QEMU_IO -c "read 0 512" $TEST_IMG 2>&1 | _filter_qemu_io | _filter_testdir ++ + # success, all done + echo "*** done" + rm -f $seq.full +diff --git a/tests/qemu-iotests/075.out b/tests/qemu-iotests/075.out +index a771789..7cdaee1 100644 +--- a/tests/qemu-iotests/075.out ++++ b/tests/qemu-iotests/075.out +@@ -19,4 +19,8 @@ no file open, try 'help open' + == offsets_size overflow === + qemu-io: can't open device TEST_DIR/simple-pattern.cloop: n_blocks 4294967295 must be 536870911 or less + no file open, try 'help open' ++ ++== refuse images that require too many offsets === ++qemu-io: can't open device TEST_DIR/simple-pattern.cloop: image requires too many offsets, try increasing block size ++no file open, try 'help open' + *** done +-- +1.7.1 + diff --git a/SOURCES/kvm-block-cloop-validate-block_size-header-field-CVE-201.patch b/SOURCES/kvm-block-cloop-validate-block_size-header-field-CVE-201.patch new file mode 100644 index 0000000..3e66b06 --- /dev/null +++ b/SOURCES/kvm-block-cloop-validate-block_size-header-field-CVE-201.patch @@ -0,0 +1,135 @@ +From ba8c0cc73f3a13b5621c8fe44eb8af20ddb9c5d0 Mon Sep 17 00:00:00 2001 +From: Stefan Hajnoczi +Date: Tue, 25 Mar 2014 14:23:11 +0100 +Subject: [PATCH 04/49] block/cloop: validate block_size header field (CVE-2014-0144) + +RH-Author: Kevin Wolf +Message-id: <1395753835-7591-5-git-send-email-kwolf@redhat.com> +Patchwork-id: n/a +O-Subject: [virt-devel] [EMBARGOED RHEL-7.0 qemu-kvm PATCH 04/48] block/cloop: validate block_size header field (CVE-2014-0144) +Bugzilla: 1079455 +RH-Acked-by: Jeff Cody +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Paolo Bonzini + +From: Stefan Hajnoczi + +Bugzilla: https://bugzilla.redhat.com/show_bug.cgi?id=1079455 +Upstream status: Embargoed + +Avoid unbounded s->uncompressed_block memory allocation by checking that +the block_size header field has a reasonable value. Also enforce the +assumption that the value is a non-zero multiple of 512. + +These constraints conform to cloop 2.639's code so we accept existing +image files. + +Signed-off-by: Stefan Hajnoczi +Signed-off-by: Kevin Wolf +--- + block/cloop.c | 23 +++++++++++++++++++++++ + tests/qemu-iotests/075 | 20 ++++++++++++++++++++ + tests/qemu-iotests/075.out | 12 ++++++++++++ + 3 files changed, 55 insertions(+), 0 deletions(-) + +diff --git a/block/cloop.c b/block/cloop.c +index b907023..f021663 100644 +--- a/block/cloop.c ++++ b/block/cloop.c +@@ -26,6 +26,9 @@ + #include "qemu/module.h" + #include + ++/* Maximum compressed block size */ ++#define MAX_BLOCK_SIZE (64 * 1024 * 1024) ++ + typedef struct BDRVCloopState { + CoMutex lock; + uint32_t block_size; +@@ -68,6 +71,26 @@ static int cloop_open(BlockDriverState *bs, QDict *options, int flags, + return ret; + } + s->block_size = be32_to_cpu(s->block_size); ++ if (s->block_size % 512) { ++ error_setg(errp, "block_size %u must be a multiple of 512", ++ s->block_size); ++ return -EINVAL; ++ } ++ if (s->block_size == 0) { ++ error_setg(errp, "block_size cannot be zero"); ++ return -EINVAL; ++ } ++ ++ /* cloop's create_compressed_fs.c warns about block sizes beyond 256 KB but ++ * we can accept more. Prevent ridiculous values like 4 GB - 1 since we ++ * need a buffer this big. ++ */ ++ if (s->block_size > MAX_BLOCK_SIZE) { ++ error_setg(errp, "block_size %u must be %u MB or less", ++ s->block_size, ++ MAX_BLOCK_SIZE / (1024 * 1024)); ++ return -EINVAL; ++ } + + ret = bdrv_pread(bs->file, 128 + 4, &s->n_blocks, 4); + if (ret < 0) { +diff --git a/tests/qemu-iotests/075 b/tests/qemu-iotests/075 +index 88ae8bb..8f54a99 100755 +--- a/tests/qemu-iotests/075 ++++ b/tests/qemu-iotests/075 +@@ -42,11 +42,31 @@ _supported_fmt cloop + _supported_proto generic + _supported_os Linux + ++block_size_offset=128 ++ + echo + echo "== check that the first sector can be read ==" + _use_sample_img simple-pattern.cloop.bz2 + $QEMU_IO -c "read 0 512" $TEST_IMG 2>&1 | _filter_qemu_io | _filter_testdir + ++echo ++echo "== block_size must be a multiple of 512 ==" ++_use_sample_img simple-pattern.cloop.bz2 ++poke_file "$TEST_IMG" "$block_size_offset" "\x00\x00\x02\x01" ++$QEMU_IO -c "read 0 512" $TEST_IMG 2>&1 | _filter_qemu_io | _filter_testdir ++ ++echo ++echo "== block_size cannot be zero ==" ++_use_sample_img simple-pattern.cloop.bz2 ++poke_file "$TEST_IMG" "$block_size_offset" "\x00\x00\x00\x00" ++$QEMU_IO -c "read 0 512" $TEST_IMG 2>&1 | _filter_qemu_io | _filter_testdir ++ ++echo ++echo "== huge block_size ===" ++_use_sample_img simple-pattern.cloop.bz2 ++poke_file "$TEST_IMG" "$block_size_offset" "\xff\xff\xfe\x00" ++$QEMU_IO -c "read 0 512" $TEST_IMG 2>&1 | _filter_qemu_io | _filter_testdir ++ + # success, all done + echo "*** done" + rm -f $seq.full +diff --git a/tests/qemu-iotests/075.out b/tests/qemu-iotests/075.out +index 26661fa..d362c95 100644 +--- a/tests/qemu-iotests/075.out ++++ b/tests/qemu-iotests/075.out +@@ -3,4 +3,16 @@ QA output created by 075 + == check that the first sector can be read == + read 512/512 bytes at offset 0 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) ++ ++== block_size must be a multiple of 512 == ++qemu-io: can't open device TEST_DIR/simple-pattern.cloop: block_size 513 must be a multiple of 512 ++no file open, try 'help open' ++ ++== block_size cannot be zero == ++qemu-io: can't open device TEST_DIR/simple-pattern.cloop: block_size cannot be zero ++no file open, try 'help open' ++ ++== huge block_size === ++qemu-io: can't open device TEST_DIR/simple-pattern.cloop: block_size 4294966784 must be 64 MB or less ++no file open, try 'help open' + *** done +-- +1.7.1 + diff --git a/SOURCES/kvm-block-drive-mirror-Check-for-NULL-backing_hd.patch b/SOURCES/kvm-block-drive-mirror-Check-for-NULL-backing_hd.patch new file mode 100644 index 0000000..063a4c2 --- /dev/null +++ b/SOURCES/kvm-block-drive-mirror-Check-for-NULL-backing_hd.patch @@ -0,0 +1,68 @@ +From bcc312ef8d0c8ff3c8743e01bd24fd26c4cc96f6 Mon Sep 17 00:00:00 2001 +From: Max Reitz +Date: Sun, 19 Jan 2014 18:07:57 +0100 +Subject: [PATCH 23/34] block/drive-mirror: Check for NULL backing_hd + +RH-Author: Max Reitz +Message-id: <1390154881-17140-4-git-send-email-mreitz@redhat.com> +Patchwork-id: 56816 +O-Subject: [RHEL-7.0 qemu-kvm PATCH v2 3/7] block/drive-mirror: Check for NULL backing_hd +Bugzilla: 921890 +RH-Acked-by: Fam Zheng +RH-Acked-by: Kevin Wolf +RH-Acked-by: Jeffrey Cody + +BZ: 921890 + +It should be possible to execute the QMP "drive-mirror" command in +"none" sync mode and "absolute-paths" mode even for block devices +lacking a backing file. + +"absolute-paths" does in fact not require a backing file to be present, +as can be seen from the "top" sync mode code path. "top" basically +states that the device should indeed have a backing file - however, the +current code catches the case if it doesn't and then simply treats it as +"full" sync mode, creating a target image without a backing file (in +"absolute-paths" mode). Thus, "absolute-paths" does not imply the target +file must indeed have a backing file. + +Therefore, the target file may be left unbacked in case of "none" sync +mode as well, if the specified device is not backed either. Currently, +qemu will crash trying to dereference the backing file pointer since it +assumes that it will always be non-NULL in that case ("none" with +"absolute-paths"). + +Signed-off-by: Max Reitz +Reviewed-by: Wenchao Xia +Reviewed-by: Eric Blake +Signed-off-by: Kevin Wolf +(cherry picked from commit 1452686495922b81d6cf43edf025c1aef15965c0) + +Signed-off-by: Max Reitz +--- + blockdev.c | 4 +++- + 1 file changed, 3 insertions(+), 1 deletion(-) + +Signed-off-by: Miroslav Rezanina +--- + blockdev.c | 4 +++- + 1 files changed, 3 insertions(+), 1 deletions(-) + +diff --git a/blockdev.c b/blockdev.c +index 0ba2504..06bbf30 100644 +--- a/blockdev.c ++++ b/blockdev.c +@@ -1611,7 +1611,9 @@ void qmp_drive_mirror(const char *device, const char *target, + return; + } + +- if (sync == MIRROR_SYNC_MODE_FULL && mode != NEW_IMAGE_MODE_EXISTING) { ++ if ((sync == MIRROR_SYNC_MODE_FULL || !source) ++ && mode != NEW_IMAGE_MODE_EXISTING) ++ { + /* create new image w/o backing file */ + assert(format && drv); + bdrv_img_create(target, format, +-- +1.7.1 + diff --git a/SOURCES/kvm-block-drive-mirror-Reuse-backing-HD-for-sync-none.patch b/SOURCES/kvm-block-drive-mirror-Reuse-backing-HD-for-sync-none.patch new file mode 100644 index 0000000..5261bd9 --- /dev/null +++ b/SOURCES/kvm-block-drive-mirror-Reuse-backing-HD-for-sync-none.patch @@ -0,0 +1,70 @@ +From 0567c3f91a89c476b29341e581aac0e522d26717 Mon Sep 17 00:00:00 2001 +From: Max Reitz +Date: Sun, 19 Jan 2014 18:08:00 +0100 +Subject: [PATCH 26/34] block/drive-mirror: Reuse backing HD for sync=none + +RH-Author: Max Reitz +Message-id: <1390154881-17140-7-git-send-email-mreitz@redhat.com> +Patchwork-id: 56819 +O-Subject: [RHEL-7.0 qemu-kvm PATCH v2 6/7] block/drive-mirror: Reuse backing HD for sync=none +Bugzilla: 921890 +RH-Acked-by: Fam Zheng +RH-Acked-by: Kevin Wolf +RH-Acked-by: Jeffrey Cody + +BZ: 921890 + +For "none" sync mode in "absolute-paths" mode, the current image should +be used as the backing file for the newly created image. + +The current behavior is: +a) If the image to be mirrored has a backing file, use that (which is + wrong, since the operations recorded by "none" are applied to the + image itself, not to its backing file). +b) If the image to be mirrored lacks a backing file, the target doesn't + have one either (which is not really wrong, but not really right, + either; "none" records a set of operations executed on the image + file, therefore having no backing file to apply these operations on + seems rather pointless). + +For a, this is clearly a bugfix. For b, it is still a bugfix, although +it might break existing API - but since that case crashed qemu just +three weeks ago (before 1452686495922b81d6cf43edf025c1aef15965c0), we +can safely assume there is no such API relying on that case yet. + +Suggested-by: Paolo Bonzini +Signed-off-by: Max Reitz +Reviewed-by: Paolo Bonzini +Reviewed-by: Kevin Wolf +Reviewed-by: Eric Blake +Message-id: 1385407736-13941-2-git-send-email-mreitz@redhat.com +Signed-off-by: Anthony Liguori +(cherry picked from commit 117e0c82881f05d88902d4059a3171bc6cd02df0) + +Signed-off-by: Max Reitz +--- + blockdev.c | 3 +++ + 1 file changed, 3 insertions(+) + +Signed-off-by: Miroslav Rezanina +--- + blockdev.c | 3 +++ + 1 files changed, 3 insertions(+), 0 deletions(-) + +diff --git a/blockdev.c b/blockdev.c +index 06bbf30..80c6bb4 100644 +--- a/blockdev.c ++++ b/blockdev.c +@@ -1604,6 +1604,9 @@ void qmp_drive_mirror(const char *device, const char *target, + if (!source && sync == MIRROR_SYNC_MODE_TOP) { + sync = MIRROR_SYNC_MODE_FULL; + } ++ if (sync == MIRROR_SYNC_MODE_NONE) { ++ source = bs; ++ } + + size = bdrv_getlength(bs); + if (size < 0) { +-- +1.7.1 + diff --git a/SOURCES/kvm-block-drivers-add-discard-write_zeroes-properties-to.patch.patch.patch b/SOURCES/kvm-block-drivers-add-discard-write_zeroes-properties-to.patch.patch.patch new file mode 100644 index 0000000..8f3f733 --- /dev/null +++ b/SOURCES/kvm-block-drivers-add-discard-write_zeroes-properties-to.patch.patch.patch @@ -0,0 +1,106 @@ +From d10c277da89a9a2d288560fc6ccdc455b3d39090 Mon Sep 17 00:00:00 2001 +Message-Id: +In-Reply-To: +References: +From: Paolo Bonzini +Date: Mon, 9 Dec 2013 14:09:18 +0100 +Subject: [PATCH 30/50] block drivers: add discard/write_zeroes properties to + bdrv_get_info implementation + +RH-Author: Paolo Bonzini +Message-id: <1386598178-11845-33-git-send-email-pbonzini@redhat.com> +Patchwork-id: 56069 +O-Subject: [RHEL 7.0 qemu-kvm PATCH 32/52] block drivers: add discard/write_zeroes properties to bdrv_get_info implementation +Bugzilla: 1007815 +RH-Acked-by: Jeffrey Cody +RH-Acked-by: Fam Zheng +RH-Acked-by: Stefan Hajnoczi + +Signed-off-by: Paolo Bonzini +Reviewed-by: Peter Lieven +Signed-off-by: Stefan Hajnoczi +(cherry picked from commit 95de6d7078b029b73708059a17cef20f332adcb7) +--- + block/qcow2.c | 2 ++ + block/qed.c | 2 ++ + block/vdi.c | 1 + + block/vhdx.c | 3 +++ + block/vpc.c | 1 + + 5 files changed, 9 insertions(+) + +Signed-off-by: Michal Novotny +--- + block/qcow2.c | 2 ++ + block/qed.c | 2 ++ + block/vdi.c | 1 + + block/vhdx.c | 3 +++ + block/vpc.c | 1 + + 5 files changed, 9 insertions(+) + +diff --git a/block/qcow2.c b/block/qcow2.c +index c109646..bbba11f 100644 +--- a/block/qcow2.c ++++ b/block/qcow2.c +@@ -1886,6 +1886,8 @@ static int64_t qcow2_vm_state_offset(BDRVQcowState *s) + static int qcow2_get_info(BlockDriverState *bs, BlockDriverInfo *bdi) + { + BDRVQcowState *s = bs->opaque; ++ bdi->unallocated_blocks_are_zero = true; ++ bdi->can_write_zeroes_with_unmap = (s->qcow_version >= 3); + bdi->cluster_size = s->cluster_size; + bdi->vm_state_offset = qcow2_vm_state_offset(s); + return 0; +diff --git a/block/qed.c b/block/qed.c +index e163372..c470329 100644 +--- a/block/qed.c ++++ b/block/qed.c +@@ -1475,6 +1475,8 @@ static int bdrv_qed_get_info(BlockDriverState *bs, BlockDriverInfo *bdi) + memset(bdi, 0, sizeof(*bdi)); + bdi->cluster_size = s->header.cluster_size; + bdi->is_dirty = s->header.features & QED_F_NEED_CHECK; ++ bdi->unallocated_blocks_are_zero = true; ++ bdi->can_write_zeroes_with_unmap = true; + return 0; + } + +diff --git a/block/vdi.c b/block/vdi.c +index dcbc27c..f973883 100644 +--- a/block/vdi.c ++++ b/block/vdi.c +@@ -331,6 +331,7 @@ static int vdi_get_info(BlockDriverState *bs, BlockDriverInfo *bdi) + logout("\n"); + bdi->cluster_size = s->block_size; + bdi->vm_state_offset = 0; ++ bdi->unallocated_blocks_are_zero = true; + return 0; + } + +diff --git a/block/vhdx.c b/block/vhdx.c +index 7285b95..41c3065 100644 +--- a/block/vhdx.c ++++ b/block/vhdx.c +@@ -884,6 +884,9 @@ static int vhdx_get_info(BlockDriverState *bs, BlockDriverInfo *bdi) + + bdi->cluster_size = s->block_size; + ++ bdi->unallocated_blocks_are_zero = ++ (s->params.data_bits & VHDX_PARAMS_HAS_PARENT) == 0; ++ + return 0; + } + +diff --git a/block/vpc.c b/block/vpc.c +index 49520c1..059069f 100644 +--- a/block/vpc.c ++++ b/block/vpc.c +@@ -448,6 +448,7 @@ static int vpc_get_info(BlockDriverState *bs, BlockDriverInfo *bdi) + bdi->cluster_size = s->block_size; + } + ++ bdi->unallocated_blocks_are_zero = true; + return 0; + } + +-- +1.7.11.7 + diff --git a/SOURCES/kvm-block-drivers-expose-requirement-for-write-same-alig.patch.patch.patch b/SOURCES/kvm-block-drivers-expose-requirement-for-write-same-alig.patch.patch.patch new file mode 100644 index 0000000..daf514a --- /dev/null +++ b/SOURCES/kvm-block-drivers-expose-requirement-for-write-same-alig.patch.patch.patch @@ -0,0 +1,83 @@ +From 2ae5ce2fe476decb545f16c5af382e5959b2933a Mon Sep 17 00:00:00 2001 +Message-Id: <2ae5ce2fe476decb545f16c5af382e5959b2933a.1389014116.git.minovotn@redhat.com> +In-Reply-To: +References: +From: Paolo Bonzini +Date: Mon, 9 Dec 2013 14:09:19 +0100 +Subject: [PATCH 31/50] block drivers: expose requirement for write same + alignment from formats + +RH-Author: Paolo Bonzini +Message-id: <1386598178-11845-34-git-send-email-pbonzini@redhat.com> +Patchwork-id: 56070 +O-Subject: [RHEL 7.0 qemu-kvm PATCH 33/52] block drivers: expose requirement for write same alignment from formats +Bugzilla: 1007815 +RH-Acked-by: Jeffrey Cody +RH-Acked-by: Fam Zheng +RH-Acked-by: Stefan Hajnoczi + +This will let misaligned but large requests use zero clusters. This +is important because the cluster size is not guest visible. + +Signed-off-by: Paolo Bonzini +Reviewed-by: Peter Lieven +Signed-off-by: Stefan Hajnoczi +(cherry picked from commit cffb1ec600de83f693a23578fc2f344c1af9b96f) + +Conflicts: + block/qed.c +--- + block/qcow2.c | 1 + + block/qed.c | 1 + + block/vmdk.c | 4 ++++ + 3 files changed, 6 insertions(+) + +Signed-off-by: Michal Novotny +--- + block/qcow2.c | 1 + + block/qed.c | 1 + + block/vmdk.c | 4 ++++ + 3 files changed, 6 insertions(+) + +diff --git a/block/qcow2.c b/block/qcow2.c +index bbba11f..bf1f66f 100644 +--- a/block/qcow2.c ++++ b/block/qcow2.c +@@ -717,6 +717,7 @@ static int qcow2_open(BlockDriverState *bs, QDict *options, int flags, + } + + qemu_opts_del(opts); ++ bs->bl.write_zeroes_alignment = s->cluster_sectors; + + if (s->use_lazy_refcounts && s->qcow_version < 3) { + error_setg(errp, "Lazy refcounts require a qcow2 image with at least " +diff --git a/block/qed.c b/block/qed.c +index c470329..0805ba3 100644 +--- a/block/qed.c ++++ b/block/qed.c +@@ -495,6 +495,7 @@ static int bdrv_qed_open(BlockDriverState *bs, QDict *options, int flags, + } + } + ++ bs->bl.write_zeroes_alignment = s->header.cluster_size >> BDRV_SECTOR_BITS; + s->need_check_timer = qemu_new_timer_ns(vm_clock, + qed_need_check_timer_cb, s); + +diff --git a/block/vmdk.c b/block/vmdk.c +index 6d676e4..8662016 100644 +--- a/block/vmdk.c ++++ b/block/vmdk.c +@@ -428,6 +428,10 @@ static int vmdk_add_extent(BlockDriverState *bs, + extent->l2_size = l2_size; + extent->cluster_sectors = flat ? sectors : cluster_sectors; + ++ if (!flat) { ++ bs->bl.write_zeroes_alignment = ++ MAX(bs->bl.write_zeroes_alignment, cluster_sectors); ++ } + if (s->num_extents > 1) { + extent->end_sector = (*(extent - 1)).end_sector + extent->sectors; + } else { +-- +1.7.11.7 + diff --git a/SOURCES/kvm-block-ensure-bdrv_drain_all-works-during-bdrv_delete.patch b/SOURCES/kvm-block-ensure-bdrv_drain_all-works-during-bdrv_delete.patch new file mode 100644 index 0000000..4f40c55 --- /dev/null +++ b/SOURCES/kvm-block-ensure-bdrv_drain_all-works-during-bdrv_delete.patch @@ -0,0 +1,54 @@ +From 0487ca6807db23556550e12585924546ed9923af Mon Sep 17 00:00:00 2001 +From: Fam Zheng +Date: Tue, 21 Jan 2014 02:59:42 +0100 +Subject: [PATCH 30/34] block: ensure bdrv_drain_all() works during bdrv_delete() + +RH-Author: Fam Zheng +Message-id: <1390273182-31302-1-git-send-email-famz@redhat.com> +Patchwork-id: 56851 +O-Subject: [RHEL-7 qemu-kvm PATCH 19/18] block: ensure bdrv_drain_all() works during bdrv_delete() +Bugzilla: 1041301 +RH-Acked-by: Jeffrey Cody +RH-Acked-by: Kevin Wolf +RH-Acked-by: Stefan Hajnoczi + +From: Stefan Hajnoczi + +In bdrv_delete() make sure to call bdrv_make_anon() *after* bdrv_close() +so that the device is still seen by bdrv_drain_all() when iterating +bdrv_states. + +Cc: qemu-stable@nongnu.org +Signed-off-by: Stefan Hajnoczi +(cherry picked from commit e1b5c52e04d04bb93546c6e37e8884889d047cb1) +Signed-off-by: Fam Zheng +--- + block.c | 4 ++-- + 1 file changed, 2 insertions(+), 2 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + block.c | 4 ++-- + 1 files changed, 2 insertions(+), 2 deletions(-) + +diff --git a/block.c b/block.c +index b4e3ced..3232971 100644 +--- a/block.c ++++ b/block.c +@@ -1674,11 +1674,11 @@ static void bdrv_delete(BlockDriverState *bs) + assert(!bs->in_use); + assert(!bs->refcnt); + ++ bdrv_close(bs); ++ + /* remove from list, if necessary */ + bdrv_make_anon(bs); + +- bdrv_close(bs); +- + g_free(bs); + } + +-- +1.7.1 + diff --git a/SOURCES/kvm-block-fix-backing-file-segfault.patch b/SOURCES/kvm-block-fix-backing-file-segfault.patch new file mode 100644 index 0000000..e9e2596 --- /dev/null +++ b/SOURCES/kvm-block-fix-backing-file-segfault.patch @@ -0,0 +1,82 @@ +From d3ec1ceddceff322c71dae8c6efff7bec166aeb8 Mon Sep 17 00:00:00 2001 +From: Kevin Wolf +Date: Wed, 8 Jan 2014 19:43:25 +0000 +Subject: [PATCH 01/37] block: fix backing file segfault + +Message-id: <1392117622-28812-2-git-send-email-kwolf@redhat.com> +Patchwork-id: 57166 +O-Subject: [RHEL-7.0 qemu-kvm PATCH v2 01/37] block: fix backing file segfault +Bugzilla: 748906 +RH-Acked-by: Laszlo Ersek +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Max Reitz + +From: Peter Feiner + +When a backing file is opened such that (1) a protocol is directly +used as the block driver and (2) the block driver has bdrv_file_open, +bdrv_open_backing_file segfaults. The problem arises because +bdrv_open_common returns without setting bd->backing_hd->file. + +To effect (1), you seem to have to use the -F flag in qemu-img. There +are several block drivers that satisfy (2), such as "file" and "nbd". +Here are some concrete examples: + + #!/bin/bash + + echo Test file format + ./qemu-img create -f file base.file 1m + ./qemu-img create -f qcow2 -F file -o backing_file=base.file\ + file-overlay.qcow2 + ./qemu-img convert -O raw file-overlay.qcow2 file-convert.raw + + echo Test nbd format + SOCK=$PWD/nbd.sock + ./qemu-img create -f raw base.raw 1m + ./qemu-nbd -t -k $SOCK base.raw & + trap "kill $!" EXIT + while ! test -e $SOCK; do sleep 1; done + ./qemu-img create -f qcow2 -F nbd -o backing_file=nbd:unix:$SOCK\ + nbd-overlay.qcow2 + ./qemu-img convert -O raw nbd-overlay.qcow2 nbd-convert.raw + +Without this patch, the two qemu-img convert commands segfault. + +This is a regression that was introduced in v1.7 by +dbecebddfa4932d1c83915bcb9b5ba5984eb91be. + +Signed-off-by: Peter Feiner +Reviewed-by: Max Reitz +Signed-off-by: Kevin Wolf +(cherry picked from commit d80ac658f2caacfb14ea386211c4a9bea0cea280) + +Signed-off-by: Kevin Wolf +--- + block.c | 8 ++++++-- + 1 file changed, 6 insertions(+), 2 deletions(-) +--- + block.c | 8 ++++++-- + 1 files changed, 6 insertions(+), 2 deletions(-) + +diff --git a/block.c b/block.c +index 1433844..df0adf3 100644 +--- a/block.c ++++ b/block.c +@@ -978,8 +978,12 @@ int bdrv_open_backing_file(BlockDriverState *bs, QDict *options, Error **errp) + error_propagate(errp, local_err); + return ret; + } +- pstrcpy(bs->backing_file, sizeof(bs->backing_file), +- bs->backing_hd->file->filename); ++ ++ if (bs->backing_hd->file) { ++ pstrcpy(bs->backing_file, sizeof(bs->backing_file), ++ bs->backing_hd->file->filename); ++ } ++ + return 0; + } + +-- +1.7.1 + diff --git a/SOURCES/kvm-block-generalize-BlockLimits-handling-to-cover-bdrv_.patch.patch.patch b/SOURCES/kvm-block-generalize-BlockLimits-handling-to-cover-bdrv_.patch.patch.patch new file mode 100644 index 0000000..8f74998 --- /dev/null +++ b/SOURCES/kvm-block-generalize-BlockLimits-handling-to-cover-bdrv_.patch.patch.patch @@ -0,0 +1,147 @@ +From 374f2dab9cd7bd26bca73ef93cf75ed919d278f4 Mon Sep 17 00:00:00 2001 +Message-Id: <374f2dab9cd7bd26bca73ef93cf75ed919d278f4.1389014116.git.minovotn@redhat.com> +In-Reply-To: +References: +From: Paolo Bonzini +Date: Mon, 9 Dec 2013 14:09:11 +0100 +Subject: [PATCH 23/50] block: generalize BlockLimits handling to cover + bdrv_aio_discard too + +RH-Author: Paolo Bonzini +Message-id: <1386598178-11845-26-git-send-email-pbonzini@redhat.com> +Patchwork-id: 56062 +O-Subject: [RHEL 7.0 qemu-kvm PATCH 25/52] block: generalize BlockLimits handling to cover bdrv_aio_discard too +Bugzilla: 1007815 +RH-Acked-by: Jeffrey Cody +RH-Acked-by: Fam Zheng +RH-Acked-by: Stefan Hajnoczi + +bdrv_co_discard is only covering drivers which have a .bdrv_co_discard() +implementation, but not those with .bdrv_aio_discard(). Not very nice, +and easy to avoid. + +Suggested-by: Kevin Wolf +Signed-off-by: Paolo Bonzini +Reviewed-by: Peter Lieven +Signed-off-by: Stefan Hajnoczi +(cherry picked from commit d51e9fe505f7c7b97762100dd0e42cef43c90524) +--- + block.c | 80 +++++++++++++++++++++++++++++++++-------------------------------- + 1 file changed, 41 insertions(+), 39 deletions(-) + +Signed-off-by: Michal Novotny +--- + block.c | 80 +++++++++++++++++++++++++++++++++-------------------------------- + 1 file changed, 41 insertions(+), 39 deletions(-) + +diff --git a/block.c b/block.c +index 60484a6..8dfc207 100644 +--- a/block.c ++++ b/block.c +@@ -4469,6 +4469,8 @@ static void coroutine_fn bdrv_discard_co_entry(void *opaque) + int coroutine_fn bdrv_co_discard(BlockDriverState *bs, int64_t sector_num, + int nb_sectors) + { ++ int max_discard; ++ + if (!bs->drv) { + return -ENOMEDIUM; + } else if (bdrv_check_request(bs, sector_num, nb_sectors)) { +@@ -4486,55 +4488,55 @@ int coroutine_fn bdrv_co_discard(BlockDriverState *bs, int64_t sector_num, + return 0; + } + +- if (bs->drv->bdrv_co_discard) { +- int max_discard = bs->bl.max_discard ? +- bs->bl.max_discard : MAX_DISCARD_DEFAULT; ++ if (!bs->drv->bdrv_co_discard && !bs->drv->bdrv_aio_discard) { ++ return 0; ++ } + +- while (nb_sectors > 0) { +- int ret; +- int num = nb_sectors; ++ max_discard = bs->bl.max_discard ? bs->bl.max_discard : MAX_DISCARD_DEFAULT; ++ while (nb_sectors > 0) { ++ int ret; ++ int num = nb_sectors; + +- /* align request */ +- if (bs->bl.discard_alignment && +- num >= bs->bl.discard_alignment && +- sector_num % bs->bl.discard_alignment) { +- if (num > bs->bl.discard_alignment) { +- num = bs->bl.discard_alignment; +- } +- num -= sector_num % bs->bl.discard_alignment; ++ /* align request */ ++ if (bs->bl.discard_alignment && ++ num >= bs->bl.discard_alignment && ++ sector_num % bs->bl.discard_alignment) { ++ if (num > bs->bl.discard_alignment) { ++ num = bs->bl.discard_alignment; + } ++ num -= sector_num % bs->bl.discard_alignment; ++ } + +- /* limit request size */ +- if (num > max_discard) { +- num = max_discard; +- } ++ /* limit request size */ ++ if (num > max_discard) { ++ num = max_discard; ++ } + ++ if (bs->drv->bdrv_co_discard) { + ret = bs->drv->bdrv_co_discard(bs, sector_num, num); +- if (ret) { +- return ret; ++ } else { ++ BlockDriverAIOCB *acb; ++ CoroutineIOCompletion co = { ++ .coroutine = qemu_coroutine_self(), ++ }; ++ ++ acb = bs->drv->bdrv_aio_discard(bs, sector_num, nb_sectors, ++ bdrv_co_io_em_complete, &co); ++ if (acb == NULL) { ++ return -EIO; ++ } else { ++ qemu_coroutine_yield(); ++ ret = co.ret; + } +- +- sector_num += num; +- nb_sectors -= num; + } +- return 0; +- } else if (bs->drv->bdrv_aio_discard) { +- BlockDriverAIOCB *acb; +- CoroutineIOCompletion co = { +- .coroutine = qemu_coroutine_self(), +- }; +- +- acb = bs->drv->bdrv_aio_discard(bs, sector_num, nb_sectors, +- bdrv_co_io_em_complete, &co); +- if (acb == NULL) { +- return -EIO; +- } else { +- qemu_coroutine_yield(); +- return co.ret; ++ if (ret) { ++ return ret; + } +- } else { +- return 0; ++ ++ sector_num += num; ++ nb_sectors -= num; + } ++ return 0; + } + + int bdrv_discard(BlockDriverState *bs, int64_t sector_num, int nb_sectors) +-- +1.7.11.7 + diff --git a/SOURCES/kvm-block-get_block_status-fix-BDRV_BLOCK_ZERO-for-unall.patch.patch.patch b/SOURCES/kvm-block-get_block_status-fix-BDRV_BLOCK_ZERO-for-unall.patch.patch.patch new file mode 100644 index 0000000..5be4293 --- /dev/null +++ b/SOURCES/kvm-block-get_block_status-fix-BDRV_BLOCK_ZERO-for-unall.patch.patch.patch @@ -0,0 +1,57 @@ +From ae042c767589da954f1b6c4662371dea189fcf50 Mon Sep 17 00:00:00 2001 +Message-Id: +In-Reply-To: +References: +From: Paolo Bonzini +Date: Mon, 9 Dec 2013 14:09:08 +0100 +Subject: [PATCH 20/50] block/get_block_status: fix BDRV_BLOCK_ZERO for + unallocated blocks + +RH-Author: Paolo Bonzini +Message-id: <1386598178-11845-23-git-send-email-pbonzini@redhat.com> +Patchwork-id: 56059 +O-Subject: [RHEL 7.0 qemu-kvm PATCH 22/52] block/get_block_status: fix BDRV_BLOCK_ZERO for unallocated blocks +Bugzilla: 1007815 +RH-Acked-by: Jeffrey Cody +RH-Acked-by: Fam Zheng +RH-Acked-by: Stefan Hajnoczi + +From: Peter Lieven + +this patch does 2 things: +a) only do additional call outs if BDRV_BLOCK_ZERO is not already set. +b) use the newly introduced bdrv_unallocated_blocks_are_zero() + to return the zero state of an unallocated block. the used callout + to bdrv_has_zero_init() is only valid right after bdrv_create. + +Reviewed-by: Eric Blake +Signed-off-by: Peter Lieven +Signed-off-by: Stefan Hajnoczi +(cherry picked from commit c3d8688470a33feb0ea78c006b4399d50c13185e) +--- + block.c | 4 ++-- + 1 file changed, 2 insertions(+), 2 deletions(-) + +Signed-off-by: Michal Novotny +--- + block.c | 4 ++-- + 1 file changed, 2 insertions(+), 2 deletions(-) + +diff --git a/block.c b/block.c +index 2e77763..60484a6 100644 +--- a/block.c ++++ b/block.c +@@ -3290,8 +3290,8 @@ static int64_t coroutine_fn bdrv_co_get_block_status(BlockDriverState *bs, + *pnum, pnum); + } + +- if (!(ret & BDRV_BLOCK_DATA)) { +- if (bdrv_has_zero_init(bs)) { ++ if (!(ret & BDRV_BLOCK_DATA) && !(ret & BDRV_BLOCK_ZERO)) { ++ if (bdrv_unallocated_blocks_are_zero(bs)) { + ret |= BDRV_BLOCK_ZERO; + } else if (bs->backing_hd) { + BlockDriverState *bs2 = bs->backing_hd; +-- +1.7.11.7 + diff --git a/SOURCES/kvm-block-gluster-add-reopen-support.patch b/SOURCES/kvm-block-gluster-add-reopen-support.patch new file mode 100644 index 0000000..907d552 --- /dev/null +++ b/SOURCES/kvm-block-gluster-add-reopen-support.patch @@ -0,0 +1,195 @@ +From b24bec7c4477946f17bf4628608b60d4960b4247 Mon Sep 17 00:00:00 2001 +From: Jeffrey Cody +Date: Thu, 6 Mar 2014 21:13:15 +0100 +Subject: [PATCH 05/16] block: gluster - add reopen support. + +RH-Author: Jeffrey Cody +Message-id: <2f1e357ca27ef45d16e62fbe44b0ce9cef2602fe.1394129674.git.jcody@redhat.com> +Patchwork-id: 58041 +O-Subject: [RHEL7 qemu-kvm PATCH 2/2] block: gluster - add reopen support. +Bugzilla: 1031526 +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Kevin Wolf +RH-Acked-by: Markus Armbruster + +Gluster does parse open flags in its .bdrv_open() implementation, +and the .bdrv_reopen_* implementations need to do the same. + +A new gluster connection to the image file to be created is established +in the .bdrv_reopen_prepare(), and the image file opened with the new +flags. + +If this is successful, then the old image file is closed, and the +old connection torn down. The relevant structure pointers in the gluster +state structure are updated to the new connection. + +If it is not successful, then the new file handle and connection is +abandoned (if it exists), while the old connection is not modified at +all. + +With reopen supported, block-commit (and offline commit) is now also +supported for image files whose base image uses the native gluster +protocol driver. + +Signed-off-by: Jeff Cody +Signed-off-by: Stefan Hajnoczi +(cherry picked from commit adccfbcd6020e928db93b2b4faf0dbd05ffbe016) + +Conflicts: + block/gluster.c + +RHEL7 Note: Conflict was in contextual information, as RHEL7 does not + have gluster zerofill support. +--- + block/gluster.c | 102 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + 1 file changed, 102 insertions(+) + +Signed-off-by: Miroslav Rezanina +--- + block/gluster.c | 102 +++++++++++++++++++++++++++++++++++++++++++++++++++++++ + 1 files changed, 102 insertions(+), 0 deletions(-) + +diff --git a/block/gluster.c b/block/gluster.c +index 95cb05a..f43d3a6 100644 +--- a/block/gluster.c ++++ b/block/gluster.c +@@ -376,6 +376,96 @@ out: + return ret; + } + ++typedef struct BDRVGlusterReopenState { ++ struct glfs *glfs; ++ struct glfs_fd *fd; ++} BDRVGlusterReopenState; ++ ++ ++static int qemu_gluster_reopen_prepare(BDRVReopenState *state, ++ BlockReopenQueue *queue, Error **errp) ++{ ++ int ret = 0; ++ BDRVGlusterReopenState *reop_s; ++ GlusterConf *gconf = NULL; ++ int open_flags = 0; ++ ++ assert(state != NULL); ++ assert(state->bs != NULL); ++ ++ state->opaque = g_malloc0(sizeof(BDRVGlusterReopenState)); ++ reop_s = state->opaque; ++ ++ qemu_gluster_parse_flags(state->flags, &open_flags); ++ ++ gconf = g_malloc0(sizeof(GlusterConf)); ++ ++ reop_s->glfs = qemu_gluster_init(gconf, state->bs->filename); ++ if (reop_s->glfs == NULL) { ++ ret = -errno; ++ goto exit; ++ } ++ ++ reop_s->fd = glfs_open(reop_s->glfs, gconf->image, open_flags); ++ if (reop_s->fd == NULL) { ++ /* reops->glfs will be cleaned up in _abort */ ++ ret = -errno; ++ goto exit; ++ } ++ ++exit: ++ /* state->opaque will be freed in either the _abort or _commit */ ++ qemu_gluster_gconf_free(gconf); ++ return ret; ++} ++ ++static void qemu_gluster_reopen_commit(BDRVReopenState *state) ++{ ++ BDRVGlusterReopenState *reop_s = state->opaque; ++ BDRVGlusterState *s = state->bs->opaque; ++ ++ ++ /* close the old */ ++ if (s->fd) { ++ glfs_close(s->fd); ++ } ++ if (s->glfs) { ++ glfs_fini(s->glfs); ++ } ++ ++ /* use the newly opened image / connection */ ++ s->fd = reop_s->fd; ++ s->glfs = reop_s->glfs; ++ ++ g_free(state->opaque); ++ state->opaque = NULL; ++ ++ return; ++} ++ ++ ++static void qemu_gluster_reopen_abort(BDRVReopenState *state) ++{ ++ BDRVGlusterReopenState *reop_s = state->opaque; ++ ++ if (reop_s == NULL) { ++ return; ++ } ++ ++ if (reop_s->fd) { ++ glfs_close(reop_s->fd); ++ } ++ ++ if (reop_s->glfs) { ++ glfs_fini(reop_s->glfs); ++ } ++ ++ g_free(state->opaque); ++ state->opaque = NULL; ++ ++ return; ++} ++ + static int qemu_gluster_create(const char *filename, + QEMUOptionParameter *options, Error **errp) + { +@@ -605,6 +695,9 @@ static BlockDriver bdrv_gluster = { + .protocol_name = "gluster", + .instance_size = sizeof(BDRVGlusterState), + .bdrv_file_open = qemu_gluster_open, ++ .bdrv_reopen_prepare = qemu_gluster_reopen_prepare, ++ .bdrv_reopen_commit = qemu_gluster_reopen_commit, ++ .bdrv_reopen_abort = qemu_gluster_reopen_abort, + .bdrv_close = qemu_gluster_close, + .bdrv_create = qemu_gluster_create, + .bdrv_getlength = qemu_gluster_getlength, +@@ -622,6 +715,9 @@ static BlockDriver bdrv_gluster_tcp = { + .protocol_name = "gluster+tcp", + .instance_size = sizeof(BDRVGlusterState), + .bdrv_file_open = qemu_gluster_open, ++ .bdrv_reopen_prepare = qemu_gluster_reopen_prepare, ++ .bdrv_reopen_commit = qemu_gluster_reopen_commit, ++ .bdrv_reopen_abort = qemu_gluster_reopen_abort, + .bdrv_close = qemu_gluster_close, + .bdrv_create = qemu_gluster_create, + .bdrv_getlength = qemu_gluster_getlength, +@@ -639,6 +735,9 @@ static BlockDriver bdrv_gluster_unix = { + .protocol_name = "gluster+unix", + .instance_size = sizeof(BDRVGlusterState), + .bdrv_file_open = qemu_gluster_open, ++ .bdrv_reopen_prepare = qemu_gluster_reopen_prepare, ++ .bdrv_reopen_commit = qemu_gluster_reopen_commit, ++ .bdrv_reopen_abort = qemu_gluster_reopen_abort, + .bdrv_close = qemu_gluster_close, + .bdrv_create = qemu_gluster_create, + .bdrv_getlength = qemu_gluster_getlength, +@@ -656,6 +755,9 @@ static BlockDriver bdrv_gluster_rdma = { + .protocol_name = "gluster+rdma", + .instance_size = sizeof(BDRVGlusterState), + .bdrv_file_open = qemu_gluster_open, ++ .bdrv_reopen_prepare = qemu_gluster_reopen_prepare, ++ .bdrv_reopen_commit = qemu_gluster_reopen_commit, ++ .bdrv_reopen_abort = qemu_gluster_reopen_abort, + .bdrv_close = qemu_gluster_close, + .bdrv_create = qemu_gluster_create, + .bdrv_getlength = qemu_gluster_getlength, +-- +1.7.1 + diff --git a/SOURCES/kvm-block-gluster-code-movements-state-storage-changes.patch b/SOURCES/kvm-block-gluster-code-movements-state-storage-changes.patch new file mode 100644 index 0000000..26e96ce --- /dev/null +++ b/SOURCES/kvm-block-gluster-code-movements-state-storage-changes.patch @@ -0,0 +1,104 @@ +From 8c40036dd1ac888d9565d6d96c8478a00bce696b Mon Sep 17 00:00:00 2001 +From: Jeffrey Cody +Date: Thu, 6 Mar 2014 21:13:14 +0100 +Subject: [PATCH 04/16] block: gluster - code movements, state storage changes + +RH-Author: Jeffrey Cody +Message-id: <8b4867e7eb4ab7db9f9e7900570daf718e62851d.1394129674.git.jcody@redhat.com> +Patchwork-id: 58040 +O-Subject: [RHEL7 qemu-kvm PATCH 1/2] block: gluster - code movements, state storage changes +Bugzilla: 1031526 +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Juan Quintela +RH-Acked-by: Kevin Wolf +RH-Acked-by: Markus Armbruster + +In preparation for supporting reopen on gluster, move flag +parsing out to a function. Also, add a NULL check in the +gconf cleanup. + +Signed-off-by: Jeff Cody +Signed-off-by: Stefan Hajnoczi +(cherry picked from commit 1b37b3442f78a77844fdaf7f53e5f04e4ce8f1d6) +--- + block/gluster.c | 41 ++++++++++++++++++++++++++--------------- + 1 file changed, 26 insertions(+), 15 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + block/gluster.c | 41 ++++++++++++++++++++++++++--------------- + 1 files changed, 26 insertions(+), 15 deletions(-) + +diff --git a/block/gluster.c b/block/gluster.c +index bf39264..95cb05a 100644 +--- a/block/gluster.c ++++ b/block/gluster.c +@@ -50,11 +50,13 @@ typedef struct GlusterConf { + + static void qemu_gluster_gconf_free(GlusterConf *gconf) + { +- g_free(gconf->server); +- g_free(gconf->volname); +- g_free(gconf->image); +- g_free(gconf->transport); +- g_free(gconf); ++ if (gconf) { ++ g_free(gconf->server); ++ g_free(gconf->volname); ++ g_free(gconf->image); ++ g_free(gconf->transport); ++ g_free(gconf); ++ } + } + + static int parse_volume_options(GlusterConf *gconf, char *path) +@@ -296,11 +298,28 @@ static QemuOptsList runtime_opts = { + }, + }; + ++static void qemu_gluster_parse_flags(int bdrv_flags, int *open_flags) ++{ ++ assert(open_flags != NULL); ++ ++ *open_flags |= O_BINARY; ++ ++ if (bdrv_flags & BDRV_O_RDWR) { ++ *open_flags |= O_RDWR; ++ } else { ++ *open_flags |= O_RDONLY; ++ } ++ ++ if ((bdrv_flags & BDRV_O_NOCACHE)) { ++ *open_flags |= O_DIRECT; ++ } ++} ++ + static int qemu_gluster_open(BlockDriverState *bs, QDict *options, + int bdrv_flags, Error **errp) + { + BDRVGlusterState *s = bs->opaque; +- int open_flags = O_BINARY; ++ int open_flags = 0; + int ret = 0; + GlusterConf *gconf = g_malloc0(sizeof(GlusterConf)); + QemuOpts *opts; +@@ -325,15 +344,7 @@ static int qemu_gluster_open(BlockDriverState *bs, QDict *options, + goto out; + } + +- if (bdrv_flags & BDRV_O_RDWR) { +- open_flags |= O_RDWR; +- } else { +- open_flags |= O_RDONLY; +- } +- +- if ((bdrv_flags & BDRV_O_NOCACHE)) { +- open_flags |= O_DIRECT; +- } ++ qemu_gluster_parse_flags(bdrv_flags, &open_flags); + + s->fd = glfs_open(s->glfs, gconf->image, open_flags); + if (!s->fd) { +-- +1.7.1 + diff --git a/SOURCES/kvm-block-handle-ENOTSUP-from-discard-in-generic-code.patch.patch.patch b/SOURCES/kvm-block-handle-ENOTSUP-from-discard-in-generic-code.patch.patch.patch new file mode 100644 index 0000000..6be005b --- /dev/null +++ b/SOURCES/kvm-block-handle-ENOTSUP-from-discard-in-generic-code.patch.patch.patch @@ -0,0 +1,91 @@ +From bb95ce076f174cba655e098fb7924364fd29aa8b Mon Sep 17 00:00:00 2001 +Message-Id: +In-Reply-To: +References: +From: Paolo Bonzini +Date: Mon, 9 Dec 2013 14:09:15 +0100 +Subject: [PATCH 27/50] block: handle ENOTSUP from discard in generic code + +RH-Author: Paolo Bonzini +Message-id: <1386598178-11845-30-git-send-email-pbonzini@redhat.com> +Patchwork-id: 56066 +O-Subject: [RHEL 7.0 qemu-kvm PATCH 29/52] block: handle ENOTSUP from discard in generic code +Bugzilla: 1007815 +RH-Acked-by: Jeffrey Cody +RH-Acked-by: Fam Zheng +RH-Acked-by: Stefan Hajnoczi + +Similar to write_zeroes, let the generic code receive a ENOTSUP for +discard operations. Since bdrv_discard has advisory semantics, +we can just swallow the error. + +Signed-off-by: Paolo Bonzini +Reviewed-by: Peter Lieven +Signed-off-by: Stefan Hajnoczi +(cherry picked from commit 7ce21016b69b512bf4777965a4292318f2bc7544) +--- + block.c | 2 +- + block/raw-posix.c | 12 ++++++------ + 2 files changed, 7 insertions(+), 7 deletions(-) + +Signed-off-by: Michal Novotny +--- + block.c | 2 +- + block/raw-posix.c | 12 ++++++------ + 2 files changed, 7 insertions(+), 7 deletions(-) + +diff --git a/block.c b/block.c +index fc15370..c9e65b4 100644 +--- a/block.c ++++ b/block.c +@@ -4545,7 +4545,7 @@ int coroutine_fn bdrv_co_discard(BlockDriverState *bs, int64_t sector_num, + ret = co.ret; + } + } +- if (ret) { ++ if (ret && ret != -ENOTSUP) { + return ret; + } + +diff --git a/block/raw-posix.c b/block/raw-posix.c +index c2b3dfd..7a140b0 100644 +--- a/block/raw-posix.c ++++ b/block/raw-posix.c +@@ -324,10 +324,10 @@ static int raw_open_common(BlockDriverState *bs, QDict *options, + } + #endif + +- s->has_discard = 1; ++ s->has_discard = true; + #ifdef CONFIG_XFS + if (platform_test_xfs_fd(s->fd)) { +- s->is_xfs = 1; ++ s->is_xfs = true; + } + #endif + +@@ -699,8 +699,8 @@ static ssize_t handle_aiocb_discard(RawPosixAIOData *aiocb) + int ret = -EOPNOTSUPP; + BDRVRawState *s = aiocb->bs->opaque; + +- if (s->has_discard == 0) { +- return 0; ++ if (!s->has_discard) { ++ return -ENOTSUP; + } + + if (aiocb->aio_type & QEMU_AIO_BLKDEV) { +@@ -735,8 +735,8 @@ static ssize_t handle_aiocb_discard(RawPosixAIOData *aiocb) + + if (ret == -ENODEV || ret == -ENOSYS || ret == -EOPNOTSUPP || + ret == -ENOTTY) { +- s->has_discard = 0; +- ret = 0; ++ s->has_discard = false; ++ ret = -ENOTSUP; + } + return ret; + } +-- +1.7.11.7 + diff --git a/SOURCES/kvm-block-honour-BlockLimits-in-bdrv_co_discard.patch.patch.patch b/SOURCES/kvm-block-honour-BlockLimits-in-bdrv_co_discard.patch.patch.patch new file mode 100644 index 0000000..e8a600e --- /dev/null +++ b/SOURCES/kvm-block-honour-BlockLimits-in-bdrv_co_discard.patch.patch.patch @@ -0,0 +1,90 @@ +From f3ba81ab59dcb21f79cf2f2053206d6b03431658 Mon Sep 17 00:00:00 2001 +Message-Id: +In-Reply-To: +References: +From: Paolo Bonzini +Date: Mon, 9 Dec 2013 14:09:03 +0100 +Subject: [PATCH 15/50] block: honour BlockLimits in bdrv_co_discard + +RH-Author: Paolo Bonzini +Message-id: <1386598178-11845-18-git-send-email-pbonzini@redhat.com> +Patchwork-id: 56053 +O-Subject: [RHEL 7.0 qemu-kvm PATCH 17/52] block: honour BlockLimits in bdrv_co_discard +Bugzilla: 1007815 +RH-Acked-by: Jeffrey Cody +RH-Acked-by: Fam Zheng +RH-Acked-by: Stefan Hajnoczi + +From: Peter Lieven + +Reviewed-by: Eric Blake +Signed-off-by: Peter Lieven +Signed-off-by: Stefan Hajnoczi +(cherry picked from commit 6f14da5247076bde1e00444f6d5b2b7ca8075a09) +--- + block.c | 37 ++++++++++++++++++++++++++++++++++++- + 1 file changed, 36 insertions(+), 1 deletion(-) + +Signed-off-by: Michal Novotny +--- + block.c | 37 ++++++++++++++++++++++++++++++++++++- + 1 file changed, 36 insertions(+), 1 deletion(-) + +diff --git a/block.c b/block.c +index 2ed9aa9..23dbafd 100644 +--- a/block.c ++++ b/block.c +@@ -4424,6 +4424,11 @@ static void coroutine_fn bdrv_discard_co_entry(void *opaque) + rwco->ret = bdrv_co_discard(rwco->bs, rwco->sector_num, rwco->nb_sectors); + } + ++/* if no limit is specified in the BlockLimits use a default ++ * of 32768 512-byte sectors (16 MiB) per request. ++ */ ++#define MAX_DISCARD_DEFAULT 32768 ++ + int coroutine_fn bdrv_co_discard(BlockDriverState *bs, int64_t sector_num, + int nb_sectors) + { +@@ -4445,7 +4450,37 @@ int coroutine_fn bdrv_co_discard(BlockDriverState *bs, int64_t sector_num, + } + + if (bs->drv->bdrv_co_discard) { +- return bs->drv->bdrv_co_discard(bs, sector_num, nb_sectors); ++ int max_discard = bs->bl.max_discard ? ++ bs->bl.max_discard : MAX_DISCARD_DEFAULT; ++ ++ while (nb_sectors > 0) { ++ int ret; ++ int num = nb_sectors; ++ ++ /* align request */ ++ if (bs->bl.discard_alignment && ++ num >= bs->bl.discard_alignment && ++ sector_num % bs->bl.discard_alignment) { ++ if (num > bs->bl.discard_alignment) { ++ num = bs->bl.discard_alignment; ++ } ++ num -= sector_num % bs->bl.discard_alignment; ++ } ++ ++ /* limit request size */ ++ if (num > max_discard) { ++ num = max_discard; ++ } ++ ++ ret = bs->drv->bdrv_co_discard(bs, sector_num, num); ++ if (ret) { ++ return ret; ++ } ++ ++ sector_num += num; ++ nb_sectors -= num; ++ } ++ return 0; + } else if (bs->drv->bdrv_aio_discard) { + BlockDriverAIOCB *acb; + CoroutineIOCompletion co = { +-- +1.7.11.7 + diff --git a/SOURCES/kvm-block-honour-BlockLimits-in-bdrv_co_do_write_zeroes.patch.patch.patch b/SOURCES/kvm-block-honour-BlockLimits-in-bdrv_co_do_write_zeroes.patch.patch.patch new file mode 100644 index 0000000..3cef2f7 --- /dev/null +++ b/SOURCES/kvm-block-honour-BlockLimits-in-bdrv_co_do_write_zeroes.patch.patch.patch @@ -0,0 +1,121 @@ +From 69e802baf506bd21a2f444cfebe4ac7f5b5d07a8 Mon Sep 17 00:00:00 2001 +Message-Id: <69e802baf506bd21a2f444cfebe4ac7f5b5d07a8.1389014116.git.minovotn@redhat.com> +In-Reply-To: +References: +From: Paolo Bonzini +Date: Mon, 9 Dec 2013 14:09:02 +0100 +Subject: [PATCH 14/50] block: honour BlockLimits in bdrv_co_do_write_zeroes + +RH-Author: Paolo Bonzini +Message-id: <1386598178-11845-17-git-send-email-pbonzini@redhat.com> +Patchwork-id: 56052 +O-Subject: [RHEL 7.0 qemu-kvm PATCH 16/52] block: honour BlockLimits in bdrv_co_do_write_zeroes +Bugzilla: 1007815 +RH-Acked-by: Jeffrey Cody +RH-Acked-by: Fam Zheng +RH-Acked-by: Stefan Hajnoczi + +From: Peter Lieven + +Reviewed-by: Eric Blake +Signed-off-by: Peter Lieven +Signed-off-by: Stefan Hajnoczi +(cherry picked from commit c31cb70728d2c0c8900b35a66784baa446fd5147) +--- + block.c | 65 +++++++++++++++++++++++++++++++++++++++++++++++++---------------- + 1 file changed, 49 insertions(+), 16 deletions(-) + +Signed-off-by: Michal Novotny +--- + block.c | 65 +++++++++++++++++++++++++++++++++++++++++++++++++---------------- + 1 file changed, 49 insertions(+), 16 deletions(-) + +diff --git a/block.c b/block.c +index 2fae459..2ed9aa9 100644 +--- a/block.c ++++ b/block.c +@@ -2724,32 +2724,65 @@ int coroutine_fn bdrv_co_copy_on_readv(BlockDriverState *bs, + BDRV_REQ_COPY_ON_READ); + } + ++/* if no limit is specified in the BlockLimits use a default ++ * of 32768 512-byte sectors (16 MiB) per request. ++ */ ++#define MAX_WRITE_ZEROES_DEFAULT 32768 ++ + static int coroutine_fn bdrv_co_do_write_zeroes(BlockDriverState *bs, + int64_t sector_num, int nb_sectors, BdrvRequestFlags flags) + { + BlockDriver *drv = bs->drv; + QEMUIOVector qiov; +- struct iovec iov; +- int ret; ++ struct iovec iov = {0}; ++ int ret = 0; + +- /* TODO Emulate only part of misaligned requests instead of letting block +- * drivers return -ENOTSUP and emulate everything */ ++ int max_write_zeroes = bs->bl.max_write_zeroes ? ++ bs->bl.max_write_zeroes : MAX_WRITE_ZEROES_DEFAULT; + +- /* First try the efficient write zeroes operation */ +- if (drv->bdrv_co_write_zeroes) { +- ret = drv->bdrv_co_write_zeroes(bs, sector_num, nb_sectors, flags); +- if (ret != -ENOTSUP) { +- return ret; ++ while (nb_sectors > 0 && !ret) { ++ int num = nb_sectors; ++ ++ /* align request */ ++ if (bs->bl.write_zeroes_alignment && ++ num >= bs->bl.write_zeroes_alignment && ++ sector_num % bs->bl.write_zeroes_alignment) { ++ if (num > bs->bl.write_zeroes_alignment) { ++ num = bs->bl.write_zeroes_alignment; ++ } ++ num -= sector_num % bs->bl.write_zeroes_alignment; + } +- } + +- /* Fall back to bounce buffer if write zeroes is unsupported */ +- iov.iov_len = nb_sectors * BDRV_SECTOR_SIZE; +- iov.iov_base = qemu_blockalign(bs, iov.iov_len); +- memset(iov.iov_base, 0, iov.iov_len); +- qemu_iovec_init_external(&qiov, &iov, 1); ++ /* limit request size */ ++ if (num > max_write_zeroes) { ++ num = max_write_zeroes; ++ } ++ ++ ret = -ENOTSUP; ++ /* First try the efficient write zeroes operation */ ++ if (drv->bdrv_co_write_zeroes) { ++ ret = drv->bdrv_co_write_zeroes(bs, sector_num, num, flags); ++ } ++ ++ if (ret == -ENOTSUP) { ++ /* Fall back to bounce buffer if write zeroes is unsupported */ ++ iov.iov_len = num * BDRV_SECTOR_SIZE; ++ if (iov.iov_base == NULL) { ++ /* allocate bounce buffer only once and ensure that it ++ * is big enough for this and all future requests. ++ */ ++ size_t bufsize = num <= nb_sectors ? num : max_write_zeroes; ++ iov.iov_base = qemu_blockalign(bs, bufsize * BDRV_SECTOR_SIZE); ++ memset(iov.iov_base, 0, bufsize * BDRV_SECTOR_SIZE); ++ } ++ qemu_iovec_init_external(&qiov, &iov, 1); + +- ret = drv->bdrv_co_writev(bs, sector_num, nb_sectors, &qiov); ++ ret = drv->bdrv_co_writev(bs, sector_num, num, &qiov); ++ } ++ ++ sector_num += num; ++ nb_sectors -= num; ++ } + + qemu_vfree(iov.iov_base); + return ret; +-- +1.7.11.7 + diff --git a/SOURCES/kvm-block-implement-reference-count-for-BlockDriverState.patch b/SOURCES/kvm-block-implement-reference-count-for-BlockDriverState.patch new file mode 100644 index 0000000..3179b6d --- /dev/null +++ b/SOURCES/kvm-block-implement-reference-count-for-BlockDriverState.patch @@ -0,0 +1,116 @@ +From 6c473bbd42becf52b10677500bb509fbfa077140 Mon Sep 17 00:00:00 2001 +From: Fam Zheng +Date: Fri, 17 Jan 2014 03:07:47 +0100 +Subject: [PATCH 04/34] block: implement reference count for BlockDriverState + +RH-Author: Fam Zheng +Message-id: <1389928083-8921-3-git-send-email-famz@redhat.com> +Patchwork-id: 56764 +O-Subject: [RHEL-7 qemu-kvm PATCH 02/18] block: implement reference count for BlockDriverState +Bugzilla: 1041301 +RH-Acked-by: Jeffrey Cody +RH-Acked-by: Kevin Wolf +RH-Acked-by: Stefan Hajnoczi + +Introduce bdrv_ref/bdrv_unref to manage the lifecycle of +BlockDriverState. They are unused for now but will used to replace +bdrv_delete() later. + +Signed-off-by: Fam Zheng +Signed-off-by: Stefan Hajnoczi +(cherry picked from commit 9fcb025146676ab376e6159b58f5a5ddb67bf03c) +Signed-off-by: Fam Zheng + +Conflicts: + block.c + Context conflict because throttling and before_write notifier + are not backported yet. + +Signed-off-by: Fam Zheng +--- + block.c | 21 +++++++++++++++++++++ + include/block/block.h | 2 ++ + include/block/block_int.h | 1 + + 3 files changed, 24 insertions(+) + +Signed-off-by: Miroslav Rezanina +--- + block.c | 21 +++++++++++++++++++++ + include/block/block.h | 2 ++ + include/block/block_int.h | 1 + + 3 files changed, 24 insertions(+), 0 deletions(-) + +diff --git a/block.c b/block.c +index cc7afd4..ddf29d0 100644 +--- a/block.c ++++ b/block.c +@@ -301,6 +301,7 @@ BlockDriverState *bdrv_new(const char *device_name) + } + bdrv_iostatus_disable(bs); + notifier_list_init(&bs->close_notifiers); ++ bs->refcnt = 1; + + return bs; + } +@@ -1580,6 +1581,9 @@ static void bdrv_move_feature_fields(BlockDriverState *bs_dest, + /* dirty bitmap */ + bs_dest->dirty_bitmap = bs_src->dirty_bitmap; + ++ /* reference count */ ++ bs_dest->refcnt = bs_src->refcnt; ++ + /* job */ + bs_dest->in_use = bs_src->in_use; + bs_dest->job = bs_src->job; +@@ -4754,6 +4758,23 @@ int64_t bdrv_get_dirty_count(BlockDriverState *bs) + } + } + ++/* Get a reference to bs */ ++void bdrv_ref(BlockDriverState *bs) ++{ ++ bs->refcnt++; ++} ++ ++/* Release a previously grabbed reference to bs. ++ * If after releasing, reference count is zero, the BlockDriverState is ++ * deleted. */ ++void bdrv_unref(BlockDriverState *bs) ++{ ++ assert(bs->refcnt > 0); ++ if (--bs->refcnt == 0) { ++ bdrv_delete(bs); ++ } ++} ++ + void bdrv_set_in_use(BlockDriverState *bs, int in_use) + { + assert(bs->in_use != in_use); +diff --git a/include/block/block.h b/include/block/block.h +index e7f718c..a3b7395 100644 +--- a/include/block/block.h ++++ b/include/block/block.h +@@ -421,6 +421,8 @@ int64_t bdrv_get_dirty_count(BlockDriverState *bs); + void bdrv_enable_copy_on_read(BlockDriverState *bs); + void bdrv_disable_copy_on_read(BlockDriverState *bs); + ++void bdrv_ref(BlockDriverState *bs); ++void bdrv_unref(BlockDriverState *bs); + void bdrv_set_in_use(BlockDriverState *bs, int in_use); + int bdrv_in_use(BlockDriverState *bs); + +diff --git a/include/block/block_int.h b/include/block/block_int.h +index d49a317..fbfdab7 100644 +--- a/include/block/block_int.h ++++ b/include/block/block_int.h +@@ -315,6 +315,7 @@ struct BlockDriverState { + BlockDeviceIoStatus iostatus; + char device_name[32]; + HBitmap *dirty_bitmap; ++ int refcnt; + int in_use; /* users other than guest access, eg. block migration */ + QTAILQ_ENTRY(BlockDriverState) list; + +-- +1.7.1 + diff --git a/SOURCES/kvm-block-introduce-BDRV_REQ_MAY_UNMAP-request-flag.patch.patch.patch b/SOURCES/kvm-block-introduce-BDRV_REQ_MAY_UNMAP-request-flag.patch.patch.patch new file mode 100644 index 0000000..a802b10 --- /dev/null +++ b/SOURCES/kvm-block-introduce-BDRV_REQ_MAY_UNMAP-request-flag.patch.patch.patch @@ -0,0 +1,89 @@ +From c8f8c2859899c631415825beee9cb6369e302f43 Mon Sep 17 00:00:00 2001 +Message-Id: +In-Reply-To: +References: +From: Paolo Bonzini +Date: Mon, 9 Dec 2013 14:08:56 +0100 +Subject: [PATCH 08/50] block: introduce BDRV_REQ_MAY_UNMAP request flag + +RH-Author: Paolo Bonzini +Message-id: <1386598178-11845-11-git-send-email-pbonzini@redhat.com> +Patchwork-id: 56047 +O-Subject: [RHEL 7.0 qemu-kvm PATCH 10/52] block: introduce BDRV_REQ_MAY_UNMAP request flag +Bugzilla: 1007815 +RH-Acked-by: Jeffrey Cody +RH-Acked-by: Fam Zheng +RH-Acked-by: Stefan Hajnoczi + +From: Peter Lieven + +Reviewed-by: Eric Blake +Signed-off-by: Peter Lieven +Signed-off-by: Stefan Hajnoczi +(cherry picked from commit d32f35cbc5a87af5e1100dd55074a79fc2cb5307) + +Conflicts: + block/backup.c [missing] +--- + block-migration.c | 3 ++- + block.c | 4 ++++ + include/block/block.h | 7 +++++++ + 3 files changed, 13 insertions(+), 1 deletion(-) + +Signed-off-by: Michal Novotny +--- + block-migration.c | 3 ++- + block.c | 4 ++++ + include/block/block.h | 7 +++++++ + 3 files changed, 13 insertions(+), 1 deletion(-) + +diff --git a/block-migration.c b/block-migration.c +index 3b22db6..1844066 100644 +--- a/block-migration.c ++++ b/block-migration.c +@@ -780,7 +780,8 @@ static int block_load(QEMUFile *f, void *opaque, int version_id) + } + + if (flags & BLK_MIG_FLAG_ZERO_BLOCK) { +- ret = bdrv_write_zeroes(bs, addr, nr_sectors, 0); ++ ret = bdrv_write_zeroes(bs, addr, nr_sectors, ++ BDRV_REQ_MAY_UNMAP); + } else { + buf = g_malloc(BLOCK_SIZE); + qemu_get_buffer(f, buf, BLOCK_SIZE); +diff --git a/block.c b/block.c +index 698334a..77167f0 100644 +--- a/block.c ++++ b/block.c +@@ -2827,6 +2827,10 @@ int coroutine_fn bdrv_co_write_zeroes(BlockDriverState *bs, + { + trace_bdrv_co_write_zeroes(bs, sector_num, nb_sectors); + ++ if (!(bs->open_flags & BDRV_O_UNMAP)) { ++ flags &= ~BDRV_REQ_MAY_UNMAP; ++ } ++ + return bdrv_co_do_writev(bs, sector_num, nb_sectors, NULL, + BDRV_REQ_ZERO_WRITE | flags); + } +diff --git a/include/block/block.h b/include/block/block.h +index 2d78a84..10abc00 100644 +--- a/include/block/block.h ++++ b/include/block/block.h +@@ -65,6 +65,13 @@ typedef struct BlockDevOps { + typedef enum { + BDRV_REQ_COPY_ON_READ = 0x1, + BDRV_REQ_ZERO_WRITE = 0x2, ++ /* The BDRV_REQ_MAY_UNMAP flag is used to indicate that the block driver ++ * is allowed to optimize a write zeroes request by unmapping (discarding) ++ * blocks if it is guaranteed that the result will read back as ++ * zeroes. The flag is only passed to the driver if the block device is ++ * opened with BDRV_O_UNMAP. ++ */ ++ BDRV_REQ_MAY_UNMAP = 0x4, + } BdrvRequestFlags; + + #define BDRV_O_RDWR 0x0002 +-- +1.7.11.7 + diff --git a/SOURCES/kvm-block-introduce-bdrv_make_zero.patch.patch.patch b/SOURCES/kvm-block-introduce-bdrv_make_zero.patch.patch.patch new file mode 100644 index 0000000..5efec27 --- /dev/null +++ b/SOURCES/kvm-block-introduce-bdrv_make_zero.patch.patch.patch @@ -0,0 +1,103 @@ +From 2f7835f6ef83931dff5fb37729fd42cd7b431b17 Mon Sep 17 00:00:00 2001 +Message-Id: <2f7835f6ef83931dff5fb37729fd42cd7b431b17.1389014116.git.minovotn@redhat.com> +In-Reply-To: +References: +From: Paolo Bonzini +Date: Mon, 9 Dec 2013 14:09:07 +0100 +Subject: [PATCH 19/50] block: introduce bdrv_make_zero + +RH-Author: Paolo Bonzini +Message-id: <1386598178-11845-22-git-send-email-pbonzini@redhat.com> +Patchwork-id: 56058 +O-Subject: [RHEL 7.0 qemu-kvm PATCH 21/52] block: introduce bdrv_make_zero +Bugzilla: 1007815 +RH-Acked-by: Jeffrey Cody +RH-Acked-by: Fam Zheng +RH-Acked-by: Stefan Hajnoczi + +From: Peter Lieven + +this patch adds a call to completely zero out a block device. +the operation is sped up by checking the block status and +only writing zeroes to the device if they currently do not +return zeroes. optionally the zero writing can be sped up +by setting the flag BDRV_REQ_MAY_UNMAP to emulate the zero +write by unmapping if the driver supports it. + +Signed-off-by: Peter Lieven +Signed-off-by: Stefan Hajnoczi +(cherry picked from commit d75cbb5e68f5a7d64248ba89399a7f2073231de5) +--- + block.c | 37 +++++++++++++++++++++++++++++++++++++ + include/block/block.h | 1 + + 2 files changed, 38 insertions(+) + +Signed-off-by: Michal Novotny +--- + block.c | 37 +++++++++++++++++++++++++++++++++++++ + include/block/block.h | 1 + + 2 files changed, 38 insertions(+) + +diff --git a/block.c b/block.c +index 23dbafd..2e77763 100644 +--- a/block.c ++++ b/block.c +@@ -2412,6 +2412,43 @@ int bdrv_write_zeroes(BlockDriverState *bs, int64_t sector_num, + BDRV_REQ_ZERO_WRITE | flags); + } + ++/* ++ * Completely zero out a block device with the help of bdrv_write_zeroes. ++ * The operation is sped up by checking the block status and only writing ++ * zeroes to the device if they currently do not return zeroes. Optional ++ * flags are passed through to bdrv_write_zeroes (e.g. BDRV_REQ_MAY_UNMAP). ++ * ++ * Returns < 0 on error, 0 on success. For error codes see bdrv_write(). ++ */ ++int bdrv_make_zero(BlockDriverState *bs, BdrvRequestFlags flags) ++{ ++ int64_t target_size = bdrv_getlength(bs) / BDRV_SECTOR_SIZE; ++ int64_t ret, nb_sectors, sector_num = 0; ++ int n; ++ ++ for (;;) { ++ nb_sectors = target_size - sector_num; ++ if (nb_sectors <= 0) { ++ return 0; ++ } ++ if (nb_sectors > INT_MAX) { ++ nb_sectors = INT_MAX; ++ } ++ ret = bdrv_get_block_status(bs, sector_num, nb_sectors, &n); ++ if (ret & BDRV_BLOCK_ZERO) { ++ sector_num += n; ++ continue; ++ } ++ ret = bdrv_write_zeroes(bs, sector_num, n, flags); ++ if (ret < 0) { ++ error_report("error writing zeroes at sector %" PRId64 ": %s", ++ sector_num, strerror(-ret)); ++ return ret; ++ } ++ sector_num += n; ++ } ++} ++ + int bdrv_pread(BlockDriverState *bs, int64_t offset, + void *buf, int count1) + { +diff --git a/include/block/block.h b/include/block/block.h +index 1958d98..b87ed3a 100644 +--- a/include/block/block.h ++++ b/include/block/block.h +@@ -218,6 +218,7 @@ int bdrv_write(BlockDriverState *bs, int64_t sector_num, + const uint8_t *buf, int nb_sectors); + int bdrv_write_zeroes(BlockDriverState *bs, int64_t sector_num, + int nb_sectors, BdrvRequestFlags flags); ++int bdrv_make_zero(BlockDriverState *bs, BdrvRequestFlags flags); + int bdrv_writev(BlockDriverState *bs, int64_t sector_num, QEMUIOVector *qiov); + int bdrv_pread(BlockDriverState *bs, int64_t offset, + void *buf, int count); +-- +1.7.11.7 + diff --git a/SOURCES/kvm-block-iscsi-add-.bdrv_get_info.patch.patch b/SOURCES/kvm-block-iscsi-add-.bdrv_get_info.patch.patch new file mode 100644 index 0000000..240ade3 --- /dev/null +++ b/SOURCES/kvm-block-iscsi-add-.bdrv_get_info.patch.patch @@ -0,0 +1,61 @@ +From 8edbab3c2116944b96ba6bcbd36e8c2c5236cf5f Mon Sep 17 00:00:00 2001 +Message-Id: <8edbab3c2116944b96ba6bcbd36e8c2c5236cf5f.1389014116.git.minovotn@redhat.com> +In-Reply-To: +References: +From: Paolo Bonzini +Date: Mon, 9 Dec 2013 14:08:59 +0100 +Subject: [PATCH 11/50] block/iscsi: add .bdrv_get_info + +RH-Author: Paolo Bonzini +Message-id: <1386598178-11845-14-git-send-email-pbonzini@redhat.com> +Patchwork-id: 56048 +O-Subject: [RHEL 7.0 qemu-kvm PATCH 13/52] block/iscsi: add .bdrv_get_info +Bugzilla: 1007815 +RH-Acked-by: Jeffrey Cody +RH-Acked-by: Fam Zheng +RH-Acked-by: Stefan Hajnoczi + +From: Peter Lieven + +Signed-off-by: Peter Lieven +Signed-off-by: Stefan Hajnoczi +(cherry picked from commit 186d4f2b1deaae5c404798959bfbdb781e762045) +--- + block/iscsi.c | 9 +++++++++ + 1 file changed, 9 insertions(+) + +Signed-off-by: Michal Novotny +--- + block/iscsi.c | 9 +++++++++ + 1 file changed, 9 insertions(+) + +diff --git a/block/iscsi.c b/block/iscsi.c +index 3a34eb7..1e8a2bb 100644 +--- a/block/iscsi.c ++++ b/block/iscsi.c +@@ -1508,6 +1508,14 @@ out: + return ret; + } + ++static int iscsi_get_info(BlockDriverState *bs, BlockDriverInfo *bdi) ++{ ++ IscsiLun *iscsilun = bs->opaque; ++ bdi->unallocated_blocks_are_zero = !!iscsilun->lbprz; ++ bdi->can_write_zeroes_with_unmap = iscsilun->lbprz && iscsilun->lbp.lbpws; ++ return 0; ++} ++ + static QEMUOptionParameter iscsi_create_options[] = { + { + .name = BLOCK_OPT_SIZE, +@@ -1528,6 +1536,7 @@ static BlockDriver bdrv_iscsi = { + .create_options = iscsi_create_options, + + .bdrv_getlength = iscsi_getlength, ++ .bdrv_get_info = iscsi_get_info, + .bdrv_truncate = iscsi_truncate, + + .bdrv_co_get_block_status = iscsi_co_get_block_status, +-- +1.7.11.7 + diff --git a/SOURCES/kvm-block-iscsi-check-WRITE-SAME-support-differently-dep.patch.patch.patch b/SOURCES/kvm-block-iscsi-check-WRITE-SAME-support-differently-dep.patch.patch.patch new file mode 100644 index 0000000..fed7676 --- /dev/null +++ b/SOURCES/kvm-block-iscsi-check-WRITE-SAME-support-differently-dep.patch.patch.patch @@ -0,0 +1,89 @@ +From 615429e3068cb4a3e57ee60d52f318aa6ca06f6d Mon Sep 17 00:00:00 2001 +Message-Id: <615429e3068cb4a3e57ee60d52f318aa6ca06f6d.1389014116.git.minovotn@redhat.com> +In-Reply-To: +References: +From: Paolo Bonzini +Date: Mon, 9 Dec 2013 14:09:22 +0100 +Subject: [PATCH 34/50] block/iscsi: check WRITE SAME support differently + depending on MAY_UNMAP + +RH-Author: Paolo Bonzini +Message-id: <1386598178-11845-37-git-send-email-pbonzini@redhat.com> +Patchwork-id: 56073 +O-Subject: [RHEL 7.0 qemu-kvm PATCH 36/52] block/iscsi: check WRITE SAME support differently depending on MAY_UNMAP +Bugzilla: 1007815 +RH-Acked-by: Jeffrey Cody +RH-Acked-by: Fam Zheng +RH-Acked-by: Stefan Hajnoczi + +The current check is right for MAY_UNMAP=1. For MAY_UNMAP=0, just +try and fall back to regular writes as soon as a WRITE SAME command +fails. + +Signed-off-by: Paolo Bonzini +Reviewed-by: Peter Lieven +Signed-off-by: Stefan Hajnoczi +(cherry picked from commit fa6252b0565526ec2347e248172f91771e0d9f47) +--- + block/iscsi.c | 19 +++++++++++++++++-- + 1 file changed, 17 insertions(+), 2 deletions(-) + +Signed-off-by: Michal Novotny +--- + block/iscsi.c | 19 +++++++++++++++++-- + 1 file changed, 17 insertions(+), 2 deletions(-) + +diff --git a/block/iscsi.c b/block/iscsi.c +index 7ae61f9..8b82fe7 100644 +--- a/block/iscsi.c ++++ b/block/iscsi.c +@@ -55,6 +55,7 @@ typedef struct IscsiLun { + QEMUTimer *nop_timer; + uint8_t lbpme; + uint8_t lbprz; ++ uint8_t has_write_same; + struct scsi_inquiry_logical_block_provisioning lbp; + struct scsi_inquiry_block_limits bl; + unsigned char *zeroblock; +@@ -978,8 +979,13 @@ coroutine_fn iscsi_co_write_zeroes(BlockDriverState *bs, int64_t sector_num, + return -EINVAL; + } + +- if (!iscsilun->lbp.lbpws) { +- /* WRITE SAME is not supported by the target */ ++ if (!(flags & BDRV_REQ_MAY_UNMAP) && !iscsilun->has_write_same) { ++ /* WRITE SAME without UNMAP is not supported by the target */ ++ return -ENOTSUP; ++ } ++ ++ if ((flags & BDRV_REQ_MAY_UNMAP) && !iscsilun->lbp.lbpws) { ++ /* WRITE SAME with UNMAP is not supported by the target */ + return -ENOTSUP; + } + +@@ -1014,6 +1020,14 @@ retry: + } + + if (iTask.status != SCSI_STATUS_GOOD) { ++ if (iTask.status == SCSI_STATUS_CHECK_CONDITION && ++ iTask.task->sense.key == SCSI_SENSE_ILLEGAL_REQUEST && ++ iTask.task->sense.ascq == SCSI_SENSE_ASCQ_INVALID_OPERATION_CODE) { ++ /* WRITE SAME is not supported by the target */ ++ iscsilun->has_write_same = false; ++ return -ENOTSUP; ++ } ++ + return -EIO; + } + +@@ -1377,6 +1391,7 @@ static int iscsi_open(BlockDriverState *bs, QDict *options, int flags, + } + + iscsilun->type = inq->periperal_device_type; ++ iscsilun->has_write_same = true; + + if ((ret = iscsi_readcapacity_sync(iscsilun)) != 0) { + goto out; +-- +1.7.11.7 + diff --git a/SOURCES/kvm-block-iscsi-remove-.bdrv_has_zero_init.patch.patch.patch b/SOURCES/kvm-block-iscsi-remove-.bdrv_has_zero_init.patch.patch.patch new file mode 100644 index 0000000..e2ef3ae --- /dev/null +++ b/SOURCES/kvm-block-iscsi-remove-.bdrv_has_zero_init.patch.patch.patch @@ -0,0 +1,62 @@ +From 81a1f4a5ffab6a20f5fa90c722791e6956999988 Mon Sep 17 00:00:00 2001 +Message-Id: <81a1f4a5ffab6a20f5fa90c722791e6956999988.1389014116.git.minovotn@redhat.com> +In-Reply-To: +References: +From: Paolo Bonzini +Date: Mon, 9 Dec 2013 14:09:20 +0100 +Subject: [PATCH 32/50] block/iscsi: remove .bdrv_has_zero_init + +RH-Author: Paolo Bonzini +Message-id: <1386598178-11845-35-git-send-email-pbonzini@redhat.com> +Patchwork-id: 56071 +O-Subject: [RHEL 7.0 qemu-kvm PATCH 34/52] block/iscsi: remove .bdrv_has_zero_init +Bugzilla: 1007815 +RH-Acked-by: Jeffrey Cody +RH-Acked-by: Fam Zheng +RH-Acked-by: Stefan Hajnoczi + +From: Peter Lieven + +since commit 3ac21627 the default value changed to 0. + +Signed-off-by: Peter Lieven +Signed-off-by: Paolo Bonzini +Signed-off-by: Stefan Hajnoczi +(cherry picked from commit 4b52498e62d02a30f780875f54431d1bad0bcabd) +--- + block/iscsi.c | 7 ------- + 1 file changed, 7 deletions(-) + +Signed-off-by: Michal Novotny +--- + block/iscsi.c | 7 ------- + 1 file changed, 7 deletions(-) + +diff --git a/block/iscsi.c b/block/iscsi.c +index 3e3ae64..c5cd86d 100644 +--- a/block/iscsi.c ++++ b/block/iscsi.c +@@ -1507,11 +1507,6 @@ static int iscsi_truncate(BlockDriverState *bs, int64_t offset) + return 0; + } + +-static int iscsi_has_zero_init(BlockDriverState *bs) +-{ +- return 0; +-} +- + static int iscsi_create(const char *filename, QEMUOptionParameter *options, + Error **errp) + { +@@ -1607,8 +1602,6 @@ static BlockDriver bdrv_iscsi = { + .bdrv_aio_writev = iscsi_aio_writev, + .bdrv_aio_flush = iscsi_aio_flush, + +- .bdrv_has_zero_init = iscsi_has_zero_init, +- + #ifdef __linux__ + .bdrv_ioctl = iscsi_ioctl, + .bdrv_aio_ioctl = iscsi_aio_ioctl, +-- +1.7.11.7 + diff --git a/SOURCES/kvm-block-iscsi-set-bdi-cluster_size.patch.patch b/SOURCES/kvm-block-iscsi-set-bdi-cluster_size.patch.patch new file mode 100644 index 0000000..ef6487f --- /dev/null +++ b/SOURCES/kvm-block-iscsi-set-bdi-cluster_size.patch.patch @@ -0,0 +1,57 @@ +From 7e4a1d08c448ddbd6e20705cd2ea38b78f833401 Mon Sep 17 00:00:00 2001 +Message-Id: <7e4a1d08c448ddbd6e20705cd2ea38b78f833401.1389014116.git.minovotn@redhat.com> +In-Reply-To: +References: +From: Paolo Bonzini +Date: Mon, 9 Dec 2013 14:09:33 +0100 +Subject: [PATCH 45/50] block/iscsi: set bdi->cluster_size + +RH-Author: Paolo Bonzini +Message-id: <1386598178-11845-48-git-send-email-pbonzini@redhat.com> +Patchwork-id: 56083 +O-Subject: [RHEL 7.0 qemu-kvm PATCH 47/52] block/iscsi: set bdi->cluster_size +Bugzilla: 1007815 +RH-Acked-by: Jeffrey Cody +RH-Acked-by: Fam Zheng +RH-Acked-by: Stefan Hajnoczi + +From: Peter Lieven + +this patch aims to set bdi->cluster_size to the internal page size +of the iscsi target so that enabled callers can align requests +properly. + +Reviewed-by: Paolo Bonzini +Signed-off-by: Peter Lieven +Signed-off-by: Stefan Hajnoczi +(cherry picked from commit 1c0704a556dbb004a3b82791779760f418053951) +--- + block/iscsi.c | 7 +++++++ + 1 file changed, 7 insertions(+) + +Signed-off-by: Michal Novotny +--- + block/iscsi.c | 7 +++++++ + 1 file changed, 7 insertions(+) + +diff --git a/block/iscsi.c b/block/iscsi.c +index 8b82fe7..94c5af8 100644 +--- a/block/iscsi.c ++++ b/block/iscsi.c +@@ -1582,6 +1582,13 @@ static int iscsi_get_info(BlockDriverState *bs, BlockDriverInfo *bdi) + IscsiLun *iscsilun = bs->opaque; + bdi->unallocated_blocks_are_zero = !!iscsilun->lbprz; + bdi->can_write_zeroes_with_unmap = iscsilun->lbprz && iscsilun->lbp.lbpws; ++ /* Guess the internal cluster (page) size of the iscsi target by the means ++ * of opt_unmap_gran. Transfer the unmap granularity only if it has a ++ * reasonable size for bdi->cluster_size */ ++ if (iscsilun->bl.opt_unmap_gran * iscsilun->block_size >= 64 * 1024 && ++ iscsilun->bl.opt_unmap_gran * iscsilun->block_size <= 16 * 1024 * 1024) { ++ bdi->cluster_size = iscsilun->bl.opt_unmap_gran * iscsilun->block_size; ++ } + return 0; + } + +-- +1.7.11.7 + diff --git a/SOURCES/kvm-block-iscsi-set-bs-bl.opt_transfer_length.patch.patch b/SOURCES/kvm-block-iscsi-set-bs-bl.opt_transfer_length.patch.patch new file mode 100644 index 0000000..aba1888 --- /dev/null +++ b/SOURCES/kvm-block-iscsi-set-bs-bl.opt_transfer_length.patch.patch @@ -0,0 +1,49 @@ +From 5e38ead2b13d0cf9477aacee2d75432fe0f2176d Mon Sep 17 00:00:00 2001 +Message-Id: <5e38ead2b13d0cf9477aacee2d75432fe0f2176d.1389014116.git.minovotn@redhat.com> +In-Reply-To: +References: +From: Paolo Bonzini +Date: Mon, 9 Dec 2013 14:09:35 +0100 +Subject: [PATCH 47/50] block/iscsi: set bs->bl.opt_transfer_length + +RH-Author: Paolo Bonzini +Message-id: <1386598178-11845-50-git-send-email-pbonzini@redhat.com> +Patchwork-id: 56086 +O-Subject: [RHEL 7.0 qemu-kvm PATCH 49/52] block/iscsi: set bs->bl.opt_transfer_length +Bugzilla: 1039557 +RH-Acked-by: Jeffrey Cody +RH-Acked-by: Fam Zheng +RH-Acked-by: Stefan Hajnoczi + +From: Peter Lieven + +Reviewed-by: Paolo Bonzini +Signed-off-by: Peter Lieven +Signed-off-by: Stefan Hajnoczi +(cherry picked from commit 7572ddc8db114d8c437a97ca3eaedab397f66cda) +--- + block/iscsi.c | 3 +++ + 1 file changed, 3 insertions(+) + +Signed-off-by: Michal Novotny +--- + block/iscsi.c | 3 +++ + 1 file changed, 3 insertions(+) + +diff --git a/block/iscsi.c b/block/iscsi.c +index 94c5af8..fce909b 100644 +--- a/block/iscsi.c ++++ b/block/iscsi.c +@@ -1459,6 +1459,9 @@ static int iscsi_open(BlockDriverState *bs, QDict *options, int flags, + } + bs->bl.write_zeroes_alignment = sector_lun2qemu(iscsilun->bl.opt_unmap_gran, + iscsilun); ++ ++ bs->bl.opt_transfer_length = sector_lun2qemu(iscsilun->bl.opt_xfer_len, ++ iscsilun); + } + + #if defined(LIBISCSI_FEATURE_NOP_COUNTER) +-- +1.7.11.7 + diff --git a/SOURCES/kvm-block-iscsi-updated-copyright.patch.patch.patch b/SOURCES/kvm-block-iscsi-updated-copyright.patch.patch.patch new file mode 100644 index 0000000..4f9404c --- /dev/null +++ b/SOURCES/kvm-block-iscsi-updated-copyright.patch.patch.patch @@ -0,0 +1,49 @@ +From 4a988f436f785fa9349baf66a0d44e26b94f75af Mon Sep 17 00:00:00 2001 +Message-Id: <4a988f436f785fa9349baf66a0d44e26b94f75af.1389014116.git.minovotn@redhat.com> +In-Reply-To: +References: +From: Paolo Bonzini +Date: Mon, 9 Dec 2013 14:09:21 +0100 +Subject: [PATCH 33/50] block/iscsi: updated copyright + +RH-Author: Paolo Bonzini +Message-id: <1386598178-11845-36-git-send-email-pbonzini@redhat.com> +Patchwork-id: 56072 +O-Subject: [RHEL 7.0 qemu-kvm PATCH 35/52] block/iscsi: updated copyright +Bugzilla: 1007815 +RH-Acked-by: Jeffrey Cody +RH-Acked-by: Fam Zheng +RH-Acked-by: Stefan Hajnoczi + +From: Peter Lieven + +added myself to reflect recent work on the iscsi block driver. + +Signed-off-by: Peter Lieven +Signed-off-by: Paolo Bonzini +Signed-off-by: Stefan Hajnoczi +(cherry picked from commit 2af8a1a704a352bab2e9eaf803db0b3552e826d0) +--- + block/iscsi.c | 1 + + 1 file changed, 1 insertion(+) + +Signed-off-by: Michal Novotny +--- + block/iscsi.c | 1 + + 1 file changed, 1 insertion(+) + +diff --git a/block/iscsi.c b/block/iscsi.c +index c5cd86d..7ae61f9 100644 +--- a/block/iscsi.c ++++ b/block/iscsi.c +@@ -2,6 +2,7 @@ + * QEMU Block driver for iSCSI images + * + * Copyright (c) 2010-2011 Ronnie Sahlberg ++ * Copyright (c) 2012-2013 Peter Lieven + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal +-- +1.7.11.7 + diff --git a/SOURCES/kvm-block-make-BdrvRequestFlags-public.patch.patch.patch b/SOURCES/kvm-block-make-BdrvRequestFlags-public.patch.patch.patch new file mode 100644 index 0000000..430a293 --- /dev/null +++ b/SOURCES/kvm-block-make-BdrvRequestFlags-public.patch.patch.patch @@ -0,0 +1,69 @@ +From ef18859f76a1499b7d6ac1f3994dade1345088f2 Mon Sep 17 00:00:00 2001 +Message-Id: +In-Reply-To: +References: +From: Paolo Bonzini +Date: Mon, 9 Dec 2013 14:08:54 +0100 +Subject: [PATCH 06/50] block: make BdrvRequestFlags public + +RH-Author: Paolo Bonzini +Message-id: <1386598178-11845-9-git-send-email-pbonzini@redhat.com> +Patchwork-id: 56045 +O-Subject: [RHEL 7.0 qemu-kvm PATCH 08/52] block: make BdrvRequestFlags public +Bugzilla: 1007815 +RH-Acked-by: Jeffrey Cody +RH-Acked-by: Fam Zheng +RH-Acked-by: Stefan Hajnoczi + +From: Peter Lieven + +Reviewed-by: Eric Blake +Signed-off-by: Peter Lieven +Signed-off-by: Stefan Hajnoczi +(cherry picked from commit 6faac15fa80c4c1f813d96afc13bceaa3bc5ffe7) +--- + block.c | 5 ----- + include/block/block.h | 5 +++++ + 2 files changed, 5 insertions(+), 5 deletions(-) + +Signed-off-by: Michal Novotny +--- + block.c | 5 ----- + include/block/block.h | 5 +++++ + 2 files changed, 5 insertions(+), 5 deletions(-) + +diff --git a/block.c b/block.c +index 02994ec..b7ca799 100644 +--- a/block.c ++++ b/block.c +@@ -51,11 +51,6 @@ + + #define NOT_DONE 0x7fffffff /* used while emulated sync operation in progress */ + +-typedef enum { +- BDRV_REQ_COPY_ON_READ = 0x1, +- BDRV_REQ_ZERO_WRITE = 0x2, +-} BdrvRequestFlags; +- + static void bdrv_dev_change_media_cb(BlockDriverState *bs, bool load); + static BlockDriverAIOCB *bdrv_aio_readv_em(BlockDriverState *bs, + int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, +diff --git a/include/block/block.h b/include/block/block.h +index 15ffbd2..ce6e897 100644 +--- a/include/block/block.h ++++ b/include/block/block.h +@@ -62,6 +62,11 @@ typedef struct BlockDevOps { + void (*resize_cb)(void *opaque); + } BlockDevOps; + ++typedef enum { ++ BDRV_REQ_COPY_ON_READ = 0x1, ++ BDRV_REQ_ZERO_WRITE = 0x2, ++} BdrvRequestFlags; ++ + #define BDRV_O_RDWR 0x0002 + #define BDRV_O_SNAPSHOT 0x0008 /* open the file read only and save writes in a snapshot */ + #define BDRV_O_NOCACHE 0x0020 /* do not use the host page cache */ +-- +1.7.11.7 + diff --git a/SOURCES/kvm-block-make-bdrv_co_do_write_zeroes-stricter-in-produ.patch.patch.patch b/SOURCES/kvm-block-make-bdrv_co_do_write_zeroes-stricter-in-produ.patch.patch.patch new file mode 100644 index 0000000..b800865 --- /dev/null +++ b/SOURCES/kvm-block-make-bdrv_co_do_write_zeroes-stricter-in-produ.patch.patch.patch @@ -0,0 +1,100 @@ +From 4a1e019ac51460ce6329892cc99fc11d518d2eb2 Mon Sep 17 00:00:00 2001 +Message-Id: <4a1e019ac51460ce6329892cc99fc11d518d2eb2.1389014116.git.minovotn@redhat.com> +In-Reply-To: +References: +From: Paolo Bonzini +Date: Mon, 9 Dec 2013 14:09:16 +0100 +Subject: [PATCH 28/50] block: make bdrv_co_do_write_zeroes stricter in + producing aligned requests + +RH-Author: Paolo Bonzini +Message-id: <1386598178-11845-31-git-send-email-pbonzini@redhat.com> +Patchwork-id: 56067 +O-Subject: [RHEL 7.0 qemu-kvm PATCH 30/52] block: make bdrv_co_do_write_zeroes stricter in producing aligned requests +Bugzilla: 1007815 +RH-Acked-by: Jeffrey Cody +RH-Acked-by: Fam Zheng +RH-Acked-by: Stefan Hajnoczi + +Right now, bdrv_co_do_write_zeroes will only try to align the +beginning of the request. However, it is simpler for many +formats to expect the block layer to separate both the head *and* +the tail. This makes sure that the format's bdrv_co_write_zeroes +function will be called with aligned sector_num and nb_sectors for +the bulk of the request. + +Signed-off-by: Paolo Bonzini +Reviewed-by: Peter Lieven +Signed-off-by: Stefan Hajnoczi +(cherry picked from commit b8d71c09f31a9cae248d167dddc75c66d5135ff2) +--- + block.c | 35 +++++++++++++++++++++++------------ + 1 file changed, 23 insertions(+), 12 deletions(-) + +Signed-off-by: Michal Novotny +--- + block.c | 35 +++++++++++++++++++++++------------ + 1 file changed, 23 insertions(+), 12 deletions(-) + +diff --git a/block.c b/block.c +index c9e65b4..1ac1ab3 100644 +--- a/block.c ++++ b/block.c +@@ -2781,14 +2781,21 @@ static int coroutine_fn bdrv_co_do_write_zeroes(BlockDriverState *bs, + while (nb_sectors > 0 && !ret) { + int num = nb_sectors; + +- /* align request */ +- if (bs->bl.write_zeroes_alignment && +- num >= bs->bl.write_zeroes_alignment && +- sector_num % bs->bl.write_zeroes_alignment) { +- if (num > bs->bl.write_zeroes_alignment) { ++ /* Align request. Block drivers can expect the "bulk" of the request ++ * to be aligned. ++ */ ++ if (bs->bl.write_zeroes_alignment ++ && num > bs->bl.write_zeroes_alignment) { ++ if (sector_num % bs->bl.write_zeroes_alignment != 0) { ++ /* Make a small request up to the first aligned sector. */ + num = bs->bl.write_zeroes_alignment; ++ num -= sector_num % bs->bl.write_zeroes_alignment; ++ } else if ((sector_num + num) % bs->bl.write_zeroes_alignment != 0) { ++ /* Shorten the request to the last aligned sector. num cannot ++ * underflow because num > bs->bl.write_zeroes_alignment. ++ */ ++ num -= (sector_num + num) % bs->bl.write_zeroes_alignment; + } +- num -= sector_num % bs->bl.write_zeroes_alignment; + } + + /* limit request size */ +@@ -2806,16 +2813,20 @@ static int coroutine_fn bdrv_co_do_write_zeroes(BlockDriverState *bs, + /* Fall back to bounce buffer if write zeroes is unsupported */ + iov.iov_len = num * BDRV_SECTOR_SIZE; + if (iov.iov_base == NULL) { +- /* allocate bounce buffer only once and ensure that it +- * is big enough for this and all future requests. +- */ +- size_t bufsize = num <= nb_sectors ? num : max_write_zeroes; +- iov.iov_base = qemu_blockalign(bs, bufsize * BDRV_SECTOR_SIZE); +- memset(iov.iov_base, 0, bufsize * BDRV_SECTOR_SIZE); ++ iov.iov_base = qemu_blockalign(bs, num * BDRV_SECTOR_SIZE); ++ memset(iov.iov_base, 0, num * BDRV_SECTOR_SIZE); + } + qemu_iovec_init_external(&qiov, &iov, 1); + + ret = drv->bdrv_co_writev(bs, sector_num, num, &qiov); ++ ++ /* Keep bounce buffer around if it is big enough for all ++ * all future requests. ++ */ ++ if (num < max_write_zeroes) { ++ qemu_vfree(iov.iov_base); ++ iov.iov_base = NULL; ++ } + } + + sector_num += num; +-- +1.7.11.7 + diff --git a/SOURCES/kvm-block-make-bdrv_delete-static.patch b/SOURCES/kvm-block-make-bdrv_delete-static.patch new file mode 100644 index 0000000..cebae69 --- /dev/null +++ b/SOURCES/kvm-block-make-bdrv_delete-static.patch @@ -0,0 +1,665 @@ +From 52d7a3ed9170da1248cadbbc746c32dd7c34c568 Mon Sep 17 00:00:00 2001 +From: Fam Zheng +Date: Fri, 17 Jan 2014 03:07:48 +0100 +Subject: [PATCH 05/34] block: make bdrv_delete() static + +RH-Author: Fam Zheng +Message-id: <1389928083-8921-4-git-send-email-famz@redhat.com> +Patchwork-id: 56765 +O-Subject: [RHEL-7 qemu-kvm PATCH 03/18] block: make bdrv_delete() static +Bugzilla: 1041301 +RH-Acked-by: Jeffrey Cody +RH-Acked-by: Kevin Wolf +RH-Acked-by: Stefan Hajnoczi + +Manage BlockDriverState lifecycle with refcnt, so bdrv_delete() is no +longer public and should be called by bdrv_unref() if refcnt is +decreased to 0. + +This is an identical change because effectively, there's no multiple +reference of BDS now: no caller of bdrv_ref() yet, only bdrv_new() sets +bs->refcnt to 1, so all bdrv_unref() now actually delete the BDS. + +Signed-off-by: Fam Zheng +Signed-off-by: Stefan Hajnoczi +(cherry picked from commit 4f6fd3491cf0f768b135ed2e242bd1d1d2a2efec) +Signed-off-by: Fam Zheng + +Conflicts: + block/backup.c + block/blkverify.c + block/vvfat.c + blockdev.c + hw/block/xen_disk.c + qemu-io.c + +All are contextual conflicts. We are doing a mechanical replacing here, +so simply use the downstream code except replace bdrv_delete with +bdrv_unref. + +Several more bdrv_delete's are converted in qemu-img.c, qemu-io.c and +block/vhdx.c. + +Signed-off-by: Fam Zheng +--- + block.c | 23 ++++++++++++----------- + block/blkverify.c | 4 ++-- + block/cow.c | 2 +- + block/iscsi.c | 2 +- + block/mirror.c | 2 +- + block/qcow.c | 2 +- + block/qcow2.c | 2 +- + block/qed.c | 2 +- + block/sheepdog.c | 6 +++--- + block/snapshot.c | 2 +- + block/stream.c | 2 +- + block/vhdx.c | 2 +- + block/vmdk.c | 10 +++++----- + block/vvfat.c | 4 ++-- + blockdev.c | 10 +++++----- + hw/block/xen_disk.c | 4 ++-- + include/block/block.h | 1 - + qemu-img.c | 31 +++++++++++++++---------------- + qemu-io.c | 6 +++--- + 19 files changed, 58 insertions(+), 59 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + block.c | 23 ++++++++++++----------- + block/blkverify.c | 4 ++-- + block/cow.c | 2 +- + block/iscsi.c | 2 +- + block/mirror.c | 2 +- + block/qcow.c | 2 +- + block/qcow2.c | 2 +- + block/qed.c | 2 +- + block/sheepdog.c | 6 +++--- + block/snapshot.c | 2 +- + block/stream.c | 2 +- + block/vhdx.c | 2 +- + block/vmdk.c | 10 +++++----- + block/vvfat.c | 4 ++-- + blockdev.c | 10 +++++----- + hw/block/xen_disk.c | 4 ++-- + include/block/block.h | 1 - + qemu-img.c | 31 +++++++++++++++---------------- + qemu-io.c | 6 +++--- + 19 files changed, 58 insertions(+), 59 deletions(-) + +diff --git a/block.c b/block.c +index ddf29d0..b4e3ced 100644 +--- a/block.c ++++ b/block.c +@@ -918,7 +918,7 @@ fail: + if (!bs->drv) { + QDECREF(bs->options); + } +- bdrv_delete(bs); ++ bdrv_unref(bs); + return ret; + } + +@@ -972,7 +972,7 @@ int bdrv_open_backing_file(BlockDriverState *bs, QDict *options, Error **errp) + *backing_filename ? backing_filename : NULL, options, + back_flags, back_drv, &local_err); + if (ret < 0) { +- bdrv_delete(bs->backing_hd); ++ bdrv_unref(bs->backing_hd); + bs->backing_hd = NULL; + bs->open_flags |= BDRV_O_NO_BACKING; + error_propagate(errp, local_err); +@@ -1051,12 +1051,12 @@ int bdrv_open(BlockDriverState *bs, const char *filename, QDict *options, + bs1 = bdrv_new(""); + ret = bdrv_open(bs1, filename, NULL, 0, drv, &local_err); + if (ret < 0) { +- bdrv_delete(bs1); ++ bdrv_unref(bs1); + goto fail; + } + total_size = bdrv_getlength(bs1) & BDRV_SECTOR_MASK; + +- bdrv_delete(bs1); ++ bdrv_unref(bs1); + + ret = get_tmp_filename(tmp_filename, sizeof(tmp_filename)); + if (ret < 0) { +@@ -1137,7 +1137,7 @@ int bdrv_open(BlockDriverState *bs, const char *filename, QDict *options, + } + + if (bs->file != file) { +- bdrv_delete(file); ++ bdrv_unref(file); + file = NULL; + } + +@@ -1177,7 +1177,7 @@ int bdrv_open(BlockDriverState *bs, const char *filename, QDict *options, + + unlink_and_fail: + if (file != NULL) { +- bdrv_delete(file); ++ bdrv_unref(file); + } + if (bs->is_temporary) { + unlink(filename); +@@ -1444,7 +1444,7 @@ void bdrv_close(BlockDriverState *bs) + + if (bs->drv) { + if (bs->backing_hd) { +- bdrv_delete(bs->backing_hd); ++ bdrv_unref(bs->backing_hd); + bs->backing_hd = NULL; + } + bs->drv->bdrv_close(bs); +@@ -1469,7 +1469,7 @@ void bdrv_close(BlockDriverState *bs) + bs->options = NULL; + + if (bs->file != NULL) { +- bdrv_delete(bs->file); ++ bdrv_unref(bs->file); + bs->file = NULL; + } + } +@@ -1667,11 +1667,12 @@ void bdrv_append(BlockDriverState *bs_new, BlockDriverState *bs_top) + bs_new->drv ? bs_new->drv->format_name : ""); + } + +-void bdrv_delete(BlockDriverState *bs) ++static void bdrv_delete(BlockDriverState *bs) + { + assert(!bs->dev); + assert(!bs->job); + assert(!bs->in_use); ++ assert(!bs->refcnt); + + /* remove from list, if necessary */ + bdrv_make_anon(bs); +@@ -2247,7 +2248,7 @@ int bdrv_drop_intermediate(BlockDriverState *active, BlockDriverState *top, + QSIMPLEQ_FOREACH_SAFE(intermediate_state, &states_to_delete, entry, next) { + /* so that bdrv_close() does not recursively close the chain */ + intermediate_state->bs->backing_hd = NULL; +- bdrv_delete(intermediate_state->bs); ++ bdrv_unref(intermediate_state->bs); + } + ret = 0; + +@@ -4989,7 +4990,7 @@ out: + free_option_parameters(param); + + if (bs) { +- bdrv_delete(bs); ++ bdrv_unref(bs); + } + if (error_is_set(&local_err)) { + error_propagate(errp, local_err); +diff --git a/block/blkverify.c b/block/blkverify.c +index 92a452d..4ff7688 100644 +--- a/block/blkverify.c ++++ b/block/blkverify.c +@@ -159,7 +159,7 @@ static int blkverify_open(BlockDriverState *bs, QDict *options, int flags, + ret = bdrv_open(s->test_file, filename, NULL, flags, NULL, &local_err); + if (ret < 0) { + error_propagate(errp, local_err); +- bdrv_delete(s->test_file); ++ bdrv_unref(s->test_file); + s->test_file = NULL; + goto fail; + } +@@ -173,7 +173,7 @@ static void blkverify_close(BlockDriverState *bs) + { + BDRVBlkverifyState *s = bs->opaque; + +- bdrv_delete(s->test_file); ++ bdrv_unref(s->test_file); + s->test_file = NULL; + } + +diff --git a/block/cow.c b/block/cow.c +index cb9a3b0..909c3e7 100644 +--- a/block/cow.c ++++ b/block/cow.c +@@ -360,7 +360,7 @@ static int cow_create(const char *filename, QEMUOptionParameter *options, + } + + exit: +- bdrv_delete(cow_bs); ++ bdrv_unref(cow_bs); + return ret; + } + +diff --git a/block/iscsi.c b/block/iscsi.c +index fce909b..fa6f7c4 100644 +--- a/block/iscsi.c ++++ b/block/iscsi.c +@@ -1576,7 +1576,7 @@ out: + } + g_free(bs->opaque); + bs->opaque = NULL; +- bdrv_delete(bs); ++ bdrv_unref(bs); + return ret; + } + +diff --git a/block/mirror.c b/block/mirror.c +index 6fa733e..6843e70 100644 +--- a/block/mirror.c ++++ b/block/mirror.c +@@ -480,7 +480,7 @@ immediate_exit: + bdrv_swap(s->target, s->common.bs); + } + bdrv_close(s->target); +- bdrv_delete(s->target); ++ bdrv_unref(s->target); + block_job_completed(&s->common, ret); + } + +diff --git a/block/qcow.c b/block/qcow.c +index 6bc2358..c470e05 100644 +--- a/block/qcow.c ++++ b/block/qcow.c +@@ -765,7 +765,7 @@ static int qcow_create(const char *filename, QEMUOptionParameter *options, + g_free(tmp); + ret = 0; + exit: +- bdrv_delete(qcow_bs); ++ bdrv_unref(qcow_bs); + return ret; + } + +diff --git a/block/qcow2.c b/block/qcow2.c +index 3f7fd51..f6307af 100644 +--- a/block/qcow2.c ++++ b/block/qcow2.c +@@ -1591,7 +1591,7 @@ static int qcow2_create2(const char *filename, int64_t total_size, + + ret = 0; + out: +- bdrv_delete(bs); ++ bdrv_unref(bs); + return ret; + } + +diff --git a/block/qed.c b/block/qed.c +index 0805ba3..fb8ccd5 100644 +--- a/block/qed.c ++++ b/block/qed.c +@@ -607,7 +607,7 @@ static int qed_create(const char *filename, uint32_t cluster_size, + ret = 0; /* success */ + out: + g_free(l1_table); +- bdrv_delete(bs); ++ bdrv_unref(bs); + return ret; + } + +diff --git a/block/sheepdog.c b/block/sheepdog.c +index 09203ad..b3a2ae8 100644 +--- a/block/sheepdog.c ++++ b/block/sheepdog.c +@@ -1451,7 +1451,7 @@ static int sd_prealloc(const char *filename) + } + out: + if (bs) { +- bdrv_delete(bs); ++ bdrv_unref(bs); + } + g_free(buf); + +@@ -1534,13 +1534,13 @@ static int sd_create(const char *filename, QEMUOptionParameter *options, + + if (!is_snapshot(&s->inode)) { + error_report("cannot clone from a non snapshot vdi"); +- bdrv_delete(bs); ++ bdrv_unref(bs); + ret = -EINVAL; + goto out; + } + + base_vid = s->inode.vdi_id; +- bdrv_delete(bs); ++ bdrv_unref(bs); + } + + ret = do_sd_create(s, vdi, vdi_size, base_vid, &vid, 0); +diff --git a/block/snapshot.c b/block/snapshot.c +index 51b4b96..b2d7681 100644 +--- a/block/snapshot.c ++++ b/block/snapshot.c +@@ -99,7 +99,7 @@ int bdrv_snapshot_goto(BlockDriverState *bs, + ret = bdrv_snapshot_goto(bs->file, snapshot_id); + open_ret = drv->bdrv_open(bs, NULL, bs->open_flags, NULL); + if (open_ret < 0) { +- bdrv_delete(bs->file); ++ bdrv_unref(bs->file); + bs->drv = NULL; + return open_ret; + } +diff --git a/block/stream.c b/block/stream.c +index cbae815..82fb179 100644 +--- a/block/stream.c ++++ b/block/stream.c +@@ -68,7 +68,7 @@ static void close_unused_images(BlockDriverState *top, BlockDriverState *base, + unused = intermediate; + intermediate = intermediate->backing_hd; + unused->backing_hd = NULL; +- bdrv_delete(unused); ++ bdrv_unref(unused); + } + top->backing_hd = base; + } +diff --git a/block/vhdx.c b/block/vhdx.c +index 8b1a5c9..1995778 100644 +--- a/block/vhdx.c ++++ b/block/vhdx.c +@@ -1847,7 +1847,7 @@ static int vhdx_create(const char *filename, QEMUOptionParameter *options, + + + delete_and_exit: +- bdrv_delete(bs); ++ bdrv_unref(bs); + exit: + g_free(creator); + return ret; +diff --git a/block/vmdk.c b/block/vmdk.c +index 8662016..a1994a4 100644 +--- a/block/vmdk.c ++++ b/block/vmdk.c +@@ -219,7 +219,7 @@ static void vmdk_free_extents(BlockDriverState *bs) + g_free(e->l1_backup_table); + g_free(e->type); + if (e->file != bs->file) { +- bdrv_delete(e->file); ++ bdrv_unref(e->file); + } + } + g_free(s->extents); +@@ -784,7 +784,7 @@ static int vmdk_parse_extents(const char *desc, BlockDriverState *bs, + /* SPARSE extent and VMFSSPARSE extent are both "COWD" sparse file*/ + ret = vmdk_open_sparse(bs, extent_file, bs->open_flags, errp); + if (ret) { +- bdrv_delete(extent_file); ++ bdrv_unref(extent_file); + return ret; + } + extent = &s->extents[s->num_extents - 1]; +@@ -1703,15 +1703,15 @@ static int vmdk_create(const char *filename, QEMUOptionParameter *options, + BlockDriverState *bs = bdrv_new(""); + ret = bdrv_open(bs, backing_file, NULL, 0, NULL, errp); + if (ret != 0) { +- bdrv_delete(bs); ++ bdrv_unref(bs); + return ret; + } + if (strcmp(bs->drv->format_name, "vmdk")) { +- bdrv_delete(bs); ++ bdrv_unref(bs); + return -EINVAL; + } + parent_cid = vmdk_read_cid(bs, 0); +- bdrv_delete(bs); ++ bdrv_unref(bs); + snprintf(parent_desc_line, sizeof(parent_desc_line), + "parentFileNameHint=\"%s\"", backing_file); + } +diff --git a/block/vvfat.c b/block/vvfat.c +index 2c7970d..3ddaa0b 100644 +--- a/block/vvfat.c ++++ b/block/vvfat.c +@@ -2896,7 +2896,7 @@ static int write_target_commit(BlockDriverState *bs, int64_t sector_num, + + static void write_target_close(BlockDriverState *bs) { + BDRVVVFATState* s = *((BDRVVVFATState**) bs->opaque); +- bdrv_delete(s->qcow); ++ bdrv_unref(s->qcow); + g_free(s->qcow_filename); + } + +@@ -2943,7 +2943,7 @@ static int enable_write_target(BDRVVVFATState *s) + if (ret < 0) { + qerror_report_err(local_err); + error_free(local_err); +- bdrv_delete(s->qcow); ++ bdrv_unref(s->qcow); + goto err; + } + +diff --git a/blockdev.c b/blockdev.c +index 93fb339..564262a 100644 +--- a/blockdev.c ++++ b/blockdev.c +@@ -221,7 +221,7 @@ static void drive_uninit(DriveInfo *dinfo) + qemu_opts_del(dinfo->opts); + } + +- bdrv_delete(dinfo->bdrv); ++ bdrv_unref(dinfo->bdrv); + g_free(dinfo->id); + QTAILQ_REMOVE(&drives, dinfo, next); + g_free(dinfo->serial); +@@ -531,7 +531,7 @@ static DriveInfo *blockdev_init(QDict *bs_opts, + return dinfo; + + err: +- bdrv_delete(dinfo->bdrv); ++ bdrv_unref(dinfo->bdrv); + g_free(dinfo->id); + QTAILQ_REMOVE(&drives, dinfo, next); + g_free(dinfo); +@@ -1086,7 +1086,7 @@ static void external_snapshot_abort(BlkTransactionStates *common) + ExternalSnapshotStates *states = + DO_UPCAST(ExternalSnapshotStates, common, common); + if (states->new_bs) { +- bdrv_delete(states->new_bs); ++ bdrv_unref(states->new_bs); + } + } + +@@ -1645,7 +1645,7 @@ void qmp_drive_mirror(const char *device, const char *target, + ret = bdrv_open(target_bs, target, NULL, flags | BDRV_O_NO_BACKING, drv, + &local_err); + if (ret < 0) { +- bdrv_delete(target_bs); ++ bdrv_unref(target_bs); + error_propagate(errp, local_err); + return; + } +@@ -1654,7 +1654,7 @@ void qmp_drive_mirror(const char *device, const char *target, + on_source_error, on_target_error, + block_job_cb, bs, &local_err); + if (local_err != NULL) { +- bdrv_delete(target_bs); ++ bdrv_unref(target_bs); + error_propagate(errp, local_err); + return; + } +diff --git a/hw/block/xen_disk.c b/hw/block/xen_disk.c +index 498f2e9..138ab94 100644 +--- a/hw/block/xen_disk.c ++++ b/hw/block/xen_disk.c +@@ -806,7 +806,7 @@ static int blk_connect(struct XenDevice *xendev) + xen_be_printf(&blkdev->xendev, 0, "error: %s\n", + error_get_pretty(local_err)); + error_free(local_err); +- bdrv_delete(blkdev->bs); ++ bdrv_unref(blkdev->bs); + blkdev->bs = NULL; + } + } +@@ -924,7 +924,7 @@ static void blk_disconnect(struct XenDevice *xendev) + /* close/delete only if we created it ourself */ + bdrv_close(blkdev->bs); + bdrv_detach_dev(blkdev->bs, blkdev); +- bdrv_delete(blkdev->bs); ++ bdrv_unref(blkdev->bs); + } + blkdev->bs = NULL; + } +diff --git a/include/block/block.h b/include/block/block.h +index a3b7395..d20d63e 100644 +--- a/include/block/block.h ++++ b/include/block/block.h +@@ -182,7 +182,6 @@ BlockDriverState *bdrv_new(const char *device_name); + void bdrv_make_anon(BlockDriverState *bs); + void bdrv_swap(BlockDriverState *bs_new, BlockDriverState *bs_old); + void bdrv_append(BlockDriverState *bs_new, BlockDriverState *bs_top); +-void bdrv_delete(BlockDriverState *bs); + int bdrv_parse_cache_flags(const char *mode, int *flags); + int bdrv_parse_discard_flags(const char *mode, int *flags); + int bdrv_file_open(BlockDriverState **pbs, const char *filename, +diff --git a/qemu-img.c b/qemu-img.c +index f0f70e4..bc48dc1 100644 +--- a/qemu-img.c ++++ b/qemu-img.c +@@ -305,7 +305,7 @@ static BlockDriverState *bdrv_new_open(const char *filename, + return bs; + fail: + if (bs) { +- bdrv_delete(bs); ++ bdrv_unref(bs); + } + return NULL; + } +@@ -658,7 +658,7 @@ static int img_check(int argc, char **argv) + + fail: + qapi_free_ImageCheck(check); +- bdrv_delete(bs); ++ bdrv_unref(bs); + + return ret; + } +@@ -728,7 +728,7 @@ static int img_commit(int argc, char **argv) + break; + } + +- bdrv_delete(bs); ++ bdrv_unref(bs); + if (ret) { + return 1; + } +@@ -1110,11 +1110,11 @@ static int img_compare(int argc, char **argv) + ret = 0; + + out: +- bdrv_delete(bs2); ++ bdrv_unref(bs2); + qemu_vfree(buf1); + qemu_vfree(buf2); + out2: +- bdrv_delete(bs1); ++ bdrv_unref(bs1); + out3: + qemu_progress_end(); + return ret; +@@ -1595,12 +1595,12 @@ out: + free_option_parameters(param); + qemu_vfree(buf); + if (out_bs) { +- bdrv_delete(out_bs); ++ bdrv_unref(out_bs); + } + if (bs) { + for (bs_i = 0; bs_i < bs_n; bs_i++) { + if (bs[bs_i]) { +- bdrv_delete(bs[bs_i]); ++ bdrv_unref(bs[bs_i]); + } + } + g_free(bs); +@@ -1738,7 +1738,7 @@ static ImageInfoList *collect_image_info_list(const char *filename, + *last = elem; + last = &elem->next; + +- bdrv_delete(bs); ++ bdrv_unref(bs); + + filename = fmt = NULL; + if (chain) { +@@ -2024,8 +2024,7 @@ static int img_map(int argc, char **argv) + dump_map_entry(output_format, &curr, NULL); + + out: +- bdrv_close(bs); +- bdrv_delete(bs); ++ bdrv_unref(bs); + return ret < 0; + } + +@@ -2144,7 +2143,7 @@ static int img_snapshot(int argc, char **argv) + } + + /* Cleanup */ +- bdrv_delete(bs); ++ bdrv_unref(bs); + if (ret) { + return 1; + } +@@ -2428,14 +2427,14 @@ out: + /* Cleanup */ + if (!unsafe) { + if (bs_old_backing != NULL) { +- bdrv_delete(bs_old_backing); ++ bdrv_unref(bs_old_backing); + } + if (bs_new_backing != NULL) { +- bdrv_delete(bs_new_backing); ++ bdrv_unref(bs_new_backing); + } + } + +- bdrv_delete(bs); ++ bdrv_unref(bs); + if (ret) { + return 1; + } +@@ -2558,7 +2557,7 @@ static int img_resize(int argc, char **argv) + } + out: + if (bs) { +- bdrv_delete(bs); ++ bdrv_unref(bs); + } + if (ret) { + return 1; +@@ -2640,7 +2639,7 @@ static int img_amend(int argc, char **argv) + + out: + if (bs) { +- bdrv_delete(bs); ++ bdrv_unref(bs); + } + free_option_parameters(create_options); + free_option_parameters(options_param); +diff --git a/qemu-io.c b/qemu-io.c +index 64b060c..7e258a5 100644 +--- a/qemu-io.c ++++ b/qemu-io.c +@@ -1761,7 +1761,7 @@ static const cmdinfo_t abort_cmd = { + + static int close_f(int argc, char **argv) + { +- bdrv_delete(bs); ++ bdrv_unref(bs); + bs = NULL; + return 0; + } +@@ -1796,7 +1796,7 @@ static int openfile(char *name, int flags, int growable, QDict *opts) + fprintf(stderr, "%s: can't open device %s: %s\n", progname, name, + error_get_pretty(local_err)); + error_free(local_err); +- bdrv_delete(bs); ++ bdrv_unref(bs); + bs = NULL; + return 1; + } +@@ -2072,7 +2072,7 @@ int main(int argc, char **argv) + bdrv_drain_all(); + + if (bs) { +- bdrv_delete(bs); ++ bdrv_unref(bs); + } + return 0; + } +-- +1.7.1 + diff --git a/SOURCES/kvm-block-qemu-iotests-add-quotes-to-TEST_IMG-usage-in-0.patch b/SOURCES/kvm-block-qemu-iotests-add-quotes-to-TEST_IMG-usage-in-0.patch new file mode 100644 index 0000000..b043434 --- /dev/null +++ b/SOURCES/kvm-block-qemu-iotests-add-quotes-to-TEST_IMG-usage-in-0.patch @@ -0,0 +1,54 @@ +From 37f496947f6acfc92c7a2d62925b0a8a1ed71a82 Mon Sep 17 00:00:00 2001 +From: Jeffrey Cody +Date: Wed, 20 Nov 2013 19:43:48 +0100 +Subject: [PATCH 05/25] block: qemu-iotests, add quotes to $TEST_IMG usage in 019 + +RH-Author: Jeffrey Cody +Message-id: <5e5cffb85c88a8d5b3d77ac793f8c12f17c12741.1384975172.git.jcody@redhat.com> +Patchwork-id: 55798 +O-Subject: [RHEL7 qemu-kvm PATCH 05/26] block: qemu-iotests, add quotes to $TEST_IMG usage in 019 +Bugzilla: 879234 +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Fam Zheng + +There were still instances of $TEST_IMG not being properly quoted. +This was in the usage of a string built up for a 'for' loop; modify +the loop so we can quote $TEST_IMG properly. + +Signed-off-by: Jeff Cody +Reviewed-by: Eric Blake +Signed-off-by: Stefan Hajnoczi +(cherry picked from commit 3cbe3e8d25529ecb4e1838d1c6856e199b3a66d4) +--- + tests/qemu-iotests/019 | 6 +++--- + 1 file changed, 3 insertions(+), 3 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + tests/qemu-iotests/019 | 6 +++--- + 1 files changed, 3 insertions(+), 3 deletions(-) + +diff --git a/tests/qemu-iotests/019 b/tests/qemu-iotests/019 +index cd3582c..5bb18d0 100755 +--- a/tests/qemu-iotests/019 ++++ b/tests/qemu-iotests/019 +@@ -90,12 +90,12 @@ mv "$TEST_IMG" "$TEST_IMG.orig" + # Test the conversion twice: One test with the old-style -B option and another + # one with -o backing_file + +-for backing_option in "-B $TEST_IMG.base" "-o backing_file=$TEST_IMG.base"; do ++for backing_option in "-B " "-o backing_file="; do + + echo +- echo Testing conversion with $backing_option | _filter_testdir | _filter_imgfmt ++ echo Testing conversion with $backing_option$TEST_IMG.base | _filter_testdir | _filter_imgfmt + echo +- $QEMU_IMG convert -O $IMGFMT $backing_option "$TEST_IMG.orig" "$TEST_IMG" ++ $QEMU_IMG convert -O $IMGFMT $backing_option"$TEST_IMG.base" "$TEST_IMG.orig" "$TEST_IMG" + + echo "Checking if backing clusters are allocated when they shouldn't" + echo +-- +1.7.1 + diff --git a/SOURCES/kvm-block-qemu-iotests-add-quotes-to-TEST_IMG-usage-io-p.patch b/SOURCES/kvm-block-qemu-iotests-add-quotes-to-TEST_IMG-usage-io-p.patch new file mode 100644 index 0000000..f8548b8 --- /dev/null +++ b/SOURCES/kvm-block-qemu-iotests-add-quotes-to-TEST_IMG-usage-io-p.patch @@ -0,0 +1,79 @@ +From b592b76b870d07c394156192913924af7d1a8079 Mon Sep 17 00:00:00 2001 +From: Jeffrey Cody +Date: Wed, 20 Nov 2013 19:43:45 +0100 +Subject: [PATCH 02/25] block: qemu-iotests, add quotes to $TEST_IMG usage io pattern tests + +RH-Author: Jeffrey Cody +Message-id: <0ff2c944dec278cb605a62a3ec55fd0a57432ecf.1384975172.git.jcody@redhat.com> +Patchwork-id: 55795 +O-Subject: [RHEL7 qemu-kvm PATCH 02/26] block: qemu-iotests, add quotes to $TEST_IMG usage io pattern tests +Bugzilla: 879234 +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Fam Zheng + +The usage of $TEST_IMG was not properly quoted everywhere in +common.pattern. + +Signed-off-by: Jeff Cody +Reviewed-by: Eric Blake +Signed-off-by: Stefan Hajnoczi +(cherry picked from commit 0084043888f6773d905c1b5d644b89c79d1c7714) +--- + tests/qemu-iotests/common.pattern | 12 ++++++------ + 1 file changed, 6 insertions(+), 6 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + tests/qemu-iotests/common.pattern | 12 ++++++------ + 1 files changed, 6 insertions(+), 6 deletions(-) + +diff --git a/tests/qemu-iotests/common.pattern b/tests/qemu-iotests/common.pattern +index 00e0f60..ddfbca1 100644 +--- a/tests/qemu-iotests/common.pattern ++++ b/tests/qemu-iotests/common.pattern +@@ -28,7 +28,7 @@ function do_is_allocated() { + } + + function is_allocated() { +- do_is_allocated "$@" | $QEMU_IO $TEST_IMG | _filter_qemu_io ++ do_is_allocated "$@" | $QEMU_IO "$TEST_IMG" | _filter_qemu_io + } + + function do_io() { +@@ -46,18 +46,18 @@ function do_io() { + } + + function io_pattern() { +- do_io "$@" | $QEMU_IO $TEST_IMG | _filter_qemu_io ++ do_io "$@" | $QEMU_IO "$TEST_IMG" | _filter_qemu_io + } + + function io() { + local start=$2 + local pattern=$(( (start >> 9) % 256 )) + +- do_io "$@" $pattern | $QEMU_IO $TEST_IMG | _filter_qemu_io ++ do_io "$@" $pattern | $QEMU_IO "$TEST_IMG" | _filter_qemu_io + } + + function io_zero() { +- do_io "$@" 0 | $QEMU_IO $TEST_IMG | _filter_qemu_io ++ do_io "$@" 0 | $QEMU_IO "$TEST_IMG" | _filter_qemu_io + } + + function io_test() { +@@ -117,8 +117,8 @@ function io_test2() { + echo === Clusters to be compressed [3] + io_pattern writev $((offset + 8 * $cluster_size)) $cluster_size $((9 * $cluster_size)) $num 165 + +- mv $TEST_IMG $TEST_IMG.orig +- $QEMU_IMG convert -f $IMGFMT -O $IMGFMT -c $TEST_IMG.orig $TEST_IMG ++ mv "$TEST_IMG" "$TEST_IMG.orig" ++ $QEMU_IMG convert -f $IMGFMT -O $IMGFMT -c "$TEST_IMG.orig" "$TEST_IMG" + + # Write the used clusters + echo === Used clusters [1] +-- +1.7.1 + diff --git a/SOURCES/kvm-block-qemu-iotests-add-quotes-to-TEST_IMG.base-usage.patch b/SOURCES/kvm-block-qemu-iotests-add-quotes-to-TEST_IMG.base-usage.patch new file mode 100644 index 0000000..c61f197 --- /dev/null +++ b/SOURCES/kvm-block-qemu-iotests-add-quotes-to-TEST_IMG.base-usage.patch @@ -0,0 +1,46 @@ +From 7e3c22ba8ef0cda6b963a630e75fcff2c501a4bc Mon Sep 17 00:00:00 2001 +From: Jeffrey Cody +Date: Wed, 20 Nov 2013 19:43:47 +0100 +Subject: [PATCH 04/25] block: qemu-iotests, add quotes to $TEST_IMG.base usage in 017 + +RH-Author: Jeffrey Cody +Message-id: <06ac39b0b706052e005be10e809d79eb633ebe5f.1384975172.git.jcody@redhat.com> +Patchwork-id: 55797 +O-Subject: [RHEL7 qemu-kvm PATCH 04/26] block: qemu-iotests, add quotes to $TEST_IMG.base usage in 017 +Bugzilla: 879234 +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Fam Zheng + +$TEST_IMG.base is used unquoted. Add quotes so that pathnames with +spaces are supported. + +Signed-off-by: Jeff Cody +Reviewed-by: Eric Blake +Signed-off-by: Stefan Hajnoczi +(cherry picked from commit 02cde1688131090d3abb2f210e30a44d96804167) +--- + tests/qemu-iotests/017 | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +Signed-off-by: Miroslav Rezanina +--- + tests/qemu-iotests/017 | 2 +- + 1 files changed, 1 insertions(+), 1 deletions(-) + +diff --git a/tests/qemu-iotests/017 b/tests/qemu-iotests/017 +index 45f2c0b..aba3faf 100755 +--- a/tests/qemu-iotests/017 ++++ b/tests/qemu-iotests/017 +@@ -66,7 +66,7 @@ echo "Creating test image with backing file" + echo + + TEST_IMG=$TEST_IMG_SAVE +-_make_test_img -b $TEST_IMG.base 6G ++_make_test_img -b "$TEST_IMG.base" 6G + + echo "Filling test image" + echo +-- +1.7.1 + diff --git a/SOURCES/kvm-block-qemu-iotests-fix-_make_test_img-to-work-with-s.patch b/SOURCES/kvm-block-qemu-iotests-fix-_make_test_img-to-work-with-s.patch new file mode 100644 index 0000000..33187e5 --- /dev/null +++ b/SOURCES/kvm-block-qemu-iotests-fix-_make_test_img-to-work-with-s.patch @@ -0,0 +1,72 @@ +From 2235c9a514307669f458b5490f127c6e11989a99 Mon Sep 17 00:00:00 2001 +From: Jeffrey Cody +Date: Wed, 20 Nov 2013 19:43:46 +0100 +Subject: [PATCH 03/25] block: qemu-iotests, fix _make_test_img() to work with spaced pathnames + +RH-Author: Jeffrey Cody +Message-id: <4c889b5de385100b5406f2cab6dfffd04936e666.1384975172.git.jcody@redhat.com> +Patchwork-id: 55796 +O-Subject: [RHEL7 qemu-kvm PATCH 03/26] block: qemu-iotests, fix _make_test_img() to work with spaced pathnames +Bugzilla: 879234 +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Fam Zheng + +_make_test_img() currently works with spaced pathnames only when not +specifying a backing file. This fixes it so that the backing file +argument is properly quoted. + +Signed-off-by: Jeff Cody +Reviewed-by: Eric Blake +Signed-off-by: Stefan Hajnoczi +(cherry picked from commit 0018c03f5d37f3a7df23eef0e9f1e6e6189ed634) +--- + tests/qemu-iotests/common.rc | 13 +++++++++++-- + 1 file changed, 11 insertions(+), 2 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + tests/qemu-iotests/common.rc | 13 +++++++++++-- + 1 files changed, 11 insertions(+), 2 deletions(-) + +diff --git a/tests/qemu-iotests/common.rc b/tests/qemu-iotests/common.rc +index 4e82604..d24de2c 100644 +--- a/tests/qemu-iotests/common.rc ++++ b/tests/qemu-iotests/common.rc +@@ -111,6 +111,8 @@ _make_test_img() + local image_size=$* + local optstr="" + local img_name="" ++ local use_backing=0 ++ local backing_file="" + + if [ -n "$TEST_IMG_FILE" ]; then + img_name=$TEST_IMG_FILE +@@ -123,7 +125,8 @@ _make_test_img() + fi + + if [ "$1" = "-b" ]; then +- extra_img_options="$1 $2" ++ use_backing=1 ++ backing_file=$2 + image_size=$3 + fi + if [ \( "$IMGFMT" = "qcow2" -o "$IMGFMT" = "qed" \) -a -n "$CLUSTER_SIZE" ]; then +@@ -135,7 +138,13 @@ _make_test_img() + fi + + # XXX(hch): have global image options? +- $QEMU_IMG create -f $IMGFMT $extra_img_options $img_name $image_size 2>&1 | \ ++ ( ++ if [ $use_backing = 1 ]; then ++ $QEMU_IMG create -f $IMGFMT $extra_img_options -b "$backing_file" "$img_name" $image_size 2>&1 ++ else ++ $QEMU_IMG create -f $IMGFMT $extra_img_options "$img_name" $image_size 2>&1 ++ fi ++ ) | \ + sed -e "s#$IMGPROTO:$TEST_DIR#TEST_DIR#g" \ + -e "s#$TEST_DIR#TEST_DIR#g" \ + -e "s#$IMGFMT#IMGFMT#g" \ +-- +1.7.1 + diff --git a/SOURCES/kvm-block-qemu-iotests-for-vhdx-add-write-test-support.patch b/SOURCES/kvm-block-qemu-iotests-for-vhdx-add-write-test-support.patch new file mode 100644 index 0000000..f16ee6a --- /dev/null +++ b/SOURCES/kvm-block-qemu-iotests-for-vhdx-add-write-test-support.patch @@ -0,0 +1,104 @@ +From 445ea167eadbc4b951b46c8a2ab52cc0ce681aac Mon Sep 17 00:00:00 2001 +From: Jeffrey Cody +Date: Wed, 20 Nov 2013 19:44:07 +0100 +Subject: [PATCH 24/25] block: qemu-iotests for vhdx, add write test support + +RH-Author: Jeffrey Cody +Message-id: +Patchwork-id: 55817 +O-Subject: [RHEL7 qemu-kvm PATCH 24/26] block: qemu-iotests for vhdx, add write test support +Bugzilla: 879234 +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Fam Zheng + +This removes the IMGFMT_GENERIC blocker for read-only, so existing +iotests run read/write tests for vhdx images created by qemu-img (e.g. +tests 001, 002, 003). + +In addition, this updates the sample image test for the Hyper-V +created image, to verify we can write it as well. + +Signed-off-by: Jeff Cody +Signed-off-by: Stefan Hajnoczi +(cherry picked from commit 751aec24cdcd4359b5927df5cebfe6b8d3e74515) + +RHEL7 Note: Difference from upstream - there was a typo in this patch, + that used 'MM' instead of 'M' for size passed into qemu-io. + Upstream apparently gobbles the extra 'M' without error, + but RHEL7 does not. Fix this so that test 064 passes. + +Signed-off-by: Jeff Cody +--- + tests/qemu-iotests/064 | 11 +++++++++++ + tests/qemu-iotests/064.out | 14 ++++++++++++++ + tests/qemu-iotests/common | 1 - + 3 files changed, 25 insertions(+), 1 deletion(-) + +Signed-off-by: Miroslav Rezanina +--- + tests/qemu-iotests/064 | 11 +++++++++++ + tests/qemu-iotests/064.out | 14 ++++++++++++++ + tests/qemu-iotests/common | 1 - + 3 files changed, 25 insertions(+), 1 deletions(-) + +diff --git a/tests/qemu-iotests/064 b/tests/qemu-iotests/064 +index 6789aa6..906205e 100755 +--- a/tests/qemu-iotests/064 ++++ b/tests/qemu-iotests/064 +@@ -56,6 +56,17 @@ echo + echo "=== Verify pattern 0x00, 66M - 1024M ===" + $QEMU_IO -r -c "read -pP 0x00 66M 958M" "$TEST_IMG" | _filter_qemu_io + ++echo ++echo "=== Verify pattern write, 0xc3 99M-157M ===" ++$QEMU_IO -c "write -pP 0xc3 99M 58M" "$TEST_IMG" | _filter_qemu_io ++# first verify we didn't write where we should not have ++$QEMU_IO -c "read -pP 0xa5 0 33M" "$TEST_IMG" | _filter_qemu_io ++$QEMU_IO -c "read -pP 0x96 33M 33M" "$TEST_IMG" | _filter_qemu_io ++$QEMU_IO -c "read -pP 0x00 66M 33M" "$TEST_IMG" | _filter_qemu_io ++$QEMU_IO -c "read -pP 0x00 157M 867M" "$TEST_IMG" | _filter_qemu_io ++# now verify what we should have actually written ++$QEMU_IO -c "read -pP 0xc3 99M 58M" "$TEST_IMG" | _filter_qemu_io ++ + # success, all done + echo "*** done" + rm -f $seq.full +diff --git a/tests/qemu-iotests/064.out b/tests/qemu-iotests/064.out +index b9e8e4a..5346a4e 100644 +--- a/tests/qemu-iotests/064.out ++++ b/tests/qemu-iotests/064.out +@@ -11,4 +11,18 @@ read 34603008/34603008 bytes at offset 34603008 + === Verify pattern 0x00, 66M - 1024M === + read 1004535808/1004535808 bytes at offset 69206016 + 958 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) ++ ++=== Verify pattern write, 0xc3 99M-157M === ++wrote 60817408/60817408 bytes at offset 103809024 ++58 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) ++read 34603008/34603008 bytes at offset 0 ++33 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) ++read 34603008/34603008 bytes at offset 34603008 ++33 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) ++read 34603008/34603008 bytes at offset 69206016 ++33 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) ++read 909115392/909115392 bytes at offset 164626432 ++867 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) ++read 60817408/60817408 bytes at offset 103809024 ++58 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) + *** done +diff --git a/tests/qemu-iotests/common b/tests/qemu-iotests/common +index 2932e14..8cde7f1 100644 +--- a/tests/qemu-iotests/common ++++ b/tests/qemu-iotests/common +@@ -200,7 +200,6 @@ testlist options + -vhdx) + IMGFMT=vhdx + xpand=false +- IMGFMT_GENERIC=false + ;; + + -rbd) +-- +1.7.1 + diff --git a/SOURCES/kvm-block-qemu-iotests-for-vhdx-read-sample-dynamic-imag.patch b/SOURCES/kvm-block-qemu-iotests-for-vhdx-read-sample-dynamic-imag.patch new file mode 100644 index 0000000..87bd8ab --- /dev/null +++ b/SOURCES/kvm-block-qemu-iotests-for-vhdx-read-sample-dynamic-imag.patch @@ -0,0 +1,208 @@ +From 9188bcfc8f33c9340acdb6279d01d09ca6fec591 Mon Sep 17 00:00:00 2001 +From: Jeffrey Cody +Date: Wed, 20 Nov 2013 19:43:44 +0100 +Subject: [PATCH 01/25] block: qemu-iotests for vhdx, read sample dynamic image + +RH-Author: Jeffrey Cody +Message-id: +Patchwork-id: 55794 +O-Subject: [RHEL7 qemu-kvm PATCH 01/26] block: qemu-iotests for vhdx, read sample dynamic image +Bugzilla: 879234 +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Fam Zheng + +This adds the VHDX format to the qemu-iotests format, and adds +a read test. The test reads from an existing sample image, that +was created with Hyper-V under Windwos Server 2012. + +The image file is a 1GB dynamic image, with 32MB blocks. + +The pattern 0xa5 exists from 0MB-33MB (past a block size boundary) + +The pattern 0x96 exists from 33MB-66MB (past another block boundary, +and leaving a partial blank block) + +>From 66MB-1024MB, all reads should return 0. + +Although 1GB dynamic image with 66MB of data, the bzip2'ed image +file size is only 874 bytes. + +This also adds in the IMGFMT_GENERIC flag, so r/o images can be +tested (e.g. ./check -vhdx) without failing tests that assume +r/w support. + +Signed-off-by: Jeff Cody +Signed-off-by: Kevin Wolf +(cherry picked from commit 89e911816a1d5cdbc9480d5464c571d216cf5ea8) +--- + tests/qemu-iotests/064 | 62 +++++++++++++++++++++ + tests/qemu-iotests/064.out | 14 +++++ + tests/qemu-iotests/common | 8 +++ + tests/qemu-iotests/common.rc | 2 +- + tests/qemu-iotests/group | 1 + + .../sample_images/iotest-dynamic-1G.vhdx.bz2 | Bin 0 -> 874 bytes + 6 files changed, 86 insertions(+), 1 deletion(-) + create mode 100755 tests/qemu-iotests/064 + create mode 100644 tests/qemu-iotests/064.out + +Signed-off-by: Miroslav Rezanina +--- + tests/qemu-iotests/064 | 62 ++++++++++++++++++++++++++++++++++++++++++ + tests/qemu-iotests/064.out | 14 +++++++++ + tests/qemu-iotests/common | 8 +++++ + tests/qemu-iotests/common.rc | 2 +- + tests/qemu-iotests/group | 1 + + 5 files changed, 86 insertions(+), 1 deletions(-) + create mode 100755 tests/qemu-iotests/064 + create mode 100644 tests/qemu-iotests/064.out + +diff --git a/tests/qemu-iotests/064 b/tests/qemu-iotests/064 +new file mode 100755 +index 0000000..6789aa6 +--- /dev/null ++++ b/tests/qemu-iotests/064 +@@ -0,0 +1,62 @@ ++#!/bin/bash ++# ++# Test VHDX read/write from a sample image created with Hyper-V ++# ++# Copyright (C) 2013 Red Hat, Inc. ++# ++# This program is free software; you can redistribute it and/or modify ++# it under the terms of the GNU General Public License as published by ++# the Free Software Foundation; either version 2 of the License, or ++# (at your option) any later version. ++# ++# This program is distributed in the hope that it will be useful, ++# but WITHOUT ANY WARRANTY; without even the implied warranty of ++# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++# GNU General Public License for more details. ++# ++# You should have received a copy of the GNU General Public License ++# along with this program. If not, see . ++# ++ ++# creator ++owner=jcody@redhat.com ++ ++seq=`basename $0` ++echo "QA output created by $seq" ++ ++here=`pwd` ++tmp=/tmp/$$ ++status=1 # failure is the default! ++ ++_cleanup() ++{ ++ _cleanup_test_img ++} ++trap "_cleanup; exit \$status" 0 1 2 3 15 ++ ++# get standard environment, filters and checks ++. ./common.rc ++. ./common.filter ++ ++_supported_fmt vhdx ++_supported_proto generic ++_supported_os Linux ++ ++_use_sample_img iotest-dynamic-1G.vhdx.bz2 ++ ++echo ++echo "=== Verify pattern 0xa5, 0 - 33MB ===" ++$QEMU_IO -r -c "read -pP 0xa5 0 33M" "$TEST_IMG" | _filter_qemu_io ++ ++echo ++echo "=== Verify pattern 0x96, 33M - 66M ===" ++$QEMU_IO -r -c "read -pP 0x96 33M 33M" "$TEST_IMG" | _filter_qemu_io ++ ++echo ++echo "=== Verify pattern 0x00, 66M - 1024M ===" ++$QEMU_IO -r -c "read -pP 0x00 66M 958M" "$TEST_IMG" | _filter_qemu_io ++ ++# success, all done ++echo "*** done" ++rm -f $seq.full ++status=0 +diff --git a/tests/qemu-iotests/064.out b/tests/qemu-iotests/064.out +new file mode 100644 +index 0000000..b9e8e4a +--- /dev/null ++++ b/tests/qemu-iotests/064.out +@@ -0,0 +1,14 @@ ++QA output created by 064 ++ ++=== Verify pattern 0xa5, 0 - 33MB === ++read 34603008/34603008 bytes at offset 0 ++33 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) ++ ++=== Verify pattern 0x96, 33M - 66M === ++read 34603008/34603008 bytes at offset 34603008 ++33 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) ++ ++=== Verify pattern 0x00, 66M - 1024M === ++read 1004535808/1004535808 bytes at offset 69206016 ++958 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) ++*** done +diff --git a/tests/qemu-iotests/common b/tests/qemu-iotests/common +index fecaf85..2932e14 100644 +--- a/tests/qemu-iotests/common ++++ b/tests/qemu-iotests/common +@@ -45,6 +45,7 @@ valgrind=false + rm -f $tmp.list $tmp.tmp $tmp.sed + + export IMGFMT=raw ++export IMGFMT_GENERIC=true + export IMGPROTO=file + export IMGOPTS="" + export QEMU_IO_OPTIONS="" +@@ -133,6 +134,7 @@ check options + -qed test qed + -vdi test vdi + -vpc test vpc ++ -vhdx test vhdx + -vmdk test vmdk + -rbd test rbd + -sheepdog test sheepdog +@@ -195,6 +197,12 @@ testlist options + xpand=false + ;; + ++ -vhdx) ++ IMGFMT=vhdx ++ xpand=false ++ IMGFMT_GENERIC=false ++ ;; ++ + -rbd) + IMGPROTO=rbd + xpand=false +diff --git a/tests/qemu-iotests/common.rc b/tests/qemu-iotests/common.rc +index 227c003..4e82604 100644 +--- a/tests/qemu-iotests/common.rc ++++ b/tests/qemu-iotests/common.rc +@@ -339,7 +339,7 @@ _fail() + _supported_fmt() + { + for f; do +- if [ "$f" = "$IMGFMT" -o "$f" = "generic" ]; then ++ if [ "$f" = "$IMGFMT" -o "$f" = "generic" -a "$IMGFMT_GENERIC" = "true" ]; then + return + fi + done +diff --git a/tests/qemu-iotests/group b/tests/qemu-iotests/group +index 4a211bf..1a182ed 100644 +--- a/tests/qemu-iotests/group ++++ b/tests/qemu-iotests/group +@@ -64,6 +64,7 @@ + 059 rw auto + 060 rw auto + 063 rw auto ++064 rw auto + 065 rw auto + 067 rw auto + 068 rw auto +-- +1.7.1 + diff --git a/SOURCES/kvm-block-qemu-iotests-removes-duplicate-double-quotes-i.patch b/SOURCES/kvm-block-qemu-iotests-removes-duplicate-double-quotes-i.patch new file mode 100644 index 0000000..ebc3f40 --- /dev/null +++ b/SOURCES/kvm-block-qemu-iotests-removes-duplicate-double-quotes-i.patch @@ -0,0 +1,45 @@ +From 1ee66862e6dac32e76687a8a2c0bdf945c2f87d6 Mon Sep 17 00:00:00 2001 +From: Jeffrey Cody +Date: Wed, 20 Nov 2013 19:43:49 +0100 +Subject: [PATCH 06/25] block: qemu-iotests, removes duplicate double quotes in 039 + +RH-Author: Jeffrey Cody +Message-id: +Patchwork-id: 55799 +O-Subject: [RHEL7 qemu-kvm PATCH 06/26] block: qemu-iotests, removes duplicate double quotes in 039 +Bugzilla: 879234 +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Fam Zheng + +Test 039 had $TEST_IMG with duplicate double quotes - remove duplicate. + +Signed-off-by: Jeff Cody +Reviewed-by: Eric Blake +Signed-off-by: Stefan Hajnoczi +(cherry picked from commit f897e3939cbbcec26e99415a499654ae7ae09b64) +--- + tests/qemu-iotests/039 | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +Signed-off-by: Miroslav Rezanina +--- + tests/qemu-iotests/039 | 2 +- + 1 files changed, 1 insertions(+), 1 deletions(-) + +diff --git a/tests/qemu-iotests/039 b/tests/qemu-iotests/039 +index f85b4ce..8bade92 100755 +--- a/tests/qemu-iotests/039 ++++ b/tests/qemu-iotests/039 +@@ -54,7 +54,7 @@ echo "== Checking that image is clean on shutdown ==" + IMGOPTS="compat=1.1,lazy_refcounts=on" + _make_test_img $size + +-$QEMU_IO -c "write -P 0x5a 0 512" ""$TEST_IMG"" | _filter_qemu_io ++$QEMU_IO -c "write -P 0x5a 0 512" "$TEST_IMG" | _filter_qemu_io + + # The dirty bit must not be set + ./qcow2.py "$TEST_IMG" dump-header | grep incompatible_features +-- +1.7.1 + diff --git a/SOURCES/kvm-block-raw-copy-BlockLimits-on-raw_open.patch.patch.patch b/SOURCES/kvm-block-raw-copy-BlockLimits-on-raw_open.patch.patch.patch new file mode 100644 index 0000000..078fbf5 --- /dev/null +++ b/SOURCES/kvm-block-raw-copy-BlockLimits-on-raw_open.patch.patch.patch @@ -0,0 +1,49 @@ +From 42fe55d38b7b9e838d1962da6a717f765fb055d0 Mon Sep 17 00:00:00 2001 +Message-Id: <42fe55d38b7b9e838d1962da6a717f765fb055d0.1389014116.git.minovotn@redhat.com> +In-Reply-To: +References: +From: Paolo Bonzini +Date: Mon, 9 Dec 2013 14:09:01 +0100 +Subject: [PATCH 13/50] block/raw: copy BlockLimits on raw_open + +RH-Author: Paolo Bonzini +Message-id: <1386598178-11845-16-git-send-email-pbonzini@redhat.com> +Patchwork-id: 56054 +O-Subject: [RHEL 7.0 qemu-kvm PATCH 15/52] block/raw: copy BlockLimits on raw_open +Bugzilla: 1007815 +RH-Acked-by: Jeffrey Cody +RH-Acked-by: Fam Zheng +RH-Acked-by: Stefan Hajnoczi + +From: Peter Lieven + +Signed-off-by: Peter Lieven +Signed-off-by: Stefan Hajnoczi +(cherry picked from commit 04f19e4d2da4325297c99e94f20b0aca52546209) + +Conflicts: + block/raw_bsd.c [replaced by block/raw.c] +--- + block/raw.c | 1 + + 1 file changed, 1 insertion(+) + +Signed-off-by: Michal Novotny +--- + block/raw.c | 1 + + 1 file changed, 1 insertion(+) + +diff --git a/block/raw.c b/block/raw.c +index 67d6445..c853258 100644 +--- a/block/raw.c ++++ b/block/raw.c +@@ -7,6 +7,7 @@ static int raw_open(BlockDriverState *bs, QDict *options, int flags, + Error **errp) + { + bs->sg = bs->file->sg; ++ bs->bl = bs->file->bl; + return 0; + } + +-- +1.7.11.7 + diff --git a/SOURCES/kvm-block-remove-QED-.bdrv_make_empty-implementation.patch b/SOURCES/kvm-block-remove-QED-.bdrv_make_empty-implementation.patch new file mode 100644 index 0000000..cbae3e9 --- /dev/null +++ b/SOURCES/kvm-block-remove-QED-.bdrv_make_empty-implementation.patch @@ -0,0 +1,61 @@ +From ebb0a0980d8347add30842be49555e4f07a4a047 Mon Sep 17 00:00:00 2001 +From: Jeffrey Cody +Date: Tue, 11 Feb 2014 16:14:29 +0100 +Subject: [PATCH 23/28] block: remove QED .bdrv_make_empty implementation + +RH-Author: Jeffrey Cody +Message-id: <2f8e3c76feeda371ed325fb08b26f3bf7e776db3.1392134912.git.jcody@redhat.com> +Patchwork-id: 57219 +O-Subject: [RHEL7 qemu-kvm PATCH 5/6] block: remove QED .bdrv_make_empty implementation +Bugzilla: 1047254 +RH-Acked-by: Kevin Wolf +RH-Acked-by: Markus Armbruster +RH-Acked-by: Miroslav Rezanina + +The QED .bdrv_make_empty() implementation does nothing but return +-ENOTSUP, which causes problems in bdrv_commit(). Since the function +stub exists for QED, it is called, which then always returns an error. + +The proper way to not support an optional driver function stub is to +just not implement it, so let's remove the stub. + +Signed-off-by: Jeff Cody +Reviewed-by: Benoit Canet +Signed-off-by: Stefan Hajnoczi +(cherry picked from commit 55aff7f133b0eb20b2c8a2a3e1307240aab8044c) +--- + block/qed.c | 6 ------ + 1 file changed, 6 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + block/qed.c | 6 ------ + 1 files changed, 0 insertions(+), 6 deletions(-) + +diff --git a/block/qed.c b/block/qed.c +index da68152..be5945b 100644 +--- a/block/qed.c ++++ b/block/qed.c +@@ -731,11 +731,6 @@ static int64_t coroutine_fn bdrv_qed_co_get_block_status(BlockDriverState *bs, + return cb.status; + } + +-static int bdrv_qed_make_empty(BlockDriverState *bs) +-{ +- return -ENOTSUP; +-} +- + static BDRVQEDState *acb_to_s(QEDAIOCB *acb) + { + return acb->common.bs->opaque; +@@ -1617,7 +1612,6 @@ static BlockDriver bdrv_qed = { + .bdrv_create = bdrv_qed_create, + .bdrv_has_zero_init = bdrv_has_zero_init_1, + .bdrv_co_get_block_status = bdrv_qed_co_get_block_status, +- .bdrv_make_empty = bdrv_qed_make_empty, + .bdrv_aio_readv = bdrv_qed_aio_readv, + .bdrv_aio_writev = bdrv_qed_aio_writev, + .bdrv_co_write_zeroes = bdrv_qed_co_write_zeroes, +-- +1.7.1 + diff --git a/SOURCES/kvm-block-remove-qcow2-.bdrv_make_empty-implementation.patch b/SOURCES/kvm-block-remove-qcow2-.bdrv_make_empty-implementation.patch new file mode 100644 index 0000000..fed083d --- /dev/null +++ b/SOURCES/kvm-block-remove-qcow2-.bdrv_make_empty-implementation.patch @@ -0,0 +1,75 @@ +From 6470641f3ae91f9024ac19c9884a583074930c78 Mon Sep 17 00:00:00 2001 +From: Jeffrey Cody +Date: Tue, 11 Feb 2014 16:14:30 +0100 +Subject: [PATCH 24/28] block: remove qcow2 .bdrv_make_empty implementation + +RH-Author: Jeffrey Cody +Message-id: <342af85f3ded3eeaa140e44b2f4956bd6d1ee45c.1392134912.git.jcody@redhat.com> +Patchwork-id: 57220 +O-Subject: [RHEL7 qemu-kvm PATCH 6/6] block: remove qcow2 .bdrv_make_empty implementation +Bugzilla: 1047254 +RH-Acked-by: Kevin Wolf +RH-Acked-by: Markus Armbruster +RH-Acked-by: Miroslav Rezanina + +The QCOW2 .bdrv_make_empty implementation always returns 0 for success, +but does not actually do anything. + +The proper way to not support an optional driver function stub is to +just not implement it, so let's remove the stub. + +Signed-off-by: Jeff Cody +Reviewed-by: Benoit Canet +Signed-off-by: Stefan Hajnoczi +(cherry picked from commit 14b4a8b9c654b625dea0f532fae5722781fd0a7d) +--- + block/qcow2.c | 21 --------------------- + 1 file changed, 21 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + block/qcow2.c | 21 --------------------- + 1 files changed, 0 insertions(+), 21 deletions(-) + +diff --git a/block/qcow2.c b/block/qcow2.c +index 05ea0cd..25a5b5e 100644 +--- a/block/qcow2.c ++++ b/block/qcow2.c +@@ -1678,26 +1678,6 @@ static int qcow2_create(const char *filename, QEMUOptionParameter *options, + return ret; + } + +-static int qcow2_make_empty(BlockDriverState *bs) +-{ +-#if 0 +- /* XXX: not correct */ +- BDRVQcowState *s = bs->opaque; +- uint32_t l1_length = s->l1_size * sizeof(uint64_t); +- int ret; +- +- memset(s->l1_table, 0, l1_length); +- if (bdrv_pwrite(bs->file, s->l1_table_offset, s->l1_table, l1_length) < 0) +- return -1; +- ret = bdrv_truncate(bs->file, s->l1_table_offset + l1_length); +- if (ret < 0) +- return ret; +- +- l2_cache_reset(bs); +-#endif +- return 0; +-} +- + static coroutine_fn int qcow2_co_write_zeroes(BlockDriverState *bs, + int64_t sector_num, int nb_sectors, BdrvRequestFlags flags) + { +@@ -2246,7 +2226,6 @@ static BlockDriver bdrv_qcow2 = { + .bdrv_has_zero_init = bdrv_has_zero_init_1, + .bdrv_co_get_block_status = qcow2_co_get_block_status, + .bdrv_set_key = qcow2_set_key, +- .bdrv_make_empty = qcow2_make_empty, + + .bdrv_co_readv = qcow2_co_readv, + .bdrv_co_writev = qcow2_co_writev, +-- +1.7.1 + diff --git a/SOURCES/kvm-block-rename-buffer_alignment-to-guest_block_size.patch b/SOURCES/kvm-block-rename-buffer_alignment-to-guest_block_size.patch new file mode 100644 index 0000000..5b2046d --- /dev/null +++ b/SOURCES/kvm-block-rename-buffer_alignment-to-guest_block_size.patch @@ -0,0 +1,178 @@ +From 2c5f92a08224373b01d7d46053f46294fa02d00a Mon Sep 17 00:00:00 2001 +From: Kevin Wolf +Date: Tue, 29 Nov 2011 11:35:47 +0100 +Subject: [PATCH 09/37] block: rename buffer_alignment to guest_block_size + +Message-id: <1392117622-28812-10-git-send-email-kwolf@redhat.com> +Patchwork-id: 57174 +O-Subject: [RHEL-7.0 qemu-kvm PATCH v2 09/37] block: rename buffer_alignment to guest_block_size +Bugzilla: 748906 +RH-Acked-by: Laszlo Ersek +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Max Reitz + +From: Paolo Bonzini + +The alignment field is now set to the value that is promised to the +guest, rather than required by the host. The next patches will make +QEMU aware of the host-provided values, so make this clear. + +The alignment is also not about memory buffers, but about the sectors on +the disk, change the documentation of the field. + +At this point, the field is set by the device emulation, but completely +ignored by the block layer. + +Signed-off-by: Paolo Bonzini +Signed-off-by: Kevin Wolf +Reviewed-by: Wenchao Xia +Reviewed-by: Max Reitz +Reviewed-by: Benoit Canet +(cherry picked from commit 1b7fd729559c6d3b273303aa48bc653ceef08747) + +Signed-off-by: Kevin Wolf +--- + block.c | 10 +++++----- + hw/block/virtio-blk.c | 2 +- + hw/ide/core.c | 2 +- + hw/scsi/scsi-disk.c | 2 +- + hw/scsi/scsi-generic.c | 2 +- + include/block/block.h | 2 +- + include/block/block_int.h | 4 ++-- + 7 files changed, 12 insertions(+), 12 deletions(-) +--- + block.c | 10 +++++----- + hw/block/virtio-blk.c | 2 +- + hw/ide/core.c | 2 +- + hw/scsi/scsi-disk.c | 2 +- + hw/scsi/scsi-generic.c | 2 +- + include/block/block.h | 2 +- + include/block/block_int.h | 4 ++-- + 7 files changed, 12 insertions(+), 12 deletions(-) + +diff --git a/block.c b/block.c +index c85f43e..f2102bc 100644 +--- a/block.c ++++ b/block.c +@@ -779,7 +779,7 @@ static int bdrv_open_common(BlockDriverState *bs, BlockDriverState *file, + } + + bs->open_flags = flags; +- bs->buffer_alignment = 512; ++ bs->guest_block_size = 512; + bs->zero_beyond_eof = true; + open_flags = bdrv_open_flags(bs, flags); + bs->read_only = !(open_flags & BDRV_O_RDWR); +@@ -1614,7 +1614,7 @@ static void bdrv_move_feature_fields(BlockDriverState *bs_dest, + bs_dest->dev_ops = bs_src->dev_ops; + bs_dest->dev_opaque = bs_src->dev_opaque; + bs_dest->dev = bs_src->dev; +- bs_dest->buffer_alignment = bs_src->buffer_alignment; ++ bs_dest->guest_block_size = bs_src->guest_block_size; + bs_dest->copy_on_read = bs_src->copy_on_read; + + bs_dest->enable_write_cache = bs_src->enable_write_cache; +@@ -1766,7 +1766,7 @@ void bdrv_detach_dev(BlockDriverState *bs, void *dev) + bs->dev = NULL; + bs->dev_ops = NULL; + bs->dev_opaque = NULL; +- bs->buffer_alignment = 512; ++ bs->guest_block_size = 512; + } + + /* TODO change to return DeviceState * when all users are qdevified */ +@@ -4738,9 +4738,9 @@ BlockDriverAIOCB *bdrv_aio_ioctl(BlockDriverState *bs, + return NULL; + } + +-void bdrv_set_buffer_alignment(BlockDriverState *bs, int align) ++void bdrv_set_guest_block_size(BlockDriverState *bs, int align) + { +- bs->buffer_alignment = align; ++ bs->guest_block_size = align; + } + + void *qemu_blockalign(BlockDriverState *bs, size_t size) +diff --git a/hw/block/virtio-blk.c b/hw/block/virtio-blk.c +index aa37cc9..a96207d 100644 +--- a/hw/block/virtio-blk.c ++++ b/hw/block/virtio-blk.c +@@ -721,7 +721,7 @@ static int virtio_blk_device_init(VirtIODevice *vdev) + register_savevm(qdev, "virtio-blk", virtio_blk_id++, 2, + virtio_blk_save, virtio_blk_load, s); + bdrv_set_dev_ops(s->bs, &virtio_block_ops, s); +- bdrv_set_buffer_alignment(s->bs, s->conf->logical_block_size); ++ bdrv_set_guest_block_size(s->bs, s->conf->logical_block_size); + + bdrv_iostatus_enable(s->bs); + +diff --git a/hw/ide/core.c b/hw/ide/core.c +index 8b3dde6..c172c71 100644 +--- a/hw/ide/core.c ++++ b/hw/ide/core.c +@@ -2007,7 +2007,7 @@ int ide_init_drive(IDEState *s, BlockDriverState *bs, IDEDriveKind kind, + s->smart_selftest_count = 0; + if (kind == IDE_CD) { + bdrv_set_dev_ops(bs, &ide_cd_block_ops, s); +- bdrv_set_buffer_alignment(bs, 2048); ++ bdrv_set_guest_block_size(bs, 2048); + } else { + if (!bdrv_is_inserted(s->bs)) { + error_report("Device needs media, but drive is empty"); +diff --git a/hw/scsi/scsi-disk.c b/hw/scsi/scsi-disk.c +index bce617c..6491091 100644 +--- a/hw/scsi/scsi-disk.c ++++ b/hw/scsi/scsi-disk.c +@@ -2254,7 +2254,7 @@ static int scsi_initfn(SCSIDevice *dev) + } else { + bdrv_set_dev_ops(s->qdev.conf.bs, &scsi_disk_block_ops, s); + } +- bdrv_set_buffer_alignment(s->qdev.conf.bs, s->qdev.blocksize); ++ bdrv_set_guest_block_size(s->qdev.conf.bs, s->qdev.blocksize); + + bdrv_iostatus_enable(s->qdev.conf.bs); + add_boot_device_path(s->qdev.conf.bootindex, &dev->qdev, NULL); +diff --git a/hw/scsi/scsi-generic.c b/hw/scsi/scsi-generic.c +index 8f195be..f08b64e 100644 +--- a/hw/scsi/scsi-generic.c ++++ b/hw/scsi/scsi-generic.c +@@ -210,7 +210,7 @@ static void scsi_read_complete(void * opaque, int ret) + s->blocksize = ldl_be_p(&r->buf[8]); + s->max_lba = ldq_be_p(&r->buf[0]); + } +- bdrv_set_buffer_alignment(s->conf.bs, s->blocksize); ++ bdrv_set_guest_block_size(s->conf.bs, s->blocksize); + + scsi_req_data(&r->req, len); + if (!r->req.io_canceled) { +diff --git a/include/block/block.h b/include/block/block.h +index 9d1ce59..2a9aa5b 100644 +--- a/include/block/block.h ++++ b/include/block/block.h +@@ -409,7 +409,7 @@ void bdrv_img_create(const char *filename, const char *fmt, + /* Returns the alignment in bytes that is required so that no bounce buffer + * is required throughout the stack */ + size_t bdrv_opt_mem_align(BlockDriverState *bs); +-void bdrv_set_buffer_alignment(BlockDriverState *bs, int align); ++void bdrv_set_guest_block_size(BlockDriverState *bs, int align); + void *qemu_blockalign(BlockDriverState *bs, size_t size); + bool bdrv_qiov_is_aligned(BlockDriverState *bs, QEMUIOVector *qiov); + +diff --git a/include/block/block_int.h b/include/block/block_int.h +index ddbd53d..0445e6b 100644 +--- a/include/block/block_int.h ++++ b/include/block/block_int.h +@@ -307,8 +307,8 @@ struct BlockDriverState { + /* Whether produces zeros when read beyond eof */ + bool zero_beyond_eof; + +- /* the memory alignment required for the buffers handled by this driver */ +- int buffer_alignment; ++ /* the block size for which the guest device expects atomicity */ ++ int guest_block_size; + + /* do we need to tell the quest if we have a volatile write cache? */ + int enable_write_cache; +-- +1.7.1 + diff --git a/SOURCES/kvm-block-resize-backing-file-image-during-offline-commi.patch b/SOURCES/kvm-block-resize-backing-file-image-during-offline-commi.patch new file mode 100644 index 0000000..4eb8344 --- /dev/null +++ b/SOURCES/kvm-block-resize-backing-file-image-during-offline-commi.patch @@ -0,0 +1,90 @@ +From c659199f9bf37c798bd741ddd151db213d5d73f8 Mon Sep 17 00:00:00 2001 +From: Jeffrey Cody +Date: Tue, 11 Feb 2014 16:14:25 +0100 +Subject: [PATCH 19/28] block: resize backing file image during offline commit, if necessary + +RH-Author: Jeffrey Cody +Message-id: <54cb47d8cd589585e9788df80b9612ea527e193d.1392134912.git.jcody@redhat.com> +Patchwork-id: 57215 +O-Subject: [RHEL7 qemu-kvm PATCH 1/6] block: resize backing file image during offline commit, if necessary +Bugzilla: 1047254 +RH-Acked-by: Kevin Wolf +RH-Acked-by: Markus Armbruster +RH-Acked-by: Miroslav Rezanina + +Currently, if an image file is logically larger than its backing file, +committing it via 'qemu-img commit' will fail. + +For instance, if we have a base image with a virtual size 10G, and a +snapshot image of size 20G, then committing the snapshot offline with +'qemu-img commit' will likely fail. + +This will automatically attempt to resize the base image, if the +snapshot image to be committed is larger. + +Signed-off-by: Jeff Cody +Reviewed-by: Fam Zheng +Reviewed-by: Eric Blake +Reviewed-by: Benoit Canet +Signed-off-by: Kevin Wolf +(cherry picked from commit 72706ea4cd38bfcb151265df0178ba21863d7518) +--- + block.c | 28 +++++++++++++++++++++++++--- + 1 file changed, 25 insertions(+), 3 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + block.c | 28 +++++++++++++++++++++++++--- + 1 files changed, 25 insertions(+), 3 deletions(-) + +diff --git a/block.c b/block.c +index 1b57236..c7aa285 100644 +--- a/block.c ++++ b/block.c +@@ -1947,10 +1947,10 @@ int bdrv_check(BlockDriverState *bs, BdrvCheckResult *res, BdrvCheckMode fix) + int bdrv_commit(BlockDriverState *bs) + { + BlockDriver *drv = bs->drv; +- int64_t sector, total_sectors; ++ int64_t sector, total_sectors, length, backing_length; + int n, ro, open_flags; + int ret = 0; +- uint8_t *buf; ++ uint8_t *buf = NULL; + char filename[PATH_MAX]; + + if (!drv) +@@ -1975,7 +1975,29 @@ int bdrv_commit(BlockDriverState *bs) + } + } + +- total_sectors = bdrv_getlength(bs) >> BDRV_SECTOR_BITS; ++ length = bdrv_getlength(bs); ++ if (length < 0) { ++ ret = length; ++ goto ro_cleanup; ++ } ++ ++ backing_length = bdrv_getlength(bs->backing_hd); ++ if (backing_length < 0) { ++ ret = backing_length; ++ goto ro_cleanup; ++ } ++ ++ /* If our top snapshot is larger than the backing file image, ++ * grow the backing file image if possible. If not possible, ++ * we must return an error */ ++ if (length > backing_length) { ++ ret = bdrv_truncate(bs->backing_hd, length); ++ if (ret < 0) { ++ goto ro_cleanup; ++ } ++ } ++ ++ total_sectors = length >> BDRV_SECTOR_BITS; + buf = g_malloc(COMMIT_BUF_SECTORS * BDRV_SECTOR_SIZE); + + for (sector = 0; sector < total_sectors; sector += n) { +-- +1.7.1 + diff --git a/SOURCES/kvm-block-resize-backing-image-during-active-layer-commi.patch b/SOURCES/kvm-block-resize-backing-image-during-active-layer-commi.patch new file mode 100644 index 0000000..14cb1e3 --- /dev/null +++ b/SOURCES/kvm-block-resize-backing-image-during-active-layer-commi.patch @@ -0,0 +1,96 @@ +From 31c90390db10329e2e7da072492fa7ec728abed0 Mon Sep 17 00:00:00 2001 +From: Jeffrey Cody +Date: Tue, 11 Feb 2014 16:14:26 +0100 +Subject: [PATCH 20/28] block: resize backing image during active layer commit, if needed + +RH-Author: Jeffrey Cody +Message-id: +Patchwork-id: 57216 +O-Subject: [RHEL7 qemu-kvm PATCH 2/6] block: resize backing image during active layer commit, if needed +Bugzilla: 1047254 +RH-Acked-by: Kevin Wolf +RH-Acked-by: Markus Armbruster +RH-Acked-by: Miroslav Rezanina + +If the top image to commit is the active layer, and also larger than +the base image, then an I/O error will likely be returned during +block-commit. + +For instance, if we have a base image with a virtual size 10G, and a +active layer image of size 20G, then committing the snapshot via +'block-commit' will likely fail. + +This will automatically attempt to resize the base image, if the +active layer image to be committed is larger. + +Signed-off-by: Jeff Cody +Reviewed-by: Eric Blake +Reviewed-by: Benoit Canet +Signed-off-by: Kevin Wolf +(cherry picked from commit 4da83585961631bfc10831dd26c4afda2a8b23e8) +--- + block/mirror.c | 38 ++++++++++++++++++++++++++++++++++++++ + 1 file changed, 38 insertions(+) + +Signed-off-by: Miroslav Rezanina +--- + block/mirror.c | 38 ++++++++++++++++++++++++++++++++++++++ + 1 files changed, 38 insertions(+), 0 deletions(-) + +diff --git a/block/mirror.c b/block/mirror.c +index 6e1f9b1..ba1428b 100644 +--- a/block/mirror.c ++++ b/block/mirror.c +@@ -627,11 +627,49 @@ void commit_active_start(BlockDriverState *bs, BlockDriverState *base, + BlockDriverCompletionFunc *cb, + void *opaque, Error **errp) + { ++ int64_t length, base_length; ++ int orig_base_flags; ++ ++ orig_base_flags = bdrv_get_flags(base); ++ + if (bdrv_reopen(base, bs->open_flags, errp)) { + return; + } ++ ++ length = bdrv_getlength(bs); ++ if (length < 0) { ++ error_setg(errp, "Unable to determine length of %s", bs->filename); ++ goto error_restore_flags; ++ } ++ ++ base_length = bdrv_getlength(base); ++ if (base_length < 0) { ++ error_setg(errp, "Unable to determine length of %s", base->filename); ++ goto error_restore_flags; ++ } ++ ++ if (length > base_length) { ++ if (bdrv_truncate(base, length) < 0) { ++ error_setg(errp, "Top image %s is larger than base image %s, and " ++ "resize of base image failed", ++ bs->filename, base->filename); ++ goto error_restore_flags; ++ } ++ } ++ + bdrv_ref(base); + mirror_start_job(bs, base, speed, 0, 0, + on_error, on_error, cb, opaque, errp, + &commit_active_job_driver, false, base); ++ if (error_is_set(errp)) { ++ goto error_restore_flags; ++ } ++ ++ return; ++ ++error_restore_flags: ++ /* ignore error and errp for bdrv_reopen, because we want to propagate ++ * the original error */ ++ bdrv_reopen(base, orig_base_flags, NULL); ++ return; + } +-- +1.7.1 + diff --git a/SOURCES/kvm-block-stream-Don-t-stream-unbacked-devices.patch b/SOURCES/kvm-block-stream-Don-t-stream-unbacked-devices.patch new file mode 100644 index 0000000..75bd164 --- /dev/null +++ b/SOURCES/kvm-block-stream-Don-t-stream-unbacked-devices.patch @@ -0,0 +1,55 @@ +From b8159f39be879b1133ce89bcb2c892e0d6711fdb Mon Sep 17 00:00:00 2001 +From: Max Reitz +Date: Sun, 22 Dec 2013 16:12:39 +0100 +Subject: [PATCH 1/8] block/stream: Don't stream unbacked devices + +RH-Author: Max Reitz +Message-id: <1387728759-7141-2-git-send-email-mreitz@redhat.com> +Patchwork-id: 56422 +O-Subject: [RHEL-7.0 qemu-kvm PATCH] block/stream: Don't stream unbacked devices +Bugzilla: 965636 +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Fam Zheng +RH-Acked-by: Kevin Wolf + +BZ: 965636 + +If a block device is unbacked, a streaming blockjob should immediately +finish instead of beginning to try to stream, then noticing the backing +file does not contain even the first sector (since it does not exist) +and then finishing normally. + +Signed-off-by: Max Reitz +Reviewed-by: Wenchao Xia +Signed-off-by: Kevin Wolf +(cherry picked from commit f4a193e717e6b5179a2e57423bfe110b724662d8) + +Signed-off-by: Max Reitz +--- + block/stream.c | 5 +++++ + 1 file changed, 5 insertions(+) + +Signed-off-by: Miroslav Rezanina +--- + block/stream.c | 5 +++++ + 1 files changed, 5 insertions(+), 0 deletions(-) + +diff --git a/block/stream.c b/block/stream.c +index 276487c..cbae815 100644 +--- a/block/stream.c ++++ b/block/stream.c +@@ -84,6 +84,11 @@ static void coroutine_fn stream_run(void *opaque) + int n = 0; + void *buf; + ++ if (!bs->backing_hd) { ++ block_job_completed(&s->common, 0); ++ return; ++ } ++ + s->common.len = bdrv_getlength(bs); + if (s->common.len < 0) { + block_job_completed(&s->common, s->common.len); +-- +1.7.1 + diff --git a/SOURCES/kvm-block-update-block-commit-documentation-regarding-im.patch b/SOURCES/kvm-block-update-block-commit-documentation-regarding-im.patch new file mode 100644 index 0000000..fb71c3d --- /dev/null +++ b/SOURCES/kvm-block-update-block-commit-documentation-regarding-im.patch @@ -0,0 +1,156 @@ +From c7c21ebc0dcddd666c616e161b0f9bbb4ade9cf4 Mon Sep 17 00:00:00 2001 +From: Jeffrey Cody +Date: Tue, 11 Feb 2014 16:14:27 +0100 +Subject: [PATCH 21/28] block: update block commit documentation regarding image truncation + +RH-Author: Jeffrey Cody +Message-id: +Patchwork-id: 57217 +O-Subject: [RHEL7 qemu-kvm PATCH 3/6] block: update block commit documentation regarding image truncation +Bugzilla: 1047254 +RH-Acked-by: Kevin Wolf +RH-Acked-by: Markus Armbruster +RH-Acked-by: Miroslav Rezanina + +This updates the documentation for commiting snapshot images. +Specifically, this highlights what happens when the base image +is either smaller or larger than the snapshot image being committed. + +In the case of the base image being smaller, it is resized to the +larger size of the snapshot image. In the case of the base image +being larger, it is not resized automatically, but once the commit +has completed it is safe for the user to truncate the base image. + +Signed-off-by: Jeff Cody +Reviewed-by: Fam Zheng +Reviewed-by: Eric Blake +Signed-off-by: Kevin Wolf +(cherry picked from commit 37222900743962e146a82b7077a18c3f39859a19) + +Conflicts: + qmp-commands.hx + +RHEL7 Notes: Conflict is due to 2 things: 1) drive-backup + not present in RHEL7, and 2) the block job + differentiation #ifdefs. +--- + hmp-commands.hx | 5 +++++ + qapi-schema.json | 7 +++++++ + qemu-img.texi | 7 ++++++- + qmp-commands.hx | 40 ++++++++++++++++++++++++++++++++++++++++ + 4 files changed, 58 insertions(+), 1 deletion(-) + +Signed-off-by: Miroslav Rezanina +--- + hmp-commands.hx | 5 +++++ + qapi-schema.json | 7 +++++++ + qemu-img.texi | 7 ++++++- + qmp-commands.hx | 40 ++++++++++++++++++++++++++++++++++++++++ + 4 files changed, 58 insertions(+), 1 deletions(-) + +diff --git a/hmp-commands.hx b/hmp-commands.hx +index 8e08ebf..467dd70 100644 +--- a/hmp-commands.hx ++++ b/hmp-commands.hx +@@ -35,6 +35,11 @@ STEXI + @item commit + @findex commit + Commit changes to the disk images (if -snapshot is used) or backing files. ++If the backing file is smaller than the snapshot, then the backing file will be ++resized to be the same size as the snapshot. If the snapshot is smaller than ++the backing file, the backing file will not be truncated. If you want the ++backing file to match the size of the smaller snapshot, you can safely truncate ++it yourself once the commit operation successfully completes. + ETEXI + + { +diff --git a/qapi-schema.json b/qapi-schema.json +index 8b257e2..017b3b7 100644 +--- a/qapi-schema.json ++++ b/qapi-schema.json +@@ -1846,6 +1846,13 @@ + # user needs to complete the job with the block-job-complete + # command after getting the ready event. (Since 2.0) + # ++# If the base image is smaller than top, then the base image ++# will be resized to be the same size as top. If top is ++# smaller than the base image, the base will not be ++# truncated. If you want the base image size to match the ++# size of the smaller top, you can safely truncate it ++# yourself once the commit operation successfully completes. ++# + # + # @speed: #optional the maximum speed, in bytes per second + # +diff --git a/qemu-img.texi b/qemu-img.texi +index 1078791..d75a780 100644 +--- a/qemu-img.texi ++++ b/qemu-img.texi +@@ -136,7 +136,12 @@ it doesn't need to be specified separately in this case. + + @item commit [-f @var{fmt}] [-t @var{cache}] @var{filename} + +-Commit the changes recorded in @var{filename} in its base image. ++Commit the changes recorded in @var{filename} in its base image or backing file. ++If the backing file is smaller than the snapshot, then the backing file will be ++resized to be the same size as the snapshot. If the snapshot is smaller than ++the backing file, the backing file will not be truncated. If you want the ++backing file to match the size of the smaller snapshot, you can safely truncate ++it yourself once the commit operation successfully completes. + + @item compare [-f @var{fmt}] [-F @var{fmt}] [-p] [-s] [-q] @var{filename1} @var{filename2} + +diff --git a/qmp-commands.hx b/qmp-commands.hx +index 7a1bfd4..08a01ee 100644 +--- a/qmp-commands.hx ++++ b/qmp-commands.hx +@@ -1008,6 +1008,46 @@ EQMP + .args_type = "device:B,base:s?,top:s,speed:o?", + .mhandler.cmd_new = qmp_marshal_input_block_commit, + }, ++ ++SQMP ++block-commit ++------------ ++ ++Live commit of data from overlay image nodes into backing nodes - i.e., writes ++data between 'top' and 'base' into 'base'. ++ ++Arguments: ++ ++- "device": The device's ID, must be unique (json-string) ++- "base": The file name of the backing image to write data into. ++ If not specified, this is the deepest backing image ++ (json-string, optional) ++- "top": The file name of the backing image within the image chain, ++ which contains the topmost data to be committed down. ++ ++ If top == base, that is an error. ++ If top == active, the job will not be completed by itself, ++ user needs to complete the job with the block-job-complete ++ command after getting the ready event. (Since 2.0) ++ ++ If the base image is smaller than top, then the base image ++ will be resized to be the same size as top. If top is ++ smaller than the base image, the base will not be ++ truncated. If you want the base image size to match the ++ size of the smaller top, you can safely truncate it ++ yourself once the commit operation successfully completes. ++ (json-string) ++- "speed": the maximum speed, in bytes per second (json-int, optional) ++ ++ ++Example: ++ ++-> { "execute": "block-commit", "arguments": { "device": "virtio0", ++ "top": "/tmp/snap1.qcow2" } } ++<- { "return": {} } ++ ++EQMP ++ + #endif + + { +-- +1.7.1 + diff --git a/SOURCES/kvm-block-use-BDS-ref-for-block-jobs.patch b/SOURCES/kvm-block-use-BDS-ref-for-block-jobs.patch new file mode 100644 index 0000000..237f823 --- /dev/null +++ b/SOURCES/kvm-block-use-BDS-ref-for-block-jobs.patch @@ -0,0 +1,154 @@ +From d83c96945764748dff98dbe37169ae7c65a3dac5 Mon Sep 17 00:00:00 2001 +From: Fam Zheng +Date: Fri, 17 Jan 2014 03:07:52 +0100 +Subject: [PATCH 09/34] block: use BDS ref for block jobs + +RH-Author: Fam Zheng +Message-id: <1389928083-8921-8-git-send-email-famz@redhat.com> +Patchwork-id: 56769 +O-Subject: [RHEL-7 qemu-kvm PATCH 07/18] block: use BDS ref for block jobs +Bugzilla: 1041301 +RH-Acked-by: Jeffrey Cody +RH-Acked-by: Kevin Wolf +RH-Acked-by: Stefan Hajnoczi + +Block jobs used drive_get_ref(drive_get_by_blockdev(bs)) to avoid BDS +being deleted. Now we have BDS reference count, and block jobs don't +care about dinfo, so replace them to get cleaner code. It is also the +safe way when BDS has no drive info. + +Signed-off-by: Fam Zheng +Signed-off-by: Stefan Hajnoczi +(cherry picked from commit fa510ebffa1fd509323e2e0888e369e23adbb508) +Signed-off-by: Fam Zheng + +Conflicts: + blockdev.c + +Conflict because drive-backup is not backported, and downstream has +6270aec (block: optionally disable live block jobs). + +Signed-off-by: Fam Zheng +--- + blockdev.c | 44 +++++++++++++++----------------------------- + blockjob.c | 1 + + 2 files changed, 16 insertions(+), 29 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + blockdev.c | 44 +++++++++++++++----------------------------- + blockjob.c | 1 + + 2 files changed, 16 insertions(+), 29 deletions(-) + +diff --git a/blockdev.c b/blockdev.c +index 564262a..d795af2 100644 +--- a/blockdev.c ++++ b/blockdev.c +@@ -243,34 +243,34 @@ void drive_get_ref(DriveInfo *dinfo) + + typedef struct { + QEMUBH *bh; +- DriveInfo *dinfo; +-} DrivePutRefBH; ++ BlockDriverState *bs; ++} BDRVPutRefBH; + + /* right now, this is only used from block_job_cb() */ + #ifdef CONFIG_LIVE_BLOCK_OPS +-static void drive_put_ref_bh(void *opaque) ++static void bdrv_put_ref_bh(void *opaque) + { +- DrivePutRefBH *s = opaque; ++ BDRVPutRefBH *s = opaque; + +- drive_put_ref(s->dinfo); ++ bdrv_unref(s->bs); + qemu_bh_delete(s->bh); + g_free(s); + } + + /* +- * Release a drive reference in a BH ++ * Release a BDS reference in a BH + * +- * It is not possible to use drive_put_ref() from a callback function when the +- * callers still need the drive. In such cases we schedule a BH to release the +- * reference. ++ * It is not safe to use bdrv_unref() from a callback function when the callers ++ * still need the BlockDriverState. In such cases we schedule a BH to release ++ * the reference. + */ +-static void drive_put_ref_bh_schedule(DriveInfo *dinfo) ++static void bdrv_put_ref_bh_schedule(BlockDriverState *bs) + { +- DrivePutRefBH *s; ++ BDRVPutRefBH *s; + +- s = g_new(DrivePutRefBH, 1); +- s->bh = qemu_bh_new(drive_put_ref_bh, s); +- s->dinfo = dinfo; ++ s = g_new(BDRVPutRefBH, 1); ++ s->bh = qemu_bh_new(bdrv_put_ref_bh, s); ++ s->bs = bs; + qemu_bh_schedule(s->bh); + } + #endif +@@ -1423,7 +1423,7 @@ static void block_job_cb(void *opaque, int ret) + } + qobject_decref(obj); + +- drive_put_ref_bh_schedule(drive_get_by_blockdev(bs)); ++ bdrv_put_ref_bh_schedule(bs); + } + + void qmp_block_stream(const char *device, bool has_base, +@@ -1460,11 +1460,6 @@ void qmp_block_stream(const char *device, bool has_base, + return; + } + +- /* Grab a reference so hotplug does not delete the BlockDriverState from +- * underneath us. +- */ +- drive_get_ref(drive_get_by_blockdev(bs)); +- + trace_qmp_block_stream(bs, bs->job); + } + +@@ -1521,10 +1516,6 @@ void qmp_block_commit(const char *device, + error_propagate(errp, local_err); + return; + } +- /* Grab a reference so hotplug does not delete the BlockDriverState from +- * underneath us. +- */ +- drive_get_ref(drive_get_by_blockdev(bs)); + } + + #define DEFAULT_MIRROR_BUF_SIZE (10 << 20) +@@ -1658,11 +1649,6 @@ void qmp_drive_mirror(const char *device, const char *target, + error_propagate(errp, local_err); + return; + } +- +- /* Grab a reference so hotplug does not delete the BlockDriverState from +- * underneath us. +- */ +- drive_get_ref(drive_get_by_blockdev(bs)); + } + #endif + +diff --git a/blockjob.c b/blockjob.c +index c0a22d9..6d8c3a2 100644 +--- a/blockjob.c ++++ b/blockjob.c +@@ -45,6 +45,7 @@ void *block_job_create(const BlockJobType *job_type, BlockDriverState *bs, + error_set(errp, QERR_DEVICE_IN_USE, bdrv_get_device_name(bs)); + return NULL; + } ++ bdrv_ref(bs); + bdrv_set_in_use(bs, 1); + + job = g_malloc0(job_type->instance_size); +-- +1.7.1 + diff --git a/SOURCES/kvm-block-use-DIV_ROUND_UP-in-bdrv_co_do_readv.patch b/SOURCES/kvm-block-use-DIV_ROUND_UP-in-bdrv_co_do_readv.patch new file mode 100644 index 0000000..cf3048c --- /dev/null +++ b/SOURCES/kvm-block-use-DIV_ROUND_UP-in-bdrv_co_do_readv.patch @@ -0,0 +1,44 @@ +From 707398814bf924b6c430a49897171d1322011bff Mon Sep 17 00:00:00 2001 +From: Kevin Wolf +Date: Thu, 26 Sep 2013 19:55:33 +0800 +Subject: [PATCH 18/37] block: use DIV_ROUND_UP in bdrv_co_do_readv + +Message-id: <1392117622-28812-19-git-send-email-kwolf@redhat.com> +Patchwork-id: 57183 +O-Subject: [RHEL-7.0 qemu-kvm PATCH v2 18/37] block: use DIV_ROUND_UP in bdrv_co_do_readv +Bugzilla: 748906 +RH-Acked-by: Laszlo Ersek +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Max Reitz + +From: Fam Zheng + +Signed-off-by: Fam Zheng +Reviewed-by: Eric Blake +Signed-off-by: Kevin Wolf +(cherry picked from commit d055a1fec37ec84fd3e87d48a0e766a9ff8369c4) + +Signed-off-by: Kevin Wolf +--- + block.c | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) +--- + block.c | 2 +- + 1 files changed, 1 insertions(+), 1 deletions(-) + +diff --git a/block.c b/block.c +index 645bcd0..feeab4e 100644 +--- a/block.c ++++ b/block.c +@@ -2795,7 +2795,7 @@ static int coroutine_fn bdrv_aligned_preadv(BlockDriverState *bs, + goto out; + } + +- total_sectors = (len + BDRV_SECTOR_SIZE - 1) >> BDRV_SECTOR_BITS; ++ total_sectors = DIV_ROUND_UP(len, BDRV_SECTOR_SIZE); + max_nb_sectors = MAX(0, total_sectors - sector_num); + if (max_nb_sectors > 0) { + ret = drv->bdrv_co_readv(bs, sector_num, +-- +1.7.1 + diff --git a/SOURCES/kvm-block-use-correct-filename-for-error-report.patch b/SOURCES/kvm-block-use-correct-filename-for-error-report.patch new file mode 100644 index 0000000..00e3493 --- /dev/null +++ b/SOURCES/kvm-block-use-correct-filename-for-error-report.patch @@ -0,0 +1,58 @@ +From bde3157fa573b77a573a248ed27a7ad6974a329e Mon Sep 17 00:00:00 2001 +From: Jeffrey Cody +Date: Thu, 23 Jan 2014 21:02:38 +0100 +Subject: [PATCH 14/14] block: use correct filename for error report + +RH-Author: Jeffrey Cody +Message-id: <8724e61ff2600d6daa9a50e4e920e35e658d252b.1390510896.git.jcody@redhat.com> +Patchwork-id: 56934 +O-Subject: [RHEL7 qemu-kvm PATCH] block: use correct filename for error report +Bugzilla: 1051438 +RH-Acked-by: Fam Zheng +RH-Acked-by: Markus Armbruster +RH-Acked-by: Kevin Wolf + +From: Dunrong Huang + +The content filename point to will be erased by qemu_opts_absorb_qdict() +in raw_open_common() in drv->bdrv_file_open() + +So it's better to use bs->filename. + +Signed-off-by: Dunrong Huang +Reviewed-by: Max Reitz +Signed-off-by: Stefan Hajnoczi +(cherry picked from commit 2fa9aa59cfc472c16309c4e84547aa873423b2f5) + +RHEL7 Notes: + BZ: 1051438 + Brew: http://brewweb.devel.redhat.com/brew/taskinfo?taskID=6926450 + +Signed-off-by: Jeff Cody +--- + block.c | 4 ++-- + 1 file changed, 2 insertions(+), 2 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + block.c | 4 ++-- + 1 files changed, 2 insertions(+), 2 deletions(-) + +diff --git a/block.c b/block.c +index 3232971..1433844 100644 +--- a/block.c ++++ b/block.c +@@ -783,8 +783,8 @@ static int bdrv_open_common(BlockDriverState *bs, BlockDriverState *file, + if (ret < 0) { + if (error_is_set(&local_err)) { + error_propagate(errp, local_err); +- } else if (filename) { +- error_setg_errno(errp, -ret, "Could not open '%s'", filename); ++ } else if (bs->filename[0]) { ++ error_setg_errno(errp, -ret, "Could not open '%s'", bs->filename); + } else { + error_setg_errno(errp, -ret, "Could not open image"); + } +-- +1.7.1 + diff --git a/SOURCES/kvm-block-vdi-bounds-check-qemu-io-tests.patch b/SOURCES/kvm-block-vdi-bounds-check-qemu-io-tests.patch new file mode 100644 index 0000000..23308a4 --- /dev/null +++ b/SOURCES/kvm-block-vdi-bounds-check-qemu-io-tests.patch @@ -0,0 +1,218 @@ +From a8a02156e1893fa0ea440c50a58171842f2aff1b Mon Sep 17 00:00:00 2001 +From: Jeff Cody +Date: Tue, 25 Mar 2014 14:23:47 +0100 +Subject: [PATCH 40/49] block: vdi bounds check qemu-io tests + +RH-Author: Kevin Wolf +Message-id: <1395753835-7591-41-git-send-email-kwolf@redhat.com> +Patchwork-id: n/a +O-Subject: [virt-devel] [EMBARGOED RHEL-7.0 qemu-kvm PATCH 40/48] block: vdi bounds check qemu-io tests +Bugzilla: 1066691 +RH-Acked-by: Jeff Cody +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Paolo Bonzini + +From: Jeff Cody + +Bugzilla: https://bugzilla.redhat.com/show_bug.cgi?id=1066691 +Upstream status: Series embargoed + +This test checks for proper bounds checking of some VDI input +headers. The following is checked: + +1. Max image size (1024TB) with the appropriate Blocks In Image +value (0x3fffffff) is detected as valid. + +2. Image size exceeding max (1024TB) is seen as invalid + +3. Valid image size but with Blocks In Image value that is too +small fails + +4. Blocks In Image size exceeding max (0x3fffffff) is seen as invalid + +5. 64MB image, with 64 Blocks In Image, and 1MB Block Size is seen +as valid + +6. Block Size < 1MB not supported + +7. Block Size > 1MB not supported + +Signed-off-by: Jeff Cody +Reviewed-by: Stefan Hajnoczi +Signed-off-by: Kevin Wolf + +Conflicts: +tests/qemu-iotests/group + +Signed-off-by: Kevin Wolf +--- + tests/qemu-iotests/084 | 104 ++++++++++++++++++++++++++++++++++++++++++++ + tests/qemu-iotests/084.out | 33 ++++++++++++++ + tests/qemu-iotests/group | 1 + + 3 files changed, 138 insertions(+), 0 deletions(-) + create mode 100755 tests/qemu-iotests/084 + create mode 100644 tests/qemu-iotests/084.out + +diff --git a/tests/qemu-iotests/084 b/tests/qemu-iotests/084 +new file mode 100755 +index 0000000..10a5a65 +--- /dev/null ++++ b/tests/qemu-iotests/084 +@@ -0,0 +1,104 @@ ++#!/bin/bash ++# ++# Test case for VDI header corruption; image too large, and too many blocks ++# ++# Copyright (C) 2013 Red Hat, Inc. ++# ++# This program is free software; you can redistribute it and/or modify ++# it under the terms of the GNU General Public License as published by ++# the Free Software Foundation; either version 2 of the License, or ++# (at your option) any later version. ++# ++# This program is distributed in the hope that it will be useful, ++# but WITHOUT ANY WARRANTY; without even the implied warranty of ++# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++# GNU General Public License for more details. ++# ++# You should have received a copy of the GNU General Public License ++# along with this program. If not, see . ++# ++ ++# creator ++owner=jcody@redhat.com ++ ++seq=`basename $0` ++echo "QA output created by $seq" ++ ++here=`pwd` ++tmp=/tmp/$$ ++status=1 # failure is the default! ++ ++_cleanup() ++{ ++ _cleanup_test_img ++} ++trap "_cleanup; exit \$status" 0 1 2 3 15 ++ ++# get standard environment, filters and checks ++. ./common.rc ++. ./common.filter ++ ++# This tests vdi-specific header fields ++_supported_fmt vdi ++_supported_proto generic ++_supported_os Linux ++ ++ds_offset=368 # disk image size field offset ++bs_offset=376 # block size field offset ++bii_offset=384 # block in image field offset ++ ++echo ++echo "=== Testing image size bounds ===" ++echo ++_make_test_img 64M ++ ++# check for image size too large ++# poke max image size, and appropriate blocks_in_image value ++echo "Test 1: Maximum size (1024 TB):" ++poke_file "$TEST_IMG" "$ds_offset" "\x00\x00\xf0\xff\xff\xff\x03\x00" ++poke_file "$TEST_IMG" "$bii_offset" "\xff\xff\xff\x3f" ++_img_info ++ ++echo ++echo "Test 2: Size too large (1024TB + 1)" ++# This should be too large (-EINVAL): ++poke_file "$TEST_IMG" "$ds_offset" "\x00\x00\xf1\xff\xff\xff\x03\x00" ++_img_info ++ ++echo ++echo "Test 3: Size valid (64M), but Blocks In Image too small (63)" ++# This sets the size to 64M, but with a blocks_in_image size that is ++# too small ++poke_file "$TEST_IMG" "$ds_offset" "\x00\x00\x00\x04\x00\x00\x00\x00" ++# For a 64M image, we would need a blocks_in_image value of at least 64, ++# so 63 should be too small and give us -ENOTSUP ++poke_file "$TEST_IMG" "$bii_offset" "\x3f\x00\x00\x00" ++_img_info ++ ++echo ++echo "Test 4: Size valid (64M), but Blocks In Image exceeds max allowed" ++# Now check the bounds of blocks_in_image - 0x3fffffff should be the max ++# value here, and we should get -ENOTSUP ++poke_file "$TEST_IMG" "$bii_offset" "\x00\x00\x00\x40" ++_img_info ++ ++# Finally, 1MB is the only block size supported. Verify that ++# a value != 1MB results in error, both smaller and larger ++echo ++echo "Test 5: Valid Image: 64MB, Blocks In Image 64, Block Size 1MB" ++poke_file "$TEST_IMG" "$bii_offset" "\x40\x00\x00\x00" # reset bii to valid ++poke_file "$TEST_IMG" "$bs_offset" "\x00\x00\x10\x00" # valid ++_img_info ++echo ++echo "Test 6: Block Size != 1MB; too small test (1MB - 1)" ++poke_file "$TEST_IMG" "$bs_offset" "\xff\xff\x0f\x00" # invalid (too small) ++_img_info ++echo ++echo "Test 7: Block Size != 1MB; too large test (1MB + 1)" ++poke_file "$TEST_IMG" "$bs_offset" "\x00\x00\x11\x00" # invalid (too large) ++_img_info ++# success, all done ++echo ++echo "*** done" ++rm -f $seq.full ++status=0 +diff --git a/tests/qemu-iotests/084.out b/tests/qemu-iotests/084.out +new file mode 100644 +index 0000000..99c8e74 +--- /dev/null ++++ b/tests/qemu-iotests/084.out +@@ -0,0 +1,33 @@ ++QA output created by 084 ++ ++=== Testing image size bounds === ++ ++Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864 ++Test 1: Maximum size (1024 TB): ++image: TEST_DIR/t.IMGFMT ++file format: IMGFMT ++virtual size: 1024T (1125899905794048 bytes) ++cluster_size: 1048576 ++ ++Test 2: Size too large (1024TB + 1) ++qemu-img: Could not open 'TEST_DIR/t.IMGFMT': Could not open 'TEST_DIR/t.IMGFMT': Invalid argument ++ ++Test 3: Size valid (64M), but Blocks In Image too small (63) ++qemu-img: Could not open 'TEST_DIR/t.IMGFMT': Could not open 'TEST_DIR/t.IMGFMT': Operation not supported ++ ++Test 4: Size valid (64M), but Blocks In Image exceeds max allowed ++qemu-img: Could not open 'TEST_DIR/t.IMGFMT': Could not open 'TEST_DIR/t.IMGFMT': Operation not supported ++ ++Test 5: Valid Image: 64MB, Blocks In Image 64, Block Size 1MB ++image: TEST_DIR/t.IMGFMT ++file format: IMGFMT ++virtual size: 64M (67108864 bytes) ++cluster_size: 1048576 ++ ++Test 6: Block Size != 1MB; too small test (1MB - 1) ++qemu-img: Could not open 'TEST_DIR/t.IMGFMT': Could not open 'TEST_DIR/t.IMGFMT': Operation not supported ++ ++Test 7: Block Size != 1MB; too large test (1MB + 1) ++qemu-img: Could not open 'TEST_DIR/t.IMGFMT': Could not open 'TEST_DIR/t.IMGFMT': Operation not supported ++ ++*** done +diff --git a/tests/qemu-iotests/group b/tests/qemu-iotests/group +index fc34194..e8ad780 100644 +--- a/tests/qemu-iotests/group ++++ b/tests/qemu-iotests/group +@@ -77,5 +77,6 @@ + 079 rw auto + 080 rw auto + 082 rw auto quick ++084 img auto + 086 rw auto quick + 088 rw auto +-- +1.7.1 + diff --git a/SOURCES/kvm-block-vhdx-add-.bdrv_create-support.patch b/SOURCES/kvm-block-vhdx-add-.bdrv_create-support.patch new file mode 100644 index 0000000..78eb0f8 --- /dev/null +++ b/SOURCES/kvm-block-vhdx-add-.bdrv_create-support.patch @@ -0,0 +1,739 @@ +From 243d499717ebba0c0644620237c266112164d5ed Mon Sep 17 00:00:00 2001 +From: Jeffrey Cody +Date: Wed, 20 Nov 2013 19:44:05 +0100 +Subject: [PATCH 22/25] block: vhdx - add .bdrv_create() support + +RH-Author: Jeffrey Cody +Message-id: <450971418e351130082c4c5f3c8ac8231810c556.1384975172.git.jcody@redhat.com> +Patchwork-id: 55814 +O-Subject: [RHEL7 qemu-kvm PATCH 22/26] block: vhdx - add .bdrv_create() support +Bugzilla: 879234 +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Fam Zheng + +This adds support for VHDX image creation, for images of type "Fixed" +and "Dynamic". "Differencing" types (i.e., VHDX images with backing +files) are currently not supported. + +Options for image creation include: + * log size: + The size of the journaling log for VHDX. Minimum is 1MB, + and it must be a multiple of 1MB. Invalid log sizes will be + silently fixed by rounding up to the nearest MB. + + Default is 1MB. + + * block size: + This is the size of a payload block. The range is 1MB to 256MB, + inclusive, and must be a multiple of 1MB as well. Invalid sizes + and multiples will be silently fixed. If '0' is passed, then + a sane size is chosen (depending on virtual image size). + + Default is 0 (Auto-select). + + * subformat: + - "dynamic" + An image without data pre-allocated. + - "fixed" + An image with data pre-allocated. + + Default is "dynamic" + +When creating the image file, the lettered sections are created: + +-----------------------------------------------------------------. +| (A) | (B) | (C) | (D) | (E) +| File ID | Header1 | Header 2 | Region Tbl 1 | Region Tbl 2 +| | | | | +.-----------------------------------------------------------------. +0 64KB 128KB 192KB 256KB 320KB + +.---- ~ ----------- ~ ------------ ~ ---------------- ~ -----------. +| (F) | (G) | (H) | +| Journal Log | BAT / Bitmap | Metadata | .... data ...... +| | | | +.---- ~ ----------- ~ ------------ ~ ---------------- ~ -----------. +1MB (var.) (var.) (var.) + +Signed-off-by: Jeff Cody +Signed-off-by: Stefan Hajnoczi +(cherry picked from commit 3412f7b1bd8f250c34c9f933767d06b9444bb821) + +RHEL7 Note: Although the cherry-pick applied clean, the 'bdrv_unref()' + call in the upstream version was reverted back to the + original 'bdrv_delete()' that is present in RHEL7. + +Signed-off-by: Jeff Cody +--- + block/vhdx.c | 558 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + block/vhdx.h | 15 +- + 2 files changed, 572 insertions(+), 1 deletion(-) + +Signed-off-by: Miroslav Rezanina +--- + block/vhdx.c | 557 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + block/vhdx.h | 15 ++- + 2 files changed, 571 insertions(+), 1 deletions(-) + +diff --git a/block/vhdx.c b/block/vhdx.c +index 5a112e8..8e3b371 100644 +--- a/block/vhdx.c ++++ b/block/vhdx.c +@@ -23,6 +23,19 @@ + #include "migration/migration.h" + + #include ++#include ++ ++/* Options for VHDX creation */ ++ ++#define VHDX_BLOCK_OPT_LOG_SIZE "log_size" ++#define VHDX_BLOCK_OPT_BLOCK_SIZE "block_size" ++#define VHDX_BLOCK_OPT_ZERO "block_state_zero" ++ ++typedef enum VHDXImageType { ++ VHDX_TYPE_DYNAMIC = 0, ++ VHDX_TYPE_FIXED, ++ VHDX_TYPE_DIFFERENCING, /* Currently unsupported */ ++} VHDXImageType; + + /* Several metadata and region table data entries are identified by + * guids in a MS-specific GUID format. */ +@@ -1332,6 +1345,548 @@ exit: + } + + ++ ++/* ++ * Create VHDX Headers ++ * ++ * There are 2 headers, and the highest sequence number will represent ++ * the active header ++ */ ++static int vhdx_create_new_headers(BlockDriverState *bs, uint64_t image_size, ++ uint32_t log_size) ++{ ++ int ret = 0; ++ VHDXHeader *hdr = NULL; ++ ++ hdr = g_malloc0(sizeof(VHDXHeader)); ++ ++ hdr->signature = VHDX_HEADER_SIGNATURE; ++ hdr->sequence_number = g_random_int(); ++ hdr->log_version = 0; ++ hdr->version = 1; ++ hdr->log_length = log_size; ++ hdr->log_offset = VHDX_HEADER_SECTION_END; ++ vhdx_guid_generate(&hdr->file_write_guid); ++ vhdx_guid_generate(&hdr->data_write_guid); ++ ++ ret = vhdx_write_header(bs, hdr, VHDX_HEADER1_OFFSET, false); ++ if (ret < 0) { ++ goto exit; ++ } ++ hdr->sequence_number++; ++ ret = vhdx_write_header(bs, hdr, VHDX_HEADER2_OFFSET, false); ++ if (ret < 0) { ++ goto exit; ++ } ++ ++exit: ++ g_free(hdr); ++ return ret; ++} ++ ++ ++/* ++ * Create the Metadata entries. ++ * ++ * For more details on the entries, see section 3.5 (pg 29) in the ++ * VHDX 1.00 specification. ++ * ++ * We support 5 metadata entries (all required by spec): ++ * File Parameters, ++ * Virtual Disk Size, ++ * Page 83 Data, ++ * Logical Sector Size, ++ * Physical Sector Size ++ * ++ * The first 64KB of the Metadata section is reserved for the metadata ++ * header and entries; beyond that, the metadata items themselves reside. ++ */ ++static int vhdx_create_new_metadata(BlockDriverState *bs, ++ uint64_t image_size, ++ uint32_t block_size, ++ uint32_t sector_size, ++ uint64_t metadata_offset, ++ VHDXImageType type) ++{ ++ int ret = 0; ++ uint32_t offset = 0; ++ void *buffer = NULL; ++ void *entry_buffer; ++ VHDXMetadataTableHeader *md_table;; ++ VHDXMetadataTableEntry *md_table_entry; ++ ++ /* Metadata entries */ ++ VHDXFileParameters *mt_file_params; ++ VHDXVirtualDiskSize *mt_virtual_size; ++ VHDXPage83Data *mt_page83; ++ VHDXVirtualDiskLogicalSectorSize *mt_log_sector_size; ++ VHDXVirtualDiskPhysicalSectorSize *mt_phys_sector_size; ++ ++ entry_buffer = g_malloc0(sizeof(VHDXFileParameters) + ++ sizeof(VHDXVirtualDiskSize) + ++ sizeof(VHDXPage83Data) + ++ sizeof(VHDXVirtualDiskLogicalSectorSize) + ++ sizeof(VHDXVirtualDiskPhysicalSectorSize)); ++ ++ mt_file_params = entry_buffer; ++ offset += sizeof(VHDXFileParameters); ++ mt_virtual_size = entry_buffer + offset; ++ offset += sizeof(VHDXVirtualDiskSize); ++ mt_page83 = entry_buffer + offset; ++ offset += sizeof(VHDXPage83Data); ++ mt_log_sector_size = entry_buffer + offset; ++ offset += sizeof(VHDXVirtualDiskLogicalSectorSize); ++ mt_phys_sector_size = entry_buffer + offset; ++ ++ mt_file_params->block_size = cpu_to_le32(block_size); ++ if (type == VHDX_TYPE_FIXED) { ++ mt_file_params->data_bits |= VHDX_PARAMS_LEAVE_BLOCKS_ALLOCED; ++ cpu_to_le32s(&mt_file_params->data_bits); ++ } ++ ++ vhdx_guid_generate(&mt_page83->page_83_data); ++ cpu_to_leguids(&mt_page83->page_83_data); ++ mt_virtual_size->virtual_disk_size = cpu_to_le64(image_size); ++ mt_log_sector_size->logical_sector_size = cpu_to_le32(sector_size); ++ mt_phys_sector_size->physical_sector_size = cpu_to_le32(sector_size); ++ ++ buffer = g_malloc0(VHDX_HEADER_BLOCK_SIZE); ++ md_table = buffer; ++ ++ md_table->signature = VHDX_METADATA_SIGNATURE; ++ md_table->entry_count = 5; ++ vhdx_metadata_header_le_export(md_table); ++ ++ ++ /* This will reference beyond the reserved table portion */ ++ offset = 64 * KiB; ++ ++ md_table_entry = buffer + sizeof(VHDXMetadataTableHeader); ++ ++ md_table_entry[0].item_id = file_param_guid; ++ md_table_entry[0].offset = offset; ++ md_table_entry[0].length = sizeof(VHDXFileParameters); ++ md_table_entry[0].data_bits |= VHDX_META_FLAGS_IS_REQUIRED; ++ offset += md_table_entry[0].length; ++ vhdx_metadata_entry_le_export(&md_table_entry[0]); ++ ++ md_table_entry[1].item_id = virtual_size_guid; ++ md_table_entry[1].offset = offset; ++ md_table_entry[1].length = sizeof(VHDXVirtualDiskSize); ++ md_table_entry[1].data_bits |= VHDX_META_FLAGS_IS_REQUIRED | ++ VHDX_META_FLAGS_IS_VIRTUAL_DISK; ++ offset += md_table_entry[1].length; ++ vhdx_metadata_entry_le_export(&md_table_entry[1]); ++ ++ md_table_entry[2].item_id = page83_guid; ++ md_table_entry[2].offset = offset; ++ md_table_entry[2].length = sizeof(VHDXPage83Data); ++ md_table_entry[2].data_bits |= VHDX_META_FLAGS_IS_REQUIRED | ++ VHDX_META_FLAGS_IS_VIRTUAL_DISK; ++ offset += md_table_entry[2].length; ++ vhdx_metadata_entry_le_export(&md_table_entry[2]); ++ ++ md_table_entry[3].item_id = logical_sector_guid; ++ md_table_entry[3].offset = offset; ++ md_table_entry[3].length = sizeof(VHDXVirtualDiskLogicalSectorSize); ++ md_table_entry[3].data_bits |= VHDX_META_FLAGS_IS_REQUIRED | ++ VHDX_META_FLAGS_IS_VIRTUAL_DISK; ++ offset += md_table_entry[3].length; ++ vhdx_metadata_entry_le_export(&md_table_entry[3]); ++ ++ md_table_entry[4].item_id = phys_sector_guid; ++ md_table_entry[4].offset = offset; ++ md_table_entry[4].length = sizeof(VHDXVirtualDiskPhysicalSectorSize); ++ md_table_entry[4].data_bits |= VHDX_META_FLAGS_IS_REQUIRED | ++ VHDX_META_FLAGS_IS_VIRTUAL_DISK; ++ vhdx_metadata_entry_le_export(&md_table_entry[4]); ++ ++ ret = bdrv_pwrite(bs, metadata_offset, buffer, VHDX_HEADER_BLOCK_SIZE); ++ if (ret < 0) { ++ goto exit; ++ } ++ ++ ret = bdrv_pwrite(bs, metadata_offset + (64 * KiB), entry_buffer, ++ VHDX_HEADER_BLOCK_SIZE); ++ if (ret < 0) { ++ goto exit; ++ } ++ ++ ++exit: ++ g_free(buffer); ++ g_free(entry_buffer); ++ return ret; ++} ++ ++/* This create the actual BAT itself. We currently only support ++ * 'Dynamic' and 'Fixed' image types. ++ * ++ * Dynamic images: default state of the BAT is all zeroes. ++ * ++ * Fixed images: default state of the BAT is fully populated, with ++ * file offsets and state PAYLOAD_BLOCK_FULLY_PRESENT. ++ */ ++static int vhdx_create_bat(BlockDriverState *bs, BDRVVHDXState *s, ++ uint64_t image_size, VHDXImageType type, ++ bool use_zero_blocks, VHDXRegionTableEntry *rt_bat) ++{ ++ int ret = 0; ++ uint64_t data_file_offset; ++ uint64_t total_sectors = 0; ++ uint64_t sector_num = 0; ++ uint64_t unused; ++ int block_state; ++ VHDXSectorInfo sinfo; ++ ++ assert(s->bat == NULL); ++ ++ /* this gives a data start after BAT/bitmap entries, and well ++ * past any metadata entries (with a 4 MB buffer for future ++ * expansion */ ++ data_file_offset = rt_bat->file_offset + rt_bat->length + 5 * MiB; ++ total_sectors = image_size >> s->logical_sector_size_bits; ++ ++ if (type == VHDX_TYPE_DYNAMIC) { ++ /* All zeroes, so we can just extend the file - the end of the BAT ++ * is the furthest thing we have written yet */ ++ ret = bdrv_truncate(bs, data_file_offset); ++ if (ret < 0) { ++ goto exit; ++ } ++ } else if (type == VHDX_TYPE_FIXED) { ++ ret = bdrv_truncate(bs, data_file_offset + image_size); ++ if (ret < 0) { ++ goto exit; ++ } ++ } else { ++ ret = -ENOTSUP; ++ goto exit; ++ } ++ ++ if (type == VHDX_TYPE_FIXED || ++ use_zero_blocks || ++ bdrv_has_zero_init(bs) == 0) { ++ /* for a fixed file, the default BAT entry is not zero */ ++ s->bat = g_malloc0(rt_bat->length); ++ block_state = type == VHDX_TYPE_FIXED ? PAYLOAD_BLOCK_FULLY_PRESENT : ++ PAYLOAD_BLOCK_NOT_PRESENT; ++ block_state = use_zero_blocks ? PAYLOAD_BLOCK_ZERO : block_state; ++ /* fill the BAT by emulating sector writes of sectors_per_block size */ ++ while (sector_num < total_sectors) { ++ vhdx_block_translate(s, sector_num, s->sectors_per_block, &sinfo); ++ sinfo.file_offset = data_file_offset + ++ (sector_num << s->logical_sector_size_bits); ++ sinfo.file_offset = ROUND_UP(sinfo.file_offset, MiB); ++ vhdx_update_bat_table_entry(bs, s, &sinfo, &unused, &unused, ++ block_state); ++ cpu_to_le64s(&s->bat[sinfo.bat_idx]); ++ sector_num += s->sectors_per_block; ++ } ++ ret = bdrv_pwrite(bs, rt_bat->file_offset, s->bat, rt_bat->length); ++ if (ret < 0) { ++ goto exit; ++ } ++ } ++ ++ ++ ++exit: ++ g_free(s->bat); ++ return ret; ++} ++ ++/* Creates the region table header, and region table entries. ++ * There are 2 supported region table entries: BAT, and Metadata/ ++ * ++ * As the calculations for the BAT region table are also needed ++ * to create the BAT itself, we will also cause the BAT to be ++ * created. ++ */ ++static int vhdx_create_new_region_table(BlockDriverState *bs, ++ uint64_t image_size, ++ uint32_t block_size, ++ uint32_t sector_size, ++ uint32_t log_size, ++ bool use_zero_blocks, ++ VHDXImageType type, ++ uint64_t *metadata_offset) ++{ ++ int ret = 0; ++ uint32_t offset = 0; ++ void *buffer = NULL; ++ BDRVVHDXState *s = NULL; ++ VHDXRegionTableHeader *region_table; ++ VHDXRegionTableEntry *rt_bat; ++ VHDXRegionTableEntry *rt_metadata; ++ ++ assert(metadata_offset != NULL); ++ ++ /* Populate enough of the BDRVVHDXState to be able to use the ++ * pre-existing BAT calculation, translation, and update functions */ ++ s = g_malloc0(sizeof(BDRVVHDXState)); ++ ++ s->chunk_ratio = (VHDX_MAX_SECTORS_PER_BLOCK) * ++ (uint64_t) sector_size / (uint64_t) block_size; ++ ++ s->sectors_per_block = block_size / sector_size; ++ s->virtual_disk_size = image_size; ++ s->block_size = block_size; ++ s->logical_sector_size = sector_size; ++ ++ vhdx_set_shift_bits(s); ++ ++ vhdx_calc_bat_entries(s); ++ ++ /* At this point the VHDX state is populated enough for creation */ ++ ++ /* a single buffer is used so we can calculate the checksum over the ++ * entire 64KB block */ ++ buffer = g_malloc0(VHDX_HEADER_BLOCK_SIZE); ++ region_table = buffer; ++ offset += sizeof(VHDXRegionTableHeader); ++ rt_bat = buffer + offset; ++ offset += sizeof(VHDXRegionTableEntry); ++ rt_metadata = buffer + offset; ++ ++ region_table->signature = VHDX_REGION_SIGNATURE; ++ region_table->entry_count = 2; /* BAT and Metadata */ ++ ++ rt_bat->guid = bat_guid; ++ rt_bat->length = ROUND_UP(s->bat_entries * sizeof(VHDXBatEntry), MiB); ++ rt_bat->file_offset = ROUND_UP(VHDX_HEADER_SECTION_END + log_size, MiB); ++ s->bat_offset = rt_bat->file_offset; ++ ++ rt_metadata->guid = metadata_guid; ++ rt_metadata->file_offset = ROUND_UP(rt_bat->file_offset + rt_bat->length, ++ MiB); ++ rt_metadata->length = 1 * MiB; /* min size, and more than enough */ ++ *metadata_offset = rt_metadata->file_offset; ++ ++ vhdx_update_checksum(buffer, VHDX_HEADER_BLOCK_SIZE, ++ offsetof(VHDXRegionTableHeader, checksum)); ++ ++ ++ /* The region table gives us the data we need to create the BAT, ++ * so do that now */ ++ ret = vhdx_create_bat(bs, s, image_size, type, use_zero_blocks, rt_bat); ++ ++ /* Now write out the region headers to disk */ ++ vhdx_region_header_le_export(region_table); ++ vhdx_region_entry_le_export(rt_bat); ++ vhdx_region_entry_le_export(rt_metadata); ++ ++ ret = bdrv_pwrite(bs, VHDX_REGION_TABLE_OFFSET, buffer, ++ VHDX_HEADER_BLOCK_SIZE); ++ if (ret < 0) { ++ goto exit; ++ } ++ ++ ret = bdrv_pwrite(bs, VHDX_REGION_TABLE2_OFFSET, buffer, ++ VHDX_HEADER_BLOCK_SIZE); ++ if (ret < 0) { ++ goto exit; ++ } ++ ++ ++exit: ++ g_free(s); ++ g_free(buffer); ++ return ret; ++} ++ ++/* We need to create the following elements: ++ * ++ * .-----------------------------------------------------------------. ++ * | (A) | (B) | (C) | (D) | (E) | ++ * | File ID | Header1 | Header 2 | Region Tbl 1 | Region Tbl 2 | ++ * | | | | | | ++ * .-----------------------------------------------------------------. ++ * 0 64KB 128KB 192KB 256KB 320KB ++ * ++ * ++ * .---- ~ ----------- ~ ------------ ~ ---------------- ~ -----------. ++ * | (F) | (G) | (H) | | ++ * | Journal Log | BAT / Bitmap | Metadata | .... data ...... | ++ * | | | | | ++ * .---- ~ ----------- ~ ------------ ~ ---------------- ~ -----------. ++ * 1MB ++ */ ++static int vhdx_create(const char *filename, QEMUOptionParameter *options, ++ Error **errp) ++{ ++ int ret = 0; ++ uint64_t image_size = (uint64_t) 2 * GiB; ++ uint32_t log_size = 1 * MiB; ++ uint32_t block_size = 0; ++ uint64_t signature; ++ uint64_t metadata_offset; ++ bool use_zero_blocks = false; ++ ++ gunichar2 *creator = NULL; ++ glong creator_items; ++ BlockDriverState *bs; ++ const char *type = NULL; ++ VHDXImageType image_type; ++ Error *local_err = NULL; ++ ++ while (options && options->name) { ++ if (!strcmp(options->name, BLOCK_OPT_SIZE)) { ++ image_size = options->value.n; ++ } else if (!strcmp(options->name, VHDX_BLOCK_OPT_LOG_SIZE)) { ++ log_size = options->value.n; ++ } else if (!strcmp(options->name, VHDX_BLOCK_OPT_BLOCK_SIZE)) { ++ block_size = options->value.n; ++ } else if (!strcmp(options->name, BLOCK_OPT_SUBFMT)) { ++ type = options->value.s; ++ } else if (!strcmp(options->name, VHDX_BLOCK_OPT_ZERO)) { ++ use_zero_blocks = options->value.n != 0; ++ } ++ options++; ++ } ++ ++ if (image_size > VHDX_MAX_IMAGE_SIZE) { ++ error_setg_errno(errp, EINVAL, "Image size too large; max of 64TB"); ++ ret = -EINVAL; ++ goto exit; ++ } ++ ++ if (type == NULL) { ++ type = "dynamic"; ++ } ++ ++ if (!strcmp(type, "dynamic")) { ++ image_type = VHDX_TYPE_DYNAMIC; ++ } else if (!strcmp(type, "fixed")) { ++ image_type = VHDX_TYPE_FIXED; ++ } else if (!strcmp(type, "differencing")) { ++ error_setg_errno(errp, ENOTSUP, ++ "Differencing files not yet supported"); ++ ret = -ENOTSUP; ++ goto exit; ++ } else { ++ ret = -EINVAL; ++ goto exit; ++ } ++ ++ /* These are pretty arbitrary, and mainly designed to keep the BAT ++ * size reasonable to load into RAM */ ++ if (block_size == 0) { ++ if (image_size > 32 * TiB) { ++ block_size = 64 * MiB; ++ } else if (image_size > (uint64_t) 100 * GiB) { ++ block_size = 32 * MiB; ++ } else if (image_size > 1 * GiB) { ++ block_size = 16 * MiB; ++ } else { ++ block_size = 8 * MiB; ++ } ++ } ++ ++ ++ /* make the log size close to what was specified, but must be ++ * min 1MB, and multiple of 1MB */ ++ log_size = ROUND_UP(log_size, MiB); ++ ++ block_size = ROUND_UP(block_size, MiB); ++ block_size = block_size > VHDX_BLOCK_SIZE_MAX ? VHDX_BLOCK_SIZE_MAX : ++ block_size; ++ ++ ret = bdrv_create_file(filename, options, &local_err); ++ if (ret < 0) { ++ error_propagate(errp, local_err); ++ goto exit; ++ } ++ ++ ret = bdrv_file_open(&bs, filename, NULL, BDRV_O_RDWR, &local_err); ++ if (ret < 0) { ++ error_propagate(errp, local_err); ++ goto exit; ++ } ++ ++ /* Create (A) */ ++ ++ /* The creator field is optional, but may be useful for ++ * debugging / diagnostics */ ++ creator = g_utf8_to_utf16("QEMU v" QEMU_VERSION, -1, NULL, ++ &creator_items, NULL); ++ signature = cpu_to_le64(VHDX_FILE_SIGNATURE); ++ bdrv_pwrite(bs, VHDX_FILE_ID_OFFSET, &signature, sizeof(signature)); ++ if (ret < 0) { ++ goto delete_and_exit; ++ } ++ if (creator) { ++ bdrv_pwrite(bs, VHDX_FILE_ID_OFFSET + sizeof(signature), creator, ++ creator_items * sizeof(gunichar2)); ++ if (ret < 0) { ++ goto delete_and_exit; ++ } ++ } ++ ++ ++ /* Creates (B),(C) */ ++ ret = vhdx_create_new_headers(bs, image_size, log_size); ++ if (ret < 0) { ++ goto delete_and_exit; ++ } ++ ++ /* Creates (D),(E),(G) explicitly. (F) created as by-product */ ++ ret = vhdx_create_new_region_table(bs, image_size, block_size, 512, ++ log_size, use_zero_blocks, image_type, ++ &metadata_offset); ++ if (ret < 0) { ++ goto delete_and_exit; ++ } ++ ++ /* Creates (H) */ ++ ret = vhdx_create_new_metadata(bs, image_size, block_size, 512, ++ metadata_offset, image_type); ++ if (ret < 0) { ++ goto delete_and_exit; ++ } ++ ++ ++ ++delete_and_exit: ++ bdrv_delete(bs); ++exit: ++ g_free(creator); ++ return ret; ++} ++ ++static QEMUOptionParameter vhdx_create_options[] = { ++ { ++ .name = BLOCK_OPT_SIZE, ++ .type = OPT_SIZE, ++ .help = "Virtual disk size; max of 64TB." ++ }, ++ { ++ .name = VHDX_BLOCK_OPT_LOG_SIZE, ++ .type = OPT_SIZE, ++ .value.n = 1 * MiB, ++ .help = "Log size; min 1MB." ++ }, ++ { ++ .name = VHDX_BLOCK_OPT_BLOCK_SIZE, ++ .type = OPT_SIZE, ++ .value.n = 0, ++ .help = "Block Size; min 1MB, max 256MB. " \ ++ "0 means auto-calculate based on image size." ++ }, ++ { ++ .name = BLOCK_OPT_SUBFMT, ++ .type = OPT_STRING, ++ .help = "VHDX format type, can be either 'dynamic' or 'fixed'. "\ ++ "Default is 'dynamic'." ++ }, ++ { ++ .name = VHDX_BLOCK_OPT_ZERO, ++ .type = OPT_FLAG, ++ .help = "Force use of payload blocks of type 'ZERO'. Non-standard." ++ }, ++ { NULL } ++}; ++ + static BlockDriver bdrv_vhdx = { + .format_name = "vhdx", + .instance_size = sizeof(BDRVVHDXState), +@@ -1342,6 +1897,8 @@ static BlockDriver bdrv_vhdx = { + .bdrv_co_readv = vhdx_co_readv, + .bdrv_co_writev = vhdx_co_writev, + .bdrv_get_info = vhdx_get_info, ++ .bdrv_create = vhdx_create, ++ .create_options = vhdx_create_options, + }; + + static void bdrv_vhdx_init(void) +diff --git a/block/vhdx.h b/block/vhdx.h +index 245547b..365eca0 100644 +--- a/block/vhdx.h ++++ b/block/vhdx.h +@@ -18,6 +18,11 @@ + #ifndef BLOCK_VHDX_H + #define BLOCK_VHDX_H + ++#define KiB (1 * 1024) ++#define MiB (KiB * 1024) ++#define GiB (MiB * 1024) ++#define TiB ((uint64_t) GiB * 1024) ++ + /* Structures and fields present in the VHDX file */ + + /* The header section has the following blocks, +@@ -36,8 +41,9 @@ + #define VHDX_HEADER1_OFFSET (VHDX_HEADER_BLOCK_SIZE * 1) + #define VHDX_HEADER2_OFFSET (VHDX_HEADER_BLOCK_SIZE * 2) + #define VHDX_REGION_TABLE_OFFSET (VHDX_HEADER_BLOCK_SIZE * 3) ++#define VHDX_REGION_TABLE2_OFFSET (VHDX_HEADER_BLOCK_SIZE * 4) + +- ++#define VHDX_HEADER_SECTION_END (1 * MiB) + /* + * A note on the use of MS-GUID fields. For more details on the GUID, + * please see: https://en.wikipedia.org/wiki/Globally_unique_identifier. +@@ -55,6 +61,7 @@ + /* These structures are ones that are defined in the VHDX specification + * document */ + ++#define VHDX_FILE_SIGNATURE 0x656C696678646876 /* "vhdxfile" in ASCII */ + typedef struct VHDXFileIdentifier { + uint64_t signature; /* "vhdxfile" in ASCII */ + uint16_t creator[256]; /* optional; utf-16 string to identify +@@ -85,6 +92,7 @@ typedef struct QEMU_PACKED MSGUID { + /* The full header is 4KB, although the actual header data is much smaller. + * But for the checksum calculation, it is over the entire 4KB structure, + * not just the defined portion of it */ ++#define VHDX_HEADER_SIGNATURE 0x64616568 + typedef struct QEMU_PACKED VHDXHeader { + uint32_t signature; /* "head" in ASCII */ + uint32_t checksum; /* CRC-32C hash of the whole header */ +@@ -125,6 +133,7 @@ typedef struct QEMU_PACKED VHDXHeader { + } VHDXHeader; + + /* Header for the region table block */ ++#define VHDX_REGION_SIGNATURE 0x69676572 /* "regi" in ASCII */ + typedef struct QEMU_PACKED VHDXRegionTableHeader { + uint32_t signature; /* "regi" in ASCII */ + uint32_t checksum; /* CRC-32C hash of the 64KB table */ +@@ -238,6 +247,7 @@ typedef uint64_t VHDXBatEntry; + #define VHDX_METADATA_MAX_ENTRIES 2047 /* not including the header */ + #define VHDX_METADATA_TABLE_MAX_SIZE \ + (VHDX_METADATA_ENTRY_SIZE * (VHDX_METADATA_MAX_ENTRIES+1)) ++#define VHDX_METADATA_SIGNATURE 0x617461646174656D /* "metadata" in ASCII */ + typedef struct QEMU_PACKED VHDXMetadataTableHeader { + uint64_t signature; /* "metadata" in ASCII */ + uint16_t reserved; +@@ -267,6 +277,8 @@ typedef struct QEMU_PACKED VHDXMetadataTableEntry { + If set indicates a fixed + size VHDX file */ + #define VHDX_PARAMS_HAS_PARENT 0x02 /* has parent / backing file */ ++#define VHDX_BLOCK_SIZE_MIN (1 * MiB) ++#define VHDX_BLOCK_SIZE_MAX (256 * MiB) + typedef struct QEMU_PACKED VHDXFileParameters { + uint32_t block_size; /* size of each payload block, always + power of 2, <= 256MB and >= 1MB. */ +@@ -274,6 +286,7 @@ typedef struct QEMU_PACKED VHDXFileParameters { + the rest are reserved (see above) */ + } VHDXFileParameters; + ++#define VHDX_MAX_IMAGE_SIZE ((uint64_t) 64 * TiB) + typedef struct QEMU_PACKED VHDXVirtualDiskSize { + uint64_t virtual_disk_size; /* Size of the virtual disk, in bytes. + Must be multiple of the sector size, +-- +1.7.1 + diff --git a/SOURCES/kvm-block-vhdx-add-header-update-capability.patch b/SOURCES/kvm-block-vhdx-add-header-update-capability.patch new file mode 100644 index 0000000..816bcfa --- /dev/null +++ b/SOURCES/kvm-block-vhdx-add-header-update-capability.patch @@ -0,0 +1,392 @@ +From 47299b9e7ac4a8318e0cf3c88cc3f24cc214da1b Mon Sep 17 00:00:00 2001 +From: Jeffrey Cody +Date: Wed, 20 Nov 2013 19:43:51 +0100 +Subject: [PATCH 08/25] block: vhdx - add header update capability. + +RH-Author: Jeffrey Cody +Message-id: <42b5dd4b297781538d090b292503c89e2dcb9ed5.1384975172.git.jcody@redhat.com> +Patchwork-id: 55801 +O-Subject: [RHEL7 qemu-kvm PATCH 08/26] block: vhdx - add header update capability. +Bugzilla: 879234 +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Fam Zheng + +This adds the ability to update the headers in a VHDX image, including +generating a new MS-compatible GUID. + +As VHDX depends on uuid.h, VHDX is now a configurable build option. If +VHDX support is enabled, that will also enable uuid as well. The +default is to have VHDX enabled. + +To enable/disable VHDX: --enable-vhdx, --disable-vhdx + +Signed-off-by: Jeff Cody +Signed-off-by: Stefan Hajnoczi +(cherry picked from commit 4f18b7824ab5eda9fe051f5b24e90e5f34d08a23) + +Conflicts: + configure + +RHEL7 Notes: Conflict due to the changes for VHDX enable/disable in the + same area of the file as the RHEL7 live block differentiation. + +Signed-off-by: Jeff Cody +--- + block/Makefile.objs | 2 +- + block/vhdx.c | 161 +++++++++++++++++++++++++++++++++++++++++++++++++++- + block/vhdx.h | 14 ++++- + configure | 26 ++++++++- + 4 files changed, 197 insertions(+), 6 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + block/Makefile.objs | 2 +- + block/vhdx.c | 161 ++++++++++++++++++++++++++++++++++++++++++++++++++- + block/vhdx.h | 14 ++++- + configure | 26 ++++++++- + 4 files changed, 197 insertions(+), 6 deletions(-) + +diff --git a/block/Makefile.objs b/block/Makefile.objs +index 3db1839..114f8a5 100644 +--- a/block/Makefile.objs ++++ b/block/Makefile.objs +@@ -2,7 +2,7 @@ block-obj-y += raw.o cow.o qcow.o vdi.o vmdk.o cloop.o dmg.o bochs.o vpc.o vvfat + block-obj-y += qcow2.o qcow2-refcount.o qcow2-cluster.o qcow2-snapshot.o qcow2-cache.o + block-obj-y += qed.o qed-gencb.o qed-l2-cache.o qed-table.o qed-cluster.o + block-obj-y += qed-check.o +-block-obj-y += vhdx.o ++block-obj-$(CONFIG_VHDX) += vhdx.o + block-obj-y += parallels.o blkdebug.o blkverify.o + block-obj-y += snapshot.o qapi.o + block-obj-$(CONFIG_WIN32) += raw-win32.o win32-aio.o +diff --git a/block/vhdx.c b/block/vhdx.c +index 23be4e3..fba2aa9 100644 +--- a/block/vhdx.c ++++ b/block/vhdx.c +@@ -22,6 +22,7 @@ + #include "block/vhdx.h" + #include "migration/migration.h" + ++#include + + /* Several metadata and region table data entries are identified by + * guids in a MS-specific GUID format. */ +@@ -157,12 +158,41 @@ typedef struct BDRVVHDXState { + VHDXBatEntry *bat; + uint64_t bat_offset; + ++ MSGUID session_guid; ++ ++ + VHDXParentLocatorHeader parent_header; + VHDXParentLocatorEntry *parent_entries; + + Error *migration_blocker; + } BDRVVHDXState; + ++/* Calculates new checksum. ++ * ++ * Zero is substituted during crc calculation for the original crc field ++ * crc_offset: byte offset in buf of the buffer crc ++ * buf: buffer pointer ++ * size: size of buffer (must be > crc_offset+4) ++ * ++ * Note: The resulting checksum is in the CPU endianness, not necessarily ++ * in the file format endianness (LE). Any header export to disk should ++ * make sure that vhdx_header_le_export() is used to convert to the ++ * correct endianness ++ */ ++uint32_t vhdx_update_checksum(uint8_t *buf, size_t size, int crc_offset) ++{ ++ uint32_t crc; ++ ++ assert(buf != NULL); ++ assert(size > (crc_offset + sizeof(crc))); ++ ++ memset(buf + crc_offset, 0, sizeof(crc)); ++ crc = crc32c(0xffffffff, buf, size); ++ memcpy(buf + crc_offset, &crc, sizeof(crc)); ++ ++ return crc; ++} ++ + uint32_t vhdx_checksum_calc(uint32_t crc, uint8_t *buf, size_t size, + int crc_offset) + { +@@ -214,6 +244,19 @@ bool vhdx_checksum_is_valid(uint8_t *buf, size_t size, int crc_offset) + + + /* ++ * This generates a UUID that is compliant with the MS GUIDs used ++ * in the VHDX spec (and elsewhere). ++ */ ++void vhdx_guid_generate(MSGUID *guid) ++{ ++ uuid_t uuid; ++ assert(guid != NULL); ++ ++ uuid_generate(uuid); ++ memcpy(guid, uuid, sizeof(MSGUID)); ++} ++ ++/* + * Per the MS VHDX Specification, for every VHDX file: + * - The header section is fixed size - 1 MB + * - The header section is always the first "object" +@@ -251,6 +294,113 @@ static void vhdx_header_le_import(VHDXHeader *h) + le64_to_cpus(&h->log_offset); + } + ++/* All VHDX structures on disk are little endian */ ++static void vhdx_header_le_export(VHDXHeader *orig_h, VHDXHeader *new_h) ++{ ++ assert(orig_h != NULL); ++ assert(new_h != NULL); ++ ++ new_h->signature = cpu_to_le32(orig_h->signature); ++ new_h->checksum = cpu_to_le32(orig_h->checksum); ++ new_h->sequence_number = cpu_to_le64(orig_h->sequence_number); ++ ++ new_h->file_write_guid = orig_h->file_write_guid; ++ new_h->data_write_guid = orig_h->data_write_guid; ++ new_h->log_guid = orig_h->log_guid; ++ ++ cpu_to_leguids(&new_h->file_write_guid); ++ cpu_to_leguids(&new_h->data_write_guid); ++ cpu_to_leguids(&new_h->log_guid); ++ ++ new_h->log_version = cpu_to_le16(orig_h->log_version); ++ new_h->version = cpu_to_le16(orig_h->version); ++ new_h->log_length = cpu_to_le32(orig_h->log_length); ++ new_h->log_offset = cpu_to_le64(orig_h->log_offset); ++} ++ ++/* Update the VHDX headers ++ * ++ * This follows the VHDX spec procedures for header updates. ++ * ++ * - non-current header is updated with largest sequence number ++ */ ++static int vhdx_update_header(BlockDriverState *bs, BDRVVHDXState *s, ++ bool generate_data_write_guid) ++{ ++ int ret = 0; ++ int hdr_idx = 0; ++ uint64_t header_offset = VHDX_HEADER1_OFFSET; ++ ++ VHDXHeader *active_header; ++ VHDXHeader *inactive_header; ++ VHDXHeader header_le; ++ uint8_t *buffer; ++ ++ /* operate on the non-current header */ ++ if (s->curr_header == 0) { ++ hdr_idx = 1; ++ header_offset = VHDX_HEADER2_OFFSET; ++ } ++ ++ active_header = s->headers[s->curr_header]; ++ inactive_header = s->headers[hdr_idx]; ++ ++ inactive_header->sequence_number = active_header->sequence_number + 1; ++ ++ /* a new file guid must be generated before any file write, including ++ * headers */ ++ inactive_header->file_write_guid = s->session_guid; ++ ++ /* a new data guid only needs to be generated before any guest-visible ++ * writes (i.e. something observable via virtual disk read) */ ++ if (generate_data_write_guid) { ++ vhdx_guid_generate(&inactive_header->data_write_guid); ++ } ++ ++ /* the header checksum is not over just the packed size of VHDXHeader, ++ * but rather over the entire 'reserved' range for the header, which is ++ * 4KB (VHDX_HEADER_SIZE). */ ++ ++ buffer = qemu_blockalign(bs, VHDX_HEADER_SIZE); ++ /* we can't assume the extra reserved bytes are 0 */ ++ ret = bdrv_pread(bs->file, header_offset, buffer, VHDX_HEADER_SIZE); ++ if (ret < 0) { ++ goto exit; ++ } ++ /* overwrite the actual VHDXHeader portion */ ++ memcpy(buffer, inactive_header, sizeof(VHDXHeader)); ++ inactive_header->checksum = ++ vhdx_update_checksum(buffer, VHDX_HEADER_SIZE, ++ offsetof(VHDXHeader, checksum)); ++ vhdx_header_le_export(inactive_header, &header_le); ++ ret = bdrv_pwrite_sync(bs->file, header_offset, &header_le, ++ sizeof(VHDXHeader)); ++ if (ret < 0) { ++ goto exit; ++ } ++ s->curr_header = hdr_idx; ++ ++exit: ++ qemu_vfree(buffer); ++ return ret; ++} ++ ++/* ++ * The VHDX spec calls for header updates to be performed twice, so that both ++ * the current and non-current header have valid info ++ */ ++static int vhdx_update_headers(BlockDriverState *bs, BDRVVHDXState *s, ++ bool generate_data_write_guid) ++{ ++ int ret; ++ ++ ret = vhdx_update_header(bs, s, generate_data_write_guid); ++ if (ret < 0) { ++ return ret; ++ } ++ ret = vhdx_update_header(bs, s, generate_data_write_guid); ++ return ret; ++} + + /* opens the specified header block from the VHDX file header section */ + static int vhdx_parse_header(BlockDriverState *bs, BDRVVHDXState *s) +@@ -742,6 +892,11 @@ static int vhdx_open(BlockDriverState *bs, QDict *options, int flags, + goto fail; + } + ++ /* This is used for any header updates, for the file_write_guid. ++ * The spec dictates that a new value should be used for the first ++ * header update */ ++ vhdx_guid_generate(&s->session_guid); ++ + ret = vhdx_parse_header(bs, s); + if (ret) { + goto fail; +@@ -804,8 +959,10 @@ static int vhdx_open(BlockDriverState *bs, QDict *options, int flags, + } + + if (flags & BDRV_O_RDWR) { +- ret = -ENOTSUP; +- goto fail; ++ ret = vhdx_update_headers(bs, s, false); ++ if (ret < 0) { ++ goto fail; ++ } + } + + /* TODO: differencing files, write */ +diff --git a/block/vhdx.h b/block/vhdx.h +index 1dbb320..2223b15 100644 +--- a/block/vhdx.h ++++ b/block/vhdx.h +@@ -67,7 +67,7 @@ typedef struct VHDXFileIdentifier { + * Microsoft is not just 16 bytes though - it is a structure that is defined, + * so we need to follow it here so that endianness does not trip us up */ + +-typedef struct MSGUID { ++typedef struct QEMU_PACKED MSGUID { + uint32_t data1; + uint16_t data2; + uint16_t data3; +@@ -309,17 +309,27 @@ typedef struct QEMU_PACKED VHDXParentLocatorEntry { + /* ----- END VHDX SPECIFICATION STRUCTURES ---- */ + + ++void vhdx_guid_generate(MSGUID *guid); ++ ++uint32_t vhdx_update_checksum(uint8_t *buf, size_t size, int crc_offset); + uint32_t vhdx_checksum_calc(uint32_t crc, uint8_t *buf, size_t size, + int crc_offset); + + bool vhdx_checksum_is_valid(uint8_t *buf, size_t size, int crc_offset); + + +-static void leguid_to_cpus(MSGUID *guid) ++static inline void leguid_to_cpus(MSGUID *guid) + { + le32_to_cpus(&guid->data1); + le16_to_cpus(&guid->data2); + le16_to_cpus(&guid->data3); + } + ++static inline void cpu_to_leguids(MSGUID *guid) ++{ ++ cpu_to_le32s(&guid->data1); ++ cpu_to_le16s(&guid->data2); ++ cpu_to_le16s(&guid->data3); ++} ++ + #endif +diff --git a/configure b/configure +index 33235c4..5161fec 100755 +--- a/configure ++++ b/configure +@@ -245,6 +245,7 @@ libssh2="" + live_block_ops="yes" + live_block_migration="no" + ceph_support="yes" ++vhdx="" + + # parse CC options first + for opt do +@@ -950,7 +951,11 @@ for opt do + ;; + --enable-ceph-support) ceph_support=="yes" + ;; +-*) echo "ERROR: unknown option $opt"; show_help="yes" ++ --enable-vhdx) vhdx="yes" ++ ;; ++ --disable-vhdx) vhdx="no" ++ ;; ++ *) echo "ERROR: unknown option $opt"; show_help="yes" + ;; + esac + done +@@ -1227,6 +1232,8 @@ echo " --disable-live-block-migration disable live block migration" + echo " --enable-live-block-migration enable live block migration" + echo " --disable-ceph-support disable support for rbd block driver support" + echo " --enable-ceph-support enable support for rbd block driver support" ++echo " --disable-vhdx disables support for the Microsoft VHDX image format" ++echo " --enable-vhdx enable support for the Microsoft VHDX image format" + echo "" + echo "NOTE: The object files are built at the place where configure is launched" + exit 1 +@@ -2027,6 +2034,18 @@ EOF + fi + fi + ++if test "$vhdx" = "yes" ; then ++ if test "$uuid" = "no" ; then ++ error_exit "uuid required for VHDX support" ++ fi ++elif test "$vhdx" != "no" ; then ++ if test "$uuid" = "yes" ; then ++ vhdx=yes ++ else ++ vhdx=no ++ fi ++fi ++ + ########################################## + # xfsctl() probe, used for raw-posix + if test "$xfs" != "no" ; then +@@ -3615,6 +3634,7 @@ echo "TPM passthrough $tpm_passthrough" + echo "QOM debugging $qom_cast_debug" + echo "Live block operations $live_block_ops" + echo "Live block migration $live_block_migration" ++echo "vhdx $vhdx" + + if test "$sdl_too_old" = "yes"; then + echo "-> Your SDL version is too old - please upgrade to have SDL support" +@@ -4011,6 +4031,10 @@ if test "ceph_support" = "yes"; then + echo "CONFIG_CEPH_SUPPORT=y" >> $config_host_mak + fi + ++if test "$vhdx" = "yes" ; then ++ echo "CONFIG_VHDX=y" >> $config_host_mak ++fi ++ + # USB host support + if test "$libusb" = "yes"; then + echo "HOST_USB=libusb legacy" >> $config_host_mak +-- +1.7.1 + diff --git a/SOURCES/kvm-block-vhdx-add-log-write-support.patch b/SOURCES/kvm-block-vhdx-add-log-write-support.patch new file mode 100644 index 0000000..2e0e37c --- /dev/null +++ b/SOURCES/kvm-block-vhdx-add-log-write-support.patch @@ -0,0 +1,360 @@ +From db9d361c509aea4ce8aca7b7f16a1808880bad29 Mon Sep 17 00:00:00 2001 +From: Jeffrey Cody +Date: Wed, 20 Nov 2013 19:43:59 +0100 +Subject: [PATCH 16/25] block: vhdx - add log write support + +RH-Author: Jeffrey Cody +Message-id: <376bced13e2a7e1069a50bcbd09f3d822306865a.1384975172.git.jcody@redhat.com> +Patchwork-id: 55809 +O-Subject: [RHEL7 qemu-kvm PATCH 16/26] block: vhdx - add log write support +Bugzilla: 879234 +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Fam Zheng + +This adds support for writing to the VHDX log. + +For spec details, see VHDX Specification Format v1.00: +https://www.microsoft.com/en-us/download/details.aspx?id=34750 + +There are a few limitations to this log support: +1.) There is no caching yet +2.) The log is flushed after each entry + +The primary write interface, vhdx_log_write_and_flush(), performs a log +write followed by an immediate flush of the log. + +As each log entry sector is a minimum of 4KB, partial sector writes are +filled in with data from the disk write destination. + +If the current file log GUID is 0, a new GUID is generated and updated +in the header. + +Signed-off-by: Jeff Cody +Signed-off-by: Stefan Hajnoczi +(cherry picked from commit 8adc52336d9c44ab4c7b9358a7be22ac0ef962bf) +--- + block/vhdx-log.c | 282 +++++++++++++++++++++++++++++++++++++++++++++++++++++++ + block/vhdx.h | 3 + + 2 files changed, 285 insertions(+) + +Signed-off-by: Miroslav Rezanina +--- + block/vhdx-log.c | 282 ++++++++++++++++++++++++++++++++++++++++++++++++++++++ + block/vhdx.h | 3 + + 2 files changed, 285 insertions(+), 0 deletions(-) + +diff --git a/block/vhdx-log.c b/block/vhdx-log.c +index 0284729..ee5583c 100644 +--- a/block/vhdx-log.c ++++ b/block/vhdx-log.c +@@ -156,6 +156,55 @@ exit: + return ret; + } + ++/* Writes num_sectors to the log (all log sectors are 4096 bytes), ++ * from buffer 'buffer'. Upon return, *sectors_written will contain ++ * the number of sectors successfully written. ++ * ++ * It is assumed that 'buffer' is at least 4096*num_sectors large. ++ * ++ * 0 is returned on success, -errno otherwise */ ++static int vhdx_log_write_sectors(BlockDriverState *bs, VHDXLogEntries *log, ++ uint32_t *sectors_written, void *buffer, ++ uint32_t num_sectors) ++{ ++ int ret = 0; ++ uint64_t offset; ++ uint32_t write; ++ void *buffer_tmp; ++ BDRVVHDXState *s = bs->opaque; ++ ++ ret = vhdx_user_visible_write(bs, s); ++ if (ret < 0) { ++ goto exit; ++ } ++ ++ write = log->write; ++ ++ buffer_tmp = buffer; ++ while (num_sectors) { ++ ++ offset = log->offset + write; ++ write = vhdx_log_inc_idx(write, log->length); ++ if (write == log->read) { ++ /* full */ ++ break; ++ } ++ ret = bdrv_pwrite(bs->file, offset, buffer_tmp, VHDX_LOG_SECTOR_SIZE); ++ if (ret < 0) { ++ goto exit; ++ } ++ buffer_tmp += VHDX_LOG_SECTOR_SIZE; ++ ++ log->write = write; ++ *sectors_written = *sectors_written + 1; ++ num_sectors--; ++ } ++ ++exit: ++ return ret; ++} ++ ++ + /* Validates a log entry header */ + static bool vhdx_log_hdr_is_valid(VHDXLogEntries *log, VHDXLogEntryHeader *hdr, + BDRVVHDXState *s) +@@ -726,3 +775,236 @@ exit: + } + + ++ ++static void vhdx_log_raw_to_le_sector(VHDXLogDescriptor *desc, ++ VHDXLogDataSector *sector, void *data, ++ uint64_t seq) ++{ ++ /* 8 + 4084 + 4 = 4096, 1 log sector */ ++ memcpy(&desc->leading_bytes, data, 8); ++ data += 8; ++ cpu_to_le64s(&desc->leading_bytes); ++ memcpy(sector->data, data, 4084); ++ data += 4084; ++ memcpy(&desc->trailing_bytes, data, 4); ++ cpu_to_le32s(&desc->trailing_bytes); ++ data += 4; ++ ++ sector->sequence_high = (uint32_t) (seq >> 32); ++ sector->sequence_low = (uint32_t) (seq & 0xffffffff); ++ sector->data_signature = VHDX_LOG_DATA_SIGNATURE; ++ ++ vhdx_log_desc_le_export(desc); ++ vhdx_log_data_le_export(sector); ++} ++ ++ ++static int vhdx_log_write(BlockDriverState *bs, BDRVVHDXState *s, ++ void *data, uint32_t length, uint64_t offset) ++{ ++ int ret = 0; ++ void *buffer = NULL; ++ void *merged_sector = NULL; ++ void *data_tmp, *sector_write; ++ unsigned int i; ++ int sector_offset; ++ uint32_t desc_sectors, sectors, total_length; ++ uint32_t sectors_written = 0; ++ uint32_t aligned_length; ++ uint32_t leading_length = 0; ++ uint32_t trailing_length = 0; ++ uint32_t partial_sectors = 0; ++ uint32_t bytes_written = 0; ++ uint64_t file_offset; ++ VHDXHeader *header; ++ VHDXLogEntryHeader new_hdr; ++ VHDXLogDescriptor *new_desc = NULL; ++ VHDXLogDataSector *data_sector = NULL; ++ MSGUID new_guid = { 0 }; ++ ++ header = s->headers[s->curr_header]; ++ ++ /* need to have offset read data, and be on 4096 byte boundary */ ++ ++ if (length > header->log_length) { ++ /* no log present. we could create a log here instead of failing */ ++ ret = -EINVAL; ++ goto exit; ++ } ++ ++ if (guid_eq(header->log_guid, zero_guid)) { ++ vhdx_guid_generate(&new_guid); ++ vhdx_update_headers(bs, s, false, &new_guid); ++ } else { ++ /* currently, we require that the log be flushed after ++ * every write. */ ++ ret = -ENOTSUP; ++ goto exit; ++ } ++ ++ /* 0 is an invalid sequence number, but may also represent the first ++ * log write (or a wrapped seq) */ ++ if (s->log.sequence == 0) { ++ s->log.sequence = 1; ++ } ++ ++ sector_offset = offset % VHDX_LOG_SECTOR_SIZE; ++ file_offset = (offset / VHDX_LOG_SECTOR_SIZE) * VHDX_LOG_SECTOR_SIZE; ++ ++ aligned_length = length; ++ ++ /* add in the unaligned head and tail bytes */ ++ if (sector_offset) { ++ leading_length = (VHDX_LOG_SECTOR_SIZE - sector_offset); ++ leading_length = leading_length > length ? length : leading_length; ++ aligned_length -= leading_length; ++ partial_sectors++; ++ } ++ ++ sectors = aligned_length / VHDX_LOG_SECTOR_SIZE; ++ trailing_length = aligned_length - (sectors * VHDX_LOG_SECTOR_SIZE); ++ if (trailing_length) { ++ partial_sectors++; ++ } ++ ++ sectors += partial_sectors; ++ ++ /* sectors is now how many sectors the data itself takes, not ++ * including the header and descriptor metadata */ ++ ++ new_hdr = (VHDXLogEntryHeader) { ++ .signature = VHDX_LOG_SIGNATURE, ++ .tail = s->log.tail, ++ .sequence_number = s->log.sequence, ++ .descriptor_count = sectors, ++ .reserved = 0, ++ .flushed_file_offset = bdrv_getlength(bs->file), ++ .last_file_offset = bdrv_getlength(bs->file), ++ }; ++ ++ new_hdr.log_guid = header->log_guid; ++ ++ desc_sectors = vhdx_compute_desc_sectors(new_hdr.descriptor_count); ++ ++ total_length = (desc_sectors + sectors) * VHDX_LOG_SECTOR_SIZE; ++ new_hdr.entry_length = total_length; ++ ++ vhdx_log_entry_hdr_le_export(&new_hdr); ++ ++ buffer = qemu_blockalign(bs, total_length); ++ memcpy(buffer, &new_hdr, sizeof(new_hdr)); ++ ++ new_desc = (VHDXLogDescriptor *) (buffer + sizeof(new_hdr)); ++ data_sector = buffer + (desc_sectors * VHDX_LOG_SECTOR_SIZE); ++ data_tmp = data; ++ ++ /* All log sectors are 4KB, so for any partial sectors we must ++ * merge the data with preexisting data from the final file ++ * destination */ ++ merged_sector = qemu_blockalign(bs, VHDX_LOG_SECTOR_SIZE); ++ ++ for (i = 0; i < sectors; i++) { ++ new_desc->signature = VHDX_LOG_DESC_SIGNATURE; ++ new_desc->sequence_number = s->log.sequence; ++ new_desc->file_offset = file_offset; ++ ++ if (i == 0 && leading_length) { ++ /* partial sector at the front of the buffer */ ++ ret = bdrv_pread(bs->file, file_offset, merged_sector, ++ VHDX_LOG_SECTOR_SIZE); ++ if (ret < 0) { ++ goto exit; ++ } ++ memcpy(merged_sector + sector_offset, data_tmp, leading_length); ++ bytes_written = leading_length; ++ sector_write = merged_sector; ++ } else if (i == sectors - 1 && trailing_length) { ++ /* partial sector at the end of the buffer */ ++ ret = bdrv_pread(bs->file, ++ file_offset, ++ merged_sector + trailing_length, ++ VHDX_LOG_SECTOR_SIZE - trailing_length); ++ if (ret < 0) { ++ goto exit; ++ } ++ memcpy(merged_sector, data_tmp, trailing_length); ++ bytes_written = trailing_length; ++ sector_write = merged_sector; ++ } else { ++ bytes_written = VHDX_LOG_SECTOR_SIZE; ++ sector_write = data_tmp; ++ } ++ ++ /* populate the raw sector data into the proper structures, ++ * as well as update the descriptor, and convert to proper ++ * endianness */ ++ vhdx_log_raw_to_le_sector(new_desc, data_sector, sector_write, ++ s->log.sequence); ++ ++ data_tmp += bytes_written; ++ data_sector++; ++ new_desc++; ++ file_offset += VHDX_LOG_SECTOR_SIZE; ++ } ++ ++ /* checksum covers entire entry, from the log header through the ++ * last data sector */ ++ vhdx_update_checksum(buffer, total_length, ++ offsetof(VHDXLogEntryHeader, checksum)); ++ cpu_to_le32s((uint32_t *)(buffer + 4)); ++ ++ /* now write to the log */ ++ vhdx_log_write_sectors(bs, &s->log, §ors_written, buffer, ++ desc_sectors + sectors); ++ if (ret < 0) { ++ goto exit; ++ } ++ ++ if (sectors_written != desc_sectors + sectors) { ++ /* instead of failing, we could flush the log here */ ++ ret = -EINVAL; ++ goto exit; ++ } ++ ++ s->log.sequence++; ++ /* write new tail */ ++ s->log.tail = s->log.write; ++ ++exit: ++ qemu_vfree(buffer); ++ qemu_vfree(merged_sector); ++ return ret; ++} ++ ++/* Perform a log write, and then immediately flush the entire log */ ++int vhdx_log_write_and_flush(BlockDriverState *bs, BDRVVHDXState *s, ++ void *data, uint32_t length, uint64_t offset) ++{ ++ int ret = 0; ++ VHDXLogSequence logs = { .valid = true, ++ .count = 1, ++ .hdr = { 0 } }; ++ ++ ++ /* Make sure data written (new and/or changed blocks) is stable ++ * on disk, before creating log entry */ ++ bdrv_flush(bs); ++ ret = vhdx_log_write(bs, s, data, length, offset); ++ if (ret < 0) { ++ goto exit; ++ } ++ logs.log = s->log; ++ ++ /* Make sure log is stable on disk */ ++ bdrv_flush(bs); ++ ret = vhdx_log_flush(bs, s, &logs); ++ if (ret < 0) { ++ goto exit; ++ } ++ ++ s->log = logs.log; ++ ++exit: ++ return ret; ++} ++ +diff --git a/block/vhdx.h b/block/vhdx.h +index 91ef8fe..4bb83de 100644 +--- a/block/vhdx.h ++++ b/block/vhdx.h +@@ -398,6 +398,9 @@ bool vhdx_checksum_is_valid(uint8_t *buf, size_t size, int crc_offset); + + int vhdx_parse_log(BlockDriverState *bs, BDRVVHDXState *s, bool *flushed); + ++int vhdx_log_write_and_flush(BlockDriverState *bs, BDRVVHDXState *s, ++ void *data, uint32_t length, uint64_t offset); ++ + static inline void leguid_to_cpus(MSGUID *guid) + { + le32_to_cpus(&guid->data1); +-- +1.7.1 + diff --git a/SOURCES/kvm-block-vhdx-add-region-overlap-detection-for-image-fi.patch b/SOURCES/kvm-block-vhdx-add-region-overlap-detection-for-image-fi.patch new file mode 100644 index 0000000..15e8568 --- /dev/null +++ b/SOURCES/kvm-block-vhdx-add-region-overlap-detection-for-image-fi.patch @@ -0,0 +1,215 @@ +From a5319d241b02f44f273b9283271b5017b45c0b50 Mon Sep 17 00:00:00 2001 +From: Jeffrey Cody +Date: Wed, 20 Nov 2013 19:43:58 +0100 +Subject: [PATCH 15/25] block: vhdx - add region overlap detection for image files + +RH-Author: Jeffrey Cody +Message-id: +Patchwork-id: 55808 +O-Subject: [RHEL7 qemu-kvm PATCH 15/26] block: vhdx - add region overlap detection for image files +Bugzilla: 879234 +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Fam Zheng + +Regions in the image file cannot overlap - the log, region tables, +and metdata must all be unique and non-overlapping. + +This adds region checking by means of a QLIST; there can be a variable +number of regions and metadata (there may be metadata or region tables +that we do not recognize / know about, but are not required). + +This adds the capability to register a region for later checking, and +to check against registered regions for any overlap. + +Also, if neither the BAT or Metadata region tables are found, return +error. + +Signed-off-by: Jeff Cody +Signed-off-by: Stefan Hajnoczi +(cherry picked from commit 1a848fd4517820981b542e0d10e64c0426414229) +--- + block/vhdx.c | 82 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + block/vhdx.h | 9 +++++++ + 2 files changed, 91 insertions(+) + +Signed-off-by: Miroslav Rezanina +--- + block/vhdx.c | 82 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + block/vhdx.h | 9 ++++++ + 2 files changed, 91 insertions(+), 0 deletions(-) + +diff --git a/block/vhdx.c b/block/vhdx.c +index b552dde..e36c60e 100644 +--- a/block/vhdx.c ++++ b/block/vhdx.c +@@ -204,6 +204,50 @@ void vhdx_guid_generate(MSGUID *guid) + memcpy(guid, uuid, sizeof(MSGUID)); + } + ++/* Check for region overlaps inside the VHDX image */ ++static int vhdx_region_check(BDRVVHDXState *s, uint64_t start, uint64_t length) ++{ ++ int ret = 0; ++ uint64_t end; ++ VHDXRegionEntry *r; ++ ++ end = start + length; ++ QLIST_FOREACH(r, &s->regions, entries) { ++ if (!((start >= r->end) || (end <= r->start))) { ++ ret = -EINVAL; ++ goto exit; ++ } ++ } ++ ++exit: ++ return ret; ++} ++ ++/* Register a region for future checks */ ++static void vhdx_region_register(BDRVVHDXState *s, ++ uint64_t start, uint64_t length) ++{ ++ VHDXRegionEntry *r; ++ ++ r = g_malloc0(sizeof(*r)); ++ ++ r->start = start; ++ r->end = start + length; ++ ++ QLIST_INSERT_HEAD(&s->regions, r, entries); ++} ++ ++/* Free all registered regions */ ++static void vhdx_region_unregister_all(BDRVVHDXState *s) ++{ ++ VHDXRegionEntry *r, *r_next; ++ ++ QLIST_FOREACH_SAFE(r, &s->regions, entries, r_next) { ++ QLIST_REMOVE(r, entries); ++ g_free(r); ++ } ++} ++ + /* + * Per the MS VHDX Specification, for every VHDX file: + * - The header section is fixed size - 1 MB +@@ -389,6 +433,9 @@ static int vhdx_parse_header(BlockDriverState *bs, BDRVVHDXState *s) + } + } + ++ vhdx_region_register(s, s->headers[s->curr_header]->log_offset, ++ s->headers[s->curr_header]->log_length); ++ + ret = 0; + + goto exit; +@@ -452,6 +499,15 @@ static int vhdx_open_region_tables(BlockDriverState *bs, BDRVVHDXState *s) + le32_to_cpus(&rt_entry.length); + le32_to_cpus(&rt_entry.data_bits); + ++ /* check for region overlap between these entries, and any ++ * other memory regions in the file */ ++ ret = vhdx_region_check(s, rt_entry.file_offset, rt_entry.length); ++ if (ret < 0) { ++ goto fail; ++ } ++ ++ vhdx_region_register(s, rt_entry.file_offset, rt_entry.length); ++ + /* see if we recognize the entry */ + if (guid_eq(rt_entry.guid, bat_guid)) { + /* must be unique; if we have already found it this is invalid */ +@@ -482,6 +538,12 @@ static int vhdx_open_region_tables(BlockDriverState *bs, BDRVVHDXState *s) + goto fail; + } + } ++ ++ if (!bat_rt_found || !metadata_rt_found) { ++ ret = -EINVAL; ++ goto fail; ++ } ++ + ret = 0; + + fail: +@@ -751,6 +813,7 @@ static void vhdx_close(BlockDriverState *bs) + error_free(s->migration_blocker); + qemu_vfree(s->log.hdr); + s->log.hdr = NULL; ++ vhdx_region_unregister_all(s); + } + + static int vhdx_open(BlockDriverState *bs, QDict *options, int flags, +@@ -768,6 +831,7 @@ static int vhdx_open(BlockDriverState *bs, QDict *options, int flags, + s->first_visible_write = true; + + qemu_co_mutex_init(&s->lock); ++ QLIST_INIT(&s->regions); + + /* validate the file signature */ + ret = bdrv_pread(bs->file, 0, &signature, sizeof(uint64_t)); +@@ -842,8 +906,26 @@ static int vhdx_open(BlockDriverState *bs, QDict *options, int flags, + goto fail; + } + ++ uint64_t payblocks = s->chunk_ratio; ++ /* endian convert, and verify populated BAT field file offsets against ++ * region table and log entries */ + for (i = 0; i < s->bat_entries; i++) { + le64_to_cpus(&s->bat[i]); ++ if (payblocks--) { ++ /* payload bat entries */ ++ if ((s->bat[i] & VHDX_BAT_STATE_BIT_MASK) == ++ PAYLOAD_BLOCK_FULL_PRESENT) { ++ ret = vhdx_region_check(s, s->bat[i] & VHDX_BAT_FILE_OFF_MASK, ++ s->block_size); ++ if (ret < 0) { ++ goto fail; ++ } ++ } ++ } else { ++ payblocks = s->chunk_ratio; ++ /* Once differencing files are supported, verify sector bitmap ++ * blocks here */ ++ } + } + + if (flags & BDRV_O_RDWR) { +diff --git a/block/vhdx.h b/block/vhdx.h +index b150ad1..91ef8fe 100644 +--- a/block/vhdx.h ++++ b/block/vhdx.h +@@ -230,6 +230,7 @@ typedef struct QEMU_PACKED VHDXLogDataSector { + other bits are reserved */ + #define VHDX_BAT_STATE_BIT_MASK 0x07 + #define VHDX_BAT_FILE_OFF_BITS (64 - 44) ++#define VHDX_BAT_FILE_OFF_MASK 0xFFFFFFFFFFF00000 /* upper 44 bits */ + typedef uint64_t VHDXBatEntry; + + /* ---- METADATA REGION STRUCTURES ---- */ +@@ -334,6 +335,12 @@ typedef struct VHDXLogEntries { + uint32_t tail; + } VHDXLogEntries; + ++typedef struct VHDXRegionEntry { ++ uint64_t start; ++ uint64_t end; ++ QLIST_ENTRY(VHDXRegionEntry) entries; ++} VHDXRegionEntry; ++ + typedef struct BDRVVHDXState { + CoMutex lock; + +@@ -374,6 +381,8 @@ typedef struct BDRVVHDXState { + VHDXParentLocatorEntry *parent_entries; + + Error *migration_blocker; ++ ++ QLIST_HEAD(VHDXRegionHead, VHDXRegionEntry) regions; + } BDRVVHDXState; + + void vhdx_guid_generate(MSGUID *guid); +-- +1.7.1 + diff --git a/SOURCES/kvm-block-vhdx-break-endian-translation-functions-out.patch b/SOURCES/kvm-block-vhdx-break-endian-translation-functions-out.patch new file mode 100644 index 0000000..875f9ad --- /dev/null +++ b/SOURCES/kvm-block-vhdx-break-endian-translation-functions-out.patch @@ -0,0 +1,273 @@ +From 88e96c366d923305d0d3f124bbe295ef5068c6bc Mon Sep 17 00:00:00 2001 +From: Jeffrey Cody +Date: Wed, 20 Nov 2013 19:43:54 +0100 +Subject: [PATCH 11/25] block: vhdx - break endian translation functions out + +RH-Author: Jeffrey Cody +Message-id: <0f4c21e92172fde45d0a5c609a19afa2e1f5a015.1384975172.git.jcody@redhat.com> +Patchwork-id: 55804 +O-Subject: [RHEL7 qemu-kvm PATCH 11/26] block: vhdx - break endian translation functions out +Bugzilla: 879234 +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Fam Zheng + +This moves the endian translation functions out from the vhdx.c source, +into a separate source file. In addition to the previously defined +endian functions, new endian translation functions for log support are +added as well. + +Signed-off-by: Jeff Cody +Signed-off-by: Stefan Hajnoczi +(cherry picked from commit 0f48e8f0978afe0bd44c63749e7df6411da6c437) +--- + block/Makefile.objs | 2 +- + block/vhdx-endian.c | 141 ++++++++++++++++++++++++++++++++++++++++++++++++++++ + block/vhdx.c | 43 ---------------- + block/vhdx.h | 8 +++ + 4 files changed, 150 insertions(+), 44 deletions(-) + create mode 100644 block/vhdx-endian.c + +Signed-off-by: Miroslav Rezanina +--- + block/Makefile.objs | 2 +- + block/vhdx-endian.c | 141 +++++++++++++++++++++++++++++++++++++++++++++++++++ + block/vhdx.c | 43 ---------------- + block/vhdx.h | 8 +++ + 4 files changed, 150 insertions(+), 44 deletions(-) + create mode 100644 block/vhdx-endian.c + +diff --git a/block/Makefile.objs b/block/Makefile.objs +index 114f8a5..a7b3b87 100644 +--- a/block/Makefile.objs ++++ b/block/Makefile.objs +@@ -2,7 +2,7 @@ block-obj-y += raw.o cow.o qcow.o vdi.o vmdk.o cloop.o dmg.o bochs.o vpc.o vvfat + block-obj-y += qcow2.o qcow2-refcount.o qcow2-cluster.o qcow2-snapshot.o qcow2-cache.o + block-obj-y += qed.o qed-gencb.o qed-l2-cache.o qed-table.o qed-cluster.o + block-obj-y += qed-check.o +-block-obj-$(CONFIG_VHDX) += vhdx.o ++block-obj-$(CONFIG_VHDX) += vhdx.o vhdx-endian.o + block-obj-y += parallels.o blkdebug.o blkverify.o + block-obj-y += snapshot.o qapi.o + block-obj-$(CONFIG_WIN32) += raw-win32.o win32-aio.o +diff --git a/block/vhdx-endian.c b/block/vhdx-endian.c +new file mode 100644 +index 0000000..3e93e63 +--- /dev/null ++++ b/block/vhdx-endian.c +@@ -0,0 +1,141 @@ ++/* ++ * Block driver for Hyper-V VHDX Images ++ * ++ * Copyright (c) 2013 Red Hat, Inc., ++ * ++ * Authors: ++ * Jeff Cody ++ * ++ * This is based on the "VHDX Format Specification v1.00", published 8/25/2012 ++ * by Microsoft: ++ * https://www.microsoft.com/en-us/download/details.aspx?id=34750 ++ * ++ * This work is licensed under the terms of the GNU LGPL, version 2 or later. ++ * See the COPYING.LIB file in the top-level directory. ++ * ++ */ ++ ++#include "qemu-common.h" ++#include "block/block_int.h" ++#include "block/vhdx.h" ++ ++#include ++ ++ ++/* ++ * All the VHDX formats on disk are little endian - the following ++ * are helper import/export functions to correctly convert ++ * endianness from disk read to native cpu format, and back again. ++ */ ++ ++ ++/* VHDX File Header */ ++ ++ ++void vhdx_header_le_import(VHDXHeader *h) ++{ ++ assert(h != NULL); ++ ++ le32_to_cpus(&h->signature); ++ le32_to_cpus(&h->checksum); ++ le64_to_cpus(&h->sequence_number); ++ ++ leguid_to_cpus(&h->file_write_guid); ++ leguid_to_cpus(&h->data_write_guid); ++ leguid_to_cpus(&h->log_guid); ++ ++ le16_to_cpus(&h->log_version); ++ le16_to_cpus(&h->version); ++ le32_to_cpus(&h->log_length); ++ le64_to_cpus(&h->log_offset); ++} ++ ++void vhdx_header_le_export(VHDXHeader *orig_h, VHDXHeader *new_h) ++{ ++ assert(orig_h != NULL); ++ assert(new_h != NULL); ++ ++ new_h->signature = cpu_to_le32(orig_h->signature); ++ new_h->checksum = cpu_to_le32(orig_h->checksum); ++ new_h->sequence_number = cpu_to_le64(orig_h->sequence_number); ++ ++ new_h->file_write_guid = orig_h->file_write_guid; ++ new_h->data_write_guid = orig_h->data_write_guid; ++ new_h->log_guid = orig_h->log_guid; ++ ++ cpu_to_leguids(&new_h->file_write_guid); ++ cpu_to_leguids(&new_h->data_write_guid); ++ cpu_to_leguids(&new_h->log_guid); ++ ++ new_h->log_version = cpu_to_le16(orig_h->log_version); ++ new_h->version = cpu_to_le16(orig_h->version); ++ new_h->log_length = cpu_to_le32(orig_h->log_length); ++ new_h->log_offset = cpu_to_le64(orig_h->log_offset); ++} ++ ++ ++/* VHDX Log Headers */ ++ ++ ++void vhdx_log_desc_le_import(VHDXLogDescriptor *d) ++{ ++ assert(d != NULL); ++ ++ le32_to_cpus(&d->signature); ++ le32_to_cpus(&d->trailing_bytes); ++ le64_to_cpus(&d->leading_bytes); ++ le64_to_cpus(&d->file_offset); ++ le64_to_cpus(&d->sequence_number); ++} ++ ++void vhdx_log_desc_le_export(VHDXLogDescriptor *d) ++{ ++ assert(d != NULL); ++ ++ cpu_to_le32s(&d->signature); ++ cpu_to_le32s(&d->trailing_bytes); ++ cpu_to_le64s(&d->leading_bytes); ++ cpu_to_le64s(&d->file_offset); ++ cpu_to_le64s(&d->sequence_number); ++} ++ ++void vhdx_log_data_le_export(VHDXLogDataSector *d) ++{ ++ assert(d != NULL); ++ ++ cpu_to_le32s(&d->data_signature); ++ cpu_to_le32s(&d->sequence_high); ++ cpu_to_le32s(&d->sequence_low); ++} ++ ++void vhdx_log_entry_hdr_le_import(VHDXLogEntryHeader *hdr) ++{ ++ assert(hdr != NULL); ++ ++ le32_to_cpus(&hdr->signature); ++ le32_to_cpus(&hdr->checksum); ++ le32_to_cpus(&hdr->entry_length); ++ le32_to_cpus(&hdr->tail); ++ le64_to_cpus(&hdr->sequence_number); ++ le32_to_cpus(&hdr->descriptor_count); ++ leguid_to_cpus(&hdr->log_guid); ++ le64_to_cpus(&hdr->flushed_file_offset); ++ le64_to_cpus(&hdr->last_file_offset); ++} ++ ++void vhdx_log_entry_hdr_le_export(VHDXLogEntryHeader *hdr) ++{ ++ assert(hdr != NULL); ++ ++ cpu_to_le32s(&hdr->signature); ++ cpu_to_le32s(&hdr->checksum); ++ cpu_to_le32s(&hdr->entry_length); ++ cpu_to_le32s(&hdr->tail); ++ cpu_to_le64s(&hdr->sequence_number); ++ cpu_to_le32s(&hdr->descriptor_count); ++ cpu_to_leguids(&hdr->log_guid); ++ cpu_to_le64s(&hdr->flushed_file_offset); ++ cpu_to_le64s(&hdr->last_file_offset); ++} ++ ++ +diff --git a/block/vhdx.c b/block/vhdx.c +index 16321ff..2efece1 100644 +--- a/block/vhdx.c ++++ b/block/vhdx.c +@@ -223,49 +223,6 @@ static int vhdx_probe(const uint8_t *buf, int buf_size, const char *filename) + return 0; + } + +-/* All VHDX structures on disk are little endian */ +-static void vhdx_header_le_import(VHDXHeader *h) +-{ +- assert(h != NULL); +- +- le32_to_cpus(&h->signature); +- le32_to_cpus(&h->checksum); +- le64_to_cpus(&h->sequence_number); +- +- leguid_to_cpus(&h->file_write_guid); +- leguid_to_cpus(&h->data_write_guid); +- leguid_to_cpus(&h->log_guid); +- +- le16_to_cpus(&h->log_version); +- le16_to_cpus(&h->version); +- le32_to_cpus(&h->log_length); +- le64_to_cpus(&h->log_offset); +-} +- +-/* All VHDX structures on disk are little endian */ +-static void vhdx_header_le_export(VHDXHeader *orig_h, VHDXHeader *new_h) +-{ +- assert(orig_h != NULL); +- assert(new_h != NULL); +- +- new_h->signature = cpu_to_le32(orig_h->signature); +- new_h->checksum = cpu_to_le32(orig_h->checksum); +- new_h->sequence_number = cpu_to_le64(orig_h->sequence_number); +- +- new_h->file_write_guid = orig_h->file_write_guid; +- new_h->data_write_guid = orig_h->data_write_guid; +- new_h->log_guid = orig_h->log_guid; +- +- cpu_to_leguids(&new_h->file_write_guid); +- cpu_to_leguids(&new_h->data_write_guid); +- cpu_to_leguids(&new_h->log_guid); +- +- new_h->log_version = cpu_to_le16(orig_h->log_version); +- new_h->version = cpu_to_le16(orig_h->version); +- new_h->log_length = cpu_to_le32(orig_h->log_length); +- new_h->log_offset = cpu_to_le64(orig_h->log_offset); +-} +- + /* Update the VHDX headers + * + * This follows the VHDX spec procedures for header updates. +diff --git a/block/vhdx.h b/block/vhdx.h +index 76ce4aa..55975a2 100644 +--- a/block/vhdx.h ++++ b/block/vhdx.h +@@ -394,4 +394,12 @@ static inline void cpu_to_leguids(MSGUID *guid) + cpu_to_le16s(&guid->data3); + } + ++void vhdx_header_le_import(VHDXHeader *h); ++void vhdx_header_le_export(VHDXHeader *orig_h, VHDXHeader *new_h); ++void vhdx_log_desc_le_import(VHDXLogDescriptor *d); ++void vhdx_log_desc_le_export(VHDXLogDescriptor *d); ++void vhdx_log_data_le_export(VHDXLogDataSector *d); ++void vhdx_log_entry_hdr_le_import(VHDXLogEntryHeader *hdr); ++void vhdx_log_entry_hdr_le_export(VHDXLogEntryHeader *hdr); ++ + #endif +-- +1.7.1 + diff --git a/SOURCES/kvm-block-vhdx-break-out-code-operations-to-functions.patch b/SOURCES/kvm-block-vhdx-break-out-code-operations-to-functions.patch new file mode 100644 index 0000000..61c9912 --- /dev/null +++ b/SOURCES/kvm-block-vhdx-break-out-code-operations-to-functions.patch @@ -0,0 +1,220 @@ +From e9029068354e2c9dbfe7e7deaa6a96344a8b4d46 Mon Sep 17 00:00:00 2001 +From: Jeffrey Cody +Date: Wed, 20 Nov 2013 19:44:03 +0100 +Subject: [PATCH 20/25] block: vhdx - break out code operations to functions + +RH-Author: Jeffrey Cody +Message-id: <7f3a67c6c0988ecccac88cc5a8985058611e4cfa.1384975172.git.jcody@redhat.com> +Patchwork-id: 55815 +O-Subject: [RHEL7 qemu-kvm PATCH 20/26] block: vhdx - break out code operations to functions +Bugzilla: 879234 +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Fam Zheng + +This is preperation for vhdx_create(). The ability to write headers, +and calculate the number of BAT entries will be needed within the +create() functions, so move this relevant code into helper functions. + +Signed-off-by: Jeff Cody +Signed-off-by: Stefan Hajnoczi +(cherry picked from commit 1e74a971cb3229813112c74dca81e599812b66f3) +--- + block/vhdx.c | 121 +++++++++++++++++++++++++++++++++++++++-------------------- + 1 file changed, 80 insertions(+), 41 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + block/vhdx.c | 121 ++++++++++++++++++++++++++++++++++++++-------------------- + 1 files changed, 80 insertions(+), 41 deletions(-) + +diff --git a/block/vhdx.c b/block/vhdx.c +index 9d51176..5a112e8 100644 +--- a/block/vhdx.c ++++ b/block/vhdx.c +@@ -248,6 +248,14 @@ static void vhdx_region_unregister_all(BDRVVHDXState *s) + } + } + ++static void vhdx_set_shift_bits(BDRVVHDXState *s) ++{ ++ s->logical_sector_size_bits = 31 - clz32(s->logical_sector_size); ++ s->sectors_per_block_bits = 31 - clz32(s->sectors_per_block); ++ s->chunk_ratio_bits = 63 - clz64(s->chunk_ratio); ++ s->block_size_bits = 31 - clz32(s->block_size); ++} ++ + /* + * Per the MS VHDX Specification, for every VHDX file: + * - The header section is fixed size - 1 MB +@@ -267,6 +275,50 @@ static int vhdx_probe(const uint8_t *buf, int buf_size, const char *filename) + return 0; + } + ++/* ++ * Writes the header to the specified offset. ++ * ++ * This will optionally read in buffer data from disk (otherwise zero-fill), ++ * and then update the header checksum. Header is converted to proper ++ * endianness before being written to the specified file offset ++ */ ++static int vhdx_write_header(BlockDriverState *bs_file, VHDXHeader *hdr, ++ uint64_t offset, bool read) ++{ ++ uint8_t *buffer = NULL; ++ int ret; ++ VHDXHeader header_le; ++ ++ assert(bs_file != NULL); ++ assert(hdr != NULL); ++ ++ /* the header checksum is not over just the packed size of VHDXHeader, ++ * but rather over the entire 'reserved' range for the header, which is ++ * 4KB (VHDX_HEADER_SIZE). */ ++ ++ buffer = qemu_blockalign(bs_file, VHDX_HEADER_SIZE); ++ if (read) { ++ /* if true, we can't assume the extra reserved bytes are 0 */ ++ ret = bdrv_pread(bs_file, offset, buffer, VHDX_HEADER_SIZE); ++ if (ret < 0) { ++ goto exit; ++ } ++ } else { ++ memset(buffer, 0, VHDX_HEADER_SIZE); ++ } ++ ++ /* overwrite the actual VHDXHeader portion */ ++ memcpy(buffer, hdr, sizeof(VHDXHeader)); ++ hdr->checksum = vhdx_update_checksum(buffer, VHDX_HEADER_SIZE, ++ offsetof(VHDXHeader, checksum)); ++ vhdx_header_le_export(hdr, &header_le); ++ ret = bdrv_pwrite_sync(bs_file, offset, &header_le, sizeof(VHDXHeader)); ++ ++exit: ++ qemu_vfree(buffer); ++ return ret; ++} ++ + /* Update the VHDX headers + * + * This follows the VHDX spec procedures for header updates. +@@ -282,8 +334,6 @@ static int vhdx_update_header(BlockDriverState *bs, BDRVVHDXState *s, + + VHDXHeader *active_header; + VHDXHeader *inactive_header; +- VHDXHeader header_le; +- uint8_t *buffer; + + /* operate on the non-current header */ + if (s->curr_header == 0) { +@@ -311,31 +361,13 @@ static int vhdx_update_header(BlockDriverState *bs, BDRVVHDXState *s, + inactive_header->log_guid = *log_guid; + } + +- /* the header checksum is not over just the packed size of VHDXHeader, +- * but rather over the entire 'reserved' range for the header, which is +- * 4KB (VHDX_HEADER_SIZE). */ +- +- buffer = qemu_blockalign(bs, VHDX_HEADER_SIZE); +- /* we can't assume the extra reserved bytes are 0 */ +- ret = bdrv_pread(bs->file, header_offset, buffer, VHDX_HEADER_SIZE); +- if (ret < 0) { +- goto exit; +- } +- /* overwrite the actual VHDXHeader portion */ +- memcpy(buffer, inactive_header, sizeof(VHDXHeader)); +- inactive_header->checksum = +- vhdx_update_checksum(buffer, VHDX_HEADER_SIZE, +- offsetof(VHDXHeader, checksum)); +- vhdx_header_le_export(inactive_header, &header_le); +- ret = bdrv_pwrite_sync(bs->file, header_offset, &header_le, +- sizeof(VHDXHeader)); ++ vhdx_write_header(bs->file, inactive_header, header_offset, true); + if (ret < 0) { + goto exit; + } + s->curr_header = hdr_idx; + + exit: +- qemu_vfree(buffer); + return ret; + } + +@@ -773,10 +805,7 @@ static int vhdx_parse_metadata(BlockDriverState *bs, BDRVVHDXState *s) + goto exit; + } + +- s->logical_sector_size_bits = 31 - clz32(s->logical_sector_size); +- s->sectors_per_block_bits = 31 - clz32(s->sectors_per_block); +- s->chunk_ratio_bits = 63 - clz64(s->chunk_ratio); +- s->block_size_bits = 31 - clz32(s->block_size); ++ vhdx_set_shift_bits(s); + + ret = 0; + +@@ -785,6 +814,31 @@ exit: + return ret; + } + ++/* ++ * Calculate the number of BAT entries, including sector ++ * bitmap entries. ++ */ ++static void vhdx_calc_bat_entries(BDRVVHDXState *s) ++{ ++ uint32_t data_blocks_cnt, bitmap_blocks_cnt; ++ ++ data_blocks_cnt = s->virtual_disk_size >> s->block_size_bits; ++ if (s->virtual_disk_size - (data_blocks_cnt << s->block_size_bits)) { ++ data_blocks_cnt++; ++ } ++ bitmap_blocks_cnt = data_blocks_cnt >> s->chunk_ratio_bits; ++ if (data_blocks_cnt - (bitmap_blocks_cnt << s->chunk_ratio_bits)) { ++ bitmap_blocks_cnt++; ++ } ++ ++ if (s->parent_entries) { ++ s->bat_entries = bitmap_blocks_cnt * (s->chunk_ratio + 1); ++ } else { ++ s->bat_entries = data_blocks_cnt + ++ ((data_blocks_cnt - 1) >> s->chunk_ratio_bits); ++ } ++ ++} + + static void vhdx_close(BlockDriverState *bs) + { +@@ -811,7 +865,6 @@ static int vhdx_open(BlockDriverState *bs, QDict *options, int flags, + int ret = 0; + uint32_t i; + uint64_t signature; +- uint32_t data_blocks_cnt, bitmap_blocks_cnt; + bool log_flushed = false; + + +@@ -862,21 +915,7 @@ static int vhdx_open(BlockDriverState *bs, QDict *options, int flags, + * logical_sector_size */ + bs->total_sectors = s->virtual_disk_size >> s->logical_sector_size_bits; + +- data_blocks_cnt = s->virtual_disk_size >> s->block_size_bits; +- if (s->virtual_disk_size - (data_blocks_cnt << s->block_size_bits)) { +- data_blocks_cnt++; +- } +- bitmap_blocks_cnt = data_blocks_cnt >> s->chunk_ratio_bits; +- if (data_blocks_cnt - (bitmap_blocks_cnt << s->chunk_ratio_bits)) { +- bitmap_blocks_cnt++; +- } +- +- if (s->parent_entries) { +- s->bat_entries = bitmap_blocks_cnt * (s->chunk_ratio + 1); +- } else { +- s->bat_entries = data_blocks_cnt + +- ((data_blocks_cnt - 1) >> s->chunk_ratio_bits); +- } ++ vhdx_calc_bat_entries(s); + + s->bat_offset = s->bat_rt.file_offset; + +-- +1.7.1 + diff --git a/SOURCES/kvm-block-vhdx-code-movement-VHDXMetadataEntries-and-BDR.patch b/SOURCES/kvm-block-vhdx-code-movement-VHDXMetadataEntries-and-BDR.patch new file mode 100644 index 0000000..a69ab02 --- /dev/null +++ b/SOURCES/kvm-block-vhdx-code-movement-VHDXMetadataEntries-and-BDR.patch @@ -0,0 +1,163 @@ +From 2abbf288d8f8cd28b89358c50bb881b2afd974c2 Mon Sep 17 00:00:00 2001 +From: Jeffrey Cody +Date: Wed, 20 Nov 2013 19:43:52 +0100 +Subject: [PATCH 09/25] block: vhdx code movement - VHDXMetadataEntries and BDRVVHDXState to header. + +RH-Author: Jeffrey Cody +Message-id: <9c245806ba56c5fa2386de02cffbaace28aa928c.1384975172.git.jcody@redhat.com> +Patchwork-id: 55802 +O-Subject: [RHEL7 qemu-kvm PATCH 09/26] block: vhdx code movement - VHDXMetadataEntries and BDRVVHDXState to header. +Bugzilla: 879234 +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Fam Zheng + +In preparation for VHDX log support, move these structures to the +header. + +Signed-off-by: Jeff Cody +Signed-off-by: Stefan Hajnoczi +(cherry picked from commit 28541d46280733b9afe7b106a3a6665275a45e5f) +--- + block/vhdx.c | 52 ---------------------------------------------------- + block/vhdx.h | 48 ++++++++++++++++++++++++++++++++++++++++++++++++ + 2 files changed, 48 insertions(+), 52 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + block/vhdx.c | 52 ---------------------------------------------------- + block/vhdx.h | 48 ++++++++++++++++++++++++++++++++++++++++++++++++ + 2 files changed, 48 insertions(+), 52 deletions(-) + +diff --git a/block/vhdx.c b/block/vhdx.c +index fba2aa9..16321ff 100644 +--- a/block/vhdx.c ++++ b/block/vhdx.c +@@ -105,16 +105,6 @@ static const MSGUID parent_vhdx_guid = { .data1 = 0xb04aefb7, + META_PAGE_83_PRESENT | META_LOGICAL_SECTOR_SIZE_PRESENT | \ + META_PHYS_SECTOR_SIZE_PRESENT) + +-typedef struct VHDXMetadataEntries { +- VHDXMetadataTableEntry file_parameters_entry; +- VHDXMetadataTableEntry virtual_disk_size_entry; +- VHDXMetadataTableEntry page83_data_entry; +- VHDXMetadataTableEntry logical_sector_size_entry; +- VHDXMetadataTableEntry phys_sector_size_entry; +- VHDXMetadataTableEntry parent_locator_entry; +- uint16_t present; +-} VHDXMetadataEntries; +- + + typedef struct VHDXSectorInfo { + uint32_t bat_idx; /* BAT entry index */ +@@ -125,48 +115,6 @@ typedef struct VHDXSectorInfo { + uint64_t block_offset; /* block offset, in bytes */ + } VHDXSectorInfo; + +- +- +-typedef struct BDRVVHDXState { +- CoMutex lock; +- +- int curr_header; +- VHDXHeader *headers[2]; +- +- VHDXRegionTableHeader rt; +- VHDXRegionTableEntry bat_rt; /* region table for the BAT */ +- VHDXRegionTableEntry metadata_rt; /* region table for the metadata */ +- +- VHDXMetadataTableHeader metadata_hdr; +- VHDXMetadataEntries metadata_entries; +- +- VHDXFileParameters params; +- uint32_t block_size; +- uint32_t block_size_bits; +- uint32_t sectors_per_block; +- uint32_t sectors_per_block_bits; +- +- uint64_t virtual_disk_size; +- uint32_t logical_sector_size; +- uint32_t physical_sector_size; +- +- uint64_t chunk_ratio; +- uint32_t chunk_ratio_bits; +- uint32_t logical_sector_size_bits; +- +- uint32_t bat_entries; +- VHDXBatEntry *bat; +- uint64_t bat_offset; +- +- MSGUID session_guid; +- +- +- VHDXParentLocatorHeader parent_header; +- VHDXParentLocatorEntry *parent_entries; +- +- Error *migration_blocker; +-} BDRVVHDXState; +- + /* Calculates new checksum. + * + * Zero is substituted during crc calculation for the original crc field +diff --git a/block/vhdx.h b/block/vhdx.h +index 2223b15..57375ff 100644 +--- a/block/vhdx.h ++++ b/block/vhdx.h +@@ -308,6 +308,54 @@ typedef struct QEMU_PACKED VHDXParentLocatorEntry { + + /* ----- END VHDX SPECIFICATION STRUCTURES ---- */ + ++typedef struct VHDXMetadataEntries { ++ VHDXMetadataTableEntry file_parameters_entry; ++ VHDXMetadataTableEntry virtual_disk_size_entry; ++ VHDXMetadataTableEntry page83_data_entry; ++ VHDXMetadataTableEntry logical_sector_size_entry; ++ VHDXMetadataTableEntry phys_sector_size_entry; ++ VHDXMetadataTableEntry parent_locator_entry; ++ uint16_t present; ++} VHDXMetadataEntries; ++ ++typedef struct BDRVVHDXState { ++ CoMutex lock; ++ ++ int curr_header; ++ VHDXHeader *headers[2]; ++ ++ VHDXRegionTableHeader rt; ++ VHDXRegionTableEntry bat_rt; /* region table for the BAT */ ++ VHDXRegionTableEntry metadata_rt; /* region table for the metadata */ ++ ++ VHDXMetadataTableHeader metadata_hdr; ++ VHDXMetadataEntries metadata_entries; ++ ++ VHDXFileParameters params; ++ uint32_t block_size; ++ uint32_t block_size_bits; ++ uint32_t sectors_per_block; ++ uint32_t sectors_per_block_bits; ++ ++ uint64_t virtual_disk_size; ++ uint32_t logical_sector_size; ++ uint32_t physical_sector_size; ++ ++ uint64_t chunk_ratio; ++ uint32_t chunk_ratio_bits; ++ uint32_t logical_sector_size_bits; ++ ++ uint32_t bat_entries; ++ VHDXBatEntry *bat; ++ uint64_t bat_offset; ++ ++ MSGUID session_guid; ++ ++ VHDXParentLocatorHeader parent_header; ++ VHDXParentLocatorEntry *parent_entries; ++ ++ Error *migration_blocker; ++} BDRVVHDXState; + + void vhdx_guid_generate(MSGUID *guid); + +-- +1.7.1 + diff --git a/SOURCES/kvm-block-vhdx-code-movement-move-vhdx_close-above-vhdx_.patch b/SOURCES/kvm-block-vhdx-code-movement-move-vhdx_close-above-vhdx_.patch new file mode 100644 index 0000000..262daef --- /dev/null +++ b/SOURCES/kvm-block-vhdx-code-movement-move-vhdx_close-above-vhdx_.patch @@ -0,0 +1,69 @@ +From a9978815f1d701d0f995ec1c8a49b2a05e1fad12 Mon Sep 17 00:00:00 2001 +From: Jeffrey Cody +Date: Wed, 20 Nov 2013 19:43:56 +0100 +Subject: [PATCH 13/25] block: vhdx code movement - move vhdx_close() above vhdx_open() + +RH-Author: Jeffrey Cody +Message-id: <577e97e41700b11687818a8dd0169444f6c58f40.1384975172.git.jcody@redhat.com> +Patchwork-id: 55805 +O-Subject: [RHEL7 qemu-kvm PATCH 13/26] block: vhdx code movement - move vhdx_close() above vhdx_open() +Bugzilla: 879234 +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Fam Zheng + +Signed-off-by: Jeff Cody +Signed-off-by: Stefan Hajnoczi +(cherry picked from commit c46415afc2c99ea052f52f9d68ed9a78799f2c10) +--- + block/vhdx.c | 22 +++++++++++----------- + 1 file changed, 11 insertions(+), 11 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + block/vhdx.c | 22 +++++++++++----------- + 1 files changed, 11 insertions(+), 11 deletions(-) + +diff --git a/block/vhdx.c b/block/vhdx.c +index 49219df..7d697e4 100644 +--- a/block/vhdx.c ++++ b/block/vhdx.c +@@ -778,6 +778,17 @@ exit: + } + + ++static void vhdx_close(BlockDriverState *bs) ++{ ++ BDRVVHDXState *s = bs->opaque; ++ qemu_vfree(s->headers[0]); ++ qemu_vfree(s->headers[1]); ++ qemu_vfree(s->bat); ++ qemu_vfree(s->parent_entries); ++ migrate_del_blocker(s->migration_blocker); ++ error_free(s->migration_blocker); ++} ++ + static int vhdx_open(BlockDriverState *bs, QDict *options, int flags, + Error **errp) + { +@@ -1047,17 +1058,6 @@ static coroutine_fn int vhdx_co_writev(BlockDriverState *bs, int64_t sector_num, + } + + +-static void vhdx_close(BlockDriverState *bs) +-{ +- BDRVVHDXState *s = bs->opaque; +- qemu_vfree(s->headers[0]); +- qemu_vfree(s->headers[1]); +- qemu_vfree(s->bat); +- qemu_vfree(s->parent_entries); +- migrate_del_blocker(s->migration_blocker); +- error_free(s->migration_blocker); +-} +- + static BlockDriver bdrv_vhdx = { + .format_name = "vhdx", + .instance_size = sizeof(BDRVVHDXState), +-- +1.7.1 + diff --git a/SOURCES/kvm-block-vhdx-fix-comment-typos-in-header-fix-incorrect.patch b/SOURCES/kvm-block-vhdx-fix-comment-typos-in-header-fix-incorrect.patch new file mode 100644 index 0000000..6a3604e --- /dev/null +++ b/SOURCES/kvm-block-vhdx-fix-comment-typos-in-header-fix-incorrect.patch @@ -0,0 +1,79 @@ +From 25ed81be92c2171ceae075daa9823e01d7f90da3 Mon Sep 17 00:00:00 2001 +From: Jeffrey Cody +Date: Wed, 20 Nov 2013 19:44:04 +0100 +Subject: [PATCH 21/25] block: vhdx - fix comment typos in header, fix incorrect struct fields + +RH-Author: Jeffrey Cody +Message-id: <65dd76628b4fc349d4a5f58f433e2e682881e85f.1384975172.git.jcody@redhat.com> +Patchwork-id: 55813 +O-Subject: [RHEL7 qemu-kvm PATCH 21/26] block: vhdx - fix comment typos in header, fix incorrect struct fields +Bugzilla: 879234 +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Fam Zheng + +VHDXPage83Data and VHDXParentLocatorHeader both incorrectly had their +MSGUID fields set as arrays of 16. This is incorrect (it stems from +an early version where those fields were uint_8 arrays). Those fields +were, up to this patch, unused. + +Also, there were a couple of typos and incorrect wording in comments, +and those have been fixed up as well. + +Signed-off-by: Jeff Cody +Signed-off-by: Stefan Hajnoczi +(cherry picked from commit 61c02e5687dcc581c9d3413b61040b023adeaa9c) +--- + block/vhdx.h | 10 +++++----- + 1 file changed, 5 insertions(+), 5 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + block/vhdx.h | 10 +++++----- + 1 files changed, 5 insertions(+), 5 deletions(-) + +diff --git a/block/vhdx.h b/block/vhdx.h +index 0acad37..245547b 100644 +--- a/block/vhdx.h ++++ b/block/vhdx.h +@@ -58,7 +58,7 @@ + typedef struct VHDXFileIdentifier { + uint64_t signature; /* "vhdxfile" in ASCII */ + uint16_t creator[256]; /* optional; utf-16 string to identify +- the vhdx file creator. Diagnotistic ++ the vhdx file creator. Diagnostic + only */ + } VHDXFileIdentifier; + +@@ -114,8 +114,8 @@ typedef struct QEMU_PACKED VHDXHeader { + there is no valid log. If non-zero, + log entries with this guid are + valid. */ +- uint16_t log_version; /* version of the log format. Mustn't be +- zero, unless log_guid is also zero */ ++ uint16_t log_version; /* version of the log format. Must be ++ set to zero */ + uint16_t version; /* version of the vhdx file. Currently, + only supported version is "1" */ + uint32_t log_length; /* length of the log. Must be multiple +@@ -281,7 +281,7 @@ typedef struct QEMU_PACKED VHDXVirtualDiskSize { + } VHDXVirtualDiskSize; + + typedef struct QEMU_PACKED VHDXPage83Data { +- MSGUID page_83_data[16]; /* unique id for scsi devices that ++ MSGUID page_83_data; /* unique id for scsi devices that + support page 0x83 */ + } VHDXPage83Data; + +@@ -296,7 +296,7 @@ typedef struct QEMU_PACKED VHDXVirtualDiskPhysicalSectorSize { + } VHDXVirtualDiskPhysicalSectorSize; + + typedef struct QEMU_PACKED VHDXParentLocatorHeader { +- MSGUID locator_type[16]; /* type of the parent virtual disk. */ ++ MSGUID locator_type; /* type of the parent virtual disk. */ + uint16_t reserved; + uint16_t key_value_count; /* number of key/value pairs for this + locator */ +-- +1.7.1 + diff --git a/SOURCES/kvm-block-vhdx-improve-error-message-and-.bdrv_check-imp.patch b/SOURCES/kvm-block-vhdx-improve-error-message-and-.bdrv_check-imp.patch new file mode 100644 index 0000000..8f64060 --- /dev/null +++ b/SOURCES/kvm-block-vhdx-improve-error-message-and-.bdrv_check-imp.patch @@ -0,0 +1,174 @@ +From ef9c4188157e2349ff68710982d9922f4a335b82 Mon Sep 17 00:00:00 2001 +From: Jeffrey Cody +Date: Mon, 13 Jan 2014 20:52:04 +0100 +Subject: [PATCH 12/16] block: vhdx - improve error message, and .bdrv_check implementation + +RH-Author: Jeffrey Cody +Message-id: +Patchwork-id: 56643 +O-Subject: [RHEL7 qemu-kvm PATCH] block: vhdx - improve error message, and .bdrv_check implementation +Bugzilla: 1035001 +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Kevin Wolf +RH-Acked-by: Fam Zheng + +If there is a dirty log file to be replayed in a VHDX image, it is +replayed in .vhdx_open(). However, if the file is opened read-only, +then a somewhat cryptic error message results. + +This adds a more helpful error message for the user. If an image file +contains a log to be replayed, and is opened read-only, the user is +instructed to run 'qemu-img check -r all' on the image file. + +Running qemu-img check -r all will cause the image file to be opened +r/w, which will replay the log file. If a log file replay is detected, +this is flagged, and bdrv_check will increase the corruptions_fixed +count for the image. + +[Fixed typo in error message that was pointed out by Eric Blake +. +--Stefan] + +Signed-off-by: Jeff Cody +Signed-off-by: Stefan Hajnoczi +(cherry picked from commit 7e30e6a6746b417c7e0dbc9af009560fbb63f336) + +Conflicts: + block/vhdx.c + +RHEL7 Notes: Conflict due to different order of members in the + BlockDriver struct. Resolved so that the order matches + what is upstream. + +BZ 1035001 +Brew: http://brewweb.devel.redhat.com/brew/taskinfo?taskID=6861970 + +Signed-off-by: Jeff Cody +--- + block/vhdx-log.c | 13 ++++++++++++- + block/vhdx.c | 25 ++++++++++++++++++++++--- + block/vhdx.h | 5 ++++- + 3 files changed, 38 insertions(+), 5 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + block/vhdx-log.c | 13 ++++++++++++- + block/vhdx.c | 25 ++++++++++++++++++++++--- + block/vhdx.h | 5 ++++- + 3 files changed, 38 insertions(+), 5 deletions(-) + +diff --git a/block/vhdx-log.c b/block/vhdx-log.c +index ee5583c..8c9ae0d 100644 +--- a/block/vhdx-log.c ++++ b/block/vhdx-log.c +@@ -706,7 +706,8 @@ exit: + * + * If read-only, we must replay the log in RAM (or refuse to open + * a dirty VHDX file read-only) */ +-int vhdx_parse_log(BlockDriverState *bs, BDRVVHDXState *s, bool *flushed) ++int vhdx_parse_log(BlockDriverState *bs, BDRVVHDXState *s, bool *flushed, ++ Error **errp) + { + int ret = 0; + VHDXHeader *hdr; +@@ -761,6 +762,16 @@ int vhdx_parse_log(BlockDriverState *bs, BDRVVHDXState *s, bool *flushed) + } + + if (logs.valid) { ++ if (bs->read_only) { ++ ret = -EPERM; ++ error_setg_errno(errp, EPERM, ++ "VHDX image file '%s' opened read-only, but " ++ "contains a log that needs to be replayed. To " ++ "replay the log, execute:\n qemu-img check -r " ++ "all '%s'", ++ bs->filename, bs->filename); ++ goto exit; ++ } + /* now flush the log */ + ret = vhdx_log_flush(bs, s, &logs); + if (ret < 0) { +diff --git a/block/vhdx.c b/block/vhdx.c +index 8e3b371..8b1a5c9 100644 +--- a/block/vhdx.c ++++ b/block/vhdx.c +@@ -878,7 +878,6 @@ static int vhdx_open(BlockDriverState *bs, QDict *options, int flags, + int ret = 0; + uint32_t i; + uint64_t signature; +- bool log_flushed = false; + + + s->bat = NULL; +@@ -907,7 +906,7 @@ static int vhdx_open(BlockDriverState *bs, QDict *options, int flags, + goto fail; + } + +- ret = vhdx_parse_log(bs, s, &log_flushed); ++ ret = vhdx_parse_log(bs, s, &s->log_replayed_on_open, errp); + if (ret < 0) { + goto fail; + } +@@ -1854,6 +1853,24 @@ exit: + return ret; + } + ++/* If opened r/w, the VHDX driver will automatically replay the log, ++ * if one is present, inside the vhdx_open() call. ++ * ++ * If qemu-img check -r all is called, the image is automatically opened ++ * r/w and any log has already been replayed, so there is nothing (currently) ++ * for us to do here ++ */ ++static int vhdx_check(BlockDriverState *bs, BdrvCheckResult *result, ++ BdrvCheckMode fix) ++{ ++ BDRVVHDXState *s = bs->opaque; ++ ++ if (s->log_replayed_on_open) { ++ result->corruptions_fixed++; ++ } ++ return 0; ++} ++ + static QEMUOptionParameter vhdx_create_options[] = { + { + .name = BLOCK_OPT_SIZE, +@@ -1896,8 +1913,10 @@ static BlockDriver bdrv_vhdx = { + .bdrv_reopen_prepare = vhdx_reopen_prepare, + .bdrv_co_readv = vhdx_co_readv, + .bdrv_co_writev = vhdx_co_writev, +- .bdrv_get_info = vhdx_get_info, + .bdrv_create = vhdx_create, ++ .bdrv_get_info = vhdx_get_info, ++ .bdrv_check = vhdx_check, ++ + .create_options = vhdx_create_options, + }; + +diff --git a/block/vhdx.h b/block/vhdx.h +index 365eca0..469e95c 100644 +--- a/block/vhdx.h ++++ b/block/vhdx.h +@@ -394,6 +394,8 @@ typedef struct BDRVVHDXState { + + Error *migration_blocker; + ++ bool log_replayed_on_open; ++ + QLIST_HEAD(VHDXRegionHead, VHDXRegionEntry) regions; + } BDRVVHDXState; + +@@ -408,7 +410,8 @@ uint32_t vhdx_checksum_calc(uint32_t crc, uint8_t *buf, size_t size, + + bool vhdx_checksum_is_valid(uint8_t *buf, size_t size, int crc_offset); + +-int vhdx_parse_log(BlockDriverState *bs, BDRVVHDXState *s, bool *flushed); ++int vhdx_parse_log(BlockDriverState *bs, BDRVVHDXState *s, bool *flushed, ++ Error **errp); + + int vhdx_log_write_and_flush(BlockDriverState *bs, BDRVVHDXState *s, + void *data, uint32_t length, uint64_t offset); +-- +1.7.1 + diff --git a/SOURCES/kvm-block-vhdx-log-parsing-replay-and-flush-support.patch b/SOURCES/kvm-block-vhdx-log-parsing-replay-and-flush-support.patch new file mode 100644 index 0000000..ec9cc44 --- /dev/null +++ b/SOURCES/kvm-block-vhdx-log-parsing-replay-and-flush-support.patch @@ -0,0 +1,959 @@ +From 457fd5fdb8a089eec09fc21e06ce3099633a248a Mon Sep 17 00:00:00 2001 +From: Jeffrey Cody +Date: Wed, 20 Nov 2013 19:43:57 +0100 +Subject: [PATCH 14/25] block: vhdx - log parsing, replay, and flush support + +RH-Author: Jeffrey Cody +Message-id: +Patchwork-id: 55807 +O-Subject: [RHEL7 qemu-kvm PATCH 14/26] block: vhdx - log parsing, replay, and flush support +Bugzilla: 879234 +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Fam Zheng + +This adds support for VHDX v0 logs, as specified in Microsoft's +VHDX Specification Format v1.00: +https://www.microsoft.com/en-us/download/details.aspx?id=34750 + +The following support is added: + +* Log parsing, and validation - validate that an existing log + is correct. + +* Log search - search through an existing log, to find any valid + sequence of entries. + +* Log replay and flush - replay an existing log, and flush/clear + the log when complete. + +The VHDX log is a circular buffer, with elements (sectors) of 4KB. + +A log entry is a variably-length number of sectors, that is +comprised of a header and 'descriptors', that describe each sector. + +A log may contain multiple entries, know as a log sequence. In a log +sequence, each log entry immediately follows the previous entry, with an +incrementing sequence number. There can only ever be one active and +valid sequence in the log. + +Each log entry must match the file log GUID in order to be valid (along +with other criteria). Once we have flushed all valid log entries, we +marked the file log GUID to be zero, which indicates a buffer with no +valid entries. + +Signed-off-by: Jeff Cody +Signed-off-by: Stefan Hajnoczi +(cherry picked from commit 0a43a1b5d7c33208120eeb2d98ebb9ab15dc2c87) +--- + block/Makefile.objs | 2 +- + block/vhdx-log.c | 728 ++++++++++++++++++++++++++++++++++++++++++++++++++++ + block/vhdx.c | 65 +---- + block/vhdx.h | 7 +- + 4 files changed, 749 insertions(+), 53 deletions(-) + create mode 100644 block/vhdx-log.c + +Signed-off-by: Miroslav Rezanina +--- + block/Makefile.objs | 2 +- + block/vhdx-log.c | 728 +++++++++++++++++++++++++++++++++++++++++++++++++++ + block/vhdx.c | 65 +---- + block/vhdx.h | 7 +- + 4 files changed, 749 insertions(+), 53 deletions(-) + create mode 100644 block/vhdx-log.c + +diff --git a/block/Makefile.objs b/block/Makefile.objs +index a7b3b87..84dd57f 100644 +--- a/block/Makefile.objs ++++ b/block/Makefile.objs +@@ -2,7 +2,7 @@ block-obj-y += raw.o cow.o qcow.o vdi.o vmdk.o cloop.o dmg.o bochs.o vpc.o vvfat + block-obj-y += qcow2.o qcow2-refcount.o qcow2-cluster.o qcow2-snapshot.o qcow2-cache.o + block-obj-y += qed.o qed-gencb.o qed-l2-cache.o qed-table.o qed-cluster.o + block-obj-y += qed-check.o +-block-obj-$(CONFIG_VHDX) += vhdx.o vhdx-endian.o ++block-obj-$(CONFIG_VHDX) += vhdx.o vhdx-endian.o vhdx-log.o + block-obj-y += parallels.o blkdebug.o blkverify.o + block-obj-y += snapshot.o qapi.o + block-obj-$(CONFIG_WIN32) += raw-win32.o win32-aio.o +diff --git a/block/vhdx-log.c b/block/vhdx-log.c +new file mode 100644 +index 0000000..0284729 +--- /dev/null ++++ b/block/vhdx-log.c +@@ -0,0 +1,728 @@ ++/* ++ * Block driver for Hyper-V VHDX Images ++ * ++ * Copyright (c) 2013 Red Hat, Inc., ++ * ++ * Authors: ++ * Jeff Cody ++ * ++ * This is based on the "VHDX Format Specification v1.00", published 8/25/2012 ++ * by Microsoft: ++ * https://www.microsoft.com/en-us/download/details.aspx?id=34750 ++ * ++ * This file covers the functionality of the metadata log writing, parsing, and ++ * replay. ++ * ++ * This work is licensed under the terms of the GNU LGPL, version 2 or later. ++ * See the COPYING.LIB file in the top-level directory. ++ * ++ */ ++#include "qemu-common.h" ++#include "block/block_int.h" ++#include "qemu/module.h" ++#include "block/vhdx.h" ++ ++ ++typedef struct VHDXLogSequence { ++ bool valid; ++ uint32_t count; ++ VHDXLogEntries log; ++ VHDXLogEntryHeader hdr; ++} VHDXLogSequence; ++ ++typedef struct VHDXLogDescEntries { ++ VHDXLogEntryHeader hdr; ++ VHDXLogDescriptor desc[]; ++} VHDXLogDescEntries; ++ ++static const MSGUID zero_guid = { 0 }; ++ ++/* The log located on the disk is circular buffer containing ++ * sectors of 4096 bytes each. ++ * ++ * It is assumed for the read/write functions below that the ++ * circular buffer scheme uses a 'one sector open' to indicate ++ * the buffer is full. Given the validation methods used for each ++ * sector, this method should be compatible with other methods that ++ * do not waste a sector. ++ */ ++ ++ ++/* Allow peeking at the hdr entry at the beginning of the current ++ * read index, without advancing the read index */ ++static int vhdx_log_peek_hdr(BlockDriverState *bs, VHDXLogEntries *log, ++ VHDXLogEntryHeader *hdr) ++{ ++ int ret = 0; ++ uint64_t offset; ++ uint32_t read; ++ ++ assert(hdr != NULL); ++ ++ /* peek is only supported on sector boundaries */ ++ if (log->read % VHDX_LOG_SECTOR_SIZE) { ++ ret = -EFAULT; ++ goto exit; ++ } ++ ++ read = log->read; ++ /* we are guaranteed that a) log sectors are 4096 bytes, ++ * and b) the log length is a multiple of 1MB. So, there ++ * is always a round number of sectors in the buffer */ ++ if ((read + sizeof(VHDXLogEntryHeader)) > log->length) { ++ read = 0; ++ } ++ ++ if (read == log->write) { ++ ret = -EINVAL; ++ goto exit; ++ } ++ ++ offset = log->offset + read; ++ ++ ret = bdrv_pread(bs->file, offset, hdr, sizeof(VHDXLogEntryHeader)); ++ if (ret < 0) { ++ goto exit; ++ } ++ ++exit: ++ return ret; ++} ++ ++/* Index increment for log, based on sector boundaries */ ++static int vhdx_log_inc_idx(uint32_t idx, uint64_t length) ++{ ++ idx += VHDX_LOG_SECTOR_SIZE; ++ /* we are guaranteed that a) log sectors are 4096 bytes, ++ * and b) the log length is a multiple of 1MB. So, there ++ * is always a round number of sectors in the buffer */ ++ return idx >= length ? 0 : idx; ++} ++ ++ ++/* Reset the log to empty */ ++static void vhdx_log_reset(BlockDriverState *bs, BDRVVHDXState *s) ++{ ++ MSGUID guid = { 0 }; ++ s->log.read = s->log.write = 0; ++ /* a log guid of 0 indicates an empty log to any parser of v0 ++ * VHDX logs */ ++ vhdx_update_headers(bs, s, false, &guid); ++} ++ ++/* Reads num_sectors from the log (all log sectors are 4096 bytes), ++ * into buffer 'buffer'. Upon return, *sectors_read will contain ++ * the number of sectors successfully read. ++ * ++ * It is assumed that 'buffer' is already allocated, and of sufficient ++ * size (i.e. >= 4096*num_sectors). ++ * ++ * If 'peek' is true, then the tail (read) pointer for the circular buffer is ++ * not modified. ++ * ++ * 0 is returned on success, -errno otherwise. */ ++static int vhdx_log_read_sectors(BlockDriverState *bs, VHDXLogEntries *log, ++ uint32_t *sectors_read, void *buffer, ++ uint32_t num_sectors, bool peek) ++{ ++ int ret = 0; ++ uint64_t offset; ++ uint32_t read; ++ ++ read = log->read; ++ ++ *sectors_read = 0; ++ while (num_sectors) { ++ if (read == log->write) { ++ /* empty */ ++ break; ++ } ++ offset = log->offset + read; ++ ++ ret = bdrv_pread(bs->file, offset, buffer, VHDX_LOG_SECTOR_SIZE); ++ if (ret < 0) { ++ goto exit; ++ } ++ read = vhdx_log_inc_idx(read, log->length); ++ ++ *sectors_read = *sectors_read + 1; ++ num_sectors--; ++ } ++ ++exit: ++ if (!peek) { ++ log->read = read; ++ } ++ return ret; ++} ++ ++/* Validates a log entry header */ ++static bool vhdx_log_hdr_is_valid(VHDXLogEntries *log, VHDXLogEntryHeader *hdr, ++ BDRVVHDXState *s) ++{ ++ int valid = false; ++ ++ if (memcmp(&hdr->signature, "loge", 4)) { ++ goto exit; ++ } ++ ++ /* if the individual entry length is larger than the whole log ++ * buffer, that is obviously invalid */ ++ if (log->length < hdr->entry_length) { ++ goto exit; ++ } ++ ++ /* length of entire entry must be in units of 4KB (log sector size) */ ++ if (hdr->entry_length % (VHDX_LOG_SECTOR_SIZE)) { ++ goto exit; ++ } ++ ++ /* per spec, sequence # must be > 0 */ ++ if (hdr->sequence_number == 0) { ++ goto exit; ++ } ++ ++ /* log entries are only valid if they match the file-wide log guid ++ * found in the active header */ ++ if (!guid_eq(hdr->log_guid, s->headers[s->curr_header]->log_guid)) { ++ goto exit; ++ } ++ ++ if (hdr->descriptor_count * sizeof(VHDXLogDescriptor) > hdr->entry_length) { ++ goto exit; ++ } ++ ++ valid = true; ++ ++exit: ++ return valid; ++} ++ ++/* ++ * Given a log header, this will validate that the descriptors and the ++ * corresponding data sectors (if applicable) ++ * ++ * Validation consists of: ++ * 1. Making sure the sequence numbers matches the entry header ++ * 2. Verifying a valid signature ('zero' or 'desc' for descriptors) ++ * 3. File offset field is a multiple of 4KB ++ * 4. If a data descriptor, the corresponding data sector ++ * has its signature ('data') and matching sequence number ++ * ++ * @desc: the data buffer containing the descriptor ++ * @hdr: the log entry header ++ * ++ * Returns true if valid ++ */ ++static bool vhdx_log_desc_is_valid(VHDXLogDescriptor *desc, ++ VHDXLogEntryHeader *hdr) ++{ ++ bool ret = false; ++ ++ if (desc->sequence_number != hdr->sequence_number) { ++ goto exit; ++ } ++ if (desc->file_offset % VHDX_LOG_SECTOR_SIZE) { ++ goto exit; ++ } ++ ++ if (!memcmp(&desc->signature, "zero", 4)) { ++ if (desc->zero_length % VHDX_LOG_SECTOR_SIZE == 0) { ++ /* valid */ ++ ret = true; ++ } ++ } else if (!memcmp(&desc->signature, "desc", 4)) { ++ /* valid */ ++ ret = true; ++ } ++ ++exit: ++ return ret; ++} ++ ++ ++/* Prior to sector data for a log entry, there is the header ++ * and the descriptors referenced in the header: ++ * ++ * [] = 4KB sector ++ * ++ * [ hdr, desc ][ desc ][ ... ][ data ][ ... ] ++ * ++ * The first sector in a log entry has a 64 byte header, and ++ * up to 126 32-byte descriptors. If more descriptors than ++ * 126 are required, then subsequent sectors can have up to 128 ++ * descriptors. Each sector is 4KB. Data follows the descriptor ++ * sectors. ++ * ++ * This will return the number of sectors needed to encompass ++ * the passed number of descriptors in desc_cnt. ++ * ++ * This will never return 0, even if desc_cnt is 0. ++ */ ++static int vhdx_compute_desc_sectors(uint32_t desc_cnt) ++{ ++ uint32_t desc_sectors; ++ ++ desc_cnt += 2; /* account for header in first sector */ ++ desc_sectors = desc_cnt / 128; ++ if (desc_cnt % 128) { ++ desc_sectors++; ++ } ++ ++ return desc_sectors; ++} ++ ++ ++/* Reads the log header, and subsequent descriptors (if any). This ++ * will allocate all the space for buffer, which must be NULL when ++ * passed into this function. Each descriptor will also be validated, ++ * and error returned if any are invalid. */ ++static int vhdx_log_read_desc(BlockDriverState *bs, BDRVVHDXState *s, ++ VHDXLogEntries *log, VHDXLogDescEntries **buffer) ++{ ++ int ret = 0; ++ uint32_t desc_sectors; ++ uint32_t sectors_read; ++ VHDXLogEntryHeader hdr; ++ VHDXLogDescEntries *desc_entries = NULL; ++ int i; ++ ++ assert(*buffer == NULL); ++ ++ ret = vhdx_log_peek_hdr(bs, log, &hdr); ++ if (ret < 0) { ++ goto exit; ++ } ++ vhdx_log_entry_hdr_le_import(&hdr); ++ if (vhdx_log_hdr_is_valid(log, &hdr, s) == false) { ++ ret = -EINVAL; ++ goto exit; ++ } ++ ++ desc_sectors = vhdx_compute_desc_sectors(hdr.descriptor_count); ++ desc_entries = qemu_blockalign(bs, desc_sectors * VHDX_LOG_SECTOR_SIZE); ++ ++ ret = vhdx_log_read_sectors(bs, log, §ors_read, desc_entries, ++ desc_sectors, false); ++ if (ret < 0) { ++ goto free_and_exit; ++ } ++ if (sectors_read != desc_sectors) { ++ ret = -EINVAL; ++ goto free_and_exit; ++ } ++ ++ /* put in proper endianness, and validate each desc */ ++ for (i = 0; i < hdr.descriptor_count; i++) { ++ vhdx_log_desc_le_import(&desc_entries->desc[i]); ++ if (vhdx_log_desc_is_valid(&desc_entries->desc[i], &hdr) == false) { ++ ret = -EINVAL; ++ goto free_and_exit; ++ } ++ } ++ ++ *buffer = desc_entries; ++ goto exit; ++ ++free_and_exit: ++ qemu_vfree(desc_entries); ++exit: ++ return ret; ++} ++ ++ ++/* Flushes the descriptor described by desc to the VHDX image file. ++ * If the descriptor is a data descriptor, than 'data' must be non-NULL, ++ * and >= 4096 bytes (VHDX_LOG_SECTOR_SIZE), containing the data to be ++ * written. ++ * ++ * Verification is performed to make sure the sequence numbers of a data ++ * descriptor match the sequence number in the desc. ++ * ++ * For a zero descriptor, it may describe multiple sectors to fill with zeroes. ++ * In this case, it should be noted that zeroes are written to disk, and the ++ * image file is not extended as a sparse file. */ ++static int vhdx_log_flush_desc(BlockDriverState *bs, VHDXLogDescriptor *desc, ++ VHDXLogDataSector *data) ++{ ++ int ret = 0; ++ uint64_t seq, file_offset; ++ uint32_t offset = 0; ++ void *buffer = NULL; ++ uint64_t count = 1; ++ int i; ++ ++ buffer = qemu_blockalign(bs, VHDX_LOG_SECTOR_SIZE); ++ ++ if (!memcmp(&desc->signature, "desc", 4)) { ++ /* data sector */ ++ if (data == NULL) { ++ ret = -EFAULT; ++ goto exit; ++ } ++ ++ /* The sequence number of the data sector must match that ++ * in the descriptor */ ++ seq = data->sequence_high; ++ seq <<= 32; ++ seq |= data->sequence_low & 0xffffffff; ++ ++ if (seq != desc->sequence_number) { ++ ret = -EINVAL; ++ goto exit; ++ } ++ ++ /* Each data sector is in total 4096 bytes, however the first ++ * 8 bytes, and last 4 bytes, are located in the descriptor */ ++ memcpy(buffer, &desc->leading_bytes, 8); ++ offset += 8; ++ ++ memcpy(buffer+offset, data->data, 4084); ++ offset += 4084; ++ ++ memcpy(buffer+offset, &desc->trailing_bytes, 4); ++ ++ } else if (!memcmp(&desc->signature, "zero", 4)) { ++ /* write 'count' sectors of sector */ ++ memset(buffer, 0, VHDX_LOG_SECTOR_SIZE); ++ count = desc->zero_length / VHDX_LOG_SECTOR_SIZE; ++ } ++ ++ file_offset = desc->file_offset; ++ ++ /* count is only > 1 if we are writing zeroes */ ++ for (i = 0; i < count; i++) { ++ ret = bdrv_pwrite_sync(bs->file, file_offset, buffer, ++ VHDX_LOG_SECTOR_SIZE); ++ if (ret < 0) { ++ goto exit; ++ } ++ file_offset += VHDX_LOG_SECTOR_SIZE; ++ } ++ ++exit: ++ qemu_vfree(buffer); ++ return ret; ++} ++ ++/* Flush the entire log (as described by 'logs') to the VHDX image ++ * file, and then set the log to 'empty' status once complete. ++ * ++ * The log entries should be validate prior to flushing */ ++static int vhdx_log_flush(BlockDriverState *bs, BDRVVHDXState *s, ++ VHDXLogSequence *logs) ++{ ++ int ret = 0; ++ int i; ++ uint32_t cnt, sectors_read; ++ uint64_t new_file_size; ++ void *data = NULL; ++ VHDXLogDescEntries *desc_entries = NULL; ++ VHDXLogEntryHeader hdr_tmp = { 0 }; ++ ++ cnt = logs->count; ++ ++ data = qemu_blockalign(bs, VHDX_LOG_SECTOR_SIZE); ++ ++ ret = vhdx_user_visible_write(bs, s); ++ if (ret < 0) { ++ goto exit; ++ } ++ ++ /* each iteration represents one log sequence, which may span multiple ++ * sectors */ ++ while (cnt--) { ++ ret = vhdx_log_peek_hdr(bs, &logs->log, &hdr_tmp); ++ if (ret < 0) { ++ goto exit; ++ } ++ /* if the log shows a FlushedFileOffset larger than our current file ++ * size, then that means the file has been truncated / corrupted, and ++ * we must refused to open it / use it */ ++ if (hdr_tmp.flushed_file_offset > bdrv_getlength(bs->file)) { ++ ret = -EINVAL; ++ goto exit; ++ } ++ ++ ret = vhdx_log_read_desc(bs, s, &logs->log, &desc_entries); ++ if (ret < 0) { ++ goto exit; ++ } ++ ++ for (i = 0; i < desc_entries->hdr.descriptor_count; i++) { ++ if (!memcmp(&desc_entries->desc[i].signature, "desc", 4)) { ++ /* data sector, so read a sector to flush */ ++ ret = vhdx_log_read_sectors(bs, &logs->log, §ors_read, ++ data, 1, false); ++ if (ret < 0) { ++ goto exit; ++ } ++ if (sectors_read != 1) { ++ ret = -EINVAL; ++ goto exit; ++ } ++ } ++ ++ ret = vhdx_log_flush_desc(bs, &desc_entries->desc[i], data); ++ if (ret < 0) { ++ goto exit; ++ } ++ } ++ if (bdrv_getlength(bs->file) < desc_entries->hdr.last_file_offset) { ++ new_file_size = desc_entries->hdr.last_file_offset; ++ if (new_file_size % (1024*1024)) { ++ /* round up to nearest 1MB boundary */ ++ new_file_size = ((new_file_size >> 20) + 1) << 20; ++ bdrv_truncate(bs->file, new_file_size); ++ } ++ } ++ qemu_vfree(desc_entries); ++ desc_entries = NULL; ++ } ++ ++ bdrv_flush(bs); ++ /* once the log is fully flushed, indicate that we have an empty log ++ * now. This also sets the log guid to 0, to indicate an empty log */ ++ vhdx_log_reset(bs, s); ++ ++exit: ++ qemu_vfree(data); ++ qemu_vfree(desc_entries); ++ return ret; ++} ++ ++static int vhdx_validate_log_entry(BlockDriverState *bs, BDRVVHDXState *s, ++ VHDXLogEntries *log, uint64_t seq, ++ bool *valid, VHDXLogEntryHeader *entry) ++{ ++ int ret = 0; ++ VHDXLogEntryHeader hdr; ++ void *buffer = NULL; ++ uint32_t i, desc_sectors, total_sectors, crc; ++ uint32_t sectors_read = 0; ++ VHDXLogDescEntries *desc_buffer = NULL; ++ ++ *valid = false; ++ ++ ret = vhdx_log_peek_hdr(bs, log, &hdr); ++ if (ret < 0) { ++ goto inc_and_exit; ++ } ++ ++ vhdx_log_entry_hdr_le_import(&hdr); ++ ++ ++ if (vhdx_log_hdr_is_valid(log, &hdr, s) == false) { ++ goto inc_and_exit; ++ } ++ ++ if (seq > 0) { ++ if (hdr.sequence_number != seq + 1) { ++ goto inc_and_exit; ++ } ++ } ++ ++ desc_sectors = vhdx_compute_desc_sectors(hdr.descriptor_count); ++ ++ /* Read desc sectors, and calculate log checksum */ ++ ++ total_sectors = hdr.entry_length / VHDX_LOG_SECTOR_SIZE; ++ ++ ++ /* read_desc() will incrememnt the read idx */ ++ ret = vhdx_log_read_desc(bs, s, log, &desc_buffer); ++ if (ret < 0) { ++ goto free_and_exit; ++ } ++ ++ crc = vhdx_checksum_calc(0xffffffff, (void *)desc_buffer, ++ desc_sectors * VHDX_LOG_SECTOR_SIZE, 4); ++ crc ^= 0xffffffff; ++ ++ buffer = qemu_blockalign(bs, VHDX_LOG_SECTOR_SIZE); ++ if (total_sectors > desc_sectors) { ++ for (i = 0; i < total_sectors - desc_sectors; i++) { ++ sectors_read = 0; ++ ret = vhdx_log_read_sectors(bs, log, §ors_read, buffer, ++ 1, false); ++ if (ret < 0 || sectors_read != 1) { ++ goto free_and_exit; ++ } ++ crc = vhdx_checksum_calc(crc, buffer, VHDX_LOG_SECTOR_SIZE, -1); ++ crc ^= 0xffffffff; ++ } ++ } ++ crc ^= 0xffffffff; ++ if (crc != desc_buffer->hdr.checksum) { ++ goto free_and_exit; ++ } ++ ++ *valid = true; ++ *entry = hdr; ++ goto free_and_exit; ++ ++inc_and_exit: ++ log->read = vhdx_log_inc_idx(log->read, log->length); ++ ++free_and_exit: ++ qemu_vfree(buffer); ++ qemu_vfree(desc_buffer); ++ return ret; ++} ++ ++/* Search through the log circular buffer, and find the valid, active ++ * log sequence, if any exists ++ * */ ++static int vhdx_log_search(BlockDriverState *bs, BDRVVHDXState *s, ++ VHDXLogSequence *logs) ++{ ++ int ret = 0; ++ uint32_t tail; ++ bool seq_valid = false; ++ VHDXLogSequence candidate = { 0 }; ++ VHDXLogEntryHeader hdr = { 0 }; ++ VHDXLogEntries curr_log; ++ ++ memcpy(&curr_log, &s->log, sizeof(VHDXLogEntries)); ++ curr_log.write = curr_log.length; /* assume log is full */ ++ curr_log.read = 0; ++ ++ ++ /* now we will go through the whole log sector by sector, until ++ * we find a valid, active log sequence, or reach the end of the ++ * log buffer */ ++ for (;;) { ++ uint64_t curr_seq = 0; ++ VHDXLogSequence current = { 0 }; ++ ++ tail = curr_log.read; ++ ++ ret = vhdx_validate_log_entry(bs, s, &curr_log, curr_seq, ++ &seq_valid, &hdr); ++ if (ret < 0) { ++ goto exit; ++ } ++ ++ if (seq_valid) { ++ current.valid = true; ++ current.log = curr_log; ++ current.log.read = tail; ++ current.log.write = curr_log.read; ++ current.count = 1; ++ current.hdr = hdr; ++ ++ ++ for (;;) { ++ ret = vhdx_validate_log_entry(bs, s, &curr_log, curr_seq, ++ &seq_valid, &hdr); ++ if (ret < 0) { ++ goto exit; ++ } ++ if (seq_valid == false) { ++ break; ++ } ++ current.log.write = curr_log.read; ++ current.count++; ++ ++ curr_seq = hdr.sequence_number; ++ } ++ } ++ ++ if (current.valid) { ++ if (candidate.valid == false || ++ current.hdr.sequence_number > candidate.hdr.sequence_number) { ++ candidate = current; ++ } ++ } ++ ++ if (curr_log.read < tail) { ++ break; ++ } ++ } ++ ++ *logs = candidate; ++ ++ if (candidate.valid) { ++ /* this is the next sequence number, for writes */ ++ s->log.sequence = candidate.hdr.sequence_number + 1; ++ } ++ ++ ++exit: ++ return ret; ++} ++ ++/* Parse the replay log. Per the VHDX spec, if the log is present ++ * it must be replayed prior to opening the file, even read-only. ++ * ++ * If read-only, we must replay the log in RAM (or refuse to open ++ * a dirty VHDX file read-only) */ ++int vhdx_parse_log(BlockDriverState *bs, BDRVVHDXState *s, bool *flushed) ++{ ++ int ret = 0; ++ VHDXHeader *hdr; ++ VHDXLogSequence logs = { 0 }; ++ ++ hdr = s->headers[s->curr_header]; ++ ++ *flushed = false; ++ ++ /* s->log.hdr is freed in vhdx_close() */ ++ if (s->log.hdr == NULL) { ++ s->log.hdr = qemu_blockalign(bs, sizeof(VHDXLogEntryHeader)); ++ } ++ ++ s->log.offset = hdr->log_offset; ++ s->log.length = hdr->log_length; ++ ++ if (s->log.offset < VHDX_LOG_MIN_SIZE || ++ s->log.offset % VHDX_LOG_MIN_SIZE) { ++ ret = -EINVAL; ++ goto exit; ++ } ++ ++ /* per spec, only log version of 0 is supported */ ++ if (hdr->log_version != 0) { ++ ret = -EINVAL; ++ goto exit; ++ } ++ ++ /* If either the log guid, or log length is zero, ++ * then a replay log is not present */ ++ if (guid_eq(hdr->log_guid, zero_guid)) { ++ goto exit; ++ } ++ ++ if (hdr->log_length == 0) { ++ goto exit; ++ } ++ ++ if (hdr->log_length % VHDX_LOG_MIN_SIZE) { ++ ret = -EINVAL; ++ goto exit; ++ } ++ ++ ++ /* The log is present, we need to find if and where there is an active ++ * sequence of valid entries present in the log. */ ++ ++ ret = vhdx_log_search(bs, s, &logs); ++ if (ret < 0) { ++ goto exit; ++ } ++ ++ if (logs.valid) { ++ /* now flush the log */ ++ ret = vhdx_log_flush(bs, s, &logs); ++ if (ret < 0) { ++ goto exit; ++ } ++ *flushed = true; ++ } ++ ++ ++exit: ++ return ret; ++} ++ ++ +diff --git a/block/vhdx.c b/block/vhdx.c +index 7d697e4..b552dde 100644 +--- a/block/vhdx.c ++++ b/block/vhdx.c +@@ -735,58 +735,22 @@ exit: + return ret; + } + +-/* Parse the replay log. Per the VHDX spec, if the log is present +- * it must be replayed prior to opening the file, even read-only. +- * +- * If read-only, we must replay the log in RAM (or refuse to open +- * a dirty VHDX file read-only */ +-static int vhdx_parse_log(BlockDriverState *bs, BDRVVHDXState *s) +-{ +- int ret = 0; +- int i; +- VHDXHeader *hdr; +- +- hdr = s->headers[s->curr_header]; +- +- /* either the log guid, or log length is zero, +- * then a replay log is present */ +- for (i = 0; i < sizeof(hdr->log_guid.data4); i++) { +- ret |= hdr->log_guid.data4[i]; +- } +- if (hdr->log_guid.data1 == 0 && +- hdr->log_guid.data2 == 0 && +- hdr->log_guid.data3 == 0 && +- ret == 0) { +- goto exit; +- } +- +- /* per spec, only log version of 0 is supported */ +- if (hdr->log_version != 0) { +- ret = -EINVAL; +- goto exit; +- } +- +- if (hdr->log_length == 0) { +- goto exit; +- } +- +- /* We currently do not support images with logs to replay */ +- ret = -ENOTSUP; +- +-exit: +- return ret; +-} +- + + static void vhdx_close(BlockDriverState *bs) + { + BDRVVHDXState *s = bs->opaque; + qemu_vfree(s->headers[0]); ++ s->headers[0] = NULL; + qemu_vfree(s->headers[1]); ++ s->headers[1] = NULL; + qemu_vfree(s->bat); ++ s->bat = NULL; + qemu_vfree(s->parent_entries); ++ s->parent_entries = NULL; + migrate_del_blocker(s->migration_blocker); + error_free(s->migration_blocker); ++ qemu_vfree(s->log.hdr); ++ s->log.hdr = NULL; + } + + static int vhdx_open(BlockDriverState *bs, QDict *options, int flags, +@@ -797,6 +761,7 @@ static int vhdx_open(BlockDriverState *bs, QDict *options, int flags, + uint32_t i; + uint64_t signature; + uint32_t data_blocks_cnt, bitmap_blocks_cnt; ++ bool log_flushed = false; + + + s->bat = NULL; +@@ -820,24 +785,25 @@ static int vhdx_open(BlockDriverState *bs, QDict *options, int flags, + vhdx_guid_generate(&s->session_guid); + + ret = vhdx_parse_header(bs, s); +- if (ret) { ++ if (ret < 0) { + goto fail; + } + +- ret = vhdx_parse_log(bs, s); +- if (ret) { ++ ret = vhdx_parse_log(bs, s, &log_flushed); ++ if (ret < 0) { + goto fail; + } + + ret = vhdx_open_region_tables(bs, s); +- if (ret) { ++ if (ret < 0) { + goto fail; + } + + ret = vhdx_parse_metadata(bs, s); +- if (ret) { ++ if (ret < 0) { + goto fail; + } ++ + s->block_size = s->params.block_size; + + /* the VHDX spec dictates that virtual_disk_size is always a multiple of +@@ -897,10 +863,7 @@ static int vhdx_open(BlockDriverState *bs, QDict *options, int flags, + + return 0; + fail: +- qemu_vfree(s->headers[0]); +- qemu_vfree(s->headers[1]); +- qemu_vfree(s->bat); +- qemu_vfree(s->parent_entries); ++ vhdx_close(bs); + return ret; + } + +diff --git a/block/vhdx.h b/block/vhdx.h +index 81785e5..b150ad1 100644 +--- a/block/vhdx.h ++++ b/block/vhdx.h +@@ -326,7 +326,11 @@ typedef struct VHDXMetadataEntries { + typedef struct VHDXLogEntries { + uint64_t offset; + uint64_t length; +- uint32_t head; ++ uint32_t write; ++ uint32_t read; ++ VHDXLogEntryHeader *hdr; ++ void *desc_buffer; ++ uint64_t sequence; + uint32_t tail; + } VHDXLogEntries; + +@@ -383,6 +387,7 @@ uint32_t vhdx_checksum_calc(uint32_t crc, uint8_t *buf, size_t size, + + bool vhdx_checksum_is_valid(uint8_t *buf, size_t size, int crc_offset); + ++int vhdx_parse_log(BlockDriverState *bs, BDRVVHDXState *s, bool *flushed); + + static inline void leguid_to_cpus(MSGUID *guid) + { +-- +1.7.1 + diff --git a/SOURCES/kvm-block-vhdx-log-support-struct-and-defines.patch b/SOURCES/kvm-block-vhdx-log-support-struct-and-defines.patch new file mode 100644 index 0000000..a26128d --- /dev/null +++ b/SOURCES/kvm-block-vhdx-log-support-struct-and-defines.patch @@ -0,0 +1,169 @@ +From a60094cdc27c9913ad93fc42383161ed40015e44 Mon Sep 17 00:00:00 2001 +From: Jeffrey Cody +Date: Wed, 20 Nov 2013 19:43:53 +0100 +Subject: [PATCH 10/25] block: vhdx - log support struct and defines + +RH-Author: Jeffrey Cody +Message-id: <2dae7f05c8661b506f3bbaa60cd8b3ad35d7a7e4.1384975172.git.jcody@redhat.com> +Patchwork-id: 55803 +O-Subject: [RHEL7 qemu-kvm PATCH 10/26] block: vhdx - log support struct and defines +Bugzilla: 879234 +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Fam Zheng + +This adds some magic number defines, and internal structure definitions +for VHDX log replay support. The struct VHDXLogEntries does not reflect +an on-disk data structure, and thus does not need to be packed. + +Some minor code style fixes are applied as well. + +Signed-off-by: Jeff Cody +Signed-off-by: Stefan Hajnoczi +(cherry picked from commit 625565d27e8d7c7f7238ccd118a2cd49c1c52963) +--- + block/vhdx.h | 46 ++++++++++++++++++++++++++++++---------------- + 1 file changed, 30 insertions(+), 16 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + block/vhdx.h | 46 ++++++++++++++++++++++++++++++---------------- + 1 files changed, 30 insertions(+), 16 deletions(-) + +diff --git a/block/vhdx.h b/block/vhdx.h +index 57375ff..76ce4aa 100644 +--- a/block/vhdx.h ++++ b/block/vhdx.h +@@ -30,12 +30,12 @@ + * 0.........64KB...........128KB........192KB..........256KB................1MB + */ + +-#define VHDX_HEADER_BLOCK_SIZE (64*1024) ++#define VHDX_HEADER_BLOCK_SIZE (64 * 1024) + + #define VHDX_FILE_ID_OFFSET 0 +-#define VHDX_HEADER1_OFFSET (VHDX_HEADER_BLOCK_SIZE*1) +-#define VHDX_HEADER2_OFFSET (VHDX_HEADER_BLOCK_SIZE*2) +-#define VHDX_REGION_TABLE_OFFSET (VHDX_HEADER_BLOCK_SIZE*3) ++#define VHDX_HEADER1_OFFSET (VHDX_HEADER_BLOCK_SIZE * 1) ++#define VHDX_HEADER2_OFFSET (VHDX_HEADER_BLOCK_SIZE * 2) ++#define VHDX_REGION_TABLE_OFFSET (VHDX_HEADER_BLOCK_SIZE * 3) + + + /* +@@ -77,10 +77,10 @@ typedef struct QEMU_PACKED MSGUID { + #define guid_eq(a, b) \ + (memcmp(&(a), &(b), sizeof(MSGUID)) == 0) + +-#define VHDX_HEADER_SIZE (4*1024) /* although the vhdx_header struct in disk +- is only 582 bytes, for purposes of crc +- the header is the first 4KB of the 64KB +- block */ ++#define VHDX_HEADER_SIZE (4 * 1024) /* although the vhdx_header struct in disk ++ is only 582 bytes, for purposes of crc ++ the header is the first 4KB of the 64KB ++ block */ + + /* The full header is 4KB, although the actual header data is much smaller. + * But for the checksum calculation, it is over the entire 4KB structure, +@@ -92,7 +92,7 @@ typedef struct QEMU_PACKED VHDXHeader { + VHDX file has 2 of these headers, + and only the header with the highest + sequence number is valid */ +- MSGUID file_write_guid; /* 128 bit unique identifier. Must be ++ MSGUID file_write_guid; /* 128 bit unique identifier. Must be + updated to new, unique value before + the first modification is made to + file */ +@@ -151,7 +151,10 @@ typedef struct QEMU_PACKED VHDXRegionTableEntry { + + + /* ---- LOG ENTRY STRUCTURES ---- */ ++#define VHDX_LOG_MIN_SIZE (1024 * 1024) ++#define VHDX_LOG_SECTOR_SIZE 4096 + #define VHDX_LOG_HDR_SIZE 64 ++#define VHDX_LOG_SIGNATURE 0x65676f6c + typedef struct QEMU_PACKED VHDXLogEntryHeader { + uint32_t signature; /* "loge" in ASCII */ + uint32_t checksum; /* CRC-32C hash of the 64KB table */ +@@ -174,7 +177,8 @@ typedef struct QEMU_PACKED VHDXLogEntryHeader { + } VHDXLogEntryHeader; + + #define VHDX_LOG_DESC_SIZE 32 +- ++#define VHDX_LOG_DESC_SIGNATURE 0x63736564 ++#define VHDX_LOG_ZERO_SIGNATURE 0x6f72657a + typedef struct QEMU_PACKED VHDXLogDescriptor { + uint32_t signature; /* "zero" or "desc" in ASCII */ + union { +@@ -194,6 +198,7 @@ typedef struct QEMU_PACKED VHDXLogDescriptor { + vhdx_log_entry_header */ + } VHDXLogDescriptor; + ++#define VHDX_LOG_DATA_SIGNATURE 0x61746164 + typedef struct QEMU_PACKED VHDXLogDataSector { + uint32_t data_signature; /* "data" in ASCII */ + uint32_t sequence_high; /* 4 MSB of 8 byte sequence_number */ +@@ -219,12 +224,12 @@ typedef struct QEMU_PACKED VHDXLogDataSector { + #define SB_BLOCK_PRESENT 6 + + /* per the spec */ +-#define VHDX_MAX_SECTORS_PER_BLOCK (1<<23) ++#define VHDX_MAX_SECTORS_PER_BLOCK (1 << 23) + + /* upper 44 bits are the file offset in 1MB units lower 3 bits are the state + other bits are reserved */ + #define VHDX_BAT_STATE_BIT_MASK 0x07 +-#define VHDX_BAT_FILE_OFF_BITS (64-44) ++#define VHDX_BAT_FILE_OFF_BITS (64 - 44) + typedef uint64_t VHDXBatEntry; + + /* ---- METADATA REGION STRUCTURES ---- */ +@@ -252,8 +257,8 @@ typedef struct QEMU_PACKED VHDXMetadataTableEntry { + metadata region */ + /* note: if length = 0, so is offset */ + uint32_t length; /* length of metadata. <= 1MB. */ +- uint32_t data_bits; /* least-significant 3 bits are flags, the +- rest are reserved (see above) */ ++ uint32_t data_bits; /* least-significant 3 bits are flags, ++ the rest are reserved (see above) */ + uint32_t reserved2; + } VHDXMetadataTableEntry; + +@@ -265,8 +270,8 @@ typedef struct QEMU_PACKED VHDXMetadataTableEntry { + typedef struct QEMU_PACKED VHDXFileParameters { + uint32_t block_size; /* size of each payload block, always + power of 2, <= 256MB and >= 1MB. */ +- uint32_t data_bits; /* least-significant 2 bits are flags, the rest +- are reserved (see above) */ ++ uint32_t data_bits; /* least-significant 2 bits are flags, ++ the rest are reserved (see above) */ + } VHDXFileParameters; + + typedef struct QEMU_PACKED VHDXVirtualDiskSize { +@@ -318,6 +323,13 @@ typedef struct VHDXMetadataEntries { + uint16_t present; + } VHDXMetadataEntries; + ++typedef struct VHDXLogEntries { ++ uint64_t offset; ++ uint64_t length; ++ uint32_t head; ++ uint32_t tail; ++} VHDXLogEntries; ++ + typedef struct BDRVVHDXState { + CoMutex lock; + +@@ -351,6 +363,8 @@ typedef struct BDRVVHDXState { + + MSGUID session_guid; + ++ VHDXLogEntries log; ++ + VHDXParentLocatorHeader parent_header; + VHDXParentLocatorEntry *parent_entries; + +-- +1.7.1 + diff --git a/SOURCES/kvm-block-vhdx-minor-comments-and-typo-correction.patch b/SOURCES/kvm-block-vhdx-minor-comments-and-typo-correction.patch new file mode 100644 index 0000000..38ba616 --- /dev/null +++ b/SOURCES/kvm-block-vhdx-minor-comments-and-typo-correction.patch @@ -0,0 +1,91 @@ +From 59e64d4b4ebda3ec50e4f962f44fb31d5ff5fa86 Mon Sep 17 00:00:00 2001 +From: Jeffrey Cody +Date: Wed, 20 Nov 2013 19:43:50 +0100 +Subject: [PATCH 07/25] block: vhdx - minor comments and typo correction. + +RH-Author: Jeffrey Cody +Message-id: <132355fbfb44520bc218abfdd3e67f9a18201cf6.1384975172.git.jcody@redhat.com> +Patchwork-id: 55800 +O-Subject: [RHEL7 qemu-kvm PATCH 07/26] block: vhdx - minor comments and typo correction. +Bugzilla: 879234 +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Fam Zheng + +Just a couple of minor comments to help note where allocated +buffers are freed, and a typo fix. + +Signed-off-by: Jeff Cody +Signed-off-by: Stefan Hajnoczi +(cherry picked from commit 6e9d290bf62406098ca3d7bf3796463681ed3c39) +--- + block/vhdx.c | 6 ++++-- + block/vhdx.h | 6 +++--- + 2 files changed, 7 insertions(+), 5 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + block/vhdx.c | 6 ++++-- + block/vhdx.h | 6 +++--- + 2 files changed, 7 insertions(+), 5 deletions(-) + +diff --git a/block/vhdx.c b/block/vhdx.c +index 41c3065..23be4e3 100644 +--- a/block/vhdx.c ++++ b/block/vhdx.c +@@ -6,9 +6,9 @@ + * Authors: + * Jeff Cody + * +- * This is based on the "VHDX Format Specification v0.95", published 4/12/2012 ++ * This is based on the "VHDX Format Specification v1.00", published 8/25/2012 + * by Microsoft: +- * https://www.microsoft.com/en-us/download/details.aspx?id=29681 ++ * https://www.microsoft.com/en-us/download/details.aspx?id=34750 + * + * This work is licensed under the terms of the GNU LGPL, version 2 or later. + * See the COPYING.LIB file in the top-level directory. +@@ -264,6 +264,7 @@ static int vhdx_parse_header(BlockDriverState *bs, BDRVVHDXState *s) + uint64_t h2_seq = 0; + uint8_t *buffer; + ++ /* header1 & header2 are freed in vhdx_close() */ + header1 = qemu_blockalign(bs, sizeof(VHDXHeader)); + header2 = qemu_blockalign(bs, sizeof(VHDXHeader)); + +@@ -790,6 +791,7 @@ static int vhdx_open(BlockDriverState *bs, QDict *options, int flags, + goto fail; + } + ++ /* s->bat is freed in vhdx_close() */ + s->bat = qemu_blockalign(bs, s->bat_rt.length); + + ret = bdrv_pread(bs->file, s->bat_offset, s->bat, s->bat_rt.length); +diff --git a/block/vhdx.h b/block/vhdx.h +index c3b64c6..1dbb320 100644 +--- a/block/vhdx.h ++++ b/block/vhdx.h +@@ -6,9 +6,9 @@ + * Authors: + * Jeff Cody + * +- * This is based on the "VHDX Format Specification v0.95", published 4/12/2012 ++ * This is based on the "VHDX Format Specification v1.00", published 8/25/2012 + * by Microsoft: +- * https://www.microsoft.com/en-us/download/details.aspx?id=29681 ++ * https://www.microsoft.com/en-us/download/details.aspx?id=34750 + * + * This work is licensed under the terms of the GNU LGPL, version 2 or later. + * See the COPYING.LIB file in the top-level directory. +@@ -116,7 +116,7 @@ typedef struct QEMU_PACKED VHDXHeader { + valid. */ + uint16_t log_version; /* version of the log format. Mustn't be + zero, unless log_guid is also zero */ +- uint16_t version; /* version of th evhdx file. Currently, ++ uint16_t version; /* version of the vhdx file. Currently, + only supported version is "1" */ + uint32_t log_length; /* length of the log. Must be multiple + of 1MB */ +-- +1.7.1 + diff --git a/SOURCES/kvm-block-vhdx-move-more-endian-translations-to-vhdx-end.patch b/SOURCES/kvm-block-vhdx-move-more-endian-translations-to-vhdx-end.patch new file mode 100644 index 0000000..13c4d5c --- /dev/null +++ b/SOURCES/kvm-block-vhdx-move-more-endian-translations-to-vhdx-end.patch @@ -0,0 +1,191 @@ +From 71ef58e93b4a9aafa838117bdaeebc72c2b826c3 Mon Sep 17 00:00:00 2001 +From: Jeffrey Cody +Date: Wed, 20 Nov 2013 19:44:02 +0100 +Subject: [PATCH 19/25] block: vhdx - move more endian translations to vhdx-endian.c + +RH-Author: Jeffrey Cody +Message-id: +Patchwork-id: 55812 +O-Subject: [RHEL7 qemu-kvm PATCH 19/26] block: vhdx - move more endian translations to vhdx-endian.c +Bugzilla: 879234 +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Fam Zheng + +In preparation for vhdx_create(), move more endian translation +functions out to vhdx-endian.c. + +Signed-off-by: Jeff Cody +Signed-off-by: Stefan Hajnoczi +(cherry picked from commit c325ee1de84dde5b2a90c30e1b788defa31c5d53) +--- + block/vhdx-endian.c | 75 +++++++++++++++++++++++++++++++++++++++++++++++++++++ + block/vhdx.c | 20 +++----------- + block/vhdx.h | 9 ++++++- + 3 files changed, 87 insertions(+), 17 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + block/vhdx-endian.c | 75 +++++++++++++++++++++++++++++++++++++++++++++++++++ + block/vhdx.c | 20 +++----------- + block/vhdx.h | 9 +++++- + 3 files changed, 87 insertions(+), 17 deletions(-) + +diff --git a/block/vhdx-endian.c b/block/vhdx-endian.c +index 3e93e63..fe879ed 100644 +--- a/block/vhdx-endian.c ++++ b/block/vhdx-endian.c +@@ -139,3 +139,78 @@ void vhdx_log_entry_hdr_le_export(VHDXLogEntryHeader *hdr) + } + + ++/* Region table entries */ ++void vhdx_region_header_le_import(VHDXRegionTableHeader *hdr) ++{ ++ assert(hdr != NULL); ++ ++ le32_to_cpus(&hdr->signature); ++ le32_to_cpus(&hdr->checksum); ++ le32_to_cpus(&hdr->entry_count); ++} ++ ++void vhdx_region_header_le_export(VHDXRegionTableHeader *hdr) ++{ ++ assert(hdr != NULL); ++ ++ cpu_to_le32s(&hdr->signature); ++ cpu_to_le32s(&hdr->checksum); ++ cpu_to_le32s(&hdr->entry_count); ++} ++ ++void vhdx_region_entry_le_import(VHDXRegionTableEntry *e) ++{ ++ assert(e != NULL); ++ ++ leguid_to_cpus(&e->guid); ++ le64_to_cpus(&e->file_offset); ++ le32_to_cpus(&e->length); ++ le32_to_cpus(&e->data_bits); ++} ++ ++void vhdx_region_entry_le_export(VHDXRegionTableEntry *e) ++{ ++ assert(e != NULL); ++ ++ cpu_to_leguids(&e->guid); ++ cpu_to_le64s(&e->file_offset); ++ cpu_to_le32s(&e->length); ++ cpu_to_le32s(&e->data_bits); ++} ++ ++ ++/* Metadata headers & table */ ++void vhdx_metadata_header_le_import(VHDXMetadataTableHeader *hdr) ++{ ++ assert(hdr != NULL); ++ ++ le64_to_cpus(&hdr->signature); ++ le16_to_cpus(&hdr->entry_count); ++} ++ ++void vhdx_metadata_header_le_export(VHDXMetadataTableHeader *hdr) ++{ ++ assert(hdr != NULL); ++ ++ cpu_to_le64s(&hdr->signature); ++ cpu_to_le16s(&hdr->entry_count); ++} ++ ++void vhdx_metadata_entry_le_import(VHDXMetadataTableEntry *e) ++{ ++ assert(e != NULL); ++ ++ leguid_to_cpus(&e->item_id); ++ le32_to_cpus(&e->offset); ++ le32_to_cpus(&e->length); ++ le32_to_cpus(&e->data_bits); ++} ++void vhdx_metadata_entry_le_export(VHDXMetadataTableEntry *e) ++{ ++ assert(e != NULL); ++ ++ cpu_to_leguids(&e->item_id); ++ cpu_to_le32s(&e->offset); ++ cpu_to_le32s(&e->length); ++ cpu_to_le32s(&e->data_bits); ++} +diff --git a/block/vhdx.c b/block/vhdx.c +index 97099aa..9d51176 100644 +--- a/block/vhdx.c ++++ b/block/vhdx.c +@@ -472,10 +472,7 @@ static int vhdx_open_region_tables(BlockDriverState *bs, BDRVVHDXState *s) + goto fail; + } + memcpy(&s->rt, buffer, sizeof(s->rt)); +- le32_to_cpus(&s->rt.signature); +- le32_to_cpus(&s->rt.checksum); +- le32_to_cpus(&s->rt.entry_count); +- le32_to_cpus(&s->rt.reserved); ++ vhdx_region_header_le_import(&s->rt); + offset += sizeof(s->rt); + + if (!vhdx_checksum_is_valid(buffer, VHDX_HEADER_BLOCK_SIZE, 4) || +@@ -494,10 +491,7 @@ static int vhdx_open_region_tables(BlockDriverState *bs, BDRVVHDXState *s) + memcpy(&rt_entry, buffer + offset, sizeof(rt_entry)); + offset += sizeof(rt_entry); + +- leguid_to_cpus(&rt_entry.guid); +- le64_to_cpus(&rt_entry.file_offset); +- le32_to_cpus(&rt_entry.length); +- le32_to_cpus(&rt_entry.data_bits); ++ vhdx_region_entry_le_import(&rt_entry); + + /* check for region overlap between these entries, and any + * other memory regions in the file */ +@@ -587,9 +581,7 @@ static int vhdx_parse_metadata(BlockDriverState *bs, BDRVVHDXState *s) + memcpy(&s->metadata_hdr, buffer, sizeof(s->metadata_hdr)); + offset += sizeof(s->metadata_hdr); + +- le64_to_cpus(&s->metadata_hdr.signature); +- le16_to_cpus(&s->metadata_hdr.reserved); +- le16_to_cpus(&s->metadata_hdr.entry_count); ++ vhdx_metadata_header_le_import(&s->metadata_hdr); + + if (memcmp(&s->metadata_hdr.signature, "metadata", 8)) { + ret = -EINVAL; +@@ -608,11 +600,7 @@ static int vhdx_parse_metadata(BlockDriverState *bs, BDRVVHDXState *s) + memcpy(&md_entry, buffer + offset, sizeof(md_entry)); + offset += sizeof(md_entry); + +- leguid_to_cpus(&md_entry.item_id); +- le32_to_cpus(&md_entry.offset); +- le32_to_cpus(&md_entry.length); +- le32_to_cpus(&md_entry.data_bits); +- le32_to_cpus(&md_entry.reserved2); ++ vhdx_metadata_entry_le_import(&md_entry); + + if (guid_eq(md_entry.item_id, file_param_guid)) { + if (s->metadata_entries.present & META_FILE_PARAMETER_PRESENT) { +diff --git a/block/vhdx.h b/block/vhdx.h +index 7deb7fd..0acad37 100644 +--- a/block/vhdx.h ++++ b/block/vhdx.h +@@ -421,7 +421,14 @@ void vhdx_log_desc_le_export(VHDXLogDescriptor *d); + void vhdx_log_data_le_export(VHDXLogDataSector *d); + void vhdx_log_entry_hdr_le_import(VHDXLogEntryHeader *hdr); + void vhdx_log_entry_hdr_le_export(VHDXLogEntryHeader *hdr); +- ++void vhdx_region_header_le_import(VHDXRegionTableHeader *hdr); ++void vhdx_region_header_le_export(VHDXRegionTableHeader *hdr); ++void vhdx_region_entry_le_import(VHDXRegionTableEntry *e); ++void vhdx_region_entry_le_export(VHDXRegionTableEntry *e); ++void vhdx_metadata_header_le_import(VHDXMetadataTableHeader *hdr); ++void vhdx_metadata_header_le_export(VHDXMetadataTableHeader *hdr); ++void vhdx_metadata_entry_le_import(VHDXMetadataTableEntry *e); ++void vhdx_metadata_entry_le_export(VHDXMetadataTableEntry *e); + int vhdx_user_visible_write(BlockDriverState *bs, BDRVVHDXState *s); + + #endif +-- +1.7.1 + diff --git a/SOURCES/kvm-block-vhdx-qemu-iotest-log-replay-of-data-sector.patch b/SOURCES/kvm-block-vhdx-qemu-iotest-log-replay-of-data-sector.patch new file mode 100644 index 0000000..21a3fcb --- /dev/null +++ b/SOURCES/kvm-block-vhdx-qemu-iotest-log-replay-of-data-sector.patch @@ -0,0 +1,150 @@ +From 5f1f1921575005ea286f1eb408f62064728df972 Mon Sep 17 00:00:00 2001 +From: Jeffrey Cody +Date: Wed, 20 Nov 2013 19:44:08 +0100 +Subject: [PATCH 25/25] block: vhdx qemu-iotest - log replay of data sector + +RH-Author: Jeffrey Cody +Message-id: <1a13302bddec68d7ee3e2f3be3a457c4bc61eea4.1384975172.git.jcody@redhat.com> +Patchwork-id: 55818 +O-Subject: [RHEL7 qemu-kvm PATCH 25/26] block: vhdx qemu-iotest - log replay of data sector +Bugzilla: 879234 +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Fam Zheng + +This tests the replay of a data sector in a VHDX image file. + +The image file is a 10G dynamic image, with 4MB block size. The +image was created with qemu-img, and the log left unplayed by +modification of the vhdx image format driver. + +It was verified under both QEMU and Hyper-V that the image file, +post log replay, matched. + +Signed-off-by: Jeff Cody +Signed-off-by: Stefan Hajnoczi +(cherry picked from commit e78835b722eb26f5a56370166e99b69e9751ea2a) + +Conflicts: + tests/qemu-iotests/group + +RHEL7 Notes: Conflict due to test number leapfrogging tests that have + not yet been backported into RHEL7. + +Signed-off-by: Jeff Cody +--- + tests/qemu-iotests/070 | 67 +++++++++++++++++++++ + tests/qemu-iotests/070.out | 8 +++ + tests/qemu-iotests/group | 1 + + 4 files changed, 76 insertions(+) + create mode 100755 tests/qemu-iotests/070 + create mode 100644 tests/qemu-iotests/070.out + +Signed-off-by: Miroslav Rezanina +--- + tests/qemu-iotests/070 | 67 ++++++++++++++++++++++++++++++++++++++++++++ + tests/qemu-iotests/070.out | 8 +++++ + tests/qemu-iotests/group | 1 + + 3 files changed, 76 insertions(+), 0 deletions(-) + create mode 100755 tests/qemu-iotests/070 + create mode 100644 tests/qemu-iotests/070.out + +diff --git a/tests/qemu-iotests/070 b/tests/qemu-iotests/070 +new file mode 100755 +index 0000000..41bf100 +--- /dev/null ++++ b/tests/qemu-iotests/070 +@@ -0,0 +1,67 @@ ++#!/bin/bash ++# ++# Test VHDX log replay from an image with a journal that needs to be ++# replayed ++# ++# Copyright (C) 2013 Red Hat, Inc. ++# ++# This program is free software; you can redistribute it and/or modify ++# it under the terms of the GNU General Public License as published by ++# the Free Software Foundation; either version 2 of the License, or ++# (at your option) any later version. ++# ++# This program is distributed in the hope that it will be useful, ++# but WITHOUT ANY WARRANTY; without even the implied warranty of ++# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++# GNU General Public License for more details. ++# ++# You should have received a copy of the GNU General Public License ++# along with this program. If not, see . ++# ++ ++# creator ++owner=jcody@redhat.com ++ ++seq=`basename $0` ++echo "QA output created by $seq" ++ ++here=`pwd` ++tmp=/tmp/$$ ++status=1 # failure is the default! ++ ++_cleanup() ++{ ++ _cleanup_test_img ++} ++trap "_cleanup; exit \$status" 0 1 2 3 15 ++ ++# get standard environment, filters and checks ++. ./common.rc ++. ./common.filter ++ ++_supported_fmt vhdx ++_supported_proto generic ++_supported_os Linux ++ ++# With the log replayed, the pattern 0xa5 extends to 0xc025000 ++# If the log was not replayed, it would only extend to 0xc000000 ++# ++# This image is a 10G dynamic image, with 4M block size, and 1 unplayed ++# data sector in the log ++# ++# This image was created with qemu-img, however it was verified using ++# Hyper-V to properly replay the logs and give the same post-replay ++# image as qemu. ++_use_sample_img iotest-dirtylog-10G-4M.vhdx.bz2 ++ ++echo ++echo "=== Verify open image read-only fails, due to dirty log ===" ++$QEMU_IO -r -c "read -pP 0xa5 0 18M" "$TEST_IMG" 2>&1 | grep -o "Permission denied" ++ ++echo "=== Verify open image replays log ===" ++$QEMU_IO -c "read -pP 0xa5 0 18M" "$TEST_IMG" | _filter_qemu_io ++ ++# success, all done ++echo "*** done" ++rm -f $seq.full ++status=0 +diff --git a/tests/qemu-iotests/070.out b/tests/qemu-iotests/070.out +new file mode 100644 +index 0000000..9db8ff2 +--- /dev/null ++++ b/tests/qemu-iotests/070.out +@@ -0,0 +1,8 @@ ++QA output created by 070 ++ ++=== Verify open image read-only fails, due to dirty log === ++Permission denied ++=== Verify open image replays log === ++read 18874368/18874368 bytes at offset 0 ++18 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) ++*** done +diff --git a/tests/qemu-iotests/group b/tests/qemu-iotests/group +index 1a182ed..0867b0f 100644 +--- a/tests/qemu-iotests/group ++++ b/tests/qemu-iotests/group +@@ -68,3 +68,4 @@ + 065 rw auto + 067 rw auto + 068 rw auto ++070 rw auto +-- +1.7.1 + diff --git a/SOURCES/kvm-block-vhdx-remove-BAT-file-offset-bit-shifting.patch b/SOURCES/kvm-block-vhdx-remove-BAT-file-offset-bit-shifting.patch new file mode 100644 index 0000000..f087f4a --- /dev/null +++ b/SOURCES/kvm-block-vhdx-remove-BAT-file-offset-bit-shifting.patch @@ -0,0 +1,84 @@ +From 989d971046a36afa7acb67855f565603297ad2e8 Mon Sep 17 00:00:00 2001 +From: Jeffrey Cody +Date: Wed, 20 Nov 2013 19:44:01 +0100 +Subject: [PATCH 18/25] block: vhdx - remove BAT file offset bit shifting + +RH-Author: Jeffrey Cody +Message-id: <348f6a1952aa68e9a5cfefb56a7e86f5ff1d01c9.1384975172.git.jcody@redhat.com> +Patchwork-id: 55811 +O-Subject: [RHEL7 qemu-kvm PATCH 18/26] block: vhdx - remove BAT file offset bit shifting +Bugzilla: 879234 +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Fam Zheng + +Bit shifting can be fun, but in this case it was unnecessary. The +upper 44 bits of the 64-bit BAT entry is specifies the File Offset, +so we shifted the bits to get access to the value. + +However, per the spec the value is in MB. So we dutifully shifted back +to the left by 20 bits, to convert to a true uint64_t file offset. + +This replaces those steps with just a bit mask, to get rid of the lower +20 bits instead. + +Signed-off-by: Jeff Cody +Signed-off-by: Stefan Hajnoczi +(cherry picked from commit 0b7da092b40734538631c3ad461c1753a87535fc) +--- + block/vhdx.c | 6 ++---- + block/vhdx.h | 1 - + 2 files changed, 2 insertions(+), 5 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + block/vhdx.c | 6 ++---- + block/vhdx.h | 1 - + 2 files changed, 2 insertions(+), 5 deletions(-) + +diff --git a/block/vhdx.c b/block/vhdx.c +index baf8970..97099aa 100644 +--- a/block/vhdx.c ++++ b/block/vhdx.c +@@ -985,7 +985,7 @@ static void vhdx_block_translate(BDRVVHDXState *s, int64_t sector_num, + + sinfo->bytes_avail = sinfo->sectors_avail << s->logical_sector_size_bits; + +- sinfo->file_offset = s->bat[sinfo->bat_idx] >> VHDX_BAT_FILE_OFF_BITS; ++ sinfo->file_offset = s->bat[sinfo->bat_idx] & VHDX_BAT_FILE_OFF_MASK; + + sinfo->block_offset = block_offset << s->logical_sector_size_bits; + +@@ -999,7 +999,6 @@ static void vhdx_block_translate(BDRVVHDXState *s, int64_t sector_num, + * in the block, and add in the payload data block offset + * in the file, in bytes, to get the final read address */ + +- sinfo->file_offset <<= 20; /* now in bytes, rather than 1MB units */ + sinfo->file_offset += sinfo->block_offset; + } + +@@ -1110,8 +1109,7 @@ static void vhdx_update_bat_table_entry(BlockDriverState *bs, BDRVVHDXState *s, + { + /* The BAT entry is a uint64, with 44 bits for the file offset in units of + * 1MB, and 3 bits for the block state. */ +- s->bat[sinfo->bat_idx] = ((sinfo->file_offset>>20) << +- VHDX_BAT_FILE_OFF_BITS); ++ s->bat[sinfo->bat_idx] = sinfo->file_offset; + + s->bat[sinfo->bat_idx] |= state & VHDX_BAT_STATE_BIT_MASK; + +diff --git a/block/vhdx.h b/block/vhdx.h +index a85c5c8..7deb7fd 100644 +--- a/block/vhdx.h ++++ b/block/vhdx.h +@@ -229,7 +229,6 @@ typedef struct QEMU_PACKED VHDXLogDataSector { + /* upper 44 bits are the file offset in 1MB units lower 3 bits are the state + other bits are reserved */ + #define VHDX_BAT_STATE_BIT_MASK 0x07 +-#define VHDX_BAT_FILE_OFF_BITS (64 - 44) + #define VHDX_BAT_FILE_OFF_MASK 0xFFFFFFFFFFF00000 /* upper 44 bits */ + typedef uint64_t VHDXBatEntry; + +-- +1.7.1 + diff --git a/SOURCES/kvm-block-vhdx-update-_make_test_img-to-filter-out-vhdx-.patch b/SOURCES/kvm-block-vhdx-update-_make_test_img-to-filter-out-vhdx-.patch new file mode 100644 index 0000000..ccf4958 --- /dev/null +++ b/SOURCES/kvm-block-vhdx-update-_make_test_img-to-filter-out-vhdx-.patch @@ -0,0 +1,50 @@ +From 98ce0a262f9b19a452e202e01ca84584079d22f2 Mon Sep 17 00:00:00 2001 +From: Jeffrey Cody +Date: Wed, 20 Nov 2013 19:44:06 +0100 +Subject: [PATCH 23/25] block: vhdx - update _make_test_img() to filter out vhdx options + +RH-Author: Jeffrey Cody +Message-id: <8632a15d525b341bea089780916ffab61f44a34f.1384975172.git.jcody@redhat.com> +Patchwork-id: 55816 +O-Subject: [RHEL7 qemu-kvm PATCH 23/26] block: vhdx - update _make_test_img() to filter out vhdx options +Bugzilla: 879234 +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Fam Zheng + +The non-global option output is suppresed in _make_test_img() for +output verification in the 0?? tests. This adds suppression for +the vhdx-unique options as well. This allows check -vhdx to run +successfully. + +Signed-off-by: Jeff Cody +Signed-off-by: Stefan Hajnoczi +(cherry picked from commit 228b234dd73383408743d749d29a6c37e9d99981) +--- + tests/qemu-iotests/common.rc | 5 ++++- + 1 file changed, 4 insertions(+), 1 deletion(-) + +Signed-off-by: Miroslav Rezanina +--- + tests/qemu-iotests/common.rc | 5 ++++- + 1 files changed, 4 insertions(+), 1 deletions(-) + +diff --git a/tests/qemu-iotests/common.rc b/tests/qemu-iotests/common.rc +index d24de2c..7f62457 100644 +--- a/tests/qemu-iotests/common.rc ++++ b/tests/qemu-iotests/common.rc +@@ -157,7 +157,10 @@ _make_test_img() + -e "s# zeroed_grain=\\(on\\|off\\)##g" \ + -e "s# subformat='[^']*'##g" \ + -e "s# adapter_type='[^']*'##g" \ +- -e "s# lazy_refcounts=\\(on\\|off\\)##g" ++ -e "s# lazy_refcounts=\\(on\\|off\\)##g" \ ++ -e "s# block_size=[0-9]\\+##g" \ ++ -e "s# block_state_zero=\\(on\\|off\\)##g" \ ++ -e "s# log_size=[0-9]\\+##g" + + # Start an NBD server on the image file, which is what we'll be talking to + if [ $IMGPROTO = "nbd" ]; then +-- +1.7.1 + diff --git a/SOURCES/kvm-block-vhdx-update-log-guid-in-header-and-first-write.patch b/SOURCES/kvm-block-vhdx-update-log-guid-in-header-and-first-write.patch new file mode 100644 index 0000000..f67ee73 --- /dev/null +++ b/SOURCES/kvm-block-vhdx-update-log-guid-in-header-and-first-write.patch @@ -0,0 +1,146 @@ +From c310637234eeafe32d0eb5626f91e12b5a2399b9 Mon Sep 17 00:00:00 2001 +From: Jeffrey Cody +Date: Wed, 20 Nov 2013 19:43:55 +0100 +Subject: [PATCH 12/25] block: vhdx - update log guid in header, and first write tracker + +RH-Author: Jeffrey Cody +Message-id: <313d521b2aab6f6657de5b4fbb9cc10e58d9d5c4.1384975172.git.jcody@redhat.com> +Patchwork-id: 55806 +O-Subject: [RHEL7 qemu-kvm PATCH 12/26] block: vhdx - update log guid in header, and first write tracker +Bugzilla: 879234 +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Fam Zheng + +Allow tracking of first file write in the VHDX image, as well as +the ability to update the GUID in the header. This is in preparation +for log support. + +Signed-off-by: Jeff Cody +Signed-off-by: Stefan Hajnoczi +(cherry picked from commit c3906c5e8281b37a526c706596af8575d6ac00d3) +--- + block/vhdx.c | 30 ++++++++++++++++++++++++------ + block/vhdx.h | 6 ++++++ + 2 files changed, 30 insertions(+), 6 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + block/vhdx.c | 30 ++++++++++++++++++++++++------ + block/vhdx.h | 6 ++++++ + 2 files changed, 30 insertions(+), 6 deletions(-) + +diff --git a/block/vhdx.c b/block/vhdx.c +index 2efece1..49219df 100644 +--- a/block/vhdx.c ++++ b/block/vhdx.c +@@ -230,7 +230,7 @@ static int vhdx_probe(const uint8_t *buf, int buf_size, const char *filename) + * - non-current header is updated with largest sequence number + */ + static int vhdx_update_header(BlockDriverState *bs, BDRVVHDXState *s, +- bool generate_data_write_guid) ++ bool generate_data_write_guid, MSGUID *log_guid) + { + int ret = 0; + int hdr_idx = 0; +@@ -262,6 +262,11 @@ static int vhdx_update_header(BlockDriverState *bs, BDRVVHDXState *s, + vhdx_guid_generate(&inactive_header->data_write_guid); + } + ++ /* update the log guid if present */ ++ if (log_guid) { ++ inactive_header->log_guid = *log_guid; ++ } ++ + /* the header checksum is not over just the packed size of VHDXHeader, + * but rather over the entire 'reserved' range for the header, which is + * 4KB (VHDX_HEADER_SIZE). */ +@@ -294,16 +299,16 @@ exit: + * The VHDX spec calls for header updates to be performed twice, so that both + * the current and non-current header have valid info + */ +-static int vhdx_update_headers(BlockDriverState *bs, BDRVVHDXState *s, +- bool generate_data_write_guid) ++int vhdx_update_headers(BlockDriverState *bs, BDRVVHDXState *s, ++ bool generate_data_write_guid, MSGUID *log_guid) + { + int ret; + +- ret = vhdx_update_header(bs, s, generate_data_write_guid); ++ ret = vhdx_update_header(bs, s, generate_data_write_guid, log_guid); + if (ret < 0) { + return ret; + } +- ret = vhdx_update_header(bs, s, generate_data_write_guid); ++ ret = vhdx_update_header(bs, s, generate_data_write_guid, log_guid); + return ret; + } + +@@ -784,6 +789,7 @@ static int vhdx_open(BlockDriverState *bs, QDict *options, int flags, + + + s->bat = NULL; ++ s->first_visible_write = true; + + qemu_co_mutex_init(&s->lock); + +@@ -864,7 +870,7 @@ static int vhdx_open(BlockDriverState *bs, QDict *options, int flags, + } + + if (flags & BDRV_O_RDWR) { +- ret = vhdx_update_headers(bs, s, false); ++ ret = vhdx_update_headers(bs, s, false, NULL); + if (ret < 0) { + goto fail; + } +@@ -1022,6 +1028,18 @@ exit: + + + ++/* Per the spec, on the first write of guest-visible data to the file the ++ * data write guid must be updated in the header */ ++int vhdx_user_visible_write(BlockDriverState *bs, BDRVVHDXState *s) ++{ ++ int ret = 0; ++ if (s->first_visible_write) { ++ s->first_visible_write = false; ++ ret = vhdx_update_headers(bs, s, true, NULL); ++ } ++ return ret; ++} ++ + static coroutine_fn int vhdx_co_writev(BlockDriverState *bs, int64_t sector_num, + int nb_sectors, QEMUIOVector *qiov) + { +diff --git a/block/vhdx.h b/block/vhdx.h +index 55975a2..81785e5 100644 +--- a/block/vhdx.h ++++ b/block/vhdx.h +@@ -361,6 +361,7 @@ typedef struct BDRVVHDXState { + VHDXBatEntry *bat; + uint64_t bat_offset; + ++ bool first_visible_write; + MSGUID session_guid; + + VHDXLogEntries log; +@@ -373,6 +374,9 @@ typedef struct BDRVVHDXState { + + void vhdx_guid_generate(MSGUID *guid); + ++int vhdx_update_headers(BlockDriverState *bs, BDRVVHDXState *s, bool rw, ++ MSGUID *log_guid); ++ + uint32_t vhdx_update_checksum(uint8_t *buf, size_t size, int crc_offset); + uint32_t vhdx_checksum_calc(uint32_t crc, uint8_t *buf, size_t size, + int crc_offset); +@@ -402,4 +406,6 @@ void vhdx_log_data_le_export(VHDXLogDataSector *d); + void vhdx_log_entry_hdr_le_import(VHDXLogEntryHeader *hdr); + void vhdx_log_entry_hdr_le_export(VHDXLogEntryHeader *hdr); + ++int vhdx_user_visible_write(BlockDriverState *bs, BDRVVHDXState *s); ++ + #endif +-- +1.7.1 + diff --git a/SOURCES/kvm-block-vhdx-write-support.patch b/SOURCES/kvm-block-vhdx-write-support.patch new file mode 100644 index 0000000..c1c7daf --- /dev/null +++ b/SOURCES/kvm-block-vhdx-write-support.patch @@ -0,0 +1,301 @@ +From f02d8f3eb38c3ed03742cbb981823a1917b3c5b2 Mon Sep 17 00:00:00 2001 +From: Jeffrey Cody +Date: Wed, 20 Nov 2013 19:44:00 +0100 +Subject: [PATCH 17/25] block: vhdx write support + +RH-Author: Jeffrey Cody +Message-id: +Patchwork-id: 55810 +O-Subject: [RHEL7 qemu-kvm PATCH 17/26] block: vhdx write support +Bugzilla: 879234 +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Fam Zheng + +This adds support for writing to VHDX image files, using coroutines. +Writes into the BAT table goes through the VHDX log. Currently, BAT +table writes occur when expanding a dynamic VHDX file, and allocating a +new BAT entry. + +Signed-off-by: Jeff Cody +Signed-off-by: Stefan Hajnoczi +(cherry picked from commit d92aa8833c051b53d3bf2614ff885df0037f10bb) +--- + block/vhdx.c | 212 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++-- + block/vhdx.h | 2 +- + 2 files changed, 209 insertions(+), 5 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + block/vhdx.c | 212 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++- + block/vhdx.h | 2 +- + 2 files changed, 209 insertions(+), 5 deletions(-) + +diff --git a/block/vhdx.c b/block/vhdx.c +index e36c60e..baf8970 100644 +--- a/block/vhdx.c ++++ b/block/vhdx.c +@@ -914,7 +914,7 @@ static int vhdx_open(BlockDriverState *bs, QDict *options, int flags, + if (payblocks--) { + /* payload bat entries */ + if ((s->bat[i] & VHDX_BAT_STATE_BIT_MASK) == +- PAYLOAD_BLOCK_FULL_PRESENT) { ++ PAYLOAD_BLOCK_FULLY_PRESENT) { + ret = vhdx_region_check(s, s->bat[i] & VHDX_BAT_FILE_OFF_MASK, + s->block_size); + if (ret < 0) { +@@ -935,7 +935,7 @@ static int vhdx_open(BlockDriverState *bs, QDict *options, int flags, + } + } + +- /* TODO: differencing files, write */ ++ /* TODO: differencing files */ + + /* Disable migration when VHDX images are used */ + error_set(&s->migration_blocker, +@@ -1052,7 +1052,7 @@ static coroutine_fn int vhdx_co_readv(BlockDriverState *bs, int64_t sector_num, + /* return zero */ + qemu_iovec_memset(&hd_qiov, 0, 0, sinfo.bytes_avail); + break; +- case PAYLOAD_BLOCK_FULL_PRESENT: ++ case PAYLOAD_BLOCK_FULLY_PRESENT: + qemu_co_mutex_unlock(&s->lock); + ret = bdrv_co_readv(bs->file, + sinfo.file_offset >> BDRV_SECTOR_BITS, +@@ -1082,7 +1082,43 @@ exit: + return ret; + } + ++/* ++ * Allocate a new payload block at the end of the file. ++ * ++ * Allocation will happen at 1MB alignment inside the file ++ * ++ * Returns the file offset start of the new payload block ++ */ ++static int vhdx_allocate_block(BlockDriverState *bs, BDRVVHDXState *s, ++ uint64_t *new_offset) ++{ ++ *new_offset = bdrv_getlength(bs->file); ++ ++ /* per the spec, the address for a block is in units of 1MB */ ++ *new_offset = ROUND_UP(*new_offset, 1024 * 1024); ++ ++ return bdrv_truncate(bs->file, *new_offset + s->block_size); ++} ++ ++/* ++ * Update the BAT table entry with the new file offset, and the new entry ++ * state */ ++static void vhdx_update_bat_table_entry(BlockDriverState *bs, BDRVVHDXState *s, ++ VHDXSectorInfo *sinfo, ++ uint64_t *bat_entry_le, ++ uint64_t *bat_offset, int state) ++{ ++ /* The BAT entry is a uint64, with 44 bits for the file offset in units of ++ * 1MB, and 3 bits for the block state. */ ++ s->bat[sinfo->bat_idx] = ((sinfo->file_offset>>20) << ++ VHDX_BAT_FILE_OFF_BITS); + ++ s->bat[sinfo->bat_idx] |= state & VHDX_BAT_STATE_BIT_MASK; ++ ++ *bat_entry_le = cpu_to_le64(s->bat[sinfo->bat_idx]); ++ *bat_offset = s->bat_offset + sinfo->bat_idx * sizeof(VHDXBatEntry); ++ ++} + + /* Per the spec, on the first write of guest-visible data to the file the + * data write guid must be updated in the header */ +@@ -1099,7 +1135,175 @@ int vhdx_user_visible_write(BlockDriverState *bs, BDRVVHDXState *s) + static coroutine_fn int vhdx_co_writev(BlockDriverState *bs, int64_t sector_num, + int nb_sectors, QEMUIOVector *qiov) + { +- return -ENOTSUP; ++ int ret = -ENOTSUP; ++ BDRVVHDXState *s = bs->opaque; ++ VHDXSectorInfo sinfo; ++ uint64_t bytes_done = 0; ++ uint64_t bat_entry = 0; ++ uint64_t bat_entry_offset = 0; ++ QEMUIOVector hd_qiov; ++ struct iovec iov1 = { 0 }; ++ struct iovec iov2 = { 0 }; ++ int sectors_to_write; ++ int bat_state; ++ uint64_t bat_prior_offset = 0; ++ bool bat_update = false; ++ ++ qemu_iovec_init(&hd_qiov, qiov->niov); ++ ++ qemu_co_mutex_lock(&s->lock); ++ ++ ret = vhdx_user_visible_write(bs, s); ++ if (ret < 0) { ++ goto exit; ++ } ++ ++ while (nb_sectors > 0) { ++ bool use_zero_buffers = false; ++ bat_update = false; ++ if (s->params.data_bits & VHDX_PARAMS_HAS_PARENT) { ++ /* not supported yet */ ++ ret = -ENOTSUP; ++ goto exit; ++ } else { ++ vhdx_block_translate(s, sector_num, nb_sectors, &sinfo); ++ sectors_to_write = sinfo.sectors_avail; ++ ++ qemu_iovec_reset(&hd_qiov); ++ /* check the payload block state */ ++ bat_state = s->bat[sinfo.bat_idx] & VHDX_BAT_STATE_BIT_MASK; ++ switch (bat_state) { ++ case PAYLOAD_BLOCK_ZERO: ++ /* in this case, we need to preserve zero writes for ++ * data that is not part of this write, so we must pad ++ * the rest of the buffer to zeroes */ ++ ++ /* if we are on a posix system with ftruncate() that extends ++ * a file, then it is zero-filled for us. On Win32, the raw ++ * layer uses SetFilePointer and SetFileEnd, which does not ++ * zero fill AFAIK */ ++ ++ /* Queue another write of zero buffers if the underlying file ++ * does not zero-fill on file extension */ ++ ++ if (bdrv_has_zero_init(bs->file) == 0) { ++ use_zero_buffers = true; ++ ++ /* zero fill the front, if any */ ++ if (sinfo.block_offset) { ++ iov1.iov_len = sinfo.block_offset; ++ iov1.iov_base = qemu_blockalign(bs, iov1.iov_len); ++ memset(iov1.iov_base, 0, iov1.iov_len); ++ qemu_iovec_concat_iov(&hd_qiov, &iov1, 1, 0, ++ sinfo.block_offset); ++ sectors_to_write += iov1.iov_len >> BDRV_SECTOR_BITS; ++ } ++ ++ /* our actual data */ ++ qemu_iovec_concat(&hd_qiov, qiov, bytes_done, ++ sinfo.bytes_avail); ++ ++ /* zero fill the back, if any */ ++ if ((sinfo.bytes_avail - sinfo.block_offset) < ++ s->block_size) { ++ iov2.iov_len = s->block_size - ++ (sinfo.bytes_avail + sinfo.block_offset); ++ iov2.iov_base = qemu_blockalign(bs, iov2.iov_len); ++ memset(iov2.iov_base, 0, iov2.iov_len); ++ qemu_iovec_concat_iov(&hd_qiov, &iov2, 1, 0, ++ sinfo.block_offset); ++ sectors_to_write += iov2.iov_len >> BDRV_SECTOR_BITS; ++ } ++ } ++ ++ /* fall through */ ++ case PAYLOAD_BLOCK_NOT_PRESENT: /* fall through */ ++ case PAYLOAD_BLOCK_UNMAPPED: /* fall through */ ++ case PAYLOAD_BLOCK_UNDEFINED: /* fall through */ ++ bat_prior_offset = sinfo.file_offset; ++ ret = vhdx_allocate_block(bs, s, &sinfo.file_offset); ++ if (ret < 0) { ++ goto exit; ++ } ++ /* once we support differencing files, this may also be ++ * partially present */ ++ /* update block state to the newly specified state */ ++ vhdx_update_bat_table_entry(bs, s, &sinfo, &bat_entry, ++ &bat_entry_offset, ++ PAYLOAD_BLOCK_FULLY_PRESENT); ++ bat_update = true; ++ /* since we just allocated a block, file_offset is the ++ * beginning of the payload block. It needs to be the ++ * write address, which includes the offset into the block */ ++ if (!use_zero_buffers) { ++ sinfo.file_offset += sinfo.block_offset; ++ } ++ /* fall through */ ++ case PAYLOAD_BLOCK_FULLY_PRESENT: ++ /* if the file offset address is in the header zone, ++ * there is a problem */ ++ if (sinfo.file_offset < (1024 * 1024)) { ++ ret = -EFAULT; ++ goto error_bat_restore; ++ } ++ ++ if (!use_zero_buffers) { ++ qemu_iovec_concat(&hd_qiov, qiov, bytes_done, ++ sinfo.bytes_avail); ++ } ++ /* block exists, so we can just overwrite it */ ++ qemu_co_mutex_unlock(&s->lock); ++ ret = bdrv_co_writev(bs->file, ++ sinfo.file_offset >> BDRV_SECTOR_BITS, ++ sectors_to_write, &hd_qiov); ++ qemu_co_mutex_lock(&s->lock); ++ if (ret < 0) { ++ goto error_bat_restore; ++ } ++ break; ++ case PAYLOAD_BLOCK_PARTIALLY_PRESENT: ++ /* we don't yet support difference files, fall through ++ * to error */ ++ default: ++ ret = -EIO; ++ goto exit; ++ break; ++ } ++ ++ if (bat_update) { ++ /* this will update the BAT entry into the log journal, and ++ * then flush the log journal out to disk */ ++ ret = vhdx_log_write_and_flush(bs, s, &bat_entry, ++ sizeof(VHDXBatEntry), ++ bat_entry_offset); ++ if (ret < 0) { ++ goto exit; ++ } ++ } ++ ++ nb_sectors -= sinfo.sectors_avail; ++ sector_num += sinfo.sectors_avail; ++ bytes_done += sinfo.bytes_avail; ++ ++ } ++ } ++ ++ goto exit; ++ ++error_bat_restore: ++ if (bat_update) { ++ /* keep metadata in sync, and restore the bat entry state ++ * if error. */ ++ sinfo.file_offset = bat_prior_offset; ++ vhdx_update_bat_table_entry(bs, s, &sinfo, &bat_entry, ++ &bat_entry_offset, bat_state); ++ } ++exit: ++ qemu_vfree(iov1.iov_base); ++ qemu_vfree(iov2.iov_base); ++ qemu_co_mutex_unlock(&s->lock); ++ qemu_iovec_destroy(&hd_qiov); ++ return ret; + } + + +diff --git a/block/vhdx.h b/block/vhdx.h +index 4bb83de..a85c5c8 100644 +--- a/block/vhdx.h ++++ b/block/vhdx.h +@@ -217,7 +217,7 @@ typedef struct QEMU_PACKED VHDXLogDataSector { + #define PAYLOAD_BLOCK_UNDEFINED 1 + #define PAYLOAD_BLOCK_ZERO 2 + #define PAYLOAD_BLOCK_UNMAPPED 5 +-#define PAYLOAD_BLOCK_FULL_PRESENT 6 ++#define PAYLOAD_BLOCK_FULLY_PRESENT 6 + #define PAYLOAD_BLOCK_PARTIALLY_PRESENT 7 + + #define SB_BLOCK_NOT_PRESENT 0 +-- +1.7.1 + diff --git a/SOURCES/kvm-block-write-Handle-COR-dependency-after-I-O-throttli.patch b/SOURCES/kvm-block-write-Handle-COR-dependency-after-I-O-throttli.patch new file mode 100644 index 0000000..fa609c2 --- /dev/null +++ b/SOURCES/kvm-block-write-Handle-COR-dependency-after-I-O-throttli.patch @@ -0,0 +1,60 @@ +From b66f204fcdb797b85050f3f6af6b4967247fd0f5 Mon Sep 17 00:00:00 2001 +From: Kevin Wolf +Date: Tue, 3 Dec 2013 14:30:44 +0100 +Subject: [PATCH 14/37] block: write: Handle COR dependency after I/O throttling + +Message-id: <1392117622-28812-15-git-send-email-kwolf@redhat.com> +Patchwork-id: 57179 +O-Subject: [RHEL-7.0 qemu-kvm PATCH v2 14/37] block: write: Handle COR dependency after I/O throttling +Bugzilla: 748906 +RH-Acked-by: Laszlo Ersek +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Max Reitz + +First waiting for all COR requests to complete and calling the +throttling function afterwards means that the request could be delayed +and we still need to wait for the COR request even if it was issued only +after the throttled write request. + +Signed-off-by: Kevin Wolf +Reviewed-by: Max Reitz +Reviewed-by: Benoit Canet +(cherry picked from commit 244eadef5c797c674b0aef96366671be4b33d03a) + +Signed-off-by: Kevin Wolf +--- + block.c | 8 ++++---- + 1 file changed, 4 insertions(+), 4 deletions(-) +--- + block.c | 8 ++++---- + 1 files changed, 4 insertions(+), 4 deletions(-) + +diff --git a/block.c b/block.c +index e6b6ed4..d8168f5 100644 +--- a/block.c ++++ b/block.c +@@ -2997,6 +2997,10 @@ static int coroutine_fn bdrv_aligned_pwritev(BlockDriverState *bs, + assert((offset & (BDRV_SECTOR_SIZE - 1)) == 0); + assert((bytes & (BDRV_SECTOR_SIZE - 1)) == 0); + ++ if (bs->copy_on_read_in_flight) { ++ wait_for_overlapping_requests(bs, sector_num, nb_sectors); ++ } ++ + tracked_request_begin(&req, bs, sector_num, nb_sectors, true); + + if (flags & BDRV_REQ_ZERO_WRITE) { +@@ -3044,10 +3048,6 @@ static int coroutine_fn bdrv_co_do_writev(BlockDriverState *bs, + return -EIO; + } + +- if (bs->copy_on_read_in_flight) { +- wait_for_overlapping_requests(bs, sector_num, nb_sectors); +- } +- + /* throttling disk I/O */ + if (bs->io_limits_enabled) { + bdrv_io_limits_intercept(bs, true, nb_sectors); +-- +1.7.1 + diff --git a/SOURCES/kvm-blockdev-fix-drive_init-opts-and-bs_opts-leaks.patch b/SOURCES/kvm-blockdev-fix-drive_init-opts-and-bs_opts-leaks.patch new file mode 100644 index 0000000..db681da --- /dev/null +++ b/SOURCES/kvm-blockdev-fix-drive_init-opts-and-bs_opts-leaks.patch @@ -0,0 +1,153 @@ +From 792e58622d0a5c0015673e2929c89b4bd36ef008 Mon Sep 17 00:00:00 2001 +Message-Id: <792e58622d0a5c0015673e2929c89b4bd36ef008.1387288155.git.minovotn@redhat.com> +In-Reply-To: <527da6c2ce2c09d0183aa8595fc95f136f61b6df.1387288155.git.minovotn@redhat.com> +References: <527da6c2ce2c09d0183aa8595fc95f136f61b6df.1387288155.git.minovotn@redhat.com> +From: Stefan Hajnoczi +Date: Thu, 12 Dec 2013 16:21:23 +0100 +Subject: [PATCH 3/8] blockdev: fix drive_init() opts and bs_opts leaks + +RH-Author: Stefan Hajnoczi +Message-id: <1386865288-1575-4-git-send-email-stefanha@redhat.com> +Patchwork-id: 56257 +O-Subject: [RHEL7 qemu-kvm PATCH 3/8] blockdev: fix drive_init() opts and bs_opts leaks +Bugzilla: 1003773 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Jeffrey Cody +RH-Acked-by: Markus Armbruster + +These memory leaks also make drive_add if=none,id=drive0 without a file= +option leak the options list. This keeps ID "drive0" around forever. + +Signed-off-by: Stefan Hajnoczi +Reviewed-by: Eric Blake +(cherry picked from commit ec9c10d29c6bb5613a680af62f5825d3bb2d31d4) +Signed-off-by: Stefan Hajnoczi + +Conflicts: + blockdev.c + +s/bdrv_delete/bdrv_unref/ upstream has resulted in a trivial conflict. +--- + blockdev.c | 27 +++++++++++++++------------ + 1 file changed, 15 insertions(+), 12 deletions(-) + +Signed-off-by: Michal Novotny +--- + blockdev.c | 27 +++++++++++++++------------ + 1 file changed, 15 insertions(+), 12 deletions(-) + +diff --git a/blockdev.c b/blockdev.c +index cdd453a..f6d607c 100644 +--- a/blockdev.c ++++ b/blockdev.c +@@ -360,7 +360,7 @@ static DriveInfo *blockdev_init(QDict *bs_opts, + qemu_opts_absorb_qdict(opts, bs_opts, &error); + if (error_is_set(&error)) { + error_propagate(errp, error); +- return NULL; ++ goto early_err; + } + + if (id) { +@@ -380,7 +380,7 @@ static DriveInfo *blockdev_init(QDict *bs_opts, + if ((buf = qemu_opt_get(opts, "discard")) != NULL) { + if (bdrv_parse_discard_flags(buf, &bdrv_flags) != 0) { + error_setg(errp, "invalid discard option"); +- return NULL; ++ goto early_err; + } + } + +@@ -402,7 +402,7 @@ static DriveInfo *blockdev_init(QDict *bs_opts, + /* this is the default */ + } else { + error_setg(errp, "invalid aio option"); +- return NULL; ++ goto early_err; + } + } + #endif +@@ -412,13 +412,13 @@ static DriveInfo *blockdev_init(QDict *bs_opts, + error_printf("Supported formats:"); + bdrv_iterate_format(bdrv_format_print, NULL); + error_printf("\n"); +- return NULL; ++ goto early_err; + } + + drv = bdrv_find_whitelisted_format(buf, ro); + if (!drv) { + error_setg(errp, "'%s' invalid format", buf); +- return NULL; ++ goto early_err; + } + } + +@@ -438,20 +438,20 @@ static DriveInfo *blockdev_init(QDict *bs_opts, + + if (!do_check_io_limits(&io_limits, &error)) { + error_propagate(errp, error); +- return NULL; ++ goto early_err; + } + + on_write_error = BLOCKDEV_ON_ERROR_ENOSPC; + if ((buf = qemu_opt_get(opts, "werror")) != NULL) { + if (type != IF_IDE && type != IF_SCSI && type != IF_VIRTIO && type != IF_NONE) { + error_setg(errp, "werror is not supported by this bus type"); +- return NULL; ++ goto early_err; + } + + on_write_error = parse_block_error_action(buf, 0, &error); + if (error_is_set(&error)) { + error_propagate(errp, error); +- return NULL; ++ goto early_err; + } + } + +@@ -459,13 +459,13 @@ static DriveInfo *blockdev_init(QDict *bs_opts, + if ((buf = qemu_opt_get(opts, "rerror")) != NULL) { + if (type != IF_IDE && type != IF_VIRTIO && type != IF_SCSI && type != IF_NONE) { + error_report("rerror is not supported by this bus type"); +- return NULL; ++ goto early_err; + } + + on_read_error = parse_block_error_action(buf, 1, &error); + if (error_is_set(&error)) { + error_propagate(errp, error); +- return NULL; ++ goto early_err; + } + } + +@@ -491,6 +491,8 @@ static DriveInfo *blockdev_init(QDict *bs_opts, + if (has_driver_specific_opts) { + file = NULL; + } else { ++ QDECREF(bs_opts); ++ qemu_opts_del(opts); + return dinfo; + } + } +@@ -529,12 +531,13 @@ static DriveInfo *blockdev_init(QDict *bs_opts, + return dinfo; + + err: +- qemu_opts_del(opts); +- QDECREF(bs_opts); + bdrv_delete(dinfo->bdrv); + g_free(dinfo->id); + QTAILQ_REMOVE(&drives, dinfo, next); + g_free(dinfo); ++early_err: ++ QDECREF(bs_opts); ++ qemu_opts_del(opts); + return NULL; + } + +-- +1.7.11.7 + diff --git a/SOURCES/kvm-blockdev-test-add-test-case-for-drive_add-duplicate-.patch b/SOURCES/kvm-blockdev-test-add-test-case-for-drive_add-duplicate-.patch new file mode 100644 index 0000000..97d1b44 --- /dev/null +++ b/SOURCES/kvm-blockdev-test-add-test-case-for-drive_add-duplicate-.patch @@ -0,0 +1,137 @@ +From 470de5e13e415a5e218d80114676a10c7dcb52c1 Mon Sep 17 00:00:00 2001 +Message-Id: <470de5e13e415a5e218d80114676a10c7dcb52c1.1387288155.git.minovotn@redhat.com> +In-Reply-To: <527da6c2ce2c09d0183aa8595fc95f136f61b6df.1387288155.git.minovotn@redhat.com> +References: <527da6c2ce2c09d0183aa8595fc95f136f61b6df.1387288155.git.minovotn@redhat.com> +From: Stefan Hajnoczi +Date: Thu, 12 Dec 2013 16:21:26 +0100 +Subject: [PATCH 6/8] blockdev-test: add test case for drive_add duplicate IDs + +RH-Author: Stefan Hajnoczi +Message-id: <1386865288-1575-7-git-send-email-stefanha@redhat.com> +Patchwork-id: 56260 +O-Subject: [RHEL7 qemu-kvm PATCH 6/8] blockdev-test: add test case for drive_add duplicate IDs +Bugzilla: 1003773 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Jeffrey Cody +RH-Acked-by: Markus Armbruster + +The following should work: + + (qemu) drive_add if=none,id=drive0 + (qemu) drive_del drive0 + (qemu) drive_add if=none,id=drive0 + +Previous versions of QEMU produced a duplicate ID error because +drive_add leaked the options. + +Signed-off-by: Stefan Hajnoczi +Reviewed-by: Eric Blake +(cherry picked from commit 7ceeedd016facf8d58e14a0d1417fa7225d71072) +Signed-off-by: Stefan Hajnoczi + +Conflicts: + tests/Makefile + +Trivial conflicts because upstream has additional tests that change the +diff context. +--- + tests/Makefile | 2 ++ + tests/blockdev-test.c | 59 +++++++++++++++++++++++++++++++++++++++++++++++++++ + 2 files changed, 61 insertions(+) + create mode 100644 tests/blockdev-test.c + +Signed-off-by: Michal Novotny +--- + tests/Makefile | 2 ++ + tests/blockdev-test.c | 59 +++++++++++++++++++++++++++++++++++++++++++++++++++ + 2 files changed, 61 insertions(+) + create mode 100644 tests/blockdev-test.c + +diff --git a/tests/Makefile b/tests/Makefile +index 394e029..91231e8 100644 +--- a/tests/Makefile ++++ b/tests/Makefile +@@ -58,6 +58,7 @@ check-qtest-i386-y += tests/boot-order-test$(EXESUF) + check-qtest-i386-y += tests/rtc-test$(EXESUF) + check-qtest-i386-y += tests/i440fx-test$(EXESUF) + check-qtest-i386-y += tests/fw_cfg-test$(EXESUF) ++check-qtest-i386-y += tests/blockdev-test$(EXESUF) + check-qtest-x86_64-y = $(check-qtest-i386-y) + gcov-files-i386-y += i386-softmmu/hw/mc146818rtc.c + gcov-files-x86_64-y = $(subst i386-softmmu/,x86_64-softmmu/,$(gcov-files-i386-y)) +@@ -135,6 +136,7 @@ tests/boot-order-test$(EXESUF): tests/boot-order-test.o + tests/tmp105-test$(EXESUF): tests/tmp105-test.o $(libqos-omap-obj-y) + tests/i440fx-test$(EXESUF): tests/i440fx-test.o $(libqos-pc-obj-y) + tests/fw_cfg-test$(EXESUF): tests/fw_cfg-test.o $(libqos-pc-obj-y) ++tests/blockdev-test$(EXESUF): tests/blockdev-test.o $(libqos-pc-obj-y) + + # QTest rules + +diff --git a/tests/blockdev-test.c b/tests/blockdev-test.c +new file mode 100644 +index 0000000..c940e00 +--- /dev/null ++++ b/tests/blockdev-test.c +@@ -0,0 +1,59 @@ ++/* ++ * blockdev.c test cases ++ * ++ * Copyright (C) 2013 Red Hat Inc. ++ * ++ * Authors: ++ * Stefan Hajnoczi ++ * ++ * This work is licensed under the terms of the GNU LGPL, version 2.1 or later. ++ * See the COPYING.LIB file in the top-level directory. ++ */ ++ ++#include ++#include ++#include "libqtest.h" ++ ++static void test_drive_add_empty(void) ++{ ++ QDict *response; ++ const char *response_return; ++ ++ /* Start with an empty drive */ ++ qtest_start("-drive if=none,id=drive0"); ++ ++ /* Delete the drive */ ++ response = qmp("{\"execute\": \"human-monitor-command\"," ++ " \"arguments\": {" ++ " \"command-line\": \"drive_del drive0\"" ++ "}}"); ++ g_assert(response); ++ response_return = qdict_get_try_str(response, "return"); ++ g_assert(response_return); ++ g_assert(strcmp(response_return, "") == 0); ++ QDECREF(response); ++ ++ /* Ensure re-adding the drive works - there should be no duplicate ID error ++ * because the old drive must be gone. ++ */ ++ response = qmp("{\"execute\": \"human-monitor-command\"," ++ " \"arguments\": {" ++ " \"command-line\": \"drive_add 0 if=none,id=drive0\"" ++ "}}"); ++ g_assert(response); ++ response_return = qdict_get_try_str(response, "return"); ++ g_assert(response_return); ++ g_assert(strcmp(response_return, "OK\r\n") == 0); ++ QDECREF(response); ++ ++ qtest_end(); ++} ++ ++int main(int argc, char **argv) ++{ ++ g_test_init(&argc, &argv, NULL); ++ ++ qtest_add_func("/qmp/drive_add_empty", test_drive_add_empty); ++ ++ return g_test_run(); ++} +-- +1.7.11.7 + diff --git a/SOURCES/kvm-blockdev-use-bdrv_getlength-in-qmp_drive_mirror.patch b/SOURCES/kvm-blockdev-use-bdrv_getlength-in-qmp_drive_mirror.patch new file mode 100644 index 0000000..07cd3c1 --- /dev/null +++ b/SOURCES/kvm-blockdev-use-bdrv_getlength-in-qmp_drive_mirror.patch @@ -0,0 +1,69 @@ +From 38d5e0867780e352a3890792f684594deb7afd7e Mon Sep 17 00:00:00 2001 +From: Max Reitz +Date: Sun, 19 Jan 2014 18:07:55 +0100 +Subject: [PATCH 21/34] blockdev: use bdrv_getlength() in qmp_drive_mirror() + +RH-Author: Max Reitz +Message-id: <1390154881-17140-2-git-send-email-mreitz@redhat.com> +Patchwork-id: 56814 +O-Subject: [RHEL-7.0 qemu-kvm PATCH v2 1/7] blockdev: use bdrv_getlength() in qmp_drive_mirror() +Bugzilla: 921890 +RH-Acked-by: Fam Zheng +RH-Acked-by: Kevin Wolf +RH-Acked-by: Jeffrey Cody + +From: Stefan Hajnoczi + +BZ: 921890 + +Use bdrv_getlength() for its byte units and error return instead of +bdrv_get_geometry(). + +Reported-by: Kevin Wolf +Reviewed-by: Eric Blake +Reviewed-by: Kevin Wolf +Signed-off-by: Stefan Hajnoczi +Signed-off-by: Kevin Wolf +(cherry picked from commit ac3c5d831aa0ff796659300e186be1a35862dbd3) + +Signed-off-by: Max Reitz +--- + blockdev.c | 10 +++++++--- + 1 file changed, 7 insertions(+), 3 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + blockdev.c | 10 +++++++--- + 1 files changed, 7 insertions(+), 3 deletions(-) + +diff --git a/blockdev.c b/blockdev.c +index 33a5f5f..0ba2504 100644 +--- a/blockdev.c ++++ b/blockdev.c +@@ -1541,7 +1541,7 @@ void qmp_drive_mirror(const char *device, const char *target, + BlockDriver *drv = NULL; + Error *local_err = NULL; + int flags; +- uint64_t size; ++ int64_t size; + int ret; + + if (!has_speed) { +@@ -1605,8 +1605,12 @@ void qmp_drive_mirror(const char *device, const char *target, + sync = MIRROR_SYNC_MODE_FULL; + } + +- bdrv_get_geometry(bs, &size); +- size *= 512; ++ size = bdrv_getlength(bs); ++ if (size < 0) { ++ error_setg_errno(errp, -size, "bdrv_getlength failed"); ++ return; ++ } ++ + if (sync == MIRROR_SYNC_MODE_FULL && mode != NEW_IMAGE_MODE_EXISTING) { + /* create new image w/o backing file */ + assert(format && drv); +-- +1.7.1 + diff --git a/SOURCES/kvm-blockjob-rename-BlockJobType-to-BlockJobDriver.patch b/SOURCES/kvm-blockjob-rename-BlockJobType-to-BlockJobDriver.patch new file mode 100644 index 0000000..bf4e52f --- /dev/null +++ b/SOURCES/kvm-blockjob-rename-BlockJobType-to-BlockJobDriver.patch @@ -0,0 +1,244 @@ +From 324996d0200ab451158581e199d9e5673e4adfd6 Mon Sep 17 00:00:00 2001 +From: Fam Zheng +Date: Fri, 17 Jan 2014 03:07:54 +0100 +Subject: [PATCH 11/34] blockjob: rename BlockJobType to BlockJobDriver + +RH-Author: Fam Zheng +Message-id: <1389928083-8921-10-git-send-email-famz@redhat.com> +Patchwork-id: 56771 +O-Subject: [RHEL-7 qemu-kvm PATCH 09/18] blockjob: rename BlockJobType to BlockJobDriver +Bugzilla: 1041301 +RH-Acked-by: Jeffrey Cody +RH-Acked-by: Kevin Wolf +RH-Acked-by: Stefan Hajnoczi + +We will use BlockJobType as the enum type name of block jobs in QAPI, +rename current BlockJobType to BlockJobDriver, which will eventually +become a set of operations, similar to block drivers. + +Signed-off-by: Fam Zheng +Reviewed-by: Eric Blake +Signed-off-by: Kevin Wolf +(cherry picked from commit 3fc4b10af09b75a1cb811b61abc9d8c90771dfb2) +Signed-off-by: Fam Zheng + +Conflicts: + block/backup.c + +Not present downstream. + +Signed-off-by: Fam Zheng +--- + block/commit.c | 4 ++-- + block/mirror.c | 4 ++-- + block/stream.c | 4 ++-- + blockjob.c | 22 +++++++++++----------- + include/block/blockjob.h | 12 ++++++------ + 5 files changed, 23 insertions(+), 23 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + block/commit.c | 4 ++-- + block/mirror.c | 4 ++-- + block/stream.c | 4 ++-- + blockjob.c | 22 +++++++++++----------- + include/block/blockjob.h | 12 ++++++------ + 5 files changed, 23 insertions(+), 23 deletions(-) + +diff --git a/block/commit.c b/block/commit.c +index 37572f0..28f45e4 100644 +--- a/block/commit.c ++++ b/block/commit.c +@@ -173,7 +173,7 @@ static void commit_set_speed(BlockJob *job, int64_t speed, Error **errp) + ratelimit_set_speed(&s->limit, speed / BDRV_SECTOR_SIZE, SLICE_TIME); + } + +-static const BlockJobType commit_job_type = { ++static const BlockJobDriver commit_job_driver = { + .instance_size = sizeof(CommitBlockJob), + .job_type = "commit", + .set_speed = commit_set_speed, +@@ -238,7 +238,7 @@ void commit_start(BlockDriverState *bs, BlockDriverState *base, + } + + +- s = block_job_create(&commit_job_type, bs, speed, cb, opaque, errp); ++ s = block_job_create(&commit_job_driver, bs, speed, cb, opaque, errp); + if (!s) { + return; + } +diff --git a/block/mirror.c b/block/mirror.c +index 342c90d..139be06 100644 +--- a/block/mirror.c ++++ b/block/mirror.c +@@ -525,7 +525,7 @@ static void mirror_complete(BlockJob *job, Error **errp) + block_job_resume(job); + } + +-static const BlockJobType mirror_job_type = { ++static const BlockJobDriver mirror_job_driver = { + .instance_size = sizeof(MirrorBlockJob), + .job_type = "mirror", + .set_speed = mirror_set_speed, +@@ -563,7 +563,7 @@ void mirror_start(BlockDriverState *bs, BlockDriverState *target, + return; + } + +- s = block_job_create(&mirror_job_type, bs, speed, cb, opaque, errp); ++ s = block_job_create(&mirror_job_driver, bs, speed, cb, opaque, errp); + if (!s) { + return; + } +diff --git a/block/stream.c b/block/stream.c +index ce16b0b..ffa4e9a 100644 +--- a/block/stream.c ++++ b/block/stream.c +@@ -204,7 +204,7 @@ static void stream_set_speed(BlockJob *job, int64_t speed, Error **errp) + ratelimit_set_speed(&s->limit, speed / BDRV_SECTOR_SIZE, SLICE_TIME); + } + +-static const BlockJobType stream_job_type = { ++static const BlockJobDriver stream_job_driver = { + .instance_size = sizeof(StreamBlockJob), + .job_type = "stream", + .set_speed = stream_set_speed, +@@ -225,7 +225,7 @@ void stream_start(BlockDriverState *bs, BlockDriverState *base, + return; + } + +- s = block_job_create(&stream_job_type, bs, speed, cb, opaque, errp); ++ s = block_job_create(&stream_job_driver, bs, speed, cb, opaque, errp); + if (!s) { + return; + } +diff --git a/blockjob.c b/blockjob.c +index 6d8c3a2..dc0fa6d 100644 +--- a/blockjob.c ++++ b/blockjob.c +@@ -35,7 +35,7 @@ + #include "qmp-commands.h" + #include "qemu/timer.h" + +-void *block_job_create(const BlockJobType *job_type, BlockDriverState *bs, ++void *block_job_create(const BlockJobDriver *driver, BlockDriverState *bs, + int64_t speed, BlockDriverCompletionFunc *cb, + void *opaque, Error **errp) + { +@@ -48,8 +48,8 @@ void *block_job_create(const BlockJobType *job_type, BlockDriverState *bs, + bdrv_ref(bs); + bdrv_set_in_use(bs, 1); + +- job = g_malloc0(job_type->instance_size); +- job->job_type = job_type; ++ job = g_malloc0(driver->instance_size); ++ job->driver = driver; + job->bs = bs; + job->cb = cb; + job->opaque = opaque; +@@ -87,11 +87,11 @@ void block_job_set_speed(BlockJob *job, int64_t speed, Error **errp) + { + Error *local_err = NULL; + +- if (!job->job_type->set_speed) { ++ if (!job->driver->set_speed) { + error_set(errp, QERR_NOT_SUPPORTED); + return; + } +- job->job_type->set_speed(job, speed, &local_err); ++ job->driver->set_speed(job, speed, &local_err); + if (error_is_set(&local_err)) { + error_propagate(errp, local_err); + return; +@@ -102,12 +102,12 @@ void block_job_set_speed(BlockJob *job, int64_t speed, Error **errp) + + void block_job_complete(BlockJob *job, Error **errp) + { +- if (job->paused || job->cancelled || !job->job_type->complete) { ++ if (job->paused || job->cancelled || !job->driver->complete) { + error_set(errp, QERR_BLOCK_JOB_NOT_READY, job->bs->device_name); + return; + } + +- job->job_type->complete(job, errp); ++ job->driver->complete(job, errp); + } + + void block_job_pause(BlockJob *job) +@@ -143,8 +143,8 @@ bool block_job_is_cancelled(BlockJob *job) + void block_job_iostatus_reset(BlockJob *job) + { + job->iostatus = BLOCK_DEVICE_IO_STATUS_OK; +- if (job->job_type->iostatus_reset) { +- job->job_type->iostatus_reset(job); ++ if (job->driver->iostatus_reset) { ++ job->driver->iostatus_reset(job); + } + } + +@@ -209,7 +209,7 @@ void block_job_sleep_ns(BlockJob *job, QEMUClock *clock, int64_t ns) + BlockJobInfo *block_job_query(BlockJob *job) + { + BlockJobInfo *info = g_new0(BlockJobInfo, 1); +- info->type = g_strdup(job->job_type->job_type); ++ info->type = g_strdup(job->driver->job_type); + info->device = g_strdup(bdrv_get_device_name(job->bs)); + info->len = job->len; + info->busy = job->busy; +@@ -236,7 +236,7 @@ QObject *qobject_from_block_job(BlockJob *job) + "'len': %" PRId64 "," + "'offset': %" PRId64 "," + "'speed': %" PRId64 " }", +- job->job_type->job_type, ++ job->driver->job_type, + bdrv_get_device_name(job->bs), + job->len, + job->offset, +diff --git a/include/block/blockjob.h b/include/block/blockjob.h +index c290d07..dadcd48 100644 +--- a/include/block/blockjob.h ++++ b/include/block/blockjob.h +@@ -28,11 +28,11 @@ + #include "block/block.h" + + /** +- * BlockJobType: ++ * BlockJobDriver: + * +- * A class type for block job objects. ++ * A class type for block job driver. + */ +-typedef struct BlockJobType { ++typedef struct BlockJobDriver { + /** Derived BlockJob struct size */ + size_t instance_size; + +@@ -50,7 +50,7 @@ typedef struct BlockJobType { + * manually. + */ + void (*complete)(BlockJob *job, Error **errp); +-} BlockJobType; ++} BlockJobDriver; + + /** + * BlockJob: +@@ -59,7 +59,7 @@ typedef struct BlockJobType { + */ + struct BlockJob { + /** The job type, including the job vtable. */ +- const BlockJobType *job_type; ++ const BlockJobDriver *driver; + + /** The block device on which the job is operating. */ + BlockDriverState *bs; +@@ -128,7 +128,7 @@ struct BlockJob { + * This function is not part of the public job interface; it should be + * called from a wrapper that is specific to the job type. + */ +-void *block_job_create(const BlockJobType *job_type, BlockDriverState *bs, ++void *block_job_create(const BlockJobDriver *driver, BlockDriverState *bs, + int64_t speed, BlockDriverCompletionFunc *cb, + void *opaque, Error **errp); + +-- +1.7.1 + diff --git a/SOURCES/kvm-bochs-Check-catalog_size-header-field-CVE-2014-0143.patch b/SOURCES/kvm-bochs-Check-catalog_size-header-field-CVE-2014-0143.patch new file mode 100644 index 0000000..88cc67f --- /dev/null +++ b/SOURCES/kvm-bochs-Check-catalog_size-header-field-CVE-2014-0143.patch @@ -0,0 +1,115 @@ +From 920f41e5268801ff36a4f76ccaf2ac2584ac009e Mon Sep 17 00:00:00 2001 +From: Kevin Wolf +Date: Tue, 25 Mar 2014 14:23:19 +0100 +Subject: [PATCH 12/49] bochs: Check catalog_size header field (CVE-2014-0143) + +RH-Author: Kevin Wolf +Message-id: <1395753835-7591-13-git-send-email-kwolf@redhat.com> +Patchwork-id: n/a +O-Subject: [virt-devel] [EMBARGOED RHEL-7.0 qemu-kvm PATCH 12/48] bochs: Check catalog_size header field (CVE-2014-0143) +Bugzilla: 1079320 +RH-Acked-by: Jeff Cody +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Paolo Bonzini + +Bugzilla: https://bugzilla.redhat.com/show_bug.cgi?id=1079320 +Upstream status: Embargoed + +It should neither become negative nor allow unbounded memory +allocations. This fixes aborts in g_malloc() and an s->catalog_bitmap +buffer overflow on big endian hosts. + +Signed-off-by: Kevin Wolf +Reviewed-by: Stefan Hajnoczi +--- + block/bochs.c | 13 +++++++++++++ + tests/qemu-iotests/078 | 13 +++++++++++++ + tests/qemu-iotests/078.out | 10 +++++++++- + 3 files changed, 35 insertions(+), 1 deletions(-) + +diff --git a/block/bochs.c b/block/bochs.c +index 04cca71..d1b1a2c 100644 +--- a/block/bochs.c ++++ b/block/bochs.c +@@ -122,7 +122,14 @@ static int bochs_open(BlockDriverState *bs, QDict *options, int flags, + bs->total_sectors = le64_to_cpu(bochs.extra.redolog.disk) / 512; + } + ++ /* Limit to 1M entries to avoid unbounded allocation. This is what is ++ * needed for the largest image that bximage can create (~8 TB). */ + s->catalog_size = le32_to_cpu(bochs.catalog); ++ if (s->catalog_size > 0x100000) { ++ error_setg(errp, "Catalog size is too large"); ++ return -EFBIG; ++ } ++ + s->catalog_bitmap = g_malloc(s->catalog_size * 4); + + ret = bdrv_pread(bs->file, le32_to_cpu(bochs.header), s->catalog_bitmap, +@@ -141,6 +148,12 @@ static int bochs_open(BlockDriverState *bs, QDict *options, int flags, + + s->extent_size = le32_to_cpu(bochs.extent); + ++ if (s->catalog_size < bs->total_sectors / s->extent_size) { ++ error_setg(errp, "Catalog size is too small for this disk size"); ++ ret = -EINVAL; ++ goto fail; ++ } ++ + qemu_co_mutex_init(&s->lock); + return 0; + +diff --git a/tests/qemu-iotests/078 b/tests/qemu-iotests/078 +index 73b573a..902ef0f 100755 +--- a/tests/qemu-iotests/078 ++++ b/tests/qemu-iotests/078 +@@ -43,6 +43,7 @@ _supported_proto generic + _supported_os Linux + + catalog_size_offset=$((0x48)) ++disk_size_offset=$((0x58)) + + echo + echo "== Read from a valid image ==" +@@ -55,6 +56,18 @@ _use_sample_img empty.bochs.bz2 + poke_file "$TEST_IMG" "$catalog_size_offset" "\xff\xff\xff\xff" + { $QEMU_IO -c "read 0 512" $TEST_IMG; } 2>&1 | _filter_qemu_io | _filter_testdir + ++echo ++echo "== Overflow for catalog size * sizeof(uint32_t) ==" ++_use_sample_img empty.bochs.bz2 ++poke_file "$TEST_IMG" "$catalog_size_offset" "\x00\x00\x00\x40" ++{ $QEMU_IO -c "read 0 512" $TEST_IMG; } 2>&1 | _filter_qemu_io | _filter_testdir ++ ++echo ++echo "== Too small catalog bitmap for image size ==" ++_use_sample_img empty.bochs.bz2 ++poke_file "$TEST_IMG" "$disk_size_offset" "\x00\xc0\x0f\x00\x00\x00\x00\x7f" ++{ $QEMU_IO -c "read 2T 4k" $TEST_IMG; } 2>&1 | _filter_qemu_io | _filter_testdir ++ + # success, all done + echo "*** done" + rm -f $seq.full +diff --git a/tests/qemu-iotests/078.out b/tests/qemu-iotests/078.out +index ef8c42d..7254693 100644 +--- a/tests/qemu-iotests/078.out ++++ b/tests/qemu-iotests/078.out +@@ -5,6 +5,14 @@ read 512/512 bytes at offset 0 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) + + == Negative catalog size == +-qemu-io: can't open device TEST_DIR/empty.bochs: Could not open 'TEST_DIR/empty.bochs': Interrupted system call ++qemu-io: can't open device TEST_DIR/empty.bochs: Catalog size is too large ++no file open, try 'help open' ++ ++== Overflow for catalog size * sizeof(uint32_t) == ++qemu-io: can't open device TEST_DIR/empty.bochs: Catalog size is too large ++no file open, try 'help open' ++ ++== Too small catalog bitmap for image size == ++qemu-io: can't open device TEST_DIR/empty.bochs: Catalog size is too small for this disk size + no file open, try 'help open' + *** done +-- +1.7.1 + diff --git a/SOURCES/kvm-bochs-Check-extent_size-header-field-CVE-2014-0142.patch b/SOURCES/kvm-bochs-Check-extent_size-header-field-CVE-2014-0142.patch new file mode 100644 index 0000000..909b5a0 --- /dev/null +++ b/SOURCES/kvm-bochs-Check-extent_size-header-field-CVE-2014-0142.patch @@ -0,0 +1,98 @@ +From 3150a448434da70b69e0b96d71223161a78d536f Mon Sep 17 00:00:00 2001 +From: Kevin Wolf +Date: Tue, 25 Mar 2014 14:23:20 +0100 +Subject: [PATCH 13/49] bochs: Check extent_size header field (CVE-2014-0142) + +RH-Author: Kevin Wolf +Message-id: <1395753835-7591-14-git-send-email-kwolf@redhat.com> +Patchwork-id: n/a +O-Subject: [virt-devel] [EMBARGOED RHEL-7.0 qemu-kvm PATCH 13/48] bochs: Check extent_size header field (CVE-2014-0142) +Bugzilla: 1079315 +RH-Acked-by: Jeff Cody +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Paolo Bonzini + +Bugzilla: https://bugzilla.redhat.com/show_bug.cgi?id=1079315 +Upstream status: Embargoed + +This fixes two possible division by zero crashes: In bochs_open() and in +seek_to_sector(). + +Signed-off-by: Kevin Wolf +Reviewed-by: Stefan Hajnoczi +--- + block/bochs.c | 8 ++++++++ + tests/qemu-iotests/078 | 13 +++++++++++++ + tests/qemu-iotests/078.out | 8 ++++++++ + 3 files changed, 29 insertions(+), 0 deletions(-) + +diff --git a/block/bochs.c b/block/bochs.c +index d1b1a2c..0ec980a 100644 +--- a/block/bochs.c ++++ b/block/bochs.c +@@ -147,6 +147,14 @@ static int bochs_open(BlockDriverState *bs, QDict *options, int flags, + s->extent_blocks = 1 + (le32_to_cpu(bochs.extent) - 1) / 512; + + s->extent_size = le32_to_cpu(bochs.extent); ++ if (s->extent_size == 0) { ++ error_setg(errp, "Extent size may not be zero"); ++ return -EINVAL; ++ } else if (s->extent_size > 0x800000) { ++ error_setg(errp, "Extent size %" PRIu32 " is too large", ++ s->extent_size); ++ return -EINVAL; ++ } + + if (s->catalog_size < bs->total_sectors / s->extent_size) { + error_setg(errp, "Catalog size is too small for this disk size"); +diff --git a/tests/qemu-iotests/078 b/tests/qemu-iotests/078 +index 902ef0f..872e734 100755 +--- a/tests/qemu-iotests/078 ++++ b/tests/qemu-iotests/078 +@@ -43,6 +43,7 @@ _supported_proto generic + _supported_os Linux + + catalog_size_offset=$((0x48)) ++extent_size_offset=$((0x50)) + disk_size_offset=$((0x58)) + + echo +@@ -68,6 +69,18 @@ _use_sample_img empty.bochs.bz2 + poke_file "$TEST_IMG" "$disk_size_offset" "\x00\xc0\x0f\x00\x00\x00\x00\x7f" + { $QEMU_IO -c "read 2T 4k" $TEST_IMG; } 2>&1 | _filter_qemu_io | _filter_testdir + ++echo ++echo "== Negative extent size ==" ++_use_sample_img empty.bochs.bz2 ++poke_file "$TEST_IMG" "$extent_size_offset" "\xff\xff\xff\xff" ++{ $QEMU_IO -c "read 768k 512" $TEST_IMG; } 2>&1 | _filter_qemu_io | _filter_testdir ++ ++echo ++echo "== Zero extent size ==" ++_use_sample_img empty.bochs.bz2 ++poke_file "$TEST_IMG" "$extent_size_offset" "\x00\x00\x00\x00" ++{ $QEMU_IO -c "read 0 512" $TEST_IMG; } 2>&1 | _filter_qemu_io | _filter_testdir ++ + # success, all done + echo "*** done" + rm -f $seq.full +diff --git a/tests/qemu-iotests/078.out b/tests/qemu-iotests/078.out +index 7254693..ea95ffd 100644 +--- a/tests/qemu-iotests/078.out ++++ b/tests/qemu-iotests/078.out +@@ -15,4 +15,12 @@ no file open, try 'help open' + == Too small catalog bitmap for image size == + qemu-io: can't open device TEST_DIR/empty.bochs: Catalog size is too small for this disk size + no file open, try 'help open' ++ ++== Negative extent size == ++qemu-io: can't open device TEST_DIR/empty.bochs: Extent size 4294967295 is too large ++no file open, try 'help open' ++ ++== Zero extent size == ++qemu-io: can't open device TEST_DIR/empty.bochs: Extent size may not be zero ++no file open, try 'help open' + *** done +-- +1.7.1 + diff --git a/SOURCES/kvm-bochs-Fix-bitmap-offset-calculation.patch b/SOURCES/kvm-bochs-Fix-bitmap-offset-calculation.patch new file mode 100644 index 0000000..39fbd81 --- /dev/null +++ b/SOURCES/kvm-bochs-Fix-bitmap-offset-calculation.patch @@ -0,0 +1,44 @@ +From faa093fc3b71b073a73f800785c3cdabe5a91cc3 Mon Sep 17 00:00:00 2001 +From: Kevin Wolf +Date: Tue, 25 Mar 2014 14:23:21 +0100 +Subject: [PATCH 14/49] bochs: Fix bitmap offset calculation + +RH-Author: Kevin Wolf +Message-id: <1395753835-7591-15-git-send-email-kwolf@redhat.com> +Patchwork-id: n/a +O-Subject: [virt-devel] [EMBARGOED RHEL-7.0 qemu-kvm PATCH 14/48] bochs: Fix bitmap offset calculation +Bugzilla: 1066691 +RH-Acked-by: Jeff Cody +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Paolo Bonzini + +Bugzilla: https://bugzilla.redhat.com/show_bug.cgi?id=1066691 +Upstream status: Series embargoed + +32 bit truncation could let us access the wrong offset in the image. + +Signed-off-by: Kevin Wolf +Reviewed-by: Stefan Hajnoczi +--- + block/bochs.c | 5 +++-- + 1 files changed, 3 insertions(+), 2 deletions(-) + +diff --git a/block/bochs.c b/block/bochs.c +index 0ec980a..5c74223 100644 +--- a/block/bochs.c ++++ b/block/bochs.c +@@ -185,8 +185,9 @@ static int64_t seek_to_sector(BlockDriverState *bs, int64_t sector_num) + return -1; /* not allocated */ + } + +- bitmap_offset = s->data_offset + (512 * s->catalog_bitmap[extent_index] * +- (s->extent_blocks + s->bitmap_blocks)); ++ bitmap_offset = s->data_offset + ++ (512 * (uint64_t) s->catalog_bitmap[extent_index] * ++ (s->extent_blocks + s->bitmap_blocks)); + + /* read in bitmap for current extent */ + if (bdrv_pread(bs->file, bitmap_offset + (extent_offset / 8), +-- +1.7.1 + diff --git a/SOURCES/kvm-bochs-Unify-header-structs-and-make-them-QEMU_PACKED.patch b/SOURCES/kvm-bochs-Unify-header-structs-and-make-them-QEMU_PACKED.patch new file mode 100644 index 0000000..647872b --- /dev/null +++ b/SOURCES/kvm-bochs-Unify-header-structs-and-make-them-QEMU_PACKED.patch @@ -0,0 +1,146 @@ +From 30e78b5a6fc16e3669f83b27e02c8eb53e646b48 Mon Sep 17 00:00:00 2001 +From: Kevin Wolf +Date: Tue, 25 Mar 2014 14:23:17 +0100 +Subject: [PATCH 10/49] bochs: Unify header structs and make them QEMU_PACKED + +RH-Author: Kevin Wolf +Message-id: <1395753835-7591-11-git-send-email-kwolf@redhat.com> +Patchwork-id: n/a +O-Subject: [virt-devel] [EMBARGOED RHEL-7.0 qemu-kvm PATCH 10/48] bochs: Unify header structs and make them QEMU_PACKED +Bugzilla: 1066691 +RH-Acked-by: Jeff Cody +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Paolo Bonzini + +Bugzilla: https://bugzilla.redhat.com/show_bug.cgi?id=1066691 +Upstream status: Series embargoed + +This is an on-disk structure, so offsets must be accurate. + +Before this patch, sizeof(bochs) != sizeof(header_v1), which makes the +memcpy() between both invalid. We're lucky enough that the destination +buffer happened to be the larger one, and the memcpy size to be taken +from the smaller one, so we didn't get a buffer overflow in practice. + +This patch unifies the both structures, eliminating the need to do a +memcpy in the first place. The common fields are extracted to the top +level of the struct and the actually differing part gets a union of the +two versions. + +Signed-off-by: Kevin Wolf +Reviewed-by: Stefan Hajnoczi +--- + block/bochs.c | 67 +++++++++++++++++++++----------------------------------- + 1 files changed, 25 insertions(+), 42 deletions(-) + +diff --git a/block/bochs.c b/block/bochs.c +index 51d9a90..708780d 100644 +--- a/block/bochs.c ++++ b/block/bochs.c +@@ -39,45 +39,30 @@ + // not allocated: 0xffffffff + + // always little-endian +-struct bochs_header_v1 { +- char magic[32]; // "Bochs Virtual HD Image" +- char type[16]; // "Redolog" +- char subtype[16]; // "Undoable" / "Volatile" / "Growing" +- uint32_t version; +- uint32_t header; // size of header +- +- union { +- struct { +- uint32_t catalog; // num of entries +- uint32_t bitmap; // bitmap size +- uint32_t extent; // extent size +- uint64_t disk; // disk size +- char padding[HEADER_SIZE - 64 - 8 - 20]; +- } redolog; +- char padding[HEADER_SIZE - 64 - 8]; +- } extra; +-}; +- +-// always little-endian + struct bochs_header { +- char magic[32]; // "Bochs Virtual HD Image" +- char type[16]; // "Redolog" +- char subtype[16]; // "Undoable" / "Volatile" / "Growing" ++ char magic[32]; /* "Bochs Virtual HD Image" */ ++ char type[16]; /* "Redolog" */ ++ char subtype[16]; /* "Undoable" / "Volatile" / "Growing" */ + uint32_t version; +- uint32_t header; // size of header ++ uint32_t header; /* size of header */ ++ ++ uint32_t catalog; /* num of entries */ ++ uint32_t bitmap; /* bitmap size */ ++ uint32_t extent; /* extent size */ + + union { +- struct { +- uint32_t catalog; // num of entries +- uint32_t bitmap; // bitmap size +- uint32_t extent; // extent size +- uint32_t reserved; // for ??? +- uint64_t disk; // disk size +- char padding[HEADER_SIZE - 64 - 8 - 24]; +- } redolog; +- char padding[HEADER_SIZE - 64 - 8]; ++ struct { ++ uint32_t reserved; /* for ??? */ ++ uint64_t disk; /* disk size */ ++ char padding[HEADER_SIZE - 64 - 20 - 12]; ++ } QEMU_PACKED redolog; ++ struct { ++ uint64_t disk; /* disk size */ ++ char padding[HEADER_SIZE - 64 - 20 - 8]; ++ } QEMU_PACKED redolog_v1; ++ char padding[HEADER_SIZE - 64 - 20]; + } extra; +-}; ++} QEMU_PACKED; + + typedef struct BDRVBochsState { + CoMutex lock; +@@ -114,7 +99,6 @@ static int bochs_open(BlockDriverState *bs, QDict *options, int flags, + BDRVBochsState *s = bs->opaque; + int i; + struct bochs_header bochs; +- struct bochs_header_v1 header_v1; + int ret; + + bs->read_only = 1; // no write support yet +@@ -133,13 +117,12 @@ static int bochs_open(BlockDriverState *bs, QDict *options, int flags, + } + + if (le32_to_cpu(bochs.version) == HEADER_V1) { +- memcpy(&header_v1, &bochs, sizeof(bochs)); +- bs->total_sectors = le64_to_cpu(header_v1.extra.redolog.disk) / 512; ++ bs->total_sectors = le64_to_cpu(bochs.extra.redolog_v1.disk) / 512; + } else { +- bs->total_sectors = le64_to_cpu(bochs.extra.redolog.disk) / 512; ++ bs->total_sectors = le64_to_cpu(bochs.extra.redolog.disk) / 512; + } + +- s->catalog_size = le32_to_cpu(bochs.extra.redolog.catalog); ++ s->catalog_size = le32_to_cpu(bochs.catalog); + s->catalog_bitmap = g_malloc(s->catalog_size * 4); + + ret = bdrv_pread(bs->file, le32_to_cpu(bochs.header), s->catalog_bitmap, +@@ -153,10 +136,10 @@ static int bochs_open(BlockDriverState *bs, QDict *options, int flags, + + s->data_offset = le32_to_cpu(bochs.header) + (s->catalog_size * 4); + +- s->bitmap_blocks = 1 + (le32_to_cpu(bochs.extra.redolog.bitmap) - 1) / 512; +- s->extent_blocks = 1 + (le32_to_cpu(bochs.extra.redolog.extent) - 1) / 512; ++ s->bitmap_blocks = 1 + (le32_to_cpu(bochs.bitmap) - 1) / 512; ++ s->extent_blocks = 1 + (le32_to_cpu(bochs.extent) - 1) / 512; + +- s->extent_size = le32_to_cpu(bochs.extra.redolog.extent); ++ s->extent_size = le32_to_cpu(bochs.extent); + + qemu_co_mutex_init(&s->lock); + return 0; +-- +1.7.1 + diff --git a/SOURCES/kvm-bochs-Use-unsigned-variables-for-offsets-and-sizes-C.patch b/SOURCES/kvm-bochs-Use-unsigned-variables-for-offsets-and-sizes-C.patch new file mode 100644 index 0000000..50c4756 --- /dev/null +++ b/SOURCES/kvm-bochs-Use-unsigned-variables-for-offsets-and-sizes-C.patch @@ -0,0 +1,111 @@ +From abf79316045a3c634e9633553942763fd358f9b2 Mon Sep 17 00:00:00 2001 +From: Kevin Wolf +Date: Tue, 25 Mar 2014 14:23:18 +0100 +Subject: [PATCH 11/49] bochs: Use unsigned variables for offsets and sizes (CVE-2014-0147) + +RH-Author: Kevin Wolf +Message-id: <1395753835-7591-12-git-send-email-kwolf@redhat.com> +Patchwork-id: n/a +O-Subject: [virt-devel] [EMBARGOED RHEL-7.0 qemu-kvm PATCH 11/48] bochs: Use unsigned variables for offsets and sizes (CVE-2014-0147) +Bugzilla: 1079339 +RH-Acked-by: Jeff Cody +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Paolo Bonzini + +Bugzilla: https://bugzilla.redhat.com/show_bug.cgi?id=1079339 +Upstream status: Embargoed + +Gets us rid of integer overflows resulting in negative sizes which +aren't correctly checked. + +Signed-off-by: Kevin Wolf +Reviewed-by: Stefan Hajnoczi +--- + block/bochs.c | 16 ++++++++-------- + tests/qemu-iotests/078 | 8 ++++++++ + tests/qemu-iotests/078.out | 4 ++++ + 3 files changed, 20 insertions(+), 8 deletions(-) + +diff --git a/block/bochs.c b/block/bochs.c +index 708780d..04cca71 100644 +--- a/block/bochs.c ++++ b/block/bochs.c +@@ -67,13 +67,13 @@ struct bochs_header { + typedef struct BDRVBochsState { + CoMutex lock; + uint32_t *catalog_bitmap; +- int catalog_size; ++ uint32_t catalog_size; + +- int data_offset; ++ uint32_t data_offset; + +- int bitmap_blocks; +- int extent_blocks; +- int extent_size; ++ uint32_t bitmap_blocks; ++ uint32_t extent_blocks; ++ uint32_t extent_size; + } BDRVBochsState; + + static int bochs_probe(const uint8_t *buf, int buf_size, const char *filename) +@@ -97,7 +97,7 @@ static int bochs_open(BlockDriverState *bs, QDict *options, int flags, + Error **errp) + { + BDRVBochsState *s = bs->opaque; +- int i; ++ uint32_t i; + struct bochs_header bochs; + int ret; + +@@ -152,8 +152,8 @@ fail: + static int64_t seek_to_sector(BlockDriverState *bs, int64_t sector_num) + { + BDRVBochsState *s = bs->opaque; +- int64_t offset = sector_num * 512; +- int64_t extent_index, extent_offset, bitmap_offset; ++ uint64_t offset = sector_num * 512; ++ uint64_t extent_index, extent_offset, bitmap_offset; + char bitmap_entry; + + // seek to sector +diff --git a/tests/qemu-iotests/078 b/tests/qemu-iotests/078 +index f55f46d..73b573a 100755 +--- a/tests/qemu-iotests/078 ++++ b/tests/qemu-iotests/078 +@@ -42,11 +42,19 @@ _supported_fmt bochs + _supported_proto generic + _supported_os Linux + ++catalog_size_offset=$((0x48)) ++ + echo + echo "== Read from a valid image ==" + _use_sample_img empty.bochs.bz2 + { $QEMU_IO -c "read 0 512" $TEST_IMG; } 2>&1 | _filter_qemu_io | _filter_testdir + ++echo ++echo "== Negative catalog size ==" ++_use_sample_img empty.bochs.bz2 ++poke_file "$TEST_IMG" "$catalog_size_offset" "\xff\xff\xff\xff" ++{ $QEMU_IO -c "read 0 512" $TEST_IMG; } 2>&1 | _filter_qemu_io | _filter_testdir ++ + # success, all done + echo "*** done" + rm -f $seq.full +diff --git a/tests/qemu-iotests/078.out b/tests/qemu-iotests/078.out +index 25d37c5..ef8c42d 100644 +--- a/tests/qemu-iotests/078.out ++++ b/tests/qemu-iotests/078.out +@@ -3,4 +3,8 @@ QA output created by 078 + == Read from a valid image == + read 512/512 bytes at offset 0 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) ++ ++== Negative catalog size == ++qemu-io: can't open device TEST_DIR/empty.bochs: Could not open 'TEST_DIR/empty.bochs': Interrupted system call ++no file open, try 'help open' + *** done +-- +1.7.1 + diff --git a/SOURCES/kvm-cleanup-object.h-include-error.h-directly.patch b/SOURCES/kvm-cleanup-object.h-include-error.h-directly.patch new file mode 100644 index 0000000..13d0826 --- /dev/null +++ b/SOURCES/kvm-cleanup-object.h-include-error.h-directly.patch @@ -0,0 +1,52 @@ +From 5d01df56c48d0ef9f08840598a57fa693ac43dcf Mon Sep 17 00:00:00 2001 +Message-Id: <5d01df56c48d0ef9f08840598a57fa693ac43dcf.1387298827.git.minovotn@redhat.com> +In-Reply-To: <3ed0fb61a3dc912ef036d7ef450bed192090709e.1387298827.git.minovotn@redhat.com> +References: <3ed0fb61a3dc912ef036d7ef450bed192090709e.1387298827.git.minovotn@redhat.com> +From: "Michael S. Tsirkin" +Date: Tue, 17 Dec 2013 15:17:47 +0100 +Subject: [PATCH 23/56] cleanup object.h: include error.h directly + +RH-Author: Michael S. Tsirkin +Message-id: <1387293161-4085-24-git-send-email-mst@redhat.com> +Patchwork-id: 56329 +O-Subject: [PATCH qemu-kvm RHEL7.0 v2 23/57] cleanup object.h: include error.h directly +Bugzilla: 1034876 +RH-Acked-by: Igor Mammedov +RH-Acked-by: Marcel Apfelbaum +RH-Acked-by: Laszlo Ersek + +From: Igor Mammedov + +qapi/error.h is simple enough to be included in qom/object.h +direcly and prepares qom/object.h to use Error typedef. + +Signed-off-by: Igor Mammedov +Signed-off-by: Michael S. Tsirkin +(cherry picked from commit 008e05662ae5ff314b2b8462508ffd4b40503369) +--- + include/qom/object.h | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +Signed-off-by: Michal Novotny +--- + include/qom/object.h | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/include/qom/object.h b/include/qom/object.h +index 23fc048..c37f3ca 100644 +--- a/include/qom/object.h ++++ b/include/qom/object.h +@@ -18,9 +18,9 @@ + #include + #include + #include "qemu/queue.h" ++#include "qapi/error.h" + + struct Visitor; +-struct Error; + + struct TypeImpl; + typedef struct TypeImpl *Type; +-- +1.7.11.7 + diff --git a/SOURCES/kvm-cleanup-trace-events.pl-New.patch b/SOURCES/kvm-cleanup-trace-events.pl-New.patch new file mode 100644 index 0000000..ad9c9e3 --- /dev/null +++ b/SOURCES/kvm-cleanup-trace-events.pl-New.patch @@ -0,0 +1,96 @@ +From 5fde31188fab75d48e9a3d508ac8f9088e09bf3d Mon Sep 17 00:00:00 2001 +Message-Id: <5fde31188fab75d48e9a3d508ac8f9088e09bf3d.1387276076.git.minovotn@redhat.com> +In-Reply-To: +References: +From: Markus Armbruster +Date: Tue, 10 Dec 2013 15:12:50 +0100 +Subject: [PATCH 09/16] cleanup-trace-events.pl: New + +RH-Author: Markus Armbruster +Message-id: <1386688376-29521-2-git-send-email-armbru@redhat.com> +Patchwork-id: 56112 +O-Subject: [PATCH 7.0 qemu-kvm 1/7] cleanup-trace-events.pl: New +Bugzilla: 997832 +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Eduardo Habkost +RH-Acked-by: Laszlo Ersek + +From: Markus Armbruster + +Simple script to drop unused events and fix up source file comments. +The next few commits put it to use. + +Signed-off-by: Markus Armbruster +Signed-off-by: Stefan Hajnoczi +(cherry picked from commit f0c03c8cf6184f25ba91449c1ff77e5e006ce514) +--- + scripts/cleanup-trace-events.pl | 51 +++++++++++++++++++++++++++++++++++++++++ + 1 file changed, 51 insertions(+) + create mode 100755 scripts/cleanup-trace-events.pl + +Signed-off-by: Michal Novotny +--- + scripts/cleanup-trace-events.pl | 51 +++++++++++++++++++++++++++++++++++++++++ + 1 file changed, 51 insertions(+) + create mode 100755 scripts/cleanup-trace-events.pl + +diff --git a/scripts/cleanup-trace-events.pl b/scripts/cleanup-trace-events.pl +new file mode 100755 +index 0000000..cffbf16 +--- /dev/null ++++ b/scripts/cleanup-trace-events.pl +@@ -0,0 +1,51 @@ ++#!/usr/bin/perl ++# Copyright (C) 2013 Red Hat, Inc. ++# ++# Authors: ++# Markus Armbruster ++# ++# This work is licensed under the terms of the GNU GPL, version 2 or ++# later. See the COPYING file in the top-level directory. ++ ++# Usage: cleanup-trace-events.pl trace-events ++# ++# Print cleaned up trace-events to standard output. ++ ++use warnings; ++use strict; ++ ++my $buf = ''; ++my %seen = (); ++ ++sub out { ++ print $buf; ++ $buf = ''; ++ %seen = (); ++} ++ ++while (<>) { ++ if (/^(disable )?([a-z_0-9]+)\(/) { ++ open GREP, '-|', 'git', 'grep', '-l', "trace_$2" ++ or die "run git grep: $!"; ++ my $fname; ++ while ($fname = ) { ++ chomp $fname; ++ next if $seen{$fname} || $fname eq 'trace-events'; ++ $seen{$fname} = 1; ++ $buf = "# $fname\n" . $buf; ++ } ++ unless (close GREP) { ++ die "close git grep: $!" ++ if $!; ++ next; ++ } ++ } elsif (/^# ([^ ]*\.[ch])$/) { ++ out; ++ next; ++ } elsif (!/^#|^$/) { ++ warn "unintelligible line"; ++ } ++ $buf .= $_; ++} ++ ++out; +-- +1.7.11.7 + diff --git a/SOURCES/kvm-commit-Remove-unused-check.patch b/SOURCES/kvm-commit-Remove-unused-check.patch new file mode 100644 index 0000000..1dd2205 --- /dev/null +++ b/SOURCES/kvm-commit-Remove-unused-check.patch @@ -0,0 +1,53 @@ +From 1d78e14b1774a799db6336a4381f91a7af295f38 Mon Sep 17 00:00:00 2001 +From: Fam Zheng +Date: Fri, 17 Jan 2014 03:08:03 +0100 +Subject: [PATCH 20/34] commit: Remove unused check + +RH-Author: Fam Zheng +Message-id: <1389928083-8921-19-git-send-email-famz@redhat.com> +Patchwork-id: 56780 +O-Subject: [RHEL-7 qemu-kvm PATCH 18/18] commit: Remove unused check +Bugzilla: 1041301 +RH-Acked-by: Jeffrey Cody +RH-Acked-by: Kevin Wolf +RH-Acked-by: Stefan Hajnoczi + +We support top == active for commit now, remove the check and add an +assertion here. + +Signed-off-by: Fam Zheng +Reviewed-by: Kevin Wolf +Signed-off-by: Stefan Hajnoczi +(cherry picked from commit 18da7f94cdce130f2a71387de4980ffa817181a1) +Signed-off-by: Fam Zheng +--- + block/commit.c | 8 +------- + 1 file changed, 1 insertion(+), 7 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + block/commit.c | 8 +------- + 1 files changed, 1 insertions(+), 7 deletions(-) + +diff --git a/block/commit.c b/block/commit.c +index d237729..e3e395d 100644 +--- a/block/commit.c ++++ b/block/commit.c +@@ -198,13 +198,7 @@ void commit_start(BlockDriverState *bs, BlockDriverState *base, + return; + } + +- /* Once we support top == active layer, remove this check */ +- if (top == bs) { +- error_setg(errp, +- "Top image as the active layer is currently unsupported"); +- return; +- } +- ++ assert(top != bs); + if (top == base) { + error_setg(errp, "Invalid files for merge: top and base are the same"); + return; +-- +1.7.1 + diff --git a/SOURCES/kvm-commit-Support-commit-active-layer.patch b/SOURCES/kvm-commit-Support-commit-active-layer.patch new file mode 100644 index 0000000..7ed4296 --- /dev/null +++ b/SOURCES/kvm-commit-Support-commit-active-layer.patch @@ -0,0 +1,113 @@ +From b55e2f4749d2e4ebfc7dfc8782de85391c1026e8 Mon Sep 17 00:00:00 2001 +From: Fam Zheng +Date: Fri, 17 Jan 2014 03:08:00 +0100 +Subject: [PATCH 17/34] commit: Support commit active layer + +RH-Author: Fam Zheng +Message-id: <1389928083-8921-16-git-send-email-famz@redhat.com> +Patchwork-id: 56777 +O-Subject: [RHEL-7 qemu-kvm PATCH 15/18] commit: Support commit active layer +Bugzilla: 1041301 +RH-Acked-by: Jeffrey Cody +RH-Acked-by: Kevin Wolf +RH-Acked-by: Stefan Hajnoczi + +If active is top, it will be mirrored to base, (with block/mirror.c +code), then the image is switched when user completes the block job. + +QMP documentation is updated. + +Signed-off-by: Fam Zheng +Signed-off-by: Stefan Hajnoczi +(cherry picked from commit 20a63d2cec838c2dde4d246c4d7abe747d9b7a11) +Signed-off-by: Fam Zheng +--- + block/mirror.c | 11 +++++++++++ + blockdev.c | 9 +++++++-- + qapi-schema.json | 5 +++-- + 3 files changed, 21 insertions(+), 4 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + block/mirror.c | 11 +++++++++++ + blockdev.c | 9 +++++++-- + qapi-schema.json | 5 +++-- + 3 files changed, 21 insertions(+), 4 deletions(-) + +diff --git a/block/mirror.c b/block/mirror.c +index 01fe379..6e1f9b1 100644 +--- a/block/mirror.c ++++ b/block/mirror.c +@@ -478,6 +478,13 @@ immediate_exit: + bdrv_reopen(s->target, bdrv_get_flags(s->common.bs), NULL); + } + bdrv_swap(s->target, s->common.bs); ++ if (s->common.driver->job_type == BLOCK_JOB_TYPE_COMMIT) { ++ /* drop the bs loop chain formed by the swap: break the loop then ++ * trigger the unref from the top one */ ++ BlockDriverState *p = s->base->backing_hd; ++ s->base->backing_hd = NULL; ++ bdrv_unref(p); ++ } + } + bdrv_unref(s->target); + block_job_completed(&s->common, ret); +@@ -620,6 +627,10 @@ void commit_active_start(BlockDriverState *bs, BlockDriverState *base, + BlockDriverCompletionFunc *cb, + void *opaque, Error **errp) + { ++ if (bdrv_reopen(base, bs->open_flags, errp)) { ++ return; ++ } ++ bdrv_ref(base); + mirror_start_job(bs, base, speed, 0, 0, + on_error, on_error, cb, opaque, errp, + &commit_active_job_driver, false, base); +diff --git a/blockdev.c b/blockdev.c +index d795af2..33a5f5f 100644 +--- a/blockdev.c ++++ b/blockdev.c +@@ -1510,8 +1510,13 @@ void qmp_block_commit(const char *device, + return; + } + +- commit_start(bs, base_bs, top_bs, speed, on_error, block_job_cb, bs, +- &local_err); ++ if (top_bs == bs) { ++ commit_active_start(bs, base_bs, speed, on_error, block_job_cb, ++ bs, &local_err); ++ } else { ++ commit_start(bs, base_bs, top_bs, speed, on_error, block_job_cb, bs, ++ &local_err); ++ } + if (local_err != NULL) { + error_propagate(errp, local_err); + return; +diff --git a/qapi-schema.json b/qapi-schema.json +index b0bd53c..a783e8e 100644 +--- a/qapi-schema.json ++++ b/qapi-schema.json +@@ -1837,9 +1837,11 @@ + # + # @top: The file name of the backing image within the image chain, + # which contains the topmost data to be committed down. +-# Note, the active layer as 'top' is currently unsupported. + # + # If top == base, that is an error. ++# If top == active, the job will not be completed by itself, ++# user needs to complete the job with the block-job-complete ++# command after getting the ready event. (Since 2.0) + # + # + # @speed: #optional the maximum speed, in bytes per second +@@ -1849,7 +1851,6 @@ + # If @device does not exist, DeviceNotFound + # If image commit is not supported by this device, NotSupported + # If @base or @top is invalid, a generic error is returned +-# If @top is the active layer, or omitted, a generic error is returned + # If @speed is invalid, InvalidParameter + # + # Since: 1.3 +-- +1.7.1 + diff --git a/SOURCES/kvm-configure-Fix-bugs-preventing-Ceph-inclusion.patch b/SOURCES/kvm-configure-Fix-bugs-preventing-Ceph-inclusion.patch new file mode 100644 index 0000000..1e2dd37 --- /dev/null +++ b/SOURCES/kvm-configure-Fix-bugs-preventing-Ceph-inclusion.patch @@ -0,0 +1,59 @@ +From af94bc39b8a4ce40083d15f660e147fb6a62b404 Mon Sep 17 00:00:00 2001 +From: Kevin Wolf +Date: Thu, 20 Mar 2014 10:59:23 +0100 +Subject: [PATCH] configure: Fix bugs preventing Ceph inclusion + +RH-Author: Kevin Wolf +Message-id: <1395313163-1002-1-git-send-email-kwolf@redhat.com> +Patchwork-id: 58164 +O-Subject: [RHEL-7.0 qemu-kvm PATCH] configure: Fix bugs preventing Ceph inclusion +Bugzilla: 1078809 +RH-Acked-by: Fam Zheng +RH-Acked-by: Miroslav Rezanina +RH-Acked-by: Ademar de Souza Reis Jr. + +Bugzilla: https://bugzilla.redhat.com/show_bug.cgi?id=1078809 +Brew: http://brewweb.devel.redhat.com/brew/taskinfo?taskID=7230126 +Upstream status: Fix for downstream-only code + +CONFIG_CEPH_SUPPORT=y never really ended up being set, neither by +default nor with an explicit --enable-ceph-support. + +Signed-off-by: Kevin Wolf +--- + configure | 6 +++--- + 1 file changed, 3 insertions(+), 3 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + configure | 6 +++--- + 1 files changed, 3 insertions(+), 3 deletions(-) + +diff --git a/configure b/configure +index 3f68220..0ac437c 100755 +--- a/configure ++++ b/configure +@@ -952,9 +952,9 @@ for opt do + ;; + --enable-live-block-migration) live_block_migration="yes" + ;; +- --disable-ceph-support) ceph_support=="no" ++ --disable-ceph-support) ceph_support="no" + ;; +- --enable-ceph-support) ceph_support=="yes" ++ --enable-ceph-support) ceph_support="yes" + ;; + --enable-vhdx) vhdx="yes" + ;; +@@ -4039,7 +4039,7 @@ if test "$live_block_migration" = "yes" ; then + echo "CONFIG_LIVE_BLOCK_MIGRATION=y" >> $config_host_mak + fi + +-if test "ceph_support" = "yes"; then ++if test "$ceph_support" = "yes"; then + echo "CONFIG_CEPH_SUPPORT=y" >> $config_host_mak + fi + +-- +1.7.1 + diff --git a/SOURCES/kvm-configure-add-option-to-disable-fstack-protect.patch b/SOURCES/kvm-configure-add-option-to-disable-fstack-protect.patch new file mode 100644 index 0000000..bc81295 --- /dev/null +++ b/SOURCES/kvm-configure-add-option-to-disable-fstack-protect.patch @@ -0,0 +1,126 @@ +From d43267efbe5634bfe9c8ca9cccd3d3d0a36759ae Mon Sep 17 00:00:00 2001 +From: Miroslav Rezanina +Date: Wed, 5 Feb 2014 15:02:19 +0100 +Subject: [PATCH 09/28] configure: add option to disable -fstack-protect + +RH-Author: Miroslav Rezanina +Message-id: +Patchwork-id: 57118 +O-Subject: [RHEL7 qemu-kvm PATCH 1/2] configure: add option to disable -fstack-protect +Bugzilla: 1044182 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Marcel Apfelbaum +RH-Acked-by: Markus Armbruster + +From: Miroslav Rezanina + +upstream: submitted +(Do not wait for apply to get to RHEL 7.0 before Snapshot 8) + +The -fstack-protector flag family is useful for ensuring safety and for +debugging, but has a performance impact. Here are some boot time comparisons +of the various versions of -fstack-protector using qemu-system-arm on an +x86_64 host: + # -fstack-protector-all + Startup finished in 1.810s (kernel) + 12.331s (initrd) + 49.016s +(userspace) = 1min 3.159s + Startup finished in 1.801s (kernel) + 12.287s (initrd) + 47.925s +(userspace) = 1min 2.013s + Startup finished in 1.812s (kernel) + 12.302s (initrd) + 47.995s +(userspace) = 1min 2.111s + + # -fstack-protector-strong + Startup finished in 1.744s (kernel) + 11.223s (initrd) + 44.688s +(userspace) = 57.657s + Startup finished in 1.721s (kernel) + 11.222s (initrd) + 44.194s +(userspace) = 57.138s + Startup finished in 1.693s (kernel) + 11.250s (initrd) + 44.426s +(userspace) = 57.370s + + # -fstack-protector + Startup finished in 1.705s (kernel) + 11.409s (initrd) + 43.563s +(userspace) = 56.677s + Startup finished in 1.877s (kernel) + 11.137s (initrd) + 43.719s +(userspace) = 56.734s + Startup finished in 1.708s (kernel) + 11.141s (initrd) + 43.628s +(userspace) = 56.478s + + # no stack protector + Startup finished in 1.743s (kernel) + 11.190s (initrd) + 43.709s +(userspace) = 56.643s + Startup finished in 1.763s (kernel) + 11.216s (initrd) + 43.767s +(userspace) = 56.747s + Startup finished in 1.711s (kernel) + 11.283s (initrd) + 43.878s +(userspace) = 56.873s + +This patch introduces a configure option to disable the stack protector +entirely, and conditional stack protector flag selection (in order, based on +availability): -fstack-protector-strong, -fstack-protector, no stack protector. + +Signed-off-by: Steven Noonan +Cc: Anthony Liguori +Reviewed-by: Stefan Weil + +Signed-off-by: Miroslav Rezanina +--- + configure | 18 +++++++++++++++--- + 1 file changed, 15 insertions(+), 3 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + configure | 18 +++++++++++++++--- + 1 files changed, 15 insertions(+), 3 deletions(-) + +diff --git a/configure b/configure +index b892b88..3f68220 100755 +--- a/configure ++++ b/configure +@@ -134,6 +134,7 @@ audio_win_int="" + cc_i386=i386-pc-linux-gnu-gcc + libs_qga="" + debug_info="yes" ++stack_protector="" + + # Don't accept a target_list environment variable. + unset target_list +@@ -839,6 +840,10 @@ for opt do + ;; + --disable-werror) werror="no" + ;; ++ --enable-stack-protector) stack_protector="yes" ++ ;; ++ --disable-stack-protector) stack_protector="no" ++ ;; + --disable-curses) curses="no" + ;; + --enable-curses) curses="yes" +@@ -1115,6 +1120,7 @@ echo " --enable-sparse enable sparse checker" + echo " --disable-sparse disable sparse checker (default)" + echo " --disable-strip disable stripping binaries" + echo " --disable-werror disable compilation abort on warning" ++echo " --disable-stack-protector disable compiler-provided stack protection" + echo " --disable-sdl disable SDL" + echo " --enable-sdl enable SDL" + echo " --disable-gtk disable gtk UI" +@@ -1296,9 +1302,15 @@ for flag in $gcc_flags; do + fi + done + +-if compile_prog "-Werror -fstack-protector-all" "" ; then +- QEMU_CFLAGS="$QEMU_CFLAGS -fstack-protector-all" +- LIBTOOLFLAGS="$LIBTOOLFLAGS -Wc,-fstack-protector-all" ++if test "$stack_protector" != "no" ; then ++ gcc_flags="-fstack-protector-strong -fstack-protector" ++ for flag in $gcc_flags; do ++ if compile_prog "-Werror $flag" "" ; then ++ QEMU_CFLAGS="$QEMU_CFLAGS $flag" ++ LIBTOOLFLAGS="$LIBTOOLFLAGS -Wc,$flag" ++ break ++ fi ++ done + fi + + # Workaround for http://gcc.gnu.org/PR55489. Happens with -fPIE/-fPIC and +-- +1.7.1 + diff --git a/SOURCES/kvm-configure-make-iasl-option-actually-work.patch b/SOURCES/kvm-configure-make-iasl-option-actually-work.patch new file mode 100644 index 0000000..6b7d9fd --- /dev/null +++ b/SOURCES/kvm-configure-make-iasl-option-actually-work.patch @@ -0,0 +1,60 @@ +From c30d1f4f94d18b19a1f17deb79b491e794e7e5a5 Mon Sep 17 00:00:00 2001 +From: Michael S. Tsirkin +Date: Sun, 12 Jan 2014 09:40:43 +0100 +Subject: [PATCH 07/16] configure: make --iasl option actually work + +RH-Author: Michael S. Tsirkin +Message-id: <1389519492-6867-4-git-send-email-mst@redhat.com> +Patchwork-id: 56635 +O-Subject: [PATCH qemu-kvm RHEL7.0 3/4] configure: make --iasl option actually work +Bugzilla: 1034876 +RH-Acked-by: Gerd Hoffmann +RH-Acked-by: Miroslav Rezanina +RH-Acked-by: Laszlo Ersek + +--iasl option was added to CC option parsing section by mistake, +it's not effective there and attempts to use cause +an 'unknown option' error. + +Fix this up. + +Tested-by: Marcel Apfelbaum +Signed-off-by: Michael S. Tsirkin +(cherry picked from commit e007dbece5fc4e55e10116c6cb42753e35a945bf) + +Conflicts: + configure +--- + configure | 4 ++-- + 1 file changed, 2 insertions(+), 2 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + configure | 4 ++-- + 1 files changed, 2 insertions(+), 2 deletions(-) + +diff --git a/configure b/configure +index 5161fec..b892b88 100755 +--- a/configure ++++ b/configure +@@ -255,8 +255,6 @@ for opt do + ;; + --cc=*) CC="$optarg" + ;; +- --iasl=*) iasl="$optarg" +- ;; + --source-path=*) source_path="$optarg" + ;; + --cpu=*) cpu="$optarg" +@@ -618,6 +616,8 @@ for opt do + ;; + --host-cc=*) host_cc="$optarg" + ;; ++ --iasl=*) iasl="$optarg" ++ ;; + --objcc=*) objcc="$optarg" + ;; + --make=*) make="$optarg" +-- +1.7.1 + diff --git a/SOURCES/kvm-curl-check-data-size-before-memcpy-to-local-buffer.-.patch b/SOURCES/kvm-curl-check-data-size-before-memcpy-to-local-buffer.-.patch new file mode 100644 index 0000000..161079f --- /dev/null +++ b/SOURCES/kvm-curl-check-data-size-before-memcpy-to-local-buffer.-.patch @@ -0,0 +1,50 @@ +From e64c6e9054f97e5894d875380d241124d8f0bcc9 Mon Sep 17 00:00:00 2001 +From: Fam Zheng +Date: Tue, 25 Mar 2014 14:23:26 +0100 +Subject: [PATCH 19/49] curl: check data size before memcpy to local buffer. (CVE-2014-0144) + +RH-Author: Kevin Wolf +Message-id: <1395753835-7591-20-git-send-email-kwolf@redhat.com> +Patchwork-id: n/a +O-Subject: [virt-devel] [EMBARGOED RHEL-7.0 qemu-kvm PATCH 19/48] curl: check data size before memcpy to local buffer. (CVE-2014-0144) +Bugzilla: 1079455 +RH-Acked-by: Jeff Cody +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Paolo Bonzini + +From: Fam Zheng + +Bugzilla: https://bugzilla.redhat.com/show_bug.cgi?id=1079455 +Upstream status: Embargoed + +curl_read_cb is callback function for libcurl when data arrives. The +data size passed in here is not guaranteed to be within the range of +request we submitted, so we may overflow the guest IO buffer. Check the +real size we have before memcpy to buffer to avoid overflow. + +Signed-off-by: Fam Zheng +Reviewed-by: Stefan Hajnoczi +Signed-off-by: Kevin Wolf +--- + block/curl.c | 5 +++++ + 1 files changed, 5 insertions(+), 0 deletions(-) + +diff --git a/block/curl.c b/block/curl.c +index 1b0fcf1..b3d948e 100644 +--- a/block/curl.c ++++ b/block/curl.c +@@ -134,6 +134,11 @@ static size_t curl_read_cb(void *ptr, size_t size, size_t nmemb, void *opaque) + if (!s || !s->orig_buf) + goto read_end; + ++ if (s->buf_off >= s->buf_len) { ++ /* buffer full, read nothing */ ++ return 0; ++ } ++ realsize = MIN(realsize, s->buf_len - s->buf_off); + memcpy(s->orig_buf + s->buf_off, ptr, realsize); + s->buf_off += realsize; + +-- +1.7.1 + diff --git a/SOURCES/kvm-dataplane-Fix-startup-race.patch b/SOURCES/kvm-dataplane-Fix-startup-race.patch new file mode 100644 index 0000000..9ae32ec --- /dev/null +++ b/SOURCES/kvm-dataplane-Fix-startup-race.patch @@ -0,0 +1,101 @@ +From f1ae5247cd1de4374905421e105d371aea6d7c75 Mon Sep 17 00:00:00 2001 +From: Stefan Hajnoczi +Date: Wed, 5 Mar 2014 14:15:03 +0100 +Subject: [PATCH 01/16] dataplane: Fix startup race. + +RH-Author: Stefan Hajnoczi +Message-id: <1394028903-5087-1-git-send-email-stefanha@redhat.com> +Patchwork-id: 58018 +O-Subject: [RHEL7 qemu-kvm PATCH] dataplane: Fix startup race. +Bugzilla: 1069541 +RH-Acked-by: Michael S. Tsirkin +RH-Acked-by: Kevin Wolf +RH-Acked-by: Paolo Bonzini + +From: Cornelia Huck + +Bugzilla: 1069541 +Upstream: 8caf907f07688972e5e7cd11526079b1665d6dba +BREW: http://brewweb.devel.redhat.com/brew/taskinfo?taskID=7144761 + +Avoid trying to setup dataplane again if dataplane setup is already in +progress. This may happen if an eventfd is triggered during setup. + +I saw this occasionally with an experimental s390 irqfd implementation: + +virtio_blk_handle_output +-> virtio_blk_data_plane_start +-> virtio_ccw_set_host_notifier +... +-> virtio_queue_set_host_notifier_fd_handler +-> virtio_queue_host_notifier_read +-> virtio_queue_notify_vq +-> virtio_blk_handle_output +-> virtio_blk_data_plane_start +-> vring_setup +-> hostmem_init +-> memory_listener_register +-> BOOM + +As virtio-ccw tries to follow what virtio-pci does, it might be triggerable +for other platforms as well. + +Signed-off-by: Cornelia Huck +Signed-off-by: Stefan Hajnoczi +(cherry picked from commit 8caf907f07688972e5e7cd11526079b1665d6dba) +Signed-off-by: Stefan Hajnoczi +--- +[----] : patches are identical +[####] : number of functional differences between upstream/downstream patch +[down] : patch is downstream-only +The flags [FC] indicate (F)unctional and (C)ontextual differences, respectively + +001/1:[----] [-C] 'dataplane: Fix startup race.' + + hw/block/dataplane/virtio-blk.c | 9 +++++++++ + 1 file changed, 9 insertions(+) + +Signed-off-by: Miroslav Rezanina +--- + hw/block/dataplane/virtio-blk.c | 9 +++++++++ + 1 files changed, 9 insertions(+), 0 deletions(-) + +diff --git a/hw/block/dataplane/virtio-blk.c b/hw/block/dataplane/virtio-blk.c +index 411becc..0b002ba 100644 +--- a/hw/block/dataplane/virtio-blk.c ++++ b/hw/block/dataplane/virtio-blk.c +@@ -42,6 +42,7 @@ typedef struct { + + struct VirtIOBlockDataPlane { + bool started; ++ bool starting; + bool stopping; + QEMUBH *start_bh; + QemuThread thread; +@@ -464,8 +465,15 @@ void virtio_blk_data_plane_start(VirtIOBlockDataPlane *s) + return; + } + ++ if (s->starting) { ++ return; ++ } ++ ++ s->starting = true; ++ + vq = virtio_get_queue(s->vdev, 0); + if (!vring_setup(&s->vring, s->vdev, 0)) { ++ s->starting = false; + return; + } + +@@ -495,6 +503,7 @@ void virtio_blk_data_plane_start(VirtIOBlockDataPlane *s) + s->io_notifier = *ioq_get_notifier(&s->ioqueue); + aio_set_event_notifier(s->ctx, &s->io_notifier, handle_io, flush_io); + ++ s->starting = false; + s->started = true; + trace_virtio_blk_data_plane_start(s); + +-- +1.7.1 + diff --git a/SOURCES/kvm-dmg-coding-style-and-indentation-cleanup.patch b/SOURCES/kvm-dmg-coding-style-and-indentation-cleanup.patch new file mode 100644 index 0000000..f8d21c2 --- /dev/null +++ b/SOURCES/kvm-dmg-coding-style-and-indentation-cleanup.patch @@ -0,0 +1,336 @@ +From 746c0b5934008a7e6a31c5de8ee5e799f88da9d9 Mon Sep 17 00:00:00 2001 +From: Stefan Hajnoczi +Date: Tue, 25 Mar 2014 14:23:40 +0100 +Subject: [PATCH 33/49] dmg: coding style and indentation cleanup + +RH-Author: Kevin Wolf +Message-id: <1395753835-7591-34-git-send-email-kwolf@redhat.com> +Patchwork-id: n/a +O-Subject: [virt-devel] [EMBARGOED RHEL-7.0 qemu-kvm PATCH 33/48] dmg: coding style and indentation cleanup +Bugzilla: 1066691 +RH-Acked-by: Jeff Cody +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Paolo Bonzini + +From: Stefan Hajnoczi + +Bugzilla: https://bugzilla.redhat.com/show_bug.cgi?id=1066691 +Upstream status: Series embargoed + +Clean up the mix of tabs and spaces, as well as the coding style +violations in block/dmg.c. There are no semantic changes since this +patch simply reformats the code. + +This patch is necessary before we can make meaningful changes to this +file, due to the inconsistent formatting and confusing indentation. + +Signed-off-by: Stefan Hajnoczi +Signed-off-by: Kevin Wolf +--- + block/dmg.c | 224 +++++++++++++++++++++++++++++++--------------------------- + 1 files changed, 120 insertions(+), 104 deletions(-) + +diff --git a/block/dmg.c b/block/dmg.c +index d5e9b1f..be2f26e 100644 +--- a/block/dmg.c ++++ b/block/dmg.c +@@ -96,9 +96,9 @@ static int dmg_open(BlockDriverState *bs, QDict *options, int flags, + Error **errp) + { + BDRVDMGState *s = bs->opaque; +- uint64_t info_begin,info_end,last_in_offset,last_out_offset; ++ uint64_t info_begin, info_end, last_in_offset, last_out_offset; + uint32_t count, tmp; +- uint32_t max_compressed_size=1,max_sectors_per_chunk=1,i; ++ uint32_t max_compressed_size = 1, max_sectors_per_chunk = 1, i; + int64_t offset; + int ret; + +@@ -160,37 +160,39 @@ static int dmg_open(BlockDriverState *bs, QDict *options, int flags, + goto fail; + } + +- if (type == 0x6d697368 && count >= 244) { +- int new_size, chunk_count; ++ if (type == 0x6d697368 && count >= 244) { ++ int new_size, chunk_count; + + offset += 4; + offset += 200; + +- chunk_count = (count-204)/40; +- new_size = sizeof(uint64_t) * (s->n_chunks + chunk_count); +- s->types = g_realloc(s->types, new_size/2); +- s->offsets = g_realloc(s->offsets, new_size); +- s->lengths = g_realloc(s->lengths, new_size); +- s->sectors = g_realloc(s->sectors, new_size); +- s->sectorcounts = g_realloc(s->sectorcounts, new_size); ++ chunk_count = (count - 204) / 40; ++ new_size = sizeof(uint64_t) * (s->n_chunks + chunk_count); ++ s->types = g_realloc(s->types, new_size / 2); ++ s->offsets = g_realloc(s->offsets, new_size); ++ s->lengths = g_realloc(s->lengths, new_size); ++ s->sectors = g_realloc(s->sectors, new_size); ++ s->sectorcounts = g_realloc(s->sectorcounts, new_size); + + for (i = s->n_chunks; i < s->n_chunks + chunk_count; i++) { + ret = read_uint32(bs, offset, &s->types[i]); + if (ret < 0) { + goto fail; + } +- offset += 4; +- if(s->types[i]!=0x80000005 && s->types[i]!=1 && s->types[i]!=2) { +- if(s->types[i]==0xffffffff) { +- last_in_offset = s->offsets[i-1]+s->lengths[i-1]; +- last_out_offset = s->sectors[i-1]+s->sectorcounts[i-1]; +- } +- chunk_count--; +- i--; +- offset += 36; +- continue; +- } +- offset += 4; ++ offset += 4; ++ if (s->types[i] != 0x80000005 && s->types[i] != 1 && ++ s->types[i] != 2) { ++ if (s->types[i] == 0xffffffff) { ++ last_in_offset = s->offsets[i - 1] + s->lengths[i - 1]; ++ last_out_offset = s->sectors[i - 1] + ++ s->sectorcounts[i - 1]; ++ } ++ chunk_count--; ++ i--; ++ offset += 36; ++ continue; ++ } ++ offset += 4; + + ret = read_uint64(bs, offset, &s->sectors[i]); + if (ret < 0) { +@@ -218,19 +220,21 @@ static int dmg_open(BlockDriverState *bs, QDict *options, int flags, + } + offset += 8; + +- if(s->lengths[i]>max_compressed_size) +- max_compressed_size = s->lengths[i]; +- if(s->sectorcounts[i]>max_sectors_per_chunk) +- max_sectors_per_chunk = s->sectorcounts[i]; +- } +- s->n_chunks+=chunk_count; +- } ++ if (s->lengths[i] > max_compressed_size) { ++ max_compressed_size = s->lengths[i]; ++ } ++ if (s->sectorcounts[i] > max_sectors_per_chunk) { ++ max_sectors_per_chunk = s->sectorcounts[i]; ++ } ++ } ++ s->n_chunks += chunk_count; ++ } + } + + /* initialize zlib engine */ +- s->compressed_chunk = g_malloc(max_compressed_size+1); +- s->uncompressed_chunk = g_malloc(512*max_sectors_per_chunk); +- if(inflateInit(&s->zstream) != Z_OK) { ++ s->compressed_chunk = g_malloc(max_compressed_size + 1); ++ s->uncompressed_chunk = g_malloc(512 * max_sectors_per_chunk); ++ if (inflateInit(&s->zstream) != Z_OK) { + ret = -EINVAL; + goto fail; + } +@@ -252,27 +256,29 @@ fail: + } + + static inline int is_sector_in_chunk(BDRVDMGState* s, +- uint32_t chunk_num,int sector_num) ++ uint32_t chunk_num, int sector_num) + { +- if(chunk_num>=s->n_chunks || s->sectors[chunk_num]>sector_num || +- s->sectors[chunk_num]+s->sectorcounts[chunk_num]<=sector_num) +- return 0; +- else +- return -1; ++ if (chunk_num >= s->n_chunks || s->sectors[chunk_num] > sector_num || ++ s->sectors[chunk_num] + s->sectorcounts[chunk_num] <= sector_num) { ++ return 0; ++ } else { ++ return -1; ++ } + } + +-static inline uint32_t search_chunk(BDRVDMGState* s,int sector_num) ++static inline uint32_t search_chunk(BDRVDMGState *s, int sector_num) + { + /* binary search */ +- uint32_t chunk1=0,chunk2=s->n_chunks,chunk3; +- while(chunk1!=chunk2) { +- chunk3 = (chunk1+chunk2)/2; +- if(s->sectors[chunk3]>sector_num) +- chunk2 = chunk3; +- else if(s->sectors[chunk3]+s->sectorcounts[chunk3]>sector_num) +- return chunk3; +- else +- chunk1 = chunk3; ++ uint32_t chunk1 = 0, chunk2 = s->n_chunks, chunk3; ++ while (chunk1 != chunk2) { ++ chunk3 = (chunk1 + chunk2) / 2; ++ if (s->sectors[chunk3] > sector_num) { ++ chunk2 = chunk3; ++ } else if (s->sectors[chunk3] + s->sectorcounts[chunk3] > sector_num) { ++ return chunk3; ++ } else { ++ chunk1 = chunk3; ++ } + } + return s->n_chunks; /* error */ + } +@@ -281,54 +287,62 @@ static inline int dmg_read_chunk(BlockDriverState *bs, int sector_num) + { + BDRVDMGState *s = bs->opaque; + +- if(!is_sector_in_chunk(s,s->current_chunk,sector_num)) { +- int ret; +- uint32_t chunk = search_chunk(s,sector_num); ++ if (!is_sector_in_chunk(s, s->current_chunk, sector_num)) { ++ int ret; ++ uint32_t chunk = search_chunk(s, sector_num); + +- if(chunk>=s->n_chunks) +- return -1; ++ if (chunk >= s->n_chunks) { ++ return -1; ++ } + +- s->current_chunk = s->n_chunks; +- switch(s->types[chunk]) { +- case 0x80000005: { /* zlib compressed */ +- int i; ++ s->current_chunk = s->n_chunks; ++ switch (s->types[chunk]) { ++ case 0x80000005: { /* zlib compressed */ ++ int i; + +- /* we need to buffer, because only the chunk as whole can be +- * inflated. */ +- i=0; +- do { ++ /* we need to buffer, because only the chunk as whole can be ++ * inflated. */ ++ i = 0; ++ do { + ret = bdrv_pread(bs->file, s->offsets[chunk] + i, +- s->compressed_chunk+i, s->lengths[chunk]-i); +- if(ret<0 && errno==EINTR) +- ret=0; +- i+=ret; +- } while(ret>=0 && ret+ilengths[chunk]); +- +- if (ret != s->lengths[chunk]) +- return -1; +- +- s->zstream.next_in = s->compressed_chunk; +- s->zstream.avail_in = s->lengths[chunk]; +- s->zstream.next_out = s->uncompressed_chunk; +- s->zstream.avail_out = 512*s->sectorcounts[chunk]; +- ret = inflateReset(&s->zstream); +- if(ret != Z_OK) +- return -1; +- ret = inflate(&s->zstream, Z_FINISH); +- if(ret != Z_STREAM_END || s->zstream.total_out != 512*s->sectorcounts[chunk]) +- return -1; +- break; } +- case 1: /* copy */ +- ret = bdrv_pread(bs->file, s->offsets[chunk], ++ s->compressed_chunk + i, ++ s->lengths[chunk] - i); ++ if (ret < 0 && errno == EINTR) { ++ ret = 0; ++ } ++ i += ret; ++ } while (ret >= 0 && ret + i < s->lengths[chunk]); ++ ++ if (ret != s->lengths[chunk]) { ++ return -1; ++ } ++ ++ s->zstream.next_in = s->compressed_chunk; ++ s->zstream.avail_in = s->lengths[chunk]; ++ s->zstream.next_out = s->uncompressed_chunk; ++ s->zstream.avail_out = 512 * s->sectorcounts[chunk]; ++ ret = inflateReset(&s->zstream); ++ if (ret != Z_OK) { ++ return -1; ++ } ++ ret = inflate(&s->zstream, Z_FINISH); ++ if (ret != Z_STREAM_END || ++ s->zstream.total_out != 512 * s->sectorcounts[chunk]) { ++ return -1; ++ } ++ break; } ++ case 1: /* copy */ ++ ret = bdrv_pread(bs->file, s->offsets[chunk], + s->uncompressed_chunk, s->lengths[chunk]); +- if (ret != s->lengths[chunk]) +- return -1; +- break; +- case 2: /* zero */ +- memset(s->uncompressed_chunk, 0, 512*s->sectorcounts[chunk]); +- break; +- } +- s->current_chunk = chunk; ++ if (ret != s->lengths[chunk]) { ++ return -1; ++ } ++ break; ++ case 2: /* zero */ ++ memset(s->uncompressed_chunk, 0, 512 * s->sectorcounts[chunk]); ++ break; ++ } ++ s->current_chunk = chunk; + } + return 0; + } +@@ -339,12 +353,14 @@ static int dmg_read(BlockDriverState *bs, int64_t sector_num, + BDRVDMGState *s = bs->opaque; + int i; + +- for(i=0;isectors[s->current_chunk]; +- memcpy(buf+i*512,s->uncompressed_chunk+sector_offset_in_chunk*512,512); ++ for (i = 0; i < nb_sectors; i++) { ++ uint32_t sector_offset_in_chunk; ++ if (dmg_read_chunk(bs, sector_num + i) != 0) { ++ return -1; ++ } ++ sector_offset_in_chunk = sector_num + i - s->sectors[s->current_chunk]; ++ memcpy(buf + i * 512, ++ s->uncompressed_chunk + sector_offset_in_chunk * 512, 512); + } + return 0; + } +@@ -376,12 +392,12 @@ static void dmg_close(BlockDriverState *bs) + } + + static BlockDriver bdrv_dmg = { +- .format_name = "dmg", +- .instance_size = sizeof(BDRVDMGState), +- .bdrv_probe = dmg_probe, +- .bdrv_open = dmg_open, +- .bdrv_read = dmg_co_read, +- .bdrv_close = dmg_close, ++ .format_name = "dmg", ++ .instance_size = sizeof(BDRVDMGState), ++ .bdrv_probe = dmg_probe, ++ .bdrv_open = dmg_open, ++ .bdrv_read = dmg_co_read, ++ .bdrv_close = dmg_close, + }; + + static void bdrv_dmg_init(void) +-- +1.7.1 + diff --git a/SOURCES/kvm-dmg-drop-broken-bdrv_pread-loop.patch b/SOURCES/kvm-dmg-drop-broken-bdrv_pread-loop.patch new file mode 100644 index 0000000..b3ed27a --- /dev/null +++ b/SOURCES/kvm-dmg-drop-broken-bdrv_pread-loop.patch @@ -0,0 +1,71 @@ +From 35538bdb46122fdf90ca869df29869b8aeaefa09 Mon Sep 17 00:00:00 2001 +From: Stefan Hajnoczi +Date: Tue, 25 Mar 2014 14:23:42 +0100 +Subject: [PATCH 35/49] dmg: drop broken bdrv_pread() loop + +RH-Author: Kevin Wolf +Message-id: <1395753835-7591-36-git-send-email-kwolf@redhat.com> +Patchwork-id: n/a +O-Subject: [virt-devel] [EMBARGOED RHEL-7.0 qemu-kvm PATCH 35/48] dmg: drop broken bdrv_pread() loop +Bugzilla: 1066691 +RH-Acked-by: Jeff Cody +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Paolo Bonzini + +From: Stefan Hajnoczi + +Bugzilla: https://bugzilla.redhat.com/show_bug.cgi?id=1066691 +Upstream status: Series embargoed + +It is not necessary to check errno for EINTR and the block layer does +not produce short reads. Therefore we can drop the loop that attempts +to read a compressed chunk. + +The loop is buggy because it incorrectly adds the transferred bytes +twice: + +do { +ret = bdrv_pread(...); +i += ret; +} while (ret >= 0 && ret + i < s->lengths[chunk]); + +Luckily we can drop the loop completely and perform a single +bdrv_pread(). + +Signed-off-by: Stefan Hajnoczi +Signed-off-by: Kevin Wolf +--- + block/dmg.c | 15 ++------------- + 1 files changed, 2 insertions(+), 13 deletions(-) + +diff --git a/block/dmg.c b/block/dmg.c +index f4f3e8e..1cc5426 100644 +--- a/block/dmg.c ++++ b/block/dmg.c +@@ -298,21 +298,10 @@ static inline int dmg_read_chunk(BlockDriverState *bs, int sector_num) + s->current_chunk = s->n_chunks; + switch (s->types[chunk]) { + case 0x80000005: { /* zlib compressed */ +- int i; +- + /* we need to buffer, because only the chunk as whole can be + * inflated. */ +- i = 0; +- do { +- ret = bdrv_pread(bs->file, s->offsets[chunk] + i, +- s->compressed_chunk + i, +- s->lengths[chunk] - i); +- if (ret < 0 && errno == EINTR) { +- ret = 0; +- } +- i += ret; +- } while (ret >= 0 && ret + i < s->lengths[chunk]); +- ++ ret = bdrv_pread(bs->file, s->offsets[chunk], ++ s->compressed_chunk, s->lengths[chunk]); + if (ret != s->lengths[chunk]) { + return -1; + } +-- +1.7.1 + diff --git a/SOURCES/kvm-dmg-prevent-chunk-buffer-overflow-CVE-2014-0145.patch b/SOURCES/kvm-dmg-prevent-chunk-buffer-overflow-CVE-2014-0145.patch new file mode 100644 index 0000000..9e2578c --- /dev/null +++ b/SOURCES/kvm-dmg-prevent-chunk-buffer-overflow-CVE-2014-0145.patch @@ -0,0 +1,105 @@ +From 0b7385ddaa538c5995d2f16333a80a0f579a6212 Mon Sep 17 00:00:00 2001 +From: Stefan Hajnoczi +Date: Tue, 25 Mar 2014 14:23:46 +0100 +Subject: [PATCH 39/49] dmg: prevent chunk buffer overflow (CVE-2014-0145) + +RH-Author: Kevin Wolf +Message-id: <1395753835-7591-40-git-send-email-kwolf@redhat.com> +Patchwork-id: n/a +O-Subject: [virt-devel] [EMBARGOED RHEL-7.0 qemu-kvm PATCH 39/48] dmg: prevent chunk buffer overflow (CVE-2014-0145) +Bugzilla: 1079325 +RH-Acked-by: Jeff Cody +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Paolo Bonzini + +From: Stefan Hajnoczi + +Bugzilla: https://bugzilla.redhat.com/show_bug.cgi?id=1079325 +Upstream status: Embargoed + +Both compressed and uncompressed I/O is buffered. dmg_open() calculates +the maximum buffer size needed from the metadata in the image file. + +There is currently a buffer overflow since ->lengths[] is accounted +against the maximum compressed buffer size but actually uses the +uncompressed buffer: + +switch (s->types[chunk]) { +case 1: /bin /boot /cgroup /dev /etc /home /lib /lib64 /lost+found /media /misc /mnt /net /opt /proc /root /sbin /selinux /srv /sys /tmp /usr /var copy audio/ backends/ block/ bsd-user/ default-configs/ disas/ docs/ dtc/ fpu/ fsdev/ gdb-xml/ hw/ include/ ldscripts/ libcacard/ linux-headers/ linux-user/ net/ pc-bios/ pixman/ po/ qapi/ qga/ QMP/ qobject/ qom/ redhat/ roms/ scripts/ slirp/ stubs/ sysconfigs/ target-alpha/ target-arm/ target-cris/ target-i386/ target-lm32/ target-m68k/ target-microblaze/ target-mips/ target-moxie/ target-openrisc/ target-ppc/ target-s390x/ target-sh4/ target-sparc/ target-unicore32/ target-xtensa/ tcg/ tests/ trace/ ui/ util/ +ret = bdrv_pread(bs->file, s->offsets[chunk], +s->uncompressed_chunk, s->lengths[chunk]); + +We must account against the maximum uncompressed buffer size for type=1 +chunks. + +This patch fixes the maximum buffer size calculation to take into +account the chunk type. It is critical that we update the correct +maximum since there are two buffers ->compressed_chunk and +->uncompressed_chunk. + +Signed-off-by: Stefan Hajnoczi +Signed-off-by: Kevin Wolf +--- + block/dmg.c | 39 +++++++++++++++++++++++++++++++++------ + 1 files changed, 33 insertions(+), 6 deletions(-) + +diff --git a/block/dmg.c b/block/dmg.c +index be0ee33..856402e 100644 +--- a/block/dmg.c ++++ b/block/dmg.c +@@ -100,6 +100,37 @@ static int read_uint32(BlockDriverState *bs, int64_t offset, uint32_t *result) + return 0; + } + ++/* Increase max chunk sizes, if necessary. This function is used to calculate ++ * the buffer sizes needed for compressed/uncompressed chunk I/O. ++ */ ++static void update_max_chunk_size(BDRVDMGState *s, uint32_t chunk, ++ uint32_t *max_compressed_size, ++ uint32_t *max_sectors_per_chunk) ++{ ++ uint32_t compressed_size = 0; ++ uint32_t uncompressed_sectors = 0; ++ ++ switch (s->types[chunk]) { ++ case 0x80000005: /* zlib compressed */ ++ compressed_size = s->lengths[chunk]; ++ uncompressed_sectors = s->sectorcounts[chunk]; ++ break; ++ case 1: /* copy */ ++ uncompressed_sectors = (s->lengths[chunk] + 511) / 512; ++ break; ++ case 2: /* zero */ ++ uncompressed_sectors = s->sectorcounts[chunk]; ++ break; ++ } ++ ++ if (compressed_size > *max_compressed_size) { ++ *max_compressed_size = compressed_size; ++ } ++ if (uncompressed_sectors > *max_sectors_per_chunk) { ++ *max_sectors_per_chunk = uncompressed_sectors; ++ } ++} ++ + static int dmg_open(BlockDriverState *bs, QDict *options, int flags, + Error **errp) + { +@@ -245,12 +276,8 @@ static int dmg_open(BlockDriverState *bs, QDict *options, int flags, + goto fail; + } + +- if (s->lengths[i] > max_compressed_size) { +- max_compressed_size = s->lengths[i]; +- } +- if (s->sectorcounts[i] > max_sectors_per_chunk) { +- max_sectors_per_chunk = s->sectorcounts[i]; +- } ++ update_max_chunk_size(s, i, &max_compressed_size, ++ &max_sectors_per_chunk); + } + s->n_chunks += chunk_count; + } +-- +1.7.1 + diff --git a/SOURCES/kvm-dmg-prevent-out-of-bounds-array-access-on-terminator.patch b/SOURCES/kvm-dmg-prevent-out-of-bounds-array-access-on-terminator.patch new file mode 100644 index 0000000..5181e77 --- /dev/null +++ b/SOURCES/kvm-dmg-prevent-out-of-bounds-array-access-on-terminator.patch @@ -0,0 +1,48 @@ +From bf5a2fd38203f176501ad891da1e7ea19da1673a Mon Sep 17 00:00:00 2001 +From: Stefan Hajnoczi +Date: Tue, 25 Mar 2014 14:23:41 +0100 +Subject: [PATCH 34/49] dmg: prevent out-of-bounds array access on terminator + +RH-Author: Kevin Wolf +Message-id: <1395753835-7591-35-git-send-email-kwolf@redhat.com> +Patchwork-id: n/a +O-Subject: [virt-devel] [EMBARGOED RHEL-7.0 qemu-kvm PATCH 34/48] dmg: prevent out-of-bounds array access on terminator +Bugzilla: 1066691 +RH-Acked-by: Jeff Cody +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Paolo Bonzini + +From: Stefan Hajnoczi + +Bugzilla: https://bugzilla.redhat.com/show_bug.cgi?id=1066691 +Upstream status: Series embargoed + +When a terminator is reached the base for offsets and sectors is stored. +The following records that are processed will use this base value. + +If the first record we encounter is a terminator, then calculating the +base values would result in out-of-bounds array accesses. Don't do +that. + +Signed-off-by: Stefan Hajnoczi +Signed-off-by: Kevin Wolf +--- + block/dmg.c | 2 +- + 1 files changed, 1 insertions(+), 1 deletions(-) + +diff --git a/block/dmg.c b/block/dmg.c +index be2f26e..f4f3e8e 100644 +--- a/block/dmg.c ++++ b/block/dmg.c +@@ -182,7 +182,7 @@ static int dmg_open(BlockDriverState *bs, QDict *options, int flags, + offset += 4; + if (s->types[i] != 0x80000005 && s->types[i] != 1 && + s->types[i] != 2) { +- if (s->types[i] == 0xffffffff) { ++ if (s->types[i] == 0xffffffff && i > 0) { + last_in_offset = s->offsets[i - 1] + s->lengths[i - 1]; + last_out_offset = s->sectors[i - 1] + + s->sectorcounts[i - 1]; +-- +1.7.1 + diff --git a/SOURCES/kvm-dmg-sanitize-chunk-length-and-sectorcount-CVE-2014-0.patch b/SOURCES/kvm-dmg-sanitize-chunk-length-and-sectorcount-CVE-2014-0.patch new file mode 100644 index 0000000..11cec63 --- /dev/null +++ b/SOURCES/kvm-dmg-sanitize-chunk-length-and-sectorcount-CVE-2014-0.patch @@ -0,0 +1,82 @@ +From ec4d254830e3da2ebb1cd9fec16c407e5b644ca6 Mon Sep 17 00:00:00 2001 +From: Stefan Hajnoczi +Date: Tue, 25 Mar 2014 14:23:44 +0100 +Subject: [PATCH 37/49] dmg: sanitize chunk length and sectorcount (CVE-2014-0145) + +RH-Author: Kevin Wolf +Message-id: <1395753835-7591-38-git-send-email-kwolf@redhat.com> +Patchwork-id: n/a +O-Subject: [virt-devel] [EMBARGOED RHEL-7.0 qemu-kvm PATCH 37/48] dmg: sanitize chunk length and sectorcount (CVE-2014-0145) +Bugzilla: 1079325 +RH-Acked-by: Jeff Cody +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Paolo Bonzini + +From: Stefan Hajnoczi + +Bugzilla: https://bugzilla.redhat.com/show_bug.cgi?id=1079325 +Upstream status: Embargoed + +Chunk length and sectorcount are used for decompression buffers as well +as the bdrv_pread() count argument. Ensure that they have reasonable +values so neither memory allocation nor conversion from uint64_t to int +will cause problems. + +Signed-off-by: Stefan Hajnoczi +Signed-off-by: Kevin Wolf +--- + block/dmg.c | 24 ++++++++++++++++++++++++ + 1 files changed, 24 insertions(+), 0 deletions(-) + +diff --git a/block/dmg.c b/block/dmg.c +index f98c94d..ad253fe 100644 +--- a/block/dmg.c ++++ b/block/dmg.c +@@ -27,6 +27,14 @@ + #include "qemu/module.h" + #include + ++enum { ++ /* Limit chunk sizes to prevent unreasonable amounts of memory being used ++ * or truncating when converting to 32-bit types ++ */ ++ DMG_LENGTHS_MAX = 64 * 1024 * 1024, /* 64 MB */ ++ DMG_SECTORCOUNTS_MAX = DMG_LENGTHS_MAX / 512, ++}; ++ + typedef struct BDRVDMGState { + CoMutex lock; + /* each chunk contains a certain number of sectors, +@@ -208,6 +216,14 @@ static int dmg_open(BlockDriverState *bs, QDict *options, int flags, + } + offset += 8; + ++ if (s->sectorcounts[i] > DMG_SECTORCOUNTS_MAX) { ++ error_report("sector count %" PRIu64 " for chunk %u is " ++ "larger than max (%u)", ++ s->sectorcounts[i], i, DMG_SECTORCOUNTS_MAX); ++ ret = -EINVAL; ++ goto fail; ++ } ++ + ret = read_uint64(bs, offset, &s->offsets[i]); + if (ret < 0) { + goto fail; +@@ -221,6 +237,14 @@ static int dmg_open(BlockDriverState *bs, QDict *options, int flags, + } + offset += 8; + ++ if (s->lengths[i] > DMG_LENGTHS_MAX) { ++ error_report("length %" PRIu64 " for chunk %u is larger " ++ "than max (%u)", ++ s->lengths[i], i, DMG_LENGTHS_MAX); ++ ret = -EINVAL; ++ goto fail; ++ } ++ + if (s->lengths[i] > max_compressed_size) { + max_compressed_size = s->lengths[i]; + } +-- +1.7.1 + diff --git a/SOURCES/kvm-dmg-use-appropriate-types-when-reading-chunks.patch b/SOURCES/kvm-dmg-use-appropriate-types-when-reading-chunks.patch new file mode 100644 index 0000000..9f60c91 --- /dev/null +++ b/SOURCES/kvm-dmg-use-appropriate-types-when-reading-chunks.patch @@ -0,0 +1,56 @@ +From 6be48dc02a2906f7b88dc5b2751f19b530ec0f58 Mon Sep 17 00:00:00 2001 +From: Stefan Hajnoczi +Date: Tue, 25 Mar 2014 14:23:43 +0100 +Subject: [PATCH 36/49] dmg: use appropriate types when reading chunks + +RH-Author: Kevin Wolf +Message-id: <1395753835-7591-37-git-send-email-kwolf@redhat.com> +Patchwork-id: n/a +O-Subject: [virt-devel] [EMBARGOED RHEL-7.0 qemu-kvm PATCH 36/48] dmg: use appropriate types when reading chunks +Bugzilla: 1066691 +RH-Acked-by: Jeff Cody +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Paolo Bonzini + +From: Stefan Hajnoczi + +Bugzilla: https://bugzilla.redhat.com/show_bug.cgi?id=1066691 +Upstream status: Series embargoed + +Use the right types instead of signed int: + +size_t new_size; + +This is a byte count for g_realloc() that is calculated from uint32_t +and size_t values. + +uint32_t chunk_count; + +Use the same type as s->n_chunks, which is used together with +chunk_count. + +This patch is a cleanup and does not fix bugs. + +Signed-off-by: Stefan Hajnoczi +Signed-off-by: Kevin Wolf +--- + block/dmg.c | 3 ++- + 1 files changed, 2 insertions(+), 1 deletions(-) + +diff --git a/block/dmg.c b/block/dmg.c +index 1cc5426..f98c94d 100644 +--- a/block/dmg.c ++++ b/block/dmg.c +@@ -161,7 +161,8 @@ static int dmg_open(BlockDriverState *bs, QDict *options, int flags, + } + + if (type == 0x6d697368 && count >= 244) { +- int new_size, chunk_count; ++ size_t new_size; ++ uint32_t chunk_count; + + offset += 4; + offset += 200; +-- +1.7.1 + diff --git a/SOURCES/kvm-dmg-use-uint64_t-consistently-for-sectors-and-length.patch b/SOURCES/kvm-dmg-use-uint64_t-consistently-for-sectors-and-length.patch new file mode 100644 index 0000000..4262da7 --- /dev/null +++ b/SOURCES/kvm-dmg-use-uint64_t-consistently-for-sectors-and-length.patch @@ -0,0 +1,63 @@ +From dbcfb970e94adbf251dadb900128d576a7e0a737 Mon Sep 17 00:00:00 2001 +From: Stefan Hajnoczi +Date: Tue, 25 Mar 2014 14:23:45 +0100 +Subject: [PATCH 38/49] dmg: use uint64_t consistently for sectors and lengths + +RH-Author: Kevin Wolf +Message-id: <1395753835-7591-39-git-send-email-kwolf@redhat.com> +Patchwork-id: n/a +O-Subject: [virt-devel] [EMBARGOED RHEL-7.0 qemu-kvm PATCH 38/48] dmg: use uint64_t consistently for sectors and lengths +Bugzilla: 1066691 +RH-Acked-by: Jeff Cody +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Paolo Bonzini + +From: Stefan Hajnoczi + +Bugzilla: https://bugzilla.redhat.com/show_bug.cgi?id=1066691 +Upstream status: Series embargoed + +The DMG metadata is stored as uint64_t, so use the same type for +sector_num. int was a particularly poor choice since it is only 32-bit +and would truncate large values. + +Signed-off-by: Stefan Hajnoczi +Signed-off-by: Kevin Wolf +--- + block/dmg.c | 6 +++--- + 1 files changed, 3 insertions(+), 3 deletions(-) + +diff --git a/block/dmg.c b/block/dmg.c +index ad253fe..be0ee33 100644 +--- a/block/dmg.c ++++ b/block/dmg.c +@@ -281,7 +281,7 @@ fail: + } + + static inline int is_sector_in_chunk(BDRVDMGState* s, +- uint32_t chunk_num, int sector_num) ++ uint32_t chunk_num, uint64_t sector_num) + { + if (chunk_num >= s->n_chunks || s->sectors[chunk_num] > sector_num || + s->sectors[chunk_num] + s->sectorcounts[chunk_num] <= sector_num) { +@@ -291,7 +291,7 @@ static inline int is_sector_in_chunk(BDRVDMGState* s, + } + } + +-static inline uint32_t search_chunk(BDRVDMGState *s, int sector_num) ++static inline uint32_t search_chunk(BDRVDMGState *s, uint64_t sector_num) + { + /* binary search */ + uint32_t chunk1 = 0, chunk2 = s->n_chunks, chunk3; +@@ -308,7 +308,7 @@ static inline uint32_t search_chunk(BDRVDMGState *s, int sector_num) + return s->n_chunks; /* error */ + } + +-static inline int dmg_read_chunk(BlockDriverState *bs, int sector_num) ++static inline int dmg_read_chunk(BlockDriverState *bs, uint64_t sector_num) + { + BDRVDMGState *s = bs->opaque; + +-- +1.7.1 + diff --git a/SOURCES/kvm-doc-fix-hardcoded-helper-path.patch b/SOURCES/kvm-doc-fix-hardcoded-helper-path.patch new file mode 100644 index 0000000..20dcf31 --- /dev/null +++ b/SOURCES/kvm-doc-fix-hardcoded-helper-path.patch @@ -0,0 +1,74 @@ +From 4df441f7a38bf7bdbc625cfd7b79c7b9f0780adc Mon Sep 17 00:00:00 2001 +From: Amos Kong +Date: Thu, 21 Nov 2013 04:58:50 +0100 +Subject: [PATCH 06/14] doc: fix hardcoded helper path + +RH-Author: Amos Kong +Message-id: <1385009930-5005-1-git-send-email-akong@redhat.com> +Patchwork-id: 55827 +O-Subject: [RHEL-7.0 qemu-kvm PATCH v2] doc: fix hardcoded helper path +Bugzilla: 1016952 +RH-Acked-by: Michael S. Tsirkin +RH-Acked-by: Vlad Yasevich +RH-Acked-by: Stefan Hajnoczi + +Bugzilla: 1016952 +Brew: http://brewweb.devel.redhat.com/brew/taskinfo?taskID=6621357 +Upstream: merged, we should parse C macros in texi mode in future + +The install directory of qemu-bridge-helper is configurable, +but we use a fixed path in the documentation. + +DEFAULT_BRIDGE_HELPER macro isn't available in texi mode, +we should always use "/path/to/" prefix for dynamic paths +(e.g.: /path/to/image, /path/to/linux, etc). + +Signed-off-by: Amos Kong +Reviewed-by: Stefan Hajnoczi +Signed-off-by: Michael S. Tsirkin +(cherry picked from commit 420508fbba2a6e8eaff008715b5f7eff83f8e865) +--- +v2: replace hardcode path prefix by '/path/to/' +--- + qemu-options.hx | 6 +++--- + 1 files changed, 3 insertions(+), 3 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + qemu-options.hx | 6 +++--- + 1 files changed, 3 insertions(+), 3 deletions(-) + +diff --git a/qemu-options.hx b/qemu-options.hx +index 3c60140..e3c5d67 100644 +--- a/qemu-options.hx ++++ b/qemu-options.hx +@@ -1593,7 +1593,7 @@ to disable script execution. + + If running QEMU as an unprivileged user, use the network helper + @var{helper} to configure the TAP interface. The default network +-helper executable is @file{/usr/local/libexec/qemu-bridge-helper}. ++helper executable is @file{/path/to/qemu-bridge-helper}. + + @option{fd}=@var{h} can be used to specify the handle of an already + opened host TAP interface. +@@ -1617,7 +1617,7 @@ qemu-system-i386 linux.img \ + #launch a QEMU instance with the default network helper to + #connect a TAP device to bridge br0 + qemu-system-i386 linux.img \ +- -net nic -net tap,"helper=/usr/local/libexec/qemu-bridge-helper" ++ -net nic -net tap,"helper=/path/to/qemu-bridge-helper" + @end example + + @item -netdev bridge,id=@var{id}[,br=@var{bridge}][,helper=@var{helper}] +@@ -1626,7 +1626,7 @@ Connect a host TAP network interface to a host bridge device. + + Use the network helper @var{helper} to configure the TAP interface and + attach it to the bridge. The default network helper executable is +-@file{/usr/local/libexec/qemu-bridge-helper} and the default bridge ++@file{/path/to/qemu-bridge-helper} and the default bridge + device is @file{br0}. + + Examples: +-- +1.7.1 + diff --git a/SOURCES/kvm-docs-qcow2-compat-1.1-is-now-the-default.patch b/SOURCES/kvm-docs-qcow2-compat-1.1-is-now-the-default.patch new file mode 100644 index 0000000..e06aeac --- /dev/null +++ b/SOURCES/kvm-docs-qcow2-compat-1.1-is-now-the-default.patch @@ -0,0 +1,81 @@ +From cac4420752da06e6d42b5b6b9f669e9f224524b3 Mon Sep 17 00:00:00 2001 +From: Stefan Hajnoczi +Date: Mon, 3 Feb 2014 10:52:55 -0500 +Subject: [PATCH 3/6] docs: qcow2 compat=1.1 is now the default + +Message-id: <1391424775-30596-1-git-send-email-stefanha@redhat.com> +Patchwork-id: 57069 +O-Subject: [PATCH RHEL7.0 qemu-kvm] docs: qcow2 compat=1.1 is now the default +Bugzilla: 1048092 +RH-Acked-by: Kevin Wolf +RH-Acked-by: Markus Armbruster +RH-Acked-by: Jeffrey Cody +RH-Acked-by: Max Reitz + +Bugzilla: 1048092 +Upstream: merged +BREW: http://brewweb.devel.redhat.com/brew/taskinfo?taskID=6990898 + +Commit 9117b47717ad208b12786ce88eacb013f9b3dd1c ("qcow2: Change default +for new images to compat=1.1") changed the default qcow2 image format +version but forgot to update qemu-doc.texi and qemu-img.texi. + +Signed-off-by: Stefan Hajnoczi +Reviewed-by: Eric Blake +Signed-off-by: Kevin Wolf +(cherry picked from commit 7fa9e1f941b4be1f71bb42de2f2ed8805d7e7326) +Signed-off-by: Stefan Hajnoczi +--- + qemu-doc.texi | 8 ++++---- + qemu-img.texi | 8 ++++---- + 2 files changed, 8 insertions(+), 8 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + qemu-doc.texi | 8 ++++---- + qemu-img.texi | 8 ++++---- + 2 files changed, 8 insertions(+), 8 deletions(-) + +diff --git a/qemu-doc.texi b/qemu-doc.texi +index 319c2f2..54ab3c5 100644 +--- a/qemu-doc.texi ++++ b/qemu-doc.texi +@@ -536,11 +536,11 @@ support of multiple VM snapshots. + Supported options: + @table @code + @item compat +-Determines the qcow2 version to use. @code{compat=0.10} uses the traditional +-image format that can be read by any QEMU since 0.10 (this is the default). ++Determines the qcow2 version to use. @code{compat=0.10} uses the ++traditional image format that can be read by any QEMU since 0.10. + @code{compat=1.1} enables image format extensions that only QEMU 1.1 and +-newer understand. Amongst others, this includes zero clusters, which allow +-efficient copy-on-read for sparse images. ++newer understand (this is the default). Amongst others, this includes ++zero clusters, which allow efficient copy-on-read for sparse images. + + @item backing_file + File name of a base image (see @option{create} subcommand) +diff --git a/qemu-img.texi b/qemu-img.texi +index a71f132..1078791 100644 +--- a/qemu-img.texi ++++ b/qemu-img.texi +@@ -387,11 +387,11 @@ support of multiple VM snapshots. + Supported options: + @table @code + @item compat +-Determines the qcow2 version to use. @code{compat=0.10} uses the traditional +-image format that can be read by any QEMU since 0.10 (this is the default). ++Determines the qcow2 version to use. @code{compat=0.10} uses the ++traditional image format that can be read by any QEMU since 0.10. + @code{compat=1.1} enables image format extensions that only QEMU 1.1 and +-newer understand. Amongst others, this includes zero clusters, which allow +-efficient copy-on-read for sparse images. ++newer understand (this is the default). Amongst others, this includes zero ++clusters, which allow efficient copy-on-read for sparse images. + + @item backing_file + File name of a base image (see @option{create} subcommand) +-- +1.8.3.1 + diff --git a/SOURCES/kvm-docs-updated-qemu-img-man-page-and-qemu-doc-to-refle.patch b/SOURCES/kvm-docs-updated-qemu-img-man-page-and-qemu-doc-to-refle.patch new file mode 100644 index 0000000..102ed67 --- /dev/null +++ b/SOURCES/kvm-docs-updated-qemu-img-man-page-and-qemu-doc-to-refle.patch @@ -0,0 +1,86 @@ +From af46a6d4f31243a842661383dc02548a1b1a3387 Mon Sep 17 00:00:00 2001 +From: Jeffrey Cody +Date: Mon, 13 Jan 2014 20:53:20 +0100 +Subject: [PATCH 13/16] docs: updated qemu-img man page and qemu-doc to reflect VHDX support. + +RH-Author: Jeffrey Cody +Message-id: <8e219e849b375a123cef62478edc843bb4439841.1389633864.git.jcody@redhat.com> +Patchwork-id: 56644 +O-Subject: [RHEL7 qemu-kvm PATCH] docs: updated qemu-img man page and qemu-doc to reflect VHDX support. +Bugzilla: 1017650 +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Kevin Wolf +RH-Acked-by: Fam Zheng + +The man page for qemu-img, and the qemu-doc, did not mention VHDX +as a supported format. This adds in reference to VHDX in those +documents. + +[Stefan Weil suggested s/Block Size/Block size/ for +consistency. I have made this change. +--Stefan] + +Signed-off-by: Jeff Cody +Reviewed-by: Stefan Weil +Signed-off-by: Stefan Hajnoczi +(cherry picked from commit 8282db1b2e7394574cb55fcc608c5cb0df159d8f) + +BZ 1017650 +Brew: http://brewweb.devel.redhat.com/brew/taskinfo?taskID=6861830 + +Signed-off-by: Jeff Cody +--- + qemu-doc.texi | 15 +++++++++++++++ + qemu-img.texi | 4 ++-- + 2 files changed, 17 insertions(+), 2 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + qemu-doc.texi | 15 +++++++++++++++ + qemu-img.texi | 4 ++-- + 2 files changed, 17 insertions(+), 2 deletions(-) + +diff --git a/qemu-doc.texi b/qemu-doc.texi +index 5fc0eae..319c2f2 100644 +--- a/qemu-doc.texi ++++ b/qemu-doc.texi +@@ -654,6 +654,21 @@ Supported options: + Specifies which VHD subformat to use. Valid options are + @code{dynamic} (default) and @code{fixed}. + @end table ++ ++@item VHDX ++Hyper-V compatible image format (VHDX). ++Supported options: ++@table @code ++@item subformat ++Specifies which VHDX subformat to use. Valid options are ++@code{dynamic} (default) and @code{fixed}. ++@item block_state_zero ++Force use of payload blocks of type 'ZERO'. ++@item block_size ++Block size; min 1 MB, max 256 MB. 0 means auto-calculate based on image size. ++@item log_size ++Log size; min 1 MB. ++@end table + @end table + + @subsubsection Read-only formats +diff --git a/qemu-img.texi b/qemu-img.texi +index da36975..a71f132 100644 +--- a/qemu-img.texi ++++ b/qemu-img.texi +@@ -427,8 +427,8 @@ This option can only be enabled if @code{compat=1.1} is specified. + + @item Other + QEMU also supports various other image file formats for compatibility with +-older QEMU versions or other hypervisors, including VMDK, VDI, VHD (vpc), qcow1 +-and QED. For a full list of supported formats see @code{qemu-img --help}. ++older QEMU versions or other hypervisors, including VMDK, VDI, VHD (vpc), VHDX, ++qcow1 and QED. For a full list of supported formats see @code{qemu-img --help}. + For a more detailed description of these formats, see the QEMU Emulation User + Documentation. + +-- +1.7.1 + diff --git a/SOURCES/kvm-ehci-implement-port-wakeup.patch b/SOURCES/kvm-ehci-implement-port-wakeup.patch new file mode 100644 index 0000000..f91a685 --- /dev/null +++ b/SOURCES/kvm-ehci-implement-port-wakeup.patch @@ -0,0 +1,103 @@ +From e29585889b3c33b370bf09c58cb4a0f4b3fae482 Mon Sep 17 00:00:00 2001 +From: Marcel Apfelbaum +Date: Wed, 18 Dec 2013 20:05:26 +0100 +Subject: [PATCH 10/16] ehci: implement port wakeup + +RH-Author: Marcel Apfelbaum +Message-id: <1387397126-27754-1-git-send-email-marcel.a@redhat.com> +Patchwork-id: 56377 +O-Subject: [RHEL-7 qemu-kvm PATCH v2] ehci: implement port wakeup +Bugzilla: 1039513 +RH-Acked-by: Michael S. Tsirkin +RH-Acked-by: Gerd Hoffmann +RH-Acked-by: Paolo Bonzini + +From: Gerd Hoffmann + +Update portsc register and raise irq in case a suspended +port is woken up, so remote wakeup works on our ehci ports. + +bugzilla: #1039513 ASSIGNED - Gerd Hoffmann - backport remote wakeup for ehci +brew: http://brewweb.devel.redhat.com/brew/taskinfo?taskID=6755209 + +Signed-off-by: Gerd Hoffmann +Signed-off-by: Marcel Apfelbaum +(cherry picked from commit e489df40caa96d895d9672d77f536f23c9e42f94) + +Conflicts: + trace-events +--- + v1->v2: + Rebased the patch. Minor conflicts. + + hw/usb/hcd-ehci.c | 18 ++++++++++++++++-- + trace-events | 3 +++ + 2 files changed, 19 insertions(+), 2 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + hw/usb/hcd-ehci.c | 18 ++++++++++++++++-- + trace-events | 3 +++ + 2 files changed, 19 insertions(+), 2 deletions(-) + +diff --git a/hw/usb/hcd-ehci.c b/hw/usb/hcd-ehci.c +index 0d3799d..02d2ab7 100644 +--- a/hw/usb/hcd-ehci.c ++++ b/hw/usb/hcd-ehci.c +@@ -826,9 +826,9 @@ static void ehci_child_detach(USBPort *port, USBDevice *child) + static void ehci_wakeup(USBPort *port) + { + EHCIState *s = port->opaque; +- uint32_t portsc = s->portsc[port->index]; ++ uint32_t *portsc = &s->portsc[port->index]; + +- if (portsc & PORTSC_POWNER) { ++ if (*portsc & PORTSC_POWNER) { + USBPort *companion = s->companion_ports[port->index]; + if (companion->ops->wakeup) { + companion->ops->wakeup(companion); +@@ -836,6 +836,12 @@ static void ehci_wakeup(USBPort *port) + return; + } + ++ if (*portsc & PORTSC_SUSPEND) { ++ trace_usb_ehci_port_wakeup(port->index); ++ *portsc |= PORTSC_FPRES; ++ ehci_raise_irq(s, USBSTS_PCD); ++ } ++ + qemu_bh_schedule(s->async_bh); + } + +@@ -1067,6 +1073,14 @@ static void ehci_port_write(void *ptr, hwaddr addr, + } + } + ++ if ((val & PORTSC_SUSPEND) && !(*portsc & PORTSC_SUSPEND)) { ++ trace_usb_ehci_port_suspend(port); ++ } ++ if (!(val & PORTSC_FPRES) && (*portsc & PORTSC_FPRES)) { ++ trace_usb_ehci_port_resume(port); ++ val &= ~PORTSC_SUSPEND; ++ } ++ + *portsc &= ~PORTSC_RO_MASK; + *portsc |= val; + trace_usb_ehci_portsc_change(addr + PORTSC_BEGIN, addr >> 2, *portsc, old); +diff --git a/trace-events b/trace-events +index e9ee94f..dbbd25d 100644 +--- a/trace-events ++++ b/trace-events +@@ -303,6 +303,9 @@ usb_ehci_sitd(uint32_t addr, uint32_t nxt, uint32_t active) "ITD @ %08x: next %0 + usb_ehci_port_attach(uint32_t port, const char *owner, const char *device) "attach port #%d, owner %s, device %s" + usb_ehci_port_detach(uint32_t port, const char *owner) "detach port #%d, owner %s" + usb_ehci_port_reset(uint32_t port, int enable) "reset port #%d - %d" ++usb_ehci_port_suspend(uint32_t port) "port #%d" ++usb_ehci_port_wakeup(uint32_t port) "port #%d" ++usb_ehci_port_resume(uint32_t port) "port #%d" + usb_ehci_queue_action(void *q, const char *action) "q %p: %s" + usb_ehci_packet_action(void *q, void *p, const char *action) "q %p p %p: %s" + usb_ehci_irq(uint32_t level, uint32_t frindex, uint32_t sts, uint32_t mask) "level %d, frindex 0x%04x, sts 0x%x, mask 0x%x" +-- +1.7.1 + diff --git a/SOURCES/kvm-enable-pvticketlocks-by-default.patch b/SOURCES/kvm-enable-pvticketlocks-by-default.patch new file mode 100644 index 0000000..2b90b9f --- /dev/null +++ b/SOURCES/kvm-enable-pvticketlocks-by-default.patch @@ -0,0 +1,95 @@ +From 5763ad32288d76433b01ce87f75cbf886f6f0e20 Mon Sep 17 00:00:00 2001 +From: Andrew Jones +Date: Tue, 14 Jan 2014 09:26:23 +0100 +Subject: [PATCH 14/16] enable pvticketlocks by default + +RH-Author: Andrew Jones +Message-id: <1389691583-3060-1-git-send-email-drjones@redhat.com> +Patchwork-id: 56650 +O-Subject: [RHEL7.0 qemu-kvm PATCH] enable pvticketlocks by default +Bugzilla: 1052340 +RH-Acked-by: Rik van Riel +RH-Acked-by: Eduardo Habkost +RH-Acked-by: Laszlo Ersek + +RHEL-only +Bugzilla: https://bugzilla.redhat.com/show_bug.cgi?id=1052340 +Brew: https://brewweb.devel.redhat.com/taskinfo?taskID=6860390 + +Let's turn pvticketlocks on by default. We need to get them more exposed +if we're ever going to make a final decision about them being on/off. +So we turn them on now, and if we'll have any issues during our +pre-release testing, then we'll just revert this patch. Since this is +something of a test patch, we leave it as RHEL only for now. We can post +an upstream patch later when we're sure it's the right way to go. + +We only enable by default on rhel7 for now, not rhel6 and earlier, +although rhel6 kernels wouldn't enable it anyway, as they don't have +pvticketlocks. Tested by me. + +Signed-off-by: Andrew Jones +--- + hw/i386/pc_piix.c | 2 ++ + target-i386/cpu.c | 6 ++++++ + target-i386/cpu.h | 1 + + 3 files changed, 9 insertions(+) + +Signed-off-by: Miroslav Rezanina +--- + hw/i386/pc_piix.c | 2 ++ + target-i386/cpu.c | 6 ++++++ + target-i386/cpu.h | 1 + + 3 files changed, 9 insertions(+), 0 deletions(-) + +diff --git a/hw/i386/pc_piix.c b/hw/i386/pc_piix.c +index 76d6e93..2961bc8 100644 +--- a/hw/i386/pc_piix.c ++++ b/hw/i386/pc_piix.c +@@ -902,6 +902,8 @@ static void pc_init_rhel650(QEMUMachineInitArgs *args) + x86_cpu_compat_set_features("Opteron_G3", FEAT_8000_0001_EDX, + 0, CPUID_EXT2_RDTSCP); + ++ disable_kvm_pv_unhalt(); ++ + rom_file_in_ram = false; + has_acpi_build = false; + pc_init_rhel700(args); +diff --git a/target-i386/cpu.c b/target-i386/cpu.c +index 42105aa..2959915 100644 +--- a/target-i386/cpu.c ++++ b/target-i386/cpu.c +@@ -253,6 +253,7 @@ static uint32_t kvm_default_features = (1 << KVM_FEATURE_CLOCKSOURCE) | + (1 << KVM_FEATURE_ASYNC_PF) | + (1 << KVM_FEATURE_STEAL_TIME) | + (1 << KVM_FEATURE_PV_EOI) | ++ (1 << KVM_FEATURE_PV_UNHALT) | + (1 << KVM_FEATURE_CLOCKSOURCE_STABLE_BIT); + + void disable_kvm_pv_eoi(void) +@@ -260,6 +261,11 @@ void disable_kvm_pv_eoi(void) + kvm_default_features &= ~(1UL << KVM_FEATURE_PV_EOI); + } + ++void disable_kvm_pv_unhalt(void) ++{ ++ kvm_default_features &= ~(1UL << KVM_FEATURE_PV_UNHALT); ++} ++ + void host_cpuid(uint32_t function, uint32_t count, + uint32_t *eax, uint32_t *ebx, uint32_t *ecx, uint32_t *edx) + { +diff --git a/target-i386/cpu.h b/target-i386/cpu.h +index 9c55953..37ff264 100644 +--- a/target-i386/cpu.h ++++ b/target-i386/cpu.h +@@ -1281,6 +1281,7 @@ void do_smm_enter(CPUX86State *env1); + void cpu_report_tpr_access(CPUX86State *env, TPRAccess access); + + void disable_kvm_pv_eoi(void); ++void disable_kvm_pv_unhalt(void); + + void x86_cpu_compat_set_features(const char *cpu_model, FeatureWord w, + uint32_t feat_add, uint32_t feat_remove); +-- +1.7.1 + diff --git a/SOURCES/kvm-error-reason-in-BLOCK_IO_ERROR-BLOCK_JOB_ERROR-event.patch b/SOURCES/kvm-error-reason-in-BLOCK_IO_ERROR-BLOCK_JOB_ERROR-event.patch new file mode 100644 index 0000000..120d3d2 --- /dev/null +++ b/SOURCES/kvm-error-reason-in-BLOCK_IO_ERROR-BLOCK_JOB_ERROR-event.patch @@ -0,0 +1,215 @@ +From 771a3a333eb0c9299a69a78ddb9c4181850b827d Mon Sep 17 00:00:00 2001 +From: Laszlo Ersek +Date: Thu, 21 Nov 2013 16:27:18 +0100 +Subject: [PATCH 08/14] error reason in BLOCK_IO_ERROR / BLOCK_JOB_ERROR events (RHEL 6->7 fwd) + +RH-Author: Laszlo Ersek +Message-id: <1385051239-3677-3-git-send-email-lersek@redhat.com> +Patchwork-id: 55835 +O-Subject: [RHEL-7.0 qemu-kvm PATCH 2/3] error reason in BLOCK_IO_ERROR / BLOCK_JOB_ERROR events (RHEL 6->7 fwd) +Bugzilla: 971938 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Jiri Denemark +RH-Acked-by: Luiz Capitulino + +Bugzilla: https://bugzilla.redhat.com/show_bug.cgi?id=971938 + +This is the RHEL-7 forward port of the RHEL-6 only commit + + commit a635efd74e0968dd4402ba87679af3015930a8cb + Author: Luiz Capitulino + Date: Fri May 14 22:49:20 2010 -0300 + + QMP: Add error reason to BLOCK_IO_ERROR event + +The RHEL-6 patch had to be updated due to the following three upstream +commits that we have in RHEL-7 by virtue of forking: + + [v1.1.0] + commit 329c0a48a92664eb48b70993c0f2473b37aa7429 + Author: Luiz Capitulino + Date: Wed Jan 25 16:59:43 2012 -0200 + + block: Rename bdrv_mon_event() & BlockMonEventAction + + [v1.3.0] + commit 3e1caa5f76a9104a0d574b0f28b3dafe986a8408 + Author: Paolo Bonzini + Date: Fri Sep 28 17:22:57 2012 +0200 + + iostatus: reorganize io error code + + [v1.3.0] + commit 32c81a4a6ecc3f50efc9c270a269e4d3d8a9fbd5 + Author: Paolo Bonzini + Date: Fri Sep 28 17:22:58 2012 +0200 + + block: introduce block job error + +The 2nd and 3rd of these actually simplified the RHEL-6 to RHEL-7 +forward-port because it had concentrated all calls to +bdrv_emit_qmp_error_event() to two locations, taking the error code as an +input parameter. The forward-ported patch can simply forward the error +code now. + +RHEL-6 doesn't have BLOCK_JOB_ERROR at all. This forward-port extends the +RH-specific error reason reporting to BLOCK_JOB_ERROR automatically. +(Except for "QMP/qmp-events.txt", where BLOCK_JOB_ERROR's documentation +needed manual patching.) + +Signed-off-by: Laszlo Ersek +--- + include/block/block_int.h | 4 +++- + block.c | 33 +++++++++++++++++++++++++++++++-- + blockjob.c | 3 ++- + QMP/qmp-events.txt | 18 ++++++++++++++++-- + 4 files changed, 52 insertions(+), 6 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + QMP/qmp-events.txt | 18 ++++++++++++++++-- + block.c | 33 +++++++++++++++++++++++++++++++-- + blockjob.c | 3 ++- + include/block/block_int.h | 4 +++- + 4 files changed, 52 insertions(+), 6 deletions(-) + +diff --git a/QMP/qmp-events.txt b/QMP/qmp-events.txt +index 79fb1c9..c8c6d75 100644 +--- a/QMP/qmp-events.txt ++++ b/QMP/qmp-events.txt +@@ -53,13 +53,20 @@ Data: + "ignore": error has been ignored + "report": error has been reported to the device + "stop": error caused VM to be stopped ++- "__com.redhat_reason": error reason, this is a RHEL7 extension, it's one of ++ the following (json-string): ++ "eio": errno EIO ++ "eperm": errno EPERM ++ "enospc": errno ENOSPC ++ "eother": any other errno (other than EIO, EPERM, ENOSPC) + + Example: + + { "event": "BLOCK_IO_ERROR", + "data": { "device": "ide0-hd1", + "operation": "write", +- "action": "stop" }, ++ "action": "stop", ++ "__com.redhat_reason": "enospc" }, + "timestamp": { "seconds": 1265044230, "microseconds": 450486 } } + + Note: If action is "stop", a STOP event will eventually follow the +@@ -131,13 +138,20 @@ Data: + "ignore": error has been ignored, the job may fail later + "report": error will be reported and the job canceled + "stop": error caused job to be paused ++- "__com.redhat_reason": error reason, this is a RHEL7 extension, it's one of ++ the following (json-string): ++ "eio": errno EIO ++ "eperm": errno EPERM ++ "enospc": errno ENOSPC ++ "eother": any other errno (other than EIO, EPERM, ENOSPC) + + Example: + + { "event": "BLOCK_JOB_ERROR", + "data": { "device": "ide0-hd1", + "operation": "write", +- "action": "stop" }, ++ "action": "stop", ++ "__com.redhat_reason": "enospc" }, + "timestamp": { "seconds": 1265044230, "microseconds": 450486 } } + + BLOCK_JOB_READY +diff --git a/block.c b/block.c +index 72ab36c..68755bf 100644 +--- a/block.c ++++ b/block.c +@@ -1723,9 +1723,36 @@ void bdrv_set_dev_ops(BlockDriverState *bs, const BlockDevOps *ops, + bs->dev_opaque = opaque; + } + ++#define BDRV_REASON_KEY RFQDN_REDHAT "reason" ++ ++/* RHEL7 vendor extension */ ++static void bdrv_put_rhel7_reason(QDict *event, int error) ++{ ++ const char *reason; ++ ++ switch (error) { ++ case ENOSPC: ++ reason = "enospc"; ++ break; ++ case EPERM: ++ reason = "eperm"; ++ break; ++ case EIO: ++ reason = "eio"; ++ break; ++ default: ++ reason = "eother"; ++ break; ++ } ++ ++ qdict_put(event, BDRV_REASON_KEY, qstring_from_str(reason)); ++} ++ + void bdrv_emit_qmp_error_event(const BlockDriverState *bdrv, + enum MonitorEvent ev, +- BlockErrorAction action, bool is_read) ++ BlockErrorAction action, ++ int error, ++ bool is_read) + { + QObject *data; + const char *action_str; +@@ -1748,6 +1775,7 @@ void bdrv_emit_qmp_error_event(const BlockDriverState *bdrv, + bdrv->device_name, + action_str, + is_read ? "read" : "write"); ++ bdrv_put_rhel7_reason(qobject_to_qdict(data), error); + monitor_protocol_event(ev, data); + + qobject_decref(data); +@@ -2905,7 +2933,8 @@ void bdrv_error_action(BlockDriverState *bs, BlockErrorAction action, + bool is_read, int error) + { + assert(error >= 0); +- bdrv_emit_qmp_error_event(bs, QEVENT_BLOCK_IO_ERROR, action, is_read); ++ bdrv_emit_qmp_error_event(bs, QEVENT_BLOCK_IO_ERROR, action, error, ++ is_read); + if (action == BDRV_ACTION_STOP) { + vm_stop(RUN_STATE_IO_ERROR); + bdrv_iostatus_set_err(bs, error); +diff --git a/blockjob.c b/blockjob.c +index ca80df1..c0a22d9 100644 +--- a/blockjob.c ++++ b/blockjob.c +@@ -271,7 +271,8 @@ BlockErrorAction block_job_error_action(BlockJob *job, BlockDriverState *bs, + default: + abort(); + } +- bdrv_emit_qmp_error_event(job->bs, QEVENT_BLOCK_JOB_ERROR, action, is_read); ++ bdrv_emit_qmp_error_event(job->bs, QEVENT_BLOCK_JOB_ERROR, action, error, ++ is_read); + if (action == BDRV_ACTION_STOP) { + block_job_pause(job); + block_job_iostatus_set_err(job, error); +diff --git a/include/block/block_int.h b/include/block/block_int.h +index 54708c6..8223f5b 100644 +--- a/include/block/block_int.h ++++ b/include/block/block_int.h +@@ -320,7 +320,9 @@ int is_windows_drive(const char *filename); + #endif + void bdrv_emit_qmp_error_event(const BlockDriverState *bdrv, + enum MonitorEvent ev, +- BlockErrorAction action, bool is_read); ++ BlockErrorAction action, ++ int error, ++ bool is_read); + + /** + * stream_start: +-- +1.7.1 + diff --git a/SOURCES/kvm-exec-Fix-prototype-of-phys_mem_set_alloc-and-related.patch b/SOURCES/kvm-exec-Fix-prototype-of-phys_mem_set_alloc-and-related.patch new file mode 100644 index 0000000..f6ca8e0 --- /dev/null +++ b/SOURCES/kvm-exec-Fix-prototype-of-phys_mem_set_alloc-and-related.patch @@ -0,0 +1,122 @@ +From 394423ac51f2b4f551bece834aa9c8586dc0a984 Mon Sep 17 00:00:00 2001 +Message-Id: <394423ac51f2b4f551bece834aa9c8586dc0a984.1387298827.git.minovotn@redhat.com> +In-Reply-To: <3ed0fb61a3dc912ef036d7ef450bed192090709e.1387298827.git.minovotn@redhat.com> +References: <3ed0fb61a3dc912ef036d7ef450bed192090709e.1387298827.git.minovotn@redhat.com> +From: "Michael S. Tsirkin" +Date: Tue, 17 Dec 2013 15:19:29 +0100 +Subject: [PATCH 56/56] exec: Fix prototype of phys_mem_set_alloc and related + functions + +RH-Author: Michael S. Tsirkin +Message-id: <1387293161-4085-57-git-send-email-mst@redhat.com> +Patchwork-id: 56362 +O-Subject: [PATCH qemu-kvm RHEL7.0 v2 56/57] exec: Fix prototype of phys_mem_set_alloc and related functions +Bugzilla: 1034876 +RH-Acked-by: Igor Mammedov +RH-Acked-by: Marcel Apfelbaum +RH-Acked-by: Laszlo Ersek +RH-Acked-by: Orit Wasserman + +From: Stefan Weil + +phys_mem_alloc and its assigned values qemu_anon_ram_alloc and +legacy_s390_alloc must have identical argument lists. + +legacy_s390_alloc uses the size parameter to call mmap, so size_t is +good enough for all of them. + +This patch fixes compiler errors on i686 Linux hosts: + + CC alpha-softmmu/exec.o +exec.c:752:51: error: + initialization from incompatible pointer type [-Werror] +exec.c: In function 'qemu_ram_alloc_from_ptr': +exec.c:1139:32: error: + comparison of distinct pointer types lacks a cast [-Werror] +exec.c: In function 'qemu_ram_remap': +exec.c:1283:21: error: + comparison of distinct pointer types lacks a cast [-Werror] + +Signed-off-by: Stefan Weil +Reviewed-by: Markus Armbruster +Message-id: 1380481005-32399-1-git-send-email-sw@weilnetz.de +Signed-off-by: Anthony Liguori +(cherry picked from commit 575ddeb459f622a114cbfe37d220c0519ec9c2a4) + +Note: not directly related to this change, and we don't have +to support building on i686. +However this is gratitious and ugly difference from upstream, +and some machines I use to test ACPI are i686, so including +this here was required for testing. +--- + include/exec/exec-all.h | 2 +- + exec.c | 4 ++-- + target-s390x/kvm.c | 4 ++-- + 3 files changed, 5 insertions(+), 5 deletions(-) + +Signed-off-by: Michal Novotny +--- + exec.c | 4 ++-- + include/exec/exec-all.h | 2 +- + target-s390x/kvm.c | 4 ++-- + 3 files changed, 5 insertions(+), 5 deletions(-) + +diff --git a/exec.c b/exec.c +index 9117a59..cb11571 100644 +--- a/exec.c ++++ b/exec.c +@@ -680,14 +680,14 @@ static int subpage_register (subpage_t *mmio, uint32_t start, uint32_t end, + uint16_t section); + static subpage_t *subpage_init(hwaddr base); + +-static void *(*phys_mem_alloc)(ram_addr_t size) = qemu_anon_ram_alloc; ++static void *(*phys_mem_alloc)(size_t size) = qemu_anon_ram_alloc; + + /* + * Set a custom physical guest memory alloator. + * Accelerators with unusual needs may need this. Hopefully, we can + * get rid of it eventually. + */ +-void phys_mem_set_alloc(void *(*alloc)(ram_addr_t)) ++void phys_mem_set_alloc(void *(*alloc)(size_t)) + { + phys_mem_alloc = alloc; + } +diff --git a/include/exec/exec-all.h b/include/exec/exec-all.h +index 993c655..3fddc3b 100644 +--- a/include/exec/exec-all.h ++++ b/include/exec/exec-all.h +@@ -366,7 +366,7 @@ bool is_tcg_gen_code(uintptr_t pc_ptr); + + #if !defined(CONFIG_USER_ONLY) + +-void phys_mem_set_alloc(void *(*alloc)(ram_addr_t)); ++void phys_mem_set_alloc(void *(*alloc)(size_t)); + + struct MemoryRegion *iotlb_to_region(hwaddr index); + uint64_t io_mem_read(struct MemoryRegion *mr, hwaddr addr, +diff --git a/target-s390x/kvm.c b/target-s390x/kvm.c +index a106e62..3fd8be5 100644 +--- a/target-s390x/kvm.c ++++ b/target-s390x/kvm.c +@@ -92,7 +92,7 @@ const KVMCapabilityInfo kvm_arch_required_capabilities[] = { + + static int cap_sync_regs; + +-static void *legacy_s390_alloc(ram_addr_t size); ++static void *legacy_s390_alloc(size_t size); + + int kvm_arch_init(KVMState *s) + { +@@ -324,7 +324,7 @@ int kvm_s390_get_registers_partial(CPUState *cs) + * to grow. We also have to use MAP parameters that avoid + * read-only mapping of guest pages. + */ +-static void *legacy_s390_alloc(ram_addr_t size) ++static void *legacy_s390_alloc(size_t size) + { + void *mem; + +-- +1.7.11.7 + diff --git a/SOURCES/kvm-exec-Remove-unused-global-variable-phys_ram_fd.patch b/SOURCES/kvm-exec-Remove-unused-global-variable-phys_ram_fd.patch new file mode 100644 index 0000000..80125ef --- /dev/null +++ b/SOURCES/kvm-exec-Remove-unused-global-variable-phys_ram_fd.patch @@ -0,0 +1,66 @@ +From a3180e79422e20d704e8a65643bbfac002142cf8 Mon Sep 17 00:00:00 2001 +From: Juan Quintela +Date: Tue, 14 Jan 2014 15:07:41 +0100 +Subject: [PATCH 30/40] exec: Remove unused global variable phys_ram_fd +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +RH-Author: Juan Quintela +Message-id: <1389712071-23303-31-git-send-email-quintela@redhat.com> +Patchwork-id: 56686 +O-Subject: [RHEL7 qemu-kvm PATCH 30/40] exec: Remove unused global variable phys_ram_fd +Bugzilla: 997559 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Orit Wasserman +RH-Acked-by: Dr. David Alan Gilbert (git) + +From: Stefan Weil + +It seems to be unused since several years (commit +be995c27640a82c7056b6f53d02ec823570114e5 in 2006). + +Signed-off-by: Stefan Weil +Reviewed-by: Andreas Färber +Message-id: 1373044036-14443-1-git-send-email-sw@weilnetz.de +Signed-off-by: Anthony Liguori +(cherry picked from commit 154bb106dc195b4fbb76df0452ab6e3e24e80d72) +Signed-off-by: Juan Quintela +--- + exec.c | 1 - + include/exec/cpu-all.h | 1 - + 2 files changed, 2 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + exec.c | 1 - + include/exec/cpu-all.h | 1 - + 2 files changed, 0 insertions(+), 2 deletions(-) + +diff --git a/exec.c b/exec.c +index 79ea3b2..443de79 100644 +--- a/exec.c ++++ b/exec.c +@@ -55,7 +55,6 @@ + //#define DEBUG_SUBPAGE + + #if !defined(CONFIG_USER_ONLY) +-int phys_ram_fd; + static int in_migration; + + RAMList ram_list = { .blocks = QTAILQ_HEAD_INITIALIZER(ram_list.blocks) }; +diff --git a/include/exec/cpu-all.h b/include/exec/cpu-all.h +index 9c85c1c..b88e56e 100644 +--- a/include/exec/cpu-all.h ++++ b/include/exec/cpu-all.h +@@ -460,7 +460,6 @@ hwaddr cpu_get_phys_page_debug(CPUArchState *env, target_ulong addr); + + /* memory API */ + +-extern int phys_ram_fd; + extern ram_addr_t ram_size; + + /* RAM is pre-allocated and passed into qemu_ram_alloc_from_ptr */ +-- +1.7.1 + diff --git a/SOURCES/kvm-exec-always-use-MADV_DONTFORK.patch b/SOURCES/kvm-exec-always-use-MADV_DONTFORK.patch new file mode 100644 index 0000000..8e69da4 --- /dev/null +++ b/SOURCES/kvm-exec-always-use-MADV_DONTFORK.patch @@ -0,0 +1,58 @@ +From 38dcbd1ff68da81b9172d8036622e41fe591c5c0 Mon Sep 17 00:00:00 2001 +From: Andrea Arcangeli +Date: Fri, 7 Feb 2014 11:02:33 +0100 +Subject: [PATCH 10/28] exec: always use MADV_DONTFORK + +RH-Author: Andrea Arcangeli +Message-id: <1391770953-20138-2-git-send-email-aarcange@redhat.com> +Patchwork-id: 57131 +O-Subject: [RHEL-7.0 qemu-kvm PATCH] exec: always use MADV_DONTFORK +Bugzilla: 1004197 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Andrew Jones +RH-Acked-by: Dr. David Alan Gilbert (git) + +MADV_DONTFORK prevents fork to fail with -ENOMEM if the default +overcommit heuristics decides there's too much anonymous virtual +memory allocated. If the KVM secondary MMU is synchronized with MMU +notifiers or not, doesn't make a difference in that regard. + +Secondly it's always more efficient to avoid copying the guest +physical address space in the fork child (so we avoid to mark all the +guest memory readonly in the parent and so we skip the establishment +and teardown of lots of pagetables in the child). + +In the common case we can ignore the error if MADV_DONTFORK is not +available. Leave a second invocation that errors out in the KVM path +if MMU notifiers are missing and KVM is enabled, to abort in such +case. + +Signed-off-by: Andrea Arcangeli +Tested-By: Benoit Canet +Acked-by: Paolo Bonzini +Signed-off-by: Gleb Natapov +(cherry picked from upstream commit 3e469dbfe413c25d48321c3a19ddfae0727dc6e5) +--- + exec.c | 1 + + 1 file changed, 1 insertion(+) + +Signed-off-by: Miroslav Rezanina +--- + exec.c | 1 + + 1 files changed, 1 insertions(+), 0 deletions(-) + +diff --git a/exec.c b/exec.c +index ce9310c..6fe2fe7 100644 +--- a/exec.c ++++ b/exec.c +@@ -1194,6 +1194,7 @@ ram_addr_t qemu_ram_alloc_from_ptr(ram_addr_t size, void *host, + + qemu_ram_setup_dump(new_block->host, size); + qemu_madvise(new_block->host, size, QEMU_MADV_HUGEPAGE); ++ qemu_madvise(new_block->host, size, QEMU_MADV_DONTFORK); + + if (kvm_enabled()) + kvm_setup_guest_memory(new_block->host, size); +-- +1.7.1 + diff --git a/SOURCES/kvm-exec-change-well-known-physical-sections-to-macros.patch b/SOURCES/kvm-exec-change-well-known-physical-sections-to-macros.patch new file mode 100644 index 0000000..20a2666 --- /dev/null +++ b/SOURCES/kvm-exec-change-well-known-physical-sections-to-macros.patch @@ -0,0 +1,167 @@ +From 348710ce46ee2ddf02396aad4bd3978c6dfc2a07 Mon Sep 17 00:00:00 2001 +From: Marcel Apfelbaum +Date: Sun, 19 Jan 2014 13:07:35 +0100 +Subject: [PATCH 10/11] exec: change well-known physical sections to macros + +RH-Author: Marcel Apfelbaum +Message-id: <1390136856-7024-2-git-send-email-marcel.a@redhat.com> +Patchwork-id: 56810 +O-Subject: [RHEL-7 qemu-kvm PATCH v2 1/2] exec: change well-known physical sections to macros +Bugzilla: 1003535 +RH-Acked-by: Michael S. Tsirkin +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Markus Armbruster + +From: Liu Ping Fan + +Sections like phys_section_unassigned always have fixed address +in phys_sections. Declared as macro, so we can use them +when having more than one phys_sections array. + +Signed-off-by: Liu Ping Fan +Signed-off-by: Liu Ping Fan +Signed-off-by: Paolo Bonzini +(cherry picked from commit b41aac4f0d17000babd815e088699d58e59917b8) +Signed-off-by: Marcel Apfelbaum + +Conflicts: + exec.c + +Signed-off-by: Marcel Apfelbaum +--- + exec.c | 42 ++++++++++++++++++++++++------------------ + 1 file changed, 24 insertions(+), 18 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + exec.c | 42 ++++++++++++++++++++++++------------------ + 1 files changed, 24 insertions(+), 18 deletions(-) + +diff --git a/exec.c b/exec.c +index b16ef4a..01c74cd 100644 +--- a/exec.c ++++ b/exec.c +@@ -101,10 +101,10 @@ struct AddressSpaceDispatch { + + static MemoryRegionSection *phys_sections; + static unsigned phys_sections_nb, phys_sections_nb_alloc; +-static uint16_t phys_section_unassigned; +-static uint16_t phys_section_notdirty; +-static uint16_t phys_section_rom; +-static uint16_t phys_section_watch; ++#define PHYS_SECTION_UNASSIGNED 0 ++#define PHYS_SECTION_NOTDIRTY 1 ++#define PHYS_SECTION_ROM 2 ++#define PHYS_SECTION_WATCH 3 + + /* Simple allocator for PhysPageEntry nodes */ + static PhysPageEntry (*phys_map_nodes)[L2_SIZE]; +@@ -168,7 +168,7 @@ static void phys_page_set_level(PhysPageEntry *lp, hwaddr *index, + if (level == 0) { + for (i = 0; i < L2_SIZE; i++) { + p[i].is_leaf = 1; +- p[i].ptr = phys_section_unassigned; ++ p[i].ptr = PHYS_SECTION_UNASSIGNED; + } + } + } else { +@@ -204,7 +204,7 @@ MemoryRegionSection *phys_page_find(AddressSpaceDispatch *d, hwaddr index) + PhysPageEntry lp = d->phys_map; + PhysPageEntry *p; + int i; +- uint16_t s_index = phys_section_unassigned; ++ uint16_t s_index = PHYS_SECTION_UNASSIGNED; + + for (i = P_L2_LEVELS - 1; i >= 0 && !lp.is_leaf; i--) { + if (lp.ptr == PHYS_MAP_NODE_NIL) { +@@ -646,9 +646,9 @@ hwaddr memory_region_section_get_iotlb(CPUArchState *env, + iotlb = (memory_region_get_ram_addr(section->mr) & TARGET_PAGE_MASK) + + memory_region_section_addr(section, paddr); + if (!section->readonly) { +- iotlb |= phys_section_notdirty; ++ iotlb |= PHYS_SECTION_NOTDIRTY; + } else { +- iotlb |= phys_section_rom; ++ iotlb |= PHYS_SECTION_ROM; + } + } else { + /* IO handlers are currently passed a physical address. +@@ -667,7 +667,7 @@ hwaddr memory_region_section_get_iotlb(CPUArchState *env, + if (vaddr == (wp->vaddr & TARGET_PAGE_MASK)) { + /* Avoid trapping reads of pages with a write breakpoint. */ + if ((prot & PAGE_WRITE) || (wp->flags & BP_MEM_READ)) { +- iotlb = phys_section_watch + paddr; ++ iotlb = PHYS_SECTION_WATCH + paddr; + *address |= TLB_MMIO; + break; + } +@@ -1722,7 +1722,7 @@ static subpage_t *subpage_init(hwaddr base) + printf("%s: %p base " TARGET_FMT_plx " len %08x %d\n", __func__, + mmio, base, TARGET_PAGE_SIZE, subpage_memory); + #endif +- subpage_register(mmio, 0, TARGET_PAGE_SIZE-1, phys_section_unassigned); ++ subpage_register(mmio, 0, TARGET_PAGE_SIZE-1, PHYS_SECTION_UNASSIGNED); + + return mmio; + } +@@ -1768,11 +1768,17 @@ static void mem_begin(MemoryListener *listener) + + static void core_begin(MemoryListener *listener) + { ++ uint16_t n; ++ + phys_sections_clear(); +- phys_section_unassigned = dummy_section(&io_mem_unassigned); +- phys_section_notdirty = dummy_section(&io_mem_notdirty); +- phys_section_rom = dummy_section(&io_mem_rom); +- phys_section_watch = dummy_section(&io_mem_watch); ++ n = dummy_section(&io_mem_unassigned); ++ assert(n == PHYS_SECTION_UNASSIGNED); ++ n = dummy_section(&io_mem_notdirty); ++ assert(n == PHYS_SECTION_NOTDIRTY); ++ n = dummy_section(&io_mem_rom); ++ assert(n == PHYS_SECTION_ROM); ++ n = dummy_section(&io_mem_watch); ++ assert(n == PHYS_SECTION_WATCH); + } + + static void tcg_commit(MemoryListener *listener) +@@ -2440,7 +2446,7 @@ void stl_phys_notdirty(hwaddr addr, uint32_t val) + if (!memory_region_is_ram(section->mr) || section->readonly) { + addr = memory_region_section_addr(section, addr); + if (memory_region_is_ram(section->mr)) { +- section = &phys_sections[phys_section_rom]; ++ section = &phys_sections[PHYS_SECTION_ROM]; + } + io_mem_write(section->mr, addr, val, 4); + } else { +@@ -2473,7 +2479,7 @@ void stq_phys_notdirty(hwaddr addr, uint64_t val) + if (!memory_region_is_ram(section->mr) || section->readonly) { + addr = memory_region_section_addr(section, addr); + if (memory_region_is_ram(section->mr)) { +- section = &phys_sections[phys_section_rom]; ++ section = &phys_sections[PHYS_SECTION_ROM]; + } + #ifdef TARGET_WORDS_BIGENDIAN + io_mem_write(section->mr, addr, val >> 32, 4); +@@ -2502,7 +2508,7 @@ static inline void stl_phys_internal(hwaddr addr, uint32_t val, + if (!memory_region_is_ram(section->mr) || section->readonly) { + addr = memory_region_section_addr(section, addr); + if (memory_region_is_ram(section->mr)) { +- section = &phys_sections[phys_section_rom]; ++ section = &phys_sections[PHYS_SECTION_ROM]; + } + #if defined(TARGET_WORDS_BIGENDIAN) + if (endian == DEVICE_LITTLE_ENDIAN) { +@@ -2569,7 +2575,7 @@ static inline void stw_phys_internal(hwaddr addr, uint32_t val, + if (!memory_region_is_ram(section->mr) || section->readonly) { + addr = memory_region_section_addr(section, addr); + if (memory_region_is_ram(section->mr)) { +- section = &phys_sections[phys_section_rom]; ++ section = &phys_sections[PHYS_SECTION_ROM]; + } + #if defined(TARGET_WORDS_BIGENDIAN) + if (endian == DEVICE_LITTLE_ENDIAN) { +-- +1.7.1 + diff --git a/SOURCES/kvm-exec-create-function-to-get-a-single-dirty-bit.patch b/SOURCES/kvm-exec-create-function-to-get-a-single-dirty-bit.patch new file mode 100644 index 0000000..b8d8a4a --- /dev/null +++ b/SOURCES/kvm-exec-create-function-to-get-a-single-dirty-bit.patch @@ -0,0 +1,63 @@ +From c3347218d224591fe59debbf2006811b418f9070 Mon Sep 17 00:00:00 2001 +From: Juan Quintela +Date: Tue, 14 Jan 2014 15:07:18 +0100 +Subject: [PATCH 07/40] exec: create function to get a single dirty bit + +RH-Author: Juan Quintela +Message-id: <1389712071-23303-8-git-send-email-quintela@redhat.com> +Patchwork-id: 56663 +O-Subject: [RHEL7 qemu-kvm PATCH 07/40] exec: create function to get a single dirty bit +Bugzilla: 997559 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Orit Wasserman +RH-Acked-by: Dr. David Alan Gilbert (git) + +Signed-off-by: Juan Quintela +Reviewed-by: Eric Blake +Reviewed-by: Orit Wasserman +(cherry picked from commit 7e5609a85e3f35965af5e4c7b1480254642cf2dd) +Signed-off-by: Juan Quintela +--- + exec.c | 2 +- + include/exec/memory-internal.h | 6 ++++++ + 2 files changed, 7 insertions(+), 1 deletion(-) + +Signed-off-by: Miroslav Rezanina +--- + exec.c | 2 +- + include/exec/memory-internal.h | 6 ++++++ + 2 files changed, 7 insertions(+), 1 deletions(-) + +diff --git a/exec.c b/exec.c +index 436dbe9..e993049 100644 +--- a/exec.c ++++ b/exec.c +@@ -1482,7 +1482,7 @@ static void notdirty_mem_write(void *opaque, hwaddr ram_addr, + { + int dirty_flags; + dirty_flags = cpu_physical_memory_get_dirty_flags(ram_addr); +- if (!(dirty_flags & CODE_DIRTY_FLAG)) { ++ if (!cpu_physical_memory_get_dirty_flag(ram_addr, CODE_DIRTY_FLAG)) { + tb_invalidate_phys_page_fast(ram_addr, size); + dirty_flags = cpu_physical_memory_get_dirty_flags(ram_addr); + } +diff --git a/include/exec/memory-internal.h b/include/exec/memory-internal.h +index 4f476d2..8872e36 100644 +--- a/include/exec/memory-internal.h ++++ b/include/exec/memory-internal.h +@@ -58,6 +58,12 @@ static inline int cpu_physical_memory_get_dirty_flags(ram_addr_t addr) + return ram_list.phys_dirty[addr >> TARGET_PAGE_BITS]; + } + ++static inline bool cpu_physical_memory_get_dirty_flag(ram_addr_t addr, ++ int dirty_flag) ++{ ++ return ram_list.phys_dirty[addr >> TARGET_PAGE_BITS] & dirty_flag; ++} ++ + /* read dirty bit (return 0 or 1) */ + static inline int cpu_physical_memory_is_dirty(ram_addr_t addr) + { +-- +1.7.1 + diff --git a/SOURCES/kvm-exec-drop-useless-if.patch b/SOURCES/kvm-exec-drop-useless-if.patch new file mode 100644 index 0000000..6003aee --- /dev/null +++ b/SOURCES/kvm-exec-drop-useless-if.patch @@ -0,0 +1,49 @@ +From 746535f5d5ced7f1df4f1cb483621939ac8076e8 Mon Sep 17 00:00:00 2001 +From: Juan Quintela +Date: Tue, 14 Jan 2014 15:07:17 +0100 +Subject: [PATCH 06/40] exec: drop useless #if + +RH-Author: Juan Quintela +Message-id: <1389712071-23303-7-git-send-email-quintela@redhat.com> +Patchwork-id: 56658 +O-Subject: [RHEL7 qemu-kvm PATCH 06/40] exec: drop useless #if +Bugzilla: 997559 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Orit Wasserman +RH-Acked-by: Dr. David Alan Gilbert (git) + +From: Paolo Bonzini + +This code is only compiled for softmmu targets. + +Reviewed-by: Richard Henderson +Signed-off-by: Paolo Bonzini +(cherry picked from commit ae4e43e80f3e1e65d096ebbc643eed9d763e1441) +Signed-off-by: Juan Quintela +--- + exec.c | 2 -- + 1 file changed, 2 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + exec.c | 2 -- + 1 files changed, 0 insertions(+), 2 deletions(-) + +diff --git a/exec.c b/exec.c +index 389888d..436dbe9 100644 +--- a/exec.c ++++ b/exec.c +@@ -1483,10 +1483,8 @@ static void notdirty_mem_write(void *opaque, hwaddr ram_addr, + int dirty_flags; + dirty_flags = cpu_physical_memory_get_dirty_flags(ram_addr); + if (!(dirty_flags & CODE_DIRTY_FLAG)) { +-#if !defined(CONFIG_USER_ONLY) + tb_invalidate_phys_page_fast(ram_addr, size); + dirty_flags = cpu_physical_memory_get_dirty_flags(ram_addr); +-#endif + } + switch (size) { + case 1: +-- +1.7.1 + diff --git a/SOURCES/kvm-exec-separate-sections-and-nodes-per-address-space.patch b/SOURCES/kvm-exec-separate-sections-and-nodes-per-address-space.patch new file mode 100644 index 0000000..9d64440 --- /dev/null +++ b/SOURCES/kvm-exec-separate-sections-and-nodes-per-address-space.patch @@ -0,0 +1,507 @@ +From a2c4efbb5b968a80eb552757308c2fb2f28157c6 Mon Sep 17 00:00:00 2001 +From: Marcel Apfelbaum +Date: Sun, 19 Jan 2014 13:07:36 +0100 +Subject: [PATCH 11/11] exec: separate sections and nodes per address space + +RH-Author: Marcel Apfelbaum +Message-id: <1390136856-7024-3-git-send-email-marcel.a@redhat.com> +Patchwork-id: 56811 +O-Subject: [RHEL-7 qemu-kvm PATCH v2 2/2] exec: separate sections and nodes per address space +Bugzilla: 1003535 +RH-Acked-by: Michael S. Tsirkin +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Markus Armbruster + +Every address space has its own nodes and sections, but +it uses the same global arrays of nodes/section. + +This limits the number of devices that can be attached +to the guest to 20-30 devices. It happens because: + - The sections array is limited to 2^12 entries. + - The main memory has at least 100 sections. + - Each device address space is actually an alias to + main memory, multiplying its number of nodes/sections. + +Remove the limitation by using separate arrays of +nodes and sections for each address space. + +Closest upstream commit: 53cb28cbfea038f8ad50132dc8a684e638c7d48b +Signed-off-by: Marcel Apfelbaum +--- +v1 -> v2: + - The series confilcted with Juan's series: + - [RHEL7 qemu-kvm PATCH 00/40] bitmap optmization + - Conflicts solved: + - AddressSpaceDispatch was moved to exec.c + - PhysPageEntry was moved to exec.c + - Moved also PhysPageMap to exec.c + + exec.c | 166 ++++++++++++++++++++++++++++++++++------------------------------- + 1 file changed, 86 insertions(+), 80 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + exec.c | 166 +++++++++++++++++++++++++++++++++------------------------------- + 1 files changed, 86 insertions(+), 80 deletions(-) + +diff --git a/exec.c b/exec.c +index 01c74cd..ce9310c 100644 +--- a/exec.c ++++ b/exec.c +@@ -91,25 +91,32 @@ struct PhysPageEntry { + uint16_t ptr : 15; + }; + ++typedef PhysPageEntry Node[L2_SIZE]; ++ ++typedef struct PhysPageMap { ++ unsigned sections_nb; ++ unsigned sections_nb_alloc; ++ unsigned nodes_nb; ++ unsigned nodes_nb_alloc; ++ Node *nodes; ++ MemoryRegionSection *sections; ++} PhysPageMap; ++ + struct AddressSpaceDispatch { + /* This is a multi-level map on the physical address space. + * The bottom level has pointers to MemoryRegionSections. + */ + PhysPageEntry phys_map; ++ PhysPageMap map; + MemoryListener listener; ++ AddressSpace *as; + }; + +-static MemoryRegionSection *phys_sections; +-static unsigned phys_sections_nb, phys_sections_nb_alloc; + #define PHYS_SECTION_UNASSIGNED 0 + #define PHYS_SECTION_NOTDIRTY 1 + #define PHYS_SECTION_ROM 2 + #define PHYS_SECTION_WATCH 3 + +-/* Simple allocator for PhysPageEntry nodes */ +-static PhysPageEntry (*phys_map_nodes)[L2_SIZE]; +-static unsigned phys_map_nodes_nb, phys_map_nodes_nb_alloc; +- + #define PHYS_MAP_NODE_NIL (((uint16_t)~0) >> 1) + + static void io_mem_init(void); +@@ -121,41 +128,38 @@ static MemoryRegion io_mem_watch; + + #if !defined(CONFIG_USER_ONLY) + +-static void phys_map_node_reserve(unsigned nodes) ++static void phys_map_node_reserve(PhysPageMap *map, unsigned nodes) + { +- if (phys_map_nodes_nb + nodes > phys_map_nodes_nb_alloc) { +- typedef PhysPageEntry Node[L2_SIZE]; +- phys_map_nodes_nb_alloc = MAX(phys_map_nodes_nb_alloc * 2, 16); +- phys_map_nodes_nb_alloc = MAX(phys_map_nodes_nb_alloc, +- phys_map_nodes_nb + nodes); +- phys_map_nodes = g_renew(Node, phys_map_nodes, +- phys_map_nodes_nb_alloc); ++ if (map->nodes_nb + nodes > map->nodes_nb_alloc) { ++ map->nodes_nb_alloc = MAX(map->nodes_nb_alloc * 2, 16); ++ map->nodes_nb_alloc = MAX(map->nodes_nb_alloc, map->nodes_nb + nodes); ++ map->nodes = g_renew(Node, map->nodes, map->nodes_nb_alloc); + } + } + +-static uint16_t phys_map_node_alloc(void) ++static uint16_t phys_map_node_alloc(PhysPageMap *map) + { + unsigned i; + uint16_t ret; + +- ret = phys_map_nodes_nb++; ++ ret = map->nodes_nb++; + assert(ret != PHYS_MAP_NODE_NIL); +- assert(ret != phys_map_nodes_nb_alloc); ++ assert(ret != map->nodes_nb_alloc); + for (i = 0; i < L2_SIZE; ++i) { +- phys_map_nodes[ret][i].is_leaf = 0; +- phys_map_nodes[ret][i].ptr = PHYS_MAP_NODE_NIL; ++ map->nodes[ret][i].is_leaf = 0; ++ map->nodes[ret][i].ptr = PHYS_MAP_NODE_NIL; + } + return ret; + } + +-static void phys_map_nodes_reset(void) ++static void phys_map_nodes_reset(PhysPageMap *map) + { +- phys_map_nodes_nb = 0; ++ map->nodes_nb = 0; + } + + +-static void phys_page_set_level(PhysPageEntry *lp, hwaddr *index, +- hwaddr *nb, uint16_t leaf, ++static void phys_page_set_level(PhysPageMap *map, PhysPageEntry *lp, ++ hwaddr *index, hwaddr *nb, uint16_t leaf, + int level) + { + PhysPageEntry *p; +@@ -163,8 +167,8 @@ static void phys_page_set_level(PhysPageEntry *lp, hwaddr *index, + hwaddr step = (hwaddr)1 << (level * L2_BITS); + + if (!lp->is_leaf && lp->ptr == PHYS_MAP_NODE_NIL) { +- lp->ptr = phys_map_node_alloc(); +- p = phys_map_nodes[lp->ptr]; ++ lp->ptr = phys_map_node_alloc(map); ++ p = map->nodes[lp->ptr]; + if (level == 0) { + for (i = 0; i < L2_SIZE; i++) { + p[i].is_leaf = 1; +@@ -172,7 +176,7 @@ static void phys_page_set_level(PhysPageEntry *lp, hwaddr *index, + } + } + } else { +- p = phys_map_nodes[lp->ptr]; ++ p = map->nodes[lp->ptr]; + } + lp = &p[(*index >> (level * L2_BITS)) & (L2_SIZE - 1)]; + +@@ -183,7 +187,7 @@ static void phys_page_set_level(PhysPageEntry *lp, hwaddr *index, + *index += step; + *nb -= step; + } else { +- phys_page_set_level(lp, index, nb, leaf, level - 1); ++ phys_page_set_level(map, lp, index, nb, leaf, level - 1); + } + ++lp; + } +@@ -194,9 +198,10 @@ static void phys_page_set(AddressSpaceDispatch *d, + uint16_t leaf) + { + /* Wildly overreserve - it doesn't matter much. */ +- phys_map_node_reserve(3 * P_L2_LEVELS); ++ phys_map_node_reserve(&d->map, 3 * P_L2_LEVELS); + +- phys_page_set_level(&d->phys_map, &index, &nb, leaf, P_L2_LEVELS - 1); ++ phys_page_set_level(&d->map, &d->phys_map, &index, ++ &nb, leaf, P_L2_LEVELS - 1); + } + + MemoryRegionSection *phys_page_find(AddressSpaceDispatch *d, hwaddr index) +@@ -210,13 +215,13 @@ MemoryRegionSection *phys_page_find(AddressSpaceDispatch *d, hwaddr index) + if (lp.ptr == PHYS_MAP_NODE_NIL) { + goto not_found; + } +- p = phys_map_nodes[lp.ptr]; ++ p = d->map.nodes[lp.ptr]; + lp = p[(index >> (i * L2_BITS)) & (L2_SIZE - 1)]; + } + + s_index = lp.ptr; + not_found: +- return &phys_sections[s_index]; ++ return &d->map.sections[s_index]; + } + + bool memory_region_is_unassigned(MemoryRegion *mr) +@@ -657,7 +662,7 @@ hwaddr memory_region_section_get_iotlb(CPUArchState *env, + and avoid full address decoding in every device. + We can't use the high bits of pd for this because + IO_MEM_ROMD uses these as a ram address. */ +- iotlb = section - phys_sections; ++ iotlb = section - address_space_memory.dispatch->map.sections; + iotlb += memory_region_section_addr(section, paddr); + } + +@@ -683,13 +688,14 @@ hwaddr memory_region_section_get_iotlb(CPUArchState *env, + #define SUBPAGE_IDX(addr) ((addr) & ~TARGET_PAGE_MASK) + typedef struct subpage_t { + MemoryRegion iomem; ++ AddressSpace *as; + hwaddr base; + uint16_t sub_section[TARGET_PAGE_SIZE]; + } subpage_t; + + static int subpage_register (subpage_t *mmio, uint32_t start, uint32_t end, + uint16_t section); +-static subpage_t *subpage_init(hwaddr base); ++static subpage_t *subpage_init(AddressSpace *as, hwaddr base); + + static void *(*phys_mem_alloc)(size_t size) = qemu_anon_ram_alloc; + +@@ -703,9 +709,9 @@ void phys_mem_set_alloc(void *(*alloc)(size_t)) + phys_mem_alloc = alloc; + } + +-static void destroy_page_desc(uint16_t section_index) ++static void destroy_page_desc(PhysPageMap *map, uint16_t section_index) + { +- MemoryRegionSection *section = &phys_sections[section_index]; ++ MemoryRegionSection *section = &map->sections[section_index]; + MemoryRegion *mr = section->mr; + + if (mr->subpage) { +@@ -715,7 +721,8 @@ static void destroy_page_desc(uint16_t section_index) + } + } + +-static void destroy_l2_mapping(PhysPageEntry *lp, unsigned level) ++static void destroy_l2_mapping(PhysPageMap *map, PhysPageEntry *lp, ++ unsigned level) + { + unsigned i; + PhysPageEntry *p; +@@ -724,12 +731,12 @@ static void destroy_l2_mapping(PhysPageEntry *lp, unsigned level) + return; + } + +- p = phys_map_nodes[lp->ptr]; ++ p = map->nodes[lp->ptr]; + for (i = 0; i < L2_SIZE; ++i) { + if (!p[i].is_leaf) { +- destroy_l2_mapping(&p[i], level - 1); ++ destroy_l2_mapping(map, &p[i], level - 1); + } else { +- destroy_page_desc(p[i].ptr); ++ destroy_page_desc(map, p[i].ptr); + } + } + lp->is_leaf = 0; +@@ -738,24 +745,25 @@ static void destroy_l2_mapping(PhysPageEntry *lp, unsigned level) + + static void destroy_all_mappings(AddressSpaceDispatch *d) + { +- destroy_l2_mapping(&d->phys_map, P_L2_LEVELS - 1); +- phys_map_nodes_reset(); ++ destroy_l2_mapping(&d->map, &d->phys_map, P_L2_LEVELS - 1); ++ phys_map_nodes_reset(&d->map); + } + +-static uint16_t phys_section_add(MemoryRegionSection *section) ++static uint16_t phys_section_add(PhysPageMap *map, ++ MemoryRegionSection *section) + { +- if (phys_sections_nb == phys_sections_nb_alloc) { +- phys_sections_nb_alloc = MAX(phys_sections_nb_alloc * 2, 16); +- phys_sections = g_renew(MemoryRegionSection, phys_sections, +- phys_sections_nb_alloc); ++ if (map->sections_nb == map->sections_nb_alloc) { ++ map->sections_nb_alloc = MAX(map->sections_nb_alloc * 2, 16); ++ map->sections = g_renew(MemoryRegionSection, map->sections, ++ map->sections_nb_alloc); + } +- phys_sections[phys_sections_nb] = *section; +- return phys_sections_nb++; ++ map->sections[map->sections_nb] = *section; ++ return map->sections_nb++; + } + +-static void phys_sections_clear(void) ++static void phys_sections_clear(PhysPageMap *map) + { +- phys_sections_nb = 0; ++ map->sections_nb = 0; + } + + static void register_subpage(AddressSpaceDispatch *d, MemoryRegionSection *section) +@@ -773,16 +781,16 @@ static void register_subpage(AddressSpaceDispatch *d, MemoryRegionSection *secti + assert(existing->mr->subpage || existing->mr == &io_mem_unassigned); + + if (!(existing->mr->subpage)) { +- subpage = subpage_init(base); ++ subpage = subpage_init(d->as, base); + subsection.mr = &subpage->iomem; + phys_page_set(d, base >> TARGET_PAGE_BITS, 1, +- phys_section_add(&subsection)); ++ phys_section_add(&d->map, &subsection)); + } else { + subpage = container_of(existing->mr, subpage_t, iomem); + } + start = section->offset_within_address_space & ~TARGET_PAGE_MASK; + end = start + section->size - 1; +- subpage_register(subpage, start, end, phys_section_add(section)); ++ subpage_register(subpage, start, end, phys_section_add(&d->map, section)); + } + + +@@ -791,7 +799,7 @@ static void register_multipage(AddressSpaceDispatch *d, MemoryRegionSection *sec + hwaddr start_addr = section->offset_within_address_space; + ram_addr_t size = section->size; + hwaddr addr; +- uint16_t section_index = phys_section_add(section); ++ uint16_t section_index = phys_section_add(&d->map, section); + + assert(size); + +@@ -1619,7 +1627,7 @@ static uint64_t subpage_read(void *opaque, hwaddr addr, + mmio, len, addr, idx); + #endif + +- section = &phys_sections[mmio->sub_section[idx]]; ++ section = &mmio->as->dispatch->map.sections[mmio->sub_section[idx]]; + addr += mmio->base; + addr -= section->offset_within_address_space; + addr += section->offset_within_region; +@@ -1638,7 +1646,7 @@ static void subpage_write(void *opaque, hwaddr addr, + __func__, mmio, len, addr, idx, value); + #endif + +- section = &phys_sections[mmio->sub_section[idx]]; ++ section = &mmio->as->dispatch->map.sections[mmio->sub_section[idx]]; + addr += mmio->base; + addr -= section->offset_within_address_space; + addr += section->offset_within_region; +@@ -1696,10 +1704,10 @@ static int subpage_register (subpage_t *mmio, uint32_t start, uint32_t end, + printf("%s: %p start %08x end %08x idx %08x eidx %08x mem %ld\n", __func__, + mmio, start, end, idx, eidx, memory); + #endif +- if (memory_region_is_ram(phys_sections[section].mr)) { +- MemoryRegionSection new_section = phys_sections[section]; ++ if (memory_region_is_ram(mmio->as->dispatch->map.sections[section].mr)) { ++ MemoryRegionSection new_section = mmio->as->dispatch->map.sections[section]; + new_section.mr = &io_mem_subpage_ram; +- section = phys_section_add(&new_section); ++ section = phys_section_add(&mmio->as->dispatch->map, &new_section); + } + for (; idx <= eidx; idx++) { + mmio->sub_section[idx] = section; +@@ -1708,12 +1716,13 @@ static int subpage_register (subpage_t *mmio, uint32_t start, uint32_t end, + return 0; + } + +-static subpage_t *subpage_init(hwaddr base) ++static subpage_t *subpage_init(AddressSpace *as, hwaddr base) + { + subpage_t *mmio; + + mmio = g_malloc0(sizeof(subpage_t)); + ++ mmio->as = as; + mmio->base = base; + memory_region_init_io(&mmio->iomem, &subpage_ops, mmio, + "subpage", TARGET_PAGE_SIZE); +@@ -1727,7 +1736,7 @@ static subpage_t *subpage_init(hwaddr base) + return mmio; + } + +-static uint16_t dummy_section(MemoryRegion *mr) ++static uint16_t dummy_section(PhysPageMap *map, MemoryRegion *mr) + { + MemoryRegionSection section = { + .mr = mr, +@@ -1736,12 +1745,13 @@ static uint16_t dummy_section(MemoryRegion *mr) + .size = UINT64_MAX, + }; + +- return phys_section_add(§ion); ++ return phys_section_add(map, §ion); + } + + MemoryRegion *iotlb_to_region(hwaddr index) + { +- return phys_sections[index & ~TARGET_PAGE_MASK].mr; ++ return address_space_memory.dispatch->map.sections[ ++ index & ~TARGET_PAGE_MASK].mr; + } + + static void io_mem_init(void) +@@ -1761,23 +1771,19 @@ static void io_mem_init(void) + static void mem_begin(MemoryListener *listener) + { + AddressSpaceDispatch *d = container_of(listener, AddressSpaceDispatch, listener); ++ uint16_t n; + + destroy_all_mappings(d); + d->phys_map.ptr = PHYS_MAP_NODE_NIL; +-} +- +-static void core_begin(MemoryListener *listener) +-{ +- uint16_t n; + +- phys_sections_clear(); +- n = dummy_section(&io_mem_unassigned); ++ phys_sections_clear(&d->map); ++ n = dummy_section(&d->map, &io_mem_unassigned); + assert(n == PHYS_SECTION_UNASSIGNED); +- n = dummy_section(&io_mem_notdirty); ++ n = dummy_section(&d->map, &io_mem_notdirty); + assert(n == PHYS_SECTION_NOTDIRTY); +- n = dummy_section(&io_mem_rom); ++ n = dummy_section(&d->map, &io_mem_rom); + assert(n == PHYS_SECTION_ROM); +- n = dummy_section(&io_mem_watch); ++ n = dummy_section(&d->map, &io_mem_watch); + assert(n == PHYS_SECTION_WATCH); + } + +@@ -1822,7 +1828,6 @@ static void io_region_del(MemoryListener *listener, + } + + static MemoryListener core_memory_listener = { +- .begin = core_begin, + .log_global_start = core_log_global_start, + .log_global_stop = core_log_global_stop, + .priority = 1, +@@ -1840,7 +1845,7 @@ static MemoryListener tcg_memory_listener = { + + void address_space_init_dispatch(AddressSpace *as) + { +- AddressSpaceDispatch *d = g_new(AddressSpaceDispatch, 1); ++ AddressSpaceDispatch *d = g_new0(AddressSpaceDispatch, 1); + + d->phys_map = (PhysPageEntry) { .ptr = PHYS_MAP_NODE_NIL, .is_leaf = 0 }; + d->listener = (MemoryListener) { +@@ -1849,6 +1854,7 @@ void address_space_init_dispatch(AddressSpace *as) + .region_nop = mem_add, + .priority = 0, + }; ++ d->as = as; + as->dispatch = d; + memory_listener_register(&d->listener, as); + } +@@ -1858,7 +1864,7 @@ void address_space_destroy_dispatch(AddressSpace *as) + AddressSpaceDispatch *d = as->dispatch; + + memory_listener_unregister(&d->listener); +- destroy_l2_mapping(&d->phys_map, P_L2_LEVELS - 1); ++ destroy_l2_mapping(&d->map, &d->phys_map, P_L2_LEVELS - 1); + g_free(d); + as->dispatch = NULL; + } +@@ -2446,7 +2452,7 @@ void stl_phys_notdirty(hwaddr addr, uint32_t val) + if (!memory_region_is_ram(section->mr) || section->readonly) { + addr = memory_region_section_addr(section, addr); + if (memory_region_is_ram(section->mr)) { +- section = &phys_sections[PHYS_SECTION_ROM]; ++ section = &address_space_memory.dispatch->map.sections[PHYS_SECTION_ROM]; + } + io_mem_write(section->mr, addr, val, 4); + } else { +@@ -2479,7 +2485,7 @@ void stq_phys_notdirty(hwaddr addr, uint64_t val) + if (!memory_region_is_ram(section->mr) || section->readonly) { + addr = memory_region_section_addr(section, addr); + if (memory_region_is_ram(section->mr)) { +- section = &phys_sections[PHYS_SECTION_ROM]; ++ section = &address_space_memory.dispatch->map.sections[PHYS_SECTION_ROM]; + } + #ifdef TARGET_WORDS_BIGENDIAN + io_mem_write(section->mr, addr, val >> 32, 4); +@@ -2508,7 +2514,7 @@ static inline void stl_phys_internal(hwaddr addr, uint32_t val, + if (!memory_region_is_ram(section->mr) || section->readonly) { + addr = memory_region_section_addr(section, addr); + if (memory_region_is_ram(section->mr)) { +- section = &phys_sections[PHYS_SECTION_ROM]; ++ section = &address_space_memory.dispatch->map.sections[PHYS_SECTION_ROM]; + } + #if defined(TARGET_WORDS_BIGENDIAN) + if (endian == DEVICE_LITTLE_ENDIAN) { +@@ -2575,7 +2581,7 @@ static inline void stw_phys_internal(hwaddr addr, uint32_t val, + if (!memory_region_is_ram(section->mr) || section->readonly) { + addr = memory_region_section_addr(section, addr); + if (memory_region_is_ram(section->mr)) { +- section = &phys_sections[PHYS_SECTION_ROM]; ++ section = &address_space_memory.dispatch->map.sections[PHYS_SECTION_ROM]; + } + #if defined(TARGET_WORDS_BIGENDIAN) + if (endian == DEVICE_LITTLE_ENDIAN) { +-- +1.7.1 + diff --git a/SOURCES/kvm-exec-use-accessor-function-to-know-if-memory-is-dirt.patch b/SOURCES/kvm-exec-use-accessor-function-to-know-if-memory-is-dirt.patch new file mode 100644 index 0000000..57d222a --- /dev/null +++ b/SOURCES/kvm-exec-use-accessor-function-to-know-if-memory-is-dirt.patch @@ -0,0 +1,59 @@ +From 66ab02bc657f102955f3077914bbaf00bc6546e9 Mon Sep 17 00:00:00 2001 +From: Juan Quintela +Date: Tue, 14 Jan 2014 15:07:15 +0100 +Subject: [PATCH 04/40] exec: use accessor function to know if memory is dirty +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +RH-Author: Juan Quintela +Message-id: <1389712071-23303-5-git-send-email-quintela@redhat.com> +Patchwork-id: 56662 +O-Subject: [RHEL7 qemu-kvm PATCH 04/40] exec: use accessor function to know if memory is dirty +Bugzilla: 997559 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Orit Wasserman +RH-Acked-by: Dr. David Alan Gilbert (git) + +Signed-off-by: Juan Quintela +Reviewed-by: Orit Wasserman +Reviewed-by: Eric Blake +(cherry picked from commit 06567942e5e92cc649b608205d5d31ff3ac21c58) + +Conflicts: + exec.c + +Conflict is due to the following comming irrelevant to migration: + +ommit 4917cf44326a1bda2fd7f27303aff7a25ad86518 +Author: Andreas Färber +Date: Mon May 27 05:17:50 2013 +0200 + + cpu: Replace cpu_single_env with CPUState current_cpu + +Signed-off-by: Juan Quintela +--- + exec.c | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +Signed-off-by: Miroslav Rezanina +--- + exec.c | 2 +- + 1 files changed, 1 insertions(+), 1 deletions(-) + +diff --git a/exec.c b/exec.c +index 571cea4..389888d 100644 +--- a/exec.c ++++ b/exec.c +@@ -1505,7 +1505,7 @@ static void notdirty_mem_write(void *opaque, hwaddr ram_addr, + cpu_physical_memory_set_dirty_flags(ram_addr, dirty_flags); + /* we remove the notdirty callback only if the code has been + flushed */ +- if (dirty_flags == 0xff) ++ if (cpu_physical_memory_is_dirty(ram_addr)) + tlb_set_dirty(cpu_single_env, cpu_single_env->mem_io_vaddr); + } + +-- +1.7.1 + diff --git a/SOURCES/kvm-fix-boot-strict-regressed-in-commit-6ef4716.patch b/SOURCES/kvm-fix-boot-strict-regressed-in-commit-6ef4716.patch new file mode 100644 index 0000000..6d53986 --- /dev/null +++ b/SOURCES/kvm-fix-boot-strict-regressed-in-commit-6ef4716.patch @@ -0,0 +1,55 @@ +From 98fa25db65984e59d72eebcc42265bdf5e02fd95 Mon Sep 17 00:00:00 2001 +From: Amos Kong +Date: Tue, 14 Jan 2014 09:56:39 +0100 +Subject: [PATCH 15/16] fix -boot strict regressed in commit 6ef4716 + +RH-Author: Amos Kong +Message-id: <1389693400-21546-2-git-send-email-akong@redhat.com> +Patchwork-id: 56652 +O-Subject: [RHEL-7.0 qemu-kvm PATCH 1/2] fix -boot strict regressed in commit 6ef4716 +Bugzilla: 997817 +RH-Acked-by: Laszlo Ersek +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Markus Armbruster + +Commit 6ef4716 cleaned up parsing of -boot option argument, but +accidentally dropped parameter strict. It should have been updated +exactly like parameter menu. Do that. + +Signed-off-by: Amos Kong +Reviewed-by: Markus Armbruster +Signed-off-by: Michael Tokarev +(cherry picked from commit e5187b561ff7b241d609a2848131879072169565) +--- + vl.c | 3 ++- + 1 files changed, 2 insertions(+), 1 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + vl.c | 3 ++- + 1 files changed, 2 insertions(+), 1 deletions(-) + +diff --git a/vl.c b/vl.c +index 781c352..11899dc 100644 +--- a/vl.c ++++ b/vl.c +@@ -459,7 +459,7 @@ static QemuOptsList qemu_boot_opts = { + .type = QEMU_OPT_STRING, + }, { + .name = "strict", +- .type = QEMU_OPT_STRING, ++ .type = QEMU_OPT_BOOL, + }, + { /*End of list */ } + }, +@@ -4059,6 +4059,7 @@ int main(int argc, char **argv, char **envp) + } + + boot_menu = qemu_opt_get_bool(opts, "menu", boot_menu); ++ boot_strict = qemu_opt_get_bool(opts, "strict", false); + } + + if (!kernel_cmdline) { +-- +1.7.1 + diff --git a/SOURCES/kvm-fix-coexistence-of-KVM-and-Hyper-V-leaves.patch b/SOURCES/kvm-fix-coexistence-of-KVM-and-Hyper-V-leaves.patch new file mode 100644 index 0000000..1684be8 --- /dev/null +++ b/SOURCES/kvm-fix-coexistence-of-KVM-and-Hyper-V-leaves.patch @@ -0,0 +1,114 @@ +From e77dfa0b88d9efdf6b2125817cd6febdcf4385b0 Mon Sep 17 00:00:00 2001 +From: Vadim Rozenfeld +Date: Mon, 3 Mar 2014 12:09:15 +0100 +Subject: [PATCH 03/12] KVM: fix coexistence of KVM and Hyper-V leaves + +RH-Author: Vadim Rozenfeld +Message-id: <1393848564-10511-4-git-send-email-vrozenfe@redhat.com> +Patchwork-id: 57959 +O-Subject: [RHEL-7.0 qemu-kvm v4 PATCH 03/12] KVM: fix coexistence of KVM and Hyper-V leaves +Bugzilla: 1004773 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Igor Mammedov +RH-Acked-by: Juan Quintela +RH-Acked-by: Eduardo Habkost + +From: Paolo Bonzini + +kvm_arch_init_vcpu's initialization of the KVM leaves at 0x40000100 +is broken, because KVM_CPUID_FEATURES is left at 0x40000001. Move +it to 0x40000101 if Hyper-V is enabled. + +Signed-off-by: Paolo Bonzini +(cherry picked from commit 234cc64796557eea829544e4ff72ee99b6149187) +--- + target-i386/kvm.c | 47 +++++++++++++++++++++++++---------------------- + 1 file changed, 25 insertions(+), 22 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + target-i386/kvm.c | 47 +++++++++++++++++++++++++---------------------- + 1 files changed, 25 insertions(+), 22 deletions(-) + +diff --git a/target-i386/kvm.c b/target-i386/kvm.c +index 3a9e376..3688371 100644 +--- a/target-i386/kvm.c ++++ b/target-i386/kvm.c +@@ -451,6 +451,7 @@ int kvm_arch_init_vcpu(CPUState *cs) + uint32_t unused; + struct kvm_cpuid_entry2 *c; + uint32_t signature[3]; ++ int kvm_base = KVM_CPUID_SIGNATURE; + int r; + + memset(&cpuid_data, 0, sizeof(cpuid_data)); +@@ -458,26 +459,22 @@ int kvm_arch_init_vcpu(CPUState *cs) + cpuid_i = 0; + + /* Paravirtualization CPUIDs */ +- c = &cpuid_data.entries[cpuid_i++]; +- c->function = KVM_CPUID_SIGNATURE; +- if (!hyperv_enabled(cpu)) { +- memcpy(signature, "KVMKVMKVM\0\0\0", 12); +- c->eax = 0; +- } else { ++ if (hyperv_enabled(cpu)) { ++ c = &cpuid_data.entries[cpuid_i++]; ++ c->function = HYPERV_CPUID_VENDOR_AND_MAX_FUNCTIONS; + memcpy(signature, "Microsoft Hv", 12); + c->eax = HYPERV_CPUID_MIN; +- } +- c->ebx = signature[0]; +- c->ecx = signature[1]; +- c->edx = signature[2]; +- +- c = &cpuid_data.entries[cpuid_i++]; +- c->function = KVM_CPUID_FEATURES; +- c->eax = env->features[FEAT_KVM]; ++ c->ebx = signature[0]; ++ c->ecx = signature[1]; ++ c->edx = signature[2]; + +- if (hyperv_enabled(cpu)) { ++ c = &cpuid_data.entries[cpuid_i++]; ++ c->function = HYPERV_CPUID_INTERFACE; + memcpy(signature, "Hv#1\0\0\0\0\0\0\0\0", 12); + c->eax = signature[0]; ++ c->ebx = 0; ++ c->ecx = 0; ++ c->edx = 0; + + c = &cpuid_data.entries[cpuid_i++]; + c->function = HYPERV_CPUID_VERSION; +@@ -509,15 +506,21 @@ int kvm_arch_init_vcpu(CPUState *cs) + c->eax = 0x40; + c->ebx = 0x40; + +- c = &cpuid_data.entries[cpuid_i++]; +- c->function = KVM_CPUID_SIGNATURE_NEXT; +- memcpy(signature, "KVMKVMKVM\0\0\0", 12); +- c->eax = 0; +- c->ebx = signature[0]; +- c->ecx = signature[1]; +- c->edx = signature[2]; ++ kvm_base = KVM_CPUID_SIGNATURE_NEXT; + } + ++ memcpy(signature, "KVMKVMKVM\0\0\0", 12); ++ c = &cpuid_data.entries[cpuid_i++]; ++ c->function = KVM_CPUID_SIGNATURE | kvm_base; ++ c->eax = 0; ++ c->ebx = signature[0]; ++ c->ecx = signature[1]; ++ c->edx = signature[2]; ++ ++ c = &cpuid_data.entries[cpuid_i++]; ++ c->function = KVM_CPUID_FEATURES | kvm_base; ++ c->eax = env->features[FEAT_KVM]; ++ + has_msr_async_pf_en = c->eax & (1 << KVM_FEATURE_ASYNC_PF); + + has_msr_pv_eoi_en = c->eax & (1 << KVM_FEATURE_PV_EOI); +-- +1.7.1 + diff --git a/SOURCES/kvm-fix-double-free-the-memslot-in-kvm_set_phys_mem.patch b/SOURCES/kvm-fix-double-free-the-memslot-in-kvm_set_phys_mem.patch new file mode 100644 index 0000000..073ad01 --- /dev/null +++ b/SOURCES/kvm-fix-double-free-the-memslot-in-kvm_set_phys_mem.patch @@ -0,0 +1,56 @@ +From dc37b3a1cd7c01dfccf9459a973694cee266957f Mon Sep 17 00:00:00 2001 +From: Laszlo Ersek +Date: Sat, 11 Jan 2014 17:59:59 +0100 +Subject: [PATCH 09/22] fix double free the memslot in kvm_set_phys_mem + +RH-Author: Laszlo Ersek +Message-id: <1389463208-6278-10-git-send-email-lersek@redhat.com> +Patchwork-id: 56622 +O-Subject: [RHEL-7.0 qemu-kvm PATCH 09/18] fix double free the memslot in kvm_set_phys_mem +Bugzilla: 1032346 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Amos Kong +RH-Acked-by: Andrew Jones + +From: Xiao Guangrong + +Luiz Capitulino reported that guest refused to boot and qemu +complained with: +kvm_set_phys_mem: error unregistering overlapping slot: Invalid argument + +It is caused by commit 235e8982ad that did double free for the memslot +so that the second one raises the -EINVAL error + +Fix it by reset memory size only if it is needed + +Reported-by: Luiz Capitulino +Signed-off-by: Xiao Guangrong +Signed-off-by: Anthony Liguori +(cherry picked from commit 651eb0f41b793021f7de672de78892def5819fb9) +Signed-off-by: Laszlo Ersek +--- + kvm-all.c | 3 ++- + 1 file changed, 2 insertions(+), 1 deletion(-) + +Signed-off-by: Miroslav Rezanina +--- + kvm-all.c | 3 ++- + 1 files changed, 2 insertions(+), 1 deletions(-) + +diff --git a/kvm-all.c b/kvm-all.c +index 42c71b9..16e4f65 100644 +--- a/kvm-all.c ++++ b/kvm-all.c +@@ -208,7 +208,8 @@ static int kvm_set_user_memory_region(KVMState *s, KVMSlot *slot) + if (s->migration_log) { + mem.flags |= KVM_MEM_LOG_DIRTY_PAGES; + } +- if (mem.flags & KVM_MEM_READONLY) { ++ ++ if (slot->memory_size && mem.flags & KVM_MEM_READONLY) { + /* Set the slot size to 0 before setting the slot to the desired + * value. This is needed based on KVM commit 75d61fbc. */ + mem.memory_size = 0; +-- +1.7.1 + diff --git a/SOURCES/kvm-fix-guest-physical-bits-to-match-host-to-go-beyond-1.patch b/SOURCES/kvm-fix-guest-physical-bits-to-match-host-to-go-beyond-1.patch new file mode 100644 index 0000000..e027b68 --- /dev/null +++ b/SOURCES/kvm-fix-guest-physical-bits-to-match-host-to-go-beyond-1.patch @@ -0,0 +1,62 @@ +From 4c20b901edfb53e4545aab8fcefb6f40fca25964 Mon Sep 17 00:00:00 2001 +From: Andrea Arcangeli +Date: Wed, 12 Feb 2014 13:30:18 +0100 +Subject: [PATCH 2/3] fix guest physical bits to match host, to go beyond 1TB guests + +RH-Author: Andrea Arcangeli +Message-id: <1392211818-14964-2-git-send-email-aarcange@redhat.com> +Patchwork-id: 57245 +O-Subject: [RHEL-7.0 qemu-kvm PATCH] fix guest physical bits to match host, to go beyond 1TB guests +Bugzilla: 989677 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Andrew Jones +RH-Acked-by: Marcelo Tosatti + +Without this patch the guest physical bits are advertised as 40, not +44 or more depending on the hardware capability of the host. + +That leads to guest kernel crashes with injection of page faults 9 +(see oops: 0009) as bits above 40 in the guest pagetables are +considered reserved. + +exregion-0206 [324572448] [17] ex_system_memory_space: System-Memory (width 32) R/W 0 Address=00000000FED00000 +BUG: unable to handle kernel paging request at ffffc9006030e000 +IP: [] acpi_ex_system_memory_space_handler+0x23e/0x2cb +PGD e01f875067 PUD 1001f075067 PMD e0178d8067 PTE 80000000fed00173 +Oops: 0009 [#1] SMP + +(see PUD with bit >=40 set) + +Signed-off-by: Andrea Arcangeli +Reported-by: Chegu Vinod +--- + target-i386/cpu.c | 7 ++++++- + 1 file changed, 6 insertions(+), 1 deletion(-) + +Signed-off-by: Miroslav Rezanina +--- + target-i386/cpu.c | 7 ++++++- + 1 files changed, 6 insertions(+), 1 deletions(-) + +diff --git a/target-i386/cpu.c b/target-i386/cpu.c +index 2959915..31ff568 100644 +--- a/target-i386/cpu.c ++++ b/target-i386/cpu.c +@@ -2174,8 +2174,13 @@ void cpu_x86_cpuid(CPUX86State *env, uint32_t index, uint32_t count, + /* XXX: This value must match the one used in the MMU code. */ + if (env->features[FEAT_8000_0001_EDX] & CPUID_EXT2_LM) { + /* 64 bit processor */ +-/* XXX: The physical address space is limited to 42 bits in exec.c. */ + *eax = 0x00003028; /* 48 bits virtual, 40 bits physical */ ++ if (kvm_enabled()) { ++ uint32_t _eax; ++ host_cpuid(0x80000000, 0, &_eax, NULL, NULL, NULL); ++ if (_eax >= 0x80000008) ++ host_cpuid(0x80000008, 0, eax, NULL, NULL, NULL); ++ } + } else { + if (env->features[FEAT_1_EDX] & CPUID_PSE36) { + *eax = 0x00000024; /* 36 bits physical */ +-- +1.7.1 + diff --git a/SOURCES/kvm-fix-intel-hda-live-migration.patch b/SOURCES/kvm-fix-intel-hda-live-migration.patch new file mode 100644 index 0000000..6204660 --- /dev/null +++ b/SOURCES/kvm-fix-intel-hda-live-migration.patch @@ -0,0 +1,48 @@ +From 73e7e8ffd938923f5e30132dd90003ebc9e423dc Mon Sep 17 00:00:00 2001 +Message-Id: <73e7e8ffd938923f5e30132dd90003ebc9e423dc.1387276076.git.minovotn@redhat.com> +In-Reply-To: +References: +From: Gerd Hoffmann +Date: Mon, 9 Dec 2013 13:57:35 +0100 +Subject: [PATCH 05/16] fix intel-hda live migration + +RH-Author: Gerd Hoffmann +Message-id: <1386597455-25593-2-git-send-email-kraxel@redhat.com> +Patchwork-id: 56035 +O-Subject: [RHEL-7 qemu-kvm PATCH 1/1] fix intel-hda live migration +Bugzilla: 1036537 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Amos Kong +RH-Acked-by: Orit Wasserman + +RHEL-6 intel-hda emulation doesn't support MSI, so we have +to turn it off for thel RHEL-6 machine types in RHEL-7. + +Signed-off-by: Gerd Hoffmann +--- + hw/i386/pc_piix.c | 4 ++++ + 1 file changed, 4 insertions(+) + +Signed-off-by: Michal Novotny +--- + hw/i386/pc_piix.c | 4 ++++ + 1 file changed, 4 insertions(+) + +diff --git a/hw/i386/pc_piix.c b/hw/i386/pc_piix.c +index e6771a9..8c3f2d6 100644 +--- a/hw/i386/pc_piix.c ++++ b/hw/i386/pc_piix.c +@@ -811,6 +811,10 @@ static QEMUMachine pc_machine_rhel700 = { + .property = "use_broken_id",\ + .value = stringify(1),\ + },{\ ++ .driver = "intel-hda",\ ++ .property = "msi",\ ++ .value = stringify(0),\ ++ },{\ + .driver = "qemu32-" TYPE_X86_CPU,\ + .property = "xlevel",\ + .value = stringify(0),\ +-- +1.7.11.7 + diff --git a/SOURCES/kvm-fix-machine-check-propagation.patch b/SOURCES/kvm-fix-machine-check-propagation.patch new file mode 100644 index 0000000..3ef71fe --- /dev/null +++ b/SOURCES/kvm-fix-machine-check-propagation.patch @@ -0,0 +1,75 @@ +From a573bf83cd8f541f3129a53238ee7c2e9ad61ff8 Mon Sep 17 00:00:00 2001 +From: Paolo Bonzini +Date: Wed, 26 Mar 2014 12:30:43 +0100 +Subject: [PATCH 49/49] fix machine-check propagation +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +RH-Author: Paolo Bonzini +Message-id: <1395837043-17408-1-git-send-email-pbonzini@redhat.com> +Patchwork-id: 58256 +O-Subject: [RHEL 7.0 qemu-kvm PATCH] fix machine-check propagation +Bugzilla: 740107 +RH-Acked-by: Marcel Apfelbaum +RH-Acked-by: Eduardo Habkost +RH-Acked-by: Dr. David Alan Gilbert (git) + +From: Dean Nelson + +Bugzilla: 740107 + +Upstream status: fixed by a big patch that should not be backported + +Brew build: http://brewweb.devel.redhat.com/brew/taskinfo?taskID=7257203 + +Machine-check propagation was broken by this commit + + commit a60f24b56b07f46453424263b276b0879c25c4e6 + Author: Andreas Färber + Date: Sat Dec 1 05:35:08 2012 +0100 + + cpu: Move kvm_state field into CPUState + + Adapt some functions to take CPUState / {PowerPC,S390}CPU argument. + + Signed-off-by: Andreas Färber + +due to a typo. In RHEL7, first_cpu is an "env" so you need ENV_GET_CPU +to convert it to a "cpu" and fish out the kvm_state. ENV_GET_CPU is +basically a "container_of" type of operation. Instead, CPU was being used +(which is just a cast). + +Upstream, everything was fixed magically when first_cpu was changed +from "env" to "cpu" in commit 182735e (cpu: Make first_cpu and next_cpu +CPUState, 2013-05-29). + +This patch fixes the bug by using the right cast. All the work was done +by Dean Nelson. + +Signed-off-by: Paolo Bonzini +--- + target-i386/kvm.c | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +Signed-off-by: Miroslav Rezanina +--- + target-i386/kvm.c | 2 +- + 1 files changed, 1 insertions(+), 1 deletions(-) + +diff --git a/target-i386/kvm.c b/target-i386/kvm.c +index ba2cd7f..6b250f5 100644 +--- a/target-i386/kvm.c ++++ b/target-i386/kvm.c +@@ -357,7 +357,7 @@ int kvm_arch_on_sigbus(int code, void *addr) + + /* Hope we are lucky for AO MCE */ + if (qemu_ram_addr_from_host(addr, &ram_addr) || +- !kvm_physical_memory_addr_from_host(CPU(first_cpu)->kvm_state, ++ !kvm_physical_memory_addr_from_host(ENV_GET_CPU(first_cpu)->kvm_state, + addr, &paddr)) { + fprintf(stderr, "Hardware memory error for memory used by " + "QEMU itself instead of guest system!: %p\n", addr); +-- +1.7.1 + diff --git a/SOURCES/kvm-fw_cfg-interface-to-trigger-callback-on-read.patch b/SOURCES/kvm-fw_cfg-interface-to-trigger-callback-on-read.patch new file mode 100644 index 0000000..4d203f2 --- /dev/null +++ b/SOURCES/kvm-fw_cfg-interface-to-trigger-callback-on-read.patch @@ -0,0 +1,146 @@ +From 8ef464d9f69895ad603c8104460ec667892be48c Mon Sep 17 00:00:00 2001 +Message-Id: <8ef464d9f69895ad603c8104460ec667892be48c.1387298827.git.minovotn@redhat.com> +In-Reply-To: <3ed0fb61a3dc912ef036d7ef450bed192090709e.1387298827.git.minovotn@redhat.com> +References: <3ed0fb61a3dc912ef036d7ef450bed192090709e.1387298827.git.minovotn@redhat.com> +From: "Michael S. Tsirkin" +Date: Tue, 17 Dec 2013 15:17:56 +0100 +Subject: [PATCH 26/56] fw_cfg: interface to trigger callback on read + +RH-Author: Michael S. Tsirkin +Message-id: <1387293161-4085-27-git-send-email-mst@redhat.com> +Patchwork-id: 56332 +O-Subject: [PATCH qemu-kvm RHEL7.0 v2 26/57] fw_cfg: interface to trigger callback on read +Bugzilla: 1034876 +RH-Acked-by: Igor Mammedov +RH-Acked-by: Marcel Apfelbaum +RH-Acked-by: Laszlo Ersek + +Reviewed-by: Gerd Hoffmann +Tested-by: Gerd Hoffmann +Reviewed-by: Igor Mammedov +Tested-by: Igor Mammedov +Signed-off-by: Michael S. Tsirkin +(cherry picked from commit d87072ceeccf4f84a64d4bc59124bcd64286c070) +--- + include/hw/nvram/fw_cfg.h | 4 ++++ + hw/nvram/fw_cfg.c | 33 ++++++++++++++++++++++++++++----- + 2 files changed, 32 insertions(+), 5 deletions(-) + +Signed-off-by: Michal Novotny +--- + hw/nvram/fw_cfg.c | 33 ++++++++++++++++++++++++++++----- + include/hw/nvram/fw_cfg.h | 4 ++++ + 2 files changed, 32 insertions(+), 5 deletions(-) + +diff --git a/hw/nvram/fw_cfg.c b/hw/nvram/fw_cfg.c +index 064344d..b865c09 100644 +--- a/hw/nvram/fw_cfg.c ++++ b/hw/nvram/fw_cfg.c +@@ -41,6 +41,7 @@ typedef struct FWCfgEntry { + uint8_t *data; + void *callback_opaque; + FWCfgCallback callback; ++ FWCfgReadCallback read_callback; + } FWCfgEntry; + + struct FWCfgState { +@@ -245,8 +246,12 @@ static uint8_t fw_cfg_read(FWCfgState *s) + + if (s->cur_entry == FW_CFG_INVALID || !e->data || s->cur_offset >= e->len) + ret = 0; +- else ++ else { ++ if (e->read_callback) { ++ e->read_callback(e->callback_opaque, s->cur_offset); ++ } + ret = e->data[s->cur_offset++]; ++ } + + trace_fw_cfg_read(s, ret); + return ret; +@@ -377,7 +382,10 @@ static const VMStateDescription vmstate_fw_cfg = { + } + }; + +-void fw_cfg_add_bytes(FWCfgState *s, uint16_t key, void *data, size_t len) ++static void fw_cfg_add_bytes_read_callback(FWCfgState *s, uint16_t key, ++ FWCfgReadCallback callback, ++ void *callback_opaque, ++ void *data, size_t len) + { + int arch = !!(key & FW_CFG_ARCH_LOCAL); + +@@ -387,6 +395,13 @@ void fw_cfg_add_bytes(FWCfgState *s, uint16_t key, void *data, size_t len) + + s->entries[arch][key].data = data; + s->entries[arch][key].len = (uint32_t)len; ++ s->entries[arch][key].read_callback = callback; ++ s->entries[arch][key].callback_opaque = callback_opaque; ++} ++ ++void fw_cfg_add_bytes(FWCfgState *s, uint16_t key, void *data, size_t len) ++{ ++ fw_cfg_add_bytes_read_callback(s, key, NULL, NULL, data, len); + } + + void fw_cfg_add_string(FWCfgState *s, uint16_t key, const char *value) +@@ -440,8 +455,9 @@ void fw_cfg_add_callback(FWCfgState *s, uint16_t key, FWCfgCallback callback, + s->entries[arch][key].callback = callback; + } + +-void fw_cfg_add_file(FWCfgState *s, const char *filename, +- void *data, size_t len) ++void fw_cfg_add_file_callback(FWCfgState *s, const char *filename, ++ FWCfgReadCallback callback, void *callback_opaque, ++ void *data, size_t len) + { + int i, index; + size_t dsize; +@@ -455,7 +471,8 @@ void fw_cfg_add_file(FWCfgState *s, const char *filename, + index = be32_to_cpu(s->files->count); + assert(index < FW_CFG_FILE_SLOTS); + +- fw_cfg_add_bytes(s, FW_CFG_FILE_FIRST + index, data, len); ++ fw_cfg_add_bytes_read_callback(s, FW_CFG_FILE_FIRST + index, ++ callback, callback_opaque, data, len); + + pstrcpy(s->files->f[index].name, sizeof(s->files->f[index].name), + filename); +@@ -473,6 +490,12 @@ void fw_cfg_add_file(FWCfgState *s, const char *filename, + s->files->count = cpu_to_be32(index+1); + } + ++void fw_cfg_add_file(FWCfgState *s, const char *filename, ++ void *data, size_t len) ++{ ++ fw_cfg_add_file_callback(s, filename, NULL, NULL, data, len); ++} ++ + static void fw_cfg_machine_ready(struct Notifier *n, void *data) + { + size_t len; +diff --git a/include/hw/nvram/fw_cfg.h b/include/hw/nvram/fw_cfg.h +index f60dd67..2ab0fc2 100644 +--- a/include/hw/nvram/fw_cfg.h ++++ b/include/hw/nvram/fw_cfg.h +@@ -60,6 +60,7 @@ typedef struct FWCfgFiles { + } FWCfgFiles; + + typedef void (*FWCfgCallback)(void *opaque, uint8_t *data); ++typedef void (*FWCfgReadCallback)(void *opaque, uint32_t offset); + + void fw_cfg_add_bytes(FWCfgState *s, uint16_t key, void *data, size_t len); + void fw_cfg_add_string(FWCfgState *s, uint16_t key, const char *value); +@@ -70,6 +71,9 @@ void fw_cfg_add_callback(FWCfgState *s, uint16_t key, FWCfgCallback callback, + void *callback_opaque, void *data, size_t len); + void fw_cfg_add_file(FWCfgState *s, const char *filename, void *data, + size_t len); ++void fw_cfg_add_file_callback(FWCfgState *s, const char *filename, ++ FWCfgReadCallback callback, void *callback_opaque, ++ void *data, size_t len); + FWCfgState *fw_cfg_init(uint32_t ctl_port, uint32_t data_port, + hwaddr crl_addr, hwaddr data_addr); + +-- +1.7.11.7 + diff --git a/SOURCES/kvm-fw_cfg-move-typedef-to-qemu-typedefs.h.patch b/SOURCES/kvm-fw_cfg-move-typedef-to-qemu-typedefs.h.patch new file mode 100644 index 0000000..d450eba --- /dev/null +++ b/SOURCES/kvm-fw_cfg-move-typedef-to-qemu-typedefs.h.patch @@ -0,0 +1,81 @@ +From c2e580f1f3137d8517894ba6d5cd6d7f85682587 Mon Sep 17 00:00:00 2001 +Message-Id: +In-Reply-To: <3ed0fb61a3dc912ef036d7ef450bed192090709e.1387298827.git.minovotn@redhat.com> +References: <3ed0fb61a3dc912ef036d7ef450bed192090709e.1387298827.git.minovotn@redhat.com> +From: "Michael S. Tsirkin" +Date: Tue, 17 Dec 2013 15:17:13 +0100 +Subject: [PATCH 10/56] fw_cfg: move typedef to qemu/typedefs.h + +RH-Author: Michael S. Tsirkin +Message-id: <1387293161-4085-11-git-send-email-mst@redhat.com> +Patchwork-id: 56315 +O-Subject: [PATCH qemu-kvm RHEL7.0 v2 10/57] fw_cfg: move typedef to qemu/typedefs.h +Bugzilla: 1034876 +RH-Acked-by: Igor Mammedov +RH-Acked-by: Marcel Apfelbaum +RH-Acked-by: Laszlo Ersek + +Less header dependencies this way. + +Signed-off-by: Michael S. Tsirkin +(cherry picked from commit 45936c8b79012da4c8986c20af4afcc9cd14bb8e) +--- + include/hw/i386/pc.h | 1 - + include/hw/nvram/fw_cfg.h | 2 +- + include/qemu/typedefs.h | 1 + + 3 files changed, 2 insertions(+), 2 deletions(-) + +Signed-off-by: Michal Novotny +--- + include/hw/i386/pc.h | 1 - + include/hw/nvram/fw_cfg.h | 2 +- + include/qemu/typedefs.h | 1 + + 3 files changed, 2 insertions(+), 2 deletions(-) + +diff --git a/include/hw/i386/pc.h b/include/hw/i386/pc.h +index 4175c1b..2cf7baa 100644 +--- a/include/hw/i386/pc.h ++++ b/include/hw/i386/pc.h +@@ -9,7 +9,6 @@ + #include "net/net.h" + #include "exec/memory.h" + #include "hw/i386/ioapic.h" +-#include "hw/nvram/fw_cfg.h" + + /* PC-style peripherals (also used by other machines). */ + +diff --git a/include/hw/nvram/fw_cfg.h b/include/hw/nvram/fw_cfg.h +index 48a8aa4..f60dd67 100644 +--- a/include/hw/nvram/fw_cfg.h ++++ b/include/hw/nvram/fw_cfg.h +@@ -6,6 +6,7 @@ + #include + + #include "exec/hwaddr.h" ++#include "qemu/typedefs.h" + #endif + + #define FW_CFG_SIGNATURE 0x00 +@@ -60,7 +61,6 @@ typedef struct FWCfgFiles { + + typedef void (*FWCfgCallback)(void *opaque, uint8_t *data); + +-typedef struct FWCfgState FWCfgState; + void fw_cfg_add_bytes(FWCfgState *s, uint16_t key, void *data, size_t len); + void fw_cfg_add_string(FWCfgState *s, uint16_t key, const char *value); + void fw_cfg_add_i16(FWCfgState *s, uint16_t key, uint16_t value); +diff --git a/include/qemu/typedefs.h b/include/qemu/typedefs.h +index 2e7d942..a332d88 100644 +--- a/include/qemu/typedefs.h ++++ b/include/qemu/typedefs.h +@@ -63,6 +63,7 @@ typedef struct EventNotifier EventNotifier; + typedef struct VirtIODevice VirtIODevice; + typedef struct QEMUSGList QEMUSGList; + typedef struct SHPCDevice SHPCDevice; ++typedef struct FWCfgState FWCfgState; + typedef struct Range Range; + + #endif /* QEMU_TYPEDEFS_H */ +-- +1.7.11.7 + diff --git a/SOURCES/kvm-hda-codec-disable-streams-on-reset.patch b/SOURCES/kvm-hda-codec-disable-streams-on-reset.patch new file mode 100644 index 0000000..d0c0a24 --- /dev/null +++ b/SOURCES/kvm-hda-codec-disable-streams-on-reset.patch @@ -0,0 +1,77 @@ +From 22f1816abcb97b9df9f0c7b896202a4c3c5d89ec Mon Sep 17 00:00:00 2001 +From: Gerd Hoffmann +Date: Mon, 3 Feb 2014 14:18:24 -0500 +Subject: [PATCH 4/6] hda-codec: disable streams on reset + +Message-id: <1391437104-22283-2-git-send-email-kraxel@redhat.com> +Patchwork-id: 57073 +O-Subject: [RHEL-7 qemu-kvm PATCH 1/1] hda-codec: disable streams on reset +Bugzilla: 947812 +RH-Acked-by: Markus Armbruster +RH-Acked-by: Laszlo Ersek +RH-Acked-by: Bandan Das + +Signed-off-by: Gerd Hoffmann +(cherry picked from commit 39e6a38cdd4b235b2918b4977f31fde2c0da3bc4) +--- + hw/audio/hda-codec.c | 18 ++++++++++++++++++ + 1 file changed, 18 insertions(+) + +Signed-off-by: Miroslav Rezanina +--- + hw/audio/hda-codec.c | 18 ++++++++++++++++++ + 1 file changed, 18 insertions(+) + +diff --git a/hw/audio/hda-codec.c b/hw/audio/hda-codec.c +index 07a43bf..986f2a9 100644 +--- a/hw/audio/hda-codec.c ++++ b/hw/audio/hda-codec.c +@@ -559,6 +559,21 @@ static int hda_audio_post_load(void *opaque, int version) + return 0; + } + ++static void hda_audio_reset(DeviceState *dev) ++{ ++ HDAAudioState *a = DO_UPCAST(HDAAudioState, hda.qdev, dev); ++ HDAAudioStream *st; ++ int i; ++ ++ dprint(a, 1, "%s\n", __func__); ++ for (i = 0; i < ARRAY_SIZE(a->st); i++) { ++ st = a->st + i; ++ if (st->node != NULL) { ++ hda_audio_set_running(st, false); ++ } ++ } ++} ++ + static const VMStateDescription vmstate_hda_audio_stream = { + .name = "hda-audio-stream", + .version_id = 1, +@@ -640,6 +655,7 @@ static void hda_audio_output_class_init(ObjectClass *klass, void *data) + k->stream = hda_audio_stream; + set_bit(DEVICE_CATEGORY_SOUND, dc->categories); + dc->desc = "HDA Audio Codec, output-only (line-out)"; ++ dc->reset = hda_audio_reset; + dc->vmsd = &vmstate_hda_audio; + dc->props = hda_audio_properties; + } +@@ -662,6 +678,7 @@ static void hda_audio_duplex_class_init(ObjectClass *klass, void *data) + k->stream = hda_audio_stream; + set_bit(DEVICE_CATEGORY_SOUND, dc->categories); + dc->desc = "HDA Audio Codec, duplex (line-out, line-in)"; ++ dc->reset = hda_audio_reset; + dc->vmsd = &vmstate_hda_audio; + dc->props = hda_audio_properties; + } +@@ -684,6 +701,7 @@ static void hda_audio_micro_class_init(ObjectClass *klass, void *data) + k->stream = hda_audio_stream; + set_bit(DEVICE_CATEGORY_SOUND, dc->categories); + dc->desc = "HDA Audio Codec, duplex (speaker, microphone)"; ++ dc->reset = hda_audio_reset; + dc->vmsd = &vmstate_hda_audio; + dc->props = hda_audio_properties; + } +-- +1.8.3.1 + diff --git a/SOURCES/kvm-help-add-id-suboption-to-iscsi.patch b/SOURCES/kvm-help-add-id-suboption-to-iscsi.patch new file mode 100644 index 0000000..f85748c --- /dev/null +++ b/SOURCES/kvm-help-add-id-suboption-to-iscsi.patch @@ -0,0 +1,47 @@ +From 066f23689bf4b417bf82895aa37d8d5a00e704bf Mon Sep 17 00:00:00 2001 +From: Paolo Bonzini +Date: Mon, 20 Jan 2014 12:49:35 +0100 +Subject: [PATCH 1/4] help: add id suboption to -iscsi + +RH-Author: Paolo Bonzini +Message-id: <1390222175-24815-1-git-send-email-pbonzini@redhat.com> +Patchwork-id: 56830 +O-Subject: [RHEL 7.0 qemu-kvm PATCH] help: add id suboption to -iscsi +Bugzilla: 1019221 +RH-Acked-by: Markus Armbruster +RH-Acked-by: Amos Kong +RH-Acked-by: Miroslav Rezanina + +Bugzilla: 1019221 + +Brew build: 6896455 + +Signed-off-by: Paolo Bonzini +(cherry picked from commit 2fe3798cd5fab65ee7c86758b1b7701d7fe3709f) +--- + As requested by QE. + + qemu-options.hx | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +Signed-off-by: Miroslav Rezanina +--- + qemu-options.hx | 2 +- + 1 files changed, 1 insertions(+), 1 deletions(-) + +diff --git a/qemu-options.hx b/qemu-options.hx +index 49b4bc2..1f2bb57 100644 +--- a/qemu-options.hx ++++ b/qemu-options.hx +@@ -2073,7 +2073,7 @@ ETEXI + DEF("iscsi", HAS_ARG, QEMU_OPTION_iscsi, + "-iscsi [user=user][,password=password]\n" + " [,header-digest=CRC32C|CR32C-NONE|NONE-CRC32C|NONE\n" +- " [,initiator-name=iqn]\n" ++ " [,initiator-name=initiator-iqn][,id=target-iqn]\n" + " iSCSI session parameters\n", QEMU_ARCH_ALL) + STEXI + +-- +1.7.1 + diff --git a/SOURCES/kvm-hpet-add-API-to-find-it.patch b/SOURCES/kvm-hpet-add-API-to-find-it.patch new file mode 100644 index 0000000..19fcada --- /dev/null +++ b/SOURCES/kvm-hpet-add-API-to-find-it.patch @@ -0,0 +1,67 @@ +From be90d9992517cf1247bcce2f0ddae2ddf8e75291 Mon Sep 17 00:00:00 2001 +Message-Id: +In-Reply-To: <3ed0fb61a3dc912ef036d7ef450bed192090709e.1387298827.git.minovotn@redhat.com> +References: <3ed0fb61a3dc912ef036d7ef450bed192090709e.1387298827.git.minovotn@redhat.com> +From: "Michael S. Tsirkin" +Date: Tue, 17 Dec 2013 15:18:57 +0100 +Subject: [PATCH 44/56] hpet: add API to find it + +RH-Author: Michael S. Tsirkin +Message-id: <1387293161-4085-45-git-send-email-mst@redhat.com> +Patchwork-id: 56350 +O-Subject: [PATCH qemu-kvm RHEL7.0 v2 44/57] hpet: add API to find it +Bugzilla: 1034876 +RH-Acked-by: Igor Mammedov +RH-Acked-by: Marcel Apfelbaum +RH-Acked-by: Laszlo Ersek +RH-Acked-by: Orit Wasserman + +Add API to find HPET using QOM. + +Reviewed-by: Gerd Hoffmann +Tested-by: Gerd Hoffmann +Reviewed-by: Igor Mammedov +Tested-by: Igor Mammedov +Signed-off-by: Michael S. Tsirkin +(cherry picked from commit 64e9df8d34e493e59c1920358257a7576a560a1a) +--- + include/hw/timer/hpet.h | 2 ++ + hw/timer/hpet.c | 5 +++++ + 2 files changed, 7 insertions(+) + +Signed-off-by: Michal Novotny +--- + hw/timer/hpet.c | 5 +++++ + include/hw/timer/hpet.h | 2 ++ + 2 files changed, 7 insertions(+) + +diff --git a/hw/timer/hpet.c b/hw/timer/hpet.c +index dd486a1..8c26851 100644 +--- a/hw/timer/hpet.c ++++ b/hw/timer/hpet.c +@@ -744,6 +744,11 @@ static void hpet_device_class_init(ObjectClass *klass, void *data) + dc->props = hpet_device_properties; + } + ++bool hpet_find(void) ++{ ++ return object_resolve_path_type("", "hpet", NULL); ++} ++ + static const TypeInfo hpet_device_info = { + .name = "hpet", + .parent = TYPE_SYS_BUS_DEVICE, +diff --git a/include/hw/timer/hpet.h b/include/hw/timer/hpet.h +index 757f79f..ab44bd3 100644 +--- a/include/hw/timer/hpet.h ++++ b/include/hw/timer/hpet.h +@@ -71,4 +71,6 @@ struct hpet_fw_config + } QEMU_PACKED; + + extern struct hpet_fw_config hpet_cfg; ++ ++bool hpet_find(void); + #endif +-- +1.7.11.7 + diff --git a/SOURCES/kvm-hpet-fix-build-with-CONFIG_HPET-off.patch b/SOURCES/kvm-hpet-fix-build-with-CONFIG_HPET-off.patch new file mode 100644 index 0000000..d0be925 --- /dev/null +++ b/SOURCES/kvm-hpet-fix-build-with-CONFIG_HPET-off.patch @@ -0,0 +1,83 @@ +From b166f0998eba97144034f39382e2e90339f4c5b1 Mon Sep 17 00:00:00 2001 +Message-Id: +In-Reply-To: <3ed0fb61a3dc912ef036d7ef450bed192090709e.1387298827.git.minovotn@redhat.com> +References: <3ed0fb61a3dc912ef036d7ef450bed192090709e.1387298827.git.minovotn@redhat.com> +From: "Michael S. Tsirkin" +Date: Tue, 17 Dec 2013 15:18:59 +0100 +Subject: [PATCH 45/56] hpet: fix build with CONFIG_HPET off + +RH-Author: Michael S. Tsirkin +Message-id: <1387293161-4085-46-git-send-email-mst@redhat.com> +Patchwork-id: 56351 +O-Subject: [PATCH qemu-kvm RHEL7.0 v2 45/57] hpet: fix build with CONFIG_HPET off +Bugzilla: 1034876 +RH-Acked-by: Igor Mammedov +RH-Acked-by: Marcel Apfelbaum +RH-Acked-by: Laszlo Ersek +RH-Acked-by: Orit Wasserman + +make hpet_find inline so we don't need +to build hpet.c to check if hpet is enabled. + +Fixes link error with CONFIG_HPET off. + +Cc: qemu-stable@nongnu.org +Signed-off-by: Michael S. Tsirkin + +Upstream status: posted +--- + include/hw/timer/hpet.h | 10 +++++++++- + hw/timer/hpet.c | 5 ----- + 2 files changed, 9 insertions(+), 6 deletions(-) + +Signed-off-by: Michal Novotny +--- + hw/timer/hpet.c | 5 ----- + include/hw/timer/hpet.h | 10 +++++++++- + 2 files changed, 9 insertions(+), 6 deletions(-) + +diff --git a/hw/timer/hpet.c b/hw/timer/hpet.c +index 8c26851..dd486a1 100644 +--- a/hw/timer/hpet.c ++++ b/hw/timer/hpet.c +@@ -744,11 +744,6 @@ static void hpet_device_class_init(ObjectClass *klass, void *data) + dc->props = hpet_device_properties; + } + +-bool hpet_find(void) +-{ +- return object_resolve_path_type("", "hpet", NULL); +-} +- + static const TypeInfo hpet_device_info = { + .name = "hpet", + .parent = TYPE_SYS_BUS_DEVICE, +diff --git a/include/hw/timer/hpet.h b/include/hw/timer/hpet.h +index ab44bd3..773953b 100644 +--- a/include/hw/timer/hpet.h ++++ b/include/hw/timer/hpet.h +@@ -13,6 +13,8 @@ + #ifndef QEMU_HPET_EMUL_H + #define QEMU_HPET_EMUL_H + ++#include "qom/object.h" ++ + #define HPET_BASE 0xfed00000 + #define HPET_CLK_PERIOD 10000000ULL /* 10000000 femtoseconds == 10ns*/ + +@@ -72,5 +74,11 @@ struct hpet_fw_config + + extern struct hpet_fw_config hpet_cfg; + +-bool hpet_find(void); ++#define TYPE_HPET "hpet" ++ ++static inline bool hpet_find(void) ++{ ++ return object_resolve_path_type("", TYPE_HPET, NULL); ++} ++ + #endif +-- +1.7.11.7 + diff --git a/SOURCES/kvm-hw-cannot_instantiate_with_device_add_yet-due-to-poi.patch b/SOURCES/kvm-hw-cannot_instantiate_with_device_add_yet-due-to-poi.patch new file mode 100644 index 0000000..6199ec5 --- /dev/null +++ b/SOURCES/kvm-hw-cannot_instantiate_with_device_add_yet-due-to-poi.patch @@ -0,0 +1,221 @@ +From 8aa43c6e4e8def26812cb435b9f3c3146488e3bd Mon Sep 17 00:00:00 2001 +From: Markus Armbruster +Date: Thu, 16 Jan 2014 15:25:18 -0500 +Subject: [PATCH 12/14] hw: cannot_instantiate_with_device_add_yet due to + pointer props +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +Message-id: <1389885919-16158-2-git-send-email-armbru@redhat.com> +Patchwork-id: 56750 +O-Subject: [PATCH 7.0 qemu-kvm 1/2] hw: cannot_instantiate_with_device_add_yet due to pointer props +Bugzilla: 1031098 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Laszlo Ersek +RH-Acked-by: Miroslav Rezanina + +Pointer properties can be set only by code, not by device_add. A +device with a pointer property can work with device_add only when the +property may remain null. + +This is the case for property "interrupt_vector" of device +"etraxfs,pic". Add a comment there. + +Set cannot_instantiate_with_device_add_yet for the other devices with +pointer properties, with a comment explaining why. + +Juha Riihimäki and Peter Maydell deserve my thanks for making "pointer +property must not remain null" blatantly obvious in the OMAP devices. + +Only device "smbus-eeprom" is actually changed. The others are all +sysbus devices, which get cannot_instantiate_with_device_add_yet set +in their abstract base's class init function. Setting it again in +their class init function is technically redundant, but serves as +insurance for when sysbus devices become available with device_add, +and as documentation. + +Signed-off-by: Markus Armbruster +Reviewed-by: Edgar E. Iglesias (for ETRAX) +Signed-off-by: Andreas Färber +(cherry picked from commit 1b111dc1216be2a89770fdc1ab3dfa8025957442) +--- + hw/audio/marvell_88w8618.c | 2 ++ + hw/dma/sparc32_dma.c | 2 ++ + hw/gpio/omap_gpio.c | 4 ++++ + hw/i2c/omap_i2c.c | 2 ++ + hw/i2c/smbus_eeprom.c | 2 ++ + hw/intc/etraxfs_pic.c | 4 ++++ + hw/intc/grlib_irqmp.c | 2 ++ + hw/intc/omap_intc.c | 4 ++++ + hw/net/etraxfs_eth.c | 2 ++ + hw/net/lance.c | 2 ++ + 10 files changed, 26 insertions(+) + +Signed-off-by: Miroslav Rezanina +--- + hw/audio/marvell_88w8618.c | 2 ++ + hw/dma/sparc32_dma.c | 2 ++ + hw/gpio/omap_gpio.c | 4 ++++ + hw/i2c/omap_i2c.c | 2 ++ + hw/i2c/smbus_eeprom.c | 2 ++ + hw/intc/etraxfs_pic.c | 4 ++++ + hw/intc/grlib_irqmp.c | 2 ++ + hw/intc/omap_intc.c | 4 ++++ + hw/net/etraxfs_eth.c | 2 ++ + hw/net/lance.c | 2 ++ + 10 files changed, 26 insertions(+) + +diff --git a/hw/audio/marvell_88w8618.c b/hw/audio/marvell_88w8618.c +index de06dfd..4f7196a 100644 +--- a/hw/audio/marvell_88w8618.c ++++ b/hw/audio/marvell_88w8618.c +@@ -285,6 +285,8 @@ static void mv88w8618_audio_class_init(ObjectClass *klass, void *data) + dc->reset = mv88w8618_audio_reset; + dc->vmsd = &mv88w8618_audio_vmsd; + dc->props = mv88w8618_audio_properties; ++ /* Reason: pointer property "wm8750" */ ++ dc->cannot_instantiate_with_device_add_yet = true; + } + + static const TypeInfo mv88w8618_audio_info = { +diff --git a/hw/dma/sparc32_dma.c b/hw/dma/sparc32_dma.c +index fd21533..c866da7 100644 +--- a/hw/dma/sparc32_dma.c ++++ b/hw/dma/sparc32_dma.c +@@ -298,6 +298,8 @@ static void sparc32_dma_class_init(ObjectClass *klass, void *data) + dc->reset = dma_reset; + dc->vmsd = &vmstate_dma; + dc->props = sparc32_dma_properties; ++ /* Reason: pointer property "iommu_opaque" */ ++ dc->cannot_instantiate_with_device_add_yet = true; + } + + static const TypeInfo sparc32_dma_info = { +diff --git a/hw/gpio/omap_gpio.c b/hw/gpio/omap_gpio.c +index f5eeaea..3f423dd 100644 +--- a/hw/gpio/omap_gpio.c ++++ b/hw/gpio/omap_gpio.c +@@ -745,6 +745,8 @@ static void omap_gpio_class_init(ObjectClass *klass, void *data) + k->init = omap_gpio_init; + dc->reset = omap_gpif_reset; + dc->props = omap_gpio_properties; ++ /* Reason: pointer property "clk" */ ++ dc->cannot_instantiate_with_device_add_yet = true; + } + + static const TypeInfo omap_gpio_info = { +@@ -774,6 +776,8 @@ static void omap2_gpio_class_init(ObjectClass *klass, void *data) + k->init = omap2_gpio_init; + dc->reset = omap2_gpif_reset; + dc->props = omap2_gpio_properties; ++ /* Reason: pointer properties "iclk", "fclk0", ..., "fclk5" */ ++ dc->cannot_instantiate_with_device_add_yet = true; + } + + static const TypeInfo omap2_gpio_info = { +diff --git a/hw/i2c/omap_i2c.c b/hw/i2c/omap_i2c.c +index efb2254..464308e 100644 +--- a/hw/i2c/omap_i2c.c ++++ b/hw/i2c/omap_i2c.c +@@ -469,6 +469,8 @@ static void omap_i2c_class_init(ObjectClass *klass, void *data) + k->init = omap_i2c_init; + dc->props = omap_i2c_properties; + dc->reset = omap_i2c_reset; ++ /* Reason: pointer properties "iclk", "fclk" */ ++ dc->cannot_instantiate_with_device_add_yet = true; + } + + static const TypeInfo omap_i2c_info = { +diff --git a/hw/i2c/smbus_eeprom.c b/hw/i2c/smbus_eeprom.c +index 0154283..0218f8a 100644 +--- a/hw/i2c/smbus_eeprom.c ++++ b/hw/i2c/smbus_eeprom.c +@@ -121,6 +121,8 @@ static void smbus_eeprom_class_initfn(ObjectClass *klass, void *data) + sc->write_data = eeprom_write_data; + sc->read_data = eeprom_read_data; + dc->props = smbus_eeprom_properties; ++ /* Reason: pointer property "data" */ ++ dc->cannot_instantiate_with_device_add_yet = true; + } + + static const TypeInfo smbus_eeprom_info = { +diff --git a/hw/intc/etraxfs_pic.c b/hw/intc/etraxfs_pic.c +index 635103c..57650c4 100644 +--- a/hw/intc/etraxfs_pic.c ++++ b/hw/intc/etraxfs_pic.c +@@ -163,6 +163,10 @@ static void etraxfs_pic_class_init(ObjectClass *klass, void *data) + + k->init = etraxfs_pic_init; + dc->props = etraxfs_pic_properties; ++ /* ++ * Note: pointer property "interrupt_vector" may remain null, thus ++ * no need for dc->cannot_instantiate_with_device_add_yet = true; ++ */ + } + + static const TypeInfo etraxfs_pic_info = { +diff --git a/hw/intc/grlib_irqmp.c b/hw/intc/grlib_irqmp.c +index 68dfe6a..1cfa960 100644 +--- a/hw/intc/grlib_irqmp.c ++++ b/hw/intc/grlib_irqmp.c +@@ -368,6 +368,8 @@ static void grlib_irqmp_class_init(ObjectClass *klass, void *data) + k->init = grlib_irqmp_init; + dc->reset = grlib_irqmp_reset; + dc->props = grlib_irqmp_properties; ++ /* Reason: pointer properties "set_pil_in", "set_pil_in_opaque" */ ++ dc->cannot_instantiate_with_device_add_yet = true; + } + + static const TypeInfo grlib_irqmp_info = { +diff --git a/hw/intc/omap_intc.c b/hw/intc/omap_intc.c +index 875eba4..e846fd6 100644 +--- a/hw/intc/omap_intc.c ++++ b/hw/intc/omap_intc.c +@@ -387,6 +387,8 @@ static void omap_intc_class_init(ObjectClass *klass, void *data) + k->init = omap_intc_init; + dc->reset = omap_inth_reset; + dc->props = omap_intc_properties; ++ /* Reason: pointer property "clk" */ ++ dc->cannot_instantiate_with_device_add_yet = true; + } + + static const TypeInfo omap_intc_info = { +@@ -631,6 +633,8 @@ static void omap2_intc_class_init(ObjectClass *klass, void *data) + k->init = omap2_intc_init; + dc->reset = omap_inth_reset; + dc->props = omap2_intc_properties; ++ /* Reason: pointer property "iclk", "fclk" */ ++ dc->cannot_instantiate_with_device_add_yet = true; + } + + static const TypeInfo omap2_intc_info = { +diff --git a/hw/net/etraxfs_eth.c b/hw/net/etraxfs_eth.c +index 1039913..374eb5a 100644 +--- a/hw/net/etraxfs_eth.c ++++ b/hw/net/etraxfs_eth.c +@@ -639,6 +639,8 @@ static void etraxfs_eth_class_init(ObjectClass *klass, void *data) + + k->init = fs_eth_init; + dc->props = etraxfs_eth_properties; ++ /* Reason: pointer properties "dma_out", "dma_in" */ ++ dc->cannot_instantiate_with_device_add_yet = true; + } + + static const TypeInfo etraxfs_eth_info = { +diff --git a/hw/net/lance.c b/hw/net/lance.c +index 90641e7..df62dcb 100644 +--- a/hw/net/lance.c ++++ b/hw/net/lance.c +@@ -154,6 +154,8 @@ static void lance_class_init(ObjectClass *klass, void *data) + dc->reset = lance_reset; + dc->vmsd = &vmstate_lance; + dc->props = lance_properties; ++ /* Reason: pointer property "dma" */ ++ dc->cannot_instantiate_with_device_add_yet = true; + } + + static const TypeInfo lance_info = { +-- +1.8.3.1 + diff --git a/SOURCES/kvm-hw-i386-Makefile.obj-use-PYTHON-to-run-.py-scripts-c.patch b/SOURCES/kvm-hw-i386-Makefile.obj-use-PYTHON-to-run-.py-scripts-c.patch new file mode 100644 index 0000000..fe1df66 --- /dev/null +++ b/SOURCES/kvm-hw-i386-Makefile.obj-use-PYTHON-to-run-.py-scripts-c.patch @@ -0,0 +1,38 @@ +From 091eecc4fa42754760dfff393dabcc2b444e9693 Mon Sep 17 00:00:00 2001 +Message-Id: <091eecc4fa42754760dfff393dabcc2b444e9693.1387369730.git.minovotn@redhat.com> +From: Michael Tokarev +Date: Tue, 17 Dec 2013 17:19:32 +0200 +Subject: [PATCH 01/21] hw/i386/Makefile.obj: use $(PYTHON) to run .py scripts + consistently + +$(PYTHON) is a Make variable which is set by configure. +In all other places over the tree, .py files are run from +Makefiles using this variable, except of a single leftover +in hw/i386/Makefile.obj (and a nearby place in there uses +$(PYTHON) correctly). Fix this leftover too. + +Signed-off-by: Michael Tokarev +Cc: Luigi Rizzo +Reviewed-by:: Stefan Weil +(cherry picked from commit 0478f37ce258438d74164dd182b0ae125f174ec6) +Signed-off-by: Michal Novotny +--- + hw/i386/Makefile.objs | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/hw/i386/Makefile.objs b/hw/i386/Makefile.objs +index 6754fd5..6a17cf8 100644 +--- a/hw/i386/Makefile.objs ++++ b/hw/i386/Makefile.objs +@@ -19,7 +19,7 @@ hw/i386/%.hex: $(SRC_PATH)/hw/i386/%.dsl $(SRC_PATH)/scripts/acpi_extract_prepro + $(call quiet-command, cpp -P $< -o $*.dsl.i.orig, " CPP $(TARGET_DIR)$*.dsl.i.orig") + $(call quiet-command, $(PYTHON) $(SRC_PATH)/scripts/acpi_extract_preprocess.py $*.dsl.i.orig > $*.dsl.i, " ACPI_PREPROCESS $(TARGET_DIR)$*.dsl.i") + $(call quiet-command, $(IASL) $(call iasl-option,$(IASL),-Pn,) -vs -l -tc -p $* $*.dsl.i $(if $(V), , > /dev/null) 2>&1 ," IASL $(TARGET_DIR)$*.dsl.i") +- $(call quiet-command, $(SRC_PATH)/scripts/acpi_extract.py $*.lst > $*.off, " ACPI_EXTRACT $(TARGET_DIR)$*.off") ++ $(call quiet-command, $(PYTHON) $(SRC_PATH)/scripts/acpi_extract.py $*.lst > $*.off, " ACPI_EXTRACT $(TARGET_DIR)$*.off") + $(call quiet-command, cat $*.off > $@, " CAT $(TARGET_DIR)$@") + else + #IASL Not present. Restore pre-generated hex files. +-- +1.7.11.7 + diff --git a/SOURCES/kvm-hw-i386-pc_sysfw-support-two-flash-drives.patch b/SOURCES/kvm-hw-i386-pc_sysfw-support-two-flash-drives.patch new file mode 100644 index 0000000..38b6ae1 --- /dev/null +++ b/SOURCES/kvm-hw-i386-pc_sysfw-support-two-flash-drives.patch @@ -0,0 +1,192 @@ +From e1fb6e4160e9d9eb1c7b01ea4b5b3a94c953c379 Mon Sep 17 00:00:00 2001 +From: Laszlo Ersek +Date: Sat, 11 Jan 2014 18:00:03 +0100 +Subject: [PATCH 13/22] hw/i386/pc_sysfw: support two flash drives + +RH-Author: Laszlo Ersek +Message-id: <1389463208-6278-14-git-send-email-lersek@redhat.com> +Patchwork-id: 56626 +O-Subject: [RHEL-7.0 qemu-kvm PATCH 13/18] hw/i386/pc_sysfw: support two flash drives +Bugzilla: 1032346 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Amos Kong +RH-Acked-by: Andrew Jones + +This patch allows the user to usefully specify + + -drive file=img_1,if=pflash,format=raw,readonly \ + -drive file=img_2,if=pflash,format=raw + +on the command line. The flash images will be mapped under 4G in their +reverse unit order -- that is, with their base addresses progressing +downwards, in increasing unit order. + +(The unit number increases with command line order if not explicitly +specified.) + +This accommodates the following use case: suppose that OVMF is split in +two parts, a writeable host file for non-volatile variable storage, and a +read-only part for bootstrap and decompressible executable code. + +The binary code part would be read-only, centrally managed on the host +system, and passed in as unit 0. The variable store would be writeable, +VM-specific, and passed in as unit 1. + + 00000000ffe00000-00000000ffe1ffff (prio 0, R-): system.flash1 + 00000000ffe20000-00000000ffffffff (prio 0, R-): system.flash0 + +(If the guest tries to write to the flash range that is backed by the +read-only drive, pflash_update() is never called; various flash +programming/erase errors are returned to the guest instead. See the +callers of pflash_update(), and the initialization of "pfl->ro", in +"hw/block/pflash_cfi01.c".) + +Signed-off-by: Laszlo Ersek +Reviewed-by: Markus Armbruster +Reviewed-by: Michael S. Tsirkin +Signed-off-by: Michael S. Tsirkin +(cherry picked from commit 637a5acb46b36a25b506ba6545e9a53350585b03) +--- + hw/i386/pc_sysfw.c | 105 +++++++++++++++++++++++++++++++++++++++++++---------- + 1 file changed, 86 insertions(+), 19 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + hw/i386/pc_sysfw.c | 105 ++++++++++++++++++++++++++++++++++++++++++--------- + 1 files changed, 86 insertions(+), 19 deletions(-) + +diff --git a/hw/i386/pc_sysfw.c b/hw/i386/pc_sysfw.c +index eb56dee..6f5ecde 100644 +--- a/hw/i386/pc_sysfw.c ++++ b/hw/i386/pc_sysfw.c +@@ -72,35 +72,102 @@ static void pc_isa_bios_init(MemoryRegion *rom_memory, + memory_region_set_readonly(isa_bios, true); + } + +-static void pc_system_flash_init(MemoryRegion *rom_memory, +- DriveInfo *pflash_drv) ++#define FLASH_MAP_UNIT_MAX 2 ++ ++/* We don't have a theoretically justifiable exact lower bound on the base ++ * address of any flash mapping. In practice, the IO-APIC MMIO range is ++ * [0xFEE00000..0xFEE01000[ -- see IO_APIC_DEFAULT_ADDRESS --, leaving free ++ * only 18MB-4KB below 4G. For now, restrict the cumulative mapping to 8MB in ++ * size. ++ */ ++#define FLASH_MAP_BASE_MIN ((hwaddr)(0x100000000ULL - 8*1024*1024)) ++ ++/* This function maps flash drives from 4G downward, in order of their unit ++ * numbers. The mapping starts at unit#0, with unit number increments of 1, and ++ * stops before the first missing flash drive, or before ++ * unit#FLASH_MAP_UNIT_MAX, whichever is reached first. ++ * ++ * Addressing within one flash drive is of course not reversed. ++ * ++ * An error message is printed and the process exits if: ++ * - the size of the backing file for a flash drive is non-positive, or not a ++ * multiple of the required sector size, or ++ * - the current mapping's base address would fall below FLASH_MAP_BASE_MIN. ++ * ++ * The drive with unit#0 (if available) is mapped at the highest address, and ++ * it is passed to pc_isa_bios_init(). Merging several drives for isa-bios is ++ * not supported. ++ */ ++static void pc_system_flash_init(MemoryRegion *rom_memory) + { ++ int unit; ++ DriveInfo *pflash_drv; + BlockDriverState *bdrv; + int64_t size; +- hwaddr phys_addr; ++ char *fatal_errmsg = NULL; ++ hwaddr phys_addr = 0x100000000ULL; + int sector_bits, sector_size; + pflash_t *system_flash; + MemoryRegion *flash_mem; ++ char name[64]; + +- bdrv = pflash_drv->bdrv; +- size = bdrv_getlength(pflash_drv->bdrv); + sector_bits = 12; + sector_size = 1 << sector_bits; + +- if ((size % sector_size) != 0) { +- fprintf(stderr, +- "qemu: PC system firmware (pflash) must be a multiple of 0x%x\n", +- sector_size); +- exit(1); ++ for (unit = 0; ++ (unit < FLASH_MAP_UNIT_MAX && ++ (pflash_drv = drive_get(IF_PFLASH, 0, unit)) != NULL); ++ ++unit) { ++ bdrv = pflash_drv->bdrv; ++ size = bdrv_getlength(bdrv); ++ if (size < 0) { ++ fatal_errmsg = g_strdup_printf("failed to get backing file size"); ++ } else if (size == 0) { ++ fatal_errmsg = g_strdup_printf("PC system firmware (pflash) " ++ "cannot have zero size"); ++ } else if ((size % sector_size) != 0) { ++ fatal_errmsg = g_strdup_printf("PC system firmware (pflash) " ++ "must be a multiple of 0x%x", sector_size); ++ } else if (phys_addr < size || phys_addr - size < FLASH_MAP_BASE_MIN) { ++ fatal_errmsg = g_strdup_printf("oversized backing file, pflash " ++ "segments cannot be mapped under " ++ TARGET_FMT_plx, FLASH_MAP_BASE_MIN); ++ } ++ if (fatal_errmsg != NULL) { ++ Location loc; ++ ++ /* push a new, "none" location on the location stack; overwrite its ++ * contents with the location saved in the option; print the error ++ * (includes location); pop the top ++ */ ++ loc_push_none(&loc); ++ if (pflash_drv->opts != NULL) { ++ qemu_opts_loc_restore(pflash_drv->opts); ++ } ++ error_report("%s", fatal_errmsg); ++ loc_pop(&loc); ++ g_free(fatal_errmsg); ++ exit(1); ++ } ++ ++ phys_addr -= size; ++ ++ /* pflash_cfi01_register() creates a deep copy of the name */ ++ snprintf(name, sizeof name, "system.flash%d", unit); ++ system_flash = pflash_cfi01_register(phys_addr, NULL /* qdev */, name, ++ size, bdrv, sector_size, ++ size >> sector_bits, ++ 1 /* width */, ++ 0x0000 /* id0 */, ++ 0x0000 /* id1 */, ++ 0x0000 /* id2 */, ++ 0x0000 /* id3 */, ++ 0 /* be */); ++ if (unit == 0) { ++ flash_mem = pflash_cfi01_get_memory(system_flash); ++ pc_isa_bios_init(rom_memory, flash_mem, size); ++ } + } +- +- phys_addr = 0x100000000ULL - size; +- system_flash = pflash_cfi01_register(phys_addr, NULL, "system.flash", size, +- bdrv, sector_size, size >> sector_bits, +- 1, 0x0000, 0x0000, 0x0000, 0x0000, 0); +- flash_mem = pflash_cfi01_get_memory(system_flash); +- +- pc_isa_bios_init(rom_memory, flash_mem, size); + } + + static void old_pc_system_rom_init(MemoryRegion *rom_memory, bool isapc_ram_fw) +@@ -181,5 +248,5 @@ void pc_system_firmware_init(MemoryRegion *rom_memory, bool isapc_ram_fw) + exit(1); + } + +- pc_system_flash_init(rom_memory, pflash_drv); ++ pc_system_flash_init(rom_memory); + } +-- +1.7.1 + diff --git a/SOURCES/kvm-i386-ACPI-table-generation-code-from-seabios.patch b/SOURCES/kvm-i386-ACPI-table-generation-code-from-seabios.patch new file mode 100644 index 0000000..957647b --- /dev/null +++ b/SOURCES/kvm-i386-ACPI-table-generation-code-from-seabios.patch @@ -0,0 +1,1823 @@ +From b451ecc8fa5bb1283a1dddc20057282676ad2593 Mon Sep 17 00:00:00 2001 +Message-Id: +In-Reply-To: <3ed0fb61a3dc912ef036d7ef450bed192090709e.1387298827.git.minovotn@redhat.com> +References: <3ed0fb61a3dc912ef036d7ef450bed192090709e.1387298827.git.minovotn@redhat.com> +From: "Michael S. Tsirkin" +Date: Tue, 17 Dec 2013 15:19:08 +0100 +Subject: [PATCH 48/56] i386: ACPI table generation code from seabios + +RH-Author: Michael S. Tsirkin +Message-id: <1387293161-4085-49-git-send-email-mst@redhat.com> +Patchwork-id: 56354 +O-Subject: [PATCH qemu-kvm RHEL7.0 v2 48/57] i386: ACPI table generation code from seabios +Bugzilla: 1034876 +RH-Acked-by: Igor Mammedov +RH-Acked-by: Marcel Apfelbaum +RH-Acked-by: Laszlo Ersek + +This adds C code for generating ACPI tables at runtime, +imported from seabios git tree + commit 51684b7ced75fb76776e8ee84833fcfb6ecf12dd + +Although ACPI tables come from a system BIOS on real hw, +it makes sense that the ACPI tables are coupled with the +virtual machine, since they have to abstract the x86 machine to +the OS's. + +This is widely desired as a way to avoid the churn +and proliferation of QEMU-specific interfaces +associated with ACPI tables in bios code. + +Notes: +As BIOS can reprogram devices prior to loading +ACPI tables, we pre-format ACPI tables but defer loading +hardware configuration there until tables are loaded. + +The code structure was intentionally kept as close +to the seabios original as possible, to simplify +comparison and making sure we didn't lose anything +in translation. + +Minor code duplication results, to help ensure there are no functional +regressions, I think it's better to merge it like this and do more code +changes in follow-up patches. + +Cross-version compatibility concerns have been addressed: + ACPI tables are exposed to guest as FW_CFG entries. + When running with -M 1.5 and older, this patch disables ACPI + table generation, and doesn't expose ACPI + tables to guest. + + As table content is likely to change over time, + the following measures are taken to simplify + cross-version migration: + - All tables besides the RSDP are packed in a single FW CFG entry. + This entry size is currently 23K. We round it up to 64K + to avoid too much churn there. + - Tables are placed in special ROM blob (not mapped into guest memory) + which is automatically migrated together with the guest, same + as BIOS code. + - Offsets where hardware configuration is loaded in ACPI tables + are also migrated, this is in case future ACPI changes make us + rearrange the tables in memory. + +This patch reuses some code from SeaBIOS, which was originally under +LGPLv2 and then relicensed to GPLv3 or LGPLv3, in QEMU under GPLv2+. This +relicensing has been acked by all contributors that had contributed to the +code since the v2->v3 relicense. ACKs approving the v2+ relicensing are +listed below. The list might include ACKs from people not holding +copyright on any parts of the reused code, but it's better to err on the +side of caution and include them. + +Affected SeaBIOS files (GPLv2+ license headers added) +: + + src/acpi-dsdt-cpu-hotplug.dsl + src/acpi-dsdt-dbug.dsl + src/acpi-dsdt-hpet.dsl + src/acpi-dsdt-isa.dsl + src/acpi-dsdt-pci-crs.dsl + src/acpi.c + src/acpi.h + src/ssdt-misc.dsl + src/ssdt-pcihp.dsl + src/ssdt-proc.dsl + tools/acpi_extract.py + tools/acpi_extract_preprocess.py + +Each one of the listed people agreed to the following: + +> If you allow the use of your contribution in QEMU under the +> terms of GPLv2 or later as proposed by this patch, +> please respond to this mail including the line: +> +> Acked-by: Name + + Acked-by: Gerd Hoffmann + Acked-by: Jan Kiszka + Acked-by: Jason Baron + Acked-by: David Woodhouse + Acked-by: Gleb Natapov + Acked-by: Marcelo Tosatti + Acked-by: Dave Frodin + Acked-by: Paolo Bonzini + Acked-by: Kevin O'Connor + Acked-by: Laszlo Ersek + Acked-by: Kenji Kaneshige + Acked-by: Isaku Yamahata + Acked-by: Magnus Christensson + Acked-by: Hu Tao + Acked-by: Eduardo Habkost + +Reviewed-by: Gerd Hoffmann +Tested-by: Gerd Hoffmann +Reviewed-by: Igor Mammedov +Tested-by: Igor Mammedov +Signed-off-by: Michael S. Tsirkin +(cherry picked from commit 72c194f7e75cb64b2558111cb111adb49fbf4097) + +Conflicts: + hw/i386/pc_piix.c + hw/i386/pc_q35.c +--- + hw/i386/acpi-build.h | 9 + + hw/i386/acpi-defs.h | 331 ++++++++++++++ + include/hw/i386/pc.h | 1 + + hw/i386/acpi-build.c | 1214 +++++++++++++++++++++++++++++++++++++++++++++++++ + hw/i386/pc.c | 2 + + hw/i386/pc_piix.c | 5 + + hw/i386/pc_q35.c | 2 + + hw/i386/Makefile.objs | 4 + + 8 files changed, 1568 insertions(+) + create mode 100644 hw/i386/acpi-build.h + create mode 100644 hw/i386/acpi-defs.h + create mode 100644 hw/i386/acpi-build.c + +Signed-off-by: Michal Novotny +--- + hw/i386/Makefile.objs | 4 + + hw/i386/acpi-build.c | 1214 +++++++++++++++++++++++++++++++++++++++++++++++++ + hw/i386/acpi-build.h | 9 + + hw/i386/acpi-defs.h | 331 ++++++++++++++ + hw/i386/pc.c | 2 + + hw/i386/pc_piix.c | 5 + + hw/i386/pc_q35.c | 2 + + include/hw/i386/pc.h | 1 + + 8 files changed, 1568 insertions(+) + create mode 100644 hw/i386/acpi-build.c + create mode 100644 hw/i386/acpi-build.h + create mode 100644 hw/i386/acpi-defs.h + +diff --git a/hw/i386/Makefile.objs b/hw/i386/Makefile.objs +index 71be2da..6754fd5 100644 +--- a/hw/i386/Makefile.objs ++++ b/hw/i386/Makefile.objs +@@ -4,7 +4,11 @@ obj-y += pc.o pc_piix.o pc_q35.o + obj-$(CONFIG_XEN) += xen_domainbuild.o xen_machine_pv.o + + obj-y += kvmvapic.o ++obj-y += acpi-build.o + obj-y += bios-linker-loader.o ++hw/i386/acpi-build.o: hw/i386/acpi-build.c hw/i386/acpi-dsdt.hex \ ++ hw/i386/ssdt-proc.hex hw/i386/ssdt-pcihp.hex hw/i386/ssdt-misc.hex \ ++ hw/i386/acpi-dsdt.hex hw/i386/q35-acpi-dsdt.hex + + iasl-option=$(shell if test -z "`$(1) $(2) 2>&1 > /dev/null`" \ + ; then echo "$(2)"; else echo "$(3)"; fi ;) +diff --git a/hw/i386/acpi-build.c b/hw/i386/acpi-build.c +new file mode 100644 +index 0000000..6cfa044 +--- /dev/null ++++ b/hw/i386/acpi-build.c +@@ -0,0 +1,1214 @@ ++/* Support for generating ACPI tables and passing them to Guests ++ * ++ * Copyright (C) 2008-2010 Kevin O'Connor ++ * Copyright (C) 2006 Fabrice Bellard ++ * Copyright (C) 2013 Red Hat Inc ++ * ++ * Author: Michael S. Tsirkin ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 2 of the License, or ++ * (at your option) any later version. ++ ++ * This program is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ * GNU General Public License for more details. ++ ++ * You should have received a copy of the GNU General Public License along ++ * with this program; if not, see . ++ */ ++ ++#include "acpi-build.h" ++#include ++#include ++#include "qemu-common.h" ++#include "qemu/bitmap.h" ++#include "qemu/range.h" ++#include "hw/pci/pci.h" ++#include "qom/cpu.h" ++#include "hw/i386/pc.h" ++#include "target-i386/cpu.h" ++#include "hw/timer/hpet.h" ++#include "hw/i386/acpi-defs.h" ++#include "hw/acpi/acpi.h" ++#include "hw/nvram/fw_cfg.h" ++#include "bios-linker-loader.h" ++#include "hw/loader.h" ++ ++/* Supported chipsets: */ ++#include "hw/acpi/piix4.h" ++#include "hw/i386/ich9.h" ++#include "hw/pci/pci_bus.h" ++#include "hw/pci-host/q35.h" ++ ++#include "hw/i386/q35-acpi-dsdt.hex" ++#include "hw/i386/acpi-dsdt.hex" ++ ++#include "qapi/qmp/qint.h" ++#include "qom/qom-qobject.h" ++ ++typedef struct AcpiCpuInfo { ++ DECLARE_BITMAP(found_cpus, MAX_CPUMASK_BITS + 1); ++} AcpiCpuInfo; ++ ++typedef struct AcpiMcfgInfo { ++ uint64_t mcfg_base; ++ uint32_t mcfg_size; ++} AcpiMcfgInfo; ++ ++typedef struct AcpiPmInfo { ++ bool s3_disabled; ++ bool s4_disabled; ++ uint8_t s4_val; ++ uint16_t sci_int; ++ uint8_t acpi_enable_cmd; ++ uint8_t acpi_disable_cmd; ++ uint32_t gpe0_blk; ++ uint32_t gpe0_blk_len; ++ uint32_t io_base; ++} AcpiPmInfo; ++ ++typedef struct AcpiMiscInfo { ++ bool has_hpet; ++ DECLARE_BITMAP(slot_hotplug_enable, PCI_SLOT_MAX); ++ const unsigned char *dsdt_code; ++ unsigned dsdt_size; ++ uint16_t pvpanic_port; ++} AcpiMiscInfo; ++ ++static void acpi_get_dsdt(AcpiMiscInfo *info) ++{ ++ Object *piix = piix4_pm_find(); ++ Object *lpc = ich9_lpc_find(); ++ assert(!!piix != !!lpc); ++ ++ if (piix) { ++ info->dsdt_code = AcpiDsdtAmlCode; ++ info->dsdt_size = sizeof AcpiDsdtAmlCode; ++ } ++ if (lpc) { ++ info->dsdt_code = Q35AcpiDsdtAmlCode; ++ info->dsdt_size = sizeof Q35AcpiDsdtAmlCode; ++ } ++} ++ ++static ++int acpi_add_cpu_info(Object *o, void *opaque) ++{ ++ AcpiCpuInfo *cpu = opaque; ++ uint64_t apic_id; ++ ++ if (object_dynamic_cast(o, TYPE_CPU)) { ++ apic_id = object_property_get_int(o, "apic-id", NULL); ++ assert(apic_id <= MAX_CPUMASK_BITS); ++ ++ set_bit(apic_id, cpu->found_cpus); ++ } ++ ++ object_child_foreach(o, acpi_add_cpu_info, opaque); ++ return 0; ++} ++ ++static void acpi_get_cpu_info(AcpiCpuInfo *cpu) ++{ ++ Object *root = object_get_root(); ++ ++ memset(cpu->found_cpus, 0, sizeof cpu->found_cpus); ++ object_child_foreach(root, acpi_add_cpu_info, cpu); ++} ++ ++static void acpi_get_pm_info(AcpiPmInfo *pm) ++{ ++ Object *piix = piix4_pm_find(); ++ Object *lpc = ich9_lpc_find(); ++ Object *obj = NULL; ++ QObject *o; ++ ++ if (piix) { ++ obj = piix; ++ } ++ if (lpc) { ++ obj = lpc; ++ } ++ assert(obj); ++ ++ /* Fill in optional s3/s4 related properties */ ++ o = object_property_get_qobject(obj, ACPI_PM_PROP_S3_DISABLED, NULL); ++ if (o) { ++ pm->s3_disabled = qint_get_int(qobject_to_qint(o)); ++ } else { ++ pm->s3_disabled = false; ++ } ++ o = object_property_get_qobject(obj, ACPI_PM_PROP_S4_DISABLED, NULL); ++ if (o) { ++ pm->s4_disabled = qint_get_int(qobject_to_qint(o)); ++ } else { ++ pm->s4_disabled = false; ++ } ++ o = object_property_get_qobject(obj, ACPI_PM_PROP_S4_VAL, NULL); ++ if (o) { ++ pm->s4_val = qint_get_int(qobject_to_qint(o)); ++ } else { ++ pm->s4_val = false; ++ } ++ ++ /* Fill in mandatory properties */ ++ pm->sci_int = object_property_get_int(obj, ACPI_PM_PROP_SCI_INT, NULL); ++ ++ pm->acpi_enable_cmd = object_property_get_int(obj, ++ ACPI_PM_PROP_ACPI_ENABLE_CMD, ++ NULL); ++ pm->acpi_disable_cmd = object_property_get_int(obj, ++ ACPI_PM_PROP_ACPI_DISABLE_CMD, ++ NULL); ++ pm->io_base = object_property_get_int(obj, ACPI_PM_PROP_PM_IO_BASE, ++ NULL); ++ pm->gpe0_blk = object_property_get_int(obj, ACPI_PM_PROP_GPE0_BLK, ++ NULL); ++ pm->gpe0_blk_len = object_property_get_int(obj, ACPI_PM_PROP_GPE0_BLK_LEN, ++ NULL); ++} ++ ++static void acpi_get_hotplug_info(AcpiMiscInfo *misc) ++{ ++ int i; ++ PCIBus *bus = find_i440fx(); ++ ++ if (!bus) { ++ /* Only PIIX supports ACPI hotplug */ ++ memset(misc->slot_hotplug_enable, 0, sizeof misc->slot_hotplug_enable); ++ return; ++ } ++ ++ memset(misc->slot_hotplug_enable, 0xff, ++ DIV_ROUND_UP(PCI_SLOT_MAX, BITS_PER_BYTE)); ++ ++ for (i = 0; i < ARRAY_SIZE(bus->devices); ++i) { ++ PCIDeviceClass *pc; ++ PCIDevice *pdev = bus->devices[i]; ++ ++ if (!pdev) { ++ continue; ++ } ++ ++ pc = PCI_DEVICE_GET_CLASS(pdev); ++ ++ if (pc->no_hotplug) { ++ int slot = PCI_SLOT(i); ++ ++ clear_bit(slot, misc->slot_hotplug_enable); ++ } ++ } ++} ++ ++static void acpi_get_misc_info(AcpiMiscInfo *info) ++{ ++ info->has_hpet = hpet_find(); ++ info->pvpanic_port = pvpanic_port(); ++} ++ ++static void acpi_get_pci_info(PcPciInfo *info) ++{ ++ Object *pci_host; ++ bool ambiguous; ++ ++ pci_host = object_resolve_path_type("", TYPE_PCI_HOST_BRIDGE, &ambiguous); ++ g_assert(!ambiguous); ++ g_assert(pci_host); ++ ++ info->w32.begin = object_property_get_int(pci_host, ++ PCI_HOST_PROP_PCI_HOLE_START, ++ NULL); ++ info->w32.end = object_property_get_int(pci_host, ++ PCI_HOST_PROP_PCI_HOLE_END, ++ NULL); ++ info->w64.begin = object_property_get_int(pci_host, ++ PCI_HOST_PROP_PCI_HOLE64_START, ++ NULL); ++ info->w64.end = object_property_get_int(pci_host, ++ PCI_HOST_PROP_PCI_HOLE64_END, ++ NULL); ++} ++ ++#define ACPI_BUILD_APPNAME "Bochs" ++#define ACPI_BUILD_APPNAME6 "BOCHS " ++#define ACPI_BUILD_APPNAME4 "BXPC" ++ ++#define ACPI_BUILD_DPRINTF(level, fmt, ...) do {} while (0) ++ ++#define ACPI_BUILD_TABLE_FILE "etc/acpi/tables" ++#define ACPI_BUILD_RSDP_FILE "etc/acpi/rsdp" ++ ++static void ++build_header(GArray *linker, GArray *table_data, ++ AcpiTableHeader *h, uint32_t sig, int len, uint8_t rev) ++{ ++ h->signature = cpu_to_le32(sig); ++ h->length = cpu_to_le32(len); ++ h->revision = rev; ++ memcpy(h->oem_id, ACPI_BUILD_APPNAME6, 6); ++ memcpy(h->oem_table_id, ACPI_BUILD_APPNAME4, 4); ++ memcpy(h->oem_table_id + 4, (void *)&sig, 4); ++ h->oem_revision = cpu_to_le32(1); ++ memcpy(h->asl_compiler_id, ACPI_BUILD_APPNAME4, 4); ++ h->asl_compiler_revision = cpu_to_le32(1); ++ h->checksum = 0; ++ /* Checksum to be filled in by Guest linker */ ++ bios_linker_loader_add_checksum(linker, ACPI_BUILD_TABLE_FILE, ++ table_data->data, h, len, &h->checksum); ++} ++ ++static inline GArray *build_alloc_array(void) ++{ ++ return g_array_new(false, true /* clear */, 1); ++} ++ ++static inline void build_free_array(GArray *array) ++{ ++ g_array_free(array, true); ++} ++ ++static inline void build_prepend_byte(GArray *array, uint8_t val) ++{ ++ g_array_prepend_val(array, val); ++} ++ ++static inline void build_append_byte(GArray *array, uint8_t val) ++{ ++ g_array_append_val(array, val); ++} ++ ++static inline void build_append_array(GArray *array, GArray *val) ++{ ++ g_array_append_vals(array, val->data, val->len); ++} ++ ++static void build_append_nameseg(GArray *array, const char *format, ...) ++{ ++ GString *s = g_string_new(""); ++ va_list args; ++ ++ va_start(args, format); ++ g_string_vprintf(s, format, args); ++ va_end(args); ++ ++ assert(s->len == 4); ++ g_array_append_vals(array, s->str, s->len); ++ g_string_free(s, true); ++} ++ ++/* 5.4 Definition Block Encoding */ ++enum { ++ PACKAGE_LENGTH_1BYTE_SHIFT = 6, /* Up to 63 - use extra 2 bits. */ ++ PACKAGE_LENGTH_2BYTE_SHIFT = 4, ++ PACKAGE_LENGTH_3BYTE_SHIFT = 12, ++ PACKAGE_LENGTH_4BYTE_SHIFT = 20, ++}; ++ ++static void build_prepend_package_length(GArray *package, unsigned min_bytes) ++{ ++ uint8_t byte; ++ unsigned length = package->len; ++ unsigned length_bytes; ++ ++ if (length + 1 < (1 << PACKAGE_LENGTH_1BYTE_SHIFT)) { ++ length_bytes = 1; ++ } else if (length + 2 < (1 << PACKAGE_LENGTH_3BYTE_SHIFT)) { ++ length_bytes = 2; ++ } else if (length + 3 < (1 << PACKAGE_LENGTH_4BYTE_SHIFT)) { ++ length_bytes = 3; ++ } else { ++ length_bytes = 4; ++ } ++ ++ /* Force length to at least min_bytes. ++ * This wastes memory but that's how bios did it. ++ */ ++ length_bytes = MAX(length_bytes, min_bytes); ++ ++ /* PkgLength is the length of the inclusive length of the data. */ ++ length += length_bytes; ++ ++ switch (length_bytes) { ++ case 1: ++ byte = length; ++ build_prepend_byte(package, byte); ++ return; ++ case 4: ++ byte = length >> PACKAGE_LENGTH_4BYTE_SHIFT; ++ build_prepend_byte(package, byte); ++ length &= (1 << PACKAGE_LENGTH_4BYTE_SHIFT) - 1; ++ /* fall through */ ++ case 3: ++ byte = length >> PACKAGE_LENGTH_3BYTE_SHIFT; ++ build_prepend_byte(package, byte); ++ length &= (1 << PACKAGE_LENGTH_3BYTE_SHIFT) - 1; ++ /* fall through */ ++ case 2: ++ byte = length >> PACKAGE_LENGTH_2BYTE_SHIFT; ++ build_prepend_byte(package, byte); ++ length &= (1 << PACKAGE_LENGTH_2BYTE_SHIFT) - 1; ++ /* fall through */ ++ } ++ /* ++ * Most significant two bits of byte zero indicate how many following bytes ++ * are in PkgLength encoding. ++ */ ++ byte = ((length_bytes - 1) << PACKAGE_LENGTH_1BYTE_SHIFT) | length; ++ build_prepend_byte(package, byte); ++} ++ ++static void build_package(GArray *package, uint8_t op, unsigned min_bytes) ++{ ++ build_prepend_package_length(package, min_bytes); ++ build_prepend_byte(package, op); ++} ++ ++static void build_append_value(GArray *table, uint32_t value, int size) ++{ ++ uint8_t prefix; ++ int i; ++ ++ switch (size) { ++ case 1: ++ prefix = 0x0A; /* BytePrefix */ ++ break; ++ case 2: ++ prefix = 0x0B; /* WordPrefix */ ++ break; ++ case 4: ++ prefix = 0x0C; /* DWordPrefix */ ++ break; ++ default: ++ assert(0); ++ return; ++ } ++ build_append_byte(table, prefix); ++ for (i = 0; i < size; ++i) { ++ build_append_byte(table, value & 0xFF); ++ value = value >> 8; ++ } ++} ++ ++static void build_append_notify_target(GArray *method, GArray *target_name, ++ uint32_t value, int size) ++{ ++ GArray *notify = build_alloc_array(); ++ uint8_t op = 0xA0; /* IfOp */ ++ ++ build_append_byte(notify, 0x93); /* LEqualOp */ ++ build_append_byte(notify, 0x68); /* Arg0Op */ ++ build_append_value(notify, value, size); ++ build_append_byte(notify, 0x86); /* NotifyOp */ ++ build_append_array(notify, target_name); ++ build_append_byte(notify, 0x69); /* Arg1Op */ ++ ++ /* Pack it up */ ++ build_package(notify, op, 1); ++ ++ build_append_array(method, notify); ++ ++ build_free_array(notify); ++} ++ ++#define ACPI_PORT_SMI_CMD 0x00b2 /* TODO: this is APM_CNT_IOPORT */ ++ ++static inline void *acpi_data_push(GArray *table_data, unsigned size) ++{ ++ unsigned off = table_data->len; ++ g_array_set_size(table_data, off + size); ++ return table_data->data + off; ++} ++ ++static unsigned acpi_data_len(GArray *table) ++{ ++ return table->len * g_array_get_element_size(table); ++} ++ ++static void acpi_align_size(GArray *blob, unsigned align) ++{ ++ /* Align size to multiple of given size. This reduces the chance ++ * we need to change size in the future (breaking cross version migration). ++ */ ++ g_array_set_size(blob, (ROUND_UP(acpi_data_len(blob), align) + ++ g_array_get_element_size(blob) - 1) / ++ g_array_get_element_size(blob)); ++} ++ ++/* Get pointer within table in a safe manner */ ++#define ACPI_BUILD_PTR(table, size, off, type) \ ++ ((type *)(acpi_data_get_ptr(table, size, off, sizeof(type)))) ++ ++static inline void *acpi_data_get_ptr(uint8_t *table_data, unsigned table_size, ++ unsigned off, unsigned size) ++{ ++ assert(off + size > off); ++ assert(off + size <= table_size); ++ return table_data + off; ++} ++ ++static inline void acpi_add_table(GArray *table_offsets, GArray *table_data) ++{ ++ uint32_t offset = cpu_to_le32(table_data->len); ++ g_array_append_val(table_offsets, offset); ++} ++ ++/* FACS */ ++static void ++build_facs(GArray *table_data, GArray *linker, PcGuestInfo *guest_info) ++{ ++ AcpiFacsDescriptorRev1 *facs = acpi_data_push(table_data, sizeof *facs); ++ facs->signature = cpu_to_le32(ACPI_FACS_SIGNATURE); ++ facs->length = cpu_to_le32(sizeof(*facs)); ++} ++ ++/* Load chipset information in FADT */ ++static void fadt_setup(AcpiFadtDescriptorRev1 *fadt, AcpiPmInfo *pm) ++{ ++ fadt->model = 1; ++ fadt->reserved1 = 0; ++ fadt->sci_int = cpu_to_le16(pm->sci_int); ++ fadt->smi_cmd = cpu_to_le32(ACPI_PORT_SMI_CMD); ++ fadt->acpi_enable = pm->acpi_enable_cmd; ++ fadt->acpi_disable = pm->acpi_disable_cmd; ++ /* EVT, CNT, TMR offset matches hw/acpi/core.c */ ++ fadt->pm1a_evt_blk = cpu_to_le32(pm->io_base); ++ fadt->pm1a_cnt_blk = cpu_to_le32(pm->io_base + 0x04); ++ fadt->pm_tmr_blk = cpu_to_le32(pm->io_base + 0x08); ++ fadt->gpe0_blk = cpu_to_le32(pm->gpe0_blk); ++ /* EVT, CNT, TMR length matches hw/acpi/core.c */ ++ fadt->pm1_evt_len = 4; ++ fadt->pm1_cnt_len = 2; ++ fadt->pm_tmr_len = 4; ++ fadt->gpe0_blk_len = pm->gpe0_blk_len; ++ fadt->plvl2_lat = cpu_to_le16(0xfff); /* C2 state not supported */ ++ fadt->plvl3_lat = cpu_to_le16(0xfff); /* C3 state not supported */ ++ fadt->flags = cpu_to_le32((1 << ACPI_FADT_F_WBINVD) | ++ (1 << ACPI_FADT_F_PROC_C1) | ++ (1 << ACPI_FADT_F_SLP_BUTTON) | ++ (1 << ACPI_FADT_F_RTC_S4)); ++ fadt->flags |= cpu_to_le32(1 << ACPI_FADT_F_USE_PLATFORM_CLOCK); ++} ++ ++ ++/* FADT */ ++static void ++build_fadt(GArray *table_data, GArray *linker, AcpiPmInfo *pm, ++ unsigned facs, unsigned dsdt) ++{ ++ AcpiFadtDescriptorRev1 *fadt = acpi_data_push(table_data, sizeof(*fadt)); ++ ++ fadt->firmware_ctrl = cpu_to_le32(facs); ++ /* FACS address to be filled by Guest linker */ ++ bios_linker_loader_add_pointer(linker, ACPI_BUILD_TABLE_FILE, ++ ACPI_BUILD_TABLE_FILE, ++ table_data, &fadt->firmware_ctrl, ++ sizeof fadt->firmware_ctrl); ++ ++ fadt->dsdt = cpu_to_le32(dsdt); ++ /* DSDT address to be filled by Guest linker */ ++ bios_linker_loader_add_pointer(linker, ACPI_BUILD_TABLE_FILE, ++ ACPI_BUILD_TABLE_FILE, ++ table_data, &fadt->dsdt, ++ sizeof fadt->dsdt); ++ ++ fadt_setup(fadt, pm); ++ ++ build_header(linker, table_data, ++ (void *)fadt, ACPI_FACP_SIGNATURE, sizeof(*fadt), 1); ++} ++ ++static void ++build_madt(GArray *table_data, GArray *linker, AcpiCpuInfo *cpu, ++ PcGuestInfo *guest_info) ++{ ++ int madt_start = table_data->len; ++ ++ AcpiMultipleApicTable *madt; ++ AcpiMadtIoApic *io_apic; ++ AcpiMadtIntsrcovr *intsrcovr; ++ AcpiMadtLocalNmi *local_nmi; ++ int i; ++ ++ madt = acpi_data_push(table_data, sizeof *madt); ++ madt->local_apic_address = cpu_to_le32(APIC_DEFAULT_ADDRESS); ++ madt->flags = cpu_to_le32(1); ++ ++ for (i = 0; i < guest_info->apic_id_limit; i++) { ++ AcpiMadtProcessorApic *apic = acpi_data_push(table_data, sizeof *apic); ++ apic->type = ACPI_APIC_PROCESSOR; ++ apic->length = sizeof(*apic); ++ apic->processor_id = i; ++ apic->local_apic_id = i; ++ if (test_bit(i, cpu->found_cpus)) { ++ apic->flags = cpu_to_le32(1); ++ } else { ++ apic->flags = cpu_to_le32(0); ++ } ++ } ++ io_apic = acpi_data_push(table_data, sizeof *io_apic); ++ io_apic->type = ACPI_APIC_IO; ++ io_apic->length = sizeof(*io_apic); ++#define ACPI_BUILD_IOAPIC_ID 0x0 ++ io_apic->io_apic_id = ACPI_BUILD_IOAPIC_ID; ++ io_apic->address = cpu_to_le32(IO_APIC_DEFAULT_ADDRESS); ++ io_apic->interrupt = cpu_to_le32(0); ++ ++ if (guest_info->apic_xrupt_override) { ++ intsrcovr = acpi_data_push(table_data, sizeof *intsrcovr); ++ intsrcovr->type = ACPI_APIC_XRUPT_OVERRIDE; ++ intsrcovr->length = sizeof(*intsrcovr); ++ intsrcovr->source = 0; ++ intsrcovr->gsi = cpu_to_le32(2); ++ intsrcovr->flags = cpu_to_le16(0); /* conforms to bus specifications */ ++ } ++ for (i = 1; i < 16; i++) { ++#define ACPI_BUILD_PCI_IRQS ((1<<5) | (1<<9) | (1<<10) | (1<<11)) ++ if (!(ACPI_BUILD_PCI_IRQS & (1 << i))) { ++ /* No need for a INT source override structure. */ ++ continue; ++ } ++ intsrcovr = acpi_data_push(table_data, sizeof *intsrcovr); ++ intsrcovr->type = ACPI_APIC_XRUPT_OVERRIDE; ++ intsrcovr->length = sizeof(*intsrcovr); ++ intsrcovr->source = i; ++ intsrcovr->gsi = cpu_to_le32(i); ++ intsrcovr->flags = cpu_to_le16(0xd); /* active high, level triggered */ ++ } ++ ++ local_nmi = acpi_data_push(table_data, sizeof *local_nmi); ++ local_nmi->type = ACPI_APIC_LOCAL_NMI; ++ local_nmi->length = sizeof(*local_nmi); ++ local_nmi->processor_id = 0xff; /* all processors */ ++ local_nmi->flags = cpu_to_le16(0); ++ local_nmi->lint = 1; /* ACPI_LINT1 */ ++ ++ build_header(linker, table_data, ++ (void *)(table_data->data + madt_start), ACPI_APIC_SIGNATURE, ++ table_data->len - madt_start, 1); ++} ++ ++/* Encode a hex value */ ++static inline char acpi_get_hex(uint32_t val) ++{ ++ val &= 0x0f; ++ return (val <= 9) ? ('0' + val) : ('A' + val - 10); ++} ++ ++#include "hw/i386/ssdt-proc.hex" ++ ++/* 0x5B 0x83 ProcessorOp PkgLength NameString ProcID */ ++#define ACPI_PROC_OFFSET_CPUHEX (*ssdt_proc_name - *ssdt_proc_start + 2) ++#define ACPI_PROC_OFFSET_CPUID1 (*ssdt_proc_name - *ssdt_proc_start + 4) ++#define ACPI_PROC_OFFSET_CPUID2 (*ssdt_proc_id - *ssdt_proc_start) ++#define ACPI_PROC_SIZEOF (*ssdt_proc_end - *ssdt_proc_start) ++#define ACPI_PROC_AML (ssdp_proc_aml + *ssdt_proc_start) ++ ++/* 0x5B 0x82 DeviceOp PkgLength NameString */ ++#define ACPI_PCIHP_OFFSET_HEX (*ssdt_pcihp_name - *ssdt_pcihp_start + 1) ++#define ACPI_PCIHP_OFFSET_ID (*ssdt_pcihp_id - *ssdt_pcihp_start) ++#define ACPI_PCIHP_OFFSET_ADR (*ssdt_pcihp_adr - *ssdt_pcihp_start) ++#define ACPI_PCIHP_OFFSET_EJ0 (*ssdt_pcihp_ej0 - *ssdt_pcihp_start) ++#define ACPI_PCIHP_SIZEOF (*ssdt_pcihp_end - *ssdt_pcihp_start) ++#define ACPI_PCIHP_AML (ssdp_pcihp_aml + *ssdt_pcihp_start) ++ ++#define ACPI_SSDT_SIGNATURE 0x54445353 /* SSDT */ ++#define ACPI_SSDT_HEADER_LENGTH 36 ++ ++#include "hw/i386/ssdt-misc.hex" ++#include "hw/i386/ssdt-pcihp.hex" ++ ++static void ++build_append_notify(GArray *device, const char *name, ++ const char *format, int skip, int count) ++{ ++ int i; ++ GArray *method = build_alloc_array(); ++ uint8_t op = 0x14; /* MethodOp */ ++ ++ build_append_nameseg(method, name); ++ build_append_byte(method, 0x02); /* MethodFlags: ArgCount */ ++ for (i = skip; i < count; i++) { ++ GArray *target = build_alloc_array(); ++ build_append_nameseg(target, format, i); ++ assert(i < 256); /* Fits in 1 byte */ ++ build_append_notify_target(method, target, i, 1); ++ build_free_array(target); ++ } ++ build_package(method, op, 2); ++ ++ build_append_array(device, method); ++ build_free_array(method); ++} ++ ++static void patch_pcihp(int slot, uint8_t *ssdt_ptr, uint32_t eject) ++{ ++ ssdt_ptr[ACPI_PCIHP_OFFSET_HEX] = acpi_get_hex(slot >> 4); ++ ssdt_ptr[ACPI_PCIHP_OFFSET_HEX + 1] = acpi_get_hex(slot); ++ ssdt_ptr[ACPI_PCIHP_OFFSET_ID] = slot; ++ ssdt_ptr[ACPI_PCIHP_OFFSET_ADR + 2] = slot; ++ ++ /* Runtime patching of ACPI_EJ0: to disable hotplug for a slot, ++ * replace the method name: _EJ0 by ACPI_EJ0_. ++ */ ++ /* Sanity check */ ++ assert(!memcmp(ssdt_ptr + ACPI_PCIHP_OFFSET_EJ0, "_EJ0", 4)); ++ ++ if (!eject) { ++ memcpy(ssdt_ptr + ACPI_PCIHP_OFFSET_EJ0, "EJ0_", 4); ++ } ++} ++ ++static void patch_pci_windows(PcPciInfo *pci, uint8_t *start, unsigned size) ++{ ++ *ACPI_BUILD_PTR(start, size, acpi_pci32_start[0], uint32_t) = ++ cpu_to_le32(pci->w32.begin); ++ ++ *ACPI_BUILD_PTR(start, size, acpi_pci32_end[0], uint32_t) = ++ cpu_to_le32(pci->w32.end - 1); ++ ++ if (pci->w64.end || pci->w64.begin) { ++ *ACPI_BUILD_PTR(start, size, acpi_pci64_valid[0], uint8_t) = 1; ++ *ACPI_BUILD_PTR(start, size, acpi_pci64_start[0], uint64_t) = ++ cpu_to_le64(pci->w64.begin); ++ *ACPI_BUILD_PTR(start, size, acpi_pci64_end[0], uint64_t) = ++ cpu_to_le64(pci->w64.end - 1); ++ *ACPI_BUILD_PTR(start, size, acpi_pci64_length[0], uint64_t) = ++ cpu_to_le64(pci->w64.end - pci->w64.begin); ++ } else { ++ *ACPI_BUILD_PTR(start, size, acpi_pci64_valid[0], uint8_t) = 0; ++ } ++} ++ ++static void ++build_ssdt(GArray *table_data, GArray *linker, ++ AcpiCpuInfo *cpu, AcpiPmInfo *pm, AcpiMiscInfo *misc, ++ PcPciInfo *pci, PcGuestInfo *guest_info) ++{ ++ int acpi_cpus = MIN(0xff, guest_info->apic_id_limit); ++ int ssdt_start = table_data->len; ++ uint8_t *ssdt_ptr; ++ int i; ++ ++ /* Copy header and patch values in the S3_ / S4_ / S5_ packages */ ++ ssdt_ptr = acpi_data_push(table_data, sizeof(ssdp_misc_aml)); ++ memcpy(ssdt_ptr, ssdp_misc_aml, sizeof(ssdp_misc_aml)); ++ if (pm->s3_disabled) { ++ ssdt_ptr[acpi_s3_name[0]] = 'X'; ++ } ++ if (pm->s4_disabled) { ++ ssdt_ptr[acpi_s4_name[0]] = 'X'; ++ } else { ++ ssdt_ptr[acpi_s4_pkg[0] + 1] = ssdt_ptr[acpi_s4_pkg[0] + 3] = ++ pm->s4_val; ++ } ++ ++ patch_pci_windows(pci, ssdt_ptr, sizeof(ssdp_misc_aml)); ++ ++ *(uint16_t *)(ssdt_ptr + *ssdt_isa_pest) = ++ cpu_to_le16(misc->pvpanic_port); ++ ++ { ++ GArray *sb_scope = build_alloc_array(); ++ uint8_t op = 0x10; /* ScopeOp */ ++ ++ build_append_nameseg(sb_scope, "_SB_"); ++ ++ /* build Processor object for each processor */ ++ for (i = 0; i < acpi_cpus; i++) { ++ uint8_t *proc = acpi_data_push(sb_scope, ACPI_PROC_SIZEOF); ++ memcpy(proc, ACPI_PROC_AML, ACPI_PROC_SIZEOF); ++ proc[ACPI_PROC_OFFSET_CPUHEX] = acpi_get_hex(i >> 4); ++ proc[ACPI_PROC_OFFSET_CPUHEX+1] = acpi_get_hex(i); ++ proc[ACPI_PROC_OFFSET_CPUID1] = i; ++ proc[ACPI_PROC_OFFSET_CPUID2] = i; ++ } ++ ++ /* build this code: ++ * Method(NTFY, 2) {If (LEqual(Arg0, 0x00)) {Notify(CP00, Arg1)} ...} ++ */ ++ /* Arg0 = Processor ID = APIC ID */ ++ build_append_notify(sb_scope, "NTFY", "CP%0.02X", 0, acpi_cpus); ++ ++ /* build "Name(CPON, Package() { One, One, ..., Zero, Zero, ... })" */ ++ build_append_byte(sb_scope, 0x08); /* NameOp */ ++ build_append_nameseg(sb_scope, "CPON"); ++ ++ { ++ GArray *package = build_alloc_array(); ++ uint8_t op = 0x12; /* PackageOp */ ++ ++ build_append_byte(package, acpi_cpus); /* NumElements */ ++ for (i = 0; i < acpi_cpus; i++) { ++ uint8_t b = test_bit(i, cpu->found_cpus) ? 0x01 : 0x00; ++ build_append_byte(package, b); ++ } ++ ++ build_package(package, op, 2); ++ build_append_array(sb_scope, package); ++ build_free_array(package); ++ } ++ ++ { ++ GArray *pci0 = build_alloc_array(); ++ uint8_t op = 0x10; /* ScopeOp */; ++ ++ build_append_nameseg(pci0, "PCI0"); ++ ++ /* build Device object for each slot */ ++ for (i = 1; i < PCI_SLOT_MAX; i++) { ++ bool eject = test_bit(i, misc->slot_hotplug_enable); ++ void *pcihp = acpi_data_push(pci0, ACPI_PCIHP_SIZEOF); ++ ++ memcpy(pcihp, ACPI_PCIHP_AML, ACPI_PCIHP_SIZEOF); ++ patch_pcihp(i, pcihp, eject); ++ } ++ ++ build_append_notify(pci0, "PCNT", "S%0.02X_", 1, PCI_SLOT_MAX); ++ build_package(pci0, op, 3); ++ build_append_array(sb_scope, pci0); ++ build_free_array(pci0); ++ } ++ ++ build_package(sb_scope, op, 3); ++ build_append_array(table_data, sb_scope); ++ build_free_array(sb_scope); ++ } ++ ++ build_header(linker, table_data, ++ (void *)(table_data->data + ssdt_start), ++ ACPI_SSDT_SIGNATURE, table_data->len - ssdt_start, 1); ++} ++ ++static void ++build_hpet(GArray *table_data, GArray *linker) ++{ ++ Acpi20Hpet *hpet; ++ ++ hpet = acpi_data_push(table_data, sizeof(*hpet)); ++ /* Note timer_block_id value must be kept in sync with value advertised by ++ * emulated hpet ++ */ ++ hpet->timer_block_id = cpu_to_le32(0x8086a201); ++ hpet->addr.address = cpu_to_le64(HPET_BASE); ++ build_header(linker, table_data, ++ (void *)hpet, ACPI_HPET_SIGNATURE, sizeof(*hpet), 1); ++} ++ ++static void ++acpi_build_srat_memory(AcpiSratMemoryAffinity *numamem, ++ uint64_t base, uint64_t len, int node, int enabled) ++{ ++ numamem->type = ACPI_SRAT_MEMORY; ++ numamem->length = sizeof(*numamem); ++ memset(numamem->proximity, 0, 4); ++ numamem->proximity[0] = node; ++ numamem->flags = cpu_to_le32(!!enabled); ++ numamem->base_addr = cpu_to_le64(base); ++ numamem->range_length = cpu_to_le64(len); ++} ++ ++static void ++build_srat(GArray *table_data, GArray *linker, ++ AcpiCpuInfo *cpu, PcGuestInfo *guest_info) ++{ ++ AcpiSystemResourceAffinityTable *srat; ++ AcpiSratProcessorAffinity *core; ++ AcpiSratMemoryAffinity *numamem; ++ ++ int i; ++ uint64_t curnode; ++ int srat_start, numa_start, slots; ++ uint64_t mem_len, mem_base, next_base; ++ ++ srat_start = table_data->len; ++ ++ srat = acpi_data_push(table_data, sizeof *srat); ++ srat->reserved1 = cpu_to_le32(1); ++ core = (void *)(srat + 1); ++ ++ for (i = 0; i < guest_info->apic_id_limit; ++i) { ++ core = acpi_data_push(table_data, sizeof *core); ++ core->type = ACPI_SRAT_PROCESSOR; ++ core->length = sizeof(*core); ++ core->local_apic_id = i; ++ curnode = guest_info->node_cpu[i]; ++ core->proximity_lo = curnode; ++ memset(core->proximity_hi, 0, 3); ++ core->local_sapic_eid = 0; ++ if (test_bit(i, cpu->found_cpus)) { ++ core->flags = cpu_to_le32(1); ++ } else { ++ core->flags = cpu_to_le32(0); ++ } ++ } ++ ++ ++ /* the memory map is a bit tricky, it contains at least one hole ++ * from 640k-1M and possibly another one from 3.5G-4G. ++ */ ++ next_base = 0; ++ numa_start = table_data->len; ++ ++ numamem = acpi_data_push(table_data, sizeof *numamem); ++ acpi_build_srat_memory(numamem, 0, 640*1024, 0, 1); ++ next_base = 1024 * 1024; ++ for (i = 1; i < guest_info->numa_nodes + 1; ++i) { ++ mem_base = next_base; ++ mem_len = guest_info->node_mem[i - 1]; ++ if (i == 1) { ++ mem_len -= 1024 * 1024; ++ } ++ next_base = mem_base + mem_len; ++ ++ /* Cut out the ACPI_PCI hole */ ++ if (mem_base <= guest_info->ram_size && ++ next_base > guest_info->ram_size) { ++ mem_len -= next_base - guest_info->ram_size; ++ if (mem_len > 0) { ++ numamem = acpi_data_push(table_data, sizeof *numamem); ++ acpi_build_srat_memory(numamem, mem_base, mem_len, i-1, 1); ++ } ++ mem_base = 1ULL << 32; ++ mem_len = next_base - guest_info->ram_size; ++ next_base += (1ULL << 32) - guest_info->ram_size; ++ } ++ numamem = acpi_data_push(table_data, sizeof *numamem); ++ acpi_build_srat_memory(numamem, mem_base, mem_len, i - 1, 1); ++ } ++ slots = (table_data->len - numa_start) / sizeof *numamem; ++ for (; slots < guest_info->numa_nodes + 2; slots++) { ++ numamem = acpi_data_push(table_data, sizeof *numamem); ++ acpi_build_srat_memory(numamem, 0, 0, 0, 0); ++ } ++ ++ build_header(linker, table_data, ++ (void *)(table_data->data + srat_start), ++ ACPI_SRAT_SIGNATURE, ++ table_data->len - srat_start, 1); ++} ++ ++static void ++build_mcfg_q35(GArray *table_data, GArray *linker, AcpiMcfgInfo *info) ++{ ++ AcpiTableMcfg *mcfg; ++ uint32_t sig; ++ int len = sizeof(*mcfg) + 1 * sizeof(mcfg->allocation[0]); ++ ++ mcfg = acpi_data_push(table_data, len); ++ mcfg->allocation[0].address = cpu_to_le64(info->mcfg_base); ++ /* Only a single allocation so no need to play with segments */ ++ mcfg->allocation[0].pci_segment = cpu_to_le16(0); ++ mcfg->allocation[0].start_bus_number = 0; ++ mcfg->allocation[0].end_bus_number = PCIE_MMCFG_BUS(info->mcfg_size - 1); ++ ++ /* MCFG is used for ECAM which can be enabled or disabled by guest. ++ * To avoid table size changes (which create migration issues), ++ * always create the table even if there are no allocations, ++ * but set the signature to a reserved value in this case. ++ * ACPI spec requires OSPMs to ignore such tables. ++ */ ++ if (info->mcfg_base == PCIE_BASE_ADDR_UNMAPPED) { ++ sig = ACPI_RSRV_SIGNATURE; ++ } else { ++ sig = ACPI_MCFG_SIGNATURE; ++ } ++ build_header(linker, table_data, (void *)mcfg, sig, len, 1); ++} ++ ++static void ++build_dsdt(GArray *table_data, GArray *linker, AcpiMiscInfo *misc) ++{ ++ void *dsdt; ++ assert(misc->dsdt_code && misc->dsdt_size); ++ dsdt = acpi_data_push(table_data, misc->dsdt_size); ++ memcpy(dsdt, misc->dsdt_code, misc->dsdt_size); ++} ++ ++/* Build final rsdt table */ ++static void ++build_rsdt(GArray *table_data, GArray *linker, GArray *table_offsets) ++{ ++ AcpiRsdtDescriptorRev1 *rsdt; ++ size_t rsdt_len; ++ int i; ++ ++ rsdt_len = sizeof(*rsdt) + sizeof(uint32_t) * table_offsets->len; ++ rsdt = acpi_data_push(table_data, rsdt_len); ++ memcpy(rsdt->table_offset_entry, table_offsets->data, ++ sizeof(uint32_t) * table_offsets->len); ++ for (i = 0; i < table_offsets->len; ++i) { ++ /* rsdt->table_offset_entry to be filled by Guest linker */ ++ bios_linker_loader_add_pointer(linker, ++ ACPI_BUILD_TABLE_FILE, ++ ACPI_BUILD_TABLE_FILE, ++ table_data, &rsdt->table_offset_entry[i], ++ sizeof(uint32_t)); ++ } ++ build_header(linker, table_data, ++ (void *)rsdt, ACPI_RSDT_SIGNATURE, rsdt_len, 1); ++} ++ ++static GArray * ++build_rsdp(GArray *rsdp_table, GArray *linker, unsigned rsdt) ++{ ++ AcpiRsdpDescriptor *rsdp = acpi_data_push(rsdp_table, sizeof *rsdp); ++ ++ bios_linker_loader_alloc(linker, ACPI_BUILD_RSDP_FILE, 1, ++ true /* fseg memory */); ++ ++ rsdp->signature = cpu_to_le64(ACPI_RSDP_SIGNATURE); ++ memcpy(rsdp->oem_id, ACPI_BUILD_APPNAME6, 6); ++ rsdp->rsdt_physical_address = cpu_to_le32(rsdt); ++ /* Address to be filled by Guest linker */ ++ bios_linker_loader_add_pointer(linker, ACPI_BUILD_RSDP_FILE, ++ ACPI_BUILD_TABLE_FILE, ++ rsdp_table, &rsdp->rsdt_physical_address, ++ sizeof rsdp->rsdt_physical_address); ++ rsdp->checksum = 0; ++ /* Checksum to be filled by Guest linker */ ++ bios_linker_loader_add_checksum(linker, ACPI_BUILD_RSDP_FILE, ++ rsdp, rsdp, sizeof *rsdp, &rsdp->checksum); ++ ++ return rsdp_table; ++} ++ ++typedef ++struct AcpiBuildTables { ++ GArray *table_data; ++ GArray *rsdp; ++ GArray *linker; ++} AcpiBuildTables; ++ ++static inline void acpi_build_tables_init(AcpiBuildTables *tables) ++{ ++ tables->rsdp = g_array_new(false, true /* clear */, 1); ++ tables->table_data = g_array_new(false, true /* clear */, 1); ++ tables->linker = bios_linker_loader_init(); ++} ++ ++static inline void acpi_build_tables_cleanup(AcpiBuildTables *tables, bool mfre) ++{ ++ void *linker_data = bios_linker_loader_cleanup(tables->linker); ++ if (mfre) { ++ g_free(linker_data); ++ } ++ g_array_free(tables->rsdp, mfre); ++ g_array_free(tables->table_data, mfre); ++} ++ ++typedef ++struct AcpiBuildState { ++ /* Copy of table in RAM (for patching). */ ++ uint8_t *table_ram; ++ uint32_t table_size; ++ /* Is table patched? */ ++ uint8_t patched; ++ PcGuestInfo *guest_info; ++} AcpiBuildState; ++ ++static bool acpi_get_mcfg(AcpiMcfgInfo *mcfg) ++{ ++ Object *pci_host; ++ QObject *o; ++ bool ambiguous; ++ ++ pci_host = object_resolve_path_type("", TYPE_PCI_HOST_BRIDGE, &ambiguous); ++ g_assert(!ambiguous); ++ g_assert(pci_host); ++ ++ o = object_property_get_qobject(pci_host, PCIE_HOST_MCFG_BASE, NULL); ++ if (!o) { ++ return false; ++ } ++ mcfg->mcfg_base = qint_get_int(qobject_to_qint(o)); ++ ++ o = object_property_get_qobject(pci_host, PCIE_HOST_MCFG_SIZE, NULL); ++ assert(o); ++ mcfg->mcfg_size = qint_get_int(qobject_to_qint(o)); ++ return true; ++} ++ ++static ++void acpi_build(PcGuestInfo *guest_info, AcpiBuildTables *tables) ++{ ++ GArray *table_offsets; ++ unsigned facs, dsdt, rsdt; ++ AcpiCpuInfo cpu; ++ AcpiPmInfo pm; ++ AcpiMiscInfo misc; ++ AcpiMcfgInfo mcfg; ++ PcPciInfo pci; ++ uint8_t *u; ++ ++ acpi_get_cpu_info(&cpu); ++ acpi_get_pm_info(&pm); ++ acpi_get_dsdt(&misc); ++ acpi_get_hotplug_info(&misc); ++ acpi_get_misc_info(&misc); ++ acpi_get_pci_info(&pci); ++ ++ table_offsets = g_array_new(false, true /* clear */, ++ sizeof(uint32_t)); ++ ACPI_BUILD_DPRINTF(3, "init ACPI tables\n"); ++ ++ bios_linker_loader_alloc(tables->linker, ACPI_BUILD_TABLE_FILE, ++ 64 /* Ensure FACS is aligned */, ++ false /* high memory */); ++ ++ /* ++ * FACS is pointed to by FADT. ++ * We place it first since it's the only table that has alignment ++ * requirements. ++ */ ++ facs = tables->table_data->len; ++ build_facs(tables->table_data, tables->linker, guest_info); ++ ++ /* DSDT is pointed to by FADT */ ++ dsdt = tables->table_data->len; ++ build_dsdt(tables->table_data, tables->linker, &misc); ++ ++ /* ACPI tables pointed to by RSDT */ ++ acpi_add_table(table_offsets, tables->table_data); ++ build_fadt(tables->table_data, tables->linker, &pm, facs, dsdt); ++ acpi_add_table(table_offsets, tables->table_data); ++ ++ build_ssdt(tables->table_data, tables->linker, &cpu, &pm, &misc, &pci, ++ guest_info); ++ acpi_add_table(table_offsets, tables->table_data); ++ ++ build_madt(tables->table_data, tables->linker, &cpu, guest_info); ++ acpi_add_table(table_offsets, tables->table_data); ++ if (misc.has_hpet) { ++ build_hpet(tables->table_data, tables->linker); ++ } ++ if (guest_info->numa_nodes) { ++ acpi_add_table(table_offsets, tables->table_data); ++ build_srat(tables->table_data, tables->linker, &cpu, guest_info); ++ } ++ if (acpi_get_mcfg(&mcfg)) { ++ acpi_add_table(table_offsets, tables->table_data); ++ build_mcfg_q35(tables->table_data, tables->linker, &mcfg); ++ } ++ ++ /* Add tables supplied by user (if any) */ ++ for (u = acpi_table_first(); u; u = acpi_table_next(u)) { ++ unsigned len = acpi_table_len(u); ++ ++ acpi_add_table(table_offsets, tables->table_data); ++ g_array_append_vals(tables->table_data, u, len); ++ } ++ ++ /* RSDT is pointed to by RSDP */ ++ rsdt = tables->table_data->len; ++ build_rsdt(tables->table_data, tables->linker, table_offsets); ++ ++ /* RSDP is in FSEG memory, so allocate it separately */ ++ build_rsdp(tables->rsdp, tables->linker, rsdt); ++ ++ /* We'll expose it all to Guest so align size to reduce ++ * chance of size changes. ++ * RSDP is small so it's easy to keep it immutable, no need to ++ * bother with alignment. ++ */ ++ acpi_align_size(tables->table_data, 0x1000); ++ ++ acpi_align_size(tables->linker, 0x1000); ++ ++ /* Cleanup memory that's no longer used. */ ++ g_array_free(table_offsets, true); ++} ++ ++static void acpi_build_update(void *build_opaque, uint32_t offset) ++{ ++ AcpiBuildState *build_state = build_opaque; ++ AcpiBuildTables tables; ++ ++ /* No state to update or already patched? Nothing to do. */ ++ if (!build_state || build_state->patched) { ++ return; ++ } ++ build_state->patched = 1; ++ ++ acpi_build_tables_init(&tables); ++ ++ acpi_build(build_state->guest_info, &tables); ++ ++ assert(acpi_data_len(tables.table_data) == build_state->table_size); ++ memcpy(build_state->table_ram, tables.table_data->data, ++ build_state->table_size); ++ ++ acpi_build_tables_cleanup(&tables, true); ++} ++ ++static void acpi_build_reset(void *build_opaque) ++{ ++ AcpiBuildState *build_state = build_opaque; ++ build_state->patched = 0; ++} ++ ++static void *acpi_add_rom_blob(AcpiBuildState *build_state, GArray *blob, ++ const char *name) ++{ ++ return rom_add_blob(name, blob->data, acpi_data_len(blob), -1, name, ++ acpi_build_update, build_state); ++} ++ ++static const VMStateDescription vmstate_acpi_build = { ++ .name = "acpi_build", ++ .version_id = 1, ++ .minimum_version_id = 1, ++ .minimum_version_id_old = 1, ++ .fields = (VMStateField[]) { ++ VMSTATE_UINT8(patched, AcpiBuildState), ++ VMSTATE_END_OF_LIST() ++ }, ++}; ++ ++void acpi_setup(PcGuestInfo *guest_info) ++{ ++ AcpiBuildTables tables; ++ AcpiBuildState *build_state; ++ ++ if (!guest_info->fw_cfg) { ++ ACPI_BUILD_DPRINTF(3, "No fw cfg. Bailing out.\n"); ++ return; ++ } ++ ++ if (!guest_info->has_acpi_build) { ++ ACPI_BUILD_DPRINTF(3, "ACPI build disabled. Bailing out.\n"); ++ return; ++ } ++ ++ build_state = g_malloc0(sizeof *build_state); ++ ++ build_state->guest_info = guest_info; ++ ++ acpi_build_tables_init(&tables); ++ acpi_build(build_state->guest_info, &tables); ++ ++ /* Now expose it all to Guest */ ++ build_state->table_ram = acpi_add_rom_blob(build_state, tables.table_data, ++ ACPI_BUILD_TABLE_FILE); ++ build_state->table_size = acpi_data_len(tables.table_data); ++ ++ acpi_add_rom_blob(NULL, tables.linker, "etc/table-loader"); ++ ++ /* ++ * RSDP is small so it's easy to keep it immutable, no need to ++ * bother with ROM blobs. ++ */ ++ fw_cfg_add_file(guest_info->fw_cfg, ACPI_BUILD_RSDP_FILE, ++ tables.rsdp->data, acpi_data_len(tables.rsdp)); ++ ++ qemu_register_reset(acpi_build_reset, build_state); ++ acpi_build_reset(build_state); ++ vmstate_register(NULL, 0, &vmstate_acpi_build, build_state); ++ ++ /* Cleanup tables but don't free the memory: we track it ++ * in build_state. ++ */ ++ acpi_build_tables_cleanup(&tables, false); ++} +diff --git a/hw/i386/acpi-build.h b/hw/i386/acpi-build.h +new file mode 100644 +index 0000000..e57b1aa +--- /dev/null ++++ b/hw/i386/acpi-build.h +@@ -0,0 +1,9 @@ ++ ++#ifndef HW_I386_ACPI_BUILD_H ++#define HW_I386_ACPI_BUILD_H ++ ++#include "qemu/typedefs.h" ++ ++void acpi_setup(PcGuestInfo *); ++ ++#endif +diff --git a/hw/i386/acpi-defs.h b/hw/i386/acpi-defs.h +new file mode 100644 +index 0000000..78ca204 +--- /dev/null ++++ b/hw/i386/acpi-defs.h +@@ -0,0 +1,331 @@ ++/* ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 2 of the License, or ++ * (at your option) any later version. ++ ++ * This program is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ * GNU General Public License for more details. ++ ++ * You should have received a copy of the GNU General Public License along ++ * with this program; if not, see . ++ */ ++#ifndef QEMU_ACPI_DEFS_H ++#define QEMU_ACPI_DEFS_H ++ ++enum { ++ ACPI_FADT_F_WBINVD, ++ ACPI_FADT_F_WBINVD_FLUSH, ++ ACPI_FADT_F_PROC_C1, ++ ACPI_FADT_F_P_LVL2_UP, ++ ACPI_FADT_F_PWR_BUTTON, ++ ACPI_FADT_F_SLP_BUTTON, ++ ACPI_FADT_F_FIX_RTC, ++ ACPI_FADT_F_RTC_S4, ++ ACPI_FADT_F_TMR_VAL_EXT, ++ ACPI_FADT_F_DCK_CAP, ++ ACPI_FADT_F_RESET_REG_SUP, ++ ACPI_FADT_F_SEALED_CASE, ++ ACPI_FADT_F_HEADLESS, ++ ACPI_FADT_F_CPU_SW_SLP, ++ ACPI_FADT_F_PCI_EXP_WAK, ++ ACPI_FADT_F_USE_PLATFORM_CLOCK, ++ ACPI_FADT_F_S4_RTC_STS_VALID, ++ ACPI_FADT_F_REMOTE_POWER_ON_CAPABLE, ++ ACPI_FADT_F_FORCE_APIC_CLUSTER_MODEL, ++ ACPI_FADT_F_FORCE_APIC_PHYSICAL_DESTINATION_MODE, ++ ACPI_FADT_F_HW_REDUCED_ACPI, ++ ACPI_FADT_F_LOW_POWER_S0_IDLE_CAPABLE, ++}; ++ ++/* ++ * ACPI 2.0 Generic Address Space definition. ++ */ ++struct Acpi20GenericAddress { ++ uint8_t address_space_id; ++ uint8_t register_bit_width; ++ uint8_t register_bit_offset; ++ uint8_t reserved; ++ uint64_t address; ++} QEMU_PACKED; ++typedef struct Acpi20GenericAddress Acpi20GenericAddress; ++ ++#define ACPI_RSDP_SIGNATURE 0x2052545020445352LL // "RSD PTR " ++ ++struct AcpiRsdpDescriptor { /* Root System Descriptor Pointer */ ++ uint64_t signature; /* ACPI signature, contains "RSD PTR " */ ++ uint8_t checksum; /* To make sum of struct == 0 */ ++ uint8_t oem_id [6]; /* OEM identification */ ++ uint8_t revision; /* Must be 0 for 1.0, 2 for 2.0 */ ++ uint32_t rsdt_physical_address; /* 32-bit physical address of RSDT */ ++ uint32_t length; /* XSDT Length in bytes including hdr */ ++ uint64_t xsdt_physical_address; /* 64-bit physical address of XSDT */ ++ uint8_t extended_checksum; /* Checksum of entire table */ ++ uint8_t reserved [3]; /* Reserved field must be 0 */ ++} QEMU_PACKED; ++typedef struct AcpiRsdpDescriptor AcpiRsdpDescriptor; ++ ++/* Table structure from Linux kernel (the ACPI tables are under the ++ BSD license) */ ++ ++ ++#define ACPI_TABLE_HEADER_DEF /* ACPI common table header */ \ ++ uint32_t signature; /* ACPI signature (4 ASCII characters) */ \ ++ uint32_t length; /* Length of table, in bytes, including header */ \ ++ uint8_t revision; /* ACPI Specification minor version # */ \ ++ uint8_t checksum; /* To make sum of entire table == 0 */ \ ++ uint8_t oem_id [6]; /* OEM identification */ \ ++ uint8_t oem_table_id [8]; /* OEM table identification */ \ ++ uint32_t oem_revision; /* OEM revision number */ \ ++ uint8_t asl_compiler_id [4]; /* ASL compiler vendor ID */ \ ++ uint32_t asl_compiler_revision; /* ASL compiler revision number */ ++ ++ ++struct AcpiTableHeader /* ACPI common table header */ ++{ ++ ACPI_TABLE_HEADER_DEF ++} QEMU_PACKED; ++typedef struct AcpiTableHeader AcpiTableHeader; ++ ++/* ++ * ACPI 1.0 Fixed ACPI Description Table (FADT) ++ */ ++#define ACPI_FACP_SIGNATURE 0x50434146 // FACP ++struct AcpiFadtDescriptorRev1 ++{ ++ ACPI_TABLE_HEADER_DEF /* ACPI common table header */ ++ uint32_t firmware_ctrl; /* Physical address of FACS */ ++ uint32_t dsdt; /* Physical address of DSDT */ ++ uint8_t model; /* System Interrupt Model */ ++ uint8_t reserved1; /* Reserved */ ++ uint16_t sci_int; /* System vector of SCI interrupt */ ++ uint32_t smi_cmd; /* Port address of SMI command port */ ++ uint8_t acpi_enable; /* Value to write to smi_cmd to enable ACPI */ ++ uint8_t acpi_disable; /* Value to write to smi_cmd to disable ACPI */ ++ uint8_t S4bios_req; /* Value to write to SMI CMD to enter S4BIOS state */ ++ uint8_t reserved2; /* Reserved - must be zero */ ++ uint32_t pm1a_evt_blk; /* Port address of Power Mgt 1a acpi_event Reg Blk */ ++ uint32_t pm1b_evt_blk; /* Port address of Power Mgt 1b acpi_event Reg Blk */ ++ uint32_t pm1a_cnt_blk; /* Port address of Power Mgt 1a Control Reg Blk */ ++ uint32_t pm1b_cnt_blk; /* Port address of Power Mgt 1b Control Reg Blk */ ++ uint32_t pm2_cnt_blk; /* Port address of Power Mgt 2 Control Reg Blk */ ++ uint32_t pm_tmr_blk; /* Port address of Power Mgt Timer Ctrl Reg Blk */ ++ uint32_t gpe0_blk; /* Port addr of General Purpose acpi_event 0 Reg Blk */ ++ uint32_t gpe1_blk; /* Port addr of General Purpose acpi_event 1 Reg Blk */ ++ uint8_t pm1_evt_len; /* Byte length of ports at pm1_x_evt_blk */ ++ uint8_t pm1_cnt_len; /* Byte length of ports at pm1_x_cnt_blk */ ++ uint8_t pm2_cnt_len; /* Byte Length of ports at pm2_cnt_blk */ ++ uint8_t pm_tmr_len; /* Byte Length of ports at pm_tm_blk */ ++ uint8_t gpe0_blk_len; /* Byte Length of ports at gpe0_blk */ ++ uint8_t gpe1_blk_len; /* Byte Length of ports at gpe1_blk */ ++ uint8_t gpe1_base; /* Offset in gpe model where gpe1 events start */ ++ uint8_t reserved3; /* Reserved */ ++ uint16_t plvl2_lat; /* Worst case HW latency to enter/exit C2 state */ ++ uint16_t plvl3_lat; /* Worst case HW latency to enter/exit C3 state */ ++ uint16_t flush_size; /* Size of area read to flush caches */ ++ uint16_t flush_stride; /* Stride used in flushing caches */ ++ uint8_t duty_offset; /* Bit location of duty cycle field in p_cnt reg */ ++ uint8_t duty_width; /* Bit width of duty cycle field in p_cnt reg */ ++ uint8_t day_alrm; /* Index to day-of-month alarm in RTC CMOS RAM */ ++ uint8_t mon_alrm; /* Index to month-of-year alarm in RTC CMOS RAM */ ++ uint8_t century; /* Index to century in RTC CMOS RAM */ ++ uint8_t reserved4; /* Reserved */ ++ uint8_t reserved4a; /* Reserved */ ++ uint8_t reserved4b; /* Reserved */ ++ uint32_t flags; ++} QEMU_PACKED; ++typedef struct AcpiFadtDescriptorRev1 AcpiFadtDescriptorRev1; ++ ++/* ++ * ACPI 1.0 Root System Description Table (RSDT) ++ */ ++#define ACPI_RSDT_SIGNATURE 0x54445352 // RSDT ++struct AcpiRsdtDescriptorRev1 ++{ ++ ACPI_TABLE_HEADER_DEF /* ACPI common table header */ ++ uint32_t table_offset_entry[0]; /* Array of pointers to other */ ++ /* ACPI tables */ ++} QEMU_PACKED; ++typedef struct AcpiRsdtDescriptorRev1 AcpiRsdtDescriptorRev1; ++ ++/* ++ * ACPI 1.0 Firmware ACPI Control Structure (FACS) ++ */ ++#define ACPI_FACS_SIGNATURE 0x53434146 // FACS ++struct AcpiFacsDescriptorRev1 ++{ ++ uint32_t signature; /* ACPI Signature */ ++ uint32_t length; /* Length of structure, in bytes */ ++ uint32_t hardware_signature; /* Hardware configuration signature */ ++ uint32_t firmware_waking_vector; /* ACPI OS waking vector */ ++ uint32_t global_lock; /* Global Lock */ ++ uint32_t flags; ++ uint8_t resverved3 [40]; /* Reserved - must be zero */ ++} QEMU_PACKED; ++typedef struct AcpiFacsDescriptorRev1 AcpiFacsDescriptorRev1; ++ ++/* ++ * Differentiated System Description Table (DSDT) ++ */ ++#define ACPI_DSDT_SIGNATURE 0x54445344 // DSDT ++ ++/* ++ * MADT values and structures ++ */ ++ ++/* Values for MADT PCATCompat */ ++ ++#define ACPI_DUAL_PIC 0 ++#define ACPI_MULTIPLE_APIC 1 ++ ++/* Master MADT */ ++ ++#define ACPI_APIC_SIGNATURE 0x43495041 // APIC ++struct AcpiMultipleApicTable ++{ ++ ACPI_TABLE_HEADER_DEF /* ACPI common table header */ ++ uint32_t local_apic_address; /* Physical address of local APIC */ ++ uint32_t flags; ++} QEMU_PACKED; ++typedef struct AcpiMultipleApicTable AcpiMultipleApicTable; ++ ++/* Values for Type in APIC sub-headers */ ++ ++#define ACPI_APIC_PROCESSOR 0 ++#define ACPI_APIC_IO 1 ++#define ACPI_APIC_XRUPT_OVERRIDE 2 ++#define ACPI_APIC_NMI 3 ++#define ACPI_APIC_LOCAL_NMI 4 ++#define ACPI_APIC_ADDRESS_OVERRIDE 5 ++#define ACPI_APIC_IO_SAPIC 6 ++#define ACPI_APIC_LOCAL_SAPIC 7 ++#define ACPI_APIC_XRUPT_SOURCE 8 ++#define ACPI_APIC_RESERVED 9 /* 9 and greater are reserved */ ++ ++/* ++ * MADT sub-structures (Follow MULTIPLE_APIC_DESCRIPTION_TABLE) ++ */ ++#define ACPI_SUB_HEADER_DEF /* Common ACPI sub-structure header */\ ++ uint8_t type; \ ++ uint8_t length; ++ ++/* Sub-structures for MADT */ ++ ++struct AcpiMadtProcessorApic ++{ ++ ACPI_SUB_HEADER_DEF ++ uint8_t processor_id; /* ACPI processor id */ ++ uint8_t local_apic_id; /* Processor's local APIC id */ ++ uint32_t flags; ++} QEMU_PACKED; ++typedef struct AcpiMadtProcessorApic AcpiMadtProcessorApic; ++ ++struct AcpiMadtIoApic ++{ ++ ACPI_SUB_HEADER_DEF ++ uint8_t io_apic_id; /* I/O APIC ID */ ++ uint8_t reserved; /* Reserved - must be zero */ ++ uint32_t address; /* APIC physical address */ ++ uint32_t interrupt; /* Global system interrupt where INTI ++ * lines start */ ++} QEMU_PACKED; ++typedef struct AcpiMadtIoApic AcpiMadtIoApic; ++ ++struct AcpiMadtIntsrcovr { ++ ACPI_SUB_HEADER_DEF ++ uint8_t bus; ++ uint8_t source; ++ uint32_t gsi; ++ uint16_t flags; ++} QEMU_PACKED; ++typedef struct AcpiMadtIntsrcovr AcpiMadtIntsrcovr; ++ ++struct AcpiMadtLocalNmi { ++ ACPI_SUB_HEADER_DEF ++ uint8_t processor_id; /* ACPI processor id */ ++ uint16_t flags; /* MPS INTI flags */ ++ uint8_t lint; /* Local APIC LINT# */ ++} QEMU_PACKED; ++typedef struct AcpiMadtLocalNmi AcpiMadtLocalNmi; ++ ++/* ++ * HPET Description Table ++ */ ++#define ACPI_HPET_SIGNATURE 0x54455048 // HPET ++struct Acpi20Hpet { ++ ACPI_TABLE_HEADER_DEF /* ACPI common table header */ ++ uint32_t timer_block_id; ++ Acpi20GenericAddress addr; ++ uint8_t hpet_number; ++ uint16_t min_tick; ++ uint8_t page_protect; ++} QEMU_PACKED; ++typedef struct Acpi20Hpet Acpi20Hpet; ++ ++/* ++ * SRAT (NUMA topology description) table ++ */ ++ ++#define ACPI_SRAT_SIGNATURE 0x54415253 // SRAT ++struct AcpiSystemResourceAffinityTable ++{ ++ ACPI_TABLE_HEADER_DEF ++ uint32_t reserved1; ++ uint32_t reserved2[2]; ++} QEMU_PACKED; ++typedef struct AcpiSystemResourceAffinityTable AcpiSystemResourceAffinityTable; ++ ++#define ACPI_SRAT_PROCESSOR 0 ++#define ACPI_SRAT_MEMORY 1 ++ ++struct AcpiSratProcessorAffinity ++{ ++ ACPI_SUB_HEADER_DEF ++ uint8_t proximity_lo; ++ uint8_t local_apic_id; ++ uint32_t flags; ++ uint8_t local_sapic_eid; ++ uint8_t proximity_hi[3]; ++ uint32_t reserved; ++} QEMU_PACKED; ++typedef struct AcpiSratProcessorAffinity AcpiSratProcessorAffinity; ++ ++struct AcpiSratMemoryAffinity ++{ ++ ACPI_SUB_HEADER_DEF ++ uint8_t proximity[4]; ++ uint16_t reserved1; ++ uint64_t base_addr; ++ uint64_t range_length; ++ uint32_t reserved2; ++ uint32_t flags; ++ uint32_t reserved3[2]; ++} QEMU_PACKED; ++typedef struct AcpiSratMemoryAffinity AcpiSratMemoryAffinity; ++ ++/* PCI fw r3.0 MCFG table. */ ++/* Subtable */ ++struct AcpiMcfgAllocation { ++ uint64_t address; /* Base address, processor-relative */ ++ uint16_t pci_segment; /* PCI segment group number */ ++ uint8_t start_bus_number; /* Starting PCI Bus number */ ++ uint8_t end_bus_number; /* Final PCI Bus number */ ++ uint32_t reserved; ++} QEMU_PACKED; ++typedef struct AcpiMcfgAllocation AcpiMcfgAllocation; ++ ++#define ACPI_MCFG_SIGNATURE 0x4746434d // MCFG ++ ++/* Reserved signature: ignored by OSPM */ ++#define ACPI_RSRV_SIGNATURE 0x554d4551 // QEMU ++ ++struct AcpiTableMcfg { ++ ACPI_TABLE_HEADER_DEF; ++ uint8_t reserved[8]; ++ AcpiMcfgAllocation allocation[0]; ++} QEMU_PACKED; ++typedef struct AcpiTableMcfg AcpiTableMcfg; ++ ++#endif +diff --git a/hw/i386/pc.c b/hw/i386/pc.c +index 041e537..320f668 100644 +--- a/hw/i386/pc.c ++++ b/hw/i386/pc.c +@@ -56,6 +56,7 @@ + #include "hw/cpu/icc_bus.h" + #include "hw/boards.h" + #include "hw/pci/pci_host.h" ++#include "acpi-build.h" + + /* debug PC/ISA interrupts */ + //#define DEBUG_IRQ +@@ -1035,6 +1036,7 @@ void pc_guest_info_machine_done(Notifier *notifier, void *data) + PcGuestInfoState, + machine_done); + pc_fw_cfg_guest_info(&guest_info_state->info); ++ acpi_setup(&guest_info_state->info); + } + + PcGuestInfo *pc_guest_info_init(ram_addr_t below_4g_mem_size, +diff --git a/hw/i386/pc_piix.c b/hw/i386/pc_piix.c +index 211ff8e..ffa35d3 100644 +--- a/hw/i386/pc_piix.c ++++ b/hw/i386/pc_piix.c +@@ -60,6 +60,7 @@ static const int ide_irq[MAX_IDE_BUS] = { 14, 15 }; + + static bool smbios_type1_defaults = true; + static bool has_pci_info = true; ++static bool has_acpi_build = true; + + /* PC hardware initialisation */ + static void pc_init1(QEMUMachineInitArgs *args, +@@ -123,6 +124,9 @@ static void pc_init1(QEMUMachineInitArgs *args, + } + + guest_info = pc_guest_info_init(below_4g_mem_size, above_4g_mem_size); ++ ++ guest_info->has_acpi_build = has_acpi_build; ++ + guest_info->has_pci_info = has_pci_info; + + /* allocate ram and load rom/bios */ +@@ -899,6 +903,7 @@ static void pc_init_rhel650(QEMUMachineInitArgs *args) + 0, CPUID_EXT2_RDTSCP); + + rom_file_in_ram = false; ++ has_acpi_build = false; + pc_init_rhel700(args); + } + +diff --git a/hw/i386/pc_q35.c b/hw/i386/pc_q35.c +index 7a58b61..824295d 100644 +--- a/hw/i386/pc_q35.c ++++ b/hw/i386/pc_q35.c +@@ -50,6 +50,7 @@ + + static bool smbios_type1_defaults = true; + static bool has_pci_info = true; ++static bool has_acpi_build = true; + + /* PC hardware initialisation */ + static void pc_q35_init(QEMUMachineInitArgs *args) +@@ -110,6 +111,7 @@ static void pc_q35_init(QEMUMachineInitArgs *args) + + guest_info = pc_guest_info_init(below_4g_mem_size, above_4g_mem_size); + guest_info->has_pci_info = has_pci_info; ++ guest_info->has_acpi_build = has_acpi_build; + + /* allocate ram and load rom/bios */ + if (!xen_enabled()) { +diff --git a/include/hw/i386/pc.h b/include/hw/i386/pc.h +index 8793715..5c69abe 100644 +--- a/include/hw/i386/pc.h ++++ b/include/hw/i386/pc.h +@@ -41,6 +41,7 @@ struct PcGuestInfo { + uint64_t *node_mem; + uint64_t *node_cpu; + FWCfgState *fw_cfg; ++ bool has_acpi_build; + }; + + /* parallel.c */ +-- +1.7.11.7 + diff --git a/SOURCES/kvm-i386-add-ACPI-table-files-from-seabios.patch b/SOURCES/kvm-i386-add-ACPI-table-files-from-seabios.patch new file mode 100644 index 0000000..ec595a5 --- /dev/null +++ b/SOURCES/kvm-i386-add-ACPI-table-files-from-seabios.patch @@ -0,0 +1,2058 @@ +From 4d111d7b23baba92ce5a2f7deb7d33f4088d8342 Mon Sep 17 00:00:00 2001 +Message-Id: <4d111d7b23baba92ce5a2f7deb7d33f4088d8342.1387298827.git.minovotn@redhat.com> +In-Reply-To: <3ed0fb61a3dc912ef036d7ef450bed192090709e.1387298827.git.minovotn@redhat.com> +References: <3ed0fb61a3dc912ef036d7ef450bed192090709e.1387298827.git.minovotn@redhat.com> +From: "Michael S. Tsirkin" +Date: Tue, 17 Dec 2013 15:18:12 +0100 +Subject: [PATCH 32/56] i386: add ACPI table files from seabios + +RH-Author: Michael S. Tsirkin +Message-id: <1387293161-4085-33-git-send-email-mst@redhat.com> +Patchwork-id: 56338 +O-Subject: [PATCH qemu-kvm RHEL7.0 v2 32/57] i386: add ACPI table files from seabios +Bugzilla: 1034876 +RH-Acked-by: Igor Mammedov +RH-Acked-by: Marcel Apfelbaum +RH-Acked-by: Laszlo Ersek + +This adds ASL code as well as scripts for processing it, +imported from seabios git tree +commit 51684b7ced75fb76776e8ee84833fcfb6ecf12dd + +Will be used for runtime acpi table generation. + +Note: +This patch reuses some code from SeaBIOS, which was originally under +LGPLv2 and then relicensed to GPLv3 or LGPLv3, in QEMU under GPLv2+. This +relicensing has been acked by all contributors that had contributed to the +code since the v2->v3 relicense. ACKs approving the v2+ relicensing are +listed below. The list might include ACKs from people not holding +copyright on any parts of the reused code, but it's better to err on the +side of caution and include them. + +Affected SeaBIOS files (GPLv2+ license headers added) +: + + src/acpi-dsdt-cpu-hotplug.dsl + src/acpi-dsdt-dbug.dsl + src/acpi-dsdt-hpet.dsl + src/acpi-dsdt-isa.dsl + src/acpi-dsdt-pci-crs.dsl + src/acpi.c + src/acpi.h + src/ssdt-misc.dsl + src/ssdt-pcihp.dsl + src/ssdt-proc.dsl + tools/acpi_extract.py + tools/acpi_extract_preprocess.py + +Each one of the listed people agreed to the following: + +> If you allow the use of your contribution in QEMU under the +> terms of GPLv2 or later as proposed by this patch, +> please respond to this mail including the line: +> +> Acked-by: Name + + Acked-by: Gerd Hoffmann + Acked-by: Jan Kiszka + Acked-by: Jason Baron + Acked-by: David Woodhouse + Acked-by: Gleb Natapov + Acked-by: Marcelo Tosatti + Acked-by: Dave Frodin + Acked-by: Paolo Bonzini + Acked-by: Kevin O'Connor + Acked-by: Laszlo Ersek + Acked-by: Kenji Kaneshige + Acked-by: Isaku Yamahata + Acked-by: Magnus Christensson + Acked-by: Hu Tao + Acked-by: Eduardo Habkost + +Reviewed-by: Laszlo Ersek +Reviewed-by: Hu Tao +Reviewed-by: Gerd Hoffmann +Tested-by: Gerd Hoffmann +Reviewed-by: Igor Mammedov +Tested-by: Igor Mammedov +Signed-off-by: Michael S. Tsirkin +(cherry picked from commit 74523b850189afc23b608918c458b9242757f6d9) +--- + hw/i386/acpi-dsdt-cpu-hotplug.dsl | 93 ++++++++ + hw/i386/acpi-dsdt-dbug.dsl | 41 ++++ + hw/i386/acpi-dsdt-hpet.dsl | 51 +++++ + hw/i386/acpi-dsdt-isa.dsl | 117 ++++++++++ + hw/i386/acpi-dsdt-pci-crs.dsl | 105 +++++++++ + hw/i386/acpi-dsdt.dsl | 343 ++++++++++++++++++++++++++++ + hw/i386/q35-acpi-dsdt.dsl | 452 +++++++++++++++++++++++++++++++++++++ + hw/i386/ssdt-misc.dsl | 119 ++++++++++ + hw/i386/ssdt-pcihp.dsl | 51 +++++ + hw/i386/ssdt-proc.dsl | 63 ++++++ + scripts/acpi_extract.py | 362 +++++++++++++++++++++++++++++ + scripts/acpi_extract_preprocess.py | 51 +++++ + 12 files changed, 1848 insertions(+) + create mode 100644 hw/i386/acpi-dsdt-cpu-hotplug.dsl + create mode 100644 hw/i386/acpi-dsdt-dbug.dsl + create mode 100644 hw/i386/acpi-dsdt-hpet.dsl + create mode 100644 hw/i386/acpi-dsdt-isa.dsl + create mode 100644 hw/i386/acpi-dsdt-pci-crs.dsl + create mode 100644 hw/i386/acpi-dsdt.dsl + create mode 100644 hw/i386/q35-acpi-dsdt.dsl + create mode 100644 hw/i386/ssdt-misc.dsl + create mode 100644 hw/i386/ssdt-pcihp.dsl + create mode 100644 hw/i386/ssdt-proc.dsl + create mode 100755 scripts/acpi_extract.py + create mode 100755 scripts/acpi_extract_preprocess.py + +Signed-off-by: Michal Novotny +--- + hw/i386/acpi-dsdt-cpu-hotplug.dsl | 93 ++++++++ + hw/i386/acpi-dsdt-dbug.dsl | 41 ++++ + hw/i386/acpi-dsdt-hpet.dsl | 51 +++++ + hw/i386/acpi-dsdt-isa.dsl | 117 ++++++++++ + hw/i386/acpi-dsdt-pci-crs.dsl | 105 +++++++++ + hw/i386/acpi-dsdt.dsl | 343 ++++++++++++++++++++++++++++ + hw/i386/q35-acpi-dsdt.dsl | 452 +++++++++++++++++++++++++++++++++++++ + hw/i386/ssdt-misc.dsl | 119 ++++++++++ + hw/i386/ssdt-pcihp.dsl | 51 +++++ + hw/i386/ssdt-proc.dsl | 63 ++++++ + scripts/acpi_extract.py | 362 +++++++++++++++++++++++++++++ + scripts/acpi_extract_preprocess.py | 51 +++++ + 12 files changed, 1848 insertions(+) + create mode 100644 hw/i386/acpi-dsdt-cpu-hotplug.dsl + create mode 100644 hw/i386/acpi-dsdt-dbug.dsl + create mode 100644 hw/i386/acpi-dsdt-hpet.dsl + create mode 100644 hw/i386/acpi-dsdt-isa.dsl + create mode 100644 hw/i386/acpi-dsdt-pci-crs.dsl + create mode 100644 hw/i386/acpi-dsdt.dsl + create mode 100644 hw/i386/q35-acpi-dsdt.dsl + create mode 100644 hw/i386/ssdt-misc.dsl + create mode 100644 hw/i386/ssdt-pcihp.dsl + create mode 100644 hw/i386/ssdt-proc.dsl + create mode 100755 scripts/acpi_extract.py + create mode 100755 scripts/acpi_extract_preprocess.py + +diff --git a/hw/i386/acpi-dsdt-cpu-hotplug.dsl b/hw/i386/acpi-dsdt-cpu-hotplug.dsl +new file mode 100644 +index 0000000..c96ac42 +--- /dev/null ++++ b/hw/i386/acpi-dsdt-cpu-hotplug.dsl +@@ -0,0 +1,93 @@ ++/* ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 2 of the License, or ++ * (at your option) any later version. ++ ++ * This program is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ * GNU General Public License for more details. ++ ++ * You should have received a copy of the GNU General Public License along ++ * with this program; if not, see . ++ */ ++ ++/**************************************************************** ++ * CPU hotplug ++ ****************************************************************/ ++ ++Scope(\_SB) { ++ /* Objects filled in by run-time generated SSDT */ ++ External(NTFY, MethodObj) ++ External(CPON, PkgObj) ++ ++ /* Methods called by run-time generated SSDT Processor objects */ ++ Method(CPMA, 1, NotSerialized) { ++ // _MAT method - create an madt apic buffer ++ // Arg0 = Processor ID = Local APIC ID ++ // Local0 = CPON flag for this cpu ++ Store(DerefOf(Index(CPON, Arg0)), Local0) ++ // Local1 = Buffer (in madt apic form) to return ++ Store(Buffer(8) {0x00, 0x08, 0x00, 0x00, 0x00, 0, 0, 0}, Local1) ++ // Update the processor id, lapic id, and enable/disable status ++ Store(Arg0, Index(Local1, 2)) ++ Store(Arg0, Index(Local1, 3)) ++ Store(Local0, Index(Local1, 4)) ++ Return (Local1) ++ } ++ Method(CPST, 1, NotSerialized) { ++ // _STA method - return ON status of cpu ++ // Arg0 = Processor ID = Local APIC ID ++ // Local0 = CPON flag for this cpu ++ Store(DerefOf(Index(CPON, Arg0)), Local0) ++ If (Local0) { ++ Return (0xF) ++ } Else { ++ Return (0x0) ++ } ++ } ++ Method(CPEJ, 2, NotSerialized) { ++ // _EJ0 method - eject callback ++ Sleep(200) ++ } ++ ++ /* CPU hotplug notify method */ ++ OperationRegion(PRST, SystemIO, 0xaf00, 32) ++ Field(PRST, ByteAcc, NoLock, Preserve) { ++ PRS, 256 ++ } ++ Method(PRSC, 0) { ++ // Local5 = active cpu bitmap ++ Store(PRS, Local5) ++ // Local2 = last read byte from bitmap ++ Store(Zero, Local2) ++ // Local0 = Processor ID / APIC ID iterator ++ Store(Zero, Local0) ++ While (LLess(Local0, SizeOf(CPON))) { ++ // Local1 = CPON flag for this cpu ++ Store(DerefOf(Index(CPON, Local0)), Local1) ++ If (And(Local0, 0x07)) { ++ // Shift down previously read bitmap byte ++ ShiftRight(Local2, 1, Local2) ++ } Else { ++ // Read next byte from cpu bitmap ++ Store(DerefOf(Index(Local5, ShiftRight(Local0, 3))), Local2) ++ } ++ // Local3 = active state for this cpu ++ Store(And(Local2, 1), Local3) ++ ++ If (LNotEqual(Local1, Local3)) { ++ // State change - update CPON with new state ++ Store(Local3, Index(CPON, Local0)) ++ // Do CPU notify ++ If (LEqual(Local3, 1)) { ++ NTFY(Local0, 1) ++ } Else { ++ NTFY(Local0, 3) ++ } ++ } ++ Increment(Local0) ++ } ++ } ++} +diff --git a/hw/i386/acpi-dsdt-dbug.dsl b/hw/i386/acpi-dsdt-dbug.dsl +new file mode 100644 +index 0000000..86230f7 +--- /dev/null ++++ b/hw/i386/acpi-dsdt-dbug.dsl +@@ -0,0 +1,41 @@ ++/* ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 2 of the License, or ++ * (at your option) any later version. ++ ++ * This program is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ * GNU General Public License for more details. ++ ++ * You should have received a copy of the GNU General Public License along ++ * with this program; if not, see . ++ */ ++ ++/**************************************************************** ++ * Debugging ++ ****************************************************************/ ++ ++Scope(\) { ++ /* Debug Output */ ++ OperationRegion(DBG, SystemIO, 0x0402, 0x01) ++ Field(DBG, ByteAcc, NoLock, Preserve) { ++ DBGB, 8, ++ } ++ ++ /* Debug method - use this method to send output to the QEMU ++ * BIOS debug port. This method handles strings, integers, ++ * and buffers. For example: DBUG("abc") DBUG(0x123) */ ++ Method(DBUG, 1) { ++ ToHexString(Arg0, Local0) ++ ToBuffer(Local0, Local0) ++ Subtract(SizeOf(Local0), 1, Local1) ++ Store(Zero, Local2) ++ While (LLess(Local2, Local1)) { ++ Store(DerefOf(Index(Local0, Local2)), DBGB) ++ Increment(Local2) ++ } ++ Store(0x0A, DBGB) ++ } ++} +diff --git a/hw/i386/acpi-dsdt-hpet.dsl b/hw/i386/acpi-dsdt-hpet.dsl +new file mode 100644 +index 0000000..dfde174 +--- /dev/null ++++ b/hw/i386/acpi-dsdt-hpet.dsl +@@ -0,0 +1,51 @@ ++/* ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 2 of the License, or ++ * (at your option) any later version. ++ ++ * This program is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ * GNU General Public License for more details. ++ ++ * You should have received a copy of the GNU General Public License along ++ * with this program; if not, see . ++ */ ++ ++/**************************************************************** ++ * HPET ++ ****************************************************************/ ++ ++Scope(\_SB) { ++ Device(HPET) { ++ Name(_HID, EISAID("PNP0103")) ++ Name(_UID, 0) ++ OperationRegion(HPTM, SystemMemory, 0xFED00000, 0x400) ++ Field(HPTM, DWordAcc, Lock, Preserve) { ++ VEND, 32, ++ PRD, 32, ++ } ++ Method(_STA, 0, NotSerialized) { ++ Store(VEND, Local0) ++ Store(PRD, Local1) ++ ShiftRight(Local0, 16, Local0) ++ If (LOr(LEqual(Local0, 0), LEqual(Local0, 0xffff))) { ++ Return (0x0) ++ } ++ If (LOr(LEqual(Local1, 0), LGreater(Local1, 100000000))) { ++ Return (0x0) ++ } ++ Return (0x0F) ++ } ++ Name(_CRS, ResourceTemplate() { ++#if 0 /* This makes WinXP BSOD for not yet figured reasons. */ ++ IRQNoFlags() {2, 8} ++#endif ++ Memory32Fixed(ReadOnly, ++ 0xFED00000, // Address Base ++ 0x00000400, // Address Length ++ ) ++ }) ++ } ++} +diff --git a/hw/i386/acpi-dsdt-isa.dsl b/hw/i386/acpi-dsdt-isa.dsl +new file mode 100644 +index 0000000..89caa16 +--- /dev/null ++++ b/hw/i386/acpi-dsdt-isa.dsl +@@ -0,0 +1,117 @@ ++/* ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 2 of the License, or ++ * (at your option) any later version. ++ ++ * This program is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ * GNU General Public License for more details. ++ ++ * You should have received a copy of the GNU General Public License along ++ * with this program; if not, see . ++ */ ++ ++/* Common legacy ISA style devices. */ ++Scope(\_SB.PCI0.ISA) { ++ ++ Device(RTC) { ++ Name(_HID, EisaId("PNP0B00")) ++ Name(_CRS, ResourceTemplate() { ++ IO(Decode16, 0x0070, 0x0070, 0x10, 0x02) ++ IRQNoFlags() { 8 } ++ IO(Decode16, 0x0072, 0x0072, 0x02, 0x06) ++ }) ++ } ++ ++ Device(KBD) { ++ Name(_HID, EisaId("PNP0303")) ++ Method(_STA, 0, NotSerialized) { ++ Return (0x0f) ++ } ++ Name(_CRS, ResourceTemplate() { ++ IO(Decode16, 0x0060, 0x0060, 0x01, 0x01) ++ IO(Decode16, 0x0064, 0x0064, 0x01, 0x01) ++ IRQNoFlags() { 1 } ++ }) ++ } ++ ++ Device(MOU) { ++ Name(_HID, EisaId("PNP0F13")) ++ Method(_STA, 0, NotSerialized) { ++ Return (0x0f) ++ } ++ Name(_CRS, ResourceTemplate() { ++ IRQNoFlags() { 12 } ++ }) ++ } ++ ++ Device(FDC0) { ++ Name(_HID, EisaId("PNP0700")) ++ Method(_STA, 0, NotSerialized) { ++ Store(FDEN, Local0) ++ If (LEqual(Local0, 0)) { ++ Return (0x00) ++ } Else { ++ Return (0x0F) ++ } ++ } ++ Name(_CRS, ResourceTemplate() { ++ IO(Decode16, 0x03F2, 0x03F2, 0x00, 0x04) ++ IO(Decode16, 0x03F7, 0x03F7, 0x00, 0x01) ++ IRQNoFlags() { 6 } ++ DMA(Compatibility, NotBusMaster, Transfer8) { 2 } ++ }) ++ } ++ ++ Device(LPT) { ++ Name(_HID, EisaId("PNP0400")) ++ Method(_STA, 0, NotSerialized) { ++ Store(LPEN, Local0) ++ If (LEqual(Local0, 0)) { ++ Return (0x00) ++ } Else { ++ Return (0x0F) ++ } ++ } ++ Name(_CRS, ResourceTemplate() { ++ IO(Decode16, 0x0378, 0x0378, 0x08, 0x08) ++ IRQNoFlags() { 7 } ++ }) ++ } ++ ++ Device(COM1) { ++ Name(_HID, EisaId("PNP0501")) ++ Name(_UID, 0x01) ++ Method(_STA, 0, NotSerialized) { ++ Store(CAEN, Local0) ++ If (LEqual(Local0, 0)) { ++ Return (0x00) ++ } Else { ++ Return (0x0F) ++ } ++ } ++ Name(_CRS, ResourceTemplate() { ++ IO(Decode16, 0x03F8, 0x03F8, 0x00, 0x08) ++ IRQNoFlags() { 4 } ++ }) ++ } ++ ++ Device(COM2) { ++ Name(_HID, EisaId("PNP0501")) ++ Name(_UID, 0x02) ++ Method(_STA, 0, NotSerialized) { ++ Store(CBEN, Local0) ++ If (LEqual(Local0, 0)) { ++ Return (0x00) ++ } Else { ++ Return (0x0F) ++ } ++ } ++ Name(_CRS, ResourceTemplate() { ++ IO(Decode16, 0x02F8, 0x02F8, 0x00, 0x08) ++ IRQNoFlags() { 3 } ++ }) ++ } ++} +diff --git a/hw/i386/acpi-dsdt-pci-crs.dsl b/hw/i386/acpi-dsdt-pci-crs.dsl +new file mode 100644 +index 0000000..b375a19 +--- /dev/null ++++ b/hw/i386/acpi-dsdt-pci-crs.dsl +@@ -0,0 +1,105 @@ ++/* ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 2 of the License, or ++ * (at your option) any later version. ++ ++ * This program is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ * GNU General Public License for more details. ++ ++ * You should have received a copy of the GNU General Public License along ++ * with this program; if not, see . ++ */ ++ ++/* PCI CRS (current resources) definition. */ ++Scope(\_SB.PCI0) { ++ ++ Name(CRES, ResourceTemplate() { ++ WordBusNumber(ResourceProducer, MinFixed, MaxFixed, PosDecode, ++ 0x0000, // Address Space Granularity ++ 0x0000, // Address Range Minimum ++ 0x00FF, // Address Range Maximum ++ 0x0000, // Address Translation Offset ++ 0x0100, // Address Length ++ ,, ) ++ IO(Decode16, ++ 0x0CF8, // Address Range Minimum ++ 0x0CF8, // Address Range Maximum ++ 0x01, // Address Alignment ++ 0x08, // Address Length ++ ) ++ WordIO(ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange, ++ 0x0000, // Address Space Granularity ++ 0x0000, // Address Range Minimum ++ 0x0CF7, // Address Range Maximum ++ 0x0000, // Address Translation Offset ++ 0x0CF8, // Address Length ++ ,, , TypeStatic) ++ WordIO(ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange, ++ 0x0000, // Address Space Granularity ++ 0x0D00, // Address Range Minimum ++ 0xFFFF, // Address Range Maximum ++ 0x0000, // Address Translation Offset ++ 0xF300, // Address Length ++ ,, , TypeStatic) ++ DWordMemory(ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite, ++ 0x00000000, // Address Space Granularity ++ 0x000A0000, // Address Range Minimum ++ 0x000BFFFF, // Address Range Maximum ++ 0x00000000, // Address Translation Offset ++ 0x00020000, // Address Length ++ ,, , AddressRangeMemory, TypeStatic) ++ DWordMemory(ResourceProducer, PosDecode, MinFixed, MaxFixed, NonCacheable, ReadWrite, ++ 0x00000000, // Address Space Granularity ++ 0xE0000000, // Address Range Minimum ++ 0xFEBFFFFF, // Address Range Maximum ++ 0x00000000, // Address Translation Offset ++ 0x1EC00000, // Address Length ++ ,, PW32, AddressRangeMemory, TypeStatic) ++ }) ++ ++ Name(CR64, ResourceTemplate() { ++ QWordMemory(ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite, ++ 0x00000000, // Address Space Granularity ++ 0x8000000000, // Address Range Minimum ++ 0xFFFFFFFFFF, // Address Range Maximum ++ 0x00000000, // Address Translation Offset ++ 0x8000000000, // Address Length ++ ,, PW64, AddressRangeMemory, TypeStatic) ++ }) ++ ++ Method(_CRS, 0) { ++ /* Fields provided by dynamically created ssdt */ ++ External(P0S, IntObj) ++ External(P0E, IntObj) ++ External(P1V, IntObj) ++ External(P1S, BuffObj) ++ External(P1E, BuffObj) ++ External(P1L, BuffObj) ++ ++ /* fixup 32bit pci io window */ ++ CreateDWordField(CRES, \_SB.PCI0.PW32._MIN, PS32) ++ CreateDWordField(CRES, \_SB.PCI0.PW32._MAX, PE32) ++ CreateDWordField(CRES, \_SB.PCI0.PW32._LEN, PL32) ++ Store(P0S, PS32) ++ Store(P0E, PE32) ++ Store(Add(Subtract(P0E, P0S), 1), PL32) ++ ++ If (LEqual(P1V, Zero)) { ++ Return (CRES) ++ } ++ ++ /* fixup 64bit pci io window */ ++ CreateQWordField(CR64, \_SB.PCI0.PW64._MIN, PS64) ++ CreateQWordField(CR64, \_SB.PCI0.PW64._MAX, PE64) ++ CreateQWordField(CR64, \_SB.PCI0.PW64._LEN, PL64) ++ Store(P1S, PS64) ++ Store(P1E, PE64) ++ Store(P1L, PL64) ++ /* add window and return result */ ++ ConcatenateResTemplate(CRES, CR64, Local0) ++ Return (Local0) ++ } ++} +diff --git a/hw/i386/acpi-dsdt.dsl b/hw/i386/acpi-dsdt.dsl +new file mode 100644 +index 0000000..90efce0 +--- /dev/null ++++ b/hw/i386/acpi-dsdt.dsl +@@ -0,0 +1,343 @@ ++/* ++ * Bochs/QEMU ACPI DSDT ASL definition ++ * ++ * Copyright (c) 2006 Fabrice Bellard ++ * ++ * This library is free software; you can redistribute it and/or ++ * modify it under the terms of the GNU Lesser General Public ++ * License version 2 as published by the Free Software Foundation. ++ * ++ * This library is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * Lesser General Public License for more details. ++ * ++ * You should have received a copy of the GNU Lesser General Public ++ * License along with this library; if not, write to the Free Software ++ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA ++ */ ++ ++ACPI_EXTRACT_ALL_CODE AcpiDsdtAmlCode ++ ++DefinitionBlock ( ++ "acpi-dsdt.aml", // Output Filename ++ "DSDT", // Signature ++ 0x01, // DSDT Compliance Revision ++ "BXPC", // OEMID ++ "BXDSDT", // TABLE ID ++ 0x1 // OEM Revision ++ ) ++{ ++ ++#include "acpi-dsdt-dbug.dsl" ++ ++ ++/**************************************************************** ++ * PCI Bus definition ++ ****************************************************************/ ++ ++ Scope(\_SB) { ++ Device(PCI0) { ++ Name(_HID, EisaId("PNP0A03")) ++ Name(_ADR, 0x00) ++ Name(_UID, 1) ++ } ++ } ++ ++#include "acpi-dsdt-pci-crs.dsl" ++#include "acpi-dsdt-hpet.dsl" ++ ++ ++/**************************************************************** ++ * VGA ++ ****************************************************************/ ++ ++ Scope(\_SB.PCI0) { ++ Device(VGA) { ++ Name(_ADR, 0x00020000) ++ OperationRegion(PCIC, PCI_Config, Zero, 0x4) ++ Field(PCIC, DWordAcc, NoLock, Preserve) { ++ VEND, 32 ++ } ++ Method(_S1D, 0, NotSerialized) { ++ Return (0x00) ++ } ++ Method(_S2D, 0, NotSerialized) { ++ Return (0x00) ++ } ++ Method(_S3D, 0, NotSerialized) { ++ If (LEqual(VEND, 0x1001b36)) { ++ Return (0x03) // QXL ++ } Else { ++ Return (0x00) ++ } ++ } ++ } ++ } ++ ++ ++/**************************************************************** ++ * PIIX4 PM ++ ****************************************************************/ ++ ++ Scope(\_SB.PCI0) { ++ Device(PX13) { ++ Name(_ADR, 0x00010003) ++ OperationRegion(P13C, PCI_Config, 0x00, 0xff) ++ } ++ } ++ ++ ++/**************************************************************** ++ * PIIX3 ISA bridge ++ ****************************************************************/ ++ ++ Scope(\_SB.PCI0) { ++ Device(ISA) { ++ Name(_ADR, 0x00010000) ++ ++ /* PIIX PCI to ISA irq remapping */ ++ OperationRegion(P40C, PCI_Config, 0x60, 0x04) ++ ++ /* enable bits */ ++ Field(\_SB.PCI0.PX13.P13C, AnyAcc, NoLock, Preserve) { ++ Offset(0x5f), ++ , 7, ++ LPEN, 1, // LPT ++ Offset(0x67), ++ , 3, ++ CAEN, 1, // COM1 ++ , 3, ++ CBEN, 1, // COM2 ++ } ++ Name(FDEN, 1) ++ } ++ } ++ ++#include "acpi-dsdt-isa.dsl" ++ ++ ++/**************************************************************** ++ * PCI hotplug ++ ****************************************************************/ ++ ++ Scope(\_SB.PCI0) { ++ OperationRegion(PCST, SystemIO, 0xae00, 0x08) ++ Field(PCST, DWordAcc, NoLock, WriteAsZeros) { ++ PCIU, 32, ++ PCID, 32, ++ } ++ ++ OperationRegion(SEJ, SystemIO, 0xae08, 0x04) ++ Field(SEJ, DWordAcc, NoLock, WriteAsZeros) { ++ B0EJ, 32, ++ } ++ ++ /* Methods called by bulk generated PCI devices below */ ++ ++ /* Methods called by hotplug devices */ ++ Method(PCEJ, 1, NotSerialized) { ++ // _EJ0 method - eject callback ++ Store(ShiftLeft(1, Arg0), B0EJ) ++ Return (0x0) ++ } ++ ++ /* Hotplug notification method supplied by SSDT */ ++ External(\_SB.PCI0.PCNT, MethodObj) ++ ++ /* PCI hotplug notify method */ ++ Method(PCNF, 0) { ++ // Local0 = iterator ++ Store(Zero, Local0) ++ While (LLess(Local0, 31)) { ++ Increment(Local0) ++ If (And(PCIU, ShiftLeft(1, Local0))) { ++ PCNT(Local0, 1) ++ } ++ If (And(PCID, ShiftLeft(1, Local0))) { ++ PCNT(Local0, 3) ++ } ++ } ++ } ++ } ++ ++ ++/**************************************************************** ++ * PCI IRQs ++ ****************************************************************/ ++ ++ Scope(\_SB) { ++ Scope(PCI0) { ++ Name(_PRT, Package() { ++ /* PCI IRQ routing table, example from ACPI 2.0a specification, ++ section 6.2.8.1 */ ++ /* Note: we provide the same info as the PCI routing ++ table of the Bochs BIOS */ ++ ++#define prt_slot(nr, lnk0, lnk1, lnk2, lnk3) \ ++ Package() { nr##ffff, 0, lnk0, 0 }, \ ++ Package() { nr##ffff, 1, lnk1, 0 }, \ ++ Package() { nr##ffff, 2, lnk2, 0 }, \ ++ Package() { nr##ffff, 3, lnk3, 0 } ++ ++#define prt_slot0(nr) prt_slot(nr, LNKD, LNKA, LNKB, LNKC) ++#define prt_slot1(nr) prt_slot(nr, LNKA, LNKB, LNKC, LNKD) ++#define prt_slot2(nr) prt_slot(nr, LNKB, LNKC, LNKD, LNKA) ++#define prt_slot3(nr) prt_slot(nr, LNKC, LNKD, LNKA, LNKB) ++ ++ prt_slot0(0x0000), ++ /* Device 1 is power mgmt device, and can only use irq 9 */ ++ prt_slot(0x0001, LNKS, LNKB, LNKC, LNKD), ++ prt_slot2(0x0002), ++ prt_slot3(0x0003), ++ prt_slot0(0x0004), ++ prt_slot1(0x0005), ++ prt_slot2(0x0006), ++ prt_slot3(0x0007), ++ prt_slot0(0x0008), ++ prt_slot1(0x0009), ++ prt_slot2(0x000a), ++ prt_slot3(0x000b), ++ prt_slot0(0x000c), ++ prt_slot1(0x000d), ++ prt_slot2(0x000e), ++ prt_slot3(0x000f), ++ prt_slot0(0x0010), ++ prt_slot1(0x0011), ++ prt_slot2(0x0012), ++ prt_slot3(0x0013), ++ prt_slot0(0x0014), ++ prt_slot1(0x0015), ++ prt_slot2(0x0016), ++ prt_slot3(0x0017), ++ prt_slot0(0x0018), ++ prt_slot1(0x0019), ++ prt_slot2(0x001a), ++ prt_slot3(0x001b), ++ prt_slot0(0x001c), ++ prt_slot1(0x001d), ++ prt_slot2(0x001e), ++ prt_slot3(0x001f), ++ }) ++ } ++ ++ Field(PCI0.ISA.P40C, ByteAcc, NoLock, Preserve) { ++ PRQ0, 8, ++ PRQ1, 8, ++ PRQ2, 8, ++ PRQ3, 8 ++ } ++ ++ Method(IQST, 1, NotSerialized) { ++ // _STA method - get status ++ If (And(0x80, Arg0)) { ++ Return (0x09) ++ } ++ Return (0x0B) ++ } ++ Method(IQCR, 1, NotSerialized) { ++ // _CRS method - get current settings ++ Name(PRR0, ResourceTemplate() { ++ Interrupt(, Level, ActiveHigh, Shared) { 0 } ++ }) ++ CreateDWordField(PRR0, 0x05, PRRI) ++ If (LLess(Arg0, 0x80)) { ++ Store(Arg0, PRRI) ++ } ++ Return (PRR0) ++ } ++ ++#define define_link(link, uid, reg) \ ++ Device(link) { \ ++ Name(_HID, EISAID("PNP0C0F")) \ ++ Name(_UID, uid) \ ++ Name(_PRS, ResourceTemplate() { \ ++ Interrupt(, Level, ActiveHigh, Shared) { \ ++ 5, 10, 11 \ ++ } \ ++ }) \ ++ Method(_STA, 0, NotSerialized) { \ ++ Return (IQST(reg)) \ ++ } \ ++ Method(_DIS, 0, NotSerialized) { \ ++ Or(reg, 0x80, reg) \ ++ } \ ++ Method(_CRS, 0, NotSerialized) { \ ++ Return (IQCR(reg)) \ ++ } \ ++ Method(_SRS, 1, NotSerialized) { \ ++ CreateDWordField(Arg0, 0x05, PRRI) \ ++ Store(PRRI, reg) \ ++ } \ ++ } ++ ++ define_link(LNKA, 0, PRQ0) ++ define_link(LNKB, 1, PRQ1) ++ define_link(LNKC, 2, PRQ2) ++ define_link(LNKD, 3, PRQ3) ++ ++ Device(LNKS) { ++ Name(_HID, EISAID("PNP0C0F")) ++ Name(_UID, 4) ++ Name(_PRS, ResourceTemplate() { ++ Interrupt(, Level, ActiveHigh, Shared) { 9 } ++ }) ++ ++ // The SCI cannot be disabled and is always attached to GSI 9, ++ // so these are no-ops. We only need this link to override the ++ // polarity to active high and match the content of the MADT. ++ Method(_STA, 0, NotSerialized) { Return (0x0b) } ++ Method(_DIS, 0, NotSerialized) { } ++ Method(_CRS, 0, NotSerialized) { Return (_PRS) } ++ Method(_SRS, 1, NotSerialized) { } ++ } ++ } ++ ++#include "acpi-dsdt-cpu-hotplug.dsl" ++ ++ ++/**************************************************************** ++ * General purpose events ++ ****************************************************************/ ++ ++ Scope(\_GPE) { ++ Name(_HID, "ACPI0006") ++ ++ Method(_L00) { ++ } ++ Method(_E01) { ++ // PCI hotplug event ++ \_SB.PCI0.PCNF() ++ } ++ Method(_E02) { ++ // CPU hotplug event ++ \_SB.PRSC() ++ } ++ Method(_L03) { ++ } ++ Method(_L04) { ++ } ++ Method(_L05) { ++ } ++ Method(_L06) { ++ } ++ Method(_L07) { ++ } ++ Method(_L08) { ++ } ++ Method(_L09) { ++ } ++ Method(_L0A) { ++ } ++ Method(_L0B) { ++ } ++ Method(_L0C) { ++ } ++ Method(_L0D) { ++ } ++ Method(_L0E) { ++ } ++ Method(_L0F) { ++ } ++ } ++} +diff --git a/hw/i386/q35-acpi-dsdt.dsl b/hw/i386/q35-acpi-dsdt.dsl +new file mode 100644 +index 0000000..21c89b0 +--- /dev/null ++++ b/hw/i386/q35-acpi-dsdt.dsl +@@ -0,0 +1,452 @@ ++/* ++ * Bochs/QEMU ACPI DSDT ASL definition ++ * ++ * Copyright (c) 2006 Fabrice Bellard ++ * ++ * This library is free software; you can redistribute it and/or ++ * modify it under the terms of the GNU Lesser General Public ++ * License version 2 as published by the Free Software Foundation. ++ * ++ * This library is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * Lesser General Public License for more details. ++ * ++ * You should have received a copy of the GNU Lesser General Public ++ * License along with this library; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA ++ */ ++/* ++ * Copyright (c) 2010 Isaku Yamahata ++ * yamahata at valinux co jp ++ * Based on acpi-dsdt.dsl, but heavily modified for q35 chipset. ++ */ ++ ++ACPI_EXTRACT_ALL_CODE Q35AcpiDsdtAmlCode ++ ++DefinitionBlock ( ++ "q35-acpi-dsdt.aml",// Output Filename ++ "DSDT", // Signature ++ 0x01, // DSDT Compliance Revision ++ "BXPC", // OEMID ++ "BXDSDT", // TABLE ID ++ 0x2 // OEM Revision ++ ) ++{ ++ ++#include "acpi-dsdt-dbug.dsl" ++ ++ Scope(\_SB) { ++ OperationRegion(PCST, SystemIO, 0xae00, 0x0c) ++ OperationRegion(PCSB, SystemIO, 0xae0c, 0x01) ++ Field(PCSB, AnyAcc, NoLock, WriteAsZeros) { ++ PCIB, 8, ++ } ++ } ++ ++ ++/**************************************************************** ++ * PCI Bus definition ++ ****************************************************************/ ++ ++ Scope(\_SB) { ++ Device(PCI0) { ++ Name(_HID, EisaId("PNP0A08")) ++ Name(_CID, EisaId("PNP0A03")) ++ Name(_ADR, 0x00) ++ Name(_UID, 1) ++ ++ // _OSC: based on sample of ACPI3.0b spec ++ Name(SUPP, 0) // PCI _OSC Support Field value ++ Name(CTRL, 0) // PCI _OSC Control Field value ++ Method(_OSC, 4) { ++ // Create DWORD-addressable fields from the Capabilities Buffer ++ CreateDWordField(Arg3, 0, CDW1) ++ ++ // Check for proper UUID ++ If (LEqual(Arg0, ToUUID("33DB4D5B-1FF7-401C-9657-7441C03DD766"))) { ++ // Create DWORD-addressable fields from the Capabilities Buffer ++ CreateDWordField(Arg3, 4, CDW2) ++ CreateDWordField(Arg3, 8, CDW3) ++ ++ // Save Capabilities DWORD2 & 3 ++ Store(CDW2, SUPP) ++ Store(CDW3, CTRL) ++ ++ // Always allow native PME, AER (no dependencies) ++ // Never allow SHPC (no SHPC controller in this system) ++ And(CTRL, 0x1D, CTRL) ++ ++#if 0 // For now, nothing to do ++ If (Not(And(CDW1, 1))) { // Query flag clear? ++ // Disable GPEs for features granted native control. ++ If (And(CTRL, 0x01)) { // Hot plug control granted? ++ Store(0, HPCE) // clear the hot plug SCI enable bit ++ Store(1, HPCS) // clear the hot plug SCI status bit ++ } ++ If (And(CTRL, 0x04)) { // PME control granted? ++ Store(0, PMCE) // clear the PME SCI enable bit ++ Store(1, PMCS) // clear the PME SCI status bit ++ } ++ If (And(CTRL, 0x10)) { // OS restoring PCI Express cap structure? ++ // Set status to not restore PCI Express cap structure ++ // upon resume from S3 ++ Store(1, S3CR) ++ } ++ } ++#endif ++ If (LNotEqual(Arg1, One)) { ++ // Unknown revision ++ Or(CDW1, 0x08, CDW1) ++ } ++ If (LNotEqual(CDW3, CTRL)) { ++ // Capabilities bits were masked ++ Or(CDW1, 0x10, CDW1) ++ } ++ // Update DWORD3 in the buffer ++ Store(CTRL, CDW3) ++ } Else { ++ Or(CDW1, 4, CDW1) // Unrecognized UUID ++ } ++ Return (Arg3) ++ } ++ } ++ } ++ ++#include "acpi-dsdt-pci-crs.dsl" ++#include "acpi-dsdt-hpet.dsl" ++ ++ ++/**************************************************************** ++ * VGA ++ ****************************************************************/ ++ ++ Scope(\_SB.PCI0) { ++ Device(VGA) { ++ Name(_ADR, 0x00010000) ++ Method(_S1D, 0, NotSerialized) { ++ Return (0x00) ++ } ++ Method(_S2D, 0, NotSerialized) { ++ Return (0x00) ++ } ++ Method(_S3D, 0, NotSerialized) { ++ Return (0x00) ++ } ++ } ++ } ++ ++ ++/**************************************************************** ++ * LPC ISA bridge ++ ****************************************************************/ ++ ++ Scope(\_SB.PCI0) { ++ /* PCI D31:f0 LPC ISA bridge */ ++ Device(ISA) { ++ /* PCI D31:f0 */ ++ Name(_ADR, 0x001f0000) ++ ++ /* ICH9 PCI to ISA irq remapping */ ++ OperationRegion(PIRQ, PCI_Config, 0x60, 0x0C) ++ ++ OperationRegion(LPCD, PCI_Config, 0x80, 0x2) ++ Field(LPCD, AnyAcc, NoLock, Preserve) { ++ COMA, 3, ++ , 1, ++ COMB, 3, ++ ++ Offset(0x01), ++ LPTD, 2, ++ , 2, ++ FDCD, 2 ++ } ++ OperationRegion(LPCE, PCI_Config, 0x82, 0x2) ++ Field(LPCE, AnyAcc, NoLock, Preserve) { ++ CAEN, 1, ++ CBEN, 1, ++ LPEN, 1, ++ FDEN, 1 ++ } ++ } ++ } ++ ++#include "acpi-dsdt-isa.dsl" ++ ++ ++/**************************************************************** ++ * PCI IRQs ++ ****************************************************************/ ++ ++ /* Zero => PIC mode, One => APIC Mode */ ++ Name(\PICF, Zero) ++ Method(\_PIC, 1, NotSerialized) { ++ Store(Arg0, \PICF) ++ } ++ ++ Scope(\_SB) { ++ Scope(PCI0) { ++#define prt_slot_lnk(nr, lnk0, lnk1, lnk2, lnk3) \ ++ Package() { nr##ffff, 0, lnk0, 0 }, \ ++ Package() { nr##ffff, 1, lnk1, 0 }, \ ++ Package() { nr##ffff, 2, lnk2, 0 }, \ ++ Package() { nr##ffff, 3, lnk3, 0 } ++ ++#define prt_slot_lnkA(nr) prt_slot_lnk(nr, LNKA, LNKB, LNKC, LNKD) ++#define prt_slot_lnkB(nr) prt_slot_lnk(nr, LNKB, LNKC, LNKD, LNKA) ++#define prt_slot_lnkC(nr) prt_slot_lnk(nr, LNKC, LNKD, LNKA, LNKB) ++#define prt_slot_lnkD(nr) prt_slot_lnk(nr, LNKD, LNKA, LNKB, LNKC) ++ ++#define prt_slot_lnkE(nr) prt_slot_lnk(nr, LNKE, LNKF, LNKG, LNKH) ++#define prt_slot_lnkF(nr) prt_slot_lnk(nr, LNKF, LNKG, LNKH, LNKE) ++#define prt_slot_lnkG(nr) prt_slot_lnk(nr, LNKG, LNKH, LNKE, LNKF) ++#define prt_slot_lnkH(nr) prt_slot_lnk(nr, LNKH, LNKE, LNKF, LNKG) ++ ++ Name(PRTP, package() { ++ prt_slot_lnkE(0x0000), ++ prt_slot_lnkF(0x0001), ++ prt_slot_lnkG(0x0002), ++ prt_slot_lnkH(0x0003), ++ prt_slot_lnkE(0x0004), ++ prt_slot_lnkF(0x0005), ++ prt_slot_lnkG(0x0006), ++ prt_slot_lnkH(0x0007), ++ prt_slot_lnkE(0x0008), ++ prt_slot_lnkF(0x0009), ++ prt_slot_lnkG(0x000a), ++ prt_slot_lnkH(0x000b), ++ prt_slot_lnkE(0x000c), ++ prt_slot_lnkF(0x000d), ++ prt_slot_lnkG(0x000e), ++ prt_slot_lnkH(0x000f), ++ prt_slot_lnkE(0x0010), ++ prt_slot_lnkF(0x0011), ++ prt_slot_lnkG(0x0012), ++ prt_slot_lnkH(0x0013), ++ prt_slot_lnkE(0x0014), ++ prt_slot_lnkF(0x0015), ++ prt_slot_lnkG(0x0016), ++ prt_slot_lnkH(0x0017), ++ prt_slot_lnkE(0x0018), ++ ++ /* INTA -> PIRQA for slot 25 - 31 ++ see the default value of DIR */ ++ prt_slot_lnkA(0x0019), ++ prt_slot_lnkA(0x001a), ++ prt_slot_lnkA(0x001b), ++ prt_slot_lnkA(0x001c), ++ prt_slot_lnkA(0x001d), ++ ++ /* PCIe->PCI bridge. use PIRQ[E-H] */ ++ prt_slot_lnkE(0x001e), ++ ++ prt_slot_lnkA(0x001f) ++ }) ++ ++#define prt_slot_gsi(nr, gsi0, gsi1, gsi2, gsi3) \ ++ Package() { nr##ffff, 0, gsi0, 0 }, \ ++ Package() { nr##ffff, 1, gsi1, 0 }, \ ++ Package() { nr##ffff, 2, gsi2, 0 }, \ ++ Package() { nr##ffff, 3, gsi3, 0 } ++ ++#define prt_slot_gsiA(nr) prt_slot_gsi(nr, GSIA, GSIB, GSIC, GSID) ++#define prt_slot_gsiB(nr) prt_slot_gsi(nr, GSIB, GSIC, GSID, GSIA) ++#define prt_slot_gsiC(nr) prt_slot_gsi(nr, GSIC, GSID, GSIA, GSIB) ++#define prt_slot_gsiD(nr) prt_slot_gsi(nr, GSID, GSIA, GSIB, GSIC) ++ ++#define prt_slot_gsiE(nr) prt_slot_gsi(nr, GSIE, GSIF, GSIG, GSIH) ++#define prt_slot_gsiF(nr) prt_slot_gsi(nr, GSIF, GSIG, GSIH, GSIE) ++#define prt_slot_gsiG(nr) prt_slot_gsi(nr, GSIG, GSIH, GSIE, GSIF) ++#define prt_slot_gsiH(nr) prt_slot_gsi(nr, GSIH, GSIE, GSIF, GSIG) ++ ++ Name(PRTA, package() { ++ prt_slot_gsiE(0x0000), ++ prt_slot_gsiF(0x0001), ++ prt_slot_gsiG(0x0002), ++ prt_slot_gsiH(0x0003), ++ prt_slot_gsiE(0x0004), ++ prt_slot_gsiF(0x0005), ++ prt_slot_gsiG(0x0006), ++ prt_slot_gsiH(0x0007), ++ prt_slot_gsiE(0x0008), ++ prt_slot_gsiF(0x0009), ++ prt_slot_gsiG(0x000a), ++ prt_slot_gsiH(0x000b), ++ prt_slot_gsiE(0x000c), ++ prt_slot_gsiF(0x000d), ++ prt_slot_gsiG(0x000e), ++ prt_slot_gsiH(0x000f), ++ prt_slot_gsiE(0x0010), ++ prt_slot_gsiF(0x0011), ++ prt_slot_gsiG(0x0012), ++ prt_slot_gsiH(0x0013), ++ prt_slot_gsiE(0x0014), ++ prt_slot_gsiF(0x0015), ++ prt_slot_gsiG(0x0016), ++ prt_slot_gsiH(0x0017), ++ prt_slot_gsiE(0x0018), ++ ++ /* INTA -> PIRQA for slot 25 - 31, but 30 ++ see the default value of DIR */ ++ prt_slot_gsiA(0x0019), ++ prt_slot_gsiA(0x001a), ++ prt_slot_gsiA(0x001b), ++ prt_slot_gsiA(0x001c), ++ prt_slot_gsiA(0x001d), ++ ++ /* PCIe->PCI bridge. use PIRQ[E-H] */ ++ prt_slot_gsiE(0x001e), ++ ++ prt_slot_gsiA(0x001f) ++ }) ++ ++ Method(_PRT, 0, NotSerialized) { ++ /* PCI IRQ routing table, example from ACPI 2.0a specification, ++ section 6.2.8.1 */ ++ /* Note: we provide the same info as the PCI routing ++ table of the Bochs BIOS */ ++ If (LEqual(\PICF, Zero)) { ++ Return (PRTP) ++ } Else { ++ Return (PRTA) ++ } ++ } ++ } ++ ++ Field(PCI0.ISA.PIRQ, ByteAcc, NoLock, Preserve) { ++ PRQA, 8, ++ PRQB, 8, ++ PRQC, 8, ++ PRQD, 8, ++ ++ Offset(0x08), ++ PRQE, 8, ++ PRQF, 8, ++ PRQG, 8, ++ PRQH, 8 ++ } ++ ++ Method(IQST, 1, NotSerialized) { ++ // _STA method - get status ++ If (And(0x80, Arg0)) { ++ Return (0x09) ++ } ++ Return (0x0B) ++ } ++ Method(IQCR, 1, NotSerialized) { ++ // _CRS method - get current settings ++ Name(PRR0, ResourceTemplate() { ++ Interrupt(, Level, ActiveHigh, Shared) { 0 } ++ }) ++ CreateDWordField(PRR0, 0x05, PRRI) ++ Store(And(Arg0, 0x0F), PRRI) ++ Return (PRR0) ++ } ++ ++#define define_link(link, uid, reg) \ ++ Device(link) { \ ++ Name(_HID, EISAID("PNP0C0F")) \ ++ Name(_UID, uid) \ ++ Name(_PRS, ResourceTemplate() { \ ++ Interrupt(, Level, ActiveHigh, Shared) { \ ++ 5, 10, 11 \ ++ } \ ++ }) \ ++ Method(_STA, 0, NotSerialized) { \ ++ Return (IQST(reg)) \ ++ } \ ++ Method(_DIS, 0, NotSerialized) { \ ++ Or(reg, 0x80, reg) \ ++ } \ ++ Method(_CRS, 0, NotSerialized) { \ ++ Return (IQCR(reg)) \ ++ } \ ++ Method(_SRS, 1, NotSerialized) { \ ++ CreateDWordField(Arg0, 0x05, PRRI) \ ++ Store(PRRI, reg) \ ++ } \ ++ } ++ ++ define_link(LNKA, 0, PRQA) ++ define_link(LNKB, 1, PRQB) ++ define_link(LNKC, 2, PRQC) ++ define_link(LNKD, 3, PRQD) ++ define_link(LNKE, 4, PRQE) ++ define_link(LNKF, 5, PRQF) ++ define_link(LNKG, 6, PRQG) ++ define_link(LNKH, 7, PRQH) ++ ++#define define_gsi_link(link, uid, gsi) \ ++ Device(link) { \ ++ Name(_HID, EISAID("PNP0C0F")) \ ++ Name(_UID, uid) \ ++ Name(_PRS, ResourceTemplate() { \ ++ Interrupt(, Level, ActiveHigh, Shared) { \ ++ gsi \ ++ } \ ++ }) \ ++ Name(_CRS, ResourceTemplate() { \ ++ Interrupt(, Level, ActiveHigh, Shared) { \ ++ gsi \ ++ } \ ++ }) \ ++ Method(_SRS, 1, NotSerialized) { \ ++ } \ ++ } ++ ++ define_gsi_link(GSIA, 0, 0x10) ++ define_gsi_link(GSIB, 0, 0x11) ++ define_gsi_link(GSIC, 0, 0x12) ++ define_gsi_link(GSID, 0, 0x13) ++ define_gsi_link(GSIE, 0, 0x14) ++ define_gsi_link(GSIF, 0, 0x15) ++ define_gsi_link(GSIG, 0, 0x16) ++ define_gsi_link(GSIH, 0, 0x17) ++ } ++ ++#include "acpi-dsdt-cpu-hotplug.dsl" ++ ++ ++/**************************************************************** ++ * General purpose events ++ ****************************************************************/ ++ ++ Scope(\_GPE) { ++ Name(_HID, "ACPI0006") ++ ++ Method(_L00) { ++ } ++ Method(_L01) { ++ // CPU hotplug event ++ \_SB.PRSC() ++ } ++ Method(_L02) { ++ } ++ Method(_L03) { ++ } ++ Method(_L04) { ++ } ++ Method(_L05) { ++ } ++ Method(_L06) { ++ } ++ Method(_L07) { ++ } ++ Method(_L08) { ++ } ++ Method(_L09) { ++ } ++ Method(_L0A) { ++ } ++ Method(_L0B) { ++ } ++ Method(_L0C) { ++ } ++ Method(_L0D) { ++ } ++ Method(_L0E) { ++ } ++ Method(_L0F) { ++ } ++ } ++} +diff --git a/hw/i386/ssdt-misc.dsl b/hw/i386/ssdt-misc.dsl +new file mode 100644 +index 0000000..a4484b8 +--- /dev/null ++++ b/hw/i386/ssdt-misc.dsl +@@ -0,0 +1,119 @@ ++/* ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 2 of the License, or ++ * (at your option) any later version. ++ ++ * This program is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ * GNU General Public License for more details. ++ ++ * You should have received a copy of the GNU General Public License along ++ * with this program; if not, see . ++ */ ++ ++ACPI_EXTRACT_ALL_CODE ssdp_misc_aml ++ ++DefinitionBlock ("ssdt-misc.aml", "SSDT", 0x01, "BXPC", "BXSSDTSUSP", 0x1) ++{ ++ ++/**************************************************************** ++ * PCI memory ranges ++ ****************************************************************/ ++ ++ Scope(\) { ++ ACPI_EXTRACT_NAME_DWORD_CONST acpi_pci32_start ++ Name(P0S, 0x12345678) ++ ACPI_EXTRACT_NAME_DWORD_CONST acpi_pci32_end ++ Name(P0E, 0x12345678) ++ ACPI_EXTRACT_NAME_BYTE_CONST acpi_pci64_valid ++ Name(P1V, 0x12) ++ ACPI_EXTRACT_NAME_BUFFER8 acpi_pci64_start ++ Name(P1S, Buffer() { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }) ++ ACPI_EXTRACT_NAME_BUFFER8 acpi_pci64_end ++ Name(P1E, Buffer() { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }) ++ ACPI_EXTRACT_NAME_BUFFER8 acpi_pci64_length ++ Name(P1L, Buffer() { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }) ++ } ++ ++ ++/**************************************************************** ++ * Suspend ++ ****************************************************************/ ++ ++ Scope(\) { ++ /* ++ * S3 (suspend-to-ram), S4 (suspend-to-disk) and S5 (power-off) type codes: ++ * must match piix4 emulation. ++ */ ++ ++ ACPI_EXTRACT_NAME_STRING acpi_s3_name ++ Name(_S3, Package(0x04) { ++ One, /* PM1a_CNT.SLP_TYP */ ++ One, /* PM1b_CNT.SLP_TYP */ ++ Zero, /* reserved */ ++ Zero /* reserved */ ++ }) ++ ACPI_EXTRACT_NAME_STRING acpi_s4_name ++ ACPI_EXTRACT_PKG_START acpi_s4_pkg ++ Name(_S4, Package(0x04) { ++ 0x2, /* PM1a_CNT.SLP_TYP */ ++ 0x2, /* PM1b_CNT.SLP_TYP */ ++ Zero, /* reserved */ ++ Zero /* reserved */ ++ }) ++ Name(_S5, Package(0x04) { ++ Zero, /* PM1a_CNT.SLP_TYP */ ++ Zero, /* PM1b_CNT.SLP_TYP */ ++ Zero, /* reserved */ ++ Zero /* reserved */ ++ }) ++ } ++ ++ External(\_SB.PCI0, DeviceObj) ++ External(\_SB.PCI0.ISA, DeviceObj) ++ ++ Scope(\_SB.PCI0.ISA) { ++ Device(PEVT) { ++ Name(_HID, "QEMU0001") ++ /* PEST will be patched to be Zero if no such device */ ++ ACPI_EXTRACT_NAME_WORD_CONST ssdt_isa_pest ++ Name(PEST, 0xFFFF) ++ OperationRegion(PEOR, SystemIO, PEST, 0x01) ++ Field(PEOR, ByteAcc, NoLock, Preserve) { ++ PEPT, 8, ++ } ++ ++ Method(_STA, 0, NotSerialized) { ++ Store(PEST, Local0) ++ If (LEqual(Local0, Zero)) { ++ Return (0x00) ++ } Else { ++ Return (0x0F) ++ } ++ } ++ ++ Method(RDPT, 0, NotSerialized) { ++ Store(PEPT, Local0) ++ Return (Local0) ++ } ++ ++ Method(WRPT, 1, NotSerialized) { ++ Store(Arg0, PEPT) ++ } ++ ++ Name(_CRS, ResourceTemplate() { ++ IO(Decode16, 0x00, 0x00, 0x01, 0x01, IO) ++ }) ++ ++ CreateWordField(_CRS, IO._MIN, IOMN) ++ CreateWordField(_CRS, IO._MAX, IOMX) ++ ++ Method(_INI, 0, NotSerialized) { ++ Store(PEST, IOMN) ++ Store(PEST, IOMX) ++ } ++ } ++ } ++} +diff --git a/hw/i386/ssdt-pcihp.dsl b/hw/i386/ssdt-pcihp.dsl +new file mode 100644 +index 0000000..d29a5b9 +--- /dev/null ++++ b/hw/i386/ssdt-pcihp.dsl +@@ -0,0 +1,51 @@ ++/* ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 2 of the License, or ++ * (at your option) any later version. ++ ++ * This program is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ * GNU General Public License for more details. ++ ++ * You should have received a copy of the GNU General Public License along ++ * with this program; if not, see . ++ */ ++ ++ACPI_EXTRACT_ALL_CODE ssdp_pcihp_aml ++ ++DefinitionBlock ("ssdt-pcihp.aml", "SSDT", 0x01, "BXPC", "BXSSDTPCIHP", 0x1) ++{ ++ ++/**************************************************************** ++ * PCI hotplug ++ ****************************************************************/ ++ ++ /* Objects supplied by DSDT */ ++ External(\_SB.PCI0, DeviceObj) ++ External(\_SB.PCI0.PCEJ, MethodObj) ++ ++ Scope(\_SB.PCI0) { ++ ++ /* Bulk generated PCI hotplug devices */ ++ ACPI_EXTRACT_DEVICE_START ssdt_pcihp_start ++ ACPI_EXTRACT_DEVICE_END ssdt_pcihp_end ++ ACPI_EXTRACT_DEVICE_STRING ssdt_pcihp_name ++ ++ // Method _EJ0 can be patched by BIOS to EJ0_ ++ // at runtime, if the slot is detected to not support hotplug. ++ // Extract the offset of the address dword and the ++ // _EJ0 name to allow this patching. ++ Device(SAA) { ++ ACPI_EXTRACT_NAME_BYTE_CONST ssdt_pcihp_id ++ Name(_SUN, 0xAA) ++ ACPI_EXTRACT_NAME_DWORD_CONST ssdt_pcihp_adr ++ Name(_ADR, 0xAA0000) ++ ACPI_EXTRACT_METHOD_STRING ssdt_pcihp_ej0 ++ Method(_EJ0, 1) { ++ Return (PCEJ(_SUN)) ++ } ++ } ++ } ++} +diff --git a/hw/i386/ssdt-proc.dsl b/hw/i386/ssdt-proc.dsl +new file mode 100644 +index 0000000..58333c7 +--- /dev/null ++++ b/hw/i386/ssdt-proc.dsl +@@ -0,0 +1,63 @@ ++/* ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 2 of the License, or ++ * (at your option) any later version. ++ ++ * This program is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ * GNU General Public License for more details. ++ ++ * You should have received a copy of the GNU General Public License along ++ * with this program; if not, see . ++ */ ++ ++/* This file is the basis for the ssdt table generated in src/acpi.c. ++ * It defines the contents of the per-cpu Processor() object. At ++ * runtime, a dynamically generated SSDT will contain one copy of this ++ * AML snippet for every possible cpu in the system. The objects will ++ * be placed in the \_SB_ namespace. ++ * ++ * In addition to the aml code generated from this file, the ++ * src/acpi.c file creates a NTFY method with an entry for each cpu: ++ * Method(NTFY, 2) { ++ * If (LEqual(Arg0, 0x00)) { Notify(CP00, Arg1) } ++ * If (LEqual(Arg0, 0x01)) { Notify(CP01, Arg1) } ++ * ... ++ * } ++ * and a CPON array with the list of active and inactive cpus: ++ * Name(CPON, Package() { One, One, ..., Zero, Zero, ... }) ++ */ ++ ++ACPI_EXTRACT_ALL_CODE ssdp_proc_aml ++ ++DefinitionBlock ("ssdt-proc.aml", "SSDT", 0x01, "BXPC", "BXSSDT", 0x1) ++{ ++ ACPI_EXTRACT_PROCESSOR_START ssdt_proc_start ++ ACPI_EXTRACT_PROCESSOR_END ssdt_proc_end ++ ACPI_EXTRACT_PROCESSOR_STRING ssdt_proc_name ++ Processor(CPAA, 0xAA, 0x0000b010, 0x06) { ++ ACPI_EXTRACT_NAME_BYTE_CONST ssdt_proc_id ++ Name(ID, 0xAA) ++/* ++ * The src/acpi.c code requires the above ACP_EXTRACT tags so that it can update ++ * CPAA and 0xAA with the appropriate CPU id (see ++ * SD_OFFSET_CPUHEX/CPUID1/CPUID2). Don't change the above without ++ * also updating the C code. ++ */ ++ Name(_HID, "ACPI0007") ++ External(CPMA, MethodObj) ++ External(CPST, MethodObj) ++ External(CPEJ, MethodObj) ++ Method(_MAT, 0) { ++ Return (CPMA(ID)) ++ } ++ Method(_STA, 0) { ++ Return (CPST(ID)) ++ } ++ Method(_EJ0, 1, NotSerialized) { ++ CPEJ(ID, Arg0) ++ } ++ } ++} +diff --git a/scripts/acpi_extract.py b/scripts/acpi_extract.py +new file mode 100755 +index 0000000..22ea468 +--- /dev/null ++++ b/scripts/acpi_extract.py +@@ -0,0 +1,362 @@ ++#!/usr/bin/python ++# Copyright (C) 2011 Red Hat, Inc., Michael S. Tsirkin ++# ++# This program is free software; you can redistribute it and/or modify ++# it under the terms of the GNU General Public License as published by ++# the Free Software Foundation; either version 2 of the License, or ++# (at your option) any later version. ++# ++# This program is distributed in the hope that it will be useful, ++# but WITHOUT ANY WARRANTY; without even the implied warranty of ++# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++# GNU General Public License for more details. ++# ++# You should have received a copy of the GNU General Public License along ++# with this program; if not, see . ++ ++# Process mixed ASL/AML listing (.lst file) produced by iasl -l ++# Locate and execute ACPI_EXTRACT directives, output offset info ++# ++# Documentation of ACPI_EXTRACT_* directive tags: ++# ++# These directive tags output offset information from AML for BIOS runtime ++# table generation. ++# Each directive is of the form: ++# ACPI_EXTRACT_ (...) ++# and causes the extractor to create an array ++# named with offset, in the generated AML, ++# of an object of a given type in the following . ++# ++# A directive must fit on a single code line. ++# ++# Object type in AML is verified, a mismatch causes a build failure. ++# ++# Directives and operators currently supported are: ++# ACPI_EXTRACT_NAME_DWORD_CONST - extract a Dword Const object from Name() ++# ACPI_EXTRACT_NAME_WORD_CONST - extract a Word Const object from Name() ++# ACPI_EXTRACT_NAME_BYTE_CONST - extract a Byte Const object from Name() ++# ACPI_EXTRACT_METHOD_STRING - extract a NameString from Method() ++# ACPI_EXTRACT_NAME_STRING - extract a NameString from Name() ++# ACPI_EXTRACT_PROCESSOR_START - start of Processor() block ++# ACPI_EXTRACT_PROCESSOR_STRING - extract a NameString from Processor() ++# ACPI_EXTRACT_PROCESSOR_END - offset at last byte of Processor() + 1 ++# ACPI_EXTRACT_PKG_START - start of Package block ++# ++# ACPI_EXTRACT_ALL_CODE - create an array storing the generated AML bytecode ++# ++# ACPI_EXTRACT is not allowed anywhere else in code, except in comments. ++ ++import re; ++import sys; ++import fileinput; ++ ++aml = [] ++asl = [] ++output = {} ++debug = "" ++ ++class asl_line: ++ line = None ++ lineno = None ++ aml_offset = None ++ ++def die(diag): ++ sys.stderr.write("Error: %s; %s\n" % (diag, debug)) ++ sys.exit(1) ++ ++#Store an ASL command, matching AML offset, and input line (for debugging) ++def add_asl(lineno, line): ++ l = asl_line() ++ l.line = line ++ l.lineno = lineno ++ l.aml_offset = len(aml) ++ asl.append(l) ++ ++#Store an AML byte sequence ++#Verify that offset output by iasl matches # of bytes so far ++def add_aml(offset, line): ++ o = int(offset, 16); ++ # Sanity check: offset must match size of code so far ++ if (o != len(aml)): ++ die("Offset 0x%x != 0x%x" % (o, len(aml))) ++ # Strip any trailing dots and ASCII dump after " ++ line = re.sub(r'\s*\.*\s*".*$',"", line) ++ # Strip traling whitespace ++ line = re.sub(r'\s+$',"", line) ++ # Strip leading whitespace ++ line = re.sub(r'^\s+',"", line) ++ # Split on whitespace ++ code = re.split(r'\s+', line) ++ for c in code: ++ # Require a legal hex number, two digits ++ if (not(re.search(r'^[0-9A-Fa-f][0-9A-Fa-f]$', c))): ++ die("Unexpected octet %s" % c); ++ aml.append(int(c, 16)); ++ ++# Process aml bytecode array, decoding AML ++def aml_pkglen_bytes(offset): ++ # PkgLength can be multibyte. Bits 8-7 give the # of extra bytes. ++ pkglenbytes = aml[offset] >> 6; ++ return pkglenbytes + 1 ++ ++def aml_pkglen(offset): ++ pkgstart = offset ++ pkglenbytes = aml_pkglen_bytes(offset) ++ pkglen = aml[offset] & 0x3F ++ # If multibyte, first nibble only uses bits 0-3 ++ if ((pkglenbytes > 1) and (pkglen & 0x30)): ++ die("PkgLen bytes 0x%x but first nibble 0x%x expected 0x0X" % ++ (pkglen, pkglen)) ++ offset += 1 ++ pkglenbytes -= 1 ++ for i in range(pkglenbytes): ++ pkglen |= aml[offset + i] << (i * 8 + 4) ++ if (len(aml) < pkgstart + pkglen): ++ die("PckgLen 0x%x at offset 0x%x exceeds AML size 0x%x" % ++ (pkglen, offset, len(aml))) ++ return pkglen ++ ++# Given method offset, find its NameString offset ++def aml_method_string(offset): ++ #0x14 MethodOp PkgLength NameString MethodFlags TermList ++ if (aml[offset] != 0x14): ++ die( "Method offset 0x%x: expected 0x14 actual 0x%x" % ++ (offset, aml[offset])); ++ offset += 1; ++ pkglenbytes = aml_pkglen_bytes(offset) ++ offset += pkglenbytes; ++ return offset; ++ ++# Given name offset, find its NameString offset ++def aml_name_string(offset): ++ #0x08 NameOp NameString DataRef ++ if (aml[offset] != 0x08): ++ die( "Name offset 0x%x: expected 0x08 actual 0x%x" % ++ (offset, aml[offset])); ++ offset += 1 ++ # Block Name Modifier. Skip it. ++ if (aml[offset] == 0x5c or aml[offset] == 0x5e): ++ offset += 1 ++ return offset; ++ ++# Given data offset, find 8 byte buffer offset ++def aml_data_buffer8(offset): ++ #0x08 NameOp NameString DataRef ++ expect = [0x11, 0x0B, 0x0A, 0x08] ++ if (aml[offset:offset+4] != expect): ++ die( "Name offset 0x%x: expected %s actual %s" % ++ (offset, aml[offset:offset+4], expect)) ++ return offset + len(expect) ++ ++# Given data offset, find dword const offset ++def aml_data_dword_const(offset): ++ #0x08 NameOp NameString DataRef ++ if (aml[offset] != 0x0C): ++ die( "Name offset 0x%x: expected 0x0C actual 0x%x" % ++ (offset, aml[offset])); ++ return offset + 1; ++ ++# Given data offset, find word const offset ++def aml_data_word_const(offset): ++ #0x08 NameOp NameString DataRef ++ if (aml[offset] != 0x0B): ++ die( "Name offset 0x%x: expected 0x0B actual 0x%x" % ++ (offset, aml[offset])); ++ return offset + 1; ++ ++# Given data offset, find byte const offset ++def aml_data_byte_const(offset): ++ #0x08 NameOp NameString DataRef ++ if (aml[offset] != 0x0A): ++ die( "Name offset 0x%x: expected 0x0A actual 0x%x" % ++ (offset, aml[offset])); ++ return offset + 1; ++ ++# Find name'd buffer8 ++def aml_name_buffer8(offset): ++ return aml_data_buffer8(aml_name_string(offset) + 4) ++ ++# Given name offset, find dword const offset ++def aml_name_dword_const(offset): ++ return aml_data_dword_const(aml_name_string(offset) + 4) ++ ++# Given name offset, find word const offset ++def aml_name_word_const(offset): ++ return aml_data_word_const(aml_name_string(offset) + 4) ++ ++# Given name offset, find byte const offset ++def aml_name_byte_const(offset): ++ return aml_data_byte_const(aml_name_string(offset) + 4) ++ ++def aml_device_start(offset): ++ #0x5B 0x82 DeviceOp PkgLength NameString ++ if ((aml[offset] != 0x5B) or (aml[offset + 1] != 0x82)): ++ die( "Name offset 0x%x: expected 0x5B 0x82 actual 0x%x 0x%x" % ++ (offset, aml[offset], aml[offset + 1])); ++ return offset ++ ++def aml_device_string(offset): ++ #0x5B 0x82 DeviceOp PkgLength NameString ++ start = aml_device_start(offset) ++ offset += 2 ++ pkglenbytes = aml_pkglen_bytes(offset) ++ offset += pkglenbytes ++ return offset ++ ++def aml_device_end(offset): ++ start = aml_device_start(offset) ++ offset += 2 ++ pkglenbytes = aml_pkglen_bytes(offset) ++ pkglen = aml_pkglen(offset) ++ return offset + pkglen ++ ++def aml_processor_start(offset): ++ #0x5B 0x83 ProcessorOp PkgLength NameString ProcID ++ if ((aml[offset] != 0x5B) or (aml[offset + 1] != 0x83)): ++ die( "Name offset 0x%x: expected 0x5B 0x83 actual 0x%x 0x%x" % ++ (offset, aml[offset], aml[offset + 1])); ++ return offset ++ ++def aml_processor_string(offset): ++ #0x5B 0x83 ProcessorOp PkgLength NameString ProcID ++ start = aml_processor_start(offset) ++ offset += 2 ++ pkglenbytes = aml_pkglen_bytes(offset) ++ offset += pkglenbytes ++ return offset ++ ++def aml_processor_end(offset): ++ start = aml_processor_start(offset) ++ offset += 2 ++ pkglenbytes = aml_pkglen_bytes(offset) ++ pkglen = aml_pkglen(offset) ++ return offset + pkglen ++ ++def aml_package_start(offset): ++ offset = aml_name_string(offset) + 4 ++ # 0x12 PkgLength NumElements PackageElementList ++ if (aml[offset] != 0x12): ++ die( "Name offset 0x%x: expected 0x12 actual 0x%x" % ++ (offset, aml[offset])); ++ offset += 1 ++ return offset + aml_pkglen_bytes(offset) + 1 ++ ++lineno = 0 ++for line in fileinput.input(): ++ # Strip trailing newline ++ line = line.rstrip(); ++ # line number and debug string to output in case of errors ++ lineno = lineno + 1 ++ debug = "input line %d: %s" % (lineno, line) ++ #ASL listing: space, then line#, then ...., then code ++ pasl = re.compile('^\s+([0-9]+)(:\s\s|\.\.\.\.)\s*') ++ m = pasl.search(line) ++ if (m): ++ add_asl(lineno, pasl.sub("", line)); ++ # AML listing: offset in hex, then ...., then code ++ paml = re.compile('^([0-9A-Fa-f]+)(:\s\s|\.\.\.\.)\s*') ++ m = paml.search(line) ++ if (m): ++ add_aml(m.group(1), paml.sub("", line)) ++ ++# Now go over code ++# Track AML offset of a previous non-empty ASL command ++prev_aml_offset = -1 ++for i in range(len(asl)): ++ debug = "input line %d: %s" % (asl[i].lineno, asl[i].line) ++ ++ l = asl[i].line ++ ++ # skip if not an extract directive ++ a = len(re.findall(r'ACPI_EXTRACT', l)) ++ if (not a): ++ # If not empty, store AML offset. Will be used for sanity checks ++ # IASL seems to put {}. at random places in the listing. ++ # Ignore any non-words for the purpose of this test. ++ m = re.search(r'\w+', l) ++ if (m): ++ prev_aml_offset = asl[i].aml_offset ++ continue ++ ++ if (a > 1): ++ die("Expected at most one ACPI_EXTRACT per line, actual %d" % a) ++ ++ mext = re.search(r''' ++ ^\s* # leading whitespace ++ /\*\s* # start C comment ++ (ACPI_EXTRACT_\w+) # directive: group(1) ++ \s+ # whitspace separates directive from array name ++ (\w+) # array name: group(2) ++ \s*\*/ # end of C comment ++ \s*$ # trailing whitespace ++ ''', l, re.VERBOSE) ++ if (not mext): ++ die("Stray ACPI_EXTRACT in input") ++ ++ # previous command must have produced some AML, ++ # otherwise we are in a middle of a block ++ if (prev_aml_offset == asl[i].aml_offset): ++ die("ACPI_EXTRACT directive in the middle of a block") ++ ++ directive = mext.group(1) ++ array = mext.group(2) ++ offset = asl[i].aml_offset ++ ++ if (directive == "ACPI_EXTRACT_ALL_CODE"): ++ if array in output: ++ die("%s directive used more than once" % directive) ++ output[array] = aml ++ continue ++ if (directive == "ACPI_EXTRACT_NAME_BUFFER8"): ++ offset = aml_name_buffer8(offset) ++ elif (directive == "ACPI_EXTRACT_NAME_DWORD_CONST"): ++ offset = aml_name_dword_const(offset) ++ elif (directive == "ACPI_EXTRACT_NAME_WORD_CONST"): ++ offset = aml_name_word_const(offset) ++ elif (directive == "ACPI_EXTRACT_NAME_BYTE_CONST"): ++ offset = aml_name_byte_const(offset) ++ elif (directive == "ACPI_EXTRACT_NAME_STRING"): ++ offset = aml_name_string(offset) ++ elif (directive == "ACPI_EXTRACT_METHOD_STRING"): ++ offset = aml_method_string(offset) ++ elif (directive == "ACPI_EXTRACT_DEVICE_START"): ++ offset = aml_device_start(offset) ++ elif (directive == "ACPI_EXTRACT_DEVICE_STRING"): ++ offset = aml_device_string(offset) ++ elif (directive == "ACPI_EXTRACT_DEVICE_END"): ++ offset = aml_device_end(offset) ++ elif (directive == "ACPI_EXTRACT_PROCESSOR_START"): ++ offset = aml_processor_start(offset) ++ elif (directive == "ACPI_EXTRACT_PROCESSOR_STRING"): ++ offset = aml_processor_string(offset) ++ elif (directive == "ACPI_EXTRACT_PROCESSOR_END"): ++ offset = aml_processor_end(offset) ++ elif (directive == "ACPI_EXTRACT_PKG_START"): ++ offset = aml_package_start(offset) ++ else: ++ die("Unsupported directive %s" % directive) ++ ++ if array not in output: ++ output[array] = [] ++ output[array].append(offset) ++ ++debug = "at end of file" ++ ++def get_value_type(maxvalue): ++ #Use type large enough to fit the table ++ if (maxvalue >= 0x10000): ++ return "int" ++ elif (maxvalue >= 0x100): ++ return "short" ++ else: ++ return "char" ++ ++# Pretty print output ++for array in output.keys(): ++ otype = get_value_type(max(output[array])) ++ odata = [] ++ for value in output[array]: ++ odata.append("0x%x" % value) ++ sys.stdout.write("static unsigned %s %s[] = {\n" % (otype, array)) ++ sys.stdout.write(",\n".join(odata)) ++ sys.stdout.write('\n};\n'); +diff --git a/scripts/acpi_extract_preprocess.py b/scripts/acpi_extract_preprocess.py +new file mode 100755 +index 0000000..69d10d6 +--- /dev/null ++++ b/scripts/acpi_extract_preprocess.py +@@ -0,0 +1,51 @@ ++#!/usr/bin/python ++# Copyright (C) 2011 Red Hat, Inc., Michael S. Tsirkin ++# ++# This program is free software; you can redistribute it and/or modify ++# it under the terms of the GNU General Public License as published by ++# the Free Software Foundation; either version 2 of the License, or ++# (at your option) any later version. ++# ++# This program is distributed in the hope that it will be useful, ++# but WITHOUT ANY WARRANTY; without even the implied warranty of ++# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++# GNU General Public License for more details. ++# ++# You should have received a copy of the GNU General Public License along ++# with this program; if not, see . ++ ++# Read a preprocessed ASL listing and put each ACPI_EXTRACT ++# directive in a comment, to make iasl skip it. ++# We also put each directive on a new line, the machinery ++# in tools/acpi_extract.py requires this. ++ ++import re; ++import sys; ++import fileinput; ++ ++def die(diag): ++ sys.stderr.write("Error: %s\n" % (diag)) ++ sys.exit(1) ++ ++# Note: () around pattern make split return matched string as part of list ++psplit = re.compile(r''' ( ++ \b # At word boundary ++ ACPI_EXTRACT_\w+ # directive ++ \s+ # some whitespace ++ \w+ # array name ++ )''', re.VERBOSE); ++ ++lineno = 0 ++for line in fileinput.input(): ++ # line number and debug string to output in case of errors ++ lineno = lineno + 1 ++ debug = "input line %d: %s" % (lineno, line.rstrip()) ++ ++ s = psplit.split(line); ++ # The way split works, each odd item is the matching ACPI_EXTRACT directive. ++ # Put each in a comment, and on a line by itself. ++ for i in range(len(s)): ++ if (i % 2): ++ sys.stdout.write("\n/* %s */\n" % s[i]) ++ else: ++ sys.stdout.write(s[i]) +-- +1.7.11.7 + diff --git a/SOURCES/kvm-i386-add-bios-linker-loader.patch b/SOURCES/kvm-i386-add-bios-linker-loader.patch new file mode 100644 index 0000000..d31cde9 --- /dev/null +++ b/SOURCES/kvm-i386-add-bios-linker-loader.patch @@ -0,0 +1,259 @@ +From 54cd29fdf716fa676866b75b7faa32aff0cf7dac Mon Sep 17 00:00:00 2001 +Message-Id: <54cd29fdf716fa676866b75b7faa32aff0cf7dac.1387298827.git.minovotn@redhat.com> +In-Reply-To: <3ed0fb61a3dc912ef036d7ef450bed192090709e.1387298827.git.minovotn@redhat.com> +References: <3ed0fb61a3dc912ef036d7ef450bed192090709e.1387298827.git.minovotn@redhat.com> +From: "Michael S. Tsirkin" +Date: Tue, 17 Dec 2013 15:18:34 +0100 +Subject: [PATCH 37/56] i386: add bios linker/loader + +RH-Author: Michael S. Tsirkin +Message-id: <1387293161-4085-38-git-send-email-mst@redhat.com> +Patchwork-id: 56343 +O-Subject: [PATCH qemu-kvm RHEL7.0 v2 37/57] i386: add bios linker/loader +Bugzilla: 1034876 +RH-Acked-by: Igor Mammedov +RH-Acked-by: Marcel Apfelbaum +RH-Acked-by: Laszlo Ersek + +This adds a dynamic bios linker/loader. +This will be used by acpi table generation +code to: + - load each table in the appropriate memory segment + - link tables to each other + - fix up checksums after said linking + +Reviewed-by: Gerd Hoffmann +Tested-by: Gerd Hoffmann +Reviewed-by: Igor Mammedov +Tested-by: Igor Mammedov +Signed-off-by: Michael S. Tsirkin +(cherry picked from commit bc70232918ad3fb45c2b5423455a5de6bc7efdef) +--- + hw/i386/bios-linker-loader.h | 27 ++++++++ + hw/i386/bios-linker-loader.c | 158 +++++++++++++++++++++++++++++++++++++++++++ + hw/i386/Makefile.objs | 1 + + 3 files changed, 186 insertions(+) + create mode 100644 hw/i386/bios-linker-loader.h + create mode 100644 hw/i386/bios-linker-loader.c + +Signed-off-by: Michal Novotny +--- + hw/i386/Makefile.objs | 1 + + hw/i386/bios-linker-loader.c | 158 +++++++++++++++++++++++++++++++++++++++++++ + hw/i386/bios-linker-loader.h | 27 ++++++++ + 3 files changed, 186 insertions(+) + create mode 100644 hw/i386/bios-linker-loader.c + create mode 100644 hw/i386/bios-linker-loader.h + +diff --git a/hw/i386/Makefile.objs b/hw/i386/Makefile.objs +index 013d250..71be2da 100644 +--- a/hw/i386/Makefile.objs ++++ b/hw/i386/Makefile.objs +@@ -4,6 +4,7 @@ obj-y += pc.o pc_piix.o pc_q35.o + obj-$(CONFIG_XEN) += xen_domainbuild.o xen_machine_pv.o + + obj-y += kvmvapic.o ++obj-y += bios-linker-loader.o + + iasl-option=$(shell if test -z "`$(1) $(2) 2>&1 > /dev/null`" \ + ; then echo "$(2)"; else echo "$(3)"; fi ;) +diff --git a/hw/i386/bios-linker-loader.c b/hw/i386/bios-linker-loader.c +new file mode 100644 +index 0000000..0833853 +--- /dev/null ++++ b/hw/i386/bios-linker-loader.c +@@ -0,0 +1,158 @@ ++/* Dynamic linker/loader of ACPI tables ++ * ++ * Copyright (C) 2013 Red Hat Inc ++ * ++ * Author: Michael S. Tsirkin ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 2 of the License, or ++ * (at your option) any later version. ++ ++ * This program is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ * GNU General Public License for more details. ++ ++ * You should have received a copy of the GNU General Public License along ++ * with this program; if not, see . ++ */ ++ ++#include "bios-linker-loader.h" ++#include "hw/nvram/fw_cfg.h" ++ ++#include ++#include ++#include "qemu/bswap.h" ++ ++#define BIOS_LINKER_LOADER_FILESZ FW_CFG_MAX_FILE_PATH ++ ++struct BiosLinkerLoaderEntry { ++ uint32_t command; ++ union { ++ /* ++ * COMMAND_ALLOCATE - allocate a table from @alloc.file ++ * subject to @alloc.align alignment (must be power of 2) ++ * and @alloc.zone (can be HIGH or FSEG) requirements. ++ * ++ * Must appear exactly once for each file, and before ++ * this file is referenced by any other command. ++ */ ++ struct { ++ char file[BIOS_LINKER_LOADER_FILESZ]; ++ uint32_t align; ++ uint8_t zone; ++ } alloc; ++ ++ /* ++ * COMMAND_ADD_POINTER - patch the table (originating from ++ * @dest_file) at @pointer.offset, by adding a pointer to the table ++ * originating from @src_file. 1,2,4 or 8 byte unsigned ++ * addition is used depending on @pointer.size. ++ */ ++ struct { ++ char dest_file[BIOS_LINKER_LOADER_FILESZ]; ++ char src_file[BIOS_LINKER_LOADER_FILESZ]; ++ uint32_t offset; ++ uint8_t size; ++ } pointer; ++ ++ /* ++ * COMMAND_ADD_CHECKSUM - calculate checksum of the range specified by ++ * @cksum_start and @cksum_length fields, ++ * and then add the value at @cksum.offset. ++ * Checksum simply sums -X for each byte X in the range ++ * using 8-bit math. ++ */ ++ struct { ++ char file[BIOS_LINKER_LOADER_FILESZ]; ++ uint32_t offset; ++ uint32_t start; ++ uint32_t length; ++ } cksum; ++ ++ /* padding */ ++ char pad[124]; ++ }; ++} QEMU_PACKED; ++typedef struct BiosLinkerLoaderEntry BiosLinkerLoaderEntry; ++ ++enum { ++ BIOS_LINKER_LOADER_COMMAND_ALLOCATE = 0x1, ++ BIOS_LINKER_LOADER_COMMAND_ADD_POINTER = 0x2, ++ BIOS_LINKER_LOADER_COMMAND_ADD_CHECKSUM = 0x3, ++}; ++ ++enum { ++ BIOS_LINKER_LOADER_ALLOC_ZONE_HIGH = 0x1, ++ BIOS_LINKER_LOADER_ALLOC_ZONE_FSEG = 0x2, ++}; ++ ++GArray *bios_linker_loader_init(void) ++{ ++ return g_array_new(false, true /* clear */, sizeof(BiosLinkerLoaderEntry)); ++} ++ ++/* Free linker wrapper and return the linker array. */ ++void *bios_linker_loader_cleanup(GArray *linker) ++{ ++ return g_array_free(linker, false); ++} ++ ++void bios_linker_loader_alloc(GArray *linker, ++ const char *file, ++ uint32_t alloc_align, ++ bool alloc_fseg) ++{ ++ BiosLinkerLoaderEntry entry; ++ ++ memset(&entry, 0, sizeof entry); ++ strncpy(entry.alloc.file, file, sizeof entry.alloc.file - 1); ++ entry.command = cpu_to_le32(BIOS_LINKER_LOADER_COMMAND_ALLOCATE); ++ entry.alloc.align = cpu_to_le32(alloc_align); ++ entry.alloc.zone = cpu_to_le32(alloc_fseg ? ++ BIOS_LINKER_LOADER_ALLOC_ZONE_FSEG : ++ BIOS_LINKER_LOADER_ALLOC_ZONE_HIGH); ++ ++ /* Alloc entries must come first, so prepend them */ ++ g_array_prepend_val(linker, entry); ++} ++ ++void bios_linker_loader_add_checksum(GArray *linker, const char *file, ++ void *table, ++ void *start, unsigned size, ++ uint8_t *checksum) ++{ ++ BiosLinkerLoaderEntry entry; ++ ++ memset(&entry, 0, sizeof entry); ++ strncpy(entry.cksum.file, file, sizeof entry.cksum.file - 1); ++ entry.command = cpu_to_le32(BIOS_LINKER_LOADER_COMMAND_ADD_CHECKSUM); ++ entry.cksum.offset = cpu_to_le32(checksum - (uint8_t *)table); ++ entry.cksum.start = cpu_to_le32((uint8_t *)start - (uint8_t *)table); ++ entry.cksum.length = cpu_to_le32(size); ++ ++ g_array_append_val(linker, entry); ++} ++ ++void bios_linker_loader_add_pointer(GArray *linker, ++ const char *dest_file, ++ const char *src_file, ++ GArray *table, void *pointer, ++ uint8_t pointer_size) ++{ ++ BiosLinkerLoaderEntry entry; ++ ++ memset(&entry, 0, sizeof entry); ++ strncpy(entry.pointer.dest_file, dest_file, ++ sizeof entry.pointer.dest_file - 1); ++ strncpy(entry.pointer.src_file, src_file, ++ sizeof entry.pointer.src_file - 1); ++ entry.command = cpu_to_le32(BIOS_LINKER_LOADER_COMMAND_ADD_POINTER); ++ entry.pointer.offset = cpu_to_le32((gchar *)pointer - table->data); ++ entry.pointer.size = pointer_size; ++ assert(pointer_size == 1 || pointer_size == 2 || ++ pointer_size == 4 || pointer_size == 8); ++ ++ g_array_append_val(linker, entry); ++} +diff --git a/hw/i386/bios-linker-loader.h b/hw/i386/bios-linker-loader.h +new file mode 100644 +index 0000000..498c0af +--- /dev/null ++++ b/hw/i386/bios-linker-loader.h +@@ -0,0 +1,27 @@ ++#ifndef BIOS_LINKER_LOADER_H ++#define BIOS_LINKER_LOADER_H ++ ++#include ++#include ++#include ++ ++GArray *bios_linker_loader_init(void); ++ ++void bios_linker_loader_alloc(GArray *linker, ++ const char *file, ++ uint32_t alloc_align, ++ bool alloc_fseg); ++ ++void bios_linker_loader_add_checksum(GArray *linker, const char *file, ++ void *table, ++ void *start, unsigned size, ++ uint8_t *checksum); ++ ++void bios_linker_loader_add_pointer(GArray *linker, ++ const char *dest_file, ++ const char *src_file, ++ GArray *table, void *pointer, ++ uint8_t pointer_size); ++ ++void *bios_linker_loader_cleanup(GArray *linker); ++#endif +-- +1.7.11.7 + diff --git a/SOURCES/kvm-i386-define-pc-guest-info.patch b/SOURCES/kvm-i386-define-pc-guest-info.patch new file mode 100644 index 0000000..7d0e651 --- /dev/null +++ b/SOURCES/kvm-i386-define-pc-guest-info.patch @@ -0,0 +1,103 @@ +From 9ac777bc498f6be28cab47c96a1f0822b5a01868 Mon Sep 17 00:00:00 2001 +Message-Id: <9ac777bc498f6be28cab47c96a1f0822b5a01868.1387298827.git.minovotn@redhat.com> +In-Reply-To: <3ed0fb61a3dc912ef036d7ef450bed192090709e.1387298827.git.minovotn@redhat.com> +References: <3ed0fb61a3dc912ef036d7ef450bed192090709e.1387298827.git.minovotn@redhat.com> +From: "Michael S. Tsirkin" +Date: Tue, 17 Dec 2013 15:18:44 +0100 +Subject: [PATCH 39/56] i386: define pc guest info + +RH-Author: Michael S. Tsirkin +Message-id: <1387293161-4085-40-git-send-email-mst@redhat.com> +Patchwork-id: 56345 +O-Subject: [PATCH qemu-kvm RHEL7.0 v2 39/57] i386: define pc guest info +Bugzilla: 1034876 +RH-Acked-by: Igor Mammedov +RH-Acked-by: Marcel Apfelbaum +RH-Acked-by: Laszlo Ersek + +This defines a structure that will be used to fill in acpi tables +where relevant properties are not yet available using QOM. + +Reviewed-by: Laszlo Ersek +Reviewed-by: Gerd Hoffmann +Tested-by: Gerd Hoffmann +Reviewed-by: Igor Mammedov +Tested-by: Igor Mammedov +Signed-off-by: Michael S. Tsirkin +(cherry picked from commit b20c9bd5f6d8860856f6078836d197c6c2e27ef1) + +Conflicts: + include/hw/i386/pc.h +--- + include/hw/i386/pc.h | 9 +++++++++ + hw/i386/pc.c | 21 +++++++++++++++++++++ + 2 files changed, 30 insertions(+) + +Signed-off-by: Michal Novotny +--- + hw/i386/pc.c | 21 +++++++++++++++++++++ + include/hw/i386/pc.h | 9 +++++++++ + 2 files changed, 30 insertions(+) + +diff --git a/hw/i386/pc.c b/hw/i386/pc.c +index e5ebd52..4d54c0b 100644 +--- a/hw/i386/pc.c ++++ b/hw/i386/pc.c +@@ -1042,6 +1042,27 @@ PcGuestInfo *pc_guest_info_init(ram_addr_t below_4g_mem_size, + { + PcGuestInfoState *guest_info_state = g_malloc0(sizeof *guest_info_state); + PcGuestInfo *guest_info = &guest_info_state->info; ++ int i, j; ++ ++ guest_info->ram_size = below_4g_mem_size + above_4g_mem_size; ++ guest_info->apic_id_limit = pc_apic_id_limit(max_cpus); ++ guest_info->apic_xrupt_override = kvm_allows_irq0_override(); ++ guest_info->numa_nodes = nb_numa_nodes; ++ guest_info->node_mem = g_memdup(node_mem, guest_info->numa_nodes * ++ sizeof *guest_info->node_mem); ++ guest_info->node_cpu = g_malloc0(guest_info->apic_id_limit * ++ sizeof *guest_info->node_cpu); ++ ++ for (i = 0; i < max_cpus; i++) { ++ unsigned int apic_id = x86_cpu_apic_id_from_index(i); ++ assert(apic_id < guest_info->apic_id_limit); ++ for (j = 0; j < nb_numa_nodes; j++) { ++ if (test_bit(i, node_cpumask[j])) { ++ guest_info->node_cpu[apic_id] = j; ++ break; ++ } ++ } ++ } + + guest_info_state->machine_done.notify = pc_guest_info_machine_done; + qemu_add_machine_init_done_notifier(&guest_info_state->machine_done); +diff --git a/include/hw/i386/pc.h b/include/hw/i386/pc.h +index abaaf93..ec91fae 100644 +--- a/include/hw/i386/pc.h ++++ b/include/hw/i386/pc.h +@@ -11,6 +11,9 @@ + #include "hw/i386/ioapic.h" + + #include "qemu/range.h" ++#include "qemu/bitmap.h" ++#include "sysemu/sysemu.h" ++#include "hw/pci/pci.h" + + /* PC-style peripherals (also used by other machines). */ + +@@ -21,6 +24,12 @@ typedef struct PcPciInfo { + + struct PcGuestInfo { + bool has_pci_info; ++ hwaddr ram_size; ++ unsigned apic_id_limit; ++ bool apic_xrupt_override; ++ uint64_t numa_nodes; ++ uint64_t *node_mem; ++ uint64_t *node_cpu; + FWCfgState *fw_cfg; + }; + +-- +1.7.11.7 + diff --git a/SOURCES/kvm-i440fx-test-generate-temporary-firmware-blob.patch b/SOURCES/kvm-i440fx-test-generate-temporary-firmware-blob.patch new file mode 100644 index 0000000..59d51d6 --- /dev/null +++ b/SOURCES/kvm-i440fx-test-generate-temporary-firmware-blob.patch @@ -0,0 +1,120 @@ +From a577ed3eaa3c3ba84133d9bea1907c69c01063ad Mon Sep 17 00:00:00 2001 +From: Laszlo Ersek +Date: Sat, 11 Jan 2014 18:00:06 +0100 +Subject: [PATCH 16/22] i440fx-test: generate temporary firmware blob + +RH-Author: Laszlo Ersek +Message-id: <1389463208-6278-17-git-send-email-lersek@redhat.com> +Patchwork-id: 56629 +O-Subject: [RHEL-7.0 qemu-kvm PATCH 16/18] i440fx-test: generate temporary firmware blob +Bugzilla: 1032346 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Amos Kong +RH-Acked-by: Andrew Jones + +The blob is 64K in size and contains 0x00..0xFF repeatedly. + +The client code added to main() wouldn't make much sense in the long term. +It helps with debugging and it silences gcc about create_blob_file() being +unused, and we'll replace it in the next patch anyway. + +Signed-off-by: Laszlo Ersek +Signed-off-by: Michael S. Tsirkin +(cherry picked from commit 27d59ccd89a5b112e5a5804250440ea30dbfb891) +--- + tests/i440fx-test.c | 60 +++++++++++++++++++++++++++++++++++++++++++++++++++++ + 1 file changed, 60 insertions(+) + +Signed-off-by: Miroslav Rezanina +--- + tests/i440fx-test.c | 60 +++++++++++++++++++++++++++++++++++++++++++++++++++ + 1 files changed, 60 insertions(+), 0 deletions(-) + +diff --git a/tests/i440fx-test.c b/tests/i440fx-test.c +index 3962bca..b6e0cd3 100644 +--- a/tests/i440fx-test.c ++++ b/tests/i440fx-test.c +@@ -20,6 +20,11 @@ + + #include + #include ++#include ++#include ++#include ++#include ++#include + + #define BROKEN 1 + +@@ -272,13 +277,68 @@ static void test_i440fx_pam(gconstpointer opaque) + qtest_end(); + } + ++#define BLOB_SIZE ((size_t)65536) ++ ++/* Create a blob file, and return its absolute pathname as a dynamically ++ * allocated string. ++ * The file is closed before the function returns. ++ * In case of error, NULL is returned. The function prints the error message. ++ */ ++static char *create_blob_file(void) ++{ ++ int ret, fd; ++ char *pathname; ++ GError *error = NULL; ++ ++ ret = -1; ++ fd = g_file_open_tmp("blob_XXXXXX", &pathname, &error); ++ if (fd == -1) { ++ fprintf(stderr, "unable to create blob file: %s\n", error->message); ++ g_error_free(error); ++ } else { ++ if (ftruncate(fd, BLOB_SIZE) == -1) { ++ fprintf(stderr, "ftruncate(\"%s\", %zu): %s\n", pathname, ++ BLOB_SIZE, strerror(errno)); ++ } else { ++ void *buf; ++ ++ buf = mmap(NULL, BLOB_SIZE, PROT_WRITE, MAP_SHARED, fd, 0); ++ if (buf == MAP_FAILED) { ++ fprintf(stderr, "mmap(\"%s\", %zu): %s\n", pathname, BLOB_SIZE, ++ strerror(errno)); ++ } else { ++ size_t i; ++ ++ for (i = 0; i < BLOB_SIZE; ++i) { ++ ((uint8_t *)buf)[i] = i; ++ } ++ munmap(buf, BLOB_SIZE); ++ ret = 0; ++ } ++ } ++ close(fd); ++ if (ret == -1) { ++ unlink(pathname); ++ g_free(pathname); ++ } ++ } ++ ++ return ret == -1 ? NULL : pathname; ++} ++ + int main(int argc, char **argv) + { ++ char *fw_pathname; + TestData data; + int ret; + + g_test_init(&argc, &argv, NULL); + ++ fw_pathname = create_blob_file(); ++ g_assert(fw_pathname != NULL); ++ unlink(fw_pathname); ++ g_free(fw_pathname); ++ + data.num_cpus = 1; + + g_test_add_data_func("/i440fx/defaults", &data, test_i440fx_defaults); +-- +1.7.1 + diff --git a/SOURCES/kvm-i440fx-test-give-each-GTest-case-its-own-qtest.patch b/SOURCES/kvm-i440fx-test-give-each-GTest-case-its-own-qtest.patch new file mode 100644 index 0000000..0b36c5c --- /dev/null +++ b/SOURCES/kvm-i440fx-test-give-each-GTest-case-its-own-qtest.patch @@ -0,0 +1,135 @@ +From f57ff93bf55cfdf09995c441cbbf8ad886f1afcb Mon Sep 17 00:00:00 2001 +From: Laszlo Ersek +Date: Sat, 11 Jan 2014 18:00:05 +0100 +Subject: [PATCH 15/22] i440fx-test: give each GTest case its own qtest + +RH-Author: Laszlo Ersek +Message-id: <1389463208-6278-16-git-send-email-lersek@redhat.com> +Patchwork-id: 56628 +O-Subject: [RHEL-7.0 qemu-kvm PATCH 15/18] i440fx-test: give each GTest case its own qtest +Bugzilla: 1032346 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Amos Kong +RH-Acked-by: Andrew Jones + +The current two GTest cases, /i440fx/defaults and /i440fx/pam can share a +qemu process, but the next two cases will need dedicated instances. It is +messy (and order-dependent) to dynamically configure GTest cases one by +one to start, stop, or keep the current qtest (*); let's just have each +GTest work with its own qtest. The performance difference should be +negligible. + +(*) As g_test_run() can be invoked at most once per process startup, and +it runs GTest cases in sequence, we'd need clumsy data structures to +control each GTest case to start/stop/keep the qemu instance. Or, we'd +have to code the same information into the test methods themselves, which +would make them even more order-dependent. + +Signed-off-by: Laszlo Ersek +Signed-off-by: Michael S. Tsirkin +(cherry picked from commit c37805b6724e5d4c3ad41653630b72b43619474e) +--- + tests/i440fx-test.c | 32 +++++++++++++++++++------------- + 1 file changed, 19 insertions(+), 13 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + tests/i440fx-test.c | 32 +++++++++++++++++++------------- + 1 files changed, 19 insertions(+), 13 deletions(-) + +diff --git a/tests/i440fx-test.c b/tests/i440fx-test.c +index 6ac46bf..3962bca 100644 +--- a/tests/i440fx-test.c ++++ b/tests/i440fx-test.c +@@ -28,16 +28,27 @@ + typedef struct TestData + { + int num_cpus; +- QPCIBus *bus; + } TestData; + ++static QPCIBus *test_start_get_bus(const TestData *s) ++{ ++ char *cmdline; ++ ++ cmdline = g_strdup_printf("-smp %d", s->num_cpus); ++ qtest_start(cmdline); ++ g_free(cmdline); ++ return qpci_init_pc(); ++} ++ + static void test_i440fx_defaults(gconstpointer opaque) + { + const TestData *s = opaque; ++ QPCIBus *bus; + QPCIDevice *dev; + uint32_t value; + +- dev = qpci_device_find(s->bus, QPCI_DEVFN(0, 0)); ++ bus = test_start_get_bus(s); ++ dev = qpci_device_find(bus, QPCI_DEVFN(0, 0)); + g_assert(dev != NULL); + + /* 3.2.2 */ +@@ -121,6 +132,8 @@ static void test_i440fx_defaults(gconstpointer opaque) + g_assert_cmpint(qpci_config_readb(dev, 0x91), ==, 0x00); /* ERRSTS */ + /* 3.2.26 */ + g_assert_cmpint(qpci_config_readb(dev, 0x93), ==, 0x00); /* TRC */ ++ ++ qtest_end(); + } + + #define PAM_RE 1 +@@ -179,6 +192,7 @@ static void write_area(uint32_t start, uint32_t end, uint8_t value) + static void test_i440fx_pam(gconstpointer opaque) + { + const TestData *s = opaque; ++ QPCIBus *bus; + QPCIDevice *dev; + int i; + static struct { +@@ -201,7 +215,8 @@ static void test_i440fx_pam(gconstpointer opaque) + { 0xEC000, 0xEFFFF }, /* BIOS Extension */ + }; + +- dev = qpci_device_find(s->bus, QPCI_DEVFN(0, 0)); ++ bus = test_start_get_bus(s); ++ dev = qpci_device_find(bus, QPCI_DEVFN(0, 0)); + g_assert(dev != NULL); + + for (i = 0; i < ARRAY_SIZE(pam_area); i++) { +@@ -254,30 +269,21 @@ static void test_i440fx_pam(gconstpointer opaque) + /* Verify the area is not our new mask */ + g_assert(!verify_area(pam_area[i].start, pam_area[i].end, 0x82)); + } ++ qtest_end(); + } + + int main(int argc, char **argv) + { + TestData data; +- char *cmdline; + int ret; + + g_test_init(&argc, &argv, NULL); + + data.num_cpus = 1; + +- cmdline = g_strdup_printf("-smp %d", data.num_cpus); +- qtest_start(cmdline); +- g_free(cmdline); +- +- data.bus = qpci_init_pc(); +- + g_test_add_data_func("/i440fx/defaults", &data, test_i440fx_defaults); + g_test_add_data_func("/i440fx/pam", &data, test_i440fx_pam); + + ret = g_test_run(); +- +- qtest_end(); +- + return ret; + } +-- +1.7.1 + diff --git a/SOURCES/kvm-i440fx-test-qtest_start-should-be-paired-with-qtest_.patch b/SOURCES/kvm-i440fx-test-qtest_start-should-be-paired-with-qtest_.patch new file mode 100644 index 0000000..59e5acf --- /dev/null +++ b/SOURCES/kvm-i440fx-test-qtest_start-should-be-paired-with-qtest_.patch @@ -0,0 +1,79 @@ +From 79eec4a8ab4eb5897563cc140c0fc2ee0738dc0b Mon Sep 17 00:00:00 2001 +From: Laszlo Ersek +Date: Sat, 11 Jan 2014 18:00:04 +0100 +Subject: [PATCH 14/22] i440fx-test: qtest_start() should be paired with qtest_end() + +RH-Author: Laszlo Ersek +Message-id: <1389463208-6278-15-git-send-email-lersek@redhat.com> +Patchwork-id: 56627 +O-Subject: [RHEL-7.0 qemu-kvm PATCH 14/18] i440fx-test: qtest_start() should be paired with qtest_end() +Bugzilla: 1032346 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Amos Kong +RH-Acked-by: Andrew Jones + +Similarly to commit 1d9358e6 +("libqtest: New qtest_end() to go with qtest_start()"). + +Signed-off-by: Laszlo Ersek +Signed-off-by: Michael S. Tsirkin +(cherry picked from commit b817e3fb5401bfab49e3c212e6daa1ff1f5a4c9a) +--- + tests/i440fx-test.c | 10 ++++------ + 1 file changed, 4 insertions(+), 6 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + tests/i440fx-test.c | 10 ++++------ + 1 files changed, 4 insertions(+), 6 deletions(-) + +diff --git a/tests/i440fx-test.c b/tests/i440fx-test.c +index 65c786c..6ac46bf 100644 +--- a/tests/i440fx-test.c ++++ b/tests/i440fx-test.c +@@ -2,9 +2,11 @@ + * qtest I440FX test case + * + * Copyright IBM, Corp. 2012-2013 ++ * Copyright Red Hat, Inc. 2013 + * + * Authors: + * Anthony Liguori ++ * Laszlo Ersek + * + * This work is licensed under the terms of the GNU GPL, version 2 or later. + * See the COPYING file in the top-level directory. +@@ -256,7 +258,6 @@ static void test_i440fx_pam(gconstpointer opaque) + + int main(int argc, char **argv) + { +- QTestState *s; + TestData data; + char *cmdline; + int ret; +@@ -266,20 +267,17 @@ int main(int argc, char **argv) + data.num_cpus = 1; + + cmdline = g_strdup_printf("-smp %d", data.num_cpus); +- s = qtest_start(cmdline); ++ qtest_start(cmdline); + g_free(cmdline); + + data.bus = qpci_init_pc(); + + g_test_add_data_func("/i440fx/defaults", &data, test_i440fx_defaults); + g_test_add_data_func("/i440fx/pam", &data, test_i440fx_pam); +- + + ret = g_test_run(); + +- if (s) { +- qtest_quit(s); +- } ++ qtest_end(); + + return ret; + } +-- +1.7.1 + diff --git a/SOURCES/kvm-i440fx-test-verify-firmware-under-4G-and-1M-both-bio.patch b/SOURCES/kvm-i440fx-test-verify-firmware-under-4G-and-1M-both-bio.patch new file mode 100644 index 0000000..c28d6e8 --- /dev/null +++ b/SOURCES/kvm-i440fx-test-verify-firmware-under-4G-and-1M-both-bio.patch @@ -0,0 +1,151 @@ +From 473a279de264f7d56a41ac77aa9db4d783733f34 Mon Sep 17 00:00:00 2001 +From: Laszlo Ersek +Date: Sat, 11 Jan 2014 18:00:07 +0100 +Subject: [PATCH 17/22] i440fx-test: verify firmware under 4G and 1M, both -bios and -pflash + +RH-Author: Laszlo Ersek +Message-id: <1389463208-6278-18-git-send-email-lersek@redhat.com> +Patchwork-id: 56631 +O-Subject: [RHEL-7.0 qemu-kvm PATCH 17/18] i440fx-test: verify firmware under 4G and 1M, both -bios and -pflash +Bugzilla: 1032346 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Amos Kong +RH-Acked-by: Andrew Jones + +Check whether the firmware is not hidden by other memory regions. + +Qemu is started in paused mode: it shouldn't try to interpret generated +garbage. + +Signed-off-by: Laszlo Ersek +Signed-off-by: Michael S. Tsirkin +(cherry picked from commit 3bcc77ae9935c8c3d10f63492af81f1d7d99d492) +--- + tests/i440fx-test.c | 81 +++++++++++++++++++++++++++++++++++++++++++++++++---- + 1 file changed, 75 insertions(+), 6 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + tests/i440fx-test.c | 81 +++++++++++++++++++++++++++++++++++++++++++++++---- + 1 files changed, 75 insertions(+), 6 deletions(-) + +diff --git a/tests/i440fx-test.c b/tests/i440fx-test.c +index b6e0cd3..fa3e3d6 100644 +--- a/tests/i440fx-test.c ++++ b/tests/i440fx-test.c +@@ -35,6 +35,11 @@ typedef struct TestData + int num_cpus; + } TestData; + ++typedef struct FirmwareTestFixture { ++ /* decides whether we're testing -bios or -pflash */ ++ bool is_bios; ++} FirmwareTestFixture; ++ + static QPCIBus *test_start_get_bus(const TestData *s) + { + char *cmdline; +@@ -278,6 +283,7 @@ static void test_i440fx_pam(gconstpointer opaque) + } + + #define BLOB_SIZE ((size_t)65536) ++#define ISA_BIOS_MAXSZ ((size_t)(128 * 1024)) + + /* Create a blob file, and return its absolute pathname as a dynamically + * allocated string. +@@ -326,23 +332,86 @@ static char *create_blob_file(void) + return ret == -1 ? NULL : pathname; + } + +-int main(int argc, char **argv) ++static void test_i440fx_firmware(FirmwareTestFixture *fixture, ++ gconstpointer user_data) + { +- char *fw_pathname; +- TestData data; +- int ret; +- +- g_test_init(&argc, &argv, NULL); ++ char *fw_pathname, *cmdline; ++ uint8_t *buf; ++ size_t i, isa_bios_size; + + fw_pathname = create_blob_file(); + g_assert(fw_pathname != NULL); ++ ++ /* Better hope the user didn't put metacharacters in TMPDIR and co. */ ++ cmdline = g_strdup_printf("-S %s %s", ++ fixture->is_bios ? "-bios" : "-pflash", ++ fw_pathname); ++ g_test_message("qemu cmdline: %s", cmdline); ++ qtest_start(cmdline); ++ g_free(cmdline); ++ ++ /* Qemu has loaded the firmware (because qtest_start() only returns after ++ * the QMP handshake completes). We must unlink the firmware blob right ++ * here, because any assertion firing below would leak it in the ++ * filesystem. This is also the reason why we recreate the blob every time ++ * this function is invoked. ++ */ + unlink(fw_pathname); + g_free(fw_pathname); + ++ /* check below 4G */ ++ buf = g_malloc0(BLOB_SIZE); ++ memread(0x100000000ULL - BLOB_SIZE, buf, BLOB_SIZE); ++ for (i = 0; i < BLOB_SIZE; ++i) { ++ g_assert_cmphex(buf[i], ==, (uint8_t)i); ++ } ++ ++ /* check in ISA space too */ ++ memset(buf, 0, BLOB_SIZE); ++ isa_bios_size = ISA_BIOS_MAXSZ < BLOB_SIZE ? ISA_BIOS_MAXSZ : BLOB_SIZE; ++ memread(0x100000 - isa_bios_size, buf, isa_bios_size); ++ for (i = 0; i < isa_bios_size; ++i) { ++ g_assert_cmphex(buf[i], ==, ++ (uint8_t)((BLOB_SIZE - isa_bios_size) + i)); ++ } ++ ++ g_free(buf); ++ qtest_end(); ++} ++ ++static void add_firmware_test(const char *testpath, ++ void (*setup_fixture)(FirmwareTestFixture *f, ++ gconstpointer test_data)) ++{ ++ g_test_add(testpath, FirmwareTestFixture, NULL, setup_fixture, ++ test_i440fx_firmware, NULL); ++} ++ ++static void request_bios(FirmwareTestFixture *fixture, ++ gconstpointer user_data) ++{ ++ fixture->is_bios = true; ++} ++ ++static void request_pflash(FirmwareTestFixture *fixture, ++ gconstpointer user_data) ++{ ++ fixture->is_bios = false; ++} ++ ++int main(int argc, char **argv) ++{ ++ TestData data; ++ int ret; ++ ++ g_test_init(&argc, &argv, NULL); ++ + data.num_cpus = 1; + + g_test_add_data_func("/i440fx/defaults", &data, test_i440fx_defaults); + g_test_add_data_func("/i440fx/pam", &data, test_i440fx_pam); ++ add_firmware_test("/i440fx/firmware/bios", request_bios); ++ add_firmware_test("/i440fx/firmware/pflash", request_pflash); + + ret = g_test_run(); + return ret; +-- +1.7.1 + diff --git a/SOURCES/kvm-ich9-APIs-for-pc-guest-info.patch b/SOURCES/kvm-ich9-APIs-for-pc-guest-info.patch new file mode 100644 index 0000000..bafe253 --- /dev/null +++ b/SOURCES/kvm-ich9-APIs-for-pc-guest-info.patch @@ -0,0 +1,211 @@ +From 3cb467f6950fee049415dfe54a5d0f498efaead8 Mon Sep 17 00:00:00 2001 +Message-Id: <3cb467f6950fee049415dfe54a5d0f498efaead8.1387298827.git.minovotn@redhat.com> +In-Reply-To: <3ed0fb61a3dc912ef036d7ef450bed192090709e.1387298827.git.minovotn@redhat.com> +References: <3ed0fb61a3dc912ef036d7ef450bed192090709e.1387298827.git.minovotn@redhat.com> +From: "Michael S. Tsirkin" +Date: Tue, 17 Dec 2013 15:18:52 +0100 +Subject: [PATCH 42/56] ich9: APIs for pc guest info + +RH-Author: Michael S. Tsirkin +Message-id: <1387293161-4085-43-git-send-email-mst@redhat.com> +Patchwork-id: 56348 +O-Subject: [PATCH qemu-kvm RHEL7.0 v2 42/57] ich9: APIs for pc guest info +Bugzilla: 1034876 +RH-Acked-by: Igor Mammedov +RH-Acked-by: Marcel Apfelbaum +RH-Acked-by: Laszlo Ersek + +This adds APIs that will be used to fill in +acpi tables, implemented using QOM, +to various ich9 components. +Some information is still missing in QOM, +so we fall back on lookups by type instead. + +Reviewed-by: Gerd Hoffmann +Tested-by: Gerd Hoffmann +Reviewed-by: Igor Mammedov +Tested-by: Igor Mammedov +Signed-off-by: Michael S. Tsirkin +(cherry picked from commit 6f1426ab0fad715bccbad60e976ebf420442006c) +--- + include/hw/acpi/ich9.h | 2 ++ + include/hw/i386/ich9.h | 2 ++ + include/hw/pci-host/q35.h | 2 ++ + hw/acpi/ich9.c | 24 ++++++++++++++++++++++++ + hw/isa/lpc_ich9.c | 40 ++++++++++++++++++++++++++++++++++++++++ + hw/pci-host/q35.c | 10 ++++++++++ + 6 files changed, 80 insertions(+) + +Signed-off-by: Michal Novotny +--- + hw/acpi/ich9.c | 24 ++++++++++++++++++++++++ + hw/isa/lpc_ich9.c | 40 ++++++++++++++++++++++++++++++++++++++++ + hw/pci-host/q35.c | 10 ++++++++++ + include/hw/acpi/ich9.h | 2 ++ + include/hw/i386/ich9.h | 2 ++ + include/hw/pci-host/q35.h | 2 ++ + 6 files changed, 80 insertions(+) + +diff --git a/hw/acpi/ich9.c b/hw/acpi/ich9.c +index 4a17f32..e747183 100644 +--- a/hw/acpi/ich9.c ++++ b/hw/acpi/ich9.c +@@ -24,6 +24,7 @@ + * GNU GPL, version 2 or (at your option) any later version. + */ + #include "hw/hw.h" ++#include "qapi/visitor.h" + #include "hw/i386/pc.h" + #include "hw/pci/pci.h" + #include "qemu/timer.h" +@@ -228,3 +229,26 @@ void ich9_pm_init(PCIDevice *lpc_pci, ICH9LPCPMRegs *pm, + pm->powerdown_notifier.notify = pm_powerdown_req; + qemu_register_powerdown_notifier(&pm->powerdown_notifier); + } ++ ++static void ich9_pm_get_gpe0_blk(Object *obj, Visitor *v, ++ void *opaque, const char *name, ++ Error **errp) ++{ ++ ICH9LPCPMRegs *pm = opaque; ++ uint32_t value = pm->pm_io_base + ICH9_PMIO_GPE0_STS; ++ ++ visit_type_uint32(v, &value, name, errp); ++} ++ ++void ich9_pm_add_properties(Object *obj, ICH9LPCPMRegs *pm, Error **errp) ++{ ++ static const uint32_t gpe0_len = ICH9_PMIO_GPE0_LEN; ++ ++ object_property_add_uint32_ptr(obj, ACPI_PM_PROP_PM_IO_BASE, ++ &pm->pm_io_base, errp); ++ object_property_add(obj, ACPI_PM_PROP_GPE0_BLK, "uint32", ++ ich9_pm_get_gpe0_blk, ++ NULL, NULL, pm, NULL); ++ object_property_add_uint32_ptr(obj, ACPI_PM_PROP_GPE0_BLK_LEN, ++ &gpe0_len, errp); ++} +diff --git a/hw/isa/lpc_ich9.c b/hw/isa/lpc_ich9.c +index 4f834b9..7a5a92f 100644 +--- a/hw/isa/lpc_ich9.c ++++ b/hw/isa/lpc_ich9.c +@@ -29,6 +29,7 @@ + */ + #include "qemu-common.h" + #include "hw/hw.h" ++#include "qapi/visitor.h" + #include "qemu/range.h" + #include "hw/isa/isa.h" + #include "hw/sysbus.h" +@@ -524,6 +525,43 @@ static const MemoryRegionOps ich9_rst_cnt_ops = { + .endianness = DEVICE_LITTLE_ENDIAN + }; + ++Object *ich9_lpc_find(void) ++{ ++ bool ambig; ++ Object *o = object_resolve_path_type("", TYPE_ICH9_LPC_DEVICE, &ambig); ++ ++ if (ambig) { ++ return NULL; ++ } ++ return o; ++} ++ ++static void ich9_lpc_get_sci_int(Object *obj, Visitor *v, ++ void *opaque, const char *name, ++ Error **errp) ++{ ++ ICH9LPCState *lpc = ICH9_LPC_DEVICE(obj); ++ uint32_t value = ich9_lpc_sci_irq(lpc); ++ ++ visit_type_uint32(v, &value, name, errp); ++} ++ ++static void ich9_lpc_add_properties(ICH9LPCState *lpc) ++{ ++ static const uint8_t acpi_enable_cmd = ICH9_APM_ACPI_ENABLE; ++ static const uint8_t acpi_disable_cmd = ICH9_APM_ACPI_DISABLE; ++ ++ object_property_add(OBJECT(lpc), ACPI_PM_PROP_SCI_INT, "uint32", ++ ich9_lpc_get_sci_int, ++ NULL, NULL, NULL, NULL); ++ object_property_add_uint8_ptr(OBJECT(lpc), ACPI_PM_PROP_ACPI_ENABLE_CMD, ++ &acpi_enable_cmd, NULL); ++ object_property_add_uint8_ptr(OBJECT(lpc), ACPI_PM_PROP_ACPI_DISABLE_CMD, ++ &acpi_disable_cmd, NULL); ++ ++ ich9_pm_add_properties(OBJECT(lpc), &lpc->pm, NULL); ++} ++ + static int ich9_lpc_initfn(PCIDevice *d) + { + ICH9LPCState *lpc = ICH9_LPC_DEVICE(d); +@@ -551,6 +589,8 @@ static int ich9_lpc_initfn(PCIDevice *d) + ICH9_RST_CNT_IOPORT, &lpc->rst_cnt_mem, + 1); + ++ ich9_lpc_add_properties(lpc); ++ + return 0; + } + +diff --git a/hw/pci-host/q35.c b/hw/pci-host/q35.c +index 87691d1..befa9d4 100644 +--- a/hw/pci-host/q35.c ++++ b/hw/pci-host/q35.c +@@ -378,6 +378,16 @@ static int mch_init(PCIDevice *d) + return 0; + } + ++uint64_t mch_mcfg_base(void) ++{ ++ bool ambiguous; ++ Object *o = object_resolve_path_type("", TYPE_MCH_PCI_DEVICE, &ambiguous); ++ if (!o) { ++ return 0; ++ } ++ return MCH_HOST_BRIDGE_PCIEXBAR_DEFAULT; ++} ++ + static void mch_class_init(ObjectClass *klass, void *data) + { + PCIDeviceClass *k = PCI_DEVICE_CLASS(klass); +diff --git a/include/hw/acpi/ich9.h b/include/hw/acpi/ich9.h +index b1fe71f..82fcf9f 100644 +--- a/include/hw/acpi/ich9.h ++++ b/include/hw/acpi/ich9.h +@@ -49,4 +49,6 @@ void ich9_pm_init(PCIDevice *lpc_pci, ICH9LPCPMRegs *pm, + void ich9_pm_iospace_update(ICH9LPCPMRegs *pm, uint32_t pm_io_base); + extern const VMStateDescription vmstate_ich9_pm; + ++void ich9_pm_add_properties(Object *obj, ICH9LPCPMRegs *pm, Error **errp); ++ + #endif /* HW_ACPI_ICH9_H */ +diff --git a/include/hw/i386/ich9.h b/include/hw/i386/ich9.h +index c5f637b..4a68b35 100644 +--- a/include/hw/i386/ich9.h ++++ b/include/hw/i386/ich9.h +@@ -66,6 +66,8 @@ typedef struct ICH9LPCState { + qemu_irq *ioapic; + } ICH9LPCState; + ++Object *ich9_lpc_find(void); ++ + #define Q35_MASK(bit, ms_bit, ls_bit) \ + ((uint##bit##_t)(((1ULL << ((ms_bit) + 1)) - 1) & ~((1ULL << ls_bit) - 1))) + +diff --git a/include/hw/pci-host/q35.h b/include/hw/pci-host/q35.h +index e660a40..856d39f 100644 +--- a/include/hw/pci-host/q35.h ++++ b/include/hw/pci-host/q35.h +@@ -150,4 +150,6 @@ typedef struct Q35PCIHost { + #define MCH_PCIE_DEV 1 + #define MCH_PCIE_FUNC 0 + ++uint64_t mch_mcfg_base(void); ++ + #endif /* HW_Q35_H */ +-- +1.7.11.7 + diff --git a/SOURCES/kvm-improve-debuggability-of-BLOCK_IO_ERROR-BLOCK_JOB_ER.patch b/SOURCES/kvm-improve-debuggability-of-BLOCK_IO_ERROR-BLOCK_JOB_ER.patch new file mode 100644 index 0000000..88a9d19 --- /dev/null +++ b/SOURCES/kvm-improve-debuggability-of-BLOCK_IO_ERROR-BLOCK_JOB_ER.patch @@ -0,0 +1,140 @@ +From bfea65d6f229fd65c78ae4daaddf0d0711d0aedd Mon Sep 17 00:00:00 2001 +From: Laszlo Ersek +Date: Thu, 21 Nov 2013 16:27:19 +0100 +Subject: [PATCH 09/14] improve debuggability of BLOCK_IO_ERROR / BLOCK_JOB_ERROR (RHEL 6->7 fwd) + +RH-Author: Laszlo Ersek +Message-id: <1385051239-3677-4-git-send-email-lersek@redhat.com> +Patchwork-id: 55837 +O-Subject: [RHEL-7.0 qemu-kvm PATCH 3/3] improve debuggability of BLOCK_IO_ERROR / BLOCK_JOB_ERROR (RHEL 6->7 fwd) +Bugzilla: 895041 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Jiri Denemark +RH-Acked-by: Luiz Capitulino + +Bugzilla: https://bugzilla.redhat.com/show_bug.cgi?id=895041 + +Forward-port of RHEL-6-only commit + + commit 1a2b98f958fb770b70fa5a244e86c93655400858 + Author: Luiz Capitulino + Date: Thu Nov 4 13:51:42 2010 -0200 + + QMP: Improve debuggability of the BLOCK_IO_ERROR event + +Again, the code & docs are extended to BLOCK_JOB_ERROR. + +In the printf() added to bdrv_emit_qmp_error_event() I could have +scavenged the static global "monitor_event_names", but I would have had +to make it extern (or rather add a public getter function), which I deemed +too much. + +Signed-off-by: Laszlo Ersek +--- + block.c | 19 +++++++++++++++++++ + QMP/qmp-events.txt | 20 ++++++++++++++++++-- + 2 files changed, 37 insertions(+), 2 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + QMP/qmp-events.txt | 20 ++++++++++++++++++-- + block.c | 19 +++++++++++++++++++ + 2 files changed, 37 insertions(+), 2 deletions(-) + +diff --git a/QMP/qmp-events.txt b/QMP/qmp-events.txt +index c8c6d75..fc4b7db 100644 +--- a/QMP/qmp-events.txt ++++ b/QMP/qmp-events.txt +@@ -59,6 +59,11 @@ Data: + "eperm": errno EPERM + "enospc": errno ENOSPC + "eother": any other errno (other than EIO, EPERM, ENOSPC) ++- "__com.redhat_debug_info": RHEL7 extension containing debug information for ++ humans, applications should NOT read any ++ information from this member (json-object): ++ - "errno": errno value (json-int) ++ - "message": error message returned by strerror() (json-string) + + Example: + +@@ -66,7 +71,10 @@ Example: + "data": { "device": "ide0-hd1", + "operation": "write", + "action": "stop", +- "__com.redhat_reason": "enospc" }, ++ "__com.redhat_reason": "enospc", ++ "__com.redhat_debug_info": { ++ "message": "No space left on device", ++ "errno": 28 } } + "timestamp": { "seconds": 1265044230, "microseconds": 450486 } } + + Note: If action is "stop", a STOP event will eventually follow the +@@ -144,6 +152,11 @@ Data: + "eperm": errno EPERM + "enospc": errno ENOSPC + "eother": any other errno (other than EIO, EPERM, ENOSPC) ++- "__com.redhat_debug_info": RHEL7 extension containing debug information for ++ humans, applications should NOT read any ++ information from this member (json-object): ++ - "errno": errno value (json-int) ++ - "message": error message returned by strerror() (json-string) + + Example: + +@@ -151,7 +164,10 @@ Example: + "data": { "device": "ide0-hd1", + "operation": "write", + "action": "stop", +- "__com.redhat_reason": "enospc" }, ++ "__com.redhat_reason": "enospc", ++ "__com.redhat_debug_info": { ++ "message": "No space left on device", ++ "errno": 28 } } + "timestamp": { "seconds": 1265044230, "microseconds": 450486 } } + + BLOCK_JOB_READY +diff --git a/block.c b/block.c +index 68755bf..8ef07bb 100644 +--- a/block.c ++++ b/block.c +@@ -1748,6 +1748,18 @@ static void bdrv_put_rhel7_reason(QDict *event, int error) + qdict_put(event, BDRV_REASON_KEY, qstring_from_str(reason)); + } + ++#define BDRV_DEBUG_KEY RFQDN_REDHAT "debug_info" ++ ++/* RHEL7 vendor extension */ ++static void bdrv_put_rhel7_debug_info(QDict *event, int error) ++{ ++ QObject *info; ++ ++ info = qobject_from_jsonf("{ 'errno': %d, 'message': %s }", error, ++ strerror(error)); ++ qdict_put_obj(event, BDRV_DEBUG_KEY, info); ++} ++ + void bdrv_emit_qmp_error_event(const BlockDriverState *bdrv, + enum MonitorEvent ev, + BlockErrorAction action, +@@ -1771,11 +1783,18 @@ void bdrv_emit_qmp_error_event(const BlockDriverState *bdrv, + abort(); + } + ++ fprintf(stderr, "%s error in device '%s': %s (%d)\n", ++ ev == QEVENT_BLOCK_IO_ERROR ? "block I/O" : ++ ev == QEVENT_BLOCK_JOB_ERROR ? "block job" : ++ "other block", ++ bdrv->device_name, strerror(error), error); ++ + data = qobject_from_jsonf("{ 'device': %s, 'action': %s, 'operation': %s }", + bdrv->device_name, + action_str, + is_read ? "read" : "write"); + bdrv_put_rhel7_reason(qobject_to_qdict(data), error); ++ bdrv_put_rhel7_debug_info(qobject_to_qdict(data), error); + monitor_protocol_event(ev, data); + + qobject_decref(data); +-- +1.7.1 + diff --git a/SOURCES/kvm-intel-hda-fix-position-buffer.patch b/SOURCES/kvm-intel-hda-fix-position-buffer.patch new file mode 100644 index 0000000..333db16 --- /dev/null +++ b/SOURCES/kvm-intel-hda-fix-position-buffer.patch @@ -0,0 +1,51 @@ +From 91bcfcc9583a61158f7f69f52ff3575eb432067f Mon Sep 17 00:00:00 2001 +From: Gerd Hoffmann +Date: Wed, 11 Dec 2013 09:49:07 -0500 +Subject: [PATCH 01/14] intel-hda: fix position buffer + +Message-id: <1386755347-9800-2-git-send-email-kraxel@redhat.com> +Patchwork-id: 56156 +O-Subject: [RHEL-7 qemu-kvm PATCH 1/1] intel-hda: fix position buffer +Bugzilla: 947785 +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Miroslav Rezanina +RH-Acked-by: Orit Wasserman + +Fix position buffer updates to use the correct stream offset. + +Without this patch both IN (record) and OUT (playback) streams +will update the IN buffer positions. The linux kernel notices +and complains: + hda-intel: Invalid position buffer, using LPIB read method instead. + +The bug may also lead to glitches when recording and playing +at the same time: + https://bugzilla.redhat.com/show_bug.cgi?id=947785 + +Cc: qemu-stable@nongnu.org +Signed-off-by: Gerd Hoffmann +(cherry picked from commit d58ce68a454e5ae9cbde0308def379e272f13b10) +--- + hw/audio/intel-hda.c | 1 + + 1 file changed, 1 insertion(+) + +Signed-off-by: Miroslav Rezanina +--- + hw/audio/intel-hda.c | 1 + + 1 file changed, 1 insertion(+) + +diff --git a/hw/audio/intel-hda.c b/hw/audio/intel-hda.c +index e747342..cc948de 100644 +--- a/hw/audio/intel-hda.c ++++ b/hw/audio/intel-hda.c +@@ -439,6 +439,7 @@ static bool intel_hda_xfer(HDACodecDevice *dev, uint32_t stnr, bool output, + } + } + if (d->dp_lbase & 0x01) { ++ s = st - d->st; + addr = intel_hda_addr(d->dp_lbase & ~0x01, d->dp_ubase); + stl_le_pci_dma(&d->pci, addr + 8*s, st->lpib); + } +-- +1.8.3.1 + diff --git a/SOURCES/kvm-introduce-MIG_STATE_CANCELLING-state.patch b/SOURCES/kvm-introduce-MIG_STATE_CANCELLING-state.patch new file mode 100644 index 0000000..c3c2e13 --- /dev/null +++ b/SOURCES/kvm-introduce-MIG_STATE_CANCELLING-state.patch @@ -0,0 +1,115 @@ +From b5a3f9ac5db568ddfb572d11fb4d6a659c0f5bfa Mon Sep 17 00:00:00 2001 +From: Dr. David Alan Gilbert (git) +Date: Wed, 15 Jan 2014 19:42:28 +0100 +Subject: [PATCH 02/34] introduce MIG_STATE_CANCELLING state + +RH-Author: Dr. David Alan Gilbert (git) +Message-id: <1389814948-3983-3-git-send-email-dgilbert@redhat.com> +Patchwork-id: 56731 +O-Subject: [RHEL-7.0 qemu-kvm PATCH 2/2] introduce MIG_STATE_CANCELLING state +Bugzilla: 1053699 +RH-Acked-by: Orit Wasserman +RH-Acked-by: Juan Quintela +RH-Acked-by: Laszlo Ersek + +From: "Zhanghaoyu (A)" + +Introduce MIG_STATE_CANCELLING state to avoid starting a new migration task while the previous one still exist. + +Signed-off-by: Zeng Junliang +Signed-off-by: Zhang Haoyu +Reviewed-by: Paolo Bonzini +Signed-off-by: Juan Quintela +(cherry picked from commit 51cf4c1a99a172679c2949a2d58a2a4ee307b557) + +Conflicts: + migration.c +--- + migration.c | 26 ++++++++++++++++---------- + 1 file changed, 16 insertions(+), 10 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + migration.c | 26 ++++++++++++++++---------- + 1 files changed, 16 insertions(+), 10 deletions(-) + +diff --git a/migration.c b/migration.c +index 735f7ca..21f7247 100644 +--- a/migration.c ++++ b/migration.c +@@ -39,6 +39,7 @@ enum { + MIG_STATE_ERROR = -1, + MIG_STATE_NONE, + MIG_STATE_SETUP, ++ MIG_STATE_CANCELLING, + MIG_STATE_CANCELLED, + MIG_STATE_ACTIVE, + MIG_STATE_COMPLETED, +@@ -194,6 +195,7 @@ MigrationInfo *qmp_query_migrate(Error **errp) + info->has_total_time = false; + break; + case MIG_STATE_ACTIVE: ++ case MIG_STATE_CANCELLING: + info->has_status = true; + info->status = g_strdup("active"); + info->has_total_time = true; +@@ -280,6 +282,13 @@ void qmp_migrate_set_capabilities(MigrationCapabilityStatusList *params, + + /* shared migration helpers */ + ++static void migrate_set_state(MigrationState *s, int old_state, int new_state) ++{ ++ if (atomic_cmpxchg(&s->state, old_state, new_state) == new_state) { ++ trace_migrate_set_state(new_state); ++ } ++} ++ + static void migrate_fd_cleanup(void *opaque) + { + MigrationState *s = opaque; +@@ -301,18 +310,14 @@ static void migrate_fd_cleanup(void *opaque) + + if (s->state != MIG_STATE_COMPLETED) { + qemu_savevm_state_cancel(); ++ if (s->state == MIG_STATE_CANCELLING) { ++ migrate_set_state(s, MIG_STATE_CANCELLING, MIG_STATE_CANCELLED); ++ } + } + + notifier_list_notify(&migration_state_notifiers, s); + } + +-static void migrate_set_state(MigrationState *s, int old_state, int new_state) +-{ +- if (atomic_cmpxchg(&s->state, old_state, new_state) == new_state) { +- trace_migrate_set_state(new_state); +- } +-} +- + void migrate_fd_error(MigrationState *s) + { + DPRINTF("setting error state\n"); +@@ -332,8 +337,8 @@ static void migrate_fd_cancel(MigrationState *s) + if (old_state != MIG_STATE_SETUP && old_state != MIG_STATE_ACTIVE) { + break; + } +- migrate_set_state(s, old_state, MIG_STATE_CANCELLED); +- } while (s->state != MIG_STATE_CANCELLED); ++ migrate_set_state(s, old_state, MIG_STATE_CANCELLING); ++ } while (s->state != MIG_STATE_CANCELLING); + } + + void add_migration_state_change_notifier(Notifier *notify) +@@ -418,7 +423,8 @@ void qmp_migrate(const char *uri, bool has_blk, bool blk, + } + #endif + +- if (s->state == MIG_STATE_ACTIVE || s->state == MIG_STATE_SETUP) { ++ if (s->state == MIG_STATE_ACTIVE || s->state == MIG_STATE_SETUP || ++ s->state == MIG_STATE_CANCELLING) { + error_set(errp, QERR_MIGRATION_ACTIVE); + return; + } +-- +1.7.1 + diff --git a/SOURCES/kvm-introduce-RFQDN_REDHAT-RHEL-6-7-fwd.patch b/SOURCES/kvm-introduce-RFQDN_REDHAT-RHEL-6-7-fwd.patch new file mode 100644 index 0000000..0ccf248 --- /dev/null +++ b/SOURCES/kvm-introduce-RFQDN_REDHAT-RHEL-6-7-fwd.patch @@ -0,0 +1,51 @@ +From eef2b7f5dd51a0b27cb291fccb995f1e3630b11f Mon Sep 17 00:00:00 2001 +From: Laszlo Ersek +Date: Thu, 21 Nov 2013 16:27:17 +0100 +Subject: [PATCH 07/14] introduce RFQDN_REDHAT (RHEL 6->7 fwd) + +RH-Author: Laszlo Ersek +Message-id: <1385051239-3677-2-git-send-email-lersek@redhat.com> +Patchwork-id: 55836 +O-Subject: [RHEL-7.0 qemu-kvm PATCH 1/3] introduce RFQDN_REDHAT (RHEL 6->7 fwd) +Bugzilla: 971933 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Jiri Denemark +RH-Acked-by: Luiz Capitulino + +Bugzilla: https://bugzilla.redhat.com/show_bug.cgi?id=971933 + +This forward ports the final effect of RHEL-6 commit + + commit 8d99c4ad4d9fa53768bfbca8606457f8179f4404 + Author: Luiz Capitulino + Date: Fri May 14 22:49:19 2010 -0300 + + Monitor: Make RFQDN_REDHAT public + +Signed-off-by: Laszlo Ersek +--- + include/monitor/monitor.h | 3 +++ + 1 file changed, 3 insertions(+) + +Signed-off-by: Miroslav Rezanina +--- + include/monitor/monitor.h | 3 +++ + 1 files changed, 3 insertions(+), 0 deletions(-) + +diff --git a/include/monitor/monitor.h b/include/monitor/monitor.h +index 10fa0e3..dcce609 100644 +--- a/include/monitor/monitor.h ++++ b/include/monitor/monitor.h +@@ -19,6 +19,9 @@ extern Monitor *default_mon; + /* flags for monitor commands */ + #define MONITOR_CMD_ASYNC 0x0001 + ++/* Red Hat Monitor's prefix (reversed fully qualified domain) */ ++#define RFQDN_REDHAT "__com.redhat_" ++ + /* QMP events */ + typedef enum MonitorEvent { + QEVENT_SHUTDOWN, +-- +1.7.1 + diff --git a/SOURCES/kvm-iotests-Test-corruption-during-COW-request.patch b/SOURCES/kvm-iotests-Test-corruption-during-COW-request.patch new file mode 100644 index 0000000..c0f52bc --- /dev/null +++ b/SOURCES/kvm-iotests-Test-corruption-during-COW-request.patch @@ -0,0 +1,108 @@ +From 8ddf0e61ad5bc3ab854a04f6b20d996ef4ed0ae2 Mon Sep 17 00:00:00 2001 +From: Max Reitz +Date: Mon, 17 Mar 2014 22:45:31 +0100 +Subject: [PATCH 6/6] iotests: Test corruption during COW request + +RH-Author: Max Reitz +Message-id: <1395096331-12610-4-git-send-email-mreitz@redhat.com> +Patchwork-id: 58121 +O-Subject: [RHEL-7.0 qemu-kvm PATCH 3/3] iotests: Test corruption during COW request +Bugzilla: 1048575 +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Kevin Wolf +RH-Acked-by: Fam Zheng + +BZ: 1048575 + +Extend test file 060 by a test case for corruption occuring concurrently +to a COW request. QEMU should not crash but rather return an appropriate +error message. + +Signed-off-by: Max Reitz +Signed-off-by: Stefan Hajnoczi +(cherry picked from commit 98d39e34fe95f8609be3ccbd1b67926631d2c7c0) + +Conflicts: + tests/qemu-iotests/060 + +As the series allowing blkdebug to be used through the QMP interfaces +has not yet been backported, this test may not use +"-o file.driver=blkdebug" to select the blkdebug block driver, but +rather "blkdebug::$TEST_IMG" as the filename. + +Signed-off-by: Max Reitz +--- + tests/qemu-iotests/060 | 26 ++++++++++++++++++++++++++ + tests/qemu-iotests/060.out | 15 +++++++++++++++ + 2 files changed, 41 insertions(+) + +Signed-off-by: Miroslav Rezanina +--- + tests/qemu-iotests/060 | 26 ++++++++++++++++++++++++++ + tests/qemu-iotests/060.out | 15 +++++++++++++++ + 2 files changed, 41 insertions(+), 0 deletions(-) + +diff --git a/tests/qemu-iotests/060 b/tests/qemu-iotests/060 +index bbb1909..2abd566 100644 +--- a/tests/qemu-iotests/060 ++++ b/tests/qemu-iotests/060 +@@ -138,6 +138,32 @@ $QEMU_IMG snapshot -a foo "$TEST_IMG" + _check_test_img + $QEMU_IO -c "$OPEN_RO" -c "read -P 1 0 512" | _filter_qemu_io + ++echo ++echo "=== Testing overlap while COW is in flight ===" ++echo ++# compat=0.10 is required in order to make the following discard actually ++# unallocate the sector rather than make it a zero sector - we want COW, after ++# all. ++IMGOPTS='compat=0.10' _make_test_img 1G ++# Write two clusters, the second one enforces creation of an L2 table after ++# the first data cluster. ++$QEMU_IO -c 'write 0k 64k' -c 'write 512M 64k' "$TEST_IMG" | _filter_qemu_io ++# Discard the first cluster. This cluster will soon enough be reallocated and ++# used for COW. ++$QEMU_IO -c 'discard 0k 64k' "$TEST_IMG" | _filter_qemu_io ++# Now, corrupt the image by marking the second L2 table cluster as free. ++poke_file "$TEST_IMG" '131084' "\x00\x00" # 0x2000c ++# Start a write operation requiring COW on the image stopping it right before ++# doing the read; then, trigger the corruption prevention by writing anything to ++# any unallocated cluster, leading to an attempt to overwrite the second L2 ++# table. Finally, resume the COW write and see it fail (but not crash). ++echo "open blkdebug::$TEST_IMG ++break cow_read 0 ++aio_write 0k 1k ++wait_break 0 ++write 64k 64k ++resume 0" | $QEMU_IO | _filter_qemu_io ++ + # success, all done + echo "*** done" + rm -f $seq.full +diff --git a/tests/qemu-iotests/060.out b/tests/qemu-iotests/060.out +index 6c7bdbb..a517948 100644 +--- a/tests/qemu-iotests/060.out ++++ b/tests/qemu-iotests/060.out +@@ -78,4 +78,19 @@ read 512/512 bytes at offset 0 + No errors were found on the image. + read 512/512 bytes at offset 0 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) ++ ++=== Testing overlap while COW is in flight === ++ ++Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824 ++wrote 65536/65536 bytes at offset 0 ++64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) ++wrote 65536/65536 bytes at offset 536870912 ++64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) ++discard 65536/65536 bytes at offset 0 ++64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) ++qcow2: Preventing invalid write on metadata (overlaps with active L2 table); image marked as corrupt. ++blkdebug: Suspended request '0' ++write failed: Input/output error ++blkdebug: Resuming request '0' ++aio_write failed: No medium found + *** done +-- +1.7.1 + diff --git a/SOURCES/kvm-isapc-Fix-non-KVM-qemu-boot-read-write-memory-for-is.patch b/SOURCES/kvm-isapc-Fix-non-KVM-qemu-boot-read-write-memory-for-is.patch new file mode 100644 index 0000000..4d10feb --- /dev/null +++ b/SOURCES/kvm-isapc-Fix-non-KVM-qemu-boot-read-write-memory-for-is.patch @@ -0,0 +1,135 @@ +From 5554a8bea7ed5a16e306fc384a88fe4ff25d9f1a Mon Sep 17 00:00:00 2001 +From: Laszlo Ersek +Date: Sat, 11 Jan 2014 17:59:55 +0100 +Subject: [PATCH 05/22] isapc: Fix non-KVM qemu boot (read/write memory for isapc BIOS) + +RH-Author: Laszlo Ersek +Message-id: <1389463208-6278-6-git-send-email-lersek@redhat.com> +Patchwork-id: 56618 +O-Subject: [RHEL-7.0 qemu-kvm PATCH 05/18] isapc: Fix non-KVM qemu boot (read/write memory for isapc BIOS) +Bugzilla: 1032346 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Amos Kong +RH-Acked-by: Andrew Jones +RH-Acked-by: Kevin Wolf + +From: Jordan Justen + +The isapc machine with seabios currently requires the BIOS region +to be read/write memory rather than read-only memory. + +KVM currently cannot support the BIOS as a ROM region, but qemu +in non-KVM mode can. Based on this, isapc machine currently only +works with KVM. + +To work-around this isapc issue, this change avoids marking the +BIOS as readonly for isapc. + +This change also will allow KVM to start supporting ROM mode +via KVM_CAP_READONLY_MEM. + +Signed-off-by: Jordan Justen +Reviewed-by: Paolo Bonzini +Message-id: 1369816047-16384-2-git-send-email-jordan.l.justen@intel.com +Signed-off-by: Anthony Liguori +(cherry picked from commit dade922f357c709c02eed2e1b1891453896756dd) +Signed-off-by: Laszlo Ersek +--- + hw/block/pc_sysfw.c | 16 +++++++++++----- + hw/i386/pc_piix.c | 5 +++++ + 2 files changed, 16 insertions(+), 5 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + hw/block/pc_sysfw.c | 16 +++++++++++----- + hw/i386/pc_piix.c | 5 +++++ + 2 files changed, 16 insertions(+), 5 deletions(-) + +diff --git a/hw/block/pc_sysfw.c b/hw/block/pc_sysfw.c +index 6149b20..4d82c70 100644 +--- a/hw/block/pc_sysfw.c ++++ b/hw/block/pc_sysfw.c +@@ -39,6 +39,7 @@ + typedef struct PcSysFwDevice { + SysBusDevice busdev; + uint8_t rom_only; ++ uint8_t isapc_ram_fw; + } PcSysFwDevice; + + static void pc_isa_bios_init(MemoryRegion *rom_memory, +@@ -136,7 +137,7 @@ static void pc_system_flash_init(MemoryRegion *rom_memory, + pc_isa_bios_init(rom_memory, flash_mem, size); + } + +-static void old_pc_system_rom_init(MemoryRegion *rom_memory) ++static void old_pc_system_rom_init(MemoryRegion *rom_memory, bool isapc_ram_fw) + { + char *filename; + MemoryRegion *bios, *isa_bios; +@@ -160,7 +161,9 @@ static void old_pc_system_rom_init(MemoryRegion *rom_memory) + bios = g_malloc(sizeof(*bios)); + memory_region_init_ram(bios, "pc.bios", bios_size); + vmstate_register_ram_global(bios); +- memory_region_set_readonly(bios, true); ++ if (!isapc_ram_fw) { ++ memory_region_set_readonly(bios, true); ++ } + ret = rom_add_file_fixed(bios_name, (uint32_t)(-bios_size), -1); + if (ret != 0) { + bios_error: +@@ -183,7 +186,9 @@ static void old_pc_system_rom_init(MemoryRegion *rom_memory) + 0x100000 - isa_bios_size, + isa_bios, + 1); +- memory_region_set_readonly(isa_bios, true); ++ if (!isapc_ram_fw) { ++ memory_region_set_readonly(isa_bios, true); ++ } + + /* map all the bios at the top of memory */ + memory_region_add_subregion(rom_memory, +@@ -213,7 +218,7 @@ void pc_system_firmware_init(MemoryRegion *rom_memory) + qdev_init_nofail(DEVICE(sysfw_dev)); + + if (sysfw_dev->rom_only) { +- old_pc_system_rom_init(rom_memory); ++ old_pc_system_rom_init(rom_memory, sysfw_dev->isapc_ram_fw); + return; + } + +@@ -231,7 +236,7 @@ void pc_system_firmware_init(MemoryRegion *rom_memory) + exit(1); + } else { + sysfw_dev->rom_only = 1; +- old_pc_system_rom_init(rom_memory); ++ old_pc_system_rom_init(rom_memory, sysfw_dev->isapc_ram_fw); + return; + } + } +@@ -252,6 +257,7 @@ void pc_system_firmware_init(MemoryRegion *rom_memory) + } + + static Property pcsysfw_properties[] = { ++ DEFINE_PROP_UINT8("isapc_ram_fw", PcSysFwDevice, isapc_ram_fw, 0), + DEFINE_PROP_UINT8("rom_only", PcSysFwDevice, rom_only, 0), + DEFINE_PROP_END_OF_LIST(), + }; +diff --git a/hw/i386/pc_piix.c b/hw/i386/pc_piix.c +index 12351f9..0a8a4e5 100644 +--- a/hw/i386/pc_piix.c ++++ b/hw/i386/pc_piix.c +@@ -714,6 +714,11 @@ static QEMUMachine isapc_machine = { + .property = "rom_only", + .value = stringify(1), + }, ++ { ++ .driver = "pc-sysfw", ++ .property = "isapc_ram_fw", ++ .value = stringify(1), ++ }, + { /* end of list */ } + }, + DEFAULT_MACHINE_OPTIONS, +-- +1.7.1 + diff --git a/SOURCES/kvm-iscsi-Set-bs-request_alignment.patch b/SOURCES/kvm-iscsi-Set-bs-request_alignment.patch new file mode 100644 index 0000000..a9cf204 --- /dev/null +++ b/SOURCES/kvm-iscsi-Set-bs-request_alignment.patch @@ -0,0 +1,47 @@ +From 36fb92fbc1edd351b923199559a0a923da9f72c4 Mon Sep 17 00:00:00 2001 +From: Kevin Wolf +Date: Tue, 29 Nov 2011 12:41:35 +0100 +Subject: [PATCH 30/37] iscsi: Set bs->request_alignment + +Message-id: <1392117622-28812-31-git-send-email-kwolf@redhat.com> +Patchwork-id: 57195 +O-Subject: [RHEL-7.0 qemu-kvm PATCH v2 30/37] iscsi: Set bs->request_alignment +Bugzilla: 748906 +RH-Acked-by: Laszlo Ersek +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Max Reitz + +From: Paolo Bonzini + +The iSCSI backend already gets the block size from the READ CAPACITY +command it sends. Save it so that the generic block layer gets it +too. + +Signed-off-by: Paolo Bonzini +Signed-off-by: Kevin Wolf +Reviewed-by: Max Reitz +(cherry picked from commit 2c9880c45e2f9a98d11d44ce9966515c23870a86) + +Signed-off-by: Kevin Wolf +--- + block/iscsi.c | 1 + + 1 file changed, 1 insertion(+) +--- + block/iscsi.c | 1 + + 1 files changed, 1 insertions(+), 0 deletions(-) + +diff --git a/block/iscsi.c b/block/iscsi.c +index 83e4f15..63a21e2 100644 +--- a/block/iscsi.c ++++ b/block/iscsi.c +@@ -1397,6 +1397,7 @@ static int iscsi_open(BlockDriverState *bs, QDict *options, int flags, + goto out; + } + bs->total_sectors = sector_lun2qemu(iscsilun->num_blocks, iscsilun); ++ bs->request_alignment = iscsilun->block_size; + + /* Medium changer or tape. We dont have any emulation for this so this must + * be sg ioctl compatible. We force it to be sg, otherwise qemu will try +-- +1.7.1 + diff --git a/SOURCES/kvm-iscsi-Use-bs-sg-for-everything-else-than-disks.patch b/SOURCES/kvm-iscsi-Use-bs-sg-for-everything-else-than-disks.patch new file mode 100644 index 0000000..6f2fe32 --- /dev/null +++ b/SOURCES/kvm-iscsi-Use-bs-sg-for-everything-else-than-disks.patch @@ -0,0 +1,63 @@ +From 9273caf09add518239e77f02081bc4f455e24425 Mon Sep 17 00:00:00 2001 +From: Kevin Wolf +Date: Mon, 10 Mar 2014 11:07:21 +0100 +Subject: [PATCH 13/16] iscsi: Use bs->sg for everything else than disks + +RH-Author: Kevin Wolf +Message-id: <1394449642-13562-2-git-send-email-kwolf@redhat.com> +Patchwork-id: 58063 +O-Subject: [RHEL-7.0 qemu-kvm PATCH 1/2] iscsi: Use bs->sg for everything else than disks +Bugzilla: 1067784 +RH-Acked-by: Juan Quintela +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Paolo Bonzini + +The current iscsi block driver code makes the rather arbitrary decision +that TYPE_MEDIUM_CHANGER and TYPE_TAPE devices have bs->sg = 1 and all +other device types are disks. + +Instead of this, check for TYPE_DISK to expose the disk interface and +make everything else bs->sg = 1. In particular, this includes devices +with TYPE_STORAGE_ARRAY, which is what LUN 0 of an iscsi target is. +(See https://bugzilla.redhat.com/show_bug.cgi?id=1067784 for the exact +scenario.) + +Signed-off-by: Kevin Wolf +Reviewed-by: Benoit Canet +Acked-by: Paolo Bonzini +(cherry picked from commit f47c3f5a800a927238d20de9f99b5c77f0bc3fe0) + +Signed-off-by: Kevin Wolf +--- + block/iscsi.c | 9 ++++----- + 1 file changed, 4 insertions(+), 5 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + block/iscsi.c | 9 ++++----- + 1 files changed, 4 insertions(+), 5 deletions(-) + +diff --git a/block/iscsi.c b/block/iscsi.c +index 63a21e2..64a8295 100644 +--- a/block/iscsi.c ++++ b/block/iscsi.c +@@ -1399,12 +1399,11 @@ static int iscsi_open(BlockDriverState *bs, QDict *options, int flags, + bs->total_sectors = sector_lun2qemu(iscsilun->num_blocks, iscsilun); + bs->request_alignment = iscsilun->block_size; + +- /* Medium changer or tape. We dont have any emulation for this so this must +- * be sg ioctl compatible. We force it to be sg, otherwise qemu will try +- * to read from the device to guess the image format. ++ /* We don't have any emulation for devices other than disks and CD-ROMs, so ++ * this must be sg ioctl compatible. We force it to be sg, otherwise qemu ++ * will try to read from the device to guess the image format. + */ +- if (iscsilun->type == TYPE_MEDIUM_CHANGER || +- iscsilun->type == TYPE_TAPE) { ++ if (iscsilun->type != TYPE_DISK && iscsilun->type != TYPE_ROM) { + bs->sg = 1; + } + +-- +1.7.1 + diff --git a/SOURCES/kvm-iscsi-add-.bdrv_get_block_status.patch.patch.patch b/SOURCES/kvm-iscsi-add-.bdrv_get_block_status.patch.patch.patch new file mode 100644 index 0000000..185c3de --- /dev/null +++ b/SOURCES/kvm-iscsi-add-.bdrv_get_block_status.patch.patch.patch @@ -0,0 +1,205 @@ +From a976099b24c5db9cb4ab1a059b01610d2fc48537 Mon Sep 17 00:00:00 2001 +Message-Id: +In-Reply-To: +References: +From: Paolo Bonzini +Date: Mon, 9 Dec 2013 14:08:52 +0100 +Subject: [PATCH 04/50] iscsi: add .bdrv_get_block_status + +RH-Author: Paolo Bonzini +Message-id: <1386598178-11845-7-git-send-email-pbonzini@redhat.com> +Patchwork-id: 56043 +O-Subject: [RHEL 7.0 qemu-kvm PATCH 06/52] iscsi: add .bdrv_get_block_status +Bugzilla: 1007815 +RH-Acked-by: Jeffrey Cody +RH-Acked-by: Fam Zheng +RH-Acked-by: Stefan Hajnoczi + +From: Peter Lieven + +this patch adds a coroutine for .bdrv_co_block_status as well as +a generic framework that can be used to build coroutines in block/iscsi. + +Signed-off-by: Peter Lieven +Signed-off-by: Paolo Bonzini +(cherry picked from commit 54a5c1d5db47b4146490937ed73e3f56022aaba6) +--- + block/iscsi.c | 136 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + 1 file changed, 136 insertions(+) + +Signed-off-by: Michal Novotny +--- + block/iscsi.c | 136 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + 1 file changed, 136 insertions(+) + +diff --git a/block/iscsi.c b/block/iscsi.c +index 6804b6d..f8d021a 100644 +--- a/block/iscsi.c ++++ b/block/iscsi.c +@@ -58,6 +58,15 @@ typedef struct IscsiLun { + struct scsi_inquiry_block_limits bl; + } IscsiLun; + ++typedef struct IscsiTask { ++ int status; ++ int complete; ++ int retries; ++ int do_retry; ++ struct scsi_task *task; ++ Coroutine *co; ++} IscsiTask; ++ + typedef struct IscsiAIOCB { + BlockDriverAIOCB common; + QEMUIOVector *qiov; +@@ -111,6 +120,41 @@ iscsi_schedule_bh(IscsiAIOCB *acb) + qemu_bh_schedule(acb->bh); + } + ++static void ++iscsi_co_generic_cb(struct iscsi_context *iscsi, int status, ++ void *command_data, void *opaque) ++{ ++ struct IscsiTask *iTask = opaque; ++ struct scsi_task *task = command_data; ++ ++ iTask->complete = 1; ++ iTask->status = status; ++ iTask->do_retry = 0; ++ iTask->task = task; ++ ++ if (iTask->retries-- > 0 && status == SCSI_STATUS_CHECK_CONDITION ++ && task->sense.key == SCSI_SENSE_UNIT_ATTENTION) { ++ iTask->do_retry = 1; ++ goto out; ++ } ++ ++ if (status != SCSI_STATUS_GOOD) { ++ error_report("iSCSI: Failure. %s", iscsi_get_error(iscsi)); ++ } ++ ++out: ++ if (iTask->co) { ++ qemu_coroutine_enter(iTask->co, NULL); ++ } ++} ++ ++static void iscsi_co_init_iscsitask(IscsiLun *iscsilun, struct IscsiTask *iTask) ++{ ++ *iTask = (struct IscsiTask) { ++ .co = qemu_coroutine_self(), ++ .retries = ISCSI_CMD_RETRIES, ++ }; ++} + + static void + iscsi_abort_task_cb(struct iscsi_context *iscsi, int status, void *command_data, +@@ -854,6 +898,96 @@ iscsi_getlength(BlockDriverState *bs) + return len; + } + ++static int64_t coroutine_fn iscsi_co_get_block_status(BlockDriverState *bs, ++ int64_t sector_num, ++ int nb_sectors, int *pnum) ++{ ++ IscsiLun *iscsilun = bs->opaque; ++ struct scsi_get_lba_status *lbas = NULL; ++ struct scsi_lba_status_descriptor *lbasd = NULL; ++ struct IscsiTask iTask; ++ int64_t ret; ++ ++ iscsi_co_init_iscsitask(iscsilun, &iTask); ++ ++ if (!is_request_lun_aligned(sector_num, nb_sectors, iscsilun)) { ++ ret = -EINVAL; ++ goto out; ++ } ++ ++ /* default to all sectors allocated */ ++ ret = BDRV_BLOCK_DATA; ++ ret |= (sector_num << BDRV_SECTOR_BITS) | BDRV_BLOCK_OFFSET_VALID; ++ *pnum = nb_sectors; ++ ++ /* LUN does not support logical block provisioning */ ++ if (iscsilun->lbpme == 0) { ++ goto out; ++ } ++ ++retry: ++ if (iscsi_get_lba_status_task(iscsilun->iscsi, iscsilun->lun, ++ sector_qemu2lun(sector_num, iscsilun), ++ 8 + 16, iscsi_co_generic_cb, ++ &iTask) == NULL) { ++ ret = -EIO; ++ goto out; ++ } ++ ++ while (!iTask.complete) { ++ iscsi_set_events(iscsilun); ++ qemu_coroutine_yield(); ++ } ++ ++ if (iTask.do_retry) { ++ if (iTask.task != NULL) { ++ scsi_free_scsi_task(iTask.task); ++ iTask.task = NULL; ++ } ++ goto retry; ++ } ++ ++ if (iTask.status != SCSI_STATUS_GOOD) { ++ /* in case the get_lba_status_callout fails (i.e. ++ * because the device is busy or the cmd is not ++ * supported) we pretend all blocks are allocated ++ * for backwards compatiblity */ ++ goto out; ++ } ++ ++ lbas = scsi_datain_unmarshall(iTask.task); ++ if (lbas == NULL) { ++ ret = -EIO; ++ goto out; ++ } ++ ++ lbasd = &lbas->descriptors[0]; ++ ++ if (sector_qemu2lun(sector_num, iscsilun) != lbasd->lba) { ++ ret = -EIO; ++ goto out; ++ } ++ ++ *pnum = sector_lun2qemu(lbasd->num_blocks, iscsilun); ++ if (*pnum > nb_sectors) { ++ *pnum = nb_sectors; ++ } ++ ++ if (lbasd->provisioning == SCSI_PROVISIONING_TYPE_DEALLOCATED || ++ lbasd->provisioning == SCSI_PROVISIONING_TYPE_ANCHORED) { ++ ret &= ~BDRV_BLOCK_DATA; ++ if (iscsilun->lbprz) { ++ ret |= BDRV_BLOCK_ZERO; ++ } ++ } ++ ++out: ++ if (iTask.task != NULL) { ++ scsi_free_scsi_task(iTask.task); ++ } ++ return ret; ++} ++ + static int parse_chap(struct iscsi_context *iscsi, const char *target) + { + QemuOptsList *list; +@@ -1406,6 +1540,8 @@ static BlockDriver bdrv_iscsi = { + .bdrv_getlength = iscsi_getlength, + .bdrv_truncate = iscsi_truncate, + ++ .bdrv_co_get_block_status = iscsi_co_get_block_status, ++ + .bdrv_aio_readv = iscsi_aio_readv, + .bdrv_aio_writev = iscsi_aio_writev, + .bdrv_aio_flush = iscsi_aio_flush, +-- +1.7.11.7 + diff --git a/SOURCES/kvm-iscsi-add-bdrv_co_write_zeroes.patch.patch.patch b/SOURCES/kvm-iscsi-add-bdrv_co_write_zeroes.patch.patch.patch new file mode 100644 index 0000000..7096251 --- /dev/null +++ b/SOURCES/kvm-iscsi-add-bdrv_co_write_zeroes.patch.patch.patch @@ -0,0 +1,130 @@ +From 0923f651d0a8ec837dc2c85dc6fbb9cfabd86172 Mon Sep 17 00:00:00 2001 +Message-Id: <0923f651d0a8ec837dc2c85dc6fbb9cfabd86172.1389014116.git.minovotn@redhat.com> +In-Reply-To: +References: +From: Paolo Bonzini +Date: Mon, 9 Dec 2013 14:09:06 +0100 +Subject: [PATCH 18/50] iscsi: add bdrv_co_write_zeroes + +RH-Author: Paolo Bonzini +Message-id: <1386598178-11845-21-git-send-email-pbonzini@redhat.com> +Patchwork-id: 56057 +O-Subject: [RHEL 7.0 qemu-kvm PATCH 20/52] iscsi: add bdrv_co_write_zeroes +Bugzilla: 1007815 +RH-Acked-by: Jeffrey Cody +RH-Acked-by: Fam Zheng +RH-Acked-by: Stefan Hajnoczi + +From: Peter Lieven + +Signed-off-by: Peter Lieven +Signed-off-by: Stefan Hajnoczi +(cherry picked from commit d4cd961507e6f013fd0f9b1dc609f15ed2aaa40d) +--- + block/iscsi.c | 64 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + 1 file changed, 64 insertions(+) + +Signed-off-by: Michal Novotny +--- + block/iscsi.c | 64 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + 1 file changed, 64 insertions(+) + +diff --git a/block/iscsi.c b/block/iscsi.c +index 567a63a..3e3ae64 100644 +--- a/block/iscsi.c ++++ b/block/iscsi.c +@@ -56,6 +56,7 @@ typedef struct IscsiLun { + uint8_t lbprz; + struct scsi_inquiry_logical_block_provisioning lbp; + struct scsi_inquiry_block_limits bl; ++ unsigned char *zeroblock; + } IscsiLun; + + typedef struct IscsiTask { +@@ -961,6 +962,65 @@ retry: + return 0; + } + ++#if defined(SCSI_SENSE_ASCQ_CAPACITY_DATA_HAS_CHANGED) ++ ++static int ++coroutine_fn iscsi_co_write_zeroes(BlockDriverState *bs, int64_t sector_num, ++ int nb_sectors, BdrvRequestFlags flags) ++{ ++ IscsiLun *iscsilun = bs->opaque; ++ struct IscsiTask iTask; ++ uint64_t lba; ++ uint32_t nb_blocks; ++ ++ if (!is_request_lun_aligned(sector_num, nb_sectors, iscsilun)) { ++ return -EINVAL; ++ } ++ ++ if (!iscsilun->lbp.lbpws) { ++ /* WRITE SAME is not supported by the target */ ++ return -ENOTSUP; ++ } ++ ++ lba = sector_qemu2lun(sector_num, iscsilun); ++ nb_blocks = sector_qemu2lun(nb_sectors, iscsilun); ++ ++ if (iscsilun->zeroblock == NULL) { ++ iscsilun->zeroblock = g_malloc0(iscsilun->block_size); ++ } ++ ++ iscsi_co_init_iscsitask(iscsilun, &iTask); ++retry: ++ if (iscsi_writesame16_task(iscsilun->iscsi, iscsilun->lun, lba, ++ iscsilun->zeroblock, iscsilun->block_size, ++ nb_blocks, 0, !!(flags & BDRV_REQ_MAY_UNMAP), ++ 0, 0, iscsi_co_generic_cb, &iTask) == NULL) { ++ return -EIO; ++ } ++ ++ while (!iTask.complete) { ++ iscsi_set_events(iscsilun); ++ qemu_coroutine_yield(); ++ } ++ ++ if (iTask.task != NULL) { ++ scsi_free_scsi_task(iTask.task); ++ iTask.task = NULL; ++ } ++ ++ if (iTask.do_retry) { ++ goto retry; ++ } ++ ++ if (iTask.status != SCSI_STATUS_GOOD) { ++ return -EIO; ++ } ++ ++ return 0; ++} ++ ++#endif /* SCSI_SENSE_ASCQ_CAPACITY_DATA_HAS_CHANGED */ ++ + static int parse_chap(struct iscsi_context *iscsi, const char *target) + { + QemuOptsList *list; +@@ -1423,6 +1483,7 @@ static void iscsi_close(BlockDriverState *bs) + } + qemu_aio_set_fd_handler(iscsi_get_fd(iscsi), NULL, NULL, NULL, NULL); + iscsi_destroy_context(iscsi); ++ g_free(iscsilun->zeroblock); + memset(iscsilun, 0, sizeof(IscsiLun)); + } + +@@ -1538,6 +1599,9 @@ static BlockDriver bdrv_iscsi = { + + .bdrv_co_get_block_status = iscsi_co_get_block_status, + .bdrv_co_discard = iscsi_co_discard, ++#if defined(SCSI_SENSE_ASCQ_CAPACITY_DATA_HAS_CHANGED) ++ .bdrv_co_write_zeroes = iscsi_co_write_zeroes, ++#endif + + .bdrv_aio_readv = iscsi_aio_readv, + .bdrv_aio_writev = iscsi_aio_writev, +-- +1.7.11.7 + diff --git a/SOURCES/kvm-iscsi-add-logical-block-provisioning-information-to-.patch.patch b/SOURCES/kvm-iscsi-add-logical-block-provisioning-information-to-.patch.patch new file mode 100644 index 0000000..ec63090 --- /dev/null +++ b/SOURCES/kvm-iscsi-add-logical-block-provisioning-information-to-.patch.patch @@ -0,0 +1,144 @@ +From 7f3514b0392635f132a8e1158d91536e5aed7783 Mon Sep 17 00:00:00 2001 +Message-Id: <7f3514b0392635f132a8e1158d91536e5aed7783.1389014116.git.minovotn@redhat.com> +In-Reply-To: +References: +From: Paolo Bonzini +Date: Mon, 9 Dec 2013 14:08:51 +0100 +Subject: [PATCH 03/50] iscsi: add logical block provisioning information to + iscsilun + +RH-Author: Paolo Bonzini +Message-id: <1386598178-11845-6-git-send-email-pbonzini@redhat.com> +Patchwork-id: 56042 +O-Subject: [RHEL 7.0 qemu-kvm PATCH 05/52] iscsi: add logical block provisioning information to iscsilun +Bugzilla: 1007815 +RH-Acked-by: Jeffrey Cody +RH-Acked-by: Fam Zheng +RH-Acked-by: Stefan Hajnoczi + +From: Peter Lieven + +Signed-off-by: Peter Lieven +Signed-off-by: Paolo Bonzini +(cherry picked from commit f18a7cbb0992a02225d26afd336aaf47de75e11c) +--- + block/iscsi.c | 77 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + 1 file changed, 77 insertions(+) + +Signed-off-by: Michal Novotny +--- + block/iscsi.c | 77 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + 1 file changed, 77 insertions(+) + +diff --git a/block/iscsi.c b/block/iscsi.c +index 8086957..6804b6d 100644 +--- a/block/iscsi.c ++++ b/block/iscsi.c +@@ -52,6 +52,10 @@ typedef struct IscsiLun { + uint64_t num_blocks; + int events; + QEMUTimer *nop_timer; ++ uint8_t lbpme; ++ uint8_t lbprz; ++ struct scsi_inquiry_logical_block_provisioning lbp; ++ struct scsi_inquiry_block_limits bl; + } IscsiLun; + + typedef struct IscsiAIOCB { +@@ -1005,6 +1009,8 @@ static int iscsi_readcapacity_sync(IscsiLun *iscsilun) + } else { + iscsilun->block_size = rc16->block_length; + iscsilun->num_blocks = rc16->returned_lba + 1; ++ iscsilun->lbpme = rc16->lbpme; ++ iscsilun->lbprz = rc16->lbprz; + } + } + break; +@@ -1057,6 +1063,37 @@ static QemuOptsList runtime_opts = { + }, + }; + ++static struct scsi_task *iscsi_do_inquiry(struct iscsi_context *iscsi, ++ int lun, int evpd, int pc) { ++ int full_size; ++ struct scsi_task *task = NULL; ++ task = iscsi_inquiry_sync(iscsi, lun, evpd, pc, 64); ++ if (task == NULL || task->status != SCSI_STATUS_GOOD) { ++ goto fail; ++ } ++ full_size = scsi_datain_getfullsize(task); ++ if (full_size > task->datain.size) { ++ scsi_free_scsi_task(task); ++ ++ /* we need more data for the full list */ ++ task = iscsi_inquiry_sync(iscsi, lun, evpd, pc, full_size); ++ if (task == NULL || task->status != SCSI_STATUS_GOOD) { ++ goto fail; ++ } ++ } ++ ++ return task; ++ ++fail: ++ error_report("iSCSI: Inquiry command failed : %s", ++ iscsi_get_error(iscsi)); ++ if (task) { ++ scsi_free_scsi_task(task); ++ return NULL; ++ } ++ return NULL; ++} ++ + /* + * We support iscsi url's on the form + * iscsi://[%@][:]// +@@ -1187,6 +1224,46 @@ static int iscsi_open(BlockDriverState *bs, QDict *options, int flags, + bs->sg = 1; + } + ++ if (iscsilun->lbpme) { ++ struct scsi_inquiry_logical_block_provisioning *inq_lbp; ++ task = iscsi_do_inquiry(iscsilun->iscsi, iscsilun->lun, 1, ++ SCSI_INQUIRY_PAGECODE_LOGICAL_BLOCK_PROVISIONING); ++ if (task == NULL) { ++ ret = -EINVAL; ++ goto out; ++ } ++ inq_lbp = scsi_datain_unmarshall(task); ++ if (inq_lbp == NULL) { ++ error_report("iSCSI: failed to unmarshall inquiry datain blob"); ++ ret = -EINVAL; ++ goto out; ++ } ++ memcpy(&iscsilun->lbp, inq_lbp, ++ sizeof(struct scsi_inquiry_logical_block_provisioning)); ++ scsi_free_scsi_task(task); ++ task = NULL; ++ } ++ ++ if (iscsilun->lbp.lbpu || iscsilun->lbp.lbpws) { ++ struct scsi_inquiry_block_limits *inq_bl; ++ task = iscsi_do_inquiry(iscsilun->iscsi, iscsilun->lun, 1, ++ SCSI_INQUIRY_PAGECODE_BLOCK_LIMITS); ++ if (task == NULL) { ++ ret = -EINVAL; ++ goto out; ++ } ++ inq_bl = scsi_datain_unmarshall(task); ++ if (inq_bl == NULL) { ++ error_report("iSCSI: failed to unmarshall inquiry datain blob"); ++ ret = -EINVAL; ++ goto out; ++ } ++ memcpy(&iscsilun->bl, inq_bl, ++ sizeof(struct scsi_inquiry_block_limits)); ++ scsi_free_scsi_task(task); ++ task = NULL; ++ } ++ + #if defined(LIBISCSI_FEATURE_NOP_COUNTER) + /* Set up a timer for sending out iSCSI NOPs */ + iscsilun->nop_timer = qemu_new_timer_ms(rt_clock, iscsi_nop_timed_event, iscsilun); +-- +1.7.11.7 + diff --git a/SOURCES/kvm-iscsi-factor-out-sector-conversions.patch.patch b/SOURCES/kvm-iscsi-factor-out-sector-conversions.patch.patch new file mode 100644 index 0000000..68c048d --- /dev/null +++ b/SOURCES/kvm-iscsi-factor-out-sector-conversions.patch.patch @@ -0,0 +1,70 @@ +From dba21483b097900b47ba5e1e597ba4a4150b1aa1 Mon Sep 17 00:00:00 2001 +Message-Id: +In-Reply-To: +References: +From: Paolo Bonzini +Date: Mon, 9 Dec 2013 14:08:50 +0100 +Subject: [PATCH 02/50] iscsi: factor out sector conversions + +RH-Author: Paolo Bonzini +Message-id: <1386598178-11845-5-git-send-email-pbonzini@redhat.com> +Patchwork-id: 56041 +O-Subject: [RHEL 7.0 qemu-kvm PATCH 04/52] iscsi: factor out sector conversions +Bugzilla: 1007815 +RH-Acked-by: Jeffrey Cody +RH-Acked-by: Fam Zheng +RH-Acked-by: Stefan Hajnoczi + +From: Peter Lieven + +Reviewed-by: Kevin Wolf +Signed-off-by: Peter Lieven +Signed-off-by: Paolo Bonzini +(cherry picked from commit 0777b5dde42f4f453abc8bb2c4e145fb8749415d) +--- + block/iscsi.c | 10 +++++++--- + 1 file changed, 7 insertions(+), 3 deletions(-) + +Signed-off-by: Michal Novotny +--- + block/iscsi.c | 10 +++++++--- + 1 file changed, 7 insertions(+), 3 deletions(-) + +diff --git a/block/iscsi.c b/block/iscsi.c +index ac35caa..8086957 100644 +--- a/block/iscsi.c ++++ b/block/iscsi.c +@@ -234,6 +234,11 @@ iscsi_aio_write16_cb(struct iscsi_context *iscsi, int status, + iscsi_schedule_bh(acb); + } + ++static int64_t sector_lun2qemu(int64_t sector, IscsiLun *iscsilun) ++{ ++ return sector * iscsilun->block_size / BDRV_SECTOR_SIZE; ++} ++ + static int64_t sector_qemu2lun(int64_t sector, IscsiLun *iscsilun) + { + return sector * BDRV_SECTOR_SIZE / iscsilun->block_size; +@@ -298,7 +303,7 @@ iscsi_aio_writev_acb(IscsiAIOCB *acb) + lba = sector_qemu2lun(acb->sector_num, acb->iscsilun); + *(uint32_t *)&acb->task->cdb[2] = htonl(lba >> 32); + *(uint32_t *)&acb->task->cdb[6] = htonl(lba & 0xffffffff); +- num_sectors = size / acb->iscsilun->block_size; ++ num_sectors = sector_qemu2lun(acb->nb_sectors, acb->iscsilun); + *(uint32_t *)&acb->task->cdb[10] = htonl(num_sectors); + acb->task->expxferlen = size; + +@@ -1171,8 +1176,7 @@ static int iscsi_open(BlockDriverState *bs, QDict *options, int flags, + if ((ret = iscsi_readcapacity_sync(iscsilun)) != 0) { + goto out; + } +- bs->total_sectors = iscsilun->num_blocks * +- iscsilun->block_size / BDRV_SECTOR_SIZE ; ++ bs->total_sectors = sector_lun2qemu(iscsilun->num_blocks, iscsilun); + + /* Medium changer or tape. We dont have any emulation for this so this must + * be sg ioctl compatible. We force it to be sg, otherwise qemu will try +-- +1.7.11.7 + diff --git a/SOURCES/kvm-iscsi-set-limits-in-BlockDriverState.patch.patch.patch b/SOURCES/kvm-iscsi-set-limits-in-BlockDriverState.patch.patch.patch new file mode 100644 index 0000000..543d81a --- /dev/null +++ b/SOURCES/kvm-iscsi-set-limits-in-BlockDriverState.patch.patch.patch @@ -0,0 +1,60 @@ +From a9bf8d1acc8589ebda4fb96acd08822a7937af9b Mon Sep 17 00:00:00 2001 +Message-Id: +In-Reply-To: +References: +From: Paolo Bonzini +Date: Mon, 9 Dec 2013 14:09:04 +0100 +Subject: [PATCH 16/50] iscsi: set limits in BlockDriverState + +RH-Author: Paolo Bonzini +Message-id: <1386598178-11845-19-git-send-email-pbonzini@redhat.com> +Patchwork-id: 56055 +O-Subject: [RHEL 7.0 qemu-kvm PATCH 18/52] iscsi: set limits in BlockDriverState +Bugzilla: 1007815 +RH-Acked-by: Jeffrey Cody +RH-Acked-by: Fam Zheng +RH-Acked-by: Stefan Hajnoczi + +From: Peter Lieven + +Reviewed-by: Eric Blake +Signed-off-by: Peter Lieven +Signed-off-by: Stefan Hajnoczi +(cherry picked from commit ba6c59191f245147e7ee0c2b9ecaf5fb116f7877) +--- + block/iscsi.c | 14 ++++++++++++++ + 1 file changed, 14 insertions(+) + +Signed-off-by: Michal Novotny +--- + block/iscsi.c | 14 ++++++++++++++ + 1 file changed, 14 insertions(+) + +diff --git a/block/iscsi.c b/block/iscsi.c +index 1e8a2bb..e5f4670 100644 +--- a/block/iscsi.c ++++ b/block/iscsi.c +@@ -1386,6 +1386,20 @@ static int iscsi_open(BlockDriverState *bs, QDict *options, int flags, + sizeof(struct scsi_inquiry_block_limits)); + scsi_free_scsi_task(task); + task = NULL; ++ ++ if (iscsilun->bl.max_unmap < 0xffffffff) { ++ bs->bl.max_discard = sector_lun2qemu(iscsilun->bl.max_unmap, ++ iscsilun); ++ } ++ bs->bl.discard_alignment = sector_lun2qemu(iscsilun->bl.opt_unmap_gran, ++ iscsilun); ++ ++ if (iscsilun->bl.max_ws_len < 0xffffffff) { ++ bs->bl.max_write_zeroes = sector_lun2qemu(iscsilun->bl.max_ws_len, ++ iscsilun); ++ } ++ bs->bl.write_zeroes_alignment = sector_lun2qemu(iscsilun->bl.opt_unmap_gran, ++ iscsilun); + } + + #if defined(LIBISCSI_FEATURE_NOP_COUNTER) +-- +1.7.11.7 + diff --git a/SOURCES/kvm-iscsi-simplify-iscsi_co_discard.patch.patch.patch b/SOURCES/kvm-iscsi-simplify-iscsi_co_discard.patch.patch.patch new file mode 100644 index 0000000..0f3ea5d --- /dev/null +++ b/SOURCES/kvm-iscsi-simplify-iscsi_co_discard.patch.patch.patch @@ -0,0 +1,137 @@ +From 2094ed57c6e6e765d7e28a0c92f05d2b3cb43fd4 Mon Sep 17 00:00:00 2001 +Message-Id: <2094ed57c6e6e765d7e28a0c92f05d2b3cb43fd4.1389014116.git.minovotn@redhat.com> +In-Reply-To: +References: +From: Paolo Bonzini +Date: Mon, 9 Dec 2013 14:09:05 +0100 +Subject: [PATCH 17/50] iscsi: simplify iscsi_co_discard + +RH-Author: Paolo Bonzini +Message-id: <1386598178-11845-20-git-send-email-pbonzini@redhat.com> +Patchwork-id: 56056 +O-Subject: [RHEL 7.0 qemu-kvm PATCH 19/52] iscsi: simplify iscsi_co_discard +Bugzilla: 1007815 +RH-Acked-by: Jeffrey Cody +RH-Acked-by: Fam Zheng +RH-Acked-by: Stefan Hajnoczi + +From: Peter Lieven + +now that bdrv_co_discard can handle limits we do not need +the request split logic here anymore. + +Reviewed-by: Eric Blake +Signed-off-by: Peter Lieven +Signed-off-by: Stefan Hajnoczi +(cherry picked from commit 01a6a238a30b0381846e3e68ba06e232567a7026) +--- + block/iscsi.c | 67 ++++++++++++++++++++++------------------------------------- + 1 file changed, 25 insertions(+), 42 deletions(-) + +Signed-off-by: Michal Novotny +--- + block/iscsi.c | 67 ++++++++++++++++++++++------------------------------------- + 1 file changed, 25 insertions(+), 42 deletions(-) + +diff --git a/block/iscsi.c b/block/iscsi.c +index e5f4670..567a63a 100644 +--- a/block/iscsi.c ++++ b/block/iscsi.c +@@ -87,7 +87,6 @@ typedef struct IscsiAIOCB { + #define NOP_INTERVAL 5000 + #define MAX_NOP_FAILURES 3 + #define ISCSI_CMD_RETRIES 5 +-#define ISCSI_MAX_UNMAP 131072 + + static void + iscsi_bh_cb(void *p) +@@ -914,8 +913,6 @@ coroutine_fn iscsi_co_discard(BlockDriverState *bs, int64_t sector_num, + IscsiLun *iscsilun = bs->opaque; + struct IscsiTask iTask; + struct unmap_list list; +- uint32_t nb_blocks; +- uint32_t max_unmap; + + if (!is_request_lun_aligned(sector_num, nb_sectors, iscsilun)) { + return -EINVAL; +@@ -927,52 +924,38 @@ coroutine_fn iscsi_co_discard(BlockDriverState *bs, int64_t sector_num, + } + + list.lba = sector_qemu2lun(sector_num, iscsilun); +- nb_blocks = sector_qemu2lun(nb_sectors, iscsilun); ++ list.num = sector_qemu2lun(nb_sectors, iscsilun); + +- max_unmap = iscsilun->bl.max_unmap; +- if (max_unmap == 0xffffffff) { +- max_unmap = ISCSI_MAX_UNMAP; +- } +- +- while (nb_blocks > 0) { +- iscsi_co_init_iscsitask(iscsilun, &iTask); +- list.num = nb_blocks; +- if (list.num > max_unmap) { +- list.num = max_unmap; +- } ++ iscsi_co_init_iscsitask(iscsilun, &iTask); + retry: +- if (iscsi_unmap_task(iscsilun->iscsi, iscsilun->lun, 0, 0, &list, 1, +- iscsi_co_generic_cb, &iTask) == NULL) { +- return -EIO; +- } +- +- while (!iTask.complete) { +- iscsi_set_events(iscsilun); +- qemu_coroutine_yield(); +- } ++ if (iscsi_unmap_task(iscsilun->iscsi, iscsilun->lun, 0, 0, &list, 1, ++ iscsi_co_generic_cb, &iTask) == NULL) { ++ return -EIO; ++ } + +- if (iTask.task != NULL) { +- scsi_free_scsi_task(iTask.task); +- iTask.task = NULL; +- } ++ while (!iTask.complete) { ++ iscsi_set_events(iscsilun); ++ qemu_coroutine_yield(); ++ } + +- if (iTask.do_retry) { +- goto retry; +- } ++ if (iTask.task != NULL) { ++ scsi_free_scsi_task(iTask.task); ++ iTask.task = NULL; ++ } + +- if (iTask.status == SCSI_STATUS_CHECK_CONDITION) { +- /* the target might fail with a check condition if it +- is not happy with the alignment of the UNMAP request +- we silently fail in this case */ +- return 0; +- } ++ if (iTask.do_retry) { ++ goto retry; ++ } + +- if (iTask.status != SCSI_STATUS_GOOD) { +- return -EIO; +- } ++ if (iTask.status == SCSI_STATUS_CHECK_CONDITION) { ++ /* the target might fail with a check condition if it ++ is not happy with the alignment of the UNMAP request ++ we silently fail in this case */ ++ return 0; ++ } + +- list.lba += list.num; +- nb_blocks -= list.num; ++ if (iTask.status != SCSI_STATUS_GOOD) { ++ return -EIO; + } + + return 0; +-- +1.7.11.7 + diff --git a/SOURCES/kvm-iscsi-split-discard-requests-in-multiple-parts.patch.patch.patch b/SOURCES/kvm-iscsi-split-discard-requests-in-multiple-parts.patch.patch.patch new file mode 100644 index 0000000..85e0cdb --- /dev/null +++ b/SOURCES/kvm-iscsi-split-discard-requests-in-multiple-parts.patch.patch.patch @@ -0,0 +1,234 @@ +From 2865e534fce4969a316a5ba764b65e540da08cee Mon Sep 17 00:00:00 2001 +Message-Id: <2865e534fce4969a316a5ba764b65e540da08cee.1389014116.git.minovotn@redhat.com> +In-Reply-To: +References: +From: Paolo Bonzini +Date: Mon, 9 Dec 2013 14:08:53 +0100 +Subject: [PATCH 05/50] iscsi: split discard requests in multiple parts + +RH-Author: Paolo Bonzini +Message-id: <1386598178-11845-8-git-send-email-pbonzini@redhat.com> +Patchwork-id: 56044 +O-Subject: [RHEL 7.0 qemu-kvm PATCH 07/52] iscsi: split discard requests in multiple parts +Bugzilla: 1007815 +RH-Acked-by: Jeffrey Cody +RH-Acked-by: Fam Zheng +RH-Acked-by: Stefan Hajnoczi + +From: Peter Lieven + +Replace .bdrv_aio_discard with .bdrv_co_discard so that discard +requests can be split in multiple parts, each for a small amount +of sectors. + +This is useful because we expose a generic API with no limit +on the amount of sectors that can be unmapped in one request. + +Signed-off-by: Peter Lieven +Signed-off-by: Paolo Bonzini +(cherry picked from commit 65f3e33964bc4bb634d61463814a4ccca794e3c0) +--- + block/iscsi.c | 156 +++++++++++++++++++++++++++------------------------------- + 1 file changed, 73 insertions(+), 83 deletions(-) + +Signed-off-by: Michal Novotny +--- + block/iscsi.c | 156 +++++++++++++++++++++++++++------------------------------- + 1 file changed, 73 insertions(+), 83 deletions(-) + +diff --git a/block/iscsi.c b/block/iscsi.c +index f8d021a..3a34eb7 100644 +--- a/block/iscsi.c ++++ b/block/iscsi.c +@@ -87,6 +87,7 @@ typedef struct IscsiAIOCB { + #define NOP_INTERVAL 5000 + #define MAX_NOP_FAILURES 3 + #define ISCSI_CMD_RETRIES 5 ++#define ISCSI_MAX_UNMAP 131072 + + static void + iscsi_bh_cb(void *p) +@@ -624,88 +625,6 @@ iscsi_aio_flush(BlockDriverState *bs, + return &acb->common; + } + +-static int iscsi_aio_discard_acb(IscsiAIOCB *acb); +- +-static void +-iscsi_unmap_cb(struct iscsi_context *iscsi, int status, +- void *command_data, void *opaque) +-{ +- IscsiAIOCB *acb = opaque; +- +- if (acb->canceled != 0) { +- return; +- } +- +- acb->status = 0; +- if (status != 0) { +- if (status == SCSI_STATUS_CHECK_CONDITION +- && acb->task->sense.key == SCSI_SENSE_UNIT_ATTENTION +- && acb->retries-- > 0) { +- scsi_free_scsi_task(acb->task); +- acb->task = NULL; +- if (iscsi_aio_discard_acb(acb) == 0) { +- iscsi_set_events(acb->iscsilun); +- return; +- } +- } +- error_report("Failed to unmap data on iSCSI lun. %s", +- iscsi_get_error(iscsi)); +- acb->status = -EIO; +- } +- +- iscsi_schedule_bh(acb); +-} +- +-static int iscsi_aio_discard_acb(IscsiAIOCB *acb) { +- struct iscsi_context *iscsi = acb->iscsilun->iscsi; +- struct unmap_list list[1]; +- +- acb->canceled = 0; +- acb->bh = NULL; +- acb->status = -EINPROGRESS; +- acb->buf = NULL; +- +- list[0].lba = sector_qemu2lun(acb->sector_num, acb->iscsilun); +- list[0].num = acb->nb_sectors * BDRV_SECTOR_SIZE / acb->iscsilun->block_size; +- +- acb->task = iscsi_unmap_task(iscsi, acb->iscsilun->lun, +- 0, 0, &list[0], 1, +- iscsi_unmap_cb, +- acb); +- if (acb->task == NULL) { +- error_report("iSCSI: Failed to send unmap command. %s", +- iscsi_get_error(iscsi)); +- return -1; +- } +- +- return 0; +-} +- +-static BlockDriverAIOCB * +-iscsi_aio_discard(BlockDriverState *bs, +- int64_t sector_num, int nb_sectors, +- BlockDriverCompletionFunc *cb, void *opaque) +-{ +- IscsiLun *iscsilun = bs->opaque; +- IscsiAIOCB *acb; +- +- acb = qemu_aio_get(&iscsi_aiocb_info, bs, cb, opaque); +- +- acb->iscsilun = iscsilun; +- acb->nb_sectors = nb_sectors; +- acb->sector_num = sector_num; +- acb->retries = ISCSI_CMD_RETRIES; +- +- if (iscsi_aio_discard_acb(acb) != 0) { +- qemu_aio_release(acb); +- return NULL; +- } +- +- iscsi_set_events(iscsilun); +- +- return &acb->common; +-} +- + #ifdef __linux__ + static void + iscsi_aio_ioctl_cb(struct iscsi_context *iscsi, int status, +@@ -988,6 +907,77 @@ out: + return ret; + } + ++static int ++coroutine_fn iscsi_co_discard(BlockDriverState *bs, int64_t sector_num, ++ int nb_sectors) ++{ ++ IscsiLun *iscsilun = bs->opaque; ++ struct IscsiTask iTask; ++ struct unmap_list list; ++ uint32_t nb_blocks; ++ uint32_t max_unmap; ++ ++ if (!is_request_lun_aligned(sector_num, nb_sectors, iscsilun)) { ++ return -EINVAL; ++ } ++ ++ if (!iscsilun->lbp.lbpu) { ++ /* UNMAP is not supported by the target */ ++ return 0; ++ } ++ ++ list.lba = sector_qemu2lun(sector_num, iscsilun); ++ nb_blocks = sector_qemu2lun(nb_sectors, iscsilun); ++ ++ max_unmap = iscsilun->bl.max_unmap; ++ if (max_unmap == 0xffffffff) { ++ max_unmap = ISCSI_MAX_UNMAP; ++ } ++ ++ while (nb_blocks > 0) { ++ iscsi_co_init_iscsitask(iscsilun, &iTask); ++ list.num = nb_blocks; ++ if (list.num > max_unmap) { ++ list.num = max_unmap; ++ } ++retry: ++ if (iscsi_unmap_task(iscsilun->iscsi, iscsilun->lun, 0, 0, &list, 1, ++ iscsi_co_generic_cb, &iTask) == NULL) { ++ return -EIO; ++ } ++ ++ while (!iTask.complete) { ++ iscsi_set_events(iscsilun); ++ qemu_coroutine_yield(); ++ } ++ ++ if (iTask.task != NULL) { ++ scsi_free_scsi_task(iTask.task); ++ iTask.task = NULL; ++ } ++ ++ if (iTask.do_retry) { ++ goto retry; ++ } ++ ++ if (iTask.status == SCSI_STATUS_CHECK_CONDITION) { ++ /* the target might fail with a check condition if it ++ is not happy with the alignment of the UNMAP request ++ we silently fail in this case */ ++ return 0; ++ } ++ ++ if (iTask.status != SCSI_STATUS_GOOD) { ++ return -EIO; ++ } ++ ++ list.lba += list.num; ++ nb_blocks -= list.num; ++ } ++ ++ return 0; ++} ++ + static int parse_chap(struct iscsi_context *iscsi, const char *target) + { + QemuOptsList *list; +@@ -1541,12 +1531,12 @@ static BlockDriver bdrv_iscsi = { + .bdrv_truncate = iscsi_truncate, + + .bdrv_co_get_block_status = iscsi_co_get_block_status, ++ .bdrv_co_discard = iscsi_co_discard, + + .bdrv_aio_readv = iscsi_aio_readv, + .bdrv_aio_writev = iscsi_aio_writev, + .bdrv_aio_flush = iscsi_aio_flush, + +- .bdrv_aio_discard = iscsi_aio_discard, + .bdrv_has_zero_init = iscsi_has_zero_init, + + #ifdef __linux__ +-- +1.7.11.7 + diff --git a/SOURCES/kvm-json-parser-fix-handling-of-large-whole-number-value.patch b/SOURCES/kvm-json-parser-fix-handling-of-large-whole-number-value.patch new file mode 100644 index 0000000..9e51b73 --- /dev/null +++ b/SOURCES/kvm-json-parser-fix-handling-of-large-whole-number-value.patch @@ -0,0 +1,82 @@ +From 2263af4c1921520ddc9177c13a176860c0069fab Mon Sep 17 00:00:00 2001 +Message-Id: <2263af4c1921520ddc9177c13a176860c0069fab.1387369730.git.minovotn@redhat.com> +In-Reply-To: <091eecc4fa42754760dfff393dabcc2b444e9693.1387369730.git.minovotn@redhat.com> +References: <091eecc4fa42754760dfff393dabcc2b444e9693.1387369730.git.minovotn@redhat.com> +From: Markus Armbruster +Date: Tue, 10 Dec 2013 15:29:04 +0100 +Subject: [PATCH 04/21] json-parser: fix handling of large whole number values + +RH-Author: Markus Armbruster +Message-id: <1386689361-30281-2-git-send-email-armbru@redhat.com> +Patchwork-id: 56120 +O-Subject: [PATCH 7.0 qemu-kvm 01/18] json-parser: fix handling of large whole number values +Bugzilla: 997915 +RH-Acked-by: Laszlo Ersek +RH-Acked-by: Kevin Wolf +RH-Acked-by: Luiz Capitulino + +From: Michael Roth + +Currently our JSON parser assumes that numbers lacking a fractional +value are integers and attempts to store them as QInt/int64 values. This +breaks in the case where the number overflows/underflows int64 values (which +is still valid JSON) + +Fix this by detecting such cases and using a QFloat to store the value +instead. + +Signed-off-by: Michael Roth +Reviewed-by: Laszlo Ersek +Reviewed-by: Amos Kong +Signed-off-by: Luiz Capitulino +(cherry picked from commit 3d5b3ec6d460a92245215aaf7b349b0b9e5ffa25) +Signed-off-by: Markus Armbruster +--- + qobject/json-parser.c | 26 +++++++++++++++++++++++--- + 1 file changed, 23 insertions(+), 3 deletions(-) + +Signed-off-by: Michal Novotny +--- + qobject/json-parser.c | 26 +++++++++++++++++++++++--- + 1 file changed, 23 insertions(+), 3 deletions(-) + +diff --git a/qobject/json-parser.c b/qobject/json-parser.c +index 05279c1..e7947b3 100644 +--- a/qobject/json-parser.c ++++ b/qobject/json-parser.c +@@ -640,9 +640,29 @@ static QObject *parse_literal(JSONParserContext *ctxt) + case JSON_STRING: + obj = QOBJECT(qstring_from_escaped_str(ctxt, token)); + break; +- case JSON_INTEGER: +- obj = QOBJECT(qint_from_int(strtoll(token_get_value(token), NULL, 10))); +- break; ++ case JSON_INTEGER: { ++ /* A possibility exists that this is a whole-valued float where the ++ * fractional part was left out due to being 0 (.0). It's not a big ++ * deal to treat these as ints in the parser, so long as users of the ++ * resulting QObject know to expect a QInt in place of a QFloat in ++ * cases like these. ++ * ++ * However, in some cases these values will overflow/underflow a ++ * QInt/int64 container, thus we should assume these are to be handled ++ * as QFloats/doubles rather than silently changing their values. ++ * ++ * strtoll() indicates these instances by setting errno to ERANGE ++ */ ++ int64_t value; ++ ++ errno = 0; /* strtoll doesn't set errno on success */ ++ value = strtoll(token_get_value(token), NULL, 10); ++ if (errno != ERANGE) { ++ obj = QOBJECT(qint_from_int(value)); ++ break; ++ } ++ /* fall through to JSON_FLOAT */ ++ } + case JSON_FLOAT: + /* FIXME dependent on locale */ + obj = QOBJECT(qfloat_from_double(strtod(token_get_value(token), NULL))); +-- +1.7.11.7 + diff --git a/SOURCES/kvm-libqtest-add-qmp-fmt-.-QDict-function.patch b/SOURCES/kvm-libqtest-add-qmp-fmt-.-QDict-function.patch new file mode 100644 index 0000000..f09bccf --- /dev/null +++ b/SOURCES/kvm-libqtest-add-qmp-fmt-.-QDict-function.patch @@ -0,0 +1,218 @@ +From 5f073207f144613806bc0b004a01ef66da9ad5e0 Mon Sep 17 00:00:00 2001 +Message-Id: <5f073207f144613806bc0b004a01ef66da9ad5e0.1387288155.git.minovotn@redhat.com> +In-Reply-To: <527da6c2ce2c09d0183aa8595fc95f136f61b6df.1387288155.git.minovotn@redhat.com> +References: <527da6c2ce2c09d0183aa8595fc95f136f61b6df.1387288155.git.minovotn@redhat.com> +From: Stefan Hajnoczi +Date: Thu, 12 Dec 2013 16:21:25 +0100 +Subject: [PATCH 5/8] libqtest: add qmp(fmt, ...) -> QDict* function +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +RH-Author: Stefan Hajnoczi +Message-id: <1386865288-1575-6-git-send-email-stefanha@redhat.com> +Patchwork-id: 56259 +O-Subject: [RHEL7 qemu-kvm PATCH 5/8] libqtest: add qmp(fmt, ...) -> QDict* function +Bugzilla: 1003773 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Jeffrey Cody +RH-Acked-by: Markus Armbruster + +Add a qtest qmp() function that returns the response object. This +allows test cases to verify the result or to check for error responses. +It also allows waiting for QMP events. + +Signed-off-by: Stefan Hajnoczi +Reviewed-by: Eric Blake +Reviewed-by: Andreas Färber +(cherry picked from commit 0c460dac03e7919079525d8e24ef2c4c607c219d) +Signed-off-by: Stefan Hajnoczi +--- + tests/libqtest.c | 66 ++++++++++++++++++++++++++++++++++++++++++++------------ + tests/libqtest.h | 37 +++++++++++++++++++++++++++++++ + 2 files changed, 89 insertions(+), 14 deletions(-) + +Signed-off-by: Michal Novotny +--- + tests/libqtest.c | 66 ++++++++++++++++++++++++++++++++++++++++++++------------ + tests/libqtest.h | 37 +++++++++++++++++++++++++++++++ + 2 files changed, 89 insertions(+), 14 deletions(-) + +diff --git a/tests/libqtest.c b/tests/libqtest.c +index dc4c983..83424c3 100644 +--- a/tests/libqtest.c ++++ b/tests/libqtest.c +@@ -30,6 +30,8 @@ + + #include "qemu/compiler.h" + #include "qemu/osdep.h" ++#include "qapi/qmp/json-streamer.h" ++#include "qapi/qmp/json-parser.h" + + #define MAX_IRQ 256 + +@@ -291,16 +293,38 @@ redo: + return words; + } + +-void qtest_qmpv_discard_response(QTestState *s, const char *fmt, va_list ap) ++typedef struct { ++ JSONMessageParser parser; ++ QDict *response; ++} QMPResponseParser; ++ ++static void qmp_response(JSONMessageParser *parser, QList *tokens) + { +- bool has_reply = false; +- int nesting = 0; ++ QMPResponseParser *qmp = container_of(parser, QMPResponseParser, parser); ++ QObject *obj; ++ ++ obj = json_parser_parse(tokens, NULL); ++ if (!obj) { ++ fprintf(stderr, "QMP JSON response parsing failed\n"); ++ exit(1); ++ } ++ ++ g_assert(qobject_type(obj) == QTYPE_QDICT); ++ g_assert(!qmp->response); ++ qmp->response = (QDict *)obj; ++} ++ ++QDict *qtest_qmpv(QTestState *s, const char *fmt, va_list ap) ++{ ++ QMPResponseParser qmp; + + /* Send QMP request */ + socket_sendf(s->qmp_fd, fmt, ap); + + /* Receive reply */ +- while (!has_reply || nesting > 0) { ++ qmp.response = NULL; ++ json_message_parser_init(&qmp.parser, qmp_response); ++ while (!qmp.response) { + ssize_t len; + char c; + +@@ -314,25 +338,39 @@ void qtest_qmpv_discard_response(QTestState *s, const char *fmt, va_list ap) + exit(1); + } + +- switch (c) { +- case '{': +- nesting++; +- has_reply = true; +- break; +- case '}': +- nesting--; +- break; +- } ++ json_message_parser_feed(&qmp.parser, &c, 1); + } ++ json_message_parser_destroy(&qmp.parser); ++ ++ return qmp.response; ++} ++ ++QDict *qtest_qmp(QTestState *s, const char *fmt, ...) ++{ ++ va_list ap; ++ QDict *response; ++ ++ va_start(ap, fmt); ++ response = qtest_qmpv(s, fmt, ap); ++ va_end(ap); ++ return response; ++} ++ ++void qtest_qmpv_discard_response(QTestState *s, const char *fmt, va_list ap) ++{ ++ QDict *response = qtest_qmpv(s, fmt, ap); ++ QDECREF(response); + } + + void qtest_qmp_discard_response(QTestState *s, const char *fmt, ...) + { + va_list ap; ++ QDict *response; + + va_start(ap, fmt); +- qtest_qmpv_discard_response(s, fmt, ap); ++ response = qtest_qmpv(s, fmt, ap); + va_end(ap); ++ QDECREF(response); + } + + const char *qtest_get_arch(void) +diff --git a/tests/libqtest.h b/tests/libqtest.h +index 3faa49b..0d914f6 100644 +--- a/tests/libqtest.h ++++ b/tests/libqtest.h +@@ -22,6 +22,7 @@ + #include + #include + #include ++#include "qapi/qmp/qdict.h" + + typedef struct QTestState QTestState; + +@@ -53,6 +54,15 @@ void qtest_quit(QTestState *s); + void qtest_qmp_discard_response(QTestState *s, const char *fmt, ...); + + /** ++ * qtest_qmp: ++ * @s: #QTestState instance to operate on. ++ * @fmt...: QMP message to send to qemu ++ * ++ * Sends a QMP message to QEMU and returns the response. ++ */ ++QDict *qtest_qmp(QTestState *s, const char *fmt, ...); ++ ++/** + * qtest_qmpv_discard_response: + * @s: #QTestState instance to operate on. + * @fmt: QMP message to send to QEMU +@@ -63,6 +73,16 @@ void qtest_qmp_discard_response(QTestState *s, const char *fmt, ...); + void qtest_qmpv_discard_response(QTestState *s, const char *fmt, va_list ap); + + /** ++ * qtest_qmpv: ++ * @s: #QTestState instance to operate on. ++ * @fmt: QMP message to send to QEMU ++ * @ap: QMP message arguments ++ * ++ * Sends a QMP message to QEMU and returns the response. ++ */ ++QDict *qtest_qmpv(QTestState *s, const char *fmt, va_list ap); ++ ++/** + * qtest_get_irq: + * @s: #QTestState instance to operate on. + * @num: Interrupt to observe. +@@ -331,6 +351,23 @@ static inline void qtest_end(void) + } + + /** ++ * qmp: ++ * @fmt...: QMP message to send to qemu ++ * ++ * Sends a QMP message to QEMU and returns the response. ++ */ ++static inline QDict *qmp(const char *fmt, ...) ++{ ++ va_list ap; ++ QDict *response; ++ ++ va_start(ap, fmt); ++ response = qtest_qmpv(global_qtest, fmt, ap); ++ va_end(ap); ++ return response; ++} ++ ++/** + * qmp_discard_response: + * @fmt...: QMP message to send to qemu + * +-- +1.7.11.7 + diff --git a/SOURCES/kvm-libqtest-rename-qmp-to-qmp_discard_response.patch b/SOURCES/kvm-libqtest-rename-qmp-to-qmp_discard_response.patch new file mode 100644 index 0000000..5cf6cb8 --- /dev/null +++ b/SOURCES/kvm-libqtest-rename-qmp-to-qmp_discard_response.patch @@ -0,0 +1,204 @@ +From ecbbc511c0c4239fed38527e05677f058e5dd5f9 Mon Sep 17 00:00:00 2001 +Message-Id: +In-Reply-To: <527da6c2ce2c09d0183aa8595fc95f136f61b6df.1387288155.git.minovotn@redhat.com> +References: <527da6c2ce2c09d0183aa8595fc95f136f61b6df.1387288155.git.minovotn@redhat.com> +From: Stefan Hajnoczi +Date: Thu, 12 Dec 2013 16:21:24 +0100 +Subject: [PATCH 4/8] libqtest: rename qmp() to qmp_discard_response() +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +RH-Author: Stefan Hajnoczi +Message-id: <1386865288-1575-5-git-send-email-stefanha@redhat.com> +Patchwork-id: 56258 +O-Subject: [RHEL7 qemu-kvm PATCH 4/8] libqtest: rename qmp() to qmp_discard_response() +Bugzilla: 1003773 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Jeffrey Cody +RH-Acked-by: Markus Armbruster + +Existing qmp() callers do not expect a response object. In order to +implement real QMP test cases it will be necessary to inspect the +response object. + +Rename qmp() to qmp_discard_response(). Later patches will introduce a +qmp() function that returns the response object and tests that use it. + +Signed-off-by: Stefan Hajnoczi +Reviewed-by: Eric Blake +Reviewed-by: Andreas Färber +(cherry picked from commit 0d1aa05e9eba2437fdcdfbaa846c850c986bf7c6) +Signed-off-by: Stefan Hajnoczi + +Conflicts: + tests/boot-order-test.c + tests/ide-test.c + +RHEL does not have tests/ide-test.c:test_flush() and the +boot-order-test.c is also slightly older. +--- + tests/boot-order-test.c | 4 ++-- + tests/fdc-test.c | 15 +++++++++------ + tests/libqtest.c | 10 +++++----- + tests/libqtest.h | 20 ++++++++++---------- + 4 files changed, 26 insertions(+), 23 deletions(-) + +Signed-off-by: Michal Novotny +--- + tests/boot-order-test.c | 4 ++-- + tests/fdc-test.c | 15 +++++++++------ + tests/libqtest.c | 10 +++++----- + tests/libqtest.h | 20 ++++++++++---------- + 4 files changed, 26 insertions(+), 23 deletions(-) + +diff --git a/tests/boot-order-test.c b/tests/boot-order-test.c +index 447be31..a35e9f7 100644 +--- a/tests/boot-order-test.c ++++ b/tests/boot-order-test.c +@@ -36,12 +36,12 @@ static void test_pc_with_args(const char *test_args, + + qtest_start(args); + test_pc_cmos(boot1, boot2); +- qmp("{ 'execute': 'system_reset' }"); ++ qmp_discard_response("{ 'execute': 'system_reset' }"); + /* + * system_reset only requests reset. We get a RESET event after + * the actual reset completes. Need to wait for that. + */ +- qmp(""); /* HACK: wait for event */ ++ qmp_discard_response(""); /* HACK: wait for event */ + test_pc_cmos(reboot1, reboot2); + qtest_quit(global_qtest); + g_free(args); +diff --git a/tests/fdc-test.c b/tests/fdc-test.c +index fd198dc..38b5b17 100644 +--- a/tests/fdc-test.c ++++ b/tests/fdc-test.c +@@ -290,10 +290,12 @@ static void test_media_insert(void) + + /* Insert media in drive. DSKCHK should not be reset until a step pulse + * is sent. */ +- qmp("{'execute':'change', 'arguments':{ 'device':'floppy0', " +- "'target': '%s' }}", test_image); +- qmp(""); /* ignore event (FIXME open -> open transition?!) */ +- qmp(""); /* ignore event */ ++ qmp_discard_response("{'execute':'change', 'arguments':{" ++ " 'device':'floppy0', 'target': '%s' }}", ++ test_image); ++ qmp_discard_response(""); /* ignore event ++ (FIXME open -> open transition?!) */ ++ qmp_discard_response(""); /* ignore event */ + + dir = inb(FLOPPY_BASE + reg_dir); + assert_bit_set(dir, DSKCHG); +@@ -322,8 +324,9 @@ static void test_media_change(void) + + /* Eject the floppy and check that DSKCHG is set. Reading it out doesn't + * reset the bit. */ +- qmp("{'execute':'eject', 'arguments':{ 'device':'floppy0' }}"); +- qmp(""); /* ignore event */ ++ qmp_discard_response("{'execute':'eject', 'arguments':{" ++ " 'device':'floppy0' }}"); ++ qmp_discard_response(""); /* ignore event */ + + dir = inb(FLOPPY_BASE + reg_dir); + assert_bit_set(dir, DSKCHG); +diff --git a/tests/libqtest.c b/tests/libqtest.c +index bb82069..dc4c983 100644 +--- a/tests/libqtest.c ++++ b/tests/libqtest.c +@@ -151,8 +151,8 @@ QTestState *qtest_init(const char *extra_args) + } + + /* Read the QMP greeting and then do the handshake */ +- qtest_qmp(s, ""); +- qtest_qmp(s, "{ 'execute': 'qmp_capabilities' }"); ++ qtest_qmp_discard_response(s, ""); ++ qtest_qmp_discard_response(s, "{ 'execute': 'qmp_capabilities' }"); + + if (getenv("QTEST_STOP")) { + kill(qtest_qemu_pid(s), SIGSTOP); +@@ -291,7 +291,7 @@ redo: + return words; + } + +-void qtest_qmpv(QTestState *s, const char *fmt, va_list ap) ++void qtest_qmpv_discard_response(QTestState *s, const char *fmt, va_list ap) + { + bool has_reply = false; + int nesting = 0; +@@ -326,12 +326,12 @@ void qtest_qmpv(QTestState *s, const char *fmt, va_list ap) + } + } + +-void qtest_qmp(QTestState *s, const char *fmt, ...) ++void qtest_qmp_discard_response(QTestState *s, const char *fmt, ...) + { + va_list ap; + + va_start(ap, fmt); +- qtest_qmpv(s, fmt, ap); ++ qtest_qmpv_discard_response(s, fmt, ap); + va_end(ap); + } + +diff --git a/tests/libqtest.h b/tests/libqtest.h +index 0f6aade..3faa49b 100644 +--- a/tests/libqtest.h ++++ b/tests/libqtest.h +@@ -44,23 +44,23 @@ QTestState *qtest_init(const char *extra_args); + void qtest_quit(QTestState *s); + + /** +- * qtest_qmp: ++ * qtest_qmp_discard_response: + * @s: #QTestState instance to operate on. + * @fmt...: QMP message to send to qemu + * +- * Sends a QMP message to QEMU ++ * Sends a QMP message to QEMU and consumes the response. + */ +-void qtest_qmp(QTestState *s, const char *fmt, ...); ++void qtest_qmp_discard_response(QTestState *s, const char *fmt, ...); + + /** +- * qtest_qmpv: ++ * qtest_qmpv_discard_response: + * @s: #QTestState instance to operate on. + * @fmt: QMP message to send to QEMU + * @ap: QMP message arguments + * +- * Sends a QMP message to QEMU. ++ * Sends a QMP message to QEMU and consumes the response. + */ +-void qtest_qmpv(QTestState *s, const char *fmt, va_list ap); ++void qtest_qmpv_discard_response(QTestState *s, const char *fmt, va_list ap); + + /** + * qtest_get_irq: +@@ -331,17 +331,17 @@ static inline void qtest_end(void) + } + + /** +- * qmp: ++ * qmp_discard_response: + * @fmt...: QMP message to send to qemu + * +- * Sends a QMP message to QEMU ++ * Sends a QMP message to QEMU and consumes the response. + */ +-static inline void qmp(const char *fmt, ...) ++static inline void qmp_discard_response(const char *fmt, ...) + { + va_list ap; + + va_start(ap, fmt); +- qtest_qmpv(global_qtest, fmt, ap); ++ qtest_qmpv_discard_response(global_qtest, fmt, ap); + va_end(ap); + } + +-- +1.7.11.7 + diff --git a/SOURCES/kvm-loader-allow-adding-ROMs-in-done-callbacks.patch b/SOURCES/kvm-loader-allow-adding-ROMs-in-done-callbacks.patch new file mode 100644 index 0000000..6a69689 --- /dev/null +++ b/SOURCES/kvm-loader-allow-adding-ROMs-in-done-callbacks.patch @@ -0,0 +1,87 @@ +From 26aeacdc397f54120d52ae10b543bb4050b940c7 Mon Sep 17 00:00:00 2001 +Message-Id: <26aeacdc397f54120d52ae10b543bb4050b940c7.1387298827.git.minovotn@redhat.com> +In-Reply-To: <3ed0fb61a3dc912ef036d7ef450bed192090709e.1387298827.git.minovotn@redhat.com> +References: <3ed0fb61a3dc912ef036d7ef450bed192090709e.1387298827.git.minovotn@redhat.com> +From: "Michael S. Tsirkin" +Date: Tue, 17 Dec 2013 15:18:39 +0100 +Subject: [PATCH 38/56] loader: allow adding ROMs in done callbacks + +RH-Author: Michael S. Tsirkin +Message-id: <1387293161-4085-39-git-send-email-mst@redhat.com> +Patchwork-id: 56344 +O-Subject: [PATCH qemu-kvm RHEL7.0 v2 38/57] loader: allow adding ROMs in done callbacks +Bugzilla: 1034876 +RH-Acked-by: Igor Mammedov +RH-Acked-by: Marcel Apfelbaum +RH-Acked-by: Laszlo Ersek + +Don't abort if machine done callbacks add ROMs. + +Reviewed-by: Gerd Hoffmann +Tested-by: Gerd Hoffmann +Reviewed-by: Igor Mammedov +Tested-by: Igor Mammedov +Signed-off-by: Michael S. Tsirkin +(cherry picked from commit d916b46494a2a477636a59900ab1609de192f47a) +--- + include/hw/loader.h | 1 + + hw/core/loader.c | 6 +++++- + vl.c | 3 +++ + 3 files changed, 9 insertions(+), 1 deletion(-) + +Signed-off-by: Michal Novotny +--- + hw/core/loader.c | 6 +++++- + include/hw/loader.h | 1 + + vl.c | 3 +++ + 3 files changed, 9 insertions(+), 1 deletion(-) + +diff --git a/hw/core/loader.c b/hw/core/loader.c +index ab4c7bd..4e72e01 100644 +--- a/hw/core/loader.c ++++ b/hw/core/loader.c +@@ -777,10 +777,14 @@ int rom_load_all(void) + rom->isrom = section.size && memory_region_is_rom(section.mr); + } + qemu_register_reset(rom_reset, NULL); +- roms_loaded = 1; + return 0; + } + ++void rom_load_done(void) ++{ ++ roms_loaded = 1; ++} ++ + void rom_set_fw(FWCfgState *f) + { + fw_cfg = f; +diff --git a/include/hw/loader.h b/include/hw/loader.h +index 1381a1d..50a017b 100644 +--- a/include/hw/loader.h ++++ b/include/hw/loader.h +@@ -33,6 +33,7 @@ void *rom_add_blob(const char *name, const void *blob, size_t len, + int rom_add_elf_program(const char *name, void *data, size_t datasize, + size_t romsize, hwaddr addr); + int rom_load_all(void); ++void rom_load_done(void); + void rom_set_fw(FWCfgState *f); + int rom_copy(uint8_t *dest, hwaddr addr, size_t size); + void *rom_ptr(hwaddr addr); +diff --git a/vl.c b/vl.c +index 9b1738b..0cbbdf0 100644 +--- a/vl.c ++++ b/vl.c +@@ -4318,6 +4318,9 @@ int main(int argc, char **argv, char **envp) + qemu_register_reset(qbus_reset_all_fn, sysbus_get_default()); + qemu_run_machine_init_done_notifiers(); + ++ /* Done notifiers can load ROMs */ ++ rom_load_done(); ++ + qemu_system_reset(VMRESET_SILENT); + if (loadvm) { + if (load_vmstate(loadvm) < 0) { +-- +1.7.11.7 + diff --git a/SOURCES/kvm-loader-rename-in_ram-has_mr.patch b/SOURCES/kvm-loader-rename-in_ram-has_mr.patch new file mode 100644 index 0000000..fcf0560 --- /dev/null +++ b/SOURCES/kvm-loader-rename-in_ram-has_mr.patch @@ -0,0 +1,97 @@ +From 478b5f940bb1898c2bdc8dce560f82da3b55e78f Mon Sep 17 00:00:00 2001 +From: Michael S. Tsirkin +Date: Wed, 12 Mar 2014 07:00:11 +0100 +Subject: [PATCH 09/16] loader: rename in_ram/has_mr + +Message-id: <1394390868-24135-1-git-send-email-mst@redhat.com> +Patchwork-id: 58053 +O-Subject: [PATCH qemu-kvm RHEL7.0 v3 1/2] loader: rename in_ram/has_mr +Bugzilla: 1064018 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Marcel Apfelbaum +RH-Acked-by: Gerd Hoffmann + +we put copy of ROMs in MR for migration. +but the name rom_in_ram makes one think we +load it in guest RAM. +Rename has_mr to make intent clearer. + +Signed-off-by: Michael S. Tsirkin + +Upstream: posted +Brew build: http://brewweb.devel.redhat.com/brew/taskinfo?taskID=7173355 +Bugzilla: https://bugzilla.redhat.com/show_bug.cgi?id=1064018#c6 +Tested: by developer +--- + include/hw/loader.h | 2 +- + hw/core/loader.c | 6 +++--- + hw/i386/pc_piix.c | 2 +- + 3 files changed, 5 insertions(+), 5 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + hw/core/loader.c | 6 +++--- + hw/i386/pc_piix.c | 2 +- + include/hw/loader.h | 2 +- + 3 files changed, 5 insertions(+), 5 deletions(-) + +diff --git a/hw/core/loader.c b/hw/core/loader.c +index 4e72e01..c363aef 100644 +--- a/hw/core/loader.c ++++ b/hw/core/loader.c +@@ -54,7 +54,7 @@ + + #include + +-bool rom_file_in_ram = true; ++bool rom_file_has_mr = true; + + static int roms_loaded; + +@@ -642,7 +642,7 @@ int rom_add_file(const char *file, const char *fw_dir, + basename); + snprintf(devpath, sizeof(devpath), "/rom@%s", fw_file_name); + +- if (rom_file_in_ram) { ++ if (rom_file_has_mr) { + data = rom_set_mr(rom, devpath); + } else { + data = rom->data; +@@ -686,7 +686,7 @@ void *rom_add_blob(const char *name, const void *blob, size_t len, + + snprintf(devpath, sizeof(devpath), "/rom@%s", fw_file_name); + +- if (rom_file_in_ram) { ++ if (rom_file_has_mr) { + data = rom_set_mr(rom, devpath); + } else { + data = rom->data; +diff --git a/hw/i386/pc_piix.c b/hw/i386/pc_piix.c +index 6773fff..be68098 100644 +--- a/hw/i386/pc_piix.c ++++ b/hw/i386/pc_piix.c +@@ -948,7 +948,7 @@ static void pc_compat_rhel650(QEMUMachineInitArgs *args) + + disable_kvm_pv_unhalt(); + +- rom_file_in_ram = false; ++ rom_file_has_mr = false; + has_acpi_build = false; + gigabyte_align = false; + } +diff --git a/include/hw/loader.h b/include/hw/loader.h +index 50a017b..7ceccce 100644 +--- a/include/hw/loader.h ++++ b/include/hw/loader.h +@@ -23,7 +23,7 @@ void pstrcpy_targphys(const char *name, + hwaddr dest, int buf_size, + const char *source); + +-extern bool rom_file_in_ram; ++extern bool rom_file_has_mr; + + int rom_add_file(const char *file, const char *fw_dir, + hwaddr addr, int32_t bootindex); +-- +1.7.1 + diff --git a/SOURCES/kvm-loader-store-FW-CFG-ROM-files-in-RAM.patch b/SOURCES/kvm-loader-store-FW-CFG-ROM-files-in-RAM.patch new file mode 100644 index 0000000..7f0a548 --- /dev/null +++ b/SOURCES/kvm-loader-store-FW-CFG-ROM-files-in-RAM.patch @@ -0,0 +1,221 @@ +From 4fb30d2478b2d030262bcd1699a683973e481cfd Mon Sep 17 00:00:00 2001 +Message-Id: <4fb30d2478b2d030262bcd1699a683973e481cfd.1387298827.git.minovotn@redhat.com> +In-Reply-To: <3ed0fb61a3dc912ef036d7ef450bed192090709e.1387298827.git.minovotn@redhat.com> +References: <3ed0fb61a3dc912ef036d7ef450bed192090709e.1387298827.git.minovotn@redhat.com> +From: "Michael S. Tsirkin" +Date: Tue, 17 Dec 2013 15:17:19 +0100 +Subject: [PATCH 12/56] loader: store FW CFG ROM files in RAM + +RH-Author: Michael S. Tsirkin +Message-id: <1387293161-4085-13-git-send-email-mst@redhat.com> +Patchwork-id: 56317 +O-Subject: [PATCH qemu-kvm RHEL7.0 v2 12/57] loader: store FW CFG ROM files in RAM +Bugzilla: 1034876 +RH-Acked-by: Igor Mammedov +RH-Acked-by: Marcel Apfelbaum +RH-Acked-by: Laszlo Ersek + +ROM files that are put in FW CFG are copied to guest ram, by BIOS, but +they are not backed by RAM so they don't get migrated. + +Each time we change two bytes in such a ROM this breaks cross-version +migration: since we can migrate after BIOS has read the first byte but +before it has read the second one, getting an inconsistent state. + +Future-proof this by creating, for each such ROM, +an MR serving as the backing store. +This MR is never mapped into guest memory, but it's registered +as RAM so it's migrated with the guest. + +Naturally, this only helps for -M 1.7 and up, older machine types +will still have the cross-version migration bug. +Luckily the race window for the problem to trigger is very small, +which is also likely why we didn't notice the cross-version +migration bug in testing yet. + +Signed-off-by: Michael S. Tsirkin +Reviewed-by: Laszlo Ersek +(cherry picked from commit 04920fc0faa4760f9c4fc0e73b992b768099be70) + +Conflicts: + hw/i386/pc_piix.c + hw/i386/pc_q35.c +--- + include/hw/loader.h | 1 + + hw/core/loader.c | 49 ++++++++++++++++++++++++++++++++++++++++++++++--- + hw/i386/pc_piix.c | 2 ++ + hw/i386/pc_q35.c | 1 + + 4 files changed, 50 insertions(+), 3 deletions(-) + +Signed-off-by: Michal Novotny +--- + hw/core/loader.c | 49 ++++++++++++++++++++++++++++++++++++++++++++++--- + hw/i386/pc_piix.c | 2 ++ + hw/i386/pc_q35.c | 1 + + include/hw/loader.h | 1 + + 4 files changed, 50 insertions(+), 3 deletions(-) + +diff --git a/hw/core/loader.c b/hw/core/loader.c +index 7d61537..6bdbd15 100644 +--- a/hw/core/loader.c ++++ b/hw/core/loader.c +@@ -54,6 +54,8 @@ + + #include + ++bool rom_file_in_ram = true; ++ + static int roms_loaded; + + /* return the size or -1 if error */ +@@ -542,6 +544,7 @@ struct Rom { + size_t datasize; + + uint8_t *data; ++ MemoryRegion *mr; + int isrom; + char *fw_dir; + char *fw_file; +@@ -571,6 +574,21 @@ static void rom_insert(Rom *rom) + QTAILQ_INSERT_TAIL(&roms, rom, next); + } + ++static void *rom_set_mr(Rom *rom, const char *name) ++{ ++ void *data; ++ ++ rom->mr = g_malloc(sizeof(*rom->mr)); ++ memory_region_init_ram(rom->mr, name, rom->datasize); ++ memory_region_set_readonly(rom->mr, true); ++ vmstate_register_ram_global(rom->mr); ++ ++ data = memory_region_get_ram_ptr(rom->mr); ++ memcpy(data, rom->data, rom->datasize); ++ ++ return data; ++} ++ + int rom_add_file(const char *file, const char *fw_dir, + hwaddr addr, int32_t bootindex) + { +@@ -612,6 +630,7 @@ int rom_add_file(const char *file, const char *fw_dir, + if (rom->fw_file && fw_cfg) { + const char *basename; + char fw_file_name[56]; ++ void *data; + + basename = strrchr(rom->fw_file, '/'); + if (basename) { +@@ -621,8 +640,15 @@ int rom_add_file(const char *file, const char *fw_dir, + } + snprintf(fw_file_name, sizeof(fw_file_name), "%s/%s", rom->fw_dir, + basename); +- fw_cfg_add_file(fw_cfg, fw_file_name, rom->data, rom->romsize); + snprintf(devpath, sizeof(devpath), "/rom@%s", fw_file_name); ++ ++ if (rom_file_in_ram) { ++ data = rom_set_mr(rom, devpath); ++ } else { ++ data = rom->data; ++ } ++ ++ fw_cfg_add_file(fw_cfg, fw_file_name, data, rom->romsize); + } else { + snprintf(devpath, sizeof(devpath), "/rom@" TARGET_FMT_plx, addr); + } +@@ -697,7 +723,12 @@ static void rom_reset(void *unused) + if (rom->data == NULL) { + continue; + } +- cpu_physical_memory_write_rom(rom->addr, rom->data, rom->datasize); ++ if (rom->mr) { ++ void *host = memory_region_get_ram_ptr(rom->mr); ++ memcpy(host, rom->data, rom->datasize); ++ } else { ++ cpu_physical_memory_write_rom(rom->addr, rom->data, rom->datasize); ++ } + if (rom->isrom) { + /* rom needs to be written only once */ + g_free(rom->data); +@@ -746,6 +777,9 @@ static Rom *find_rom(hwaddr addr) + if (rom->fw_file) { + continue; + } ++ if (rom->mr) { ++ continue; ++ } + if (rom->addr > addr) { + continue; + } +@@ -773,6 +807,9 @@ int rom_copy(uint8_t *dest, hwaddr addr, size_t size) + if (rom->fw_file) { + continue; + } ++ if (rom->mr) { ++ continue; ++ } + if (rom->addr + rom->romsize < addr) { + continue; + } +@@ -831,7 +868,13 @@ void do_info_roms(Monitor *mon, const QDict *qdict) + Rom *rom; + + QTAILQ_FOREACH(rom, &roms, next) { +- if (!rom->fw_file) { ++ if (rom->mr) { ++ monitor_printf(mon, "%s" ++ " size=0x%06zx name=\"%s\"\n", ++ rom->mr->name, ++ rom->romsize, ++ rom->name); ++ } else if (!rom->fw_file) { + monitor_printf(mon, "addr=" TARGET_FMT_plx + " size=0x%06zx mem=%s name=\"%s\"\n", + rom->addr, rom->romsize, +diff --git a/hw/i386/pc_piix.c b/hw/i386/pc_piix.c +index b6f9288..07848c1 100644 +--- a/hw/i386/pc_piix.c ++++ b/hw/i386/pc_piix.c +@@ -25,6 +25,7 @@ + #include + + #include "hw/hw.h" ++#include "hw/loader.h" + #include "hw/i386/pc.h" + #include "hw/i386/apic.h" + #include "hw/i386/smbios.h" +@@ -883,6 +884,7 @@ static void pc_init_rhel650(QEMUMachineInitArgs *args) + x86_cpu_compat_set_features("Opteron_G3", FEAT_8000_0001_EDX, + 0, CPUID_EXT2_RDTSCP); + ++ rom_file_in_ram = false; + pc_init_rhel700(args); + } + +diff --git a/hw/i386/pc_q35.c b/hw/i386/pc_q35.c +index f308098..8fa6793 100644 +--- a/hw/i386/pc_q35.c ++++ b/hw/i386/pc_q35.c +@@ -28,6 +28,7 @@ + * THE SOFTWARE. + */ + #include "hw/hw.h" ++#include "hw/loader.h" + #include "sysemu/arch_init.h" + #include "hw/i2c/smbus.h" + #include "hw/boards.h" +diff --git a/include/hw/loader.h b/include/hw/loader.h +index 15d4cc9..19e11ea 100644 +--- a/include/hw/loader.h ++++ b/include/hw/loader.h +@@ -23,6 +23,7 @@ void pstrcpy_targphys(const char *name, + hwaddr dest, int buf_size, + const char *source); + ++extern bool rom_file_in_ram; + + int rom_add_file(const char *file, const char *fw_dir, + hwaddr addr, int32_t bootindex); +-- +1.7.11.7 + diff --git a/SOURCES/kvm-loader-support-for-unmapped-ROM-blobs.patch b/SOURCES/kvm-loader-support-for-unmapped-ROM-blobs.patch new file mode 100644 index 0000000..497fb21 --- /dev/null +++ b/SOURCES/kvm-loader-support-for-unmapped-ROM-blobs.patch @@ -0,0 +1,128 @@ +From 829a4521369f93923f4787cc1e45f1a0d432d71b Mon Sep 17 00:00:00 2001 +Message-Id: <829a4521369f93923f4787cc1e45f1a0d432d71b.1387298827.git.minovotn@redhat.com> +In-Reply-To: <3ed0fb61a3dc912ef036d7ef450bed192090709e.1387298827.git.minovotn@redhat.com> +References: <3ed0fb61a3dc912ef036d7ef450bed192090709e.1387298827.git.minovotn@redhat.com> +From: "Michael S. Tsirkin" +Date: Tue, 17 Dec 2013 15:17:59 +0100 +Subject: [PATCH 27/56] loader: support for unmapped ROM blobs + +RH-Author: Michael S. Tsirkin +Message-id: <1387293161-4085-28-git-send-email-mst@redhat.com> +Patchwork-id: 56333 +O-Subject: [PATCH qemu-kvm RHEL7.0 v2 27/57] loader: support for unmapped ROM blobs +Bugzilla: 1034876 +RH-Acked-by: Igor Mammedov +RH-Acked-by: Marcel Apfelbaum +RH-Acked-by: Laszlo Ersek + +Support ROM blobs not mapped into guest memory: +same as ROM files really but use caller's buffer. + +Support invoking callback on access and +return memory pointer making it easier +for caller to update memory if necessary. + +Reviewed-by: Gerd Hoffmann +Tested-by: Gerd Hoffmann +Reviewed-by: Laszlo Ersek +Reviewed-by: Igor Mammedov +Tested-by: Igor Mammedov +Signed-off-by: Michael S. Tsirkin +(cherry picked from commit 48354cc5a3744c9a56462e5053e1f267a0ce69de) +--- + hw/lm32/lm32_hwsetup.h | 2 +- + include/hw/loader.h | 7 ++++--- + hw/core/loader.c | 23 ++++++++++++++++++++--- + 3 files changed, 25 insertions(+), 7 deletions(-) + +Signed-off-by: Michal Novotny +--- + hw/core/loader.c | 23 ++++++++++++++++++++--- + hw/lm32/lm32_hwsetup.h | 2 +- + include/hw/loader.h | 7 ++++--- + 3 files changed, 25 insertions(+), 7 deletions(-) + +diff --git a/hw/core/loader.c b/hw/core/loader.c +index 6bdbd15..2bfff48 100644 +--- a/hw/core/loader.c ++++ b/hw/core/loader.c +@@ -666,10 +666,12 @@ err: + return -1; + } + +-int rom_add_blob(const char *name, const void *blob, size_t len, +- hwaddr addr) ++void *rom_add_blob(const char *name, const void *blob, size_t len, ++ hwaddr addr, const char *fw_file_name, ++ FWCfgReadCallback fw_callback, void *callback_opaque) + { + Rom *rom; ++ void *data = NULL; + + rom = g_malloc0(sizeof(*rom)); + rom->name = g_strdup(name); +@@ -679,7 +681,22 @@ int rom_add_blob(const char *name, const void *blob, size_t len, + rom->data = g_malloc0(rom->datasize); + memcpy(rom->data, blob, len); + rom_insert(rom); +- return 0; ++ if (fw_file_name && fw_cfg) { ++ char devpath[100]; ++ ++ snprintf(devpath, sizeof(devpath), "/rom@%s", fw_file_name); ++ ++ if (rom_file_in_ram) { ++ data = rom_set_mr(rom, devpath); ++ } else { ++ data = rom->data; ++ } ++ ++ fw_cfg_add_file_callback(fw_cfg, fw_file_name, ++ fw_callback, callback_opaque, ++ data, rom->romsize); ++ } ++ return data; + } + + /* This function is specific for elf program because we don't need to allocate +diff --git a/hw/lm32/lm32_hwsetup.h b/hw/lm32/lm32_hwsetup.h +index 3449bd8..9fd5e69 100644 +--- a/hw/lm32/lm32_hwsetup.h ++++ b/hw/lm32/lm32_hwsetup.h +@@ -73,7 +73,7 @@ static inline void hwsetup_free(HWSetup *hw) + static inline void hwsetup_create_rom(HWSetup *hw, + hwaddr base) + { +- rom_add_blob("hwsetup", hw->data, TARGET_PAGE_SIZE, base); ++ rom_add_blob("hwsetup", hw->data, TARGET_PAGE_SIZE, base, NULL, NULL, NULL); + } + + static inline void hwsetup_add_u8(HWSetup *hw, uint8_t u) +diff --git a/include/hw/loader.h b/include/hw/loader.h +index 19e11ea..1381a1d 100644 +--- a/include/hw/loader.h ++++ b/include/hw/loader.h +@@ -27,8 +27,9 @@ extern bool rom_file_in_ram; + + int rom_add_file(const char *file, const char *fw_dir, + hwaddr addr, int32_t bootindex); +-int rom_add_blob(const char *name, const void *blob, size_t len, +- hwaddr addr); ++void *rom_add_blob(const char *name, const void *blob, size_t len, ++ hwaddr addr, const char *fw_file_name, ++ FWCfgReadCallback fw_callback, void *callback_opaque); + int rom_add_elf_program(const char *name, void *data, size_t datasize, + size_t romsize, hwaddr addr); + int rom_load_all(void); +@@ -40,7 +41,7 @@ void do_info_roms(Monitor *mon, const QDict *qdict); + #define rom_add_file_fixed(_f, _a, _i) \ + rom_add_file(_f, NULL, _a, _i) + #define rom_add_blob_fixed(_f, _b, _l, _a) \ +- rom_add_blob(_f, _b, _l, _a) ++ (rom_add_blob(_f, _b, _l, _a, NULL, NULL, NULL) ? 0 : -1) + + #define PC_ROM_MIN_VGA 0xc0000 + #define PC_ROM_MIN_OPTION 0xc8000 +-- +1.7.11.7 + diff --git a/SOURCES/kvm-loader-use-file-path-size-from-fw_cfg.h.patch b/SOURCES/kvm-loader-use-file-path-size-from-fw_cfg.h.patch new file mode 100644 index 0000000..bbd5973 --- /dev/null +++ b/SOURCES/kvm-loader-use-file-path-size-from-fw_cfg.h.patch @@ -0,0 +1,74 @@ +From 3090a6d3f085dea8f7f6539bf12709cd79d57cb4 Mon Sep 17 00:00:00 2001 +Message-Id: <3090a6d3f085dea8f7f6539bf12709cd79d57cb4.1387298827.git.minovotn@redhat.com> +In-Reply-To: <3ed0fb61a3dc912ef036d7ef450bed192090709e.1387298827.git.minovotn@redhat.com> +References: <3ed0fb61a3dc912ef036d7ef450bed192090709e.1387298827.git.minovotn@redhat.com> +From: "Michael S. Tsirkin" +Date: Tue, 17 Dec 2013 15:18:28 +0100 +Subject: [PATCH 36/56] loader: use file path size from fw_cfg.h + +RH-Author: Michael S. Tsirkin +Message-id: <1387293161-4085-37-git-send-email-mst@redhat.com> +Patchwork-id: 56342 +O-Subject: [PATCH qemu-kvm RHEL7.0 v2 36/57] loader: use file path size from fw_cfg.h +Bugzilla: 1034876 +RH-Acked-by: Igor Mammedov +RH-Acked-by: Marcel Apfelbaum +RH-Acked-by: Laszlo Ersek + +Avoid a bit of code duplication, make +max file path constant reusable. + +Suggested-by: Laszlo Ersek +Reviewed-by: Gerd Hoffmann +Tested-by: Gerd Hoffmann +Reviewed-by: Igor Mammedov +Tested-by: Igor Mammedov +Signed-off-by: Michael S. Tsirkin +(cherry picked from commit 35c12e60c840bc4840cbbe3f6ca514a53b2e36bc) +--- + include/hw/nvram/fw_cfg.h | 4 +++- + hw/core/loader.c | 2 +- + 2 files changed, 4 insertions(+), 2 deletions(-) + +Signed-off-by: Michal Novotny +--- + hw/core/loader.c | 2 +- + include/hw/nvram/fw_cfg.h | 4 +++- + 2 files changed, 4 insertions(+), 2 deletions(-) + +diff --git a/hw/core/loader.c b/hw/core/loader.c +index 2bfff48..ab4c7bd 100644 +--- a/hw/core/loader.c ++++ b/hw/core/loader.c +@@ -629,7 +629,7 @@ int rom_add_file(const char *file, const char *fw_dir, + rom_insert(rom); + if (rom->fw_file && fw_cfg) { + const char *basename; +- char fw_file_name[56]; ++ char fw_file_name[FW_CFG_MAX_FILE_PATH]; + void *data; + + basename = strrchr(rom->fw_file, '/'); +diff --git a/include/hw/nvram/fw_cfg.h b/include/hw/nvram/fw_cfg.h +index 2ab0fc2..72b1549 100644 +--- a/include/hw/nvram/fw_cfg.h ++++ b/include/hw/nvram/fw_cfg.h +@@ -46,12 +46,14 @@ + + #define FW_CFG_INVALID 0xffff + ++#define FW_CFG_MAX_FILE_PATH 56 ++ + #ifndef NO_QEMU_PROTOS + typedef struct FWCfgFile { + uint32_t size; /* file size */ + uint16_t select; /* write this to 0x510 to read it */ + uint16_t reserved; +- char name[56]; ++ char name[FW_CFG_MAX_FILE_PATH]; + } FWCfgFile; + + typedef struct FWCfgFiles { +-- +1.7.11.7 + diff --git a/SOURCES/kvm-lock-Fix-memory-leaks-in-bdrv_co_do_pwritev.patch b/SOURCES/kvm-lock-Fix-memory-leaks-in-bdrv_co_do_pwritev.patch new file mode 100644 index 0000000..b1dab86 --- /dev/null +++ b/SOURCES/kvm-lock-Fix-memory-leaks-in-bdrv_co_do_pwritev.patch @@ -0,0 +1,48 @@ +From 8dddbd7dc9948e743695166bab2b7ca94012badf Mon Sep 17 00:00:00 2001 +From: Kevin Wolf +Date: Fri, 7 Feb 2014 15:29:00 +0100 +Subject: [PATCH 25/37] lock: Fix memory leaks in bdrv_co_do_pwritev() + +Message-id: <1392117622-28812-26-git-send-email-kwolf@redhat.com> +Patchwork-id: 57190 +O-Subject: [RHEL-7.0 qemu-kvm PATCH v2 25/37] block: Fix memory leaks in bdrv_co_do_pwritev() +Bugzilla: 748906 +RH-Acked-by: Laszlo Ersek +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Max Reitz + +The error path for a failure in one of the two bdrv_aligned_preadv() +calls leaked head_buf or tail_buf, respectively. This fixes the memory +leak. + +Reported-by: Laszlo Ersek +Signed-off-by: Kevin Wolf +Reviewed-by: Eric Blake +Reviewed-by: Laszlo Ersek +Signed-off-by: Kevin Wolf +--- + block.c | 4 ++-- + 1 file changed, 2 insertions(+), 2 deletions(-) +--- + block.c | 4 ++-- + 1 files changed, 2 insertions(+), 2 deletions(-) + +diff --git a/block.c b/block.c +index 3ec3949..9eeb072 100644 +--- a/block.c ++++ b/block.c +@@ -3180,9 +3180,9 @@ fail: + + if (use_local_qiov) { + qemu_iovec_destroy(&local_qiov); +- qemu_vfree(head_buf); +- qemu_vfree(tail_buf); + } ++ qemu_vfree(head_buf); ++ qemu_vfree(tail_buf); + + return ret; + } +-- +1.7.1 + diff --git a/SOURCES/kvm-make-availability-of-Hyper-V-enlightenments-depe.patch b/SOURCES/kvm-make-availability-of-Hyper-V-enlightenments-depe.patch new file mode 100644 index 0000000..33cd780 --- /dev/null +++ b/SOURCES/kvm-make-availability-of-Hyper-V-enlightenments-depe.patch @@ -0,0 +1,101 @@ +From 4e424b837ade87f4d44cbd51e8994e4ac8f36515 Mon Sep 17 00:00:00 2001 +From: Vadim Rozenfeld +Date: Mon, 3 Mar 2014 12:09:16 +0100 +Subject: [PATCH 04/12] kvm: make availability of Hyper-V enlightenments dependent on KVM_CAP_HYPERV + +RH-Author: Vadim Rozenfeld +Message-id: <1393848564-10511-5-git-send-email-vrozenfe@redhat.com> +Patchwork-id: 57960 +O-Subject: [RHEL-7.0 qemu-kvm v4 PATCH 04/12] kvm: make availability of Hyper-V enlightenments dependent on KVM_CAP_HYPERV +Bugzilla: 1004773 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Igor Mammedov +RH-Acked-by: Juan Quintela +RH-Acked-by: Eduardo Habkost + +From: Paolo Bonzini + +The MS docs specify HV_X64_MSR_HYPERCALL as a mandatory interface, +thus we must provide the MSRs even if the user only specified +features that, like relaxed timing, in principle don't require them. +And the MSRs are only there if the hypervisor has KVM_CAP_HYPERV. + +Signed-off-by: Paolo Bonzini +(cherry picked from commit 7bc3d711b45d6feacab96eda410c5655f4ddafcf) +--- + target-i386/kvm.c | 16 +++++++++++----- + 1 file changed, 11 insertions(+), 5 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + target-i386/kvm.c | 16 +++++++++++----- + 1 files changed, 11 insertions(+), 5 deletions(-) + +diff --git a/target-i386/kvm.c b/target-i386/kvm.c +index 3688371..495021b 100644 +--- a/target-i386/kvm.c ++++ b/target-i386/kvm.c +@@ -70,6 +70,8 @@ static bool has_msr_pv_eoi_en; + static bool has_msr_misc_enable; + static bool has_msr_kvm_steal_time; + static int lm_capable_kernel; ++static bool has_msr_hv_hypercall; ++static bool has_msr_hv_vapic; + + static bool has_msr_architectural_pmu; + static uint32_t num_architectural_pmu_counters; +@@ -433,8 +435,10 @@ static bool hyperv_hypercall_available(X86CPU *cpu) + + static bool hyperv_enabled(X86CPU *cpu) + { +- return hyperv_hypercall_available(cpu) || +- cpu->hyperv_relaxed_timing; ++ CPUState *cs = CPU(cpu); ++ return kvm_check_extension(cs->kvm_state, KVM_CAP_HYPERV) > 0 && ++ (hyperv_hypercall_available(cpu) || ++ cpu->hyperv_relaxed_timing); + } + + #define KVM_MAX_CPUID_ENTRIES 100 +@@ -489,6 +493,7 @@ int kvm_arch_init_vcpu(CPUState *cs) + if (cpu->hyperv_vapic) { + c->eax |= HV_X64_MSR_HYPERCALL_AVAILABLE; + c->eax |= HV_X64_MSR_APIC_ACCESS_AVAILABLE; ++ has_msr_hv_vapic = true; + } + + c = &cpuid_data.entries[cpuid_i++]; +@@ -496,7 +501,7 @@ int kvm_arch_init_vcpu(CPUState *cs) + if (cpu->hyperv_relaxed_timing) { + c->eax |= HV_X64_RELAXED_TIMING_RECOMMENDED; + } +- if (cpu->hyperv_vapic) { ++ if (has_msr_hv_vapic) { + c->eax |= HV_X64_APIC_ACCESS_RECOMMENDED; + } + c->ebx = cpu->hyperv_spinlock_attempts; +@@ -507,6 +512,7 @@ int kvm_arch_init_vcpu(CPUState *cs) + c->ebx = 0x40; + + kvm_base = KVM_CPUID_SIGNATURE_NEXT; ++ has_msr_hv_hypercall = true; + } + + memcpy(signature, "KVMKVMKVM\0\0\0", 12); +@@ -1191,11 +1197,11 @@ static int kvm_put_msrs(X86CPU *cpu, int level) + kvm_msr_entry_set(&msrs[n++], MSR_CORE_PERF_GLOBAL_CTRL, + env->msr_global_ctrl); + } +- if (hyperv_hypercall_available(cpu)) { ++ if (has_msr_hv_hypercall) { + kvm_msr_entry_set(&msrs[n++], HV_X64_MSR_GUEST_OS_ID, 0); + kvm_msr_entry_set(&msrs[n++], HV_X64_MSR_HYPERCALL, 0); + } +- if (cpu->hyperv_vapic) { ++ if (has_msr_hv_vapic) { + kvm_msr_entry_set(&msrs[n++], HV_X64_MSR_APIC_ASSIST_PAGE, 0); + } + } +-- +1.7.1 + diff --git a/SOURCES/kvm-make-hyperv-hypercall-and-guest-os-id-MSRs-migra.patch b/SOURCES/kvm-make-hyperv-hypercall-and-guest-os-id-MSRs-migra.patch new file mode 100644 index 0000000..6111615 --- /dev/null +++ b/SOURCES/kvm-make-hyperv-hypercall-and-guest-os-id-MSRs-migra.patch @@ -0,0 +1,135 @@ +From ab03fc7dbf876e611f43be34faa6945728977056 Mon Sep 17 00:00:00 2001 +From: Vadim Rozenfeld +Date: Mon, 3 Mar 2014 12:09:17 +0100 +Subject: [PATCH 05/12] kvm: make hyperv hypercall and guest os id MSRs migratable. + +RH-Author: Vadim Rozenfeld +Message-id: <1393848564-10511-6-git-send-email-vrozenfe@redhat.com> +Patchwork-id: 57961 +O-Subject: [RHEL-7.0 qemu-kvm v4 PATCH 05/12] kvm: make hyperv hypercall and guest os id MSRs migratable. +Bugzilla: 1004773 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Igor Mammedov +RH-Acked-by: Eduardo Habkost +RH-Acked-by: Juan Quintela + +Note: The field order in vmstate_msr_hypercall_hypercall follows the same + pattern as in RHEL6, but not upstream. + +Signed-off-by: Vadim Rozenfeld +Signed-off-by: Paolo Bonzini +(cherry picked from commit 1c90ef2619dd6e5c4fec7e9e18c04c0a08e93aac) + +Conflicts: + target-i386/machine.c +--- + target-i386/cpu.h | 2 ++ + target-i386/kvm.c | 16 ++++++++++++++-- + target-i386/machine.c | 23 +++++++++++++++++++++++ + 3 files changed, 39 insertions(+), 2 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + target-i386/cpu.h | 2 ++ + target-i386/kvm.c | 16 ++++++++++++++-- + target-i386/machine.c | 23 +++++++++++++++++++++++ + 3 files changed, 39 insertions(+), 2 deletions(-) + +diff --git a/target-i386/cpu.h b/target-i386/cpu.h +index 4c4c9ff..4835a64 100644 +--- a/target-i386/cpu.h ++++ b/target-i386/cpu.h +@@ -844,6 +844,8 @@ typedef struct CPUX86State { + uint64_t msr_fixed_counters[MAX_FIXED_COUNTERS]; + uint64_t msr_gp_counters[MAX_GP_COUNTERS]; + uint64_t msr_gp_evtsel[MAX_GP_COUNTERS]; ++ uint64_t msr_hv_hypercall; ++ uint64_t msr_hv_guest_os_id; + + /* exception/interrupt handling */ + int error_code; +diff --git a/target-i386/kvm.c b/target-i386/kvm.c +index 495021b..943abe1 100644 +--- a/target-i386/kvm.c ++++ b/target-i386/kvm.c +@@ -1198,8 +1198,10 @@ static int kvm_put_msrs(X86CPU *cpu, int level) + env->msr_global_ctrl); + } + if (has_msr_hv_hypercall) { +- kvm_msr_entry_set(&msrs[n++], HV_X64_MSR_GUEST_OS_ID, 0); +- kvm_msr_entry_set(&msrs[n++], HV_X64_MSR_HYPERCALL, 0); ++ kvm_msr_entry_set(&msrs[n++], HV_X64_MSR_GUEST_OS_ID, ++ env->msr_hv_guest_os_id); ++ kvm_msr_entry_set(&msrs[n++], HV_X64_MSR_HYPERCALL, ++ env->msr_hv_hypercall); + } + if (has_msr_hv_vapic) { + kvm_msr_entry_set(&msrs[n++], HV_X64_MSR_APIC_ASSIST_PAGE, 0); +@@ -1475,6 +1477,10 @@ static int kvm_get_msrs(X86CPU *cpu) + } + } + ++ if (has_msr_hv_hypercall) { ++ msrs[n++].index = HV_X64_MSR_HYPERCALL; ++ msrs[n++].index = HV_X64_MSR_GUEST_OS_ID; ++ } + msr_data.info.nmsrs = n; + ret = kvm_vcpu_ioctl(CPU(cpu), KVM_GET_MSRS, &msr_data); + if (ret < 0) { +@@ -1576,6 +1582,12 @@ static int kvm_get_msrs(X86CPU *cpu) + case MSR_P6_EVNTSEL0 ... MSR_P6_EVNTSEL0 + MAX_GP_COUNTERS - 1: + env->msr_gp_evtsel[index - MSR_P6_EVNTSEL0] = msrs[i].data; + break; ++ case HV_X64_MSR_HYPERCALL: ++ env->msr_hv_hypercall = msrs[i].data; ++ break; ++ case HV_X64_MSR_GUEST_OS_ID: ++ env->msr_hv_guest_os_id = msrs[i].data; ++ break; + } + } + +diff --git a/target-i386/machine.c b/target-i386/machine.c +index 08b4ed3..817f8e4 100644 +--- a/target-i386/machine.c ++++ b/target-i386/machine.c +@@ -506,6 +506,26 @@ static const VMStateDescription vmstate_msr_architectural_pmu = { + } + }; + ++static bool hyperv_hypercall_enable_needed(void *opaque) ++{ ++ X86CPU *cpu = opaque; ++ CPUX86State *env = &cpu->env; ++ ++ return env->msr_hv_hypercall != 0 || env->msr_hv_guest_os_id != 0; ++} ++ ++static const VMStateDescription vmstate_msr_hypercall_hypercall = { ++ .name = "cpu/msr_hyperv_hypercall", ++ .version_id = 1, ++ .minimum_version_id = 1, ++ .minimum_version_id_old = 1, ++ .fields = (VMStateField []) { ++ VMSTATE_UINT64(env.msr_hv_guest_os_id, X86CPU), ++ VMSTATE_UINT64(env.msr_hv_hypercall, X86CPU), ++ VMSTATE_END_OF_LIST() ++ } ++}; ++ + const VMStateDescription vmstate_x86_cpu = { + .name = "cpu", + .version_id = 12, +@@ -638,6 +658,9 @@ const VMStateDescription vmstate_x86_cpu = { + .vmsd = &vmstate_msr_architectural_pmu, + .needed = pmu_enable_needed, + }, { ++ .vmsd = &vmstate_msr_hypercall_hypercall, ++ .needed = hyperv_hypercall_enable_needed, ++ } , { + /* empty */ + } + } +-- +1.7.1 + diff --git a/SOURCES/kvm-make-hyperv-vapic-assist-page-migratable.patch b/SOURCES/kvm-make-hyperv-vapic-assist-page-migratable.patch new file mode 100644 index 0000000..33109c0 --- /dev/null +++ b/SOURCES/kvm-make-hyperv-vapic-assist-page-migratable.patch @@ -0,0 +1,121 @@ +From b8aa71df9dc7135c4894732449745f1e8a130798 Mon Sep 17 00:00:00 2001 +From: Vadim Rozenfeld +Date: Mon, 3 Mar 2014 12:09:18 +0100 +Subject: [PATCH 06/12] kvm: make hyperv vapic assist page migratable + +RH-Author: Vadim Rozenfeld +Message-id: <1393848564-10511-7-git-send-email-vrozenfe@redhat.com> +Patchwork-id: 57962 +O-Subject: [RHEL-7.0 qemu-kvm v4 PATCH 06/12] kvm: make hyperv vapic assist page migratable +Bugzilla: 1004773 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Igor Mammedov +RH-Acked-by: Eduardo Habkost +RH-Acked-by: Juan Quintela + +Signed-off-by: Vadim Rozenfeld +Signed-off-by: Paolo Bonzini +(cherry picked from commit 5ef68987e5671edf5f51f845d1bbf3e5759a8526) +--- + target-i386/cpu.h | 1 + + target-i386/kvm.c | 10 +++++++++- + target-i386/machine.c | 22 ++++++++++++++++++++++ + 3 files changed, 32 insertions(+), 1 deletion(-) + +Signed-off-by: Miroslav Rezanina +--- + target-i386/cpu.h | 1 + + target-i386/kvm.c | 10 +++++++++- + target-i386/machine.c | 22 ++++++++++++++++++++++ + 3 files changed, 32 insertions(+), 1 deletions(-) + +diff --git a/target-i386/cpu.h b/target-i386/cpu.h +index 4835a64..0773499 100644 +--- a/target-i386/cpu.h ++++ b/target-i386/cpu.h +@@ -846,6 +846,7 @@ typedef struct CPUX86State { + uint64_t msr_gp_evtsel[MAX_GP_COUNTERS]; + uint64_t msr_hv_hypercall; + uint64_t msr_hv_guest_os_id; ++ uint64_t msr_hv_vapic; + + /* exception/interrupt handling */ + int error_code; +diff --git a/target-i386/kvm.c b/target-i386/kvm.c +index 943abe1..a2946c4 100644 +--- a/target-i386/kvm.c ++++ b/target-i386/kvm.c +@@ -1204,7 +1204,8 @@ static int kvm_put_msrs(X86CPU *cpu, int level) + env->msr_hv_hypercall); + } + if (has_msr_hv_vapic) { +- kvm_msr_entry_set(&msrs[n++], HV_X64_MSR_APIC_ASSIST_PAGE, 0); ++ kvm_msr_entry_set(&msrs[n++], HV_X64_MSR_APIC_ASSIST_PAGE, ++ env->msr_hv_vapic); + } + } + if (env->mcg_cap) { +@@ -1481,6 +1482,10 @@ static int kvm_get_msrs(X86CPU *cpu) + msrs[n++].index = HV_X64_MSR_HYPERCALL; + msrs[n++].index = HV_X64_MSR_GUEST_OS_ID; + } ++ if (has_msr_hv_vapic) { ++ msrs[n++].index = HV_X64_MSR_APIC_ASSIST_PAGE; ++ } ++ + msr_data.info.nmsrs = n; + ret = kvm_vcpu_ioctl(CPU(cpu), KVM_GET_MSRS, &msr_data); + if (ret < 0) { +@@ -1588,6 +1593,9 @@ static int kvm_get_msrs(X86CPU *cpu) + case HV_X64_MSR_GUEST_OS_ID: + env->msr_hv_guest_os_id = msrs[i].data; + break; ++ case HV_X64_MSR_APIC_ASSIST_PAGE: ++ env->msr_hv_vapic = msrs[i].data; ++ break; + } + } + +diff --git a/target-i386/machine.c b/target-i386/machine.c +index 817f8e4..021390b 100644 +--- a/target-i386/machine.c ++++ b/target-i386/machine.c +@@ -526,6 +526,25 @@ static const VMStateDescription vmstate_msr_hypercall_hypercall = { + } + }; + ++static bool hyperv_vapic_enable_needed(void *opaque) ++{ ++ X86CPU *cpu = opaque; ++ CPUX86State *env = &cpu->env; ++ ++ return env->msr_hv_vapic != 0; ++} ++ ++static const VMStateDescription vmstate_msr_hyperv_vapic = { ++ .name = "cpu/msr_hyperv_vapic", ++ .version_id = 1, ++ .minimum_version_id = 1, ++ .minimum_version_id_old = 1, ++ .fields = (VMStateField []) { ++ VMSTATE_UINT64(env.msr_hv_vapic, X86CPU), ++ VMSTATE_END_OF_LIST() ++ } ++}; ++ + const VMStateDescription vmstate_x86_cpu = { + .name = "cpu", + .version_id = 12, +@@ -660,6 +679,9 @@ const VMStateDescription vmstate_x86_cpu = { + }, { + .vmsd = &vmstate_msr_hypercall_hypercall, + .needed = hyperv_hypercall_enable_needed, ++ }, { ++ .vmsd = &vmstate_msr_hyperv_vapic, ++ .needed = hyperv_vapic_enable_needed, + } , { + /* empty */ + } +-- +1.7.1 + diff --git a/SOURCES/kvm-memory-Rename-readable-flag-to-romd_mode.patch b/SOURCES/kvm-memory-Rename-readable-flag-to-romd_mode.patch new file mode 100644 index 0000000..571daf8 --- /dev/null +++ b/SOURCES/kvm-memory-Rename-readable-flag-to-romd_mode.patch @@ -0,0 +1,252 @@ +From bf17f7d5651bdf24cc15268ff20ecbccf74ea138 Mon Sep 17 00:00:00 2001 +From: Laszlo Ersek +Date: Sat, 11 Jan 2014 17:59:54 +0100 +Subject: [PATCH 04/22] memory: Rename readable flag to romd_mode + +RH-Author: Laszlo Ersek +Message-id: <1389463208-6278-5-git-send-email-lersek@redhat.com> +Patchwork-id: 56617 +O-Subject: [RHEL-7.0 qemu-kvm PATCH 04/18] memory: Rename readable flag to romd_mode +Bugzilla: 1032346 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Amos Kong +RH-Acked-by: Andrew Jones +RH-Acked-by: Kevin Wolf + +From: Jan Kiszka + +"Readable" is a very unfortunate name for this flag because even a +rom_device region will always be readable from the guest POV. What +differs is the mapping, just like the comments had to explain already. +Also, readable could currently be understood as being a generic region +flag, but it only applies to rom_device regions. + +So rename the flag and the function to modify it after the original term +"ROMD" which could also be interpreted as "ROM direct", i.e. ROM mode +with direct access. In any case, the scope of the flag is clearer now. + +Signed-off-by: Jan Kiszka +Reviewed-by: Peter Maydell +Signed-off-by: Paolo Bonzini +(cherry picked from commit 5f9a5ea1c0a8391033e7d33abd335dd804a1001a) +Signed-off-by: Laszlo Ersek +--- + include/exec/memory.h | 22 +++++++++++----------- + hw/block/pflash_cfi01.c | 6 +++--- + hw/block/pflash_cfi02.c | 2 +- + memory.c | 30 +++++++++++++++--------------- + 4 files changed, 30 insertions(+), 30 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + hw/block/pflash_cfi01.c | 6 +++--- + hw/block/pflash_cfi02.c | 2 +- + include/exec/memory.h | 22 +++++++++++----------- + memory.c | 30 +++++++++++++++--------------- + 4 files changed, 30 insertions(+), 30 deletions(-) + +diff --git a/hw/block/pflash_cfi01.c b/hw/block/pflash_cfi01.c +index 0bbb1a3..18eb0bc 100644 +--- a/hw/block/pflash_cfi01.c ++++ b/hw/block/pflash_cfi01.c +@@ -105,7 +105,7 @@ static void pflash_timer (void *opaque) + DPRINTF("%s: command %02x done\n", __func__, pfl->cmd); + /* Reset flash */ + pfl->status ^= 0x80; +- memory_region_rom_device_set_readable(&pfl->mem, true); ++ memory_region_rom_device_set_romd(&pfl->mem, true); + pfl->wcycle = 0; + pfl->cmd = 0; + } +@@ -281,7 +281,7 @@ static void pflash_write(pflash_t *pfl, hwaddr offset, + + if (!pfl->wcycle) { + /* Set the device in I/O access mode */ +- memory_region_rom_device_set_readable(&pfl->mem, false); ++ memory_region_rom_device_set_romd(&pfl->mem, false); + } + + switch (pfl->wcycle) { +@@ -458,7 +458,7 @@ static void pflash_write(pflash_t *pfl, hwaddr offset, + "\n", __func__, offset, pfl->wcycle, pfl->cmd, value); + + reset_flash: +- memory_region_rom_device_set_readable(&pfl->mem, true); ++ memory_region_rom_device_set_romd(&pfl->mem, true); + + pfl->wcycle = 0; + pfl->cmd = 0; +diff --git a/hw/block/pflash_cfi02.c b/hw/block/pflash_cfi02.c +index 9a7fa70..5f25246 100644 +--- a/hw/block/pflash_cfi02.c ++++ b/hw/block/pflash_cfi02.c +@@ -111,7 +111,7 @@ static void pflash_setup_mappings(pflash_t *pfl) + + static void pflash_register_memory(pflash_t *pfl, int rom_mode) + { +- memory_region_rom_device_set_readable(&pfl->orig_mem, rom_mode); ++ memory_region_rom_device_set_romd(&pfl->orig_mem, rom_mode); + pfl->rom_mode = rom_mode; + } + +diff --git a/include/exec/memory.h b/include/exec/memory.h +index bd6d31a..3bbe378 100644 +--- a/include/exec/memory.h ++++ b/include/exec/memory.h +@@ -124,7 +124,7 @@ struct MemoryRegion { + ram_addr_t ram_addr; + bool subpage; + bool terminates; +- bool readable; ++ bool romd_mode; + bool ram; + bool readonly; /* For RAM regions */ + bool enabled; +@@ -353,16 +353,16 @@ uint64_t memory_region_size(MemoryRegion *mr); + bool memory_region_is_ram(MemoryRegion *mr); + + /** +- * memory_region_is_romd: check whether a memory region is ROMD ++ * memory_region_is_romd: check whether a memory region is in ROMD mode + * +- * Returns %true is a memory region is ROMD and currently set to allow ++ * Returns %true if a memory region is a ROM device and currently set to allow + * direct reads. + * + * @mr: the memory region being queried + */ + static inline bool memory_region_is_romd(MemoryRegion *mr) + { +- return mr->rom_device && mr->readable; ++ return mr->rom_device && mr->romd_mode; + } + + /** +@@ -500,18 +500,18 @@ void memory_region_reset_dirty(MemoryRegion *mr, hwaddr addr, + void memory_region_set_readonly(MemoryRegion *mr, bool readonly); + + /** +- * memory_region_rom_device_set_readable: enable/disable ROM readability ++ * memory_region_rom_device_set_romd: enable/disable ROMD mode + * + * Allows a ROM device (initialized with memory_region_init_rom_device() to +- * to be marked as readable (default) or not readable. When it is readable, +- * the device is mapped to guest memory. When not readable, reads are +- * forwarded to the #MemoryRegion.read function. ++ * set to ROMD mode (default) or MMIO mode. When it is in ROMD mode, the ++ * device is mapped to guest memory and satisfies read access directly. ++ * When in MMIO mode, reads are forwarded to the #MemoryRegion.read function. ++ * Writes are always handled by the #MemoryRegion.write function. + * + * @mr: the memory region to be updated +- * @readable: whether reads are satisified directly (%true) or via callbacks +- * (%false) ++ * @romd_mode: %true to put the region into ROMD mode + */ +-void memory_region_rom_device_set_readable(MemoryRegion *mr, bool readable); ++void memory_region_rom_device_set_romd(MemoryRegion *mr, bool romd_mode); + + /** + * memory_region_set_coalescing: Enable memory coalescing for the region. +diff --git a/memory.c b/memory.c +index 685912d..edaf6fd 100644 +--- a/memory.c ++++ b/memory.c +@@ -214,7 +214,7 @@ struct FlatRange { + hwaddr offset_in_region; + AddrRange addr; + uint8_t dirty_log_mask; +- bool readable; ++ bool romd_mode; + bool readonly; + }; + +@@ -237,7 +237,7 @@ static bool flatrange_equal(FlatRange *a, FlatRange *b) + return a->mr == b->mr + && addrrange_equal(a->addr, b->addr) + && a->offset_in_region == b->offset_in_region +- && a->readable == b->readable ++ && a->romd_mode == b->romd_mode + && a->readonly == b->readonly; + } + +@@ -277,7 +277,7 @@ static bool can_merge(FlatRange *r1, FlatRange *r2) + r1->addr.size), + int128_make64(r2->offset_in_region)) + && r1->dirty_log_mask == r2->dirty_log_mask +- && r1->readable == r2->readable ++ && r1->romd_mode == r2->romd_mode + && r1->readonly == r2->readonly; + } + +@@ -533,7 +533,7 @@ static void render_memory_region(FlatView *view, + fr.offset_in_region = offset_in_region; + fr.addr = addrrange_make(base, now); + fr.dirty_log_mask = mr->dirty_log_mask; +- fr.readable = mr->readable; ++ fr.romd_mode = mr->romd_mode; + fr.readonly = readonly; + flatview_insert(view, i, &fr); + ++i; +@@ -553,7 +553,7 @@ static void render_memory_region(FlatView *view, + fr.offset_in_region = offset_in_region; + fr.addr = addrrange_make(base, remain); + fr.dirty_log_mask = mr->dirty_log_mask; +- fr.readable = mr->readable; ++ fr.romd_mode = mr->romd_mode; + fr.readonly = readonly; + flatview_insert(view, i, &fr); + } +@@ -802,7 +802,7 @@ void memory_region_init(MemoryRegion *mr, + mr->enabled = true; + mr->terminates = false; + mr->ram = false; +- mr->readable = true; ++ mr->romd_mode = true; + mr->readonly = false; + mr->rom_device = false; + mr->destructor = memory_region_destructor_none; +@@ -1118,11 +1118,11 @@ void memory_region_set_readonly(MemoryRegion *mr, bool readonly) + } + } + +-void memory_region_rom_device_set_readable(MemoryRegion *mr, bool readable) ++void memory_region_rom_device_set_romd(MemoryRegion *mr, bool romd_mode) + { +- if (mr->readable != readable) { ++ if (mr->romd_mode != romd_mode) { + memory_region_transaction_begin(); +- mr->readable = readable; ++ mr->romd_mode = romd_mode; + memory_region_update_pending |= mr->enabled; + memory_region_transaction_commit(); + } +@@ -1644,9 +1644,9 @@ static void mtree_print_mr(fprintf_function mon_printf, void *f, + base + mr->addr + + (hwaddr)int128_get64(mr->size) - 1, + mr->priority, +- mr->readable ? 'R' : '-', +- !mr->readonly && !(mr->rom_device && mr->readable) ? 'W' +- : '-', ++ mr->romd_mode ? 'R' : '-', ++ !mr->readonly && !(mr->rom_device && mr->romd_mode) ? 'W' ++ : '-', + mr->name, + mr->alias->name, + mr->alias_offset, +@@ -1659,9 +1659,9 @@ static void mtree_print_mr(fprintf_function mon_printf, void *f, + base + mr->addr + + (hwaddr)int128_get64(mr->size) - 1, + mr->priority, +- mr->readable ? 'R' : '-', +- !mr->readonly && !(mr->rom_device && mr->readable) ? 'W' +- : '-', ++ mr->romd_mode ? 'R' : '-', ++ !mr->readonly && !(mr->rom_device && mr->romd_mode) ? 'W' ++ : '-', + mr->name); + } + +-- +1.7.1 + diff --git a/SOURCES/kvm-memory-Replace-open-coded-memory_region_is_romd.patch b/SOURCES/kvm-memory-Replace-open-coded-memory_region_is_romd.patch new file mode 100644 index 0000000..5d02268 --- /dev/null +++ b/SOURCES/kvm-memory-Replace-open-coded-memory_region_is_romd.patch @@ -0,0 +1,48 @@ +From 8b8d0c6584741845558eb066c8b1c393dc86bb29 Mon Sep 17 00:00:00 2001 +From: Laszlo Ersek +Date: Sat, 11 Jan 2014 17:59:53 +0100 +Subject: [PATCH 03/22] memory: Replace open-coded memory_region_is_romd + +RH-Author: Laszlo Ersek +Message-id: <1389463208-6278-4-git-send-email-lersek@redhat.com> +Patchwork-id: 56616 +O-Subject: [RHEL-7.0 qemu-kvm PATCH 03/18] memory: Replace open-coded memory_region_is_romd +Bugzilla: 1032346 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Amos Kong +RH-Acked-by: Andrew Jones +RH-Acked-by: Kevin Wolf + +From: Jan Kiszka + +Improves readability. + +Reviewed-by: Peter Maydell +Signed-off-by: Jan Kiszka +(cherry picked from commit 4b81126e3399bfbcc47a4d696902c93401169f72) +Signed-off-by: Laszlo Ersek +--- + translate-all.c | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +Signed-off-by: Miroslav Rezanina +--- + translate-all.c | 2 +- + 1 files changed, 1 insertions(+), 1 deletions(-) + +diff --git a/translate-all.c b/translate-all.c +index da93608..0d84b0d 100644 +--- a/translate-all.c ++++ b/translate-all.c +@@ -1359,7 +1359,7 @@ void tb_invalidate_phys_addr(hwaddr addr) + section = phys_page_find(address_space_memory.dispatch, + addr >> TARGET_PAGE_BITS); + if (!(memory_region_is_ram(section->mr) +- || (section->mr->rom_device && section->mr->readable))) { ++ || memory_region_is_romd(section->mr))) { + return; + } + ram_addr = (memory_region_get_ram_addr(section->mr) & TARGET_PAGE_MASK) +-- +1.7.1 + diff --git a/SOURCES/kvm-memory-all-users-of-cpu_physical_memory_get_dirty-us.patch b/SOURCES/kvm-memory-all-users-of-cpu_physical_memory_get_dirty-us.patch new file mode 100644 index 0000000..c8dcd94 --- /dev/null +++ b/SOURCES/kvm-memory-all-users-of-cpu_physical_memory_get_dirty-us.patch @@ -0,0 +1,67 @@ +From 34f281f51324d0b4638803025b2a107c37ee6c4c Mon Sep 17 00:00:00 2001 +From: Juan Quintela +Date: Tue, 14 Jan 2014 15:07:20 +0100 +Subject: [PATCH 09/40] memory: all users of cpu_physical_memory_get_dirty used only one flag + +RH-Author: Juan Quintela +Message-id: <1389712071-23303-10-git-send-email-quintela@redhat.com> +Patchwork-id: 56665 +O-Subject: [RHEL7 qemu-kvm PATCH 09/40] memory: all users of cpu_physical_memory_get_dirty used only one flag +Bugzilla: 997559 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Orit Wasserman +RH-Acked-by: Dr. David Alan Gilbert (git) + +So cpu_physical_memory_get_dirty_flags is not needed anymore + +Signed-off-by: Juan Quintela +Reviewed-by: Eric Blake +Reviewed-by: Orit Wasserman +(cherry picked from commit 36187e2ca0295364dcb9a3f256a6fcd77e983c02) +Signed-off-by: Juan Quintela +--- + include/exec/memory-internal.h | 9 ++------- + 1 file changed, 2 insertions(+), 7 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + include/exec/memory-internal.h | 9 ++------- + 1 files changed, 2 insertions(+), 7 deletions(-) + +diff --git a/include/exec/memory-internal.h b/include/exec/memory-internal.h +index dfc03e1..571a5ef 100644 +--- a/include/exec/memory-internal.h ++++ b/include/exec/memory-internal.h +@@ -53,11 +53,6 @@ void qemu_ram_free_from_ptr(ram_addr_t addr); + #define CODE_DIRTY_FLAG 0x02 + #define MIGRATION_DIRTY_FLAG 0x08 + +-static inline int cpu_physical_memory_get_dirty_flags(ram_addr_t addr) +-{ +- return ram_list.phys_dirty[addr >> TARGET_PAGE_BITS]; +-} +- + static inline bool cpu_physical_memory_get_dirty_flag(ram_addr_t addr, + int dirty_flag) + { +@@ -76,7 +71,7 @@ static inline bool cpu_physical_memory_is_dirty(ram_addr_t addr) + + static inline int cpu_physical_memory_get_dirty(ram_addr_t start, + ram_addr_t length, +- int dirty_flags) ++ int dirty_flag) + { + int ret = 0; + ram_addr_t addr, end; +@@ -84,7 +79,7 @@ static inline int cpu_physical_memory_get_dirty(ram_addr_t start, + end = TARGET_PAGE_ALIGN(start + length); + start &= TARGET_PAGE_MASK; + for (addr = start; addr < end; addr += TARGET_PAGE_SIZE) { +- ret |= cpu_physical_memory_get_dirty_flags(addr) & dirty_flags; ++ ret |= cpu_physical_memory_get_dirty_flag(addr, dirty_flag); + } + return ret; + } +-- +1.7.1 + diff --git a/SOURCES/kvm-memory-cpu_physical_memory_clear_dirty_flag-result-i.patch b/SOURCES/kvm-memory-cpu_physical_memory_clear_dirty_flag-result-i.patch new file mode 100644 index 0000000..293150e --- /dev/null +++ b/SOURCES/kvm-memory-cpu_physical_memory_clear_dirty_flag-result-i.patch @@ -0,0 +1,52 @@ +From 40df172dc059d425c1d557c2e21fc931bf3c2251 Mon Sep 17 00:00:00 2001 +From: Juan Quintela +Date: Tue, 14 Jan 2014 15:07:27 +0100 +Subject: [PATCH 16/40] memory: cpu_physical_memory_clear_dirty_flag() result is never used + +RH-Author: Juan Quintela +Message-id: <1389712071-23303-17-git-send-email-quintela@redhat.com> +Patchwork-id: 56670 +O-Subject: [RHEL7 qemu-kvm PATCH 16/40] memory: cpu_physical_memory_clear_dirty_flag() result is never used +Bugzilla: 997559 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Orit Wasserman +RH-Acked-by: Dr. David Alan Gilbert (git) + +Signed-off-by: Juan Quintela +Reviewed-by: Eric Blake +Reviewed-by: Orit Wasserman +(cherry picked from commit e8a97cafc4108fa964807eb9cbce7eda698f99bb) +Signed-off-by: Juan Quintela +--- + include/exec/memory-internal.h | 4 ++-- + 1 file changed, 2 insertions(+), 2 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + include/exec/memory-internal.h | 4 ++-- + 1 files changed, 2 insertions(+), 2 deletions(-) + +diff --git a/include/exec/memory-internal.h b/include/exec/memory-internal.h +index ef5de3e..2c86add 100644 +--- a/include/exec/memory-internal.h ++++ b/include/exec/memory-internal.h +@@ -95,14 +95,14 @@ static inline void cpu_physical_memory_set_dirty(ram_addr_t addr) + cpu_physical_memory_set_dirty_flag(addr, DIRTY_MEMORY_CODE); + } + +-static inline int cpu_physical_memory_clear_dirty_flag(ram_addr_t addr, ++static inline void cpu_physical_memory_clear_dirty_flag(ram_addr_t addr, + unsigned client) + { + int mask = ~(1 << client); + + assert(client < DIRTY_MEMORY_NUM); + +- return ram_list.phys_dirty[addr >> TARGET_PAGE_BITS] &= mask; ++ ram_list.phys_dirty[addr >> TARGET_PAGE_BITS] &= mask; + } + + static inline void cpu_physical_memory_set_dirty_range(ram_addr_t start, +-- +1.7.1 + diff --git a/SOURCES/kvm-memory-cpu_physical_memory_clear_dirty_range-now-use.patch b/SOURCES/kvm-memory-cpu_physical_memory_clear_dirty_range-now-use.patch new file mode 100644 index 0000000..59aaf35 --- /dev/null +++ b/SOURCES/kvm-memory-cpu_physical_memory_clear_dirty_range-now-use.patch @@ -0,0 +1,56 @@ +From 4130035f29158309e86b3a1e0f25dbd5bec81af0 Mon Sep 17 00:00:00 2001 +From: Juan Quintela +Date: Tue, 14 Jan 2014 15:07:38 +0100 +Subject: [PATCH 27/40] memory: cpu_physical_memory_clear_dirty_range() now uses bitmap operations + +RH-Author: Juan Quintela +Message-id: <1389712071-23303-28-git-send-email-quintela@redhat.com> +Patchwork-id: 56685 +O-Subject: [RHEL7 qemu-kvm PATCH 27/40] memory: cpu_physical_memory_clear_dirty_range() now uses bitmap operations +Bugzilla: 997559 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Orit Wasserman +RH-Acked-by: Dr. David Alan Gilbert (git) + +We were clearing a range of bits, so use bitmap_clear(). + +Signed-off-by: Juan Quintela +Reviewed-by: Eric Blake +Reviewed-by: Orit Wasserman +(cherry picked from commit a461e389f489e72cdc770ff887512c2c9109bc43) +Signed-off-by: Juan Quintela +--- + include/exec/memory-internal.h | 10 ++++------ + 1 file changed, 4 insertions(+), 6 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + include/exec/memory-internal.h | 10 ++++------ + 1 files changed, 4 insertions(+), 6 deletions(-) + +diff --git a/include/exec/memory-internal.h b/include/exec/memory-internal.h +index 9d32a5a..94bd6af 100644 +--- a/include/exec/memory-internal.h ++++ b/include/exec/memory-internal.h +@@ -104,14 +104,12 @@ static inline void cpu_physical_memory_clear_dirty_range(ram_addr_t start, + ram_addr_t length, + unsigned client) + { +- ram_addr_t addr, end; ++ unsigned long end, page; + + assert(client < DIRTY_MEMORY_NUM); +- end = TARGET_PAGE_ALIGN(start + length); +- start &= TARGET_PAGE_MASK; +- for (addr = start; addr < end; addr += TARGET_PAGE_SIZE) { +- clear_bit(addr >> TARGET_PAGE_BITS, ram_list.dirty_memory[client]); +- } ++ end = TARGET_PAGE_ALIGN(start + length) >> TARGET_PAGE_BITS; ++ page = start >> TARGET_PAGE_BITS; ++ bitmap_clear(ram_list.dirty_memory[client], page, end - page); + } + + void cpu_physical_memory_reset_dirty(ram_addr_t start, ram_addr_t end, +-- +1.7.1 + diff --git a/SOURCES/kvm-memory-cpu_physical_memory_get_dirty-is-used-as-retu.patch b/SOURCES/kvm-memory-cpu_physical_memory_get_dirty-is-used-as-retu.patch new file mode 100644 index 0000000..3eb27b3 --- /dev/null +++ b/SOURCES/kvm-memory-cpu_physical_memory_get_dirty-is-used-as-retu.patch @@ -0,0 +1,66 @@ +From 0a833a763d5ab1da11f11303e96b0c56100ce2b9 Mon Sep 17 00:00:00 2001 +From: Juan Quintela +Date: Tue, 14 Jan 2014 15:07:34 +0100 +Subject: [PATCH 23/40] memory: cpu_physical_memory_get_dirty() is used as returning a bool + +RH-Author: Juan Quintela +Message-id: <1389712071-23303-24-git-send-email-quintela@redhat.com> +Patchwork-id: 56676 +O-Subject: [RHEL7 qemu-kvm PATCH 23/40] memory: cpu_physical_memory_get_dirty() is used as returning a bool +Bugzilla: 997559 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Orit Wasserman +RH-Acked-by: Dr. David Alan Gilbert (git) + +Signed-off-by: Juan Quintela +Reviewed-by: Eric Blake +Reviewed-by: Orit Wasserman +(cherry picked from commit 94833c896d2d339571a66542f2715b1897d70fa7) +Signed-off-by: Juan Quintela +--- + include/exec/memory-internal.h | 15 ++++++++------- + 1 file changed, 8 insertions(+), 7 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + include/exec/memory-internal.h | 15 ++++++++------- + 1 files changed, 8 insertions(+), 7 deletions(-) + +diff --git a/include/exec/memory-internal.h b/include/exec/memory-internal.h +index 9099561..f27b830 100644 +--- a/include/exec/memory-internal.h ++++ b/include/exec/memory-internal.h +@@ -49,11 +49,10 @@ ram_addr_t qemu_ram_alloc(ram_addr_t size, MemoryRegion *mr); + void qemu_ram_free(ram_addr_t addr); + void qemu_ram_free_from_ptr(ram_addr_t addr); + +-static inline int cpu_physical_memory_get_dirty(ram_addr_t start, +- ram_addr_t length, +- unsigned client) ++static inline bool cpu_physical_memory_get_dirty(ram_addr_t start, ++ ram_addr_t length, ++ unsigned client) + { +- int ret = 0; + ram_addr_t addr, end; + + assert(client < DIRTY_MEMORY_NUM); +@@ -61,10 +60,12 @@ static inline int cpu_physical_memory_get_dirty(ram_addr_t start, + end = TARGET_PAGE_ALIGN(start + length); + start &= TARGET_PAGE_MASK; + for (addr = start; addr < end; addr += TARGET_PAGE_SIZE) { +- ret |= test_bit(addr >> TARGET_PAGE_BITS, +- ram_list.dirty_memory[client]); ++ if (test_bit(addr >> TARGET_PAGE_BITS, ++ ram_list.dirty_memory[client])) { ++ return true; ++ } + } +- return ret; ++ return false; + } + + static inline bool cpu_physical_memory_get_dirty_flag(ram_addr_t addr, +-- +1.7.1 + diff --git a/SOURCES/kvm-memory-cpu_physical_memory_mask_dirty_range-always-c.patch b/SOURCES/kvm-memory-cpu_physical_memory_mask_dirty_range-always-c.patch new file mode 100644 index 0000000..d5e7be5 --- /dev/null +++ b/SOURCES/kvm-memory-cpu_physical_memory_mask_dirty_range-always-c.patch @@ -0,0 +1,281 @@ +From e892037c3e5cf8ec5f0278dcbc97167831100a54 Mon Sep 17 00:00:00 2001 +From: Juan Quintela +Date: Tue, 14 Jan 2014 15:07:23 +0100 +Subject: [PATCH 12/40] memory: cpu_physical_memory_mask_dirty_range() always clears a single flag + +RH-Author: Juan Quintela +Message-id: <1389712071-23303-13-git-send-email-quintela@redhat.com> +Patchwork-id: 56667 +O-Subject: [RHEL7 qemu-kvm PATCH 12/40] memory: cpu_physical_memory_mask_dirty_range() always clears a single flag +Bugzilla: 997559 +RH-Acked-by: Orit Wasserman +RH-Acked-by: Dr. David Alan Gilbert (git) +RH-Acked-by: Paolo Bonzini + +Document it + +Signed-off-by: Juan Quintela +Reviewed-by: Eric Blake +Reviewed-by: Orit Wasserman +(cherry picked from commit 52159192919469b424b54c167312e53d5a62d233) +Signed-off-by: Juan Quintela +--- + cputlb.c | 4 ++-- + exec.c | 19 ++++++++++--------- + include/exec/memory-internal.h | 40 ++++++++++++++++++---------------------- + include/exec/memory.h | 3 --- + memory.c | 10 ++++------ + 5 files changed, 34 insertions(+), 42 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + cputlb.c | 4 ++-- + exec.c | 19 ++++++++++--------- + include/exec/memory-internal.h | 40 ++++++++++++++++++---------------------- + include/exec/memory.h | 3 --- + memory.c | 10 ++++------ + 5 files changed, 34 insertions(+), 42 deletions(-) + +diff --git a/cputlb.c b/cputlb.c +index 84e83e0..9c89c01 100644 +--- a/cputlb.c ++++ b/cputlb.c +@@ -129,7 +129,7 @@ void tlb_protect_code(ram_addr_t ram_addr) + { + cpu_physical_memory_reset_dirty(ram_addr, + ram_addr + TARGET_PAGE_SIZE, +- CODE_DIRTY_FLAG); ++ DIRTY_MEMORY_CODE); + } + + /* update the TLB so that writes in physical page 'phys_addr' are no longer +@@ -137,7 +137,7 @@ void tlb_protect_code(ram_addr_t ram_addr) + void tlb_unprotect_code_phys(CPUArchState *env, ram_addr_t ram_addr, + target_ulong vaddr) + { +- cpu_physical_memory_set_dirty_flag(ram_addr, CODE_DIRTY_FLAG); ++ cpu_physical_memory_set_dirty_flag(ram_addr, DIRTY_MEMORY_CODE); + } + + static bool tlb_is_dirty_ram(CPUTLBEntry *tlbe) +diff --git a/exec.c b/exec.c +index 069e082..8942d50 100644 +--- a/exec.c ++++ b/exec.c +@@ -596,7 +596,7 @@ static void tlb_reset_dirty_range_all(ram_addr_t start, ram_addr_t end, + + /* Note: start and end must be within the same ram block. */ + void cpu_physical_memory_reset_dirty(ram_addr_t start, ram_addr_t end, +- int dirty_flags) ++ unsigned client) + { + uintptr_t length; + +@@ -606,7 +606,7 @@ void cpu_physical_memory_reset_dirty(ram_addr_t start, ram_addr_t end, + length = end - start; + if (length == 0) + return; +- cpu_physical_memory_mask_dirty_range(start, length, dirty_flags); ++ cpu_physical_memory_mask_dirty_range(start, length, client); + + if (tcg_enabled()) { + tlb_reset_dirty_range_all(start, end, length); +@@ -1480,7 +1480,7 @@ static const MemoryRegionOps rom_mem_ops = { + static void notdirty_mem_write(void *opaque, hwaddr ram_addr, + uint64_t val, unsigned size) + { +- if (!cpu_physical_memory_get_dirty_flag(ram_addr, CODE_DIRTY_FLAG)) { ++ if (!cpu_physical_memory_get_dirty_flag(ram_addr, DIRTY_MEMORY_CODE)) { + tb_invalidate_phys_page_fast(ram_addr, size); + } + switch (size) { +@@ -1496,8 +1496,8 @@ static void notdirty_mem_write(void *opaque, hwaddr ram_addr, + default: + abort(); + } +- cpu_physical_memory_set_dirty_flag(ram_addr, MIGRATION_DIRTY_FLAG); +- cpu_physical_memory_set_dirty_flag(ram_addr, VGA_DIRTY_FLAG); ++ cpu_physical_memory_set_dirty_flag(ram_addr, DIRTY_MEMORY_MIGRATION); ++ cpu_physical_memory_set_dirty_flag(ram_addr, DIRTY_MEMORY_VGA); + /* we remove the notdirty callback only if the code has been + flushed */ + if (cpu_physical_memory_is_dirty(ram_addr)) +@@ -1919,8 +1919,8 @@ static void invalidate_and_set_dirty(hwaddr addr, + /* invalidate code */ + tb_invalidate_phys_page_range(addr, addr + length, 0); + /* set dirty bit */ +- cpu_physical_memory_set_dirty_flag(addr, VGA_DIRTY_FLAG); +- cpu_physical_memory_set_dirty_flag(addr, MIGRATION_DIRTY_FLAG); ++ cpu_physical_memory_set_dirty_flag(addr, DIRTY_MEMORY_VGA); ++ cpu_physical_memory_set_dirty_flag(addr, DIRTY_MEMORY_MIGRATION); + } + xen_modified_memory(addr, length); + } +@@ -2435,8 +2435,9 @@ void stl_phys_notdirty(hwaddr addr, uint32_t val) + /* invalidate code */ + tb_invalidate_phys_page_range(addr1, addr1 + 4, 0); + /* set dirty bit */ +- cpu_physical_memory_set_dirty_flag(addr1, MIGRATION_DIRTY_FLAG); +- cpu_physical_memory_set_dirty_flag(addr1, VGA_DIRTY_FLAG); ++ cpu_physical_memory_set_dirty_flag(addr1, ++ DIRTY_MEMORY_MIGRATION); ++ cpu_physical_memory_set_dirty_flag(addr1, DIRTY_MEMORY_VGA); + } + } + } +diff --git a/include/exec/memory-internal.h b/include/exec/memory-internal.h +index 794fabd..fbcd384 100644 +--- a/include/exec/memory-internal.h ++++ b/include/exec/memory-internal.h +@@ -49,29 +49,25 @@ ram_addr_t qemu_ram_alloc(ram_addr_t size, MemoryRegion *mr); + void qemu_ram_free(ram_addr_t addr); + void qemu_ram_free_from_ptr(ram_addr_t addr); + +-#define VGA_DIRTY_FLAG 0x01 +-#define CODE_DIRTY_FLAG 0x02 +-#define MIGRATION_DIRTY_FLAG 0x08 +- + static inline bool cpu_physical_memory_get_dirty_flag(ram_addr_t addr, +- int dirty_flag) ++ unsigned client) + { +- return ram_list.phys_dirty[addr >> TARGET_PAGE_BITS] & dirty_flag; ++ return ram_list.phys_dirty[addr >> TARGET_PAGE_BITS] & (1 << client); + } + + /* read dirty bit (return 0 or 1) */ + static inline bool cpu_physical_memory_is_dirty(ram_addr_t addr) + { +- bool vga = cpu_physical_memory_get_dirty_flag(addr, VGA_DIRTY_FLAG); +- bool code = cpu_physical_memory_get_dirty_flag(addr, CODE_DIRTY_FLAG); ++ bool vga = cpu_physical_memory_get_dirty_flag(addr, DIRTY_MEMORY_VGA); ++ bool code = cpu_physical_memory_get_dirty_flag(addr, DIRTY_MEMORY_CODE); + bool migration = +- cpu_physical_memory_get_dirty_flag(addr, MIGRATION_DIRTY_FLAG); ++ cpu_physical_memory_get_dirty_flag(addr, DIRTY_MEMORY_MIGRATION); + return vga && code && migration; + } + + static inline int cpu_physical_memory_get_dirty(ram_addr_t start, + ram_addr_t length, +- int dirty_flag) ++ unsigned client) + { + int ret = 0; + ram_addr_t addr, end; +@@ -79,28 +75,28 @@ static inline int cpu_physical_memory_get_dirty(ram_addr_t start, + end = TARGET_PAGE_ALIGN(start + length); + start &= TARGET_PAGE_MASK; + for (addr = start; addr < end; addr += TARGET_PAGE_SIZE) { +- ret |= cpu_physical_memory_get_dirty_flag(addr, dirty_flag); ++ ret |= cpu_physical_memory_get_dirty_flag(addr, client); + } + return ret; + } + + static inline void cpu_physical_memory_set_dirty_flag(ram_addr_t addr, +- int dirty_flag) ++ unsigned client) + { +- ram_list.phys_dirty[addr >> TARGET_PAGE_BITS] |= dirty_flag; ++ ram_list.phys_dirty[addr >> TARGET_PAGE_BITS] |= (1 << client); + } + + static inline void cpu_physical_memory_set_dirty(ram_addr_t addr) + { +- cpu_physical_memory_set_dirty_flag(addr, MIGRATION_DIRTY_FLAG); +- cpu_physical_memory_set_dirty_flag(addr, VGA_DIRTY_FLAG); +- cpu_physical_memory_set_dirty_flag(addr, CODE_DIRTY_FLAG); ++ cpu_physical_memory_set_dirty_flag(addr, DIRTY_MEMORY_MIGRATION); ++ cpu_physical_memory_set_dirty_flag(addr, DIRTY_MEMORY_VGA); ++ cpu_physical_memory_set_dirty_flag(addr, DIRTY_MEMORY_CODE); + } + +-static inline int cpu_physical_memory_clear_dirty_flags(ram_addr_t addr, +- int dirty_flags) ++static inline int cpu_physical_memory_clear_dirty_flag(ram_addr_t addr, ++ unsigned client) + { +- int mask = ~dirty_flags; ++ int mask = ~(1 << client); + + return ram_list.phys_dirty[addr >> TARGET_PAGE_BITS] &= mask; + } +@@ -120,19 +116,19 @@ static inline void cpu_physical_memory_set_dirty_range(ram_addr_t start, + + static inline void cpu_physical_memory_mask_dirty_range(ram_addr_t start, + ram_addr_t length, +- int dirty_flags) ++ unsigned client) + { + ram_addr_t addr, end; + + end = TARGET_PAGE_ALIGN(start + length); + start &= TARGET_PAGE_MASK; + for (addr = start; addr < end; addr += TARGET_PAGE_SIZE) { +- cpu_physical_memory_clear_dirty_flags(addr, dirty_flags); ++ cpu_physical_memory_clear_dirty_flag(addr, client); + } + } + + void cpu_physical_memory_reset_dirty(ram_addr_t start, ram_addr_t end, +- int dirty_flags); ++ unsigned client); + + extern const IORangeOps memory_region_iorange_ops; + +diff --git a/include/exec/memory.h b/include/exec/memory.h +index 9e88320..868fdb1 100644 +--- a/include/exec/memory.h ++++ b/include/exec/memory.h +@@ -30,9 +30,6 @@ typedef struct MemoryRegionOps MemoryRegionOps; + typedef struct MemoryRegionPortio MemoryRegionPortio; + typedef struct MemoryRegionMmio MemoryRegionMmio; + +-/* Must match *_DIRTY_FLAGS in cpu-all.h. To be replaced with dynamic +- * registration. +- */ + #define DIRTY_MEMORY_VGA 0 + #define DIRTY_MEMORY_CODE 1 + #define DIRTY_MEMORY_MIGRATION 3 +diff --git a/memory.c b/memory.c +index e7a454f..2883da5 100644 +--- a/memory.c ++++ b/memory.c +@@ -1070,8 +1070,7 @@ bool memory_region_get_dirty(MemoryRegion *mr, hwaddr addr, + hwaddr size, unsigned client) + { + assert(mr->terminates); +- return cpu_physical_memory_get_dirty(mr->ram_addr + addr, size, +- 1 << client); ++ return cpu_physical_memory_get_dirty(mr->ram_addr + addr, size, client); + } + + void memory_region_set_dirty(MemoryRegion *mr, hwaddr addr, +@@ -1086,12 +1085,11 @@ bool memory_region_test_and_clear_dirty(MemoryRegion *mr, hwaddr addr, + { + bool ret; + assert(mr->terminates); +- ret = cpu_physical_memory_get_dirty(mr->ram_addr + addr, size, +- 1 << client); ++ ret = cpu_physical_memory_get_dirty(mr->ram_addr + addr, size, client); + if (ret) { + cpu_physical_memory_reset_dirty(mr->ram_addr + addr, + mr->ram_addr + addr + size, +- 1 << client); ++ client); + } + return ret; + } +@@ -1137,7 +1135,7 @@ void memory_region_reset_dirty(MemoryRegion *mr, hwaddr addr, + assert(mr->terminates); + cpu_physical_memory_reset_dirty(mr->ram_addr + addr, + mr->ram_addr + addr + size, +- 1 << client); ++ client); + } + + void *memory_region_get_ram_ptr(MemoryRegion *mr) +-- +1.7.1 + diff --git a/SOURCES/kvm-memory-cpu_physical_memory_set_dirty_flags-result-is.patch b/SOURCES/kvm-memory-cpu_physical_memory_set_dirty_flags-result-is.patch new file mode 100644 index 0000000..a4a9a04 --- /dev/null +++ b/SOURCES/kvm-memory-cpu_physical_memory_set_dirty_flags-result-is.patch @@ -0,0 +1,50 @@ +From 7ed93a1e2246aca0686810f2a32582c31bd7219f Mon Sep 17 00:00:00 2001 +From: Juan Quintela +Date: Tue, 14 Jan 2014 15:07:13 +0100 +Subject: [PATCH 02/40] memory: cpu_physical_memory_set_dirty_flags() result is never used + +RH-Author: Juan Quintela +Message-id: <1389712071-23303-3-git-send-email-quintela@redhat.com> +Patchwork-id: 56660 +O-Subject: [RHEL7 qemu-kvm PATCH 02/40] memory: cpu_physical_memory_set_dirty_flags() result is never used +Bugzilla: 997559 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Orit Wasserman +RH-Acked-by: Dr. David Alan Gilbert (git) + +So return void. + +Signed-off-by: Juan Quintela +Reviewed-by: Orit Wasserman +Reviewed-by: Eric Blake +(cherry picked from commit e2da99d582300bb8deecb25d26a179ef5b92e066) +Signed-off-by: Juan Quintela +--- + include/exec/memory-internal.h | 4 ++-- + 1 file changed, 2 insertions(+), 2 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + include/exec/memory-internal.h | 4 ++-- + 1 files changed, 2 insertions(+), 2 deletions(-) + +diff --git a/include/exec/memory-internal.h b/include/exec/memory-internal.h +index 1b156fd..eac149a 100644 +--- a/include/exec/memory-internal.h ++++ b/include/exec/memory-internal.h +@@ -79,10 +79,10 @@ static inline int cpu_physical_memory_get_dirty(ram_addr_t start, + return ret; + } + +-static inline int cpu_physical_memory_set_dirty_flags(ram_addr_t addr, ++static inline void cpu_physical_memory_set_dirty_flags(ram_addr_t addr, + int dirty_flags) + { +- return ram_list.phys_dirty[addr >> TARGET_PAGE_BITS] |= dirty_flags; ++ ram_list.phys_dirty[addr >> TARGET_PAGE_BITS] |= dirty_flags; + } + + static inline void cpu_physical_memory_set_dirty(ram_addr_t addr) +-- +1.7.1 + diff --git a/SOURCES/kvm-memory-cpu_physical_memory_set_dirty_range-always-di.patch b/SOURCES/kvm-memory-cpu_physical_memory_set_dirty_range-always-di.patch new file mode 100644 index 0000000..1ac1bae --- /dev/null +++ b/SOURCES/kvm-memory-cpu_physical_memory_set_dirty_range-always-di.patch @@ -0,0 +1,100 @@ +From 0ef152ec4827c61924b0e05d32e4ba44a8aa996f Mon Sep 17 00:00:00 2001 +From: Juan Quintela +Date: Tue, 14 Jan 2014 15:07:22 +0100 +Subject: [PATCH 11/40] memory: cpu_physical_memory_set_dirty_range() always dirty all flags + +RH-Author: Juan Quintela +Message-id: <1389712071-23303-12-git-send-email-quintela@redhat.com> +Patchwork-id: 56666 +O-Subject: [RHEL7 qemu-kvm PATCH 11/40] memory: cpu_physical_memory_set_dirty_range() always dirty all flags +Bugzilla: 997559 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Orit Wasserman +RH-Acked-by: Dr. David Alan Gilbert (git) + +So remove the flag argument and do it directly. After this change, +there is nothing else using cpu_physical_memory_set_dirty_flags() so +remove it. + +Signed-off-by: Juan Quintela +Reviewed-by: Eric Blake +Reviewed-by: Orit Wasserman +(cherry picked from commit 75218e7f2b7f052c6f44489afaf45b3ea4369f45) +Signed-off-by: Juan Quintela +--- + exec.c | 2 +- + include/exec/memory-internal.h | 11 ++--------- + memory.c | 2 +- + 3 files changed, 4 insertions(+), 11 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + exec.c | 2 +- + include/exec/memory-internal.h | 11 ++--------- + memory.c | 2 +- + 3 files changed, 4 insertions(+), 11 deletions(-) + +diff --git a/exec.c b/exec.c +index 178ed4a..069e082 100644 +--- a/exec.c ++++ b/exec.c +@@ -1162,7 +1162,7 @@ ram_addr_t qemu_ram_alloc_from_ptr(ram_addr_t size, void *host, + last_ram_offset() >> TARGET_PAGE_BITS); + memset(ram_list.phys_dirty + (new_block->offset >> TARGET_PAGE_BITS), + 0, size >> TARGET_PAGE_BITS); +- cpu_physical_memory_set_dirty_range(new_block->offset, size, 0xff); ++ cpu_physical_memory_set_dirty_range(new_block->offset, size); + + qemu_ram_setup_dump(new_block->host, size); + qemu_madvise(new_block->host, size, QEMU_MADV_HUGEPAGE); +diff --git a/include/exec/memory-internal.h b/include/exec/memory-internal.h +index 55b4022..794fabd 100644 +--- a/include/exec/memory-internal.h ++++ b/include/exec/memory-internal.h +@@ -84,12 +84,6 @@ static inline int cpu_physical_memory_get_dirty(ram_addr_t start, + return ret; + } + +-static inline void cpu_physical_memory_set_dirty_flags(ram_addr_t addr, +- int dirty_flags) +-{ +- ram_list.phys_dirty[addr >> TARGET_PAGE_BITS] |= dirty_flags; +-} +- + static inline void cpu_physical_memory_set_dirty_flag(ram_addr_t addr, + int dirty_flag) + { +@@ -112,15 +106,14 @@ static inline int cpu_physical_memory_clear_dirty_flags(ram_addr_t addr, + } + + static inline void cpu_physical_memory_set_dirty_range(ram_addr_t start, +- ram_addr_t length, +- int dirty_flags) ++ ram_addr_t length) + { + ram_addr_t addr, end; + + end = TARGET_PAGE_ALIGN(start + length); + start &= TARGET_PAGE_MASK; + for (addr = start; addr < end; addr += TARGET_PAGE_SIZE) { +- cpu_physical_memory_set_dirty_flags(addr, dirty_flags); ++ cpu_physical_memory_set_dirty(addr); + } + xen_modified_memory(addr, length); + } +diff --git a/memory.c b/memory.c +index fc11859..e7a454f 100644 +--- a/memory.c ++++ b/memory.c +@@ -1078,7 +1078,7 @@ void memory_region_set_dirty(MemoryRegion *mr, hwaddr addr, + hwaddr size) + { + assert(mr->terminates); +- cpu_physical_memory_set_dirty_range(mr->ram_addr + addr, size, -1); ++ cpu_physical_memory_set_dirty_range(mr->ram_addr + addr, size); + } + + bool memory_region_test_and_clear_dirty(MemoryRegion *mr, hwaddr addr, +-- +1.7.1 + diff --git a/SOURCES/kvm-memory-cpu_physical_memory_set_dirty_range-now-uses-.patch b/SOURCES/kvm-memory-cpu_physical_memory_set_dirty_range-now-uses-.patch new file mode 100644 index 0000000..55689df --- /dev/null +++ b/SOURCES/kvm-memory-cpu_physical_memory_set_dirty_range-now-uses-.patch @@ -0,0 +1,67 @@ +From 07e1f1362ec868bde3cd99d55541e572ae5aa300 Mon Sep 17 00:00:00 2001 +From: Juan Quintela +Date: Tue, 14 Jan 2014 15:07:37 +0100 +Subject: [PATCH 26/40] memory: cpu_physical_memory_set_dirty_range() now uses bitmap operations + +RH-Author: Juan Quintela +Message-id: <1389712071-23303-27-git-send-email-quintela@redhat.com> +Patchwork-id: 56681 +O-Subject: [RHEL7 qemu-kvm PATCH 26/40] memory: cpu_physical_memory_set_dirty_range() now uses bitmap operations +Bugzilla: 997559 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Orit Wasserman +RH-Acked-by: Dr. David Alan Gilbert (git) + +We were setting a range of bits, so use bitmap_set(). + +Note: xen has always been wrong, and should have used start instead +of addr from the beginning. + +Signed-off-by: Juan Quintela +Reviewed-by: Eric Blake +Reviewed-by: Orit Wasserman +(cherry picked from commit 5b9a3a5f77e3458af6c1bb0654ee0f32936a5594) +Signed-off-by: Juan Quintela +--- + include/exec/memory-internal.h | 19 +++++++------------ + 1 file changed, 7 insertions(+), 12 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + include/exec/memory-internal.h | 19 +++++++------------ + 1 files changed, 7 insertions(+), 12 deletions(-) + +diff --git a/include/exec/memory-internal.h b/include/exec/memory-internal.h +index 1eda526..9d32a5a 100644 +--- a/include/exec/memory-internal.h ++++ b/include/exec/memory-internal.h +@@ -90,19 +90,14 @@ static inline void cpu_physical_memory_set_dirty_flag(ram_addr_t addr, + static inline void cpu_physical_memory_set_dirty_range(ram_addr_t start, + ram_addr_t length) + { +- ram_addr_t addr, end; ++ unsigned long end, page; + +- end = TARGET_PAGE_ALIGN(start + length); +- start &= TARGET_PAGE_MASK; +- for (addr = start; addr < end; addr += TARGET_PAGE_SIZE) { +- set_bit(addr >> TARGET_PAGE_BITS, +- ram_list.dirty_memory[DIRTY_MEMORY_MIGRATION]); +- set_bit(addr >> TARGET_PAGE_BITS, +- ram_list.dirty_memory[DIRTY_MEMORY_VGA]); +- set_bit(addr >> TARGET_PAGE_BITS, +- ram_list.dirty_memory[DIRTY_MEMORY_CODE]); +- } +- xen_modified_memory(addr, length); ++ end = TARGET_PAGE_ALIGN(start + length) >> TARGET_PAGE_BITS; ++ page = start >> TARGET_PAGE_BITS; ++ bitmap_set(ram_list.dirty_memory[DIRTY_MEMORY_MIGRATION], page, end - page); ++ bitmap_set(ram_list.dirty_memory[DIRTY_MEMORY_VGA], page, end - page); ++ bitmap_set(ram_list.dirty_memory[DIRTY_MEMORY_CODE], page, end - page); ++ xen_modified_memory(start, length); + } + + static inline void cpu_physical_memory_clear_dirty_range(ram_addr_t start, +-- +1.7.1 + diff --git a/SOURCES/kvm-memory-cpu_physical_memory_set_dirty_range-return-vo.patch b/SOURCES/kvm-memory-cpu_physical_memory_set_dirty_range-return-vo.patch new file mode 100644 index 0000000..9e612bc --- /dev/null +++ b/SOURCES/kvm-memory-cpu_physical_memory_set_dirty_range-return-vo.patch @@ -0,0 +1,44 @@ +From 9a690622915308d0832e5565b4f0ce66563fa09f Mon Sep 17 00:00:00 2001 +From: Juan Quintela +Date: Tue, 14 Jan 2014 15:07:14 +0100 +Subject: [PATCH 03/40] memory: cpu_physical_memory_set_dirty_range() return void + +RH-Author: Juan Quintela +Message-id: <1389712071-23303-4-git-send-email-quintela@redhat.com> +Patchwork-id: 56659 +O-Subject: [RHEL7 qemu-kvm PATCH 03/40] memory: cpu_physical_memory_set_dirty_range() return void +Bugzilla: 997559 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Orit Wasserman +RH-Acked-by: Dr. David Alan Gilbert (git) + +Signed-off-by: Juan Quintela +Reviewed-by: Orit Wasserman +Reviewed-by: Eric Blake +(cherry picked from commit 78d0042642a415b56b3c53a6044f30eff47bf69c) +Signed-off-by: Juan Quintela +--- + memory.c | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +Signed-off-by: Miroslav Rezanina +--- + memory.c | 2 +- + 1 files changed, 1 insertions(+), 1 deletions(-) + +diff --git a/memory.c b/memory.c +index 75ca281..fc11859 100644 +--- a/memory.c ++++ b/memory.c +@@ -1078,7 +1078,7 @@ void memory_region_set_dirty(MemoryRegion *mr, hwaddr addr, + hwaddr size) + { + assert(mr->terminates); +- return cpu_physical_memory_set_dirty_range(mr->ram_addr + addr, size, -1); ++ cpu_physical_memory_set_dirty_range(mr->ram_addr + addr, size, -1); + } + + bool memory_region_test_and_clear_dirty(MemoryRegion *mr, hwaddr addr, +-- +1.7.1 + diff --git a/SOURCES/kvm-memory-cpu_physical_memory_set_dirty_tracking-should.patch b/SOURCES/kvm-memory-cpu_physical_memory_set_dirty_tracking-should.patch new file mode 100644 index 0000000..faa880e --- /dev/null +++ b/SOURCES/kvm-memory-cpu_physical_memory_set_dirty_tracking-should.patch @@ -0,0 +1,75 @@ +From 5446e66dd3df0b07dd1d3554ce3356ae7f6e3fed Mon Sep 17 00:00:00 2001 +From: Juan Quintela +Date: Tue, 14 Jan 2014 15:07:42 +0100 +Subject: [PATCH 31/40] memory: cpu_physical_memory_set_dirty_tracking() should return void + +RH-Author: Juan Quintela +Message-id: <1389712071-23303-32-git-send-email-quintela@redhat.com> +Patchwork-id: 56684 +O-Subject: [RHEL7 qemu-kvm PATCH 31/40] memory: cpu_physical_memory_set_dirty_tracking() should return void +Bugzilla: 997559 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Orit Wasserman +RH-Acked-by: Dr. David Alan Gilbert (git) + +Result was always 0, and not used anywhere. Once there, use bool type +for the parameter. + +Signed-off-by: Juan Quintela +Reviewed-by: Eric Blake +Reviewed-by: Orit Wasserman +(cherry picked from commit 981fdf2353d5e708adbe5227260d5e46eececc05) +Signed-off-by: Juan Quintela +--- + exec.c | 10 ++++------ + 1 file changed, 4 insertions(+), 6 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + exec.c | 10 ++++------ + 1 files changed, 4 insertions(+), 6 deletions(-) + +diff --git a/exec.c b/exec.c +index 443de79..2bf71bf 100644 +--- a/exec.c ++++ b/exec.c +@@ -55,7 +55,7 @@ + //#define DEBUG_SUBPAGE + + #if !defined(CONFIG_USER_ONLY) +-static int in_migration; ++static bool in_migration; + + RAMList ram_list = { .blocks = QTAILQ_HEAD_INITIALIZER(ram_list.blocks) }; + +@@ -609,11 +609,9 @@ void cpu_physical_memory_reset_dirty(ram_addr_t start, ram_addr_t length, + } + } + +-static int cpu_physical_memory_set_dirty_tracking(int enable) ++static void cpu_physical_memory_set_dirty_tracking(bool enable) + { +- int ret = 0; + in_migration = enable; +- return ret; + } + + hwaddr memory_region_section_get_iotlb(CPUArchState *env, +@@ -1774,12 +1772,12 @@ static void tcg_commit(MemoryListener *listener) + + static void core_log_global_start(MemoryListener *listener) + { +- cpu_physical_memory_set_dirty_tracking(1); ++ cpu_physical_memory_set_dirty_tracking(true); + } + + static void core_log_global_stop(MemoryListener *listener) + { +- cpu_physical_memory_set_dirty_tracking(0); ++ cpu_physical_memory_set_dirty_tracking(false); + } + + static void io_region_add(MemoryListener *listener, +-- +1.7.1 + diff --git a/SOURCES/kvm-memory-create-function-to-set-a-single-dirty-bit.patch b/SOURCES/kvm-memory-create-function-to-set-a-single-dirty-bit.patch new file mode 100644 index 0000000..3c6f4be --- /dev/null +++ b/SOURCES/kvm-memory-create-function-to-set-a-single-dirty-bit.patch @@ -0,0 +1,63 @@ +From 7c7071e191d00c972db07e90eddb40ad9214fe59 Mon Sep 17 00:00:00 2001 +From: Juan Quintela +Date: Tue, 14 Jan 2014 15:07:16 +0100 +Subject: [PATCH 05/40] memory: create function to set a single dirty bit + +RH-Author: Juan Quintela +Message-id: <1389712071-23303-6-git-send-email-quintela@redhat.com> +Patchwork-id: 56657 +O-Subject: [RHEL7 qemu-kvm PATCH 05/40] memory: create function to set a single dirty bit +Bugzilla: 997559 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Orit Wasserman +RH-Acked-by: Dr. David Alan Gilbert (git) + +Signed-off-by: Juan Quintela +Reviewed-by: Orit Wasserman +Reviewed-by: Eric Blake +(cherry picked from commit a1390db4df32ad95bf7854944180d2343f7f6368) +Signed-off-by: Juan Quintela +--- + cputlb.c | 2 +- + include/exec/memory-internal.h | 6 ++++++ + 2 files changed, 7 insertions(+), 1 deletion(-) + +Signed-off-by: Miroslav Rezanina +--- + cputlb.c | 2 +- + include/exec/memory-internal.h | 6 ++++++ + 2 files changed, 7 insertions(+), 1 deletions(-) + +diff --git a/cputlb.c b/cputlb.c +index aba7e44..84e83e0 100644 +--- a/cputlb.c ++++ b/cputlb.c +@@ -137,7 +137,7 @@ void tlb_protect_code(ram_addr_t ram_addr) + void tlb_unprotect_code_phys(CPUArchState *env, ram_addr_t ram_addr, + target_ulong vaddr) + { +- cpu_physical_memory_set_dirty_flags(ram_addr, CODE_DIRTY_FLAG); ++ cpu_physical_memory_set_dirty_flag(ram_addr, CODE_DIRTY_FLAG); + } + + static bool tlb_is_dirty_ram(CPUTLBEntry *tlbe) +diff --git a/include/exec/memory-internal.h b/include/exec/memory-internal.h +index eac149a..4f476d2 100644 +--- a/include/exec/memory-internal.h ++++ b/include/exec/memory-internal.h +@@ -85,6 +85,12 @@ static inline void cpu_physical_memory_set_dirty_flags(ram_addr_t addr, + ram_list.phys_dirty[addr >> TARGET_PAGE_BITS] |= dirty_flags; + } + ++static inline void cpu_physical_memory_set_dirty_flag(ram_addr_t addr, ++ int dirty_flag) ++{ ++ ram_list.phys_dirty[addr >> TARGET_PAGE_BITS] |= dirty_flag; ++} ++ + static inline void cpu_physical_memory_set_dirty(ram_addr_t addr) + { + cpu_physical_memory_set_dirty_flags(addr, 0xff); +-- +1.7.1 + diff --git a/SOURCES/kvm-memory-make-cpu_physical_memory_get_dirty-the-main-f.patch b/SOURCES/kvm-memory-make-cpu_physical_memory_get_dirty-the-main-f.patch new file mode 100644 index 0000000..71ae9f6 --- /dev/null +++ b/SOURCES/kvm-memory-make-cpu_physical_memory_get_dirty-the-main-f.patch @@ -0,0 +1,91 @@ +From b48448f26497b1d92d21cc5bf5bd662f9759b65d Mon Sep 17 00:00:00 2001 +From: Juan Quintela +Date: Tue, 14 Jan 2014 15:07:33 +0100 +Subject: [PATCH 22/40] memory: make cpu_physical_memory_get_dirty() the main function + +RH-Author: Juan Quintela +Message-id: <1389712071-23303-23-git-send-email-quintela@redhat.com> +Patchwork-id: 56678 +O-Subject: [RHEL7 qemu-kvm PATCH 22/40] memory: make cpu_physical_memory_get_dirty() the main function +Bugzilla: 997559 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Orit Wasserman +RH-Acked-by: Dr. David Alan Gilbert (git) + +And make cpu_physical_memory_get_dirty_flag() to use it. It used to +be the other way around. + +Signed-off-by: Juan Quintela +Reviewed-by: Eric Blake +Reviewed-by: Orit Wasserman +(cherry picked from commit 9f2c43e41a13605d3ab1e37ba433aa669652fb6b) +Signed-off-by: Juan Quintela +--- + include/exec/memory-internal.h | 36 +++++++++++++++++++----------------- + 1 file changed, 19 insertions(+), 17 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + include/exec/memory-internal.h | 36 +++++++++++++++++++----------------- + 1 files changed, 19 insertions(+), 17 deletions(-) + +diff --git a/include/exec/memory-internal.h b/include/exec/memory-internal.h +index e8fae2a..9099561 100644 +--- a/include/exec/memory-internal.h ++++ b/include/exec/memory-internal.h +@@ -49,11 +49,28 @@ ram_addr_t qemu_ram_alloc(ram_addr_t size, MemoryRegion *mr); + void qemu_ram_free(ram_addr_t addr); + void qemu_ram_free_from_ptr(ram_addr_t addr); + ++static inline int cpu_physical_memory_get_dirty(ram_addr_t start, ++ ram_addr_t length, ++ unsigned client) ++{ ++ int ret = 0; ++ ram_addr_t addr, end; ++ ++ assert(client < DIRTY_MEMORY_NUM); ++ ++ end = TARGET_PAGE_ALIGN(start + length); ++ start &= TARGET_PAGE_MASK; ++ for (addr = start; addr < end; addr += TARGET_PAGE_SIZE) { ++ ret |= test_bit(addr >> TARGET_PAGE_BITS, ++ ram_list.dirty_memory[client]); ++ } ++ return ret; ++} ++ + static inline bool cpu_physical_memory_get_dirty_flag(ram_addr_t addr, + unsigned client) + { +- assert(client < DIRTY_MEMORY_NUM); +- return test_bit(addr >> TARGET_PAGE_BITS, ram_list.dirty_memory[client]); ++ return cpu_physical_memory_get_dirty(addr, 1, client); + } + + /* read dirty bit (return 0 or 1) */ +@@ -66,21 +83,6 @@ static inline bool cpu_physical_memory_is_dirty(ram_addr_t addr) + return vga && code && migration; + } + +-static inline int cpu_physical_memory_get_dirty(ram_addr_t start, +- ram_addr_t length, +- unsigned client) +-{ +- int ret = 0; +- ram_addr_t addr, end; +- +- end = TARGET_PAGE_ALIGN(start + length); +- start &= TARGET_PAGE_MASK; +- for (addr = start; addr < end; addr += TARGET_PAGE_SIZE) { +- ret |= cpu_physical_memory_get_dirty_flag(addr, client); +- } +- return ret; +-} +- + static inline void cpu_physical_memory_set_dirty_flag(ram_addr_t addr, + unsigned client) + { +-- +1.7.1 + diff --git a/SOURCES/kvm-memory-make-cpu_physical_memory_is_dirty-return-bool.patch b/SOURCES/kvm-memory-make-cpu_physical_memory_is_dirty-return-bool.patch new file mode 100644 index 0000000..6bba7bb --- /dev/null +++ b/SOURCES/kvm-memory-make-cpu_physical_memory_is_dirty-return-bool.patch @@ -0,0 +1,80 @@ +From 478863d3d5428211d0d64a9928484e0b1f5be8a4 Mon Sep 17 00:00:00 2001 +From: Juan Quintela +Date: Tue, 14 Jan 2014 15:07:19 +0100 +Subject: [PATCH 08/40] memory: make cpu_physical_memory_is_dirty return bool + +RH-Author: Juan Quintela +Message-id: <1389712071-23303-9-git-send-email-quintela@redhat.com> +Patchwork-id: 56664 +O-Subject: [RHEL7 qemu-kvm PATCH 08/40] memory: make cpu_physical_memory_is_dirty return bool +Bugzilla: 997559 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Orit Wasserman +RH-Acked-by: Dr. David Alan Gilbert (git) + +Signed-off-by: Juan Quintela +Reviewed-by: Eric Blake +Reviewed-by: Orit Wasserman +(cherry picked from commit 4f08cabe9e6efe8a50abc30cfa59e8470ad434d7) +Signed-off-by: Juan Quintela +--- + exec.c | 7 ++----- + include/exec/memory-internal.h | 8 ++++++-- + 2 files changed, 8 insertions(+), 7 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + exec.c | 7 ++----- + include/exec/memory-internal.h | 8 ++++++-- + 2 files changed, 8 insertions(+), 7 deletions(-) + +diff --git a/exec.c b/exec.c +index e993049..ea81329 100644 +--- a/exec.c ++++ b/exec.c +@@ -1480,11 +1480,8 @@ static const MemoryRegionOps rom_mem_ops = { + static void notdirty_mem_write(void *opaque, hwaddr ram_addr, + uint64_t val, unsigned size) + { +- int dirty_flags; +- dirty_flags = cpu_physical_memory_get_dirty_flags(ram_addr); + if (!cpu_physical_memory_get_dirty_flag(ram_addr, CODE_DIRTY_FLAG)) { + tb_invalidate_phys_page_fast(ram_addr, size); +- dirty_flags = cpu_physical_memory_get_dirty_flags(ram_addr); + } + switch (size) { + case 1: +@@ -1499,8 +1496,8 @@ static void notdirty_mem_write(void *opaque, hwaddr ram_addr, + default: + abort(); + } +- dirty_flags |= (0xff & ~CODE_DIRTY_FLAG); +- cpu_physical_memory_set_dirty_flags(ram_addr, dirty_flags); ++ cpu_physical_memory_set_dirty_flag(ram_addr, MIGRATION_DIRTY_FLAG); ++ cpu_physical_memory_set_dirty_flag(ram_addr, VGA_DIRTY_FLAG); + /* we remove the notdirty callback only if the code has been + flushed */ + if (cpu_physical_memory_is_dirty(ram_addr)) +diff --git a/include/exec/memory-internal.h b/include/exec/memory-internal.h +index 8872e36..dfc03e1 100644 +--- a/include/exec/memory-internal.h ++++ b/include/exec/memory-internal.h +@@ -65,9 +65,13 @@ static inline bool cpu_physical_memory_get_dirty_flag(ram_addr_t addr, + } + + /* read dirty bit (return 0 or 1) */ +-static inline int cpu_physical_memory_is_dirty(ram_addr_t addr) ++static inline bool cpu_physical_memory_is_dirty(ram_addr_t addr) + { +- return cpu_physical_memory_get_dirty_flags(addr) == 0xff; ++ bool vga = cpu_physical_memory_get_dirty_flag(addr, VGA_DIRTY_FLAG); ++ bool code = cpu_physical_memory_get_dirty_flag(addr, CODE_DIRTY_FLAG); ++ bool migration = ++ cpu_physical_memory_get_dirty_flag(addr, MIGRATION_DIRTY_FLAG); ++ return vga && code && migration; + } + + static inline int cpu_physical_memory_get_dirty(ram_addr_t start, +-- +1.7.1 + diff --git a/SOURCES/kvm-memory-make-cpu_physical_memory_reset_dirty-take-a-l.patch b/SOURCES/kvm-memory-make-cpu_physical_memory_reset_dirty-take-a-l.patch new file mode 100644 index 0000000..36f5c35 --- /dev/null +++ b/SOURCES/kvm-memory-make-cpu_physical_memory_reset_dirty-take-a-l.patch @@ -0,0 +1,154 @@ +From 60aa55e63ee56107ed2fd639b08ee166ca0b6264 Mon Sep 17 00:00:00 2001 +From: Juan Quintela +Date: Tue, 14 Jan 2014 15:07:40 +0100 +Subject: [PATCH 29/40] memory: make cpu_physical_memory_reset_dirty() take a length parameter + +RH-Author: Juan Quintela +Message-id: <1389712071-23303-30-git-send-email-quintela@redhat.com> +Patchwork-id: 56683 +O-Subject: [RHEL7 qemu-kvm PATCH 29/40] memory: make cpu_physical_memory_reset_dirty() take a length parameter +Bugzilla: 997559 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Orit Wasserman +RH-Acked-by: Dr. David Alan Gilbert (git) + +We have an end parameter in all the callers, and this make it coherent +with the rest of cpu_physical_memory_* functions, that also take a +length parameter. + +Once here, move the start/end calculation to +tlb_reset_dirty_range_all() as we don't need it here anymore. + +Signed-off-by: Juan Quintela +Reviewed-by: Eric Blake +Reviewed-by: Orit Wasserman +(cherry picked from commit a2f4d5bef2cfde557d76fc45a40d2c89b6bed4e4) + +Conflicts: + exec.c + +Missing upstream commit: + +commit 041603fe5d4537cd165941f96bd76a31f7f662fd +Author: Paolo Bonzini +Date: Mon Sep 9 17:49:45 2013 +0200 + + exec: remove qemu_safe_ram_ptr + +Signed-off-by: Juan Quintela +--- + cputlb.c | 3 +-- + exec.c | 19 ++++++++----------- + include/exec/memory-internal.h | 2 +- + memory.c | 8 ++------ + 4 files changed, 12 insertions(+), 20 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + cputlb.c | 3 +-- + exec.c | 19 ++++++++----------- + include/exec/memory-internal.h | 2 +- + memory.c | 8 ++------ + 4 files changed, 12 insertions(+), 20 deletions(-) + +diff --git a/cputlb.c b/cputlb.c +index 04d7f14..44ec9bc 100644 +--- a/cputlb.c ++++ b/cputlb.c +@@ -127,8 +127,7 @@ void tlb_flush_page(CPUArchState *env, target_ulong addr) + can be detected */ + void tlb_protect_code(ram_addr_t ram_addr) + { +- cpu_physical_memory_reset_dirty(ram_addr, +- ram_addr + TARGET_PAGE_SIZE, ++ cpu_physical_memory_reset_dirty(ram_addr, TARGET_PAGE_SIZE, + DIRTY_MEMORY_CODE); + } + +diff --git a/exec.c b/exec.c +index ec01b0f..79ea3b2 100644 +--- a/exec.c ++++ b/exec.c +@@ -576,10 +576,13 @@ CPUArchState *cpu_copy(CPUArchState *env) + } + + #if !defined(CONFIG_USER_ONLY) +-static void tlb_reset_dirty_range_all(ram_addr_t start, ram_addr_t end, +- uintptr_t length) ++static void tlb_reset_dirty_range_all(ram_addr_t start, ram_addr_t length) + { +- uintptr_t start1; ++ ram_addr_t start1; ++ ram_addr_t end; ++ ++ end = TARGET_PAGE_ALIGN(start + length); ++ start &= TARGET_PAGE_MASK; + + /* we modify the TLB cache so that the dirty bit will be set again + when accessing the range */ +@@ -595,21 +598,15 @@ static void tlb_reset_dirty_range_all(ram_addr_t start, ram_addr_t end, + } + + /* Note: start and end must be within the same ram block. */ +-void cpu_physical_memory_reset_dirty(ram_addr_t start, ram_addr_t end, ++void cpu_physical_memory_reset_dirty(ram_addr_t start, ram_addr_t length, + unsigned client) + { +- uintptr_t length; +- +- start &= TARGET_PAGE_MASK; +- end = TARGET_PAGE_ALIGN(end); +- +- length = end - start; + if (length == 0) + return; + cpu_physical_memory_clear_dirty_range(start, length, client); + + if (tcg_enabled()) { +- tlb_reset_dirty_range_all(start, end, length); ++ tlb_reset_dirty_range_all(start, length); + } + } + +diff --git a/include/exec/memory-internal.h b/include/exec/memory-internal.h +index 416ce86..d2b85de 100644 +--- a/include/exec/memory-internal.h ++++ b/include/exec/memory-internal.h +@@ -111,7 +111,7 @@ static inline void cpu_physical_memory_clear_dirty_range(ram_addr_t start, + bitmap_clear(ram_list.dirty_memory[client], page, end - page); + } + +-void cpu_physical_memory_reset_dirty(ram_addr_t start, ram_addr_t end, ++void cpu_physical_memory_reset_dirty(ram_addr_t start, ram_addr_t length, + unsigned client); + + extern const IORangeOps memory_region_iorange_ops; +diff --git a/memory.c b/memory.c +index 2883da5..b49642b 100644 +--- a/memory.c ++++ b/memory.c +@@ -1087,9 +1087,7 @@ bool memory_region_test_and_clear_dirty(MemoryRegion *mr, hwaddr addr, + assert(mr->terminates); + ret = cpu_physical_memory_get_dirty(mr->ram_addr + addr, size, client); + if (ret) { +- cpu_physical_memory_reset_dirty(mr->ram_addr + addr, +- mr->ram_addr + addr + size, +- client); ++ cpu_physical_memory_reset_dirty(mr->ram_addr + addr, size, client); + } + return ret; + } +@@ -1133,9 +1131,7 @@ void memory_region_reset_dirty(MemoryRegion *mr, hwaddr addr, + hwaddr size, unsigned client) + { + assert(mr->terminates); +- cpu_physical_memory_reset_dirty(mr->ram_addr + addr, +- mr->ram_addr + addr + size, +- client); ++ cpu_physical_memory_reset_dirty(mr->ram_addr + addr, size, client); + } + + void *memory_region_get_ram_ptr(MemoryRegion *mr) +-- +1.7.1 + diff --git a/SOURCES/kvm-memory-make-sure-that-client-is-always-inside-range.patch b/SOURCES/kvm-memory-make-sure-that-client-is-always-inside-range.patch new file mode 100644 index 0000000..e91d5ac --- /dev/null +++ b/SOURCES/kvm-memory-make-sure-that-client-is-always-inside-range.patch @@ -0,0 +1,60 @@ +From 11b9b3f7b11d113e5789877dec1ab41be838c007 Mon Sep 17 00:00:00 2001 +From: Juan Quintela +Date: Tue, 14 Jan 2014 15:07:25 +0100 +Subject: [PATCH 14/40] memory: make sure that client is always inside range + +RH-Author: Juan Quintela +Message-id: <1389712071-23303-15-git-send-email-quintela@redhat.com> +Patchwork-id: 56669 +O-Subject: [RHEL7 qemu-kvm PATCH 14/40] memory: make sure that client is always inside range +Bugzilla: 997559 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Orit Wasserman +RH-Acked-by: Dr. David Alan Gilbert (git) + +Signed-off-by: Juan Quintela +Reviewed-by: Eric Blake +Reviewed-by: Orit Wasserman +(cherry picked from commit 7a5b558c9d061814f34d9b95d70d17ef75037937) +Signed-off-by: Juan Quintela +--- + include/exec/memory-internal.h | 4 ++++ + 1 file changed, 4 insertions(+) + +Signed-off-by: Miroslav Rezanina +--- + include/exec/memory-internal.h | 4 ++++ + 1 files changed, 4 insertions(+), 0 deletions(-) + +diff --git a/include/exec/memory-internal.h b/include/exec/memory-internal.h +index fbcd384..ef5de3e 100644 +--- a/include/exec/memory-internal.h ++++ b/include/exec/memory-internal.h +@@ -52,6 +52,7 @@ void qemu_ram_free_from_ptr(ram_addr_t addr); + static inline bool cpu_physical_memory_get_dirty_flag(ram_addr_t addr, + unsigned client) + { ++ assert(client < DIRTY_MEMORY_NUM); + return ram_list.phys_dirty[addr >> TARGET_PAGE_BITS] & (1 << client); + } + +@@ -83,6 +84,7 @@ static inline int cpu_physical_memory_get_dirty(ram_addr_t start, + static inline void cpu_physical_memory_set_dirty_flag(ram_addr_t addr, + unsigned client) + { ++ assert(client < DIRTY_MEMORY_NUM); + ram_list.phys_dirty[addr >> TARGET_PAGE_BITS] |= (1 << client); + } + +@@ -98,6 +100,8 @@ static inline int cpu_physical_memory_clear_dirty_flag(ram_addr_t addr, + { + int mask = ~(1 << client); + ++ assert(client < DIRTY_MEMORY_NUM); ++ + return ram_list.phys_dirty[addr >> TARGET_PAGE_BITS] &= mask; + } + +-- +1.7.1 + diff --git a/SOURCES/kvm-memory-move-bitmap-synchronization-to-its-own-functi.patch b/SOURCES/kvm-memory-move-bitmap-synchronization-to-its-own-functi.patch new file mode 100644 index 0000000..941e981 --- /dev/null +++ b/SOURCES/kvm-memory-move-bitmap-synchronization-to-its-own-functi.patch @@ -0,0 +1,129 @@ +From e484992052b63d94c3bcdce6f070eb55f635212b Mon Sep 17 00:00:00 2001 +From: Juan Quintela +Date: Tue, 14 Jan 2014 15:07:48 +0100 +Subject: [PATCH 37/40] memory: move bitmap synchronization to its own function +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +RH-Author: Juan Quintela +Message-id: <1389712071-23303-38-git-send-email-quintela@redhat.com> +Patchwork-id: 56692 +O-Subject: [RHEL7 qemu-kvm PATCH 37/40] memory: move bitmap synchronization to its own function +Bugzilla: 997559 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Orit Wasserman +RH-Acked-by: Dr. David Alan Gilbert (git) + +We want to have all the functions that handle directly the dirty +bitmap near. We will change it later. + +Signed-off-by: Juan Quintela +Reviewed-by: Orit Wasserman +(cherry picked from commit 5ff7fb77b3cee8e26648e4fdccb23a77c2a6d3c6) + +Conflicts: + kvm-all.c + +commit dd1750d7981cf9e38985c9dfa474dcdbbe236270 +Author: Andreas Färber +Date: Wed May 1 13:45:44 2013 +0200 + + kvm: Change kvm_cpu_synchronize_state() argument to CPUState + +Signed-off-by: Juan Quintela +--- + include/exec/ram_addr.h | 31 +++++++++++++++++++++++++++++++ + kvm-all.c | 26 ++------------------------ + 2 files changed, 33 insertions(+), 24 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + include/exec/ram_addr.h | 31 +++++++++++++++++++++++++++++++ + kvm-all.c | 28 +++------------------------- + 2 files changed, 34 insertions(+), 25 deletions(-) + +diff --git a/include/exec/ram_addr.h b/include/exec/ram_addr.h +index 0caa239..9962e12 100644 +--- a/include/exec/ram_addr.h ++++ b/include/exec/ram_addr.h +@@ -78,6 +78,37 @@ static inline void cpu_physical_memory_set_dirty_range(ram_addr_t start, + xen_modified_memory(start, length); + } + ++static inline void cpu_physical_memory_set_dirty_lebitmap(unsigned long *bitmap, ++ ram_addr_t start, ++ ram_addr_t pages) ++{ ++ unsigned int i, j; ++ unsigned long page_number, c; ++ hwaddr addr; ++ ram_addr_t ram_addr; ++ unsigned int len = (pages + HOST_LONG_BITS - 1) / HOST_LONG_BITS; ++ unsigned long hpratio = getpagesize() / TARGET_PAGE_SIZE; ++ ++ /* ++ * bitmap-traveling is faster than memory-traveling (for addr...) ++ * especially when most of the memory is not dirty. ++ */ ++ for (i = 0; i < len; i++) { ++ if (bitmap[i] != 0) { ++ c = leul_to_cpu(bitmap[i]); ++ do { ++ j = ffsl(c) - 1; ++ c &= ~(1ul << j); ++ page_number = (i * HOST_LONG_BITS + j) * hpratio; ++ addr = page_number * TARGET_PAGE_SIZE; ++ ram_addr = start + addr; ++ cpu_physical_memory_set_dirty_range(ram_addr, ++ TARGET_PAGE_SIZE * hpratio); ++ } while (c != 0); ++ } ++ } ++} ++ + static inline void cpu_physical_memory_clear_dirty_range(ram_addr_t start, + ram_addr_t length, + unsigned client) +diff --git a/kvm-all.c b/kvm-all.c +index d3aa869..19acd58 100644 +--- a/kvm-all.c ++++ b/kvm-all.c +@@ -365,32 +365,10 @@ static int kvm_set_migration_log(int enable) + static int kvm_get_dirty_pages_log_range(MemoryRegionSection *section, + unsigned long *bitmap) + { +- unsigned int i, j; +- unsigned long page_number, c; +- hwaddr addr; + ram_addr_t start = section->offset_within_region + section->mr->ram_addr; +- ram_addr_t ram_addr; +- unsigned int len = ((section->size / getpagesize()) + HOST_LONG_BITS - 1) / HOST_LONG_BITS; +- unsigned long hpratio = getpagesize() / TARGET_PAGE_SIZE; ++ ram_addr_t pages = section->size / getpagesize(); + +- /* +- * bitmap-traveling is faster than memory-traveling (for addr...) +- * especially when most of the memory is not dirty. +- */ +- for (i = 0; i < len; i++) { +- if (bitmap[i] != 0) { +- c = leul_to_cpu(bitmap[i]); +- do { +- j = ffsl(c) - 1; +- c &= ~(1ul << j); +- page_number = (i * HOST_LONG_BITS + j) * hpratio; +- addr = page_number * TARGET_PAGE_SIZE; +- ram_addr = start + addr; +- cpu_physical_memory_set_dirty_range(ram_addr, +- TARGET_PAGE_SIZE * hpratio); +- } while (c != 0); +- } +- } ++ cpu_physical_memory_set_dirty_lebitmap(bitmap, start, pages); + return 0; + } + +-- +1.7.1 + diff --git a/SOURCES/kvm-memory-move-private-types-to-exec.c.patch b/SOURCES/kvm-memory-move-private-types-to-exec.c.patch new file mode 100644 index 0000000..9f42fee --- /dev/null +++ b/SOURCES/kvm-memory-move-private-types-to-exec.c.patch @@ -0,0 +1,89 @@ +From 1c6276766eb0cb15ebefbf14f81accd3fe7716bc Mon Sep 17 00:00:00 2001 +From: Juan Quintela +Date: Tue, 14 Jan 2014 15:07:43 +0100 +Subject: [PATCH 32/40] memory: move private types to exec.c + +RH-Author: Juan Quintela +Message-id: <1389712071-23303-33-git-send-email-quintela@redhat.com> +Patchwork-id: 56687 +O-Subject: [RHEL7 qemu-kvm PATCH 32/40] memory: move private types to exec.c +Bugzilla: 997559 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Orit Wasserman +RH-Acked-by: Dr. David Alan Gilbert (git) + +From: Paolo Bonzini + +Signed-off-by: Paolo Bonzini +(cherry picked from commit 1db8abb10243abe969a2ba307664ba51b60fcac6) +Signed-off-by: Juan Quintela +--- + exec.c | 16 ++++++++++++++++ + include/exec/memory-internal.h | 15 --------------- + 2 files changed, 16 insertions(+), 15 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + exec.c | 16 ++++++++++++++++ + include/exec/memory-internal.h | 15 --------------- + 2 files changed, 16 insertions(+), 15 deletions(-) + +diff --git a/exec.c b/exec.c +index 2bf71bf..12adb12 100644 +--- a/exec.c ++++ b/exec.c +@@ -82,6 +82,22 @@ int use_icount; + + #if !defined(CONFIG_USER_ONLY) + ++typedef struct PhysPageEntry PhysPageEntry; ++ ++struct PhysPageEntry { ++ uint16_t is_leaf : 1; ++ /* index into phys_sections (is_leaf) or phys_map_nodes (!is_leaf) */ ++ uint16_t ptr : 15; ++}; ++ ++struct AddressSpaceDispatch { ++ /* This is a multi-level map on the physical address space. ++ * The bottom level has pointers to MemoryRegionSections. ++ */ ++ PhysPageEntry phys_map; ++ MemoryListener listener; ++}; ++ + static MemoryRegionSection *phys_sections; + static unsigned phys_sections_nb, phys_sections_nb_alloc; + static uint16_t phys_section_unassigned; +diff --git a/include/exec/memory-internal.h b/include/exec/memory-internal.h +index d2b85de..327d54e 100644 +--- a/include/exec/memory-internal.h ++++ b/include/exec/memory-internal.h +@@ -22,24 +22,9 @@ + #ifndef CONFIG_USER_ONLY + #include "hw/xen/xen.h" + +-typedef struct PhysPageEntry PhysPageEntry; +- +-struct PhysPageEntry { +- uint16_t is_leaf : 1; +- /* index into phys_sections (is_leaf) or phys_map_nodes (!is_leaf) */ +- uint16_t ptr : 15; +-}; + + typedef struct AddressSpaceDispatch AddressSpaceDispatch; + +-struct AddressSpaceDispatch { +- /* This is a multi-level map on the physical address space. +- * The bottom level has pointers to MemoryRegionSections. +- */ +- PhysPageEntry phys_map; +- MemoryListener listener; +-}; +- + void address_space_init_dispatch(AddressSpace *as); + void address_space_destroy_dispatch(AddressSpace *as); + +-- +1.7.1 + diff --git a/SOURCES/kvm-memory-only-resize-dirty-bitmap-when-memory-size-inc.patch b/SOURCES/kvm-memory-only-resize-dirty-bitmap-when-memory-size-inc.patch new file mode 100644 index 0000000..fca8c2d --- /dev/null +++ b/SOURCES/kvm-memory-only-resize-dirty-bitmap-when-memory-size-inc.patch @@ -0,0 +1,62 @@ +From 1e5621a56dcf27b1b9d04bc749e7fbeaa1e17729 Mon Sep 17 00:00:00 2001 +From: Juan Quintela +Date: Tue, 14 Jan 2014 15:07:26 +0100 +Subject: [PATCH 15/40] memory: only resize dirty bitmap when memory size increases + +RH-Author: Juan Quintela +Message-id: <1389712071-23303-16-git-send-email-quintela@redhat.com> +Patchwork-id: 56672 +O-Subject: [RHEL7 qemu-kvm PATCH 15/40] memory: only resize dirty bitmap when memory size increases +Bugzilla: 997559 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Orit Wasserman +RH-Acked-by: Dr. David Alan Gilbert (git) + +Signed-off-by: Juan Quintela +Reviewed-by: Eric Blake +Reviewed-by: Orit Wasserman +(cherry picked from commit 2152f5ca782e51a4d05a1f7d9bfa83286323cbc9) +Signed-off-by: Juan Quintela +--- + exec.c | 12 +++++++++--- + 1 file changed, 9 insertions(+), 3 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + exec.c | 12 +++++++++--- + 1 files changed, 9 insertions(+), 3 deletions(-) + +diff --git a/exec.c b/exec.c +index 8942d50..be99d45 100644 +--- a/exec.c ++++ b/exec.c +@@ -1098,6 +1098,9 @@ ram_addr_t qemu_ram_alloc_from_ptr(ram_addr_t size, void *host, + MemoryRegion *mr) + { + RAMBlock *block, *new_block; ++ ram_addr_t old_ram_size, new_ram_size; ++ ++ old_ram_size = last_ram_offset() >> TARGET_PAGE_BITS; + + size = TARGET_PAGE_ALIGN(size); + new_block = g_malloc0(sizeof(*new_block)); +@@ -1158,10 +1161,13 @@ ram_addr_t qemu_ram_alloc_from_ptr(ram_addr_t size, void *host, + ram_list.version++; + qemu_mutex_unlock_ramlist(); + +- ram_list.phys_dirty = g_realloc(ram_list.phys_dirty, +- last_ram_offset() >> TARGET_PAGE_BITS); +- memset(ram_list.phys_dirty + (new_block->offset >> TARGET_PAGE_BITS), ++ new_ram_size = last_ram_offset() >> TARGET_PAGE_BITS; ++ ++ if (new_ram_size > old_ram_size) { ++ ram_list.phys_dirty = g_realloc(ram_list.phys_dirty, new_ram_size); ++ memset(ram_list.phys_dirty + (new_block->offset >> TARGET_PAGE_BITS), + 0, size >> TARGET_PAGE_BITS); ++ } + cpu_physical_memory_set_dirty_range(new_block->offset, size); + + qemu_ram_setup_dump(new_block->host, size); +-- +1.7.1 + diff --git a/SOURCES/kvm-memory-s-dirty-clean-in-cpu_physical_memory_is_dirty.patch b/SOURCES/kvm-memory-s-dirty-clean-in-cpu_physical_memory_is_dirty.patch new file mode 100644 index 0000000..9206ba7 --- /dev/null +++ b/SOURCES/kvm-memory-s-dirty-clean-in-cpu_physical_memory_is_dirty.patch @@ -0,0 +1,134 @@ +From 8683104151659e4d210bdeb2eaf9da667b005fd2 Mon Sep 17 00:00:00 2001 +From: Juan Quintela +Date: Tue, 14 Jan 2014 15:07:39 +0100 +Subject: [PATCH 28/40] memory: s/dirty/clean/ in cpu_physical_memory_is_dirty() + +RH-Author: Juan Quintela +Message-id: <1389712071-23303-29-git-send-email-quintela@redhat.com> +Patchwork-id: 56682 +O-Subject: [RHEL7 qemu-kvm PATCH 28/40] memory: s/dirty/clean/ in cpu_physical_memory_is_dirty() +Bugzilla: 997559 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Orit Wasserman +RH-Acked-by: Dr. David Alan Gilbert (git) + +All uses except one really want the other meaning. + +Signed-off-by: Juan Quintela +Reviewed-by: Eric Blake +Reviewed-by: Orit Wasserman +(cherry picked from commit a2cd8c852d2d8c2a084b68b2470f214d6726f6d2) + +Conflicts: + cputlb.c + exec.c + +Missing upstream commit: + +commit 149f54b53b7666a3facd45e86eece60ce7d3b114 +Author: Paolo Bonzini +Date: Fri May 24 12:59:37 2013 +0200 + + memory: add address_space_translate + +and + +commit 0cac1b66c88c4cd3ec1d358091486787837215a3 +Author: Blue Swirl +Date: Mon Apr 9 16:50:52 2012 +0000 + + cputlb: move TLB handling to a separate file + +is what remove tlb_udate_dirty() that we have to change + +Signed-off-by: Juan Quintela +--- + cputlb.c | 4 ++-- + exec.c | 6 +++--- + include/exec/memory-internal.h | 5 ++--- + 3 files changed, 7 insertions(+), 8 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + cputlb.c | 4 ++-- + exec.c | 6 +++--- + include/exec/memory-internal.h | 5 ++--- + 3 files changed, 7 insertions(+), 8 deletions(-) + +diff --git a/cputlb.c b/cputlb.c +index 9c89c01..04d7f14 100644 +--- a/cputlb.c ++++ b/cputlb.c +@@ -167,7 +167,7 @@ static inline void tlb_update_dirty(CPUTLBEntry *tlb_entry) + p = (void *)(uintptr_t)((tlb_entry->addr_write & TARGET_PAGE_MASK) + + tlb_entry->addend); + ram_addr = qemu_ram_addr_from_host_nofail(p); +- if (!cpu_physical_memory_is_dirty(ram_addr)) { ++ if (cpu_physical_memory_is_clean(ram_addr)) { + tlb_entry->addr_write |= TLB_NOTDIRTY; + } + } +@@ -300,7 +300,7 @@ void tlb_set_page(CPUArchState *env, target_ulong vaddr, + /* Write access calls the I/O callback. */ + te->addr_write = address | TLB_MMIO; + } else if (memory_region_is_ram(section->mr) +- && !cpu_physical_memory_is_dirty( ++ && cpu_physical_memory_is_clean( + section->mr->ram_addr + + memory_region_section_addr(section, paddr))) { + te->addr_write = address | TLB_NOTDIRTY; +diff --git a/exec.c b/exec.c +index 77c2a0a..ec01b0f 100644 +--- a/exec.c ++++ b/exec.c +@@ -1509,7 +1509,7 @@ static void notdirty_mem_write(void *opaque, hwaddr ram_addr, + cpu_physical_memory_set_dirty_flag(ram_addr, DIRTY_MEMORY_VGA); + /* we remove the notdirty callback only if the code has been + flushed */ +- if (cpu_physical_memory_is_dirty(ram_addr)) ++ if (!cpu_physical_memory_is_clean(ram_addr)) + tlb_set_dirty(cpu_single_env, cpu_single_env->mem_io_vaddr); + } + +@@ -1924,7 +1924,7 @@ int cpu_memory_rw_debug(CPUArchState *env, target_ulong addr, + static void invalidate_and_set_dirty(hwaddr addr, + hwaddr length) + { +- if (!cpu_physical_memory_is_dirty(addr)) { ++ if (cpu_physical_memory_is_clean(addr)) { + /* invalidate code */ + tb_invalidate_phys_page_range(addr, addr + length, 0); + /* set dirty bit */ +@@ -2440,7 +2440,7 @@ void stl_phys_notdirty(hwaddr addr, uint32_t val) + stl_p(ptr, val); + + if (unlikely(in_migration)) { +- if (!cpu_physical_memory_is_dirty(addr1)) { ++ if (cpu_physical_memory_is_clean(addr1)) { + /* invalidate code */ + tb_invalidate_phys_page_range(addr1, addr1 + 4, 0); + /* set dirty bit */ +diff --git a/include/exec/memory-internal.h b/include/exec/memory-internal.h +index 94bd6af..416ce86 100644 +--- a/include/exec/memory-internal.h ++++ b/include/exec/memory-internal.h +@@ -70,14 +70,13 @@ static inline bool cpu_physical_memory_get_dirty_flag(ram_addr_t addr, + return cpu_physical_memory_get_dirty(addr, 1, client); + } + +-/* read dirty bit (return 0 or 1) */ +-static inline bool cpu_physical_memory_is_dirty(ram_addr_t addr) ++static inline bool cpu_physical_memory_is_clean(ram_addr_t addr) + { + bool vga = cpu_physical_memory_get_dirty_flag(addr, DIRTY_MEMORY_VGA); + bool code = cpu_physical_memory_get_dirty_flag(addr, DIRTY_MEMORY_CODE); + bool migration = + cpu_physical_memory_get_dirty_flag(addr, DIRTY_MEMORY_MIGRATION); +- return vga && code && migration; ++ return !(vga && code && migration); + } + + static inline void cpu_physical_memory_set_dirty_flag(ram_addr_t addr, +-- +1.7.1 + diff --git a/SOURCES/kvm-memory-s-mask-clear-cpu_physical_memory_mask_dirty_r.patch b/SOURCES/kvm-memory-s-mask-clear-cpu_physical_memory_mask_dirty_r.patch new file mode 100644 index 0000000..0f3cf0f --- /dev/null +++ b/SOURCES/kvm-memory-s-mask-clear-cpu_physical_memory_mask_dirty_r.patch @@ -0,0 +1,65 @@ +From 7565f009dfdc2a54fab24deb0a5887be00777acc Mon Sep 17 00:00:00 2001 +From: Juan Quintela +Date: Tue, 14 Jan 2014 15:07:35 +0100 +Subject: [PATCH 24/40] memory: s/mask/clear/ cpu_physical_memory_mask_dirty_range + +RH-Author: Juan Quintela +Message-id: <1389712071-23303-25-git-send-email-quintela@redhat.com> +Patchwork-id: 56679 +O-Subject: [RHEL7 qemu-kvm PATCH 24/40] memory: s/mask/clear/ cpu_physical_memory_mask_dirty_range +Bugzilla: 997559 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Orit Wasserman +RH-Acked-by: Dr. David Alan Gilbert (git) + +Now all functions use the same wording that bitops/bitmap operations + +Signed-off-by: Juan Quintela +Reviewed-by: Eric Blake +Reviewed-by: Orit Wasserman +(cherry picked from commit ace694cccccf343852d9f0b34171ad475e248bbf) +Signed-off-by: Juan Quintela +--- + exec.c | 2 +- + include/exec/memory-internal.h | 6 +++--- + 2 files changed, 4 insertions(+), 4 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + exec.c | 2 +- + include/exec/memory-internal.h | 6 +++--- + 2 files changed, 4 insertions(+), 4 deletions(-) + +diff --git a/exec.c b/exec.c +index 45b2c46..77c2a0a 100644 +--- a/exec.c ++++ b/exec.c +@@ -606,7 +606,7 @@ void cpu_physical_memory_reset_dirty(ram_addr_t start, ram_addr_t end, + length = end - start; + if (length == 0) + return; +- cpu_physical_memory_mask_dirty_range(start, length, client); ++ cpu_physical_memory_clear_dirty_range(start, length, client); + + if (tcg_enabled()) { + tlb_reset_dirty_range_all(start, end, length); +diff --git a/include/exec/memory-internal.h b/include/exec/memory-internal.h +index f27b830..caff5b4 100644 +--- a/include/exec/memory-internal.h ++++ b/include/exec/memory-internal.h +@@ -109,9 +109,9 @@ static inline void cpu_physical_memory_set_dirty_range(ram_addr_t start, + xen_modified_memory(addr, length); + } + +-static inline void cpu_physical_memory_mask_dirty_range(ram_addr_t start, +- ram_addr_t length, +- unsigned client) ++static inline void cpu_physical_memory_clear_dirty_range(ram_addr_t start, ++ ram_addr_t length, ++ unsigned client) + { + ram_addr_t addr, end; + +-- +1.7.1 + diff --git a/SOURCES/kvm-memory-set-single-dirty-flags-when-possible.patch b/SOURCES/kvm-memory-set-single-dirty-flags-when-possible.patch new file mode 100644 index 0000000..c56099e --- /dev/null +++ b/SOURCES/kvm-memory-set-single-dirty-flags-when-possible.patch @@ -0,0 +1,73 @@ +From 370fe54037a8d715db78f35d1853dbecdbcef3a0 Mon Sep 17 00:00:00 2001 +From: Juan Quintela +Date: Tue, 14 Jan 2014 15:07:21 +0100 +Subject: [PATCH 10/40] memory: set single dirty flags when possible + +RH-Author: Juan Quintela +Message-id: <1389712071-23303-11-git-send-email-quintela@redhat.com> +Patchwork-id: 56661 +O-Subject: [RHEL7 qemu-kvm PATCH 10/40] memory: set single dirty flags when possible +Bugzilla: 997559 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Orit Wasserman +RH-Acked-by: Dr. David Alan Gilbert (git) + +Signed-off-by: Juan Quintela +Reviewed-by: Eric Blake +Reviewed-by: Orit Wasserman +(cherry picked from commit 63995cebfaa283586682ea6236c9686b2a49ece7) +Signed-off-by: Juan Quintela +--- + exec.c | 7 ++++--- + include/exec/memory-internal.h | 4 +++- + 2 files changed, 7 insertions(+), 4 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + exec.c | 7 ++++--- + include/exec/memory-internal.h | 4 +++- + 2 files changed, 7 insertions(+), 4 deletions(-) + +diff --git a/exec.c b/exec.c +index ea81329..178ed4a 100644 +--- a/exec.c ++++ b/exec.c +@@ -1919,7 +1919,8 @@ static void invalidate_and_set_dirty(hwaddr addr, + /* invalidate code */ + tb_invalidate_phys_page_range(addr, addr + length, 0); + /* set dirty bit */ +- cpu_physical_memory_set_dirty_flags(addr, (0xff & ~CODE_DIRTY_FLAG)); ++ cpu_physical_memory_set_dirty_flag(addr, VGA_DIRTY_FLAG); ++ cpu_physical_memory_set_dirty_flag(addr, MIGRATION_DIRTY_FLAG); + } + xen_modified_memory(addr, length); + } +@@ -2434,8 +2435,8 @@ void stl_phys_notdirty(hwaddr addr, uint32_t val) + /* invalidate code */ + tb_invalidate_phys_page_range(addr1, addr1 + 4, 0); + /* set dirty bit */ +- cpu_physical_memory_set_dirty_flags( +- addr1, (0xff & ~CODE_DIRTY_FLAG)); ++ cpu_physical_memory_set_dirty_flag(addr1, MIGRATION_DIRTY_FLAG); ++ cpu_physical_memory_set_dirty_flag(addr1, VGA_DIRTY_FLAG); + } + } + } +diff --git a/include/exec/memory-internal.h b/include/exec/memory-internal.h +index 571a5ef..55b4022 100644 +--- a/include/exec/memory-internal.h ++++ b/include/exec/memory-internal.h +@@ -98,7 +98,9 @@ static inline void cpu_physical_memory_set_dirty_flag(ram_addr_t addr, + + static inline void cpu_physical_memory_set_dirty(ram_addr_t addr) + { +- cpu_physical_memory_set_dirty_flags(addr, 0xff); ++ cpu_physical_memory_set_dirty_flag(addr, MIGRATION_DIRTY_FLAG); ++ cpu_physical_memory_set_dirty_flag(addr, VGA_DIRTY_FLAG); ++ cpu_physical_memory_set_dirty_flag(addr, CODE_DIRTY_FLAG); + } + + static inline int cpu_physical_memory_clear_dirty_flags(ram_addr_t addr, +-- +1.7.1 + diff --git a/SOURCES/kvm-memory-split-cpu_physical_memory_-functions-to-its-o.patch b/SOURCES/kvm-memory-split-cpu_physical_memory_-functions-to-its-o.patch new file mode 100644 index 0000000..da41441 --- /dev/null +++ b/SOURCES/kvm-memory-split-cpu_physical_memory_-functions-to-its-o.patch @@ -0,0 +1,304 @@ +From e2bf4a6155c08480e42afe12d5ea1ce083c35f00 Mon Sep 17 00:00:00 2001 +From: Juan Quintela +Date: Tue, 14 Jan 2014 15:07:44 +0100 +Subject: [PATCH 33/40] memory: split cpu_physical_memory_* functions to its own include + +RH-Author: Juan Quintela +Message-id: <1389712071-23303-34-git-send-email-quintela@redhat.com> +Patchwork-id: 56688 +O-Subject: [RHEL7 qemu-kvm PATCH 33/40] memory: split cpu_physical_memory_* functions to its own include +Bugzilla: 997559 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Orit Wasserman +RH-Acked-by: Dr. David Alan Gilbert (git) + +All the functions that use ram_addr_t should be here. + +Signed-off-by: Juan Quintela +Reviewed-by: Orit Wasserman +(cherry picked from commit 220c3ebddbd1ac289ae7fc64733c9501b3921d94) + +Conflicts: + exec.c + include/exec/memory-internal.h + +Conflicts due to missing upstream commits: + +commit d2702032b4746515cff0bf29891a6b6decfc3d86 +Author: Paolo Bonzini +Date: Fri May 24 11:55:06 2013 +0200 + + memory: export memory_region_access_valid to exec.c + +commit d197063fcf969e1269dc53c9c9e9a073f87aa3b4 +Author: Paolo Bonzini +Date: Fri May 24 13:23:38 2013 +0200 + + memory: move unassigned_mem_ops to memory.c + +commit b40acf99bef69fa8ab0f9092ff162fde945eec12 +Author: Jan Kiszka +Date: Mon Jun 24 10:45:09 2013 +0200 + + ioport: Switch dispatching to memory core layer + +commit ee983cb3cc8f856b408a272269f434cc9a82ceff +Author: Paolo Bonzini +Date: Tue May 14 11:47:56 2013 +0200 + + exec: make qemu_get_ram_ptr private + +Signed-off-by: Juan Quintela +--- + cputlb.c | 1 + + exec.c | 1 + + include/exec/memory-internal.h | 76 --------------------------------- + include/exec/ram_addr.h | 97 ++++++++++++++++++++++++++++++++++++++++++ + memory.c | 1 + + 5 files changed, 100 insertions(+), 76 deletions(-) + create mode 100644 include/exec/ram_addr.h + +Signed-off-by: Miroslav Rezanina +--- + cputlb.c | 1 + + exec.c | 1 + + include/exec/memory-internal.h | 76 ------------------------------- + include/exec/ram_addr.h | 97 ++++++++++++++++++++++++++++++++++++++++ + memory.c | 1 + + 5 files changed, 100 insertions(+), 76 deletions(-) + create mode 100644 include/exec/ram_addr.h + +diff --git a/cputlb.c b/cputlb.c +index 44ec9bc..7699fdd 100644 +--- a/cputlb.c ++++ b/cputlb.c +@@ -26,6 +26,7 @@ + #include "exec/cputlb.h" + + #include "exec/memory-internal.h" ++#include "exec/ram_addr.h" + + //#define DEBUG_TLB + //#define DEBUG_TLB_CHECK +diff --git a/exec.c b/exec.c +index 12adb12..b16ef4a 100644 +--- a/exec.c ++++ b/exec.c +@@ -50,6 +50,7 @@ + #include "translate-all.h" + + #include "exec/memory-internal.h" ++#include "exec/ram_addr.h" + + //#define DEBUG_UNASSIGNED + //#define DEBUG_SUBPAGE +diff --git a/include/exec/memory-internal.h b/include/exec/memory-internal.h +index 327d54e..8b558bf 100644 +--- a/include/exec/memory-internal.h ++++ b/include/exec/memory-internal.h +@@ -20,87 +20,11 @@ + #define MEMORY_INTERNAL_H + + #ifndef CONFIG_USER_ONLY +-#include "hw/xen/xen.h" +- +- + typedef struct AddressSpaceDispatch AddressSpaceDispatch; + + void address_space_init_dispatch(AddressSpace *as); + void address_space_destroy_dispatch(AddressSpace *as); + +-ram_addr_t qemu_ram_alloc_from_ptr(ram_addr_t size, void *host, +- MemoryRegion *mr); +-ram_addr_t qemu_ram_alloc(ram_addr_t size, MemoryRegion *mr); +-void qemu_ram_free(ram_addr_t addr); +-void qemu_ram_free_from_ptr(ram_addr_t addr); +- +-static inline bool cpu_physical_memory_get_dirty(ram_addr_t start, +- ram_addr_t length, +- unsigned client) +-{ +- unsigned long end, page, next; +- +- assert(client < DIRTY_MEMORY_NUM); +- +- end = TARGET_PAGE_ALIGN(start + length) >> TARGET_PAGE_BITS; +- page = start >> TARGET_PAGE_BITS; +- next = find_next_bit(ram_list.dirty_memory[client], end, page); +- +- return next < end; +-} +- +-static inline bool cpu_physical_memory_get_dirty_flag(ram_addr_t addr, +- unsigned client) +-{ +- return cpu_physical_memory_get_dirty(addr, 1, client); +-} +- +-static inline bool cpu_physical_memory_is_clean(ram_addr_t addr) +-{ +- bool vga = cpu_physical_memory_get_dirty_flag(addr, DIRTY_MEMORY_VGA); +- bool code = cpu_physical_memory_get_dirty_flag(addr, DIRTY_MEMORY_CODE); +- bool migration = +- cpu_physical_memory_get_dirty_flag(addr, DIRTY_MEMORY_MIGRATION); +- return !(vga && code && migration); +-} +- +-static inline void cpu_physical_memory_set_dirty_flag(ram_addr_t addr, +- unsigned client) +-{ +- assert(client < DIRTY_MEMORY_NUM); +- set_bit(addr >> TARGET_PAGE_BITS, ram_list.dirty_memory[client]); +-} +- +-static inline void cpu_physical_memory_set_dirty_range(ram_addr_t start, +- ram_addr_t length) +-{ +- unsigned long end, page; +- +- end = TARGET_PAGE_ALIGN(start + length) >> TARGET_PAGE_BITS; +- page = start >> TARGET_PAGE_BITS; +- bitmap_set(ram_list.dirty_memory[DIRTY_MEMORY_MIGRATION], page, end - page); +- bitmap_set(ram_list.dirty_memory[DIRTY_MEMORY_VGA], page, end - page); +- bitmap_set(ram_list.dirty_memory[DIRTY_MEMORY_CODE], page, end - page); +- xen_modified_memory(start, length); +-} +- +-static inline void cpu_physical_memory_clear_dirty_range(ram_addr_t start, +- ram_addr_t length, +- unsigned client) +-{ +- unsigned long end, page; +- +- assert(client < DIRTY_MEMORY_NUM); +- end = TARGET_PAGE_ALIGN(start + length) >> TARGET_PAGE_BITS; +- page = start >> TARGET_PAGE_BITS; +- bitmap_clear(ram_list.dirty_memory[client], page, end - page); +-} +- +-void cpu_physical_memory_reset_dirty(ram_addr_t start, ram_addr_t length, +- unsigned client); +- + extern const IORangeOps memory_region_iorange_ops; +- + #endif +- + #endif +diff --git a/include/exec/ram_addr.h b/include/exec/ram_addr.h +new file mode 100644 +index 0000000..0caa239 +--- /dev/null ++++ b/include/exec/ram_addr.h +@@ -0,0 +1,97 @@ ++/* ++ * Declarations for cpu physical memory functions ++ * ++ * Copyright 2011 Red Hat, Inc. and/or its affiliates ++ * ++ * Authors: ++ * Avi Kivity ++ * ++ * This work is licensed under the terms of the GNU GPL, version 2 or ++ * later. See the COPYING file in the top-level directory. ++ * ++ */ ++ ++/* ++ * This header is for use by exec.c and memory.c ONLY. Do not include it. ++ * The functions declared here will be removed soon. ++ */ ++ ++#ifndef RAM_ADDR_H ++#define RAM_ADDR_H ++ ++#ifndef CONFIG_USER_ONLY ++#include "hw/xen/xen.h" ++ ++ram_addr_t qemu_ram_alloc_from_ptr(ram_addr_t size, void *host, ++ MemoryRegion *mr); ++ram_addr_t qemu_ram_alloc(ram_addr_t size, MemoryRegion *mr); ++void qemu_ram_free(ram_addr_t addr); ++void qemu_ram_free_from_ptr(ram_addr_t addr); ++ ++static inline bool cpu_physical_memory_get_dirty(ram_addr_t start, ++ ram_addr_t length, ++ unsigned client) ++{ ++ unsigned long end, page, next; ++ ++ assert(client < DIRTY_MEMORY_NUM); ++ ++ end = TARGET_PAGE_ALIGN(start + length) >> TARGET_PAGE_BITS; ++ page = start >> TARGET_PAGE_BITS; ++ next = find_next_bit(ram_list.dirty_memory[client], end, page); ++ ++ return next < end; ++} ++ ++static inline bool cpu_physical_memory_get_dirty_flag(ram_addr_t addr, ++ unsigned client) ++{ ++ return cpu_physical_memory_get_dirty(addr, 1, client); ++} ++ ++static inline bool cpu_physical_memory_is_clean(ram_addr_t addr) ++{ ++ bool vga = cpu_physical_memory_get_dirty_flag(addr, DIRTY_MEMORY_VGA); ++ bool code = cpu_physical_memory_get_dirty_flag(addr, DIRTY_MEMORY_CODE); ++ bool migration = ++ cpu_physical_memory_get_dirty_flag(addr, DIRTY_MEMORY_MIGRATION); ++ return !(vga && code && migration); ++} ++ ++static inline void cpu_physical_memory_set_dirty_flag(ram_addr_t addr, ++ unsigned client) ++{ ++ assert(client < DIRTY_MEMORY_NUM); ++ set_bit(addr >> TARGET_PAGE_BITS, ram_list.dirty_memory[client]); ++} ++ ++static inline void cpu_physical_memory_set_dirty_range(ram_addr_t start, ++ ram_addr_t length) ++{ ++ unsigned long end, page; ++ ++ end = TARGET_PAGE_ALIGN(start + length) >> TARGET_PAGE_BITS; ++ page = start >> TARGET_PAGE_BITS; ++ bitmap_set(ram_list.dirty_memory[DIRTY_MEMORY_MIGRATION], page, end - page); ++ bitmap_set(ram_list.dirty_memory[DIRTY_MEMORY_VGA], page, end - page); ++ bitmap_set(ram_list.dirty_memory[DIRTY_MEMORY_CODE], page, end - page); ++ xen_modified_memory(start, length); ++} ++ ++static inline void cpu_physical_memory_clear_dirty_range(ram_addr_t start, ++ ram_addr_t length, ++ unsigned client) ++{ ++ unsigned long end, page; ++ ++ assert(client < DIRTY_MEMORY_NUM); ++ end = TARGET_PAGE_ALIGN(start + length) >> TARGET_PAGE_BITS; ++ page = start >> TARGET_PAGE_BITS; ++ bitmap_clear(ram_list.dirty_memory[client], page, end - page); ++} ++ ++void cpu_physical_memory_reset_dirty(ram_addr_t start, ram_addr_t length, ++ unsigned client); ++ ++#endif ++#endif +diff --git a/memory.c b/memory.c +index b49642b..685912d 100644 +--- a/memory.c ++++ b/memory.c +@@ -21,6 +21,7 @@ + #include + + #include "exec/memory-internal.h" ++#include "exec/ram_addr.h" + + static unsigned memory_region_transaction_depth; + static bool memory_region_update_pending; +-- +1.7.1 + diff --git a/SOURCES/kvm-memory-split-dirty-bitmap-into-three.patch b/SOURCES/kvm-memory-split-dirty-bitmap-into-three.patch new file mode 100644 index 0000000..eea4cf3 --- /dev/null +++ b/SOURCES/kvm-memory-split-dirty-bitmap-into-three.patch @@ -0,0 +1,169 @@ +From e6b7d9c30dfcdf22dcf87eab667a4212e803ec54 Mon Sep 17 00:00:00 2001 +From: Juan Quintela +Date: Tue, 14 Jan 2014 15:07:29 +0100 +Subject: [PATCH 18/40] memory: split dirty bitmap into three + +RH-Author: Juan Quintela +Message-id: <1389712071-23303-19-git-send-email-quintela@redhat.com> +Patchwork-id: 56673 +O-Subject: [RHEL7 qemu-kvm PATCH 18/40] memory: split dirty bitmap into three +Bugzilla: 997559 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Orit Wasserman +RH-Acked-by: Dr. David Alan Gilbert (git) + +After all the previous patches, spliting the bitmap gets direct. + +Note: For some reason, I have to move DIRTY_MEMORY_* definitions to +the beginning of memory.h to make compilation work. + +Signed-off-by: Juan Quintela +Reviewed-by: Eric Blake +Reviewed-by: Orit Wasserman +(cherry picked from commit 1ab4c8ceaa5ec55af9bb25e88e46d461a8550280) + +Manual compilation fix: + +- For some reason includes get completely wrong, I had to change the + order of memory.h in ioport.c + Upstream has a much saner layout of include dependences + +Signed-off-by: Juan Quintela +--- + exec.c | 9 ++++++--- + include/exec/cpu-all.h | 3 ++- + include/exec/memory-internal.h | 9 +++------ + include/exec/memory.h | 10 +++++----- + ioport.c | 2 +- + 5 files changed, 17 insertions(+), 16 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + exec.c | 9 ++++++--- + include/exec/cpu-all.h | 3 ++- + include/exec/memory-internal.h | 9 +++------ + include/exec/memory.h | 10 +++++----- + ioport.c | 2 +- + 5 files changed, 17 insertions(+), 16 deletions(-) + +diff --git a/exec.c b/exec.c +index be99d45..45b2c46 100644 +--- a/exec.c ++++ b/exec.c +@@ -1164,9 +1164,12 @@ ram_addr_t qemu_ram_alloc_from_ptr(ram_addr_t size, void *host, + new_ram_size = last_ram_offset() >> TARGET_PAGE_BITS; + + if (new_ram_size > old_ram_size) { +- ram_list.phys_dirty = g_realloc(ram_list.phys_dirty, new_ram_size); +- memset(ram_list.phys_dirty + (new_block->offset >> TARGET_PAGE_BITS), +- 0, size >> TARGET_PAGE_BITS); ++ int i; ++ for (i = 0; i < DIRTY_MEMORY_NUM; i++) { ++ ram_list.dirty_memory[i] = ++ bitmap_zero_extend(ram_list.dirty_memory[i], ++ old_ram_size, new_ram_size); ++ } + } + cpu_physical_memory_set_dirty_range(new_block->offset, size); + +diff --git a/include/exec/cpu-all.h b/include/exec/cpu-all.h +index c369b25..9c85c1c 100644 +--- a/include/exec/cpu-all.h ++++ b/include/exec/cpu-all.h +@@ -22,6 +22,7 @@ + #include "qemu-common.h" + #include "qemu/tls.h" + #include "exec/cpu-common.h" ++#include "exec/memory.h" + #include "qemu/thread.h" + + /* some important defines: +@@ -482,7 +483,7 @@ typedef struct RAMBlock { + typedef struct RAMList { + QemuMutex mutex; + /* Protected by the iothread lock. */ +- uint8_t *phys_dirty; ++ unsigned long *dirty_memory[DIRTY_MEMORY_NUM]; + RAMBlock *mru_block; + /* Protected by the ramlist lock. */ + QTAILQ_HEAD(, RAMBlock) blocks; +diff --git a/include/exec/memory-internal.h b/include/exec/memory-internal.h +index 2c86add..962b292 100644 +--- a/include/exec/memory-internal.h ++++ b/include/exec/memory-internal.h +@@ -53,7 +53,7 @@ static inline bool cpu_physical_memory_get_dirty_flag(ram_addr_t addr, + unsigned client) + { + assert(client < DIRTY_MEMORY_NUM); +- return ram_list.phys_dirty[addr >> TARGET_PAGE_BITS] & (1 << client); ++ return test_bit(addr >> TARGET_PAGE_BITS, ram_list.dirty_memory[client]); + } + + /* read dirty bit (return 0 or 1) */ +@@ -85,7 +85,7 @@ static inline void cpu_physical_memory_set_dirty_flag(ram_addr_t addr, + unsigned client) + { + assert(client < DIRTY_MEMORY_NUM); +- ram_list.phys_dirty[addr >> TARGET_PAGE_BITS] |= (1 << client); ++ set_bit(addr >> TARGET_PAGE_BITS, ram_list.dirty_memory[client]); + } + + static inline void cpu_physical_memory_set_dirty(ram_addr_t addr) +@@ -98,11 +98,8 @@ static inline void cpu_physical_memory_set_dirty(ram_addr_t addr) + static inline void cpu_physical_memory_clear_dirty_flag(ram_addr_t addr, + unsigned client) + { +- int mask = ~(1 << client); +- + assert(client < DIRTY_MEMORY_NUM); +- +- ram_list.phys_dirty[addr >> TARGET_PAGE_BITS] &= mask; ++ clear_bit(addr >> TARGET_PAGE_BITS, ram_list.dirty_memory[client]); + } + + static inline void cpu_physical_memory_set_dirty_range(ram_addr_t start, +diff --git a/include/exec/memory.h b/include/exec/memory.h +index 0023edf..bd6d31a 100644 +--- a/include/exec/memory.h ++++ b/include/exec/memory.h +@@ -16,6 +16,11 @@ + + #ifndef CONFIG_USER_ONLY + ++#define DIRTY_MEMORY_VGA 0 ++#define DIRTY_MEMORY_CODE 1 ++#define DIRTY_MEMORY_MIGRATION 2 ++#define DIRTY_MEMORY_NUM 3 /* num of dirty bits */ ++ + #include + #include + #include "qemu-common.h" +@@ -30,11 +35,6 @@ typedef struct MemoryRegionOps MemoryRegionOps; + typedef struct MemoryRegionPortio MemoryRegionPortio; + typedef struct MemoryRegionMmio MemoryRegionMmio; + +-#define DIRTY_MEMORY_VGA 0 +-#define DIRTY_MEMORY_CODE 1 +-#define DIRTY_MEMORY_MIGRATION 2 +-#define DIRTY_MEMORY_NUM 3 /* num of dirty bits */ +- + struct MemoryRegionMmio { + CPUReadMemoryFunc *read[3]; + CPUWriteMemoryFunc *write[3]; +diff --git a/ioport.c b/ioport.c +index a0ac2a0..957e980 100644 +--- a/ioport.c ++++ b/ioport.c +@@ -25,8 +25,8 @@ + * splitted out ioport related stuffs from vl.c. + */ + +-#include "exec/ioport.h" + #include "trace.h" ++#include "exec/ioport.h" + #include "exec/memory.h" + + /***********************************************************/ +-- +1.7.1 + diff --git a/SOURCES/kvm-memory-syncronize-kvm-bitmap-using-bitmaps-operation.patch b/SOURCES/kvm-memory-syncronize-kvm-bitmap-using-bitmaps-operation.patch new file mode 100644 index 0000000..22ebaa0 --- /dev/null +++ b/SOURCES/kvm-memory-syncronize-kvm-bitmap-using-bitmaps-operation.patch @@ -0,0 +1,103 @@ +From c18e8f4bf7a628949f0d79facf91ddf6d07401e9 Mon Sep 17 00:00:00 2001 +From: Juan Quintela +Date: Tue, 14 Jan 2014 15:07:49 +0100 +Subject: [PATCH 38/40] memory: syncronize kvm bitmap using bitmaps operations + +RH-Author: Juan Quintela +Message-id: <1389712071-23303-39-git-send-email-quintela@redhat.com> +Patchwork-id: 56693 +O-Subject: [RHEL7 qemu-kvm PATCH 38/40] memory: syncronize kvm bitmap using bitmaps operations +Bugzilla: 997559 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Orit Wasserman +RH-Acked-by: Dr. David Alan Gilbert (git) + +If bitmaps are aligned properly, use bitmap operations. If they are +not, just use old bit at a time code. + +Signed-off-by: Juan Quintela +Reviewed-by: Orit Wasserman +(cherry picked from commit ae2810c4bb3b383176e8e1b33931b16c01483aab) +Signed-off-by: Juan Quintela +--- + include/exec/ram_addr.h | 54 ++++++++++++++++++++++++++++++++----------------- + 1 file changed, 36 insertions(+), 18 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + include/exec/ram_addr.h | 54 +++++++++++++++++++++++++++++++--------------- + 1 files changed, 36 insertions(+), 18 deletions(-) + +diff --git a/include/exec/ram_addr.h b/include/exec/ram_addr.h +index 9962e12..080a8b1 100644 +--- a/include/exec/ram_addr.h ++++ b/include/exec/ram_addr.h +@@ -82,29 +82,47 @@ static inline void cpu_physical_memory_set_dirty_lebitmap(unsigned long *bitmap, + ram_addr_t start, + ram_addr_t pages) + { +- unsigned int i, j; ++ unsigned long i, j; + unsigned long page_number, c; + hwaddr addr; + ram_addr_t ram_addr; +- unsigned int len = (pages + HOST_LONG_BITS - 1) / HOST_LONG_BITS; ++ unsigned long len = (pages + HOST_LONG_BITS - 1) / HOST_LONG_BITS; + unsigned long hpratio = getpagesize() / TARGET_PAGE_SIZE; ++ unsigned long page = BIT_WORD(start >> TARGET_PAGE_BITS); + +- /* +- * bitmap-traveling is faster than memory-traveling (for addr...) +- * especially when most of the memory is not dirty. +- */ +- for (i = 0; i < len; i++) { +- if (bitmap[i] != 0) { +- c = leul_to_cpu(bitmap[i]); +- do { +- j = ffsl(c) - 1; +- c &= ~(1ul << j); +- page_number = (i * HOST_LONG_BITS + j) * hpratio; +- addr = page_number * TARGET_PAGE_SIZE; +- ram_addr = start + addr; +- cpu_physical_memory_set_dirty_range(ram_addr, +- TARGET_PAGE_SIZE * hpratio); +- } while (c != 0); ++ /* start address is aligned at the start of a word? */ ++ if (((page * BITS_PER_LONG) << TARGET_PAGE_BITS) == start) { ++ long k; ++ long nr = BITS_TO_LONGS(pages); ++ ++ for (k = 0; k < nr; k++) { ++ if (bitmap[k]) { ++ unsigned long temp = leul_to_cpu(bitmap[k]); ++ ++ ram_list.dirty_memory[DIRTY_MEMORY_MIGRATION][page + k] |= temp; ++ ram_list.dirty_memory[DIRTY_MEMORY_VGA][page + k] |= temp; ++ ram_list.dirty_memory[DIRTY_MEMORY_CODE][page + k] |= temp; ++ } ++ } ++ xen_modified_memory(start, pages); ++ } else { ++ /* ++ * bitmap-traveling is faster than memory-traveling (for addr...) ++ * especially when most of the memory is not dirty. ++ */ ++ for (i = 0; i < len; i++) { ++ if (bitmap[i] != 0) { ++ c = leul_to_cpu(bitmap[i]); ++ do { ++ j = ffsl(c) - 1; ++ c &= ~(1ul << j); ++ page_number = (i * HOST_LONG_BITS + j) * hpratio; ++ addr = page_number * TARGET_PAGE_SIZE; ++ ram_addr = start + addr; ++ cpu_physical_memory_set_dirty_range(ram_addr, ++ TARGET_PAGE_SIZE * hpratio); ++ } while (c != 0); ++ } + } + } + } +-- +1.7.1 + diff --git a/SOURCES/kvm-memory-unfold-cpu_physical_memory_clear_dirty_flag-i.patch b/SOURCES/kvm-memory-unfold-cpu_physical_memory_clear_dirty_flag-i.patch new file mode 100644 index 0000000..a9c1395 --- /dev/null +++ b/SOURCES/kvm-memory-unfold-cpu_physical_memory_clear_dirty_flag-i.patch @@ -0,0 +1,62 @@ +From f59303c7088fc5408c60fbdba36ebe72cbc3ea30 Mon Sep 17 00:00:00 2001 +From: Juan Quintela +Date: Tue, 14 Jan 2014 15:07:30 +0100 +Subject: [PATCH 19/40] memory: unfold cpu_physical_memory_clear_dirty_flag() in its only user + +RH-Author: Juan Quintela +Message-id: <1389712071-23303-20-git-send-email-quintela@redhat.com> +Patchwork-id: 56674 +O-Subject: [RHEL7 qemu-kvm PATCH 19/40] memory: unfold cpu_physical_memory_clear_dirty_flag() in its only user +Bugzilla: 997559 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Orit Wasserman +RH-Acked-by: Dr. David Alan Gilbert (git) + +Signed-off-by: Juan Quintela +Reviewed-by: Eric Blake +Reviewed-by: Orit Wasserman +(cherry picked from commit 86a49582dbe66d59a9366d2f002f0d6af965ecb8) +Signed-off-by: Juan Quintela +--- + include/exec/memory-internal.h | 10 ++-------- + 1 file changed, 2 insertions(+), 8 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + include/exec/memory-internal.h | 10 ++-------- + 1 files changed, 2 insertions(+), 8 deletions(-) + +diff --git a/include/exec/memory-internal.h b/include/exec/memory-internal.h +index 962b292..c6372e4 100644 +--- a/include/exec/memory-internal.h ++++ b/include/exec/memory-internal.h +@@ -95,13 +95,6 @@ static inline void cpu_physical_memory_set_dirty(ram_addr_t addr) + cpu_physical_memory_set_dirty_flag(addr, DIRTY_MEMORY_CODE); + } + +-static inline void cpu_physical_memory_clear_dirty_flag(ram_addr_t addr, +- unsigned client) +-{ +- assert(client < DIRTY_MEMORY_NUM); +- clear_bit(addr >> TARGET_PAGE_BITS, ram_list.dirty_memory[client]); +-} +- + static inline void cpu_physical_memory_set_dirty_range(ram_addr_t start, + ram_addr_t length) + { +@@ -121,10 +114,11 @@ static inline void cpu_physical_memory_mask_dirty_range(ram_addr_t start, + { + ram_addr_t addr, end; + ++ assert(client < DIRTY_MEMORY_NUM); + end = TARGET_PAGE_ALIGN(start + length); + start &= TARGET_PAGE_MASK; + for (addr = start; addr < end; addr += TARGET_PAGE_SIZE) { +- cpu_physical_memory_clear_dirty_flag(addr, client); ++ clear_bit(addr >> TARGET_PAGE_BITS, ram_list.dirty_memory[client]); + } + } + +-- +1.7.1 + diff --git a/SOURCES/kvm-memory-unfold-cpu_physical_memory_set_dirty-in-its-o.patch b/SOURCES/kvm-memory-unfold-cpu_physical_memory_set_dirty-in-its-o.patch new file mode 100644 index 0000000..59bf1ca --- /dev/null +++ b/SOURCES/kvm-memory-unfold-cpu_physical_memory_set_dirty-in-its-o.patch @@ -0,0 +1,60 @@ +From 7f3acd02a66cd7b2172a5bf264ba26e2f25ae1b9 Mon Sep 17 00:00:00 2001 +From: Juan Quintela +Date: Tue, 14 Jan 2014 15:07:31 +0100 +Subject: [PATCH 20/40] memory: unfold cpu_physical_memory_set_dirty() in its only user + +RH-Author: Juan Quintela +Message-id: <1389712071-23303-21-git-send-email-quintela@redhat.com> +Patchwork-id: 56675 +O-Subject: [RHEL7 qemu-kvm PATCH 20/40] memory: unfold cpu_physical_memory_set_dirty() in its only user +Bugzilla: 997559 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Orit Wasserman +RH-Acked-by: Dr. David Alan Gilbert (git) + +Signed-off-by: Juan Quintela +Reviewed-by: Eric Blake +Reviewed-by: Orit Wasserman +(cherry picked from commit 4f13bb80a2dc1bb851b43da6dd9117473772b197) +Signed-off-by: Juan Quintela +--- + include/exec/memory-internal.h | 11 +++-------- + 1 file changed, 3 insertions(+), 8 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + include/exec/memory-internal.h | 11 +++-------- + 1 files changed, 3 insertions(+), 8 deletions(-) + +diff --git a/include/exec/memory-internal.h b/include/exec/memory-internal.h +index c6372e4..19d8393 100644 +--- a/include/exec/memory-internal.h ++++ b/include/exec/memory-internal.h +@@ -88,13 +88,6 @@ static inline void cpu_physical_memory_set_dirty_flag(ram_addr_t addr, + set_bit(addr >> TARGET_PAGE_BITS, ram_list.dirty_memory[client]); + } + +-static inline void cpu_physical_memory_set_dirty(ram_addr_t addr) +-{ +- cpu_physical_memory_set_dirty_flag(addr, DIRTY_MEMORY_MIGRATION); +- cpu_physical_memory_set_dirty_flag(addr, DIRTY_MEMORY_VGA); +- cpu_physical_memory_set_dirty_flag(addr, DIRTY_MEMORY_CODE); +-} +- + static inline void cpu_physical_memory_set_dirty_range(ram_addr_t start, + ram_addr_t length) + { +@@ -103,7 +96,9 @@ static inline void cpu_physical_memory_set_dirty_range(ram_addr_t start, + end = TARGET_PAGE_ALIGN(start + length); + start &= TARGET_PAGE_MASK; + for (addr = start; addr < end; addr += TARGET_PAGE_SIZE) { +- cpu_physical_memory_set_dirty(addr); ++ cpu_physical_memory_set_dirty_flag(addr, DIRTY_MEMORY_MIGRATION); ++ cpu_physical_memory_set_dirty_flag(addr, DIRTY_MEMORY_VGA); ++ cpu_physical_memory_set_dirty_flag(addr, DIRTY_MEMORY_CODE); + } + xen_modified_memory(addr, length); + } +-- +1.7.1 + diff --git a/SOURCES/kvm-memory-unfold-cpu_physical_memory_set_dirty_flag.patch b/SOURCES/kvm-memory-unfold-cpu_physical_memory_set_dirty_flag.patch new file mode 100644 index 0000000..0ab0d86 --- /dev/null +++ b/SOURCES/kvm-memory-unfold-cpu_physical_memory_set_dirty_flag.patch @@ -0,0 +1,51 @@ +From 10cef67ef7714773f79e444450983d5bbdb2e014 Mon Sep 17 00:00:00 2001 +From: Juan Quintela +Date: Tue, 14 Jan 2014 15:07:32 +0100 +Subject: [PATCH 21/40] memory: unfold cpu_physical_memory_set_dirty_flag() + +RH-Author: Juan Quintela +Message-id: <1389712071-23303-22-git-send-email-quintela@redhat.com> +Patchwork-id: 56677 +O-Subject: [RHEL7 qemu-kvm PATCH 21/40] memory: unfold cpu_physical_memory_set_dirty_flag() +Bugzilla: 997559 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Orit Wasserman +RH-Acked-by: Dr. David Alan Gilbert (git) + +Signed-off-by: Juan Quintela +Reviewed-by: Eric Blake +Reviewed-by: Orit Wasserman +(cherry picked from commit c1427a3f84c42d5159d10927700eafc9b653d68f) +Signed-off-by: Juan Quintela +--- + include/exec/memory-internal.h | 9 ++++++--- + 1 file changed, 6 insertions(+), 3 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + include/exec/memory-internal.h | 9 ++++++--- + 1 files changed, 6 insertions(+), 3 deletions(-) + +diff --git a/include/exec/memory-internal.h b/include/exec/memory-internal.h +index 19d8393..e8fae2a 100644 +--- a/include/exec/memory-internal.h ++++ b/include/exec/memory-internal.h +@@ -96,9 +96,12 @@ static inline void cpu_physical_memory_set_dirty_range(ram_addr_t start, + end = TARGET_PAGE_ALIGN(start + length); + start &= TARGET_PAGE_MASK; + for (addr = start; addr < end; addr += TARGET_PAGE_SIZE) { +- cpu_physical_memory_set_dirty_flag(addr, DIRTY_MEMORY_MIGRATION); +- cpu_physical_memory_set_dirty_flag(addr, DIRTY_MEMORY_VGA); +- cpu_physical_memory_set_dirty_flag(addr, DIRTY_MEMORY_CODE); ++ set_bit(addr >> TARGET_PAGE_BITS, ++ ram_list.dirty_memory[DIRTY_MEMORY_MIGRATION]); ++ set_bit(addr >> TARGET_PAGE_BITS, ++ ram_list.dirty_memory[DIRTY_MEMORY_VGA]); ++ set_bit(addr >> TARGET_PAGE_BITS, ++ ram_list.dirty_memory[DIRTY_MEMORY_CODE]); + } + xen_modified_memory(addr, length); + } +-- +1.7.1 + diff --git a/SOURCES/kvm-memory-unfold-memory_region_test_and_clear.patch b/SOURCES/kvm-memory-unfold-memory_region_test_and_clear.patch new file mode 100644 index 0000000..1bb8460 --- /dev/null +++ b/SOURCES/kvm-memory-unfold-memory_region_test_and_clear.patch @@ -0,0 +1,60 @@ +From bde7a88eaae5b1f1d2dd83a4d4fd232991d2397d Mon Sep 17 00:00:00 2001 +From: Juan Quintela +Date: Tue, 14 Jan 2014 15:07:45 +0100 +Subject: [PATCH 34/40] memory: unfold memory_region_test_and_clear() + +RH-Author: Juan Quintela +Message-id: <1389712071-23303-35-git-send-email-quintela@redhat.com> +Patchwork-id: 56689 +O-Subject: [RHEL7 qemu-kvm PATCH 34/40] memory: unfold memory_region_test_and_clear() +Bugzilla: 997559 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Orit Wasserman +RH-Acked-by: Dr. David Alan Gilbert (git) + +We are going to update the bitmap directly + +Signed-off-by: Juan Quintela +Reviewed-by: Orit Wasserman +(cherry picked from commit 12291ec18fdce3c1973c172f5a942a1bd26b9a5f) +Signed-off-by: Juan Quintela +--- + arch_init.c | 10 +++++++--- + 1 file changed, 7 insertions(+), 3 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + arch_init.c | 10 +++++++--- + 1 files changed, 7 insertions(+), 3 deletions(-) + +diff --git a/arch_init.c b/arch_init.c +index d71fb33..41da357 100644 +--- a/arch_init.c ++++ b/arch_init.c +@@ -48,6 +48,7 @@ + #include "qmp-commands.h" + #include "trace.h" + #include "exec/cpu-all.h" ++#include "exec/ram_addr.h" + #include "hw/acpi/acpi.h" + + #ifdef DEBUG_ARCH_INIT +@@ -400,9 +401,12 @@ static void migration_bitmap_sync(void) + + QTAILQ_FOREACH(block, &ram_list.blocks, next) { + for (addr = 0; addr < block->length; addr += TARGET_PAGE_SIZE) { +- if (memory_region_test_and_clear_dirty(block->mr, +- addr, TARGET_PAGE_SIZE, +- DIRTY_MEMORY_MIGRATION)) { ++ if (cpu_physical_memory_get_dirty(block->mr->ram_addr + addr, ++ TARGET_PAGE_SIZE, ++ DIRTY_MEMORY_MIGRATION)) { ++ cpu_physical_memory_reset_dirty(block->mr->ram_addr + addr, ++ TARGET_PAGE_SIZE, ++ DIRTY_MEMORY_MIGRATION); + migration_bitmap_set_dirty(block->mr, addr); + } + } +-- +1.7.1 + diff --git a/SOURCES/kvm-memory-use-bit-2-for-migration.patch b/SOURCES/kvm-memory-use-bit-2-for-migration.patch new file mode 100644 index 0000000..6b61fd0 --- /dev/null +++ b/SOURCES/kvm-memory-use-bit-2-for-migration.patch @@ -0,0 +1,48 @@ +From 620f885e15281ca32108331e68aec4ace5bdcec2 Mon Sep 17 00:00:00 2001 +From: Juan Quintela +Date: Tue, 14 Jan 2014 15:07:24 +0100 +Subject: [PATCH 13/40] memory: use bit 2 for migration + +RH-Author: Juan Quintela +Message-id: <1389712071-23303-14-git-send-email-quintela@redhat.com> +Patchwork-id: 56668 +O-Subject: [RHEL7 qemu-kvm PATCH 13/40] memory: use bit 2 for migration +Bugzilla: 997559 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Orit Wasserman +RH-Acked-by: Dr. David Alan Gilbert (git) + +For historical reasons it was bit 3. Once there, create a constant to +know the number of clients. + +Signed-off-by: Juan Quintela +Reviewed-by: Eric Blake +Reviewed-by: Orit Wasserman +(cherry picked from commit 5adca7ace9b80bf594e4c52c0d5b23573cba3639) +Signed-off-by: Juan Quintela +--- + include/exec/memory.h | 3 ++- + 1 file changed, 2 insertions(+), 1 deletion(-) + +Signed-off-by: Miroslav Rezanina +--- + include/exec/memory.h | 3 ++- + 1 files changed, 2 insertions(+), 1 deletions(-) + +diff --git a/include/exec/memory.h b/include/exec/memory.h +index 868fdb1..0023edf 100644 +--- a/include/exec/memory.h ++++ b/include/exec/memory.h +@@ -32,7 +32,8 @@ typedef struct MemoryRegionMmio MemoryRegionMmio; + + #define DIRTY_MEMORY_VGA 0 + #define DIRTY_MEMORY_CODE 1 +-#define DIRTY_MEMORY_MIGRATION 3 ++#define DIRTY_MEMORY_MIGRATION 2 ++#define DIRTY_MEMORY_NUM 3 /* num of dirty bits */ + + struct MemoryRegionMmio { + CPUReadMemoryFunc *read[3]; +-- +1.7.1 + diff --git a/SOURCES/kvm-memory-use-find_next_bit-to-find-dirty-bits.patch b/SOURCES/kvm-memory-use-find_next_bit-to-find-dirty-bits.patch new file mode 100644 index 0000000..fa86038 --- /dev/null +++ b/SOURCES/kvm-memory-use-find_next_bit-to-find-dirty-bits.patch @@ -0,0 +1,63 @@ +From 11ef790c7cca491bba62d8cb94018c1cf78e033c Mon Sep 17 00:00:00 2001 +From: Juan Quintela +Date: Tue, 14 Jan 2014 15:07:36 +0100 +Subject: [PATCH 25/40] memory: use find_next_bit() to find dirty bits + +RH-Author: Juan Quintela +Message-id: <1389712071-23303-26-git-send-email-quintela@redhat.com> +Patchwork-id: 56680 +O-Subject: [RHEL7 qemu-kvm PATCH 25/40] memory: use find_next_bit() to find dirty bits +Bugzilla: 997559 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Orit Wasserman +RH-Acked-by: Dr. David Alan Gilbert (git) + +This operation is way faster than doing it bit by bit. + +Signed-off-by: Juan Quintela +Reviewed-by: Eric Blake +Reviewed-by: Orit Wasserman +(cherry picked from commit 1bafff0c7cb99972fd243464632eca0780c6a8f1) +Signed-off-by: Juan Quintela +--- + include/exec/memory-internal.h | 16 ++++++---------- + 1 file changed, 6 insertions(+), 10 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + include/exec/memory-internal.h | 16 ++++++---------- + 1 files changed, 6 insertions(+), 10 deletions(-) + +diff --git a/include/exec/memory-internal.h b/include/exec/memory-internal.h +index caff5b4..1eda526 100644 +--- a/include/exec/memory-internal.h ++++ b/include/exec/memory-internal.h +@@ -53,19 +53,15 @@ static inline bool cpu_physical_memory_get_dirty(ram_addr_t start, + ram_addr_t length, + unsigned client) + { +- ram_addr_t addr, end; ++ unsigned long end, page, next; + + assert(client < DIRTY_MEMORY_NUM); + +- end = TARGET_PAGE_ALIGN(start + length); +- start &= TARGET_PAGE_MASK; +- for (addr = start; addr < end; addr += TARGET_PAGE_SIZE) { +- if (test_bit(addr >> TARGET_PAGE_BITS, +- ram_list.dirty_memory[client])) { +- return true; +- } +- } +- return false; ++ end = TARGET_PAGE_ALIGN(start + length) >> TARGET_PAGE_BITS; ++ page = start >> TARGET_PAGE_BITS; ++ next = find_next_bit(ram_list.dirty_memory[client], end, page); ++ ++ return next < end; + } + + static inline bool cpu_physical_memory_get_dirty_flag(ram_addr_t addr, +-- +1.7.1 + diff --git a/SOURCES/kvm-mempath-prefault-fix-off-by-one-error.patch b/SOURCES/kvm-mempath-prefault-fix-off-by-one-error.patch new file mode 100644 index 0000000..e1d64b3 --- /dev/null +++ b/SOURCES/kvm-mempath-prefault-fix-off-by-one-error.patch @@ -0,0 +1,43 @@ +From 3dfe8a98ffab1c5194818f623f4bcf80d49f3a07 Mon Sep 17 00:00:00 2001 +From: Marcelo Tosatti +Date: Mon, 24 Feb 2014 14:59:16 +0100 +Subject: [PATCH 1/7] mempath prefault: fix off-by-one error + +RH-Author: Marcelo Tosatti +Message-id: <20140224145916.GA9047@amt.cnet> +Patchwork-id: 57767 +O-Subject: [RHEL7 qemu-kvm PATCH] mempath prefault: fix off-by-one error +Bugzilla: 1069039 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Radim Krcmar +RH-Acked-by: Andrea Arcangeli + +commit 2ba82852894c762299b7d05e9a2be184116b80f0 of uq/master branch +of qemu-kvm.git + +Fix off-by-one error (noticed by Andrea Arcangeli). + +Reviewed-by: Paolo Bonzini +Signed-off-by: Marcelo Tosatti +BZ: 1069039 +Signed-off-by: Miroslav Rezanina +--- + exec.c | 2 +- + 1 files changed, 1 insertions(+), 1 deletions(-) + +diff --git a/exec.c b/exec.c +index 6fe2fe7..b7d9e1a 100644 +--- a/exec.c ++++ b/exec.c +@@ -980,7 +980,7 @@ static void *file_ram_alloc(RAMBlock *block, + } + + /* MAP_POPULATE silently ignores failures */ +- for (i = 0; i < (memory/hpagesize)-1; i++) { ++ for (i = 0; i < (memory/hpagesize); i++) { + memset(area + (hpagesize*i), 0, 1); + } + +-- +1.7.1 + diff --git a/SOURCES/kvm-mempath-prefault-pages-manually-v4.patch b/SOURCES/kvm-mempath-prefault-pages-manually-v4.patch new file mode 100644 index 0000000..d7f980c --- /dev/null +++ b/SOURCES/kvm-mempath-prefault-pages-manually-v4.patch @@ -0,0 +1,170 @@ +From 0de3b24dc9428a37330f9065bc3626a3a07a9200 Mon Sep 17 00:00:00 2001 +Message-Id: <0de3b24dc9428a37330f9065bc3626a3a07a9200.1387382496.git.minovotn@redhat.com> +In-Reply-To: +References: +From: Marcelo Tosatti +Date: Thu, 12 Dec 2013 01:36:44 +0100 +Subject: [PATCH 46/46] mempath: prefault pages manually (v4) + +RH-Author: Marcelo Tosatti +Message-id: <20131212013644.GA8646@amt.cnet> +Patchwork-id: 56243 +O-Subject: [RHEL7 qemu-kvm PATCH] mempath: prefault pages manually (v4) +Bugzilla: 1026554 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Igor Mammedov +RH-Acked-by: Andrew Jones + +commit ef36fa1492e9105f3fa607b56edc63df513d7da1 upstream + +v4: s/fail/failed/ (Peter Maydell) + +Signed-off-by: Paolo Bonzini +Signed-off-by: Marcelo Tosatti +BZ: 1026554 +Signed-off-by: Michal Novotny +--- + exec.c | 59 +++++++++++++++++++++++++++++++++++++++++++++------------ + qemu-options.hx | 2 -- + vl.c | 4 ---- + 3 files changed, 47 insertions(+), 18 deletions(-) + +diff --git a/exec.c b/exec.c +index 64af205..571cea4 100644 +--- a/exec.c ++++ b/exec.c +@@ -865,6 +865,13 @@ static long gethugepagesize(const char *path) + return fs.f_bsize; + } + ++static sigjmp_buf sigjump; ++ ++static void sigbus_handler(int signal) ++{ ++ siglongjmp(sigjump, 1); ++} ++ + static void *file_ram_alloc(RAMBlock *block, + ram_addr_t memory, + const char *path) +@@ -874,9 +881,6 @@ static void *file_ram_alloc(RAMBlock *block, + char *c; + void *area; + int fd; +-#ifdef MAP_POPULATE +- int flags; +-#endif + unsigned long hpagesize; + + hpagesize = gethugepagesize(path); +@@ -924,21 +928,52 @@ static void *file_ram_alloc(RAMBlock *block, + if (ftruncate(fd, memory)) + perror("ftruncate"); + +-#ifdef MAP_POPULATE +- /* NB: MAP_POPULATE won't exhaustively alloc all phys pages in the case +- * MAP_PRIVATE is requested. For mem_prealloc we mmap as MAP_SHARED +- * to sidestep this quirk. +- */ +- flags = mem_prealloc ? MAP_POPULATE | MAP_SHARED : MAP_PRIVATE; +- area = mmap(0, memory, PROT_READ | PROT_WRITE, flags, fd, 0); +-#else + area = mmap(0, memory, PROT_READ | PROT_WRITE, MAP_PRIVATE, fd, 0); +-#endif + if (area == MAP_FAILED) { + perror("file_ram_alloc: can't mmap RAM pages"); + close(fd); + return (NULL); + } ++ ++ if (mem_prealloc) { ++ int ret, i; ++ struct sigaction act, oldact; ++ sigset_t set, oldset; ++ ++ memset(&act, 0, sizeof(act)); ++ act.sa_handler = &sigbus_handler; ++ act.sa_flags = 0; ++ ++ ret = sigaction(SIGBUS, &act, &oldact); ++ if (ret) { ++ perror("file_ram_alloc: failed to install signal handler"); ++ exit(1); ++ } ++ ++ /* unblock SIGBUS */ ++ sigemptyset(&set); ++ sigaddset(&set, SIGBUS); ++ pthread_sigmask(SIG_UNBLOCK, &set, &oldset); ++ ++ if (sigsetjmp(sigjump, 1)) { ++ fprintf(stderr, "file_ram_alloc: failed to preallocate pages\n"); ++ exit(1); ++ } ++ ++ /* MAP_POPULATE silently ignores failures */ ++ for (i = 0; i < (memory/hpagesize)-1; i++) { ++ memset(area + (hpagesize*i), 0, 1); ++ } ++ ++ ret = sigaction(SIGBUS, &oldact, NULL); ++ if (ret) { ++ perror("file_ram_alloc: failed to reinstall signal handler"); ++ exit(1); ++ } ++ ++ pthread_sigmask(SIG_SETMASK, &oldset, NULL); ++ } ++ + block->fd = fd; + return area; + } +diff --git a/qemu-options.hx b/qemu-options.hx +index e3c5d67..d9320b5 100644 +--- a/qemu-options.hx ++++ b/qemu-options.hx +@@ -228,7 +228,6 @@ STEXI + Allocate guest RAM from a temporarily created file in @var{path}. + ETEXI + +-#ifdef MAP_POPULATE + DEF("mem-prealloc", 0, QEMU_OPTION_mem_prealloc, + "-mem-prealloc preallocate guest memory (use with -mem-path)\n", + QEMU_ARCH_ALL) +@@ -237,7 +236,6 @@ STEXI + @findex -mem-prealloc + Preallocate memory when using -mem-path. + ETEXI +-#endif + + DEF("k", HAS_ARG, QEMU_OPTION_k, + "-k language use keyboard layout (for example 'fr' for French)\n", +diff --git a/vl.c b/vl.c +index 0cbbdf0..da12b90 100644 +--- a/vl.c ++++ b/vl.c +@@ -188,9 +188,7 @@ static int display_remote; + const char* keyboard_layout = NULL; + ram_addr_t ram_size; + const char *mem_path = NULL; +-#ifdef MAP_POPULATE + int mem_prealloc = 0; /* force preallocation of physical target memory */ +-#endif + int nb_nics; + NICInfo nd_table[MAX_NICS]; + int autostart; +@@ -3174,11 +3172,9 @@ int main(int argc, char **argv, char **envp) + case QEMU_OPTION_mempath: + mem_path = optarg; + break; +-#ifdef MAP_POPULATE + case QEMU_OPTION_mem_prealloc: + mem_prealloc = 1; + break; +-#endif + case QEMU_OPTION_d: + log_mask = optarg; + break; +-- +1.7.11.7 + diff --git a/SOURCES/kvm-migration-Fail-migration-on-bdrv_flush_all-error.patch b/SOURCES/kvm-migration-Fail-migration-on-bdrv_flush_all-error.patch new file mode 100644 index 0000000..4c5dbe9 --- /dev/null +++ b/SOURCES/kvm-migration-Fail-migration-on-bdrv_flush_all-error.patch @@ -0,0 +1,92 @@ +From 0262e36cb9326586a82985b1c26ee8cf9c6e0578 Mon Sep 17 00:00:00 2001 +Message-Id: <0262e36cb9326586a82985b1c26ee8cf9c6e0578.1387382496.git.minovotn@redhat.com> +In-Reply-To: +References: +From: Nigel Croxon +Date: Thu, 14 Nov 2013 22:52:39 +0100 +Subject: [PATCH 03/46] migration: Fail migration on bdrv_flush_all() error + +RH-Author: Nigel Croxon +Message-id: <1384469598-13137-4-git-send-email-ncroxon@redhat.com> +Patchwork-id: 55687 +O-Subject: [RHEL7.0 PATCH 03/42] migration: Fail migration on bdrv_flush_all() error +Bugzilla: 1011720 +RH-Acked-by: Orit Wasserman +RH-Acked-by: Amit Shah +RH-Acked-by: Paolo Bonzini + +Bugzilla: 1011720 +https://bugzilla.redhat.com/show_bug.cgi?id=1011720 + +>From commit ID: +commit 0e1146a7a011a69d8cbc958b4f7ebad186730fc3 +Author: Kevin Wolf +Date: Fri Jul 5 13:54:55 2013 +0200 + + migration: Fail migration on bdrv_flush_all() error + + If bdrv_flush_all() returns an error, there is an inconsistency in the + view of an image file between the source and the destination host. + Completing the migration would lead to corruption. Better abort + migration in this case. + + To reproduce this case, try the following (ensures that there is + something to flush, and then fails that flush): + + $ qemu-img create -f qcow2 test.qcow2 1G + $ cat blkdebug.cfg + [inject-error] + event = "flush_to_os" + errno = "5" + $ qemu-system-x86_64 -hda blkdebug:blkdebug.cfg:test.qcow2 -monitor stdio + (qemu) qemu-io ide0-hd0 "write 0 4k" + (qemu) migrate ... + + Signed-off-by: Kevin Wolf + Reviewed-by: Stefan Hajnoczi +--- + migration.c | 17 ++++++++++++++--- + 1 files changed, 14 insertions(+), 3 deletions(-) + +Signed-off-by: Michal Novotny +--- + migration.c | 17 ++++++++++++++--- + 1 file changed, 14 insertions(+), 3 deletions(-) + +diff --git a/migration.c b/migration.c +index d91e702..3520776 100644 +--- a/migration.c ++++ b/migration.c +@@ -542,15 +542,26 @@ static void *migration_thread(void *opaque) + if (pending_size && pending_size >= max_size) { + qemu_savevm_state_iterate(s->file); + } else { ++ int ret; ++ + DPRINTF("done iterating\n"); + qemu_mutex_lock_iothread(); + start_time = qemu_get_clock_ms(rt_clock); + qemu_system_wakeup_request(QEMU_WAKEUP_REASON_OTHER); + old_vm_running = runstate_is_running(); +- vm_stop_force_state(RUN_STATE_FINISH_MIGRATE); +- qemu_file_set_rate_limit(s->file, INT_MAX); +- qemu_savevm_state_complete(s->file); ++ ++ ret = vm_stop_force_state(RUN_STATE_FINISH_MIGRATE); ++ if (ret >= 0) { ++ qemu_file_set_rate_limit(s->file, INT_MAX); ++ qemu_savevm_state_complete(s->file); ++ } + qemu_mutex_unlock_iothread(); ++ ++ if (ret < 0) { ++ migrate_finish_set_state(s, MIG_STATE_ERROR); ++ break; ++ } ++ + if (!qemu_file_get_error(s->file)) { + migrate_finish_set_state(s, MIG_STATE_COMPLETED); + break; +-- +1.7.11.7 + diff --git a/SOURCES/kvm-migration-Fix-debug-print-type.patch b/SOURCES/kvm-migration-Fix-debug-print-type.patch new file mode 100644 index 0000000..5c1bcad --- /dev/null +++ b/SOURCES/kvm-migration-Fix-debug-print-type.patch @@ -0,0 +1,58 @@ +From 69e9d2cbd41bf6884d2259675cd58b891c6df2de Mon Sep 17 00:00:00 2001 +Message-Id: <69e9d2cbd41bf6884d2259675cd58b891c6df2de.1387382496.git.minovotn@redhat.com> +In-Reply-To: +References: +From: Nigel Croxon +Date: Thu, 14 Nov 2013 22:53:14 +0100 +Subject: [PATCH 38/46] migration: Fix debug print type + +RH-Author: Nigel Croxon +Message-id: <1384469598-13137-39-git-send-email-ncroxon@redhat.com> +Patchwork-id: 55724 +O-Subject: [RHEL7.0 PATCH 38/42] migration: Fix debug print type +Bugzilla: 1011720 +RH-Acked-by: Orit Wasserman +RH-Acked-by: Amit Shah +RH-Acked-by: Paolo Bonzini + +Bugzilla: 1011720 +https://bugzilla.redhat.com/show_bug.cgi?id=1011720 + +>From commit ID: +commit 5016e2df569bc7d67637060103dd360ed2f0d557 +Author: Christoffer Dall +Date: Fri Aug 23 10:34:16 2013 -0700 + + migration: Fix debug print type + + The printf args are uint64_t and with -Werr QEMU doesn't compile with + migration debugging turned on unless this is fixed. Fix it. + + Signed-off-by: Christoffer Dall + Signed-off-by: Juan Quintela +--- + migration.c | 3 ++- + 1 files changed, 2 insertions(+), 1 deletions(-) + +Signed-off-by: Michal Novotny +--- + migration.c | 3 ++- + 1 file changed, 2 insertions(+), 1 deletion(-) + +diff --git a/migration.c b/migration.c +index 4f070a3..c0202b4 100644 +--- a/migration.c ++++ b/migration.c +@@ -574,7 +574,8 @@ static void *migration_thread(void *opaque) + if (!qemu_file_rate_limit(s->file)) { + DPRINTF("iterate\n"); + pending_size = qemu_savevm_state_pending(s->file, max_size); +- DPRINTF("pending size %lu max %lu\n", pending_size, max_size); ++ DPRINTF("pending size %" PRIu64 " max %" PRIu64 "\n", ++ pending_size, max_size); + if (pending_size && pending_size >= max_size) { + qemu_savevm_state_iterate(s->file); + } else { +-- +1.7.11.7 + diff --git a/SOURCES/kvm-migration-Fix-rate-limit.patch b/SOURCES/kvm-migration-Fix-rate-limit.patch new file mode 100644 index 0000000..3c5d374 --- /dev/null +++ b/SOURCES/kvm-migration-Fix-rate-limit.patch @@ -0,0 +1,50 @@ +From 43f7374cfc7133025aa4c94f51d6733ee89b713d Mon Sep 17 00:00:00 2001 +From: "Dr. David Alan Gilbert (git)" +Date: Tue, 14 Jan 2014 15:27:12 -0500 +Subject: [PATCH 03/14] migration: Fix rate limit + +Message-id: <1389713232-30999-3-git-send-email-dgilbert@redhat.com> +Patchwork-id: 56698 +O-Subject: [RHEL-7.0 qemu-kvm PATCH 2/2] migration: Fix rate limit +Bugzilla: 1003467 +RH-Acked-by: Orit Wasserman +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Laszlo Ersek + +From: Matthew Garrett + +The migration thread appears to want to allow writeout to occur at full +speed rather than being rate limited during completion of state saving, +but sets the limit to INT_MAX when xfer_limit is INT64_MAX. This causes +problems if there's more than 2GB of state left to save at this point. It +probably ought to just be INT64_MAX instead. + +Signed-off-by: Matthew Garrett +Reviewed-by: Paolo Bonzini +Signed-off-by: Juan Quintela +(cherry picked from commit 40596834c0d57a223124a956ccbe39dfeadc9f0e) +--- + migration.c | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +Signed-off-by: Miroslav Rezanina +--- + migration.c | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/migration.c b/migration.c +index 13fc59b..ef9a61f 100644 +--- a/migration.c ++++ b/migration.c +@@ -589,7 +589,7 @@ static void *migration_thread(void *opaque) + + ret = vm_stop_force_state(RUN_STATE_FINISH_MIGRATE); + if (ret >= 0) { +- qemu_file_set_rate_limit(s->file, INT_MAX); ++ qemu_file_set_rate_limit(s->file, INT64_MAX); + qemu_savevm_state_complete(s->file); + } + qemu_mutex_unlock_iothread(); +-- +1.8.3.1 + diff --git a/SOURCES/kvm-migration-fix-free-XBZRLE-decoded_buf-wrong.patch b/SOURCES/kvm-migration-fix-free-XBZRLE-decoded_buf-wrong.patch new file mode 100644 index 0000000..f245acc --- /dev/null +++ b/SOURCES/kvm-migration-fix-free-XBZRLE-decoded_buf-wrong.patch @@ -0,0 +1,140 @@ +From 0726ca63bf611741889fb77f68afd9e7e18d4e47 Mon Sep 17 00:00:00 2001 +From: Orit Wasserman +Date: Tue, 11 Feb 2014 14:56:37 +0100 +Subject: [PATCH 18/28] migration:fix free XBZRLE decoded_buf wrong + +RH-Author: Orit Wasserman +Message-id: <1392130597-23600-3-git-send-email-owasserm@redhat.com> +Patchwork-id: 57213 +O-Subject: [RHEL7 qemu-kvm PATCH 2/2] migration:fix free XBZRLE decoded_buf wrong +Bugzilla: 1038540 +RH-Acked-by: Marcel Apfelbaum +RH-Acked-by: Dr. David Alan Gilbert (git) +RH-Acked-by: Juan Quintela + +From: "Gonglei (Arei)" + +When qemu do live migration with xbzrle, qemu malloc decoded_buf +at destination end but free it at source end. It will crash qemu +by double free error in some scenarios. Splitting the XBZRLE structure +for clear logic distinguishing src/dst side. + +Signed-off-by: ChenLiang +Reviewed-by: Peter Maydell +Reviewed-by: Orit Wasserman +Signed-off-by: GongLei +Signed-off-by: Juan Quintela +(cherry picked from commit 905f26f2221e139ac0e7317ddac158c50f5cf876) +--- + arch_init.c | 22 ++++++++++++---------- + include/migration/migration.h | 1 + + migration.c | 1 + + 3 files changed, 14 insertions(+), 10 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + arch_init.c | 22 ++++++++++++---------- + include/migration/migration.h | 1 + + migration.c | 1 + + 3 files changed, 14 insertions(+), 10 deletions(-) + +diff --git a/arch_init.c b/arch_init.c +index 65148d6..31bf690 100644 +--- a/arch_init.c ++++ b/arch_init.c +@@ -164,17 +164,15 @@ static struct { + uint8_t *encoded_buf; + /* buffer for storing page content */ + uint8_t *current_buf; +- /* buffer used for XBZRLE decoding */ +- uint8_t *decoded_buf; + /* Cache for XBZRLE */ + PageCache *cache; + } XBZRLE = { + .encoded_buf = NULL, + .current_buf = NULL, +- .decoded_buf = NULL, + .cache = NULL, + }; +- ++/* buffer used for XBZRLE decoding */ ++static uint8_t *xbzrle_decoded_buf; + + int64_t xbzrle_cache_resize(int64_t new_size) + { +@@ -608,6 +606,12 @@ uint64_t ram_bytes_total(void) + return total; + } + ++void free_xbzrle_decoded_buf(void) ++{ ++ g_free(xbzrle_decoded_buf); ++ xbzrle_decoded_buf = NULL; ++} ++ + static void migration_end(void) + { + if (migration_bitmap) { +@@ -621,11 +625,9 @@ static void migration_end(void) + g_free(XBZRLE.cache); + g_free(XBZRLE.encoded_buf); + g_free(XBZRLE.current_buf); +- g_free(XBZRLE.decoded_buf); + XBZRLE.cache = NULL; + XBZRLE.encoded_buf = NULL; + XBZRLE.current_buf = NULL; +- XBZRLE.decoded_buf = NULL; + } + } + +@@ -830,8 +832,8 @@ static int load_xbzrle(QEMUFile *f, ram_addr_t addr, void *host) + unsigned int xh_len; + int xh_flags; + +- if (!XBZRLE.decoded_buf) { +- XBZRLE.decoded_buf = g_malloc(TARGET_PAGE_SIZE); ++ if (!xbzrle_decoded_buf) { ++ xbzrle_decoded_buf = g_malloc(TARGET_PAGE_SIZE); + } + + /* extract RLE header */ +@@ -848,10 +850,10 @@ static int load_xbzrle(QEMUFile *f, ram_addr_t addr, void *host) + return -1; + } + /* load data and decode */ +- qemu_get_buffer(f, XBZRLE.decoded_buf, xh_len); ++ qemu_get_buffer(f, xbzrle_decoded_buf, xh_len); + + /* decode RLE */ +- ret = xbzrle_decode_buffer(XBZRLE.decoded_buf, xh_len, host, ++ ret = xbzrle_decode_buffer(xbzrle_decoded_buf, xh_len, host, + TARGET_PAGE_SIZE); + if (ret == -1) { + fprintf(stderr, "Failed to load XBZRLE page - decode error!\n"); +diff --git a/include/migration/migration.h b/include/migration/migration.h +index 140e6b4..9314511 100644 +--- a/include/migration/migration.h ++++ b/include/migration/migration.h +@@ -98,6 +98,7 @@ MigrationState *migrate_get_current(void); + uint64_t ram_bytes_remaining(void); + uint64_t ram_bytes_transferred(void); + uint64_t ram_bytes_total(void); ++void free_xbzrle_decoded_buf(void); + + void acct_update_position(QEMUFile *f, size_t size, bool zero); + +diff --git a/migration.c b/migration.c +index b6de990..93de654 100644 +--- a/migration.c ++++ b/migration.c +@@ -104,6 +104,7 @@ static void process_incoming_migration_co(void *opaque) + + ret = qemu_loadvm_state(f); + qemu_fclose(f); ++ free_xbzrle_decoded_buf(); + if (ret < 0) { + fprintf(stderr, "load of migration failed\n"); + exit(EXIT_FAILURE); +-- +1.7.1 + diff --git a/SOURCES/kvm-migration-fix-spice-migration.patch b/SOURCES/kvm-migration-fix-spice-migration.patch new file mode 100644 index 0000000..e971e74 --- /dev/null +++ b/SOURCES/kvm-migration-fix-spice-migration.patch @@ -0,0 +1,114 @@ +From 7861f4a9c8f7125b758e9be430b195527db83430 Mon Sep 17 00:00:00 2001 +Message-Id: <7861f4a9c8f7125b758e9be430b195527db83430.1387382496.git.minovotn@redhat.com> +In-Reply-To: +References: +From: Nigel Croxon +Date: Thu, 14 Nov 2013 22:53:17 +0100 +Subject: [PATCH 41/46] migration: fix spice migration + +RH-Author: Nigel Croxon +Message-id: <1384469598-13137-42-git-send-email-ncroxon@redhat.com> +Patchwork-id: 55722 +O-Subject: [RHEL7.0 PATCH 41/42] migration: fix spice migration +Bugzilla: 1011720 +RH-Acked-by: Orit Wasserman +RH-Acked-by: Amit Shah +RH-Acked-by: Paolo Bonzini + +Bugzilla: 1011720 +https://bugzilla.redhat.com/show_bug.cgi?id=1011720 + +>From commit ID: +commit 02edd2e7665bceb307bedd8afe625c0f7e8d7cfa +Author: Stefan Hajnoczi +Date: Mon Jul 29 15:01:58 2013 +0200 + + migration: fix spice migration + + Commit 29ae8a4133082e16970c9d4be09f4b6a15034617 ("rdma: introduce + MIG_STATE_NONE and change MIG_STATE_SETUP state transition") changed the + state transitions during migration setup. + + Spice used to be notified with MIG_STATE_ACTIVE and it detected this + using migration_is_active(). Spice is now notified with + MIG_STATE_SETUP and migration_is_active() no longer works. + + Replace migration_is_active() with migration_in_setup() to fix spice + migration. + + Cc: Michael R. Hines + Reviewed-by: Kevin Wolf + Signed-off-by: Stefan Hajnoczi +--- + hw/block/virtio-blk.c | 2 +- + include/migration/migration.h | 2 +- + migration.c | 4 ++-- + ui/spice-core.c | 2 +- + 4 files changed, 5 insertions(+), 5 deletions(-) + +Signed-off-by: Michal Novotny +--- + hw/block/virtio-blk.c | 2 +- + include/migration/migration.h | 2 +- + migration.c | 4 ++-- + ui/spice-core.c | 2 +- + 4 files changed, 5 insertions(+), 5 deletions(-) + +diff --git a/hw/block/virtio-blk.c b/hw/block/virtio-blk.c +index 9fe622d..49a23c3 100644 +--- a/hw/block/virtio-blk.c ++++ b/hw/block/virtio-blk.c +@@ -658,7 +658,7 @@ static void virtio_blk_migration_state_changed(Notifier *notifier, void *data) + migration_state_notifier); + MigrationState *mig = data; + +- if (migration_is_active(mig)) { ++ if (migration_in_setup(mig)) { + if (!s->dataplane) { + return; + } +diff --git a/include/migration/migration.h b/include/migration/migration.h +index 08c772d..140e6b4 100644 +--- a/include/migration/migration.h ++++ b/include/migration/migration.h +@@ -90,7 +90,7 @@ int migrate_fd_close(MigrationState *s); + + void add_migration_state_change_notifier(Notifier *notify); + void remove_migration_state_change_notifier(Notifier *notify); +-bool migration_is_active(MigrationState *); ++bool migration_in_setup(MigrationState *); + bool migration_has_finished(MigrationState *); + bool migration_has_failed(MigrationState *); + MigrationState *migrate_get_current(void); +diff --git a/migration.c b/migration.c +index c0202b4..13fc59b 100644 +--- a/migration.c ++++ b/migration.c +@@ -339,9 +339,9 @@ void remove_migration_state_change_notifier(Notifier *notify) + notifier_remove(notify); + } + +-bool migration_is_active(MigrationState *s) ++bool migration_in_setup(MigrationState *s) + { +- return s->state == MIG_STATE_ACTIVE; ++ return s->state == MIG_STATE_SETUP; + } + + bool migration_has_finished(MigrationState *s) +diff --git a/ui/spice-core.c b/ui/spice-core.c +index c8337ab..d67449e 100644 +--- a/ui/spice-core.c ++++ b/ui/spice-core.c +@@ -561,7 +561,7 @@ static void migration_state_notifier(Notifier *notifier, void *data) + { + MigrationState *s = data; + +- if (migration_is_active(s)) { ++ if (migration_in_setup(s)) { + spice_server_migrate_start(spice_server); + } else if (migration_has_finished(s)) { + spice_server_migrate_end(spice_server, true); +-- +1.7.11.7 + diff --git a/SOURCES/kvm-migration-omit-drive-ref-as-we-have-bdrv_ref-now.patch b/SOURCES/kvm-migration-omit-drive-ref-as-we-have-bdrv_ref-now.patch new file mode 100644 index 0000000..89150bc --- /dev/null +++ b/SOURCES/kvm-migration-omit-drive-ref-as-we-have-bdrv_ref-now.patch @@ -0,0 +1,56 @@ +From 375004355689da9457ce5df62849d74cebd1c0c0 Mon Sep 17 00:00:00 2001 +From: Fam Zheng +Date: Fri, 17 Jan 2014 03:07:49 +0100 +Subject: [PATCH 06/34] migration: omit drive ref as we have bdrv_ref now + +RH-Author: Fam Zheng +Message-id: <1389928083-8921-5-git-send-email-famz@redhat.com> +Patchwork-id: 56766 +O-Subject: [RHEL-7 qemu-kvm PATCH 04/18] migration: omit drive ref as we have bdrv_ref now +Bugzilla: 1041301 +RH-Acked-by: Jeffrey Cody +RH-Acked-by: Kevin Wolf +RH-Acked-by: Stefan Hajnoczi + +block-migration.c does not actually use DriveInfo anywhere. Hence it's +safe to drive ref code, we really only care about referencing BDS. + +Signed-off-by: Fam Zheng +Signed-off-by: Stefan Hajnoczi +(cherry picked from commit 8442cfd0346de849264494c5adedbac12553867e) +Signed-off-by: Fam Zheng +--- + block-migration.c | 4 ++-- + 1 file changed, 2 insertions(+), 2 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + block-migration.c | 4 ++-- + 1 files changed, 2 insertions(+), 2 deletions(-) + +diff --git a/block-migration.c b/block-migration.c +index 1844066..fc4ef93 100644 +--- a/block-migration.c ++++ b/block-migration.c +@@ -336,8 +336,8 @@ static void init_blk_migration_it(void *opaque, BlockDriverState *bs) + bmds->completed_sectors = 0; + bmds->shared_base = block_mig_state.shared_base; + alloc_aio_bitmap(bmds); +- drive_get_ref(drive_get_by_blockdev(bs)); + bdrv_set_in_use(bs, 1); ++ bdrv_ref(bs); + + block_mig_state.total_sector_sum += sectors; + +@@ -575,7 +575,7 @@ static void blk_mig_cleanup(void) + while ((bmds = QSIMPLEQ_FIRST(&block_mig_state.bmds_list)) != NULL) { + QSIMPLEQ_REMOVE_HEAD(&block_mig_state.bmds_list, entry); + bdrv_set_in_use(bmds->bs, 0); +- drive_put_ref(drive_get_by_blockdev(bmds->bs)); ++ bdrv_unref(bmds->bs); + g_free(bmds->aio_bitmap); + g_free(bmds); + } +-- +1.7.1 + diff --git a/SOURCES/kvm-migration-ram_handle_compressed.patch b/SOURCES/kvm-migration-ram_handle_compressed.patch new file mode 100644 index 0000000..5811605 --- /dev/null +++ b/SOURCES/kvm-migration-ram_handle_compressed.patch @@ -0,0 +1,68 @@ +From 325f2d5f89e8275844a08c5fd0ea0e2ebe4874ca Mon Sep 17 00:00:00 2001 +Message-Id: <325f2d5f89e8275844a08c5fd0ea0e2ebe4874ca.1387382496.git.minovotn@redhat.com> +In-Reply-To: +References: +From: Nigel Croxon +Date: Thu, 14 Nov 2013 22:53:16 +0100 +Subject: [PATCH 40/46] migration: ram_handle_compressed + +RH-Author: Nigel Croxon +Message-id: <1384469598-13137-41-git-send-email-ncroxon@redhat.com> +Patchwork-id: 55727 +O-Subject: [RHEL7.0 PATCH 40/42] migration: ram_handle_compressed +Bugzilla: 1011720 +RH-Acked-by: Orit Wasserman +RH-Acked-by: Amit Shah +RH-Acked-by: Paolo Bonzini + +Bugzilla: 1011720 +https://bugzilla.redhat.com/show_bug.cgi?id=1011720 + +>From commit ID: +commit d613a56f845788412a442c6b5aff88b38244f99a +Author: Isaku Yamahata +Date: Sat Sep 21 01:23:37 2013 +0900 + + migration: ram_handle_compressed + + ram_handle_compressed() should be aware of size > TARGET_PAGE_SIZE. + migration-rdma can call it with larger size. + + Signed-off-by: Isaku Yamahata + Signed-off-by: Juan Quintela +--- + arch_init.c | 11 ++++++----- + 1 files changed, 6 insertions(+), 5 deletions(-) + +Signed-off-by: Michal Novotny +--- + arch_init.c | 11 ++++++----- + 1 file changed, 6 insertions(+), 5 deletions(-) + +diff --git a/arch_init.c b/arch_init.c +index 5ce9c61..d71fb33 100644 +--- a/arch_init.c ++++ b/arch_init.c +@@ -848,13 +848,14 @@ static inline void *host_from_stream_offset(QEMUFile *f, + */ + void ram_handle_compressed(void *host, uint8_t ch, uint64_t size) + { +- if (ch != 0 || !is_zero_range(host, TARGET_PAGE_SIZE)) { ++ if (ch != 0 || !is_zero_range(host, size)) { + memset(host, ch, size); + #ifndef _WIN32 +- if (ch == 0 && +- (!kvm_enabled() || kvm_has_sync_mmu()) && +- getpagesize() <= TARGET_PAGE_SIZE) { +- qemu_madvise(host, TARGET_PAGE_SIZE, QEMU_MADV_DONTNEED); ++ if (ch == 0 && (!kvm_enabled() || kvm_has_sync_mmu())) { ++ size = size & ~(getpagesize() - 1); ++ if (size > 0) { ++ qemu_madvise(host, size, QEMU_MADV_DONTNEED); ++ } + } + #endif + } +-- +1.7.11.7 + diff --git a/SOURCES/kvm-migration-synchronize-memory-bitmap-64bits-at-a-time.patch b/SOURCES/kvm-migration-synchronize-memory-bitmap-64bits-at-a-time.patch new file mode 100644 index 0000000..4b53258 --- /dev/null +++ b/SOURCES/kvm-migration-synchronize-memory-bitmap-64bits-at-a-time.patch @@ -0,0 +1,88 @@ +From 7471a0a26dde86aa466e2183c6e43df9c01250d6 Mon Sep 17 00:00:00 2001 +From: Juan Quintela +Date: Tue, 14 Jan 2014 15:07:51 +0100 +Subject: [PATCH 40/40] migration: synchronize memory bitmap 64bits at a time + +RH-Author: Juan Quintela +Message-id: <1389712071-23303-41-git-send-email-quintela@redhat.com> +Patchwork-id: 56695 +O-Subject: [RHEL7 qemu-kvm PATCH 40/40] migration: synchronize memory bitmap 64bits at a time +Bugzilla: 997559 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Orit Wasserman +RH-Acked-by: Dr. David Alan Gilbert (git) + +We use the old code if the bitmaps are not aligned + +Signed-off-by: Juan Quintela +Reviewed-by: Orit Wasserman +(cherry picked from commit aa8dc044772ba156cbcf2174b5673cfa11f566a7) +Signed-off-by: Juan Quintela +--- + arch_init.c | 38 +++++++++++++++++++++++++++++--------- + 1 file changed, 29 insertions(+), 9 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + arch_init.c | 38 +++++++++++++++++++++++++++++--------- + 1 files changed, 29 insertions(+), 9 deletions(-) + +diff --git a/arch_init.c b/arch_init.c +index 23650e7..31aac84 100644 +--- a/arch_init.c ++++ b/arch_init.c +@@ -50,6 +50,7 @@ + #include "exec/cpu-all.h" + #include "exec/ram_addr.h" + #include "hw/acpi/acpi.h" ++#include "qemu/host-utils.h" + + #ifdef DEBUG_ARCH_INIT + #define DPRINTF(fmt, ...) \ +@@ -376,15 +377,34 @@ static inline bool migration_bitmap_set_dirty(ram_addr_t addr) + static void migration_bitmap_sync_range(ram_addr_t start, ram_addr_t length) + { + ram_addr_t addr; +- +- for (addr = 0; addr < length; addr += TARGET_PAGE_SIZE) { +- if (cpu_physical_memory_get_dirty(start + addr, +- TARGET_PAGE_SIZE, +- DIRTY_MEMORY_MIGRATION)) { +- cpu_physical_memory_reset_dirty(start + addr, +- TARGET_PAGE_SIZE, +- DIRTY_MEMORY_MIGRATION); +- migration_bitmap_set_dirty(start + addr); ++ unsigned long page = BIT_WORD(start >> TARGET_PAGE_BITS); ++ ++ /* start address is aligned at the start of a word? */ ++ if (((page * BITS_PER_LONG) << TARGET_PAGE_BITS) == start) { ++ int k; ++ int nr = BITS_TO_LONGS(length >> TARGET_PAGE_BITS); ++ unsigned long *src = ram_list.dirty_memory[DIRTY_MEMORY_MIGRATION]; ++ ++ for (k = page; k < page + nr; k++) { ++ if (src[k]) { ++ unsigned long new_dirty; ++ new_dirty = ~migration_bitmap[k]; ++ migration_bitmap[k] |= src[k]; ++ new_dirty &= src[k]; ++ migration_dirty_pages += ctpopl(new_dirty); ++ src[k] = 0; ++ } ++ } ++ } else { ++ for (addr = 0; addr < length; addr += TARGET_PAGE_SIZE) { ++ if (cpu_physical_memory_get_dirty(start + addr, ++ TARGET_PAGE_SIZE, ++ DIRTY_MEMORY_MIGRATION)) { ++ cpu_physical_memory_reset_dirty(start + addr, ++ TARGET_PAGE_SIZE, ++ DIRTY_MEMORY_MIGRATION); ++ migration_bitmap_set_dirty(start + addr); ++ } + } + } + } +-- +1.7.1 + diff --git a/SOURCES/kvm-milkymist-minimac2-Fix-minimac2_read-_write-tracepoi.patch b/SOURCES/kvm-milkymist-minimac2-Fix-minimac2_read-_write-tracepoi.patch new file mode 100644 index 0000000..8ec6fd5 --- /dev/null +++ b/SOURCES/kvm-milkymist-minimac2-Fix-minimac2_read-_write-tracepoi.patch @@ -0,0 +1,51 @@ +From 52f4da1d90ef6a6c56d7e6016539c0054066c458 Mon Sep 17 00:00:00 2001 +Message-Id: <52f4da1d90ef6a6c56d7e6016539c0054066c458.1387276076.git.minovotn@redhat.com> +In-Reply-To: +References: +From: Markus Armbruster +Date: Tue, 10 Dec 2013 15:12:52 +0100 +Subject: [PATCH 11/16] milkymist-minimac2: Fix minimac2_read/_write + tracepoints + +RH-Author: Markus Armbruster +Message-id: <1386688376-29521-4-git-send-email-armbru@redhat.com> +Patchwork-id: 56111 +O-Subject: [PATCH 7.0 qemu-kvm 3/7] milkymist-minimac2: Fix minimac2_read/_write tracepoints +Bugzilla: 997832 +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Eduardo Habkost +RH-Acked-by: Laszlo Ersek + +From: Markus Armbruster + +Broken in milkymist-minimac.c from the start (commit 0742454), +faithfully moved to milkymist-minimac2.c (commit 57aa265). + +Signed-off-by: Markus Armbruster +Signed-off-by: Stefan Hajnoczi +(cherry picked from commit 0ece9671fd22e3ea518aa30f941e8794116985e7) +--- + hw/net/milkymist-minimac2.c | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +Signed-off-by: Michal Novotny +--- + hw/net/milkymist-minimac2.c | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/hw/net/milkymist-minimac2.c b/hw/net/milkymist-minimac2.c +index 4ef6318..7448777 100644 +--- a/hw/net/milkymist-minimac2.c ++++ b/hw/net/milkymist-minimac2.c +@@ -355,7 +355,7 @@ minimac2_write(void *opaque, hwaddr addr, uint64_t value, + { + MilkymistMinimac2State *s = opaque; + +- trace_milkymist_minimac2_memory_read(addr, value); ++ trace_milkymist_minimac2_memory_write(addr, value); + + addr >>= 2; + switch (addr) { +-- +1.7.11.7 + diff --git a/SOURCES/kvm-mirror-Don-t-close-target.patch b/SOURCES/kvm-mirror-Don-t-close-target.patch new file mode 100644 index 0000000..c47ea45 --- /dev/null +++ b/SOURCES/kvm-mirror-Don-t-close-target.patch @@ -0,0 +1,45 @@ +From 6fe6f64923937e725013de1a8e5f7d7b10047787 Mon Sep 17 00:00:00 2001 +From: Fam Zheng +Date: Fri, 17 Jan 2014 03:07:57 +0100 +Subject: [PATCH 14/34] mirror: Don't close target + +RH-Author: Fam Zheng +Message-id: <1389928083-8921-13-git-send-email-famz@redhat.com> +Patchwork-id: 56774 +O-Subject: [RHEL-7 qemu-kvm PATCH 12/18] mirror: Don't close target +Bugzilla: 1041301 +RH-Acked-by: Jeffrey Cody +RH-Acked-by: Kevin Wolf +RH-Acked-by: Stefan Hajnoczi + +Let reference count manage target and don't call bdrv_close here. + +Signed-off-by: Fam Zheng +Reviewed-by: Kevin Wolf +Signed-off-by: Stefan Hajnoczi +(cherry picked from commit f95c625ce4cb7863795fcc36502ac58a44fdb2f1) +Signed-off-by: Fam Zheng +--- + block/mirror.c | 1 - + 1 file changed, 1 deletion(-) + +Signed-off-by: Miroslav Rezanina +--- + block/mirror.c | 1 - + 1 files changed, 0 insertions(+), 1 deletions(-) + +diff --git a/block/mirror.c b/block/mirror.c +index 8837186..1e3337f 100644 +--- a/block/mirror.c ++++ b/block/mirror.c +@@ -479,7 +479,6 @@ immediate_exit: + } + bdrv_swap(s->target, s->common.bs); + } +- bdrv_close(s->target); + bdrv_unref(s->target); + block_job_completed(&s->common, ret); + } +-- +1.7.1 + diff --git a/SOURCES/kvm-mirror-Move-base-to-MirrorBlockJob.patch b/SOURCES/kvm-mirror-Move-base-to-MirrorBlockJob.patch new file mode 100644 index 0000000..7fcc6b9 --- /dev/null +++ b/SOURCES/kvm-mirror-Move-base-to-MirrorBlockJob.patch @@ -0,0 +1,85 @@ +From 1098dfcaf705697337694269c4990d2fb58347a6 Mon Sep 17 00:00:00 2001 +From: Fam Zheng +Date: Fri, 17 Jan 2014 03:07:58 +0100 +Subject: [PATCH 15/34] mirror: Move base to MirrorBlockJob + +RH-Author: Fam Zheng +Message-id: <1389928083-8921-14-git-send-email-famz@redhat.com> +Patchwork-id: 56775 +O-Subject: [RHEL-7 qemu-kvm PATCH 13/18] mirror: Move base to MirrorBlockJob +Bugzilla: 1041301 +RH-Acked-by: Jeffrey Cody +RH-Acked-by: Kevin Wolf +RH-Acked-by: Stefan Hajnoczi + +This allows setting the base before entering mirror_run, commit will +make use of it. + +Signed-off-by: Fam Zheng +Reviewed-by: Kevin Wolf +Signed-off-by: Stefan Hajnoczi +(cherry picked from commit 5bc361b8134eff68e2c40916d1cf58b3523d223b) +Signed-off-by: Fam Zheng +--- + block/mirror.c | 12 ++++++++++-- + 1 file changed, 10 insertions(+), 2 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + block/mirror.c | 12 ++++++++++-- + 1 files changed, 10 insertions(+), 2 deletions(-) + +diff --git a/block/mirror.c b/block/mirror.c +index 1e3337f..8ccde2f 100644 +--- a/block/mirror.c ++++ b/block/mirror.c +@@ -31,6 +31,7 @@ typedef struct MirrorBlockJob { + BlockJob common; + RateLimit limit; + BlockDriverState *target; ++ BlockDriverState *base; + MirrorSyncMode mode; + BlockdevOnError on_source_error, on_target_error; + bool synced; +@@ -334,8 +335,7 @@ static void coroutine_fn mirror_run(void *opaque) + + if (s->mode != MIRROR_SYNC_MODE_NONE) { + /* First part, loop on the sectors and initialize the dirty bitmap. */ +- BlockDriverState *base; +- base = s->mode == MIRROR_SYNC_MODE_FULL ? NULL : bs->backing_hd; ++ BlockDriverState *base = s->base; + for (sector_num = 0; sector_num < end; ) { + int64_t next = (sector_num | (sectors_per_chunk - 1)) + 1; + ret = bdrv_is_allocated_above(bs, base, +@@ -540,6 +540,7 @@ void mirror_start(BlockDriverState *bs, BlockDriverState *target, + void *opaque, Error **errp) + { + MirrorBlockJob *s; ++ BlockDriverState *base = NULL; + + if (granularity == 0) { + /* Choose the default granularity based on the target file's cluster +@@ -562,6 +563,12 @@ void mirror_start(BlockDriverState *bs, BlockDriverState *target, + return; + } + ++ if (mode == MIRROR_SYNC_MODE_TOP) { ++ base = bs->backing_hd; ++ } else { ++ base = NULL; ++ } ++ + s = block_job_create(&mirror_job_driver, bs, speed, cb, opaque, errp); + if (!s) { + return; +@@ -571,6 +578,7 @@ void mirror_start(BlockDriverState *bs, BlockDriverState *target, + s->on_target_error = on_target_error; + s->target = target; + s->mode = mode; ++ s->base = base; + s->granularity = granularity; + s->buf_size = MAX(buf_size, granularity); + +-- +1.7.1 + diff --git a/SOURCES/kvm-misc-Disable-EFI-enabled-roms.patch b/SOURCES/kvm-misc-Disable-EFI-enabled-roms.patch index 506674f..0088d2c 100644 --- a/SOURCES/kvm-misc-Disable-EFI-enabled-roms.patch +++ b/SOURCES/kvm-misc-Disable-EFI-enabled-roms.patch @@ -113,5 +113,3 @@ index 161ade3..d82f6ff 100644 k->vendor_id = PCI_VENDOR_ID_REDHAT_QUMRANET; k->device_id = PCI_DEVICE_ID_VIRTIO_NET; k->revision = VIRTIO_PCI_ABI_VERSION; -diff --git a/redhat/qemu-kvm.spec.template b/redhat/qemu-kvm.spec.template -index d1fb86f..95a1660 100644 diff --git a/SOURCES/kvm-monitor-Cleanup-mon-outbuf-on-write-error.patch b/SOURCES/kvm-monitor-Cleanup-mon-outbuf-on-write-error.patch new file mode 100644 index 0000000..f1884c6 --- /dev/null +++ b/SOURCES/kvm-monitor-Cleanup-mon-outbuf-on-write-error.patch @@ -0,0 +1,57 @@ +From f917e135d99ab0749ab747b3abce45e78de8c479 Mon Sep 17 00:00:00 2001 +From: Amit Shah +Date: Fri, 14 Feb 2014 08:27:07 +0100 +Subject: [PATCH 3/3] monitor: Cleanup mon->outbuf on write error + +RH-Author: Amit Shah +Message-id: +Patchwork-id: 57275 +O-Subject: [RHEL 7.0 qemu-kvm PATCH 1/1] monitor: Cleanup mon->outbuf on write error +Bugzilla: 1065225 +RH-Acked-by: Laszlo Ersek +RH-Acked-by: Markus Armbruster +RH-Acked-by: Luiz Capitulino + +From: Stratos Psomadakis + +In case monitor_flush() fails to write the contents of mon->outbuf to +the output device, mon->outbuf is not cleaned up properly. Check the +return code of the qemu_chr_fe_write() function and cleanup the outbuf +if it fails. + +References: http://lists.nongnu.org/archive/html/qemu-devel/2014-01/msg02890.html + +Bugzilla: 1065225 + +Signed-off-by: Stratos Psomadakis +Signed-off-by: Dimitris Aragiorgis +Signed-off-by: Luiz Capitulino +(cherry picked from commit 056f49ff2cf645dc484956b00b65a3aa18a1a9a3) +Signed-off-by: Amit Shah +--- + monitor.c | 4 ++-- + 1 file changed, 2 insertions(+), 2 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + monitor.c | 4 ++-- + 1 files changed, 2 insertions(+), 2 deletions(-) + +diff --git a/monitor.c b/monitor.c +index 8f36f91..a6abfb5 100644 +--- a/monitor.c ++++ b/monitor.c +@@ -287,8 +287,8 @@ void monitor_flush(Monitor *mon) + + if (len && !mon->mux_out) { + rc = qemu_chr_fe_write(mon->chr, (const uint8_t *) buf, len); +- if (rc == len) { +- /* all flushed */ ++ if ((rc < 0 && errno != EAGAIN) || (rc == len)) { ++ /* all flushed or error */ + QDECREF(mon->outbuf); + mon->outbuf = qstring_new(); + return; +-- +1.7.1 + diff --git a/SOURCES/kvm-nbd-use-BlockDriverState-refcnt.patch b/SOURCES/kvm-nbd-use-BlockDriverState-refcnt.patch new file mode 100644 index 0000000..8a840f6 --- /dev/null +++ b/SOURCES/kvm-nbd-use-BlockDriverState-refcnt.patch @@ -0,0 +1,89 @@ +From 33eef488233850a3eeb806bf11d562c86eaacb72 Mon Sep 17 00:00:00 2001 +From: Fam Zheng +Date: Fri, 17 Jan 2014 03:07:51 +0100 +Subject: [PATCH 08/34] nbd: use BlockDriverState refcnt + +RH-Author: Fam Zheng +Message-id: <1389928083-8921-7-git-send-email-famz@redhat.com> +Patchwork-id: 56768 +O-Subject: [RHEL-7 qemu-kvm PATCH 06/18] nbd: use BlockDriverState refcnt +Bugzilla: 1041301 +RH-Acked-by: Jeffrey Cody +RH-Acked-by: Kevin Wolf +RH-Acked-by: Stefan Hajnoczi + +Previously, nbd calls drive_get_ref() on the drive of bs. A BDS doesn't +always have associated dinfo, which nbd doesn't care either. We already +have BDS ref count, so use it to make it safe for a BDS w/o blockdev. + +Signed-off-by: Fam Zheng +Signed-off-by: Stefan Hajnoczi +(cherry picked from commit 38b54b6dc18ae7e2a32e5ae38b312fb13f0584c8) +Signed-off-by: Fam Zheng +--- + blockdev-nbd.c | 10 +--------- + nbd.c | 5 +++++ + 2 files changed, 6 insertions(+), 9 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + blockdev-nbd.c | 10 +--------- + nbd.c | 5 +++++ + 2 files changed, 6 insertions(+), 9 deletions(-) + +diff --git a/blockdev-nbd.c b/blockdev-nbd.c +index 95f10c8..922cf56 100644 +--- a/blockdev-nbd.c ++++ b/blockdev-nbd.c +@@ -69,12 +69,6 @@ static void nbd_close_notifier(Notifier *n, void *data) + g_free(cn); + } + +-static void nbd_server_put_ref(NBDExport *exp) +-{ +- BlockDriverState *bs = nbd_export_get_blockdev(exp); +- drive_put_ref(drive_get_by_blockdev(bs)); +-} +- + void qmp_nbd_server_add(const char *device, bool has_writable, bool writable, + Error **errp) + { +@@ -105,11 +99,9 @@ void qmp_nbd_server_add(const char *device, bool has_writable, bool writable, + writable = false; + } + +- exp = nbd_export_new(bs, 0, -1, writable ? 0 : NBD_FLAG_READ_ONLY, +- nbd_server_put_ref); ++ exp = nbd_export_new(bs, 0, -1, writable ? 0 : NBD_FLAG_READ_ONLY, NULL); + + nbd_export_set_name(exp, device); +- drive_get_ref(drive_get_by_blockdev(bs)); + + n = g_malloc0(sizeof(NBDCloseNotifier)); + n->n.notify = nbd_close_notifier; +diff --git a/nbd.c b/nbd.c +index 2606403..f258cdd 100644 +--- a/nbd.c ++++ b/nbd.c +@@ -881,6 +881,7 @@ NBDExport *nbd_export_new(BlockDriverState *bs, off_t dev_offset, + exp->nbdflags = nbdflags; + exp->size = size == -1 ? bdrv_getlength(bs) : size; + exp->close = close; ++ bdrv_ref(bs); + return exp; + } + +@@ -927,6 +928,10 @@ void nbd_export_close(NBDExport *exp) + } + nbd_export_set_name(exp, NULL); + nbd_export_put(exp); ++ if (exp->bs) { ++ bdrv_unref(exp->bs); ++ exp->bs = NULL; ++ } + } + + void nbd_export_get(NBDExport *exp) +-- +1.7.1 + diff --git a/SOURCES/kvm-net-Update-netdev-peer-on-link-change.patch b/SOURCES/kvm-net-Update-netdev-peer-on-link-change.patch new file mode 100644 index 0000000..af5ac8d --- /dev/null +++ b/SOURCES/kvm-net-Update-netdev-peer-on-link-change.patch @@ -0,0 +1,89 @@ +From 6fa94ac455819e37a16ed8439be4bbf0b869884c Mon Sep 17 00:00:00 2001 +Message-Id: <6fa94ac455819e37a16ed8439be4bbf0b869884c.1387276076.git.minovotn@redhat.com> +In-Reply-To: +References: +From: Vlad Yasevich +Date: Wed, 11 Dec 2013 21:40:06 +0100 +Subject: [PATCH 16/16] net: Update netdev peer on link change + +RH-Author: Vlad Yasevich +Message-id: <1386798006-31753-1-git-send-email-vyasevic@redhat.com> +Patchwork-id: 56241 +O-Subject: [RHEL 7.0 qemu PATCH] net: Update netdev peer on link change +Bugzilla: 1027571 +RH-Acked-by: Amos Kong +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Xiao Wang + +BZ: https://bugzilla.redhat.com/show_bug.cgi?id=1027571 +Brew: http://brewweb.devel.redhat.com/brew/taskinfo?taskID=6714640 + +When a link change occurs on a backend (like tap), we currently do +not propage such change to the nic. As a result, when someone turns +off a link on a tap device, for instance, then a guest doesn't see +that change and continues to try to send traffic or run DHCP even +though the lower-layer is disconnected. This is OK when the network +is set up as a HUB since the the guest may be connected to other HUB +ports too, but when it's set up as a netdev, it makes thinkgs worse. + +The patch addresses this by setting the peers link down only when the +peer is not a HUBPORT device. With this patch, in the following config + -netdev tap,id=net0 -device e1000,mac=XXXXX,netdev=net0 +when net0 link is turned off, the guest e1000 shows lower-layer link +down. This allows guests to boot much faster in such configurations. +With windows guest, it also allows the network to recover properly +since windows will not configure the link-local IPv4 address, and +when the link is turned on, the proper address address is configured. + +Signed-off-by: Vlad Yasevich +Signed-off-by: Stefan Hajnoczi +(cherry picked from commit 02d38fcb2caa4454cf4ed728d5908c3cc9ba47be) +--- + net/net.c | 26 +++++++++++++++++--------- + 1 file changed, 17 insertions(+), 9 deletions(-) + +Signed-off-by: Michal Novotny +--- + net/net.c | 26 +++++++++++++++++--------- + 1 file changed, 17 insertions(+), 9 deletions(-) + +diff --git a/net/net.c b/net/net.c +index c0d61bf..a8c49fc 100644 +--- a/net/net.c ++++ b/net/net.c +@@ -1059,15 +1059,23 @@ void qmp_set_link(const char *name, bool up, Error **errp) + nc->info->link_status_changed(nc); + } + +- /* Notify peer. Don't update peer link status: this makes it possible to +- * disconnect from host network without notifying the guest. +- * FIXME: is disconnected link status change operation useful? +- * +- * Current behaviour is compatible with qemu vlans where there could be +- * multiple clients that can still communicate with each other in +- * disconnected mode. For now maintain this compatibility. */ +- if (nc->peer && nc->peer->info->link_status_changed) { +- nc->peer->info->link_status_changed(nc->peer); ++ if (nc->peer) { ++ /* Change peer link only if the peer is NIC and then notify peer. ++ * If the peer is a HUBPORT or a backend, we do not change the ++ * link status. ++ * ++ * This behavior is compatible with qemu vlans where there could be ++ * multiple clients that can still communicate with each other in ++ * disconnected mode. For now maintain this compatibility. ++ */ ++ if (nc->peer->info->type == NET_CLIENT_OPTIONS_KIND_NIC) { ++ for (i = 0; i < queues; i++) { ++ ncs[i]->peer->link_down = !up; ++ } ++ } ++ if (nc->peer->info->link_status_changed) { ++ nc->peer->info->link_status_changed(nc->peer); ++ } + } + } + +-- +1.7.11.7 + diff --git a/SOURCES/kvm-option-Add-assigned-flag-to-QEMUOptionParameter.patch b/SOURCES/kvm-option-Add-assigned-flag-to-QEMUOptionParameter.patch new file mode 100644 index 0000000..9f960b9 --- /dev/null +++ b/SOURCES/kvm-option-Add-assigned-flag-to-QEMUOptionParameter.patch @@ -0,0 +1,92 @@ +From 5902165e0f08a265b0bb422f13e161bd4de37eb3 Mon Sep 17 00:00:00 2001 +From: Max Reitz +Date: Tue, 7 Jan 2014 21:57:06 +0100 +Subject: [PATCH 01/14] option: Add assigned flag to QEMUOptionParameter + +RH-Author: Max Reitz +Message-id: <1389131839-12920-2-git-send-email-mreitz@redhat.com> +Patchwork-id: 56537 +O-Subject: [RHEL-7.0 qemu-kvm PATCH v2 01/14] option: Add assigned flag to QEMUOptionParameter +Bugzilla: 1033490 +RH-Acked-by: Kevin Wolf +RH-Acked-by: Fam Zheng +RH-Acked-by: Stefan Hajnoczi + +BZ: 1033490 + +Adds an "assigned" flag to QEMUOptionParameter which is cleared at the +beginning of parse_option_parameters and set on (successful) +set_option_parameter and set_option_parameter_int. + +Signed-off-by: Max Reitz +Signed-off-by: Kevin Wolf +(cherry picked from commit d4ca092a423f1f853a99357bab01a168bb57d625) + +Signed-off-by: Max Reitz +--- + include/qemu/option.h | 1 + + util/qemu-option.c | 9 +++++++++ + 2 files changed, 10 insertions(+) + +Signed-off-by: Miroslav Rezanina +--- + include/qemu/option.h | 1 + + util/qemu-option.c | 9 +++++++++ + 2 files changed, 10 insertions(+), 0 deletions(-) + +diff --git a/include/qemu/option.h b/include/qemu/option.h +index 96f70b6..5c0c6dd 100644 +--- a/include/qemu/option.h ++++ b/include/qemu/option.h +@@ -46,6 +46,7 @@ typedef struct QEMUOptionParameter { + char* s; + } value; + const char *help; ++ bool assigned; + } QEMUOptionParameter; + + +diff --git a/util/qemu-option.c b/util/qemu-option.c +index 1cefbfe..2445406 100644 +--- a/util/qemu-option.c ++++ b/util/qemu-option.c +@@ -275,6 +275,8 @@ int set_option_parameter(QEMUOptionParameter *list, const char *name, + return -1; + } + ++ list->assigned = true; ++ + return 0; + } + +@@ -306,6 +308,8 @@ int set_option_parameter_int(QEMUOptionParameter *list, const char *name, + return -1; + } + ++ list->assigned = true; ++ + return 0; + } + +@@ -397,6 +401,7 @@ QEMUOptionParameter *parse_option_parameters(const char *param, + char value[256]; + char *param_delim, *value_delim; + char next_delim; ++ int i; + + if (list == NULL) { + return NULL; +@@ -406,6 +411,10 @@ QEMUOptionParameter *parse_option_parameters(const char *param, + dest = allocated = append_option_parameters(NULL, list); + } + ++ for (i = 0; dest[i].name; i++) { ++ dest[i].assigned = false; ++ } ++ + while (*param) { + + // Find parameter name and value in the string +-- +1.7.1 + diff --git a/SOURCES/kvm-parallels-Fix-catalog-size-integer-overflow-CVE-2014.patch b/SOURCES/kvm-parallels-Fix-catalog-size-integer-overflow-CVE-2014.patch new file mode 100644 index 0000000..1559eb5 --- /dev/null +++ b/SOURCES/kvm-parallels-Fix-catalog-size-integer-overflow-CVE-2014.patch @@ -0,0 +1,206 @@ +From eabeace95bfc1dd3c2280105c4fa83195c7bd4bd Mon Sep 17 00:00:00 2001 +From: Kevin Wolf +Date: Tue, 25 Mar 2014 14:23:54 +0100 +Subject: [PATCH 47/49] parallels: Fix catalog size integer overflow (CVE-2014-0143) + +RH-Author: Kevin Wolf +Message-id: <1395753835-7591-48-git-send-email-kwolf@redhat.com> +Patchwork-id: n/a +O-Subject: [virt-devel] [EMBARGOED RHEL-7.0 qemu-kvm PATCH 47/48] parallels: Fix catalog size integer overflow (CVE-2014-0143) +Bugzilla: 1079320 +RH-Acked-by: Jeff Cody +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Paolo Bonzini + +Bugzilla: https://bugzilla.redhat.com/show_bug.cgi?id=1079320 +Upstream status: Embargoed + +The first test case would cause a huge memory allocation, leading to a +qemu abort; the second one to a too small malloc() for the catalog +(smaller than s->catalog_size), which causes a read-only out-of-bounds +array access and on big endian hosts an endianess conversion for an +undefined memory area. + +The sample image used here is not an original Parallels image. It was +created using an hexeditor on the basis of the struct that qemu uses. +Good enough for trying to crash the driver, but not for ensuring +compatibility. + +Signed-off-by: Kevin Wolf + +Conflicts: +tests/qemu-iotests/group + +Signed-off-by: Kevin Wolf +--- + block/parallels.c | 7 ++- + tests/qemu-iotests/076 | 69 ++++++++++++++++++++ + tests/qemu-iotests/076.out | 14 ++++ + tests/qemu-iotests/common | 7 ++ + tests/qemu-iotests/group | 1 + + .../qemu-iotests/sample_images/fake.parallels.bz2 | Bin 0 -> 141 bytes + 6 files changed, 97 insertions(+), 1 deletions(-) + create mode 100755 tests/qemu-iotests/076 + create mode 100644 tests/qemu-iotests/076.out + create mode 100644 tests/qemu-iotests/sample_images/fake.parallels.bz2 + +diff --git a/block/parallels.c b/block/parallels.c +index 2121e43..5d1c0af 100644 +--- a/block/parallels.c ++++ b/block/parallels.c +@@ -49,7 +49,7 @@ typedef struct BDRVParallelsState { + CoMutex lock; + + uint32_t *catalog_bitmap; +- int catalog_size; ++ unsigned int catalog_size; + + int tracks; + } BDRVParallelsState; +@@ -94,6 +94,11 @@ static int parallels_open(BlockDriverState *bs, QDict *options, int flags, + s->tracks = le32_to_cpu(ph.tracks); + + s->catalog_size = le32_to_cpu(ph.catalog_entries); ++ if (s->catalog_size > INT_MAX / 4) { ++ error_setg(errp, "Catalog too large"); ++ ret = -EFBIG; ++ goto fail; ++ } + s->catalog_bitmap = g_malloc(s->catalog_size * 4); + + ret = bdrv_pread(bs->file, 64, s->catalog_bitmap, s->catalog_size * 4); +diff --git a/tests/qemu-iotests/076 b/tests/qemu-iotests/076 +new file mode 100755 +index 0000000..6028ac5 +--- /dev/null ++++ b/tests/qemu-iotests/076 +@@ -0,0 +1,69 @@ ++#!/bin/bash ++# ++# parallels format input validation tests ++# ++# Copyright (C) 2013 Red Hat, Inc. ++# ++# This program is free software; you can redistribute it and/or modify ++# it under the terms of the GNU General Public License as published by ++# the Free Software Foundation; either version 2 of the License, or ++# (at your option) any later version. ++# ++# This program is distributed in the hope that it will be useful, ++# but WITHOUT ANY WARRANTY; without even the implied warranty of ++# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++# GNU General Public License for more details. ++# ++# You should have received a copy of the GNU General Public License ++# along with this program. If not, see . ++# ++ ++# creator ++owner=kwolf@redhat.com ++ ++seq=`basename $0` ++echo "QA output created by $seq" ++ ++here=`pwd` ++tmp=/tmp/$$ ++status=1 # failure is the default! ++ ++_cleanup() ++{ ++ _cleanup_test_img ++} ++trap "_cleanup; exit \$status" 0 1 2 3 15 ++ ++# get standard environment, filters and checks ++. ./common.rc ++. ./common.filter ++ ++_supported_fmt parallels ++_supported_proto generic ++_supported_os Linux ++ ++catalog_entries_offset=$((0x20)) ++nb_sectors_offset=$((0x24)) ++ ++echo ++echo "== Read from a valid (enough) image ==" ++_use_sample_img fake.parallels.bz2 ++{ $QEMU_IO -c "read -P 0x11 0 64k" $TEST_IMG; } 2>&1 | _filter_qemu_io | _filter_testdir ++ ++echo ++echo "== Negative catalog size ==" ++_use_sample_img fake.parallels.bz2 ++poke_file "$TEST_IMG" "$catalog_entries_offset" "\xff\xff\xff\xff" ++{ $QEMU_IO -c "read 0 512" $TEST_IMG; } 2>&1 | _filter_qemu_io | _filter_testdir ++ ++echo ++echo "== Overflow in catalog allocation ==" ++_use_sample_img fake.parallels.bz2 ++poke_file "$TEST_IMG" "$nb_sectors_offset" "\xff\xff\xff\xff" ++poke_file "$TEST_IMG" "$catalog_entries_offset" "\x01\x00\x00\x40" ++{ $QEMU_IO -c "read 64M 64M" $TEST_IMG; } 2>&1 | _filter_qemu_io | _filter_testdir ++ ++# success, all done ++echo "*** done" ++rm -f $seq.full ++status=0 +diff --git a/tests/qemu-iotests/076.out b/tests/qemu-iotests/076.out +new file mode 100644 +index 0000000..12af42a +--- /dev/null ++++ b/tests/qemu-iotests/076.out +@@ -0,0 +1,14 @@ ++QA output created by 076 ++ ++== Read from a valid (enough) image == ++read 65536/65536 bytes at offset 0 ++64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) ++ ++== Negative catalog size == ++qemu-io: can't open device TEST_DIR/fake.parallels: Catalog too large ++no file open, try 'help open' ++ ++== Overflow in catalog allocation == ++qemu-io: can't open device TEST_DIR/fake.parallels: Catalog too large ++no file open, try 'help open' ++*** done +diff --git a/tests/qemu-iotests/common b/tests/qemu-iotests/common +index 35abbfc..f8c1b56 100644 +--- a/tests/qemu-iotests/common ++++ b/tests/qemu-iotests/common +@@ -131,6 +131,7 @@ check options + -bochs test bochs + -cow test cow + -cloop test cloop ++ -parallels test parallels + -qcow test qcow + -qcow2 test qcow2 + -qed test qed +@@ -181,6 +182,12 @@ testlist options + xpand=false + ;; + ++ -parallels) ++ IMGFMT=parallels ++ IMGFMT_GENERIC=false ++ xpand=false ++ ;; ++ + -qcow) + IMGFMT=qcow + xpand=false +diff --git a/tests/qemu-iotests/group b/tests/qemu-iotests/group +index e8ad780..ad96fcf 100644 +--- a/tests/qemu-iotests/group ++++ b/tests/qemu-iotests/group +@@ -72,6 +72,7 @@ + 068 rw auto + 070 rw auto + 075 rw auto ++076 auto + 077 rw auto + 078 rw auto + 079 rw auto +-- +1.7.1 + diff --git a/SOURCES/kvm-parallels-Sanity-check-for-s-tracks-CVE-2014-0142.patch b/SOURCES/kvm-parallels-Sanity-check-for-s-tracks-CVE-2014-0142.patch new file mode 100644 index 0000000..b91bc2f --- /dev/null +++ b/SOURCES/kvm-parallels-Sanity-check-for-s-tracks-CVE-2014-0142.patch @@ -0,0 +1,96 @@ +From 8d0f3218313c74d2e9df015385b809a7cb03734e Mon Sep 17 00:00:00 2001 +From: Kevin Wolf +Date: Tue, 25 Mar 2014 14:23:55 +0100 +Subject: [PATCH 48/49] parallels: Sanity check for s->tracks (CVE-2014-0142) + +RH-Author: Kevin Wolf +Message-id: <1395753835-7591-49-git-send-email-kwolf@redhat.com> +Patchwork-id: n/a +O-Subject: [virt-devel] [EMBARGOED RHEL-7.0 qemu-kvm PATCH 48/48] parallels: Sanity check for s->tracks (CVE-2014-0142) +Bugzilla: 1079315 +RH-Acked-by: Jeff Cody +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Paolo Bonzini + +Bugzilla: https://bugzilla.redhat.com/show_bug.cgi?id=1079315 +Upstream status: Embargoed + +This avoids a possible division by zero. + +Convert s->tracks to unsigned as well because it feels better than +surviving just because the results of calculations with s->tracks are +converted to unsigned anyway. + +Signed-off-by: Kevin Wolf +--- + block/parallels.c | 7 ++++++- + tests/qemu-iotests/076 | 7 +++++++ + tests/qemu-iotests/076.out | 4 ++++ + 3 files changed, 17 insertions(+), 1 deletions(-) + +diff --git a/block/parallels.c b/block/parallels.c +index 5d1c0af..d83cde4 100644 +--- a/block/parallels.c ++++ b/block/parallels.c +@@ -51,7 +51,7 @@ typedef struct BDRVParallelsState { + uint32_t *catalog_bitmap; + unsigned int catalog_size; + +- int tracks; ++ unsigned int tracks; + } BDRVParallelsState; + + static int parallels_probe(const uint8_t *buf, int buf_size, const char *filename) +@@ -92,6 +92,11 @@ static int parallels_open(BlockDriverState *bs, QDict *options, int flags, + bs->total_sectors = le32_to_cpu(ph.nb_sectors); + + s->tracks = le32_to_cpu(ph.tracks); ++ if (s->tracks == 0) { ++ error_setg(errp, "Invalid image: Zero sectors per track"); ++ ret = -EINVAL; ++ goto fail; ++ } + + s->catalog_size = le32_to_cpu(ph.catalog_entries); + if (s->catalog_size > INT_MAX / 4) { +diff --git a/tests/qemu-iotests/076 b/tests/qemu-iotests/076 +index 6028ac5..b614a7d 100755 +--- a/tests/qemu-iotests/076 ++++ b/tests/qemu-iotests/076 +@@ -42,6 +42,7 @@ _supported_fmt parallels + _supported_proto generic + _supported_os Linux + ++tracks_offset=$((0x1c)) + catalog_entries_offset=$((0x20)) + nb_sectors_offset=$((0x24)) + +@@ -63,6 +64,12 @@ poke_file "$TEST_IMG" "$nb_sectors_offset" "\xff\xff\xff\xff" + poke_file "$TEST_IMG" "$catalog_entries_offset" "\x01\x00\x00\x40" + { $QEMU_IO -c "read 64M 64M" $TEST_IMG; } 2>&1 | _filter_qemu_io | _filter_testdir + ++echo ++echo "== Zero sectors per track ==" ++_use_sample_img fake.parallels.bz2 ++poke_file "$TEST_IMG" "$tracks_offset" "\x00\x00\x00\x00" ++{ $QEMU_IO -c "read 0 512" $TEST_IMG; } 2>&1 | _filter_qemu_io | _filter_testdir ++ + # success, all done + echo "*** done" + rm -f $seq.full +diff --git a/tests/qemu-iotests/076.out b/tests/qemu-iotests/076.out +index 12af42a..f7745d8 100644 +--- a/tests/qemu-iotests/076.out ++++ b/tests/qemu-iotests/076.out +@@ -11,4 +11,8 @@ no file open, try 'help open' + == Overflow in catalog allocation == + qemu-io: can't open device TEST_DIR/fake.parallels: Catalog too large + no file open, try 'help open' ++ ++== Zero sectors per track == ++qemu-io: can't open device TEST_DIR/fake.parallels: Invalid image: Zero sectors per track ++no file open, try 'help open' + *** done +-- +1.7.1 + diff --git a/SOURCES/kvm-pc-Add-RHEL6-e1000-gPXE-image.patch b/SOURCES/kvm-pc-Add-RHEL6-e1000-gPXE-image.patch new file mode 100644 index 0000000..8443110 --- /dev/null +++ b/SOURCES/kvm-pc-Add-RHEL6-e1000-gPXE-image.patch @@ -0,0 +1,55 @@ +From b7f8490681d9bfb5c47f250323e369bed1645aac Mon Sep 17 00:00:00 2001 +From: Eduardo Habkost +Date: Fri, 7 Mar 2014 18:37:48 +0100 +Subject: [PATCH 08/16] pc: Add RHEL6 e1000 gPXE image + +RH-Author: Eduardo Habkost +Message-id: <1394217468-2864-3-git-send-email-ehabkost@redhat.com> +Patchwork-id: 58050 +O-Subject: [RHEL7 qemu-kvm PATCH 2/2] pc: Add RHEL6 e1000 gPXE image +Bugzilla: 1073774 +RH-Acked-by: Juan Quintela +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Amos Kong + +Bugzilla: 1073774 +Brew scratch build: http://brewweb.devel.redhat.com/brew/taskinfo?taskID=7157997 + +The fix for bz#997702 didn't have the RHEL6 e1000 ROM. Add the e1000-0x100e.rom +file from gpxe-roms-qemu-0.9.7-6.9.el6.noarch.rpm. + +Signed-off-by: Eduardo Habkost +--- + hw/i386/pc_piix.c | 4 ++++ + redhat/Makefile.common | 2 +- + redhat/qemu-kvm.spec.template | 3 +++ + redhat/rhel6-e1000.rom | Bin 0 -> 69120 bytes + 4 files changed, 8 insertions(+), 1 deletion(-) + create mode 100644 redhat/rhel6-e1000.rom + +Signed-off-by: Miroslav Rezanina +--- + hw/i386/pc_piix.c | 4 ++++ + redhat/Makefile.common | 2 +- + redhat/qemu-kvm.spec.template | 3 +++ + redhat/rhel6-e1000.rom | Bin 0 -> 69120 bytes + 4 files changed, 8 insertions(+), 1 deletions(-) + create mode 100644 redhat/rhel6-e1000.rom + +diff --git a/hw/i386/pc_piix.c b/hw/i386/pc_piix.c +index 98a5253..6773fff 100644 +--- a/hw/i386/pc_piix.c ++++ b/hw/i386/pc_piix.c +@@ -897,6 +897,10 @@ static QEMUMachine pc_machine_rhel700 = { + .property = "romfile",\ + .value = "rhel6-rtl8139.rom",\ + },{\ ++ .driver = "e1000",\ ++ .property = "romfile",\ ++ .value = "rhel6-e1000.rom",\ ++ },{\ + .driver = "virtio-net-pci",\ + .property = "romfile",\ + .value = "rhel6-virtio.rom",\ +-- +1.7.1 diff --git a/SOURCES/kvm-pc-Create-pc_compat_rhel-functions.patch b/SOURCES/kvm-pc-Create-pc_compat_rhel-functions.patch new file mode 100644 index 0000000..2df1b06 --- /dev/null +++ b/SOURCES/kvm-pc-Create-pc_compat_rhel-functions.patch @@ -0,0 +1,195 @@ +From 9b80afa6377ff6cb0f0f28ab3719ddb5b61e4193 Mon Sep 17 00:00:00 2001 +From: Eduardo Habkost +Date: Mon, 20 Jan 2014 19:05:29 +0100 +Subject: [PATCH 32/34] pc: Create pc_compat_rhel*() functions + +RH-Author: Eduardo Habkost +Message-id: <1390244730-31038-2-git-send-email-ehabkost@redhat.com> +Patchwork-id: 56847 +O-Subject: [RHEL7 qemu-kvm PATCH 1/2] pc: Create pc_compat_rhel*() functions +Bugzilla: 1049706 +RH-Acked-by: Laszlo Ersek +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Bandan Das + +Bugzilla: 1049706 +Brew scratch build: http://brewweb.devel.redhat.com/brew/taskinfo?taskID=6900764 +Upstream status: not applicable + +This is the RHEL equivalent of upstream +commit 396f79f45ea75bd1c421522f29b4f91d490df7cc. + +With the previous code, the compat code for a newer release could undo +the compat changes made by the compat code for an older release. With +the pc_init_*()/pc_compat_*() pattern, we can have two compat functions +touching the same bits, as the older compat functions will run last, +allowing it to undo changes done by newer compat functions. + +Signed-off-by: Eduardo Habkost +--- + hw/i386/pc_piix.c | 59 ++++++++++++++++++++++++++++++++++++++++++++++--------- + hw/i386/pc_q35.c | 5 +++++ + 2 files changed, 55 insertions(+), 9 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + hw/i386/pc_piix.c | 59 ++++++++++++++++++++++++++++++++++++++++++++-------- + hw/i386/pc_q35.c | 5 ++++ + 2 files changed, 55 insertions(+), 9 deletions(-) + +diff --git a/hw/i386/pc_piix.c b/hw/i386/pc_piix.c +index e061877..769571c 100644 +--- a/hw/i386/pc_piix.c ++++ b/hw/i386/pc_piix.c +@@ -743,8 +743,13 @@ machine_init(pc_machine_init); + + /* Red Hat Enterprise Linux machine types */ + ++static void pc_compat_rhel700(QEMUMachineInitArgs *args) ++{ ++} ++ + static void pc_init_rhel700(QEMUMachineInitArgs *args) + { ++ pc_compat_rhel700(args); + pc_init_pci(args); + } + +@@ -868,8 +873,9 @@ static QEMUMachine pc_machine_rhel700 = { + .value = "rhel6-virtio.rom",\ + } + +-static void pc_init_rhel650(QEMUMachineInitArgs *args) ++static void pc_compat_rhel650(QEMUMachineInitArgs *args) + { ++ pc_compat_rhel700(args); + x86_cpu_compat_set_features("pentium", FEAT_1_EDX, 0, CPUID_APIC); + x86_cpu_compat_set_features("pentium2", FEAT_1_EDX, 0, CPUID_APIC); + x86_cpu_compat_set_features("pentium3", FEAT_1_EDX, 0, CPUID_APIC); +@@ -911,7 +917,12 @@ static void pc_init_rhel650(QEMUMachineInitArgs *args) + + rom_file_in_ram = false; + has_acpi_build = false; +- pc_init_rhel700(args); ++} ++ ++static void pc_init_rhel650(QEMUMachineInitArgs *args) ++{ ++ pc_compat_rhel650(args); ++ pc_init_pci(args); + } + + static QEMUMachine pc_machine_rhel650 = { +@@ -950,10 +961,16 @@ static QEMUMachine pc_machine_rhel650 = { + .value = "off",\ + } + +-static void pc_init_rhel640(QEMUMachineInitArgs *args) ++static void pc_compat_rhel640(QEMUMachineInitArgs *args) + { ++ pc_compat_rhel650(args); + x86_cpu_compat_set_features(NULL, FEAT_1_EDX, 0, CPUID_SEP); +- pc_init_rhel650(args); ++} ++ ++static void pc_init_rhel640(QEMUMachineInitArgs *args) ++{ ++ pc_compat_rhel640(args); ++ pc_init_pci(args); + } + + static QEMUMachine pc_machine_rhel640 = { +@@ -1016,13 +1033,19 @@ static QEMUMachine pc_machine_rhel640 = { + .value = "1",\ + } + +-static void pc_init_rhel630(QEMUMachineInitArgs *args) ++static void pc_compat_rhel630(QEMUMachineInitArgs *args) + { ++ pc_compat_rhel640(args); + disable_kvm_pv_eoi(); + enable_compat_apic_id_mode(); + x86_cpu_compat_set_features("SandyBridge", FEAT_1_ECX, + 0, CPUID_EXT_TSC_DEADLINE_TIMER); +- pc_init_rhel640(args); ++} ++ ++static void pc_init_rhel630(QEMUMachineInitArgs *args) ++{ ++ pc_compat_rhel630(args); ++ pc_init_pci(args); + } + + static QEMUMachine pc_machine_rhel630 = { +@@ -1045,9 +1068,15 @@ static QEMUMachine pc_machine_rhel630 = { + .value = "off",\ + } + ++static void pc_compat_rhel620(QEMUMachineInitArgs *args) ++{ ++ pc_compat_rhel630(args); ++} ++ + static void pc_init_rhel620(QEMUMachineInitArgs *args) + { +- pc_init_rhel630(args); ++ pc_compat_rhel620(args); ++ pc_init_pci(args); + } + + static QEMUMachine pc_machine_rhel620 = { +@@ -1111,9 +1140,15 @@ static QEMUMachine pc_machine_rhel620 = { + .value = "1",\ + } + ++static void pc_compat_rhel610(QEMUMachineInitArgs *args) ++{ ++ pc_compat_rhel620(args); ++} ++ + static void pc_init_rhel610(QEMUMachineInitArgs *args) + { +- pc_init_rhel620(args); ++ pc_compat_rhel610(args); ++ pc_init_pci(args); + } + + static QEMUMachine pc_machine_rhel610 = { +@@ -1144,9 +1179,15 @@ static QEMUMachine pc_machine_rhel610 = { + .value = stringify(0),\ + } + ++static void pc_compat_rhel600(QEMUMachineInitArgs *args) ++{ ++ pc_compat_rhel610(args); ++} ++ + static void pc_init_rhel600(QEMUMachineInitArgs *args) + { +- pc_init_rhel610(args); ++ pc_compat_rhel600(args); ++ pc_init_pci(args); + } + + static QEMUMachine pc_machine_rhel600 = { +diff --git a/hw/i386/pc_q35.c b/hw/i386/pc_q35.c +index 8d1a714..0280a95 100644 +--- a/hw/i386/pc_q35.c ++++ b/hw/i386/pc_q35.c +@@ -268,8 +268,13 @@ machine_init(pc_q35_machine_init); + + /* Red Hat Enterprise Linux machine types */ + ++static void pc_q35_compat_rhel700(QEMUMachineInitArgs *args) ++{ ++} ++ + static void pc_q35_init_rhel700(QEMUMachineInitArgs *args) + { ++ pc_q35_compat_rhel700(args); + pc_q35_init(args); + } + +-- +1.7.1 + diff --git a/SOURCES/kvm-pc-Disable-RDTSCP-on-AMD-CPU-models.patch b/SOURCES/kvm-pc-Disable-RDTSCP-on-AMD-CPU-models.patch new file mode 100644 index 0000000..cfaba14 --- /dev/null +++ b/SOURCES/kvm-pc-Disable-RDTSCP-on-AMD-CPU-models.patch @@ -0,0 +1,103 @@ +From 32c34876557574575cec036f09f7c826ccb4368a Mon Sep 17 00:00:00 2001 +From: Eduardo Habkost +Date: Mon, 27 Jan 2014 16:07:43 +0100 +Subject: [PATCH 21/22] pc: Disable RDTSCP on AMD CPU models + +RH-Author: Eduardo Habkost +Message-id: <1390838863-11030-3-git-send-email-ehabkost@redhat.com> +Patchwork-id: 56961 +O-Subject: [RHEL7 qemu-kvm PATCH v2 2/2] pc: Disable RDTSCP on AMD CPU models +Bugzilla: 1056428 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Igor Mammedov +RH-Acked-by: Miroslav Rezanina + +Bugzilla: 874400 +Upstream status: not applicable (see notes below) +Brew scratch build: http://brewweb.devel.redhat.com/brew/taskinfo?taskID=6953316 + +KVM can't expose RDTSCP to guests on AMD CPUs, so there's no point in +having RDTSCP enabled on AMD CPU models. + +About upstream status and rationale for making it RHEL-specific: + +This is another case where independently from the upstream decision, we +will want to add RHEL-specific code to fiddle with the CPU definitions. + +TCG does support RDTSCP, so it makes sense for upstream to keep RDTSCP +enabled on those CPU models. We, on the other hand, care about KVM and +know libvirt doesn't use enforce mode yet (but should eventually use +it), so it makes sense to disable RDTSCP on AMD models in RHEL. + +(This will eventually be a problem for libvirt upstream, when it starts +using or emulating "enforce" mode. I have added notes at: +http://wiki.qemu.org/Features/CPUModels#Disabling_features_that_were_always_disabled_on_KVM ) + +Changes v1 -> v2: + * Fix typo: "phenon" -> "phenom" + +Signed-off-by: Eduardo Habkost +--- + hw/i386/pc_piix.c | 14 ++++++++++++++ + hw/i386/pc_q35.c | 14 ++++++++++++++ + 2 files changed, 28 insertions(+) + +Signed-off-by: Miroslav Rezanina +--- + hw/i386/pc_piix.c | 14 ++++++++++++++ + hw/i386/pc_q35.c | 14 ++++++++++++++ + 2 files changed, 28 insertions(+), 0 deletions(-) + +diff --git a/hw/i386/pc_piix.c b/hw/i386/pc_piix.c +index b918f69..aac920a 100644 +--- a/hw/i386/pc_piix.c ++++ b/hw/i386/pc_piix.c +@@ -760,6 +760,20 @@ static void pc_compat_rhel700(QEMUMachineInitArgs *args) + x86_cpu_compat_set_features("Opteron_G3", FEAT_1_ECX, CPUID_EXT_X2APIC, 0); + x86_cpu_compat_set_features("Opteron_G4", FEAT_1_ECX, CPUID_EXT_X2APIC, 0); + x86_cpu_compat_set_features("Opteron_G5", FEAT_1_ECX, CPUID_EXT_X2APIC, 0); ++ ++ /* KVM can't expose RDTSCP on AMD CPUs, so there's no point in enabling it ++ * on AMD CPU models. ++ */ ++ x86_cpu_compat_set_features("phenom", FEAT_8000_0001_EDX, 0, ++ CPUID_EXT2_RDTSCP); ++ x86_cpu_compat_set_features("Opteron_G2", FEAT_8000_0001_EDX, 0, ++ CPUID_EXT2_RDTSCP); ++ x86_cpu_compat_set_features("Opteron_G3", FEAT_8000_0001_EDX, 0, ++ CPUID_EXT2_RDTSCP); ++ x86_cpu_compat_set_features("Opteron_G4", FEAT_8000_0001_EDX, 0, ++ CPUID_EXT2_RDTSCP); ++ x86_cpu_compat_set_features("Opteron_G5", FEAT_8000_0001_EDX, 0, ++ CPUID_EXT2_RDTSCP); + } + + static void pc_init_rhel700(QEMUMachineInitArgs *args) +diff --git a/hw/i386/pc_q35.c b/hw/i386/pc_q35.c +index 1ac46be..1aa8bde 100644 +--- a/hw/i386/pc_q35.c ++++ b/hw/i386/pc_q35.c +@@ -283,6 +283,20 @@ static void pc_q35_compat_rhel700(QEMUMachineInitArgs *args) + x86_cpu_compat_set_features("Opteron_G3", FEAT_1_ECX, CPUID_EXT_X2APIC, 0); + x86_cpu_compat_set_features("Opteron_G4", FEAT_1_ECX, CPUID_EXT_X2APIC, 0); + x86_cpu_compat_set_features("Opteron_G5", FEAT_1_ECX, CPUID_EXT_X2APIC, 0); ++ ++ /* KVM can't expose RDTSCP on AMD CPUs, so there's no point in enabling it ++ * on AMD CPU models. ++ */ ++ x86_cpu_compat_set_features("phenom", FEAT_8000_0001_EDX, 0, ++ CPUID_EXT2_RDTSCP); ++ x86_cpu_compat_set_features("Opteron_G2", FEAT_8000_0001_EDX, 0, ++ CPUID_EXT2_RDTSCP); ++ x86_cpu_compat_set_features("Opteron_G3", FEAT_8000_0001_EDX, 0, ++ CPUID_EXT2_RDTSCP); ++ x86_cpu_compat_set_features("Opteron_G4", FEAT_8000_0001_EDX, 0, ++ CPUID_EXT2_RDTSCP); ++ x86_cpu_compat_set_features("Opteron_G5", FEAT_8000_0001_EDX, 0, ++ CPUID_EXT2_RDTSCP); + } + + static void pc_q35_init_rhel700(QEMUMachineInitArgs *args) +-- +1.7.1 + diff --git a/SOURCES/kvm-pc-Disable-RDTSCP-unconditionally-on-rhel6.-machine-.patch b/SOURCES/kvm-pc-Disable-RDTSCP-unconditionally-on-rhel6.-machine-.patch new file mode 100644 index 0000000..21cf37c --- /dev/null +++ b/SOURCES/kvm-pc-Disable-RDTSCP-unconditionally-on-rhel6.-machine-.patch @@ -0,0 +1,71 @@ +From 26653f89373a3439d6dba73c660d00116c0dbbc0 Mon Sep 17 00:00:00 2001 +From: Eduardo Habkost +Date: Mon, 27 Jan 2014 16:07:42 +0100 +Subject: [PATCH 20/22] pc: Disable RDTSCP unconditionally on rhel6.* machine-types + +RH-Author: Eduardo Habkost +Message-id: <1390838863-11030-2-git-send-email-ehabkost@redhat.com> +Patchwork-id: 56960 +O-Subject: [RHEL7 qemu-kvm PATCH 1/2] pc: Disable RDTSCP unconditionally on rhel6.* machine-types +Bugzilla: 918907 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Igor Mammedov +RH-Acked-by: Miroslav Rezanina + +Bugzilla: 918907 +Upstream status: not applicable +Brew scratch build: http://brewweb.devel.redhat.com/brew/taskinfo?taskID=6953316 + +The RHEL-6 kernel didn't support exposing RDTSCP at all, so we need to +disable RDTSCP on all CPU models. + +The previous rhel6.5.0 compat code wasn't complete, because Opteron_G4 +and Opteron_G5 were not being changed. + +Signed-off-by: Eduardo Habkost +--- + hw/i386/pc_piix.c | 16 +++------------- + 1 file changed, 3 insertions(+), 13 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + hw/i386/pc_piix.c | 16 +++------------- + 1 files changed, 3 insertions(+), 13 deletions(-) + +diff --git a/hw/i386/pc_piix.c b/hw/i386/pc_piix.c +index 641f3d9..b918f69 100644 +--- a/hw/i386/pc_piix.c ++++ b/hw/i386/pc_piix.c +@@ -906,10 +906,9 @@ static void pc_compat_rhel650(QEMUMachineInitArgs *args) + CPUID_EXT2_CX8 | CPUID_EXT2_MCE | CPUID_EXT2_PAE | CPUID_EXT2_MSR | + CPUID_EXT2_TSC | CPUID_EXT2_PSE | CPUID_EXT2_DE | CPUID_EXT2_FPU, + 0); +- x86_cpu_compat_set_features("SandyBridge", FEAT_8000_0001_EDX, +- 0, CPUID_EXT2_RDTSCP); +- x86_cpu_compat_set_features("Haswell", FEAT_8000_0001_EDX, +- 0, CPUID_EXT2_RDTSCP); ++ ++ /* RHEL-6 kernel never supported exposing RDTSCP */ ++ x86_cpu_compat_set_features(NULL, FEAT_8000_0001_EDX, 0, CPUID_EXT2_RDTSCP); + + x86_cpu_compat_set_features("Opteron_G1", FEAT_1_ECX, CPUID_EXT_X2APIC, 0); + x86_cpu_compat_set_features("Opteron_G2", FEAT_1_ECX, CPUID_EXT_X2APIC, 0); +@@ -917,15 +916,6 @@ static void pc_compat_rhel650(QEMUMachineInitArgs *args) + x86_cpu_compat_set_features("Opteron_G4", FEAT_1_ECX, 0, CPUID_EXT_X2APIC); + x86_cpu_compat_set_features("Opteron_G5", FEAT_1_ECX, 0, CPUID_EXT_X2APIC); + +- x86_cpu_compat_set_features("phenom", FEAT_8000_0001_EDX, +- 0, CPUID_EXT2_RDTSCP); +- x86_cpu_compat_set_features("Opteron_G1", FEAT_8000_0001_EDX, +- 0, CPUID_EXT2_RDTSCP); +- x86_cpu_compat_set_features("Opteron_G2", FEAT_8000_0001_EDX, +- 0, CPUID_EXT2_RDTSCP); +- x86_cpu_compat_set_features("Opteron_G3", FEAT_8000_0001_EDX, +- 0, CPUID_EXT2_RDTSCP); +- + /* RHEL-6 had 3dnow & 3dnowext unconditionally disabled on all models */ + x86_cpu_compat_set_features(NULL, FEAT_8000_0001_EDX, 0, + CPUID_EXT2_3DNOW | CPUID_EXT2_3DNOWEXT); +-- +1.7.1 + diff --git a/SOURCES/kvm-pc-Enable-x2apic-by-default-on-more-recent-CPU-model.patch b/SOURCES/kvm-pc-Enable-x2apic-by-default-on-more-recent-CPU-model.patch new file mode 100644 index 0000000..51ccd71 --- /dev/null +++ b/SOURCES/kvm-pc-Enable-x2apic-by-default-on-more-recent-CPU-model.patch @@ -0,0 +1,118 @@ +From 1144c6fa17e7d3fca1e2940c8bd0da966c74e4c5 Mon Sep 17 00:00:00 2001 +From: Eduardo Habkost +Date: Mon, 20 Jan 2014 19:05:30 +0100 +Subject: [PATCH 33/34] pc: Enable x2apic by default on more recent CPU models (v2) + +RH-Author: Eduardo Habkost +Message-id: <1390244730-31038-3-git-send-email-ehabkost@redhat.com> +Patchwork-id: 56848 +O-Subject: [RHEL7 qemu-kvm PATCH 2/2] pc: Enable x2apic by default on more recent CPU models (v2) +Bugzilla: 1049706 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Bandan Das +RH-Acked-by: Laszlo Ersek + +Bugzilla: 1049706 +Brew scratch build: http://brewweb.devel.redhat.com/brew/taskinfo?taskID=6900764 +Upstream status: not applicable (see notes below) + +On RHEL-6 we already enabled x2apic by default on Conroe, Penryn, +Nehalem, Westmere, SandyBridge, Haswell, Opteron_G{1,2,3}. + +To not introduce performance regressions, this patch changes the rhel7 +machine-types to enable x2apic by default on all those models and also +on Opteron_G{4,5}. + +Quoting the patch I sent upstream[1]: + +> Normally we try to keep the CPU model definitions as close as the real +> CPUs as possible, but x2apic can be emulated by KVM without host CPU +> support for x2apic, and it improves performance by reducing APIC access +> overhead. x2apic emulation is available on KVM since 2009 (Linux +> 2.6.32-rc1), there's no reason for not enabling x2apic by default when +> running KVM. + +Upstream status is "not applicable" because this patch touches only the +rhel7-specific PC code. I am doing this because my plan is to enable +x2apic by default even if upstream rejects my patch, and I want to get +this done as soon as possible to get more testing exposure. + +[1] A patch was submitted to change cpu.c to add x2apic to those CPU models + upstream, and can be seen at: + Message-Id: <1390228618-21663-1-git-send-email-ehabkost@redhat.com> + http://article.gmane.org/gmane.comp.emulators.qemu/251492 + + The upstream patch is a resend. A similar patch was sent in + September 2013, was ACKed by Gleb, but was ignored by all + maintainers. + +Changes v2: + * Use the new pc_compat_rhel*() functions + * Disable x2apic explicitly on Opteron_G{4,5} on pc_compat_rhel650() + +Signed-off-by: Eduardo Habkost +--- + hw/i386/pc_piix.c | 12 ++++++++++++ + hw/i386/pc_q35.c | 10 ++++++++++ + 2 files changed, 22 insertions(+) + +Signed-off-by: Miroslav Rezanina +--- + hw/i386/pc_piix.c | 12 ++++++++++++ + hw/i386/pc_q35.c | 10 ++++++++++ + 2 files changed, 22 insertions(+), 0 deletions(-) + +diff --git a/hw/i386/pc_piix.c b/hw/i386/pc_piix.c +index 769571c..663c9d5 100644 +--- a/hw/i386/pc_piix.c ++++ b/hw/i386/pc_piix.c +@@ -745,6 +745,16 @@ machine_init(pc_machine_init); + + static void pc_compat_rhel700(QEMUMachineInitArgs *args) + { ++ x86_cpu_compat_set_features("Conroe", FEAT_1_ECX, CPUID_EXT_X2APIC, 0); ++ x86_cpu_compat_set_features("Penryn", FEAT_1_ECX, CPUID_EXT_X2APIC, 0); ++ x86_cpu_compat_set_features("Nehalem", FEAT_1_ECX, CPUID_EXT_X2APIC, 0); ++ x86_cpu_compat_set_features("Westmere", FEAT_1_ECX, CPUID_EXT_X2APIC, 0); ++ /* SandyBridge and Haswell already have x2apic enabled */ ++ x86_cpu_compat_set_features("Opteron_G1", FEAT_1_ECX, CPUID_EXT_X2APIC, 0); ++ x86_cpu_compat_set_features("Opteron_G2", FEAT_1_ECX, CPUID_EXT_X2APIC, 0); ++ x86_cpu_compat_set_features("Opteron_G3", FEAT_1_ECX, CPUID_EXT_X2APIC, 0); ++ x86_cpu_compat_set_features("Opteron_G4", FEAT_1_ECX, CPUID_EXT_X2APIC, 0); ++ x86_cpu_compat_set_features("Opteron_G5", FEAT_1_ECX, CPUID_EXT_X2APIC, 0); + } + + static void pc_init_rhel700(QEMUMachineInitArgs *args) +@@ -899,6 +909,8 @@ static void pc_compat_rhel650(QEMUMachineInitArgs *args) + x86_cpu_compat_set_features("Opteron_G1", FEAT_1_ECX, CPUID_EXT_X2APIC, 0); + x86_cpu_compat_set_features("Opteron_G2", FEAT_1_ECX, CPUID_EXT_X2APIC, 0); + x86_cpu_compat_set_features("Opteron_G3", FEAT_1_ECX, CPUID_EXT_X2APIC, 0); ++ x86_cpu_compat_set_features("Opteron_G4", FEAT_1_ECX, 0, CPUID_EXT_X2APIC); ++ x86_cpu_compat_set_features("Opteron_G5", FEAT_1_ECX, 0, CPUID_EXT_X2APIC); + + x86_cpu_compat_set_features("phenom", FEAT_8000_0001_EDX, + 0, CPUID_EXT2_RDTSCP); +diff --git a/hw/i386/pc_q35.c b/hw/i386/pc_q35.c +index 0280a95..232c62d 100644 +--- a/hw/i386/pc_q35.c ++++ b/hw/i386/pc_q35.c +@@ -270,6 +270,16 @@ machine_init(pc_q35_machine_init); + + static void pc_q35_compat_rhel700(QEMUMachineInitArgs *args) + { ++ x86_cpu_compat_set_features("Conroe", FEAT_1_ECX, CPUID_EXT_X2APIC, 0); ++ x86_cpu_compat_set_features("Penryn", FEAT_1_ECX, CPUID_EXT_X2APIC, 0); ++ x86_cpu_compat_set_features("Nehalem", FEAT_1_ECX, CPUID_EXT_X2APIC, 0); ++ x86_cpu_compat_set_features("Westmere", FEAT_1_ECX, CPUID_EXT_X2APIC, 0); ++ /* SandyBridge and Haswell already have x2apic enabled */ ++ x86_cpu_compat_set_features("Opteron_G1", FEAT_1_ECX, CPUID_EXT_X2APIC, 0); ++ x86_cpu_compat_set_features("Opteron_G2", FEAT_1_ECX, CPUID_EXT_X2APIC, 0); ++ x86_cpu_compat_set_features("Opteron_G3", FEAT_1_ECX, CPUID_EXT_X2APIC, 0); ++ x86_cpu_compat_set_features("Opteron_G4", FEAT_1_ECX, CPUID_EXT_X2APIC, 0); ++ x86_cpu_compat_set_features("Opteron_G5", FEAT_1_ECX, CPUID_EXT_X2APIC, 0); + } + + static void pc_q35_init_rhel700(QEMUMachineInitArgs *args) +-- +1.7.1 + diff --git a/SOURCES/kvm-pc-Fix-rhel6.-3dnow-3dnowext-compat-bits.patch b/SOURCES/kvm-pc-Fix-rhel6.-3dnow-3dnowext-compat-bits.patch new file mode 100644 index 0000000..38b1b7f --- /dev/null +++ b/SOURCES/kvm-pc-Fix-rhel6.-3dnow-3dnowext-compat-bits.patch @@ -0,0 +1,61 @@ +From d56b59537e7039d62f4ae68610eb0763d88f9289 Mon Sep 17 00:00:00 2001 +From: Eduardo Habkost +Date: Wed, 15 Jan 2014 19:37:36 -0500 +Subject: [PATCH 07/14] pc: Fix rhel6.* 3dnow & 3dnowext compat bits + +Message-id: <1389814656-20101-1-git-send-email-ehabkost@redhat.com> +Patchwork-id: 56728 +O-Subject: [RHEL-7 qemu-kvm PATCH] pc: Fix rhel6.* 3dnow & 3dnowext compat bits +Bugzilla: 918907 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Laszlo Ersek +RH-Acked-by: Bandan Das + +Bugzilla: 918907 +Upstream status: not applicable +Brew scratch build: http://brewweb.devel.redhat.com/brew/taskinfo?taskID=6879262 + +RHEL-6 qemu-kvm has a hack that unconditionally disables 3dnow and +3dnowext on the CPUID handling code. To keep compatibility we need to do +the same on the rhel6.* machine-types. + +The hack on RHEL-6 is at target-i386/cpuid.c:cpu_x86_cpuid(): + + switch(index) { + [...] + case 0x80000001: + [...] + if (kvm_enabled()) { + [...] + /* 3dnow */ + *edx &= ~0xc0000000; + } [...] + +Signed-off-by: Eduardo Habkost +--- + hw/i386/pc_piix.c | 4 ++++ + 1 file changed, 4 insertions(+) + +Signed-off-by: Miroslav Rezanina +--- + hw/i386/pc_piix.c | 4 ++++ + 1 file changed, 4 insertions(+) + +diff --git a/hw/i386/pc_piix.c b/hw/i386/pc_piix.c +index 2961bc8..29c013a 100644 +--- a/hw/i386/pc_piix.c ++++ b/hw/i386/pc_piix.c +@@ -902,6 +902,10 @@ static void pc_init_rhel650(QEMUMachineInitArgs *args) + x86_cpu_compat_set_features("Opteron_G3", FEAT_8000_0001_EDX, + 0, CPUID_EXT2_RDTSCP); + ++ /* RHEL-6 had 3dnow & 3dnowext unconditionally disabled on all models */ ++ x86_cpu_compat_set_features(NULL, FEAT_8000_0001_EDX, 0, ++ CPUID_EXT2_3DNOW | CPUID_EXT2_3DNOWEXT); ++ + disable_kvm_pv_unhalt(); + + rom_file_in_ram = false; +-- +1.8.3.1 + diff --git a/SOURCES/kvm-pc-Save-size-of-RAM-below-4GB.patch b/SOURCES/kvm-pc-Save-size-of-RAM-below-4GB.patch new file mode 100644 index 0000000..cb9cf40 --- /dev/null +++ b/SOURCES/kvm-pc-Save-size-of-RAM-below-4GB.patch @@ -0,0 +1,65 @@ +From c097095019b643c2212037eb98c150650931284e Mon Sep 17 00:00:00 2001 +From: Eduardo Habkost +Date: Tue, 11 Feb 2014 14:03:47 +0100 +Subject: [PATCH 11/28] pc: Save size of RAM below 4GB + +RH-Author: Eduardo Habkost +Message-id: <1392127428-9286-2-git-send-email-ehabkost@redhat.com> +Patchwork-id: 57204 +O-Subject: [PATCH 1/2] pc: Save size of RAM below 4GB +Bugzilla: 1048080 +RH-Acked-by: Marcel Apfelbaum +RH-Acked-by: Laszlo Ersek +RH-Acked-by: Michael S. Tsirkin + +Bugzilla: 1048080 +Brew scratch build: http://brewweb.devel.redhat.com/brew/taskinfo?taskID=7027865 + +The ram_below_4g value will be useful in other places, such as the ACPI +table code, and other code that currently requires passing +below_4g_mem_size around in function arguments. + +Signed-off-by: Eduardo Habkost +Reviewed-by: Michael S. Tsirkin +Signed-off-by: Michael S. Tsirkin +(cherry picked from commit f30ee8a9682be4abfcb05c6389894f8cfc35c3f0) +Signed-off-by: Eduardo Habkost +--- + hw/i386/pc.c | 1 + + include/hw/i386/pc.h | 2 +- + 2 files changed, 2 insertions(+), 1 deletion(-) + +Signed-off-by: Miroslav Rezanina +--- + hw/i386/pc.c | 1 + + include/hw/i386/pc.h | 2 +- + 2 files changed, 2 insertions(+), 1 deletions(-) + +diff --git a/hw/i386/pc.c b/hw/i386/pc.c +index a0f0b24..1468d50 100644 +--- a/hw/i386/pc.c ++++ b/hw/i386/pc.c +@@ -1046,6 +1046,7 @@ PcGuestInfo *pc_guest_info_init(ram_addr_t below_4g_mem_size, + PcGuestInfo *guest_info = &guest_info_state->info; + int i, j; + ++ guest_info->ram_size_below_4g = below_4g_mem_size; + guest_info->ram_size = below_4g_mem_size + above_4g_mem_size; + guest_info->apic_id_limit = pc_apic_id_limit(max_cpus); + guest_info->apic_xrupt_override = kvm_allows_irq0_override(); +diff --git a/include/hw/i386/pc.h b/include/hw/i386/pc.h +index 413358f..f56e9ea 100644 +--- a/include/hw/i386/pc.h ++++ b/include/hw/i386/pc.h +@@ -35,7 +35,7 @@ typedef struct PcPciInfo { + struct PcGuestInfo { + bool has_pci_info; + bool isapc_ram_fw; +- hwaddr ram_size; ++ hwaddr ram_size, ram_size_below_4g; + unsigned apic_id_limit; + bool apic_xrupt_override; + uint64_t numa_nodes; +-- +1.7.1 + diff --git a/SOURCES/kvm-pc-Use-cpu64-rhel6-CPU-model-by-default-on-rhel6-mac.patch b/SOURCES/kvm-pc-Use-cpu64-rhel6-CPU-model-by-default-on-rhel6-mac.patch new file mode 100644 index 0000000..09be4ab --- /dev/null +++ b/SOURCES/kvm-pc-Use-cpu64-rhel6-CPU-model-by-default-on-rhel6-mac.patch @@ -0,0 +1,49 @@ +From 990b368672cccb1c1c9fe189517abedf5455cb5c Mon Sep 17 00:00:00 2001 +From: Eduardo Habkost +Date: Tue, 25 Mar 2014 16:03:46 +0100 +Subject: [PATCH 1/2] pc: Use cpu64-rhel6 CPU model by default on rhel6 machine-types + +RH-Author: Eduardo Habkost +Message-id: <1395763427-31684-2-git-send-email-ehabkost@redhat.com> +Patchwork-id: 58246 +O-Subject: [RHEL7 qemu-kvm PATCH 1/2] pc: Use cpu64-rhel6 CPU model by default on rhel6 machine-types +Bugzilla: 1080170 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Alex Williamson +RH-Acked-by: Bandan Das + +Bugzilla: 1080170 +Brew scratch build: http://brewweb.devel.redhat.com/brew/taskinfo?taskID=7250917 +Upstream status: not applicable + +On RHEL-6, cpu64-rhel6 was the default CPU model, so use it as default +on rhel6.* machine-types so we keep the ABI and not break RHEL6->RHEL7 +live-migration. + +Signed-off-by: Eduardo Habkost +--- + hw/i386/pc_piix.c | 3 +++ + 1 file changed, 3 insertions(+) + +Signed-off-by: Miroslav Rezanina +--- + hw/i386/pc_piix.c | 3 +++ + 1 files changed, 3 insertions(+), 0 deletions(-) + +diff --git a/hw/i386/pc_piix.c b/hw/i386/pc_piix.c +index be68098..940816f 100644 +--- a/hw/i386/pc_piix.c ++++ b/hw/i386/pc_piix.c +@@ -917,6 +917,9 @@ static QEMUMachine pc_machine_rhel700 = { + static void pc_compat_rhel650(QEMUMachineInitArgs *args) + { + pc_compat_rhel700(args); ++ if (!args->cpu_model) { ++ args->cpu_model = "cpu64-rhel6"; ++ } + x86_cpu_compat_set_features("pentium", FEAT_1_EDX, 0, CPUID_APIC); + x86_cpu_compat_set_features("pentium2", FEAT_1_EDX, 0, CPUID_APIC); + x86_cpu_compat_set_features("pentium3", FEAT_1_EDX, 0, CPUID_APIC); +-- +1.7.1 + diff --git a/SOURCES/kvm-pc-add-I440FX-QOM-cast-macro.patch b/SOURCES/kvm-pc-add-I440FX-QOM-cast-macro.patch new file mode 100644 index 0000000..dc27d56 --- /dev/null +++ b/SOURCES/kvm-pc-add-I440FX-QOM-cast-macro.patch @@ -0,0 +1,73 @@ +From 7529646c9b02c1e122b6f3972fd034be651962cc Mon Sep 17 00:00:00 2001 +Message-Id: <7529646c9b02c1e122b6f3972fd034be651962cc.1387298827.git.minovotn@redhat.com> +In-Reply-To: <3ed0fb61a3dc912ef036d7ef450bed192090709e.1387298827.git.minovotn@redhat.com> +References: <3ed0fb61a3dc912ef036d7ef450bed192090709e.1387298827.git.minovotn@redhat.com> +From: "Michael S. Tsirkin" +Date: Tue, 17 Dec 2013 15:17:32 +0100 +Subject: [PATCH 17/56] pc: add I440FX QOM cast macro +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +RH-Author: Michael S. Tsirkin +Message-id: <1387293161-4085-18-git-send-email-mst@redhat.com> +Patchwork-id: 56323 +O-Subject: [PATCH qemu-kvm RHEL7.0 v2 17/57] pc: add I440FX QOM cast macro +Bugzilla: 1034876 +RH-Acked-by: Igor Mammedov +RH-Acked-by: Marcel Apfelbaum +RH-Acked-by: Laszlo Ersek + +From: Igor Mammedov + +Signed-off-by: Igor Mammedov +Reviewed-by: Michael S. Tsirkin +Reviewed-by: Andreas Färber +Message-id: 1375109277-25561-3-git-send-email-imammedo@redhat.com +Signed-off-by: Anthony Liguori +(cherry picked from commit 1d0d4aa412eef7d98e53c313c79c359f2f65376e) +--- + hw/pci-host/piix.c | 8 ++++++-- + 1 file changed, 6 insertions(+), 2 deletions(-) + +Signed-off-by: Michal Novotny +--- + hw/pci-host/piix.c | 8 ++++++-- + 1 file changed, 6 insertions(+), 2 deletions(-) + +diff --git a/hw/pci-host/piix.c b/hw/pci-host/piix.c +index 8894c03..adc094a 100644 +--- a/hw/pci-host/piix.c ++++ b/hw/pci-host/piix.c +@@ -38,6 +38,10 @@ + * http://download.intel.com/design/chipsets/datashts/29054901.pdf + */ + ++#define TYPE_I440FX_PCI_HOST_BRIDGE "i440FX-pcihost" ++#define I440FX_PCI_HOST_BRIDGE(obj) \ ++ OBJECT_CHECK(I440FXState, (obj), TYPE_I440FX_PCI_HOST_BRIDGE) ++ + typedef struct I440FXState { + PCIHostState parent_obj; + } I440FXState; +@@ -245,7 +249,7 @@ PCIBus *i440fx_init(PCII440FXState **pi440fx_state, + PCII440FXState *f; + unsigned i; + +- dev = qdev_create(NULL, "i440FX-pcihost"); ++ dev = qdev_create(NULL, TYPE_I440FX_PCI_HOST_BRIDGE); + s = PCI_HOST_BRIDGE(dev); + b = pci_bus_new(dev, NULL, pci_address_space, + address_space_io, 0, TYPE_PCI_BUS); +@@ -627,7 +631,7 @@ static void i440fx_pcihost_class_init(ObjectClass *klass, void *data) + } + + static const TypeInfo i440fx_pcihost_info = { +- .name = "i440FX-pcihost", ++ .name = TYPE_I440FX_PCI_HOST_BRIDGE, + .parent = TYPE_PCI_HOST_BRIDGE, + .instance_size = sizeof(I440FXState), + .class_init = i440fx_pcihost_class_init, +-- +1.7.11.7 + diff --git a/SOURCES/kvm-pc-avoid-duplicate-names-for-ROM-MRs.patch b/SOURCES/kvm-pc-avoid-duplicate-names-for-ROM-MRs.patch new file mode 100644 index 0000000..3d5b83d --- /dev/null +++ b/SOURCES/kvm-pc-avoid-duplicate-names-for-ROM-MRs.patch @@ -0,0 +1,132 @@ +From 5f8e45393355671d8793e4bb37c07c95c609fdcd Mon Sep 17 00:00:00 2001 +From: Michael S. Tsirkin +Date: Sun, 9 Mar 2014 18:48:58 +0100 +Subject: [PATCH 10/16] pc: avoid duplicate names for ROM MRs + +RH-Author: Michael S. Tsirkin +Message-id: <1394390868-24135-2-git-send-email-mst@redhat.com> +Patchwork-id: 58054 +O-Subject: [PATCH qemu-kvm RHEL7.0 v3 2/2] pc: avoid duplicate names for ROM MRs +Bugzilla: 1064018 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Marcel Apfelbaum +RH-Acked-by: Gerd Hoffmann + +Since +commit 04920fc0faa4760f9c4fc0e73b992b768099be70 + loader: store FW CFG ROM files in RAM +RAM MRs including ROM files in FW CFGs are created +and named using the file basename. + +This becomes problematic if these names are +supplied by user, since the basename might not +be unique. + +There are two cases we care about: +- option-rom flag. +- option ROM for devices. This triggers e.g. when + using rombar=0. + +At the moment we get an assert. E.g +qemu -option-rom /usr/share/ipxe/8086100e.rom -option-rom +/usr/share/ipxe.efi/8086100e.rom +RAMBlock "/rom@genroms/8086100e.rom" already registered, abort! + +This is a regression from 1.7. + +For now let's keep it simple and just avoid creating the +MRs in case of option ROMs. + +Signed-off-by: Michael S. Tsirkin + +Upstream: posted +Brew build: http://brewweb.devel.redhat.com/brew/taskinfo?taskID=7173355 +Bugzilla: https://bugzilla.redhat.com/show_bug.cgi?id=1064018#c6 +Tested: by developer +--- + include/hw/loader.h | 6 ++++-- + hw/core/loader.c | 10 ++++++---- + 2 files changed, 10 insertions(+), 6 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + hw/core/loader.c | 10 ++++++---- + include/hw/loader.h | 6 ++++-- + 2 files changed, 10 insertions(+), 6 deletions(-) + +diff --git a/hw/core/loader.c b/hw/core/loader.c +index c363aef..9309b8c 100644 +--- a/hw/core/loader.c ++++ b/hw/core/loader.c +@@ -54,6 +54,7 @@ + + #include + ++bool option_rom_has_mr = false; + bool rom_file_has_mr = true; + + static int roms_loaded; +@@ -590,7 +591,8 @@ static void *rom_set_mr(Rom *rom, const char *name) + } + + int rom_add_file(const char *file, const char *fw_dir, +- hwaddr addr, int32_t bootindex) ++ hwaddr addr, int32_t bootindex, ++ bool option_rom) + { + Rom *rom; + int rc, fd = -1; +@@ -642,7 +644,7 @@ int rom_add_file(const char *file, const char *fw_dir, + basename); + snprintf(devpath, sizeof(devpath), "/rom@%s", fw_file_name); + +- if (rom_file_has_mr) { ++ if ((!option_rom || option_rom_has_mr) && rom_file_has_mr) { + data = rom_set_mr(rom, devpath); + } else { + data = rom->data; +@@ -721,12 +723,12 @@ int rom_add_elf_program(const char *name, void *data, size_t datasize, + + int rom_add_vga(const char *file) + { +- return rom_add_file(file, "vgaroms", 0, -1); ++ return rom_add_file(file, "vgaroms", 0, -1, true); + } + + int rom_add_option(const char *file, int32_t bootindex) + { +- return rom_add_file(file, "genroms", 0, bootindex); ++ return rom_add_file(file, "genroms", 0, bootindex, true); + } + + static void rom_reset(void *unused) +diff --git a/include/hw/loader.h b/include/hw/loader.h +index 7ceccce..a5e02ce 100644 +--- a/include/hw/loader.h ++++ b/include/hw/loader.h +@@ -23,10 +23,12 @@ void pstrcpy_targphys(const char *name, + hwaddr dest, int buf_size, + const char *source); + ++extern bool option_rom_has_mr; + extern bool rom_file_has_mr; + + int rom_add_file(const char *file, const char *fw_dir, +- hwaddr addr, int32_t bootindex); ++ hwaddr addr, int32_t bootindex, ++ bool option_rom); + void *rom_add_blob(const char *name, const void *blob, size_t len, + hwaddr addr, const char *fw_file_name, + FWCfgReadCallback fw_callback, void *callback_opaque); +@@ -40,7 +42,7 @@ void *rom_ptr(hwaddr addr); + void do_info_roms(Monitor *mon, const QDict *qdict); + + #define rom_add_file_fixed(_f, _a, _i) \ +- rom_add_file(_f, NULL, _a, _i) ++ rom_add_file(_f, NULL, _a, _i, false) + #define rom_add_blob_fixed(_f, _b, _l, _a) \ + (rom_add_blob(_f, _b, _l, _a, NULL, NULL, NULL) ? 0 : -1) + +-- +1.7.1 + diff --git a/SOURCES/kvm-pc-disable-pci-info.patch b/SOURCES/kvm-pc-disable-pci-info.patch new file mode 100644 index 0000000..d0b1005 --- /dev/null +++ b/SOURCES/kvm-pc-disable-pci-info.patch @@ -0,0 +1,77 @@ +From 83aeeafe6163924b991c2e0f89e3a79b3bc6b182 Mon Sep 17 00:00:00 2001 +Message-Id: <83aeeafe6163924b991c2e0f89e3a79b3bc6b182.1387298827.git.minovotn@redhat.com> +In-Reply-To: <3ed0fb61a3dc912ef036d7ef450bed192090709e.1387298827.git.minovotn@redhat.com> +References: <3ed0fb61a3dc912ef036d7ef450bed192090709e.1387298827.git.minovotn@redhat.com> +From: "Michael S. Tsirkin" +Date: Tue, 17 Dec 2013 15:19:16 +0100 +Subject: [PATCH 51/56] pc: disable pci-info + +RH-Author: Michael S. Tsirkin +Message-id: <1387293161-4085-52-git-send-email-mst@redhat.com> +Patchwork-id: 56357 +O-Subject: [PATCH qemu-kvm RHEL7.0 v2 51/57] pc: disable pci-info +Bugzilla: 1034876 +RH-Acked-by: Igor Mammedov +RH-Acked-by: Marcel Apfelbaum +RH-Acked-by: Laszlo Ersek + +From: Igor Mammedov + +The BIOS that we ship in 1.7 does not use pci info +from host and so far isn't going to use it. +Taking in account problems it caused see 9604f70fdf and +to avoid future incompatibility issues, it's safest to +disable that interface by default for all machine types +including 1.7 as it was never exposed/used by guest. +And properly remove/cleanup it during 1.8 development cycle. + +Signed-off-by: Igor Mammedov +Reviewed-by: Gerd Hoffmann +Reviewed-by: Michael S. Tsirkin +Reviewed-by: Eduardo Habkost +Signed-off-by: Michael S. Tsirkin +(cherry picked from commit 7f1bb742be39184b469d53c0901240b12bb85589) + +Conflicts: + hw/i386/pc_piix.c + hw/i386/pc_q35.c +--- + hw/i386/pc_piix.c | 2 +- + hw/i386/pc_q35.c | 2 +- + 2 files changed, 2 insertions(+), 2 deletions(-) + +Signed-off-by: Michal Novotny +--- + hw/i386/pc_piix.c | 2 +- + hw/i386/pc_q35.c | 2 +- + 2 files changed, 2 insertions(+), 2 deletions(-) + +diff --git a/hw/i386/pc_piix.c b/hw/i386/pc_piix.c +index ffa35d3..76d6e93 100644 +--- a/hw/i386/pc_piix.c ++++ b/hw/i386/pc_piix.c +@@ -59,7 +59,7 @@ static const int ide_iobase2[MAX_IDE_BUS] = { 0x3f6, 0x376 }; + static const int ide_irq[MAX_IDE_BUS] = { 14, 15 }; + + static bool smbios_type1_defaults = true; +-static bool has_pci_info = true; ++static bool has_pci_info; + static bool has_acpi_build = true; + + /* PC hardware initialisation */ +diff --git a/hw/i386/pc_q35.c b/hw/i386/pc_q35.c +index 824295d..86c0c90 100644 +--- a/hw/i386/pc_q35.c ++++ b/hw/i386/pc_q35.c +@@ -49,7 +49,7 @@ + #define MAX_SATA_PORTS 6 + + static bool smbios_type1_defaults = true; +-static bool has_pci_info = true; ++static bool has_pci_info; + static bool has_acpi_build = true; + + /* PC hardware initialisation */ +-- +1.7.11.7 + diff --git a/SOURCES/kvm-pc-don-t-access-fw-cfg-if-NULL.patch b/SOURCES/kvm-pc-don-t-access-fw-cfg-if-NULL.patch new file mode 100644 index 0000000..81c6b93 --- /dev/null +++ b/SOURCES/kvm-pc-don-t-access-fw-cfg-if-NULL.patch @@ -0,0 +1,50 @@ +From 2cd283cab24c3765c11a19897d4ee3f1ce37000f Mon Sep 17 00:00:00 2001 +Message-Id: <2cd283cab24c3765c11a19897d4ee3f1ce37000f.1387298827.git.minovotn@redhat.com> +In-Reply-To: <3ed0fb61a3dc912ef036d7ef450bed192090709e.1387298827.git.minovotn@redhat.com> +References: <3ed0fb61a3dc912ef036d7ef450bed192090709e.1387298827.git.minovotn@redhat.com> +From: "Michael S. Tsirkin" +Date: Tue, 17 Dec 2013 15:17:29 +0100 +Subject: [PATCH 16/56] pc: don't access fw cfg if NULL + +RH-Author: Michael S. Tsirkin +Message-id: <1387293161-4085-17-git-send-email-mst@redhat.com> +Patchwork-id: 56322 +O-Subject: [PATCH qemu-kvm RHEL7.0 v2 16/57] pc: don't access fw cfg if NULL +Bugzilla: 1034876 +RH-Acked-by: Igor Mammedov +RH-Acked-by: Marcel Apfelbaum +RH-Acked-by: Laszlo Ersek + +commit f8c457b88d72a48989f190bc3d7b79f4f3b7d11c + "pc: pass PCI hole ranges to Guests" +broke Xen as it has no fw_cfg. +Check for this configuration and boil out. + +Signed-off-by: Michael S. Tsirkin +Tested-by: Stefano Stabellini +(cherry picked from commit d26d9e14c15837eba2b7447e8d15230bab8e0940) +--- + hw/i386/pc.c | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +Signed-off-by: Michal Novotny +--- + hw/i386/pc.c | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/hw/i386/pc.c b/hw/i386/pc.c +index 238f6a0..9d9f5d2 100644 +--- a/hw/i386/pc.c ++++ b/hw/i386/pc.c +@@ -996,7 +996,7 @@ typedef struct PcRomPciInfo { + static void pc_fw_cfg_guest_info(PcGuestInfo *guest_info) + { + PcRomPciInfo *info; +- if (!guest_info->has_pci_info) { ++ if (!guest_info->has_pci_info || !guest_info->fw_cfg) { + return; + } + +-- +1.7.11.7 + diff --git a/SOURCES/kvm-pc-drop-virtio-balloon-pci-event_idx-compat-property.patch b/SOURCES/kvm-pc-drop-virtio-balloon-pci-event_idx-compat-property.patch new file mode 100644 index 0000000..ee7aeca --- /dev/null +++ b/SOURCES/kvm-pc-drop-virtio-balloon-pci-event_idx-compat-property.patch @@ -0,0 +1,72 @@ +From cbe9fe3834d08758bc787ac0800afb9ece6ed782 Mon Sep 17 00:00:00 2001 +From: Luiz Capitulino +Date: Tue, 12 Nov 2013 17:10:04 +0100 +Subject: [PATCH 01/14] pc: drop virtio-balloon-pci event_idx compat property + +RH-Author: Luiz Capitulino +Message-id: <20131112121004.12eb9431@redhat.com> +Patchwork-id: 55664 +O-Subject: [RHEL-7.0 qemu-kvm PATCH] pc: drop virtio-balloon-pci event_idx compat property +Bugzilla: 1029539 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Eduardo Habkost +RH-Acked-by: Juan Quintela + +Bugzilla: 1029539 +Brew-build: https://brewweb.devel.redhat.com/taskinfo?taskID=6564546 + +Due to a bug, RHEL6 has never disabled the virtio-balloon-pci +driver's event_idx property for machine types rhel6.0.0 and +rhel6.1.0. The end result is that migration from RHEL6 to RHEL7 +fails for those machine types. + +The most obvious way to fix this problem is to fix RHEL6 to +really disable the property. But this won't solve the problem +for old RHEL6 binaries. Actually, it will make migration +incompatible between old RHEL6 binaries and newer ones. + +This commit makes the mistake official instead by dropping +the compat property for RHEL7. This fixes migration between +RHEL6 and RHEL7 without adding any new problems. + +Signed-off-by: Luiz Capitulino +--- + hw/i386/pc_piix.c | 9 +++++---- + 1 file changed, 5 insertions(+), 4 deletions(-) + +PS: Will post RHEL6.6 patch later. +Signed-off-by: Miroslav Rezanina +--- + hw/i386/pc_piix.c | 9 +++++---- + 1 files changed, 5 insertions(+), 4 deletions(-) + +diff --git a/hw/i386/pc_piix.c b/hw/i386/pc_piix.c +index 8bae4c5..e6771a9 100644 +--- a/hw/i386/pc_piix.c ++++ b/hw/i386/pc_piix.c +@@ -1030,6 +1030,11 @@ static QEMUMachine pc_machine_rhel620 = { + DEFAULT_MACHINE_OPTIONS, + }; + ++/* ++ * NOTE: We don't have the event_idx compat entry for the ++ * virtio-balloon-pci driver because RHEL6 doesn't disable ++ * it either due to a bug (see RHBZ 1029539 fo more info) ++ */ + #define PC_RHEL6_1_COMPAT \ + PC_RHEL6_2_COMPAT,\ + {\ +@@ -1061,10 +1066,6 @@ static QEMUMachine pc_machine_rhel620 = { + .property = "event_idx",\ + .value = "off",\ + },{\ +- .driver = "virtio-balloon-pci",\ +- .property = "event_idx",\ +- .value = "off",\ +- },{\ + .driver = "usb-kbd",\ + .property = "serial",\ + .value = "1",\ +-- +1.7.1 + diff --git a/SOURCES/kvm-pc-fix-regression-for-64-bit-PCI-memory.patch b/SOURCES/kvm-pc-fix-regression-for-64-bit-PCI-memory.patch new file mode 100644 index 0000000..168a0b5 --- /dev/null +++ b/SOURCES/kvm-pc-fix-regression-for-64-bit-PCI-memory.patch @@ -0,0 +1,140 @@ +From 1cf1fcaf322e07354e830f2562db856ecbb1bf4c Mon Sep 17 00:00:00 2001 +Message-Id: <1cf1fcaf322e07354e830f2562db856ecbb1bf4c.1387298827.git.minovotn@redhat.com> +In-Reply-To: <3ed0fb61a3dc912ef036d7ef450bed192090709e.1387298827.git.minovotn@redhat.com> +References: <3ed0fb61a3dc912ef036d7ef450bed192090709e.1387298827.git.minovotn@redhat.com> +From: "Michael S. Tsirkin" +Date: Tue, 17 Dec 2013 15:17:45 +0100 +Subject: [PATCH 22/56] pc: fix regression for 64 bit PCI memory + +RH-Author: Michael S. Tsirkin +Message-id: <1387293161-4085-23-git-send-email-mst@redhat.com> +Patchwork-id: 56328 +O-Subject: [PATCH qemu-kvm RHEL7.0 v2 22/57] pc: fix regression for 64 bit PCI memory +Bugzilla: 1034876 +RH-Acked-by: Igor Mammedov +RH-Acked-by: Marcel Apfelbaum +RH-Acked-by: Laszlo Ersek + +commit 398489018183d613306ab022653552247d93919f + pc: limit 64 bit hole to 2G by default +introduced a way for management to control +the window allocated to the 64 bit PCI hole. + +This is useful, but existing management tools do not know how to set +this property. As a result, e.g. specifying a large ivshmem device with +size > 4G is broken by default. For example this configuration no +longer works: + +-device ivshmem,size=4294967296,chardev=cfoo +-chardev socket,path=/tmp/sock,id=cfoo,server,nowait + +Fix this by detecting that hole size was not specified +and defaulting to the backwards-compatible value of 1 << 62. + +Cc: qemu-stable@nongnu.org +Cc: Igor Mammedov +Signed-off-by: Michael S. Tsirkin +(cherry picked from commit 1466cef32dd5e7ef3c6477e96d85d92302ad02e3) + +Conflicts: + hw/pci-host/piix.c + hw/pci-host/q35.c +--- + include/hw/i386/pc.h | 11 ++++++++++- + hw/pci-host/piix.c | 9 ++++++--- + hw/pci-host/q35.c | 8 +++++--- + 3 files changed, 21 insertions(+), 7 deletions(-) + +Signed-off-by: Michal Novotny +--- + hw/pci-host/piix.c | 9 ++++++--- + hw/pci-host/q35.c | 8 +++++--- + include/hw/i386/pc.h | 11 ++++++++++- + 3 files changed, 21 insertions(+), 7 deletions(-) + +diff --git a/hw/pci-host/piix.c b/hw/pci-host/piix.c +index 0c26835..6502d1c 100644 +--- a/hw/pci-host/piix.c ++++ b/hw/pci-host/piix.c +@@ -319,6 +319,7 @@ PCIBus *i440fx_init(PCII440FXState **pi440fx_state, + PCII440FXState *f; + unsigned i; + I440FXState *i440fx; ++ uint64_t pci_hole64_size; + + dev = qdev_create(NULL, TYPE_I440FX_PCI_HOST_BRIDGE); + s = PCI_HOST_BRIDGE(dev); +@@ -350,13 +351,15 @@ PCIBus *i440fx_init(PCII440FXState **pi440fx_state, + pci_hole_start, pci_hole_size); + memory_region_add_subregion(f->system_memory, pci_hole_start, &f->pci_hole); + ++ pci_hole64_size = pci_host_get_hole64_size(i440fx->pci_hole64_size); ++ + pc_init_pci64_hole(&i440fx->pci_info, 0x100000000ULL + above_4g_mem_size, +- i440fx->pci_hole64_size); ++ pci_hole64_size); + memory_region_init_alias(&f->pci_hole_64bit, "pci-hole64", + f->pci_address_space, + i440fx->pci_info.w64.begin, +- i440fx->pci_hole64_size); +- if (i440fx->pci_hole64_size) { ++ pci_hole64_size); ++ if (pci_hole64_size) { + memory_region_add_subregion(f->system_memory, + i440fx->pci_info.w64.begin, + &f->pci_hole_64bit); +diff --git a/hw/pci-host/q35.c b/hw/pci-host/q35.c +index 943e55f..05779b8 100644 +--- a/hw/pci-host/q35.c ++++ b/hw/pci-host/q35.c +@@ -325,6 +325,7 @@ static int mch_init(PCIDevice *d) + { + int i; + MCHPCIState *mch = MCH_PCI_DEVICE(d); ++ uint64_t pci_hole64_size; + + /* setup pci memory regions */ + memory_region_init_alias(&mch->pci_hole, "pci-hole", +@@ -334,13 +335,14 @@ static int mch_init(PCIDevice *d) + memory_region_add_subregion(mch->system_memory, mch->below_4g_mem_size, + &mch->pci_hole); + ++ pci_hole64_size = pci_host_get_hole64_size(mch->pci_hole64_size); + pc_init_pci64_hole(&mch->pci_info, 0x100000000ULL + mch->above_4g_mem_size, +- mch->pci_hole64_size); ++ pci_hole64_size); + memory_region_init_alias(&mch->pci_hole_64bit, "pci-hole64", + mch->pci_address_space, + mch->pci_info.w64.begin, +- mch->pci_hole64_size); +- if (mch->pci_hole64_size) { ++ pci_hole64_size); ++ if (pci_hole64_size) { + memory_region_add_subregion(mch->system_memory, + mch->pci_info.w64.begin, + &mch->pci_hole_64bit); +diff --git a/include/hw/i386/pc.h b/include/hw/i386/pc.h +index fe21bc3..abaaf93 100644 +--- a/include/hw/i386/pc.h ++++ b/include/hw/i386/pc.h +@@ -105,7 +105,16 @@ PcGuestInfo *pc_guest_info_init(ram_addr_t below_4g_mem_size, + #define PCI_HOST_PROP_PCI_HOLE64_START "pci-hole64-start" + #define PCI_HOST_PROP_PCI_HOLE64_END "pci-hole64-end" + #define PCI_HOST_PROP_PCI_HOLE64_SIZE "pci-hole64-size" +-#define DEFAULT_PCI_HOLE64_SIZE (1ULL << 31) ++#define DEFAULT_PCI_HOLE64_SIZE (~0x0ULL) ++ ++static inline uint64_t pci_host_get_hole64_size(uint64_t pci_hole64_size) ++{ ++ if (pci_hole64_size == DEFAULT_PCI_HOLE64_SIZE) { ++ return 1ULL << 62; ++ } else { ++ return pci_hole64_size; ++ } ++} + + void pc_init_pci64_hole(PcPciInfo *pci_info, uint64_t pci_hole64_start, + uint64_t pci_hole64_size); +-- +1.7.11.7 + diff --git a/SOURCES/kvm-pc-limit-64-bit-hole-to-2G-by-default.patch b/SOURCES/kvm-pc-limit-64-bit-hole-to-2G-by-default.patch new file mode 100644 index 0000000..fdf9587 --- /dev/null +++ b/SOURCES/kvm-pc-limit-64-bit-hole-to-2G-by-default.patch @@ -0,0 +1,555 @@ +From e27159f910abe099eba5d6959ace2f2de42e5f46 Mon Sep 17 00:00:00 2001 +Message-Id: +In-Reply-To: <3ed0fb61a3dc912ef036d7ef450bed192090709e.1387298827.git.minovotn@redhat.com> +References: <3ed0fb61a3dc912ef036d7ef450bed192090709e.1387298827.git.minovotn@redhat.com> +From: "Michael S. Tsirkin" +Date: Tue, 17 Dec 2013 15:17:34 +0100 +Subject: [PATCH 18/56] pc: limit 64 bit hole to 2G by default +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +RH-Author: Michael S. Tsirkin +Message-id: <1387293161-4085-19-git-send-email-mst@redhat.com> +Patchwork-id: 56324 +O-Subject: [PATCH qemu-kvm RHEL7.0 v2 18/57] pc: limit 64 bit hole to 2G by default +Bugzilla: 1034876 +RH-Acked-by: Igor Mammedov +RH-Acked-by: Marcel Apfelbaum +RH-Acked-by: Laszlo Ersek + +From: Igor Mammedov + +It turns out that some 32 bit windows guests crash +if 64 bit PCI hole size is >2G. +Limit it to 2G for piix and q35 by default. +User may override default 64-bit PCI hole size by +using "pci-hole64-size" property. + +Examples: +-global i440FX-pcihost.pci-hole64-size=4G + +-global q35-pcihost.pci-hole64-size=4G + +Reported-by: Igor Mammedov , +Signed-off-by: Michael S. Tsirkin +Signed-off-by: Igor Mammedov +Reviewed-by: Michael S. Tsirkin +Reviewed-by: Andreas Färber +Message-id: 1375109277-25561-8-git-send-email-imammedo@redhat.com +Signed-off-by: Anthony Liguori +(cherry picked from commit 398489018183d613306ab022653552247d93919f) + +Conflicts: + hw/i386/pc.c + hw/pci-host/piix.c + hw/pci-host/q35.c +--- + include/hw/i386/pc.h | 14 +++++-- + include/hw/pci-host/q35.h | 2 + + hw/i386/pc.c | 56 ++++++++++++++++----------- + hw/i386/pc_piix.c | 14 +------ + hw/pci-host/piix.c | 99 ++++++++++++++++++++++++++++++++++++++++++++--- + hw/pci-host/q35.c | 88 ++++++++++++++++++++++++++++++++++------- + 6 files changed, 215 insertions(+), 58 deletions(-) + +Signed-off-by: Michal Novotny +--- + hw/i386/pc.c | 56 ++++++++++++++++----------- + hw/i386/pc_piix.c | 14 +------ + hw/pci-host/piix.c | 99 ++++++++++++++++++++++++++++++++++++++++++++--- + hw/pci-host/q35.c | 88 ++++++++++++++++++++++++++++++++++------- + include/hw/i386/pc.h | 14 +++++-- + include/hw/pci-host/q35.h | 2 + + 6 files changed, 215 insertions(+), 58 deletions(-) + +diff --git a/hw/i386/pc.c b/hw/i386/pc.c +index 9d9f5d2..e5ebd52 100644 +--- a/hw/i386/pc.c ++++ b/hw/i386/pc.c +@@ -55,6 +55,7 @@ + #include "hw/acpi/acpi.h" + #include "hw/cpu/icc_bus.h" + #include "hw/boards.h" ++#include "hw/pci/pci_host.h" + + /* debug PC/ISA interrupts */ + //#define DEBUG_IRQ +@@ -996,15 +997,27 @@ typedef struct PcRomPciInfo { + static void pc_fw_cfg_guest_info(PcGuestInfo *guest_info) + { + PcRomPciInfo *info; ++ Object *pci_info; ++ bool ambiguous = false; ++ + if (!guest_info->has_pci_info || !guest_info->fw_cfg) { + return; + } ++ pci_info = object_resolve_path_type("", TYPE_PCI_HOST_BRIDGE, &ambiguous); ++ g_assert(!ambiguous); ++ if (!pci_info) { ++ return; ++ } + + info = g_malloc(sizeof *info); +- info->w32_min = cpu_to_le64(guest_info->pci_info.w32.begin); +- info->w32_max = cpu_to_le64(guest_info->pci_info.w32.end); +- info->w64_min = cpu_to_le64(guest_info->pci_info.w64.begin); +- info->w64_max = cpu_to_le64(guest_info->pci_info.w64.end); ++ info->w32_min = cpu_to_le64(object_property_get_int(pci_info, ++ PCI_HOST_PROP_PCI_HOLE_START, NULL)); ++ info->w32_max = cpu_to_le64(object_property_get_int(pci_info, ++ PCI_HOST_PROP_PCI_HOLE_END, NULL)); ++ info->w64_min = cpu_to_le64(object_property_get_int(pci_info, ++ PCI_HOST_PROP_PCI_HOLE64_START, NULL)); ++ info->w64_max = cpu_to_le64(object_property_get_int(pci_info, ++ PCI_HOST_PROP_PCI_HOLE64_END, NULL)); + /* Pass PCI hole info to guest via a side channel. + * Required so guest PCI enumeration does the right thing. */ + fw_cfg_add_file(guest_info->fw_cfg, "etc/pci-info", info, sizeof *info); +@@ -1030,29 +1043,28 @@ PcGuestInfo *pc_guest_info_init(ram_addr_t below_4g_mem_size, + PcGuestInfoState *guest_info_state = g_malloc0(sizeof *guest_info_state); + PcGuestInfo *guest_info = &guest_info_state->info; + +- guest_info->pci_info.w32.end = IO_APIC_DEFAULT_ADDRESS; +- if (sizeof(hwaddr) == 4) { +- guest_info->pci_info.w64.begin = 0; +- guest_info->pci_info.w64.end = 0; +- } else { +- /* +- * BIOS does not set MTRR entries for the 64 bit window, so no need to +- * align address to power of two. Align address at 1G, this makes sure +- * it can be exactly covered with a PAT entry even when using huge +- * pages. +- */ +- guest_info->pci_info.w64.begin = +- ROUND_UP((0x1ULL << 32) + above_4g_mem_size, 0x1ULL << 30); +- guest_info->pci_info.w64.end = guest_info->pci_info.w64.begin + +- (0x1ULL << 62); +- assert(guest_info->pci_info.w64.begin <= guest_info->pci_info.w64.end); +- } +- + guest_info_state->machine_done.notify = pc_guest_info_machine_done; + qemu_add_machine_init_done_notifier(&guest_info_state->machine_done); + return guest_info; + } + ++void pc_init_pci64_hole(PcPciInfo *pci_info, uint64_t pci_hole64_start, ++ uint64_t pci_hole64_size) ++{ ++ if ((sizeof(hwaddr) == 4) || (!pci_hole64_size)) { ++ return; ++ } ++ /* ++ * BIOS does not set MTRR entries for the 64 bit window, so no need to ++ * align address to power of two. Align address at 1G, this makes sure ++ * it can be exactly covered with a PAT entry even when using huge ++ * pages. ++ */ ++ pci_info->w64.begin = ROUND_UP(pci_hole64_start, 0x1ULL << 30); ++ pci_info->w64.end = pci_info->w64.begin + pci_hole64_size; ++ assert(pci_info->w64.begin <= pci_info->w64.end); ++} ++ + void pc_acpi_init(const char *default_dsdt) + { + char *filename; +diff --git a/hw/i386/pc_piix.c b/hw/i386/pc_piix.c +index 6d50a4e..211ff8e 100644 +--- a/hw/i386/pc_piix.c ++++ b/hw/i386/pc_piix.c +@@ -125,15 +125,6 @@ static void pc_init1(QEMUMachineInitArgs *args, + guest_info = pc_guest_info_init(below_4g_mem_size, above_4g_mem_size); + guest_info->has_pci_info = has_pci_info; + +- /* Set PCI window size the way seabios has always done it. */ +- /* Power of 2 so bios can cover it with a single MTRR */ +- if (ram_size <= 0x80000000) +- guest_info->pci_info.w32.begin = 0x80000000; +- else if (ram_size <= 0xc0000000) +- guest_info->pci_info.w32.begin = 0xc0000000; +- else +- guest_info->pci_info.w32.begin = 0xe0000000; +- + /* allocate ram and load rom/bios */ + if (!xen_enabled()) { + fw_cfg = pc_memory_init(system_memory, +@@ -157,10 +148,7 @@ static void pc_init1(QEMUMachineInitArgs *args, + system_memory, system_io, args->ram_size, + below_4g_mem_size, + 0x100000000ULL - below_4g_mem_size, +- 0x100000000ULL + above_4g_mem_size, +- (sizeof(hwaddr) == 4 +- ? 0 +- : ((uint64_t)1 << 62)), ++ above_4g_mem_size, + pci_memory, ram_memory); + } else { + pci_bus = NULL; +diff --git a/hw/pci-host/piix.c b/hw/pci-host/piix.c +index adc094a..167d1fd 100644 +--- a/hw/pci-host/piix.c ++++ b/hw/pci-host/piix.c +@@ -32,6 +32,8 @@ + #include "hw/xen/xen.h" + #include "hw/pci-host/pam.h" + #include "sysemu/sysemu.h" ++#include "hw/i386/ioapic.h" ++#include "qapi/visitor.h" + + /* + * I440FX chipset data sheet. +@@ -44,6 +46,8 @@ + + typedef struct I440FXState { + PCIHostState parent_obj; ++ PcPciInfo pci_info; ++ uint64_t pci_hole64_size; + } I440FXState; + + #define PIIX_NUM_PIC_IRQS 16 /* i8259 * 2 */ +@@ -201,9 +205,49 @@ static const VMStateDescription vmstate_i440fx = { + } + }; + ++static void i440fx_pcihost_get_pci_hole_start(Object *obj, Visitor *v, ++ void *opaque, const char *name, ++ Error **errp) ++{ ++ I440FXState *s = I440FX_PCI_HOST_BRIDGE(obj); ++ uint32_t value = s->pci_info.w32.begin; ++ ++ visit_type_uint32(v, &value, name, errp); ++} ++ ++static void i440fx_pcihost_get_pci_hole_end(Object *obj, Visitor *v, ++ void *opaque, const char *name, ++ Error **errp) ++{ ++ I440FXState *s = I440FX_PCI_HOST_BRIDGE(obj); ++ uint32_t value = s->pci_info.w32.end; ++ ++ visit_type_uint32(v, &value, name, errp); ++} ++ ++static void i440fx_pcihost_get_pci_hole64_start(Object *obj, Visitor *v, ++ void *opaque, const char *name, ++ Error **errp) ++{ ++ I440FXState *s = I440FX_PCI_HOST_BRIDGE(obj); ++ ++ visit_type_uint64(v, &s->pci_info.w64.begin, name, errp); ++} ++ ++static void i440fx_pcihost_get_pci_hole64_end(Object *obj, Visitor *v, ++ void *opaque, const char *name, ++ Error **errp) ++{ ++ I440FXState *s = I440FX_PCI_HOST_BRIDGE(obj); ++ ++ visit_type_uint64(v, &s->pci_info.w64.end, name, errp); ++} ++ + static int i440fx_pcihost_initfn(SysBusDevice *dev) + { + PCIHostState *s = PCI_HOST_BRIDGE(dev); ++ I440FXState *d = I440FX_PCI_HOST_BRIDGE(s); ++ Object *obj = OBJECT(s); + + memory_region_init_io(&s->conf_mem, &pci_host_conf_le_ops, s, + "pci-conf-idx", 4); +@@ -212,6 +256,27 @@ static int i440fx_pcihost_initfn(SysBusDevice *dev) + + memory_region_init_io(&s->data_mem, &pci_host_data_le_ops, s, + "pci-conf-data", 4); ++ ++ object_property_add(obj, PCI_HOST_PROP_PCI_HOLE_START, "int", ++ i440fx_pcihost_get_pci_hole_start, ++ NULL, NULL, NULL, NULL); ++ ++ object_property_add(obj, PCI_HOST_PROP_PCI_HOLE_END, "int", ++ i440fx_pcihost_get_pci_hole_end, ++ NULL, NULL, NULL, NULL); ++ ++ object_property_add(obj, PCI_HOST_PROP_PCI_HOLE64_START, "int", ++ i440fx_pcihost_get_pci_hole64_start, ++ NULL, NULL, NULL, NULL); ++ ++ object_property_add(obj, PCI_HOST_PROP_PCI_HOLE64_END, "int", ++ i440fx_pcihost_get_pci_hole64_end, ++ NULL, NULL, NULL, NULL); ++ ++ d->pci_info.w32.end = IO_APIC_DEFAULT_ADDRESS; ++ ++ memory_region_init_io(&s->data_mem, &pci_host_data_le_ops, s, ++ "pci-conf-data", 4); + sysbus_add_io(dev, 0xcfc, &s->data_mem); + sysbus_init_ioports(&s->busdev, 0xcfc, 4); + +@@ -236,8 +301,7 @@ PCIBus *i440fx_init(PCII440FXState **pi440fx_state, + ram_addr_t ram_size, + hwaddr pci_hole_start, + hwaddr pci_hole_size, +- hwaddr pci_hole64_start, +- hwaddr pci_hole64_size, ++ ram_addr_t above_4g_mem_size, + MemoryRegion *pci_address_space, + MemoryRegion *ram_memory) + { +@@ -248,6 +312,7 @@ PCIBus *i440fx_init(PCII440FXState **pi440fx_state, + PIIX3State *piix3; + PCII440FXState *f; + unsigned i; ++ I440FXState *i440fx; + + dev = qdev_create(NULL, TYPE_I440FX_PCI_HOST_BRIDGE); + s = PCI_HOST_BRIDGE(dev); +@@ -263,14 +328,31 @@ PCIBus *i440fx_init(PCII440FXState **pi440fx_state, + f->system_memory = address_space_mem; + f->pci_address_space = pci_address_space; + f->ram_memory = ram_memory; ++ ++ i440fx = I440FX_PCI_HOST_BRIDGE(dev); ++ /* Set PCI window size the way seabios has always done it. */ ++ /* Power of 2 so bios can cover it with a single MTRR */ ++ if (ram_size <= 0x80000000) { ++ i440fx->pci_info.w32.begin = 0x80000000; ++ } else if (ram_size <= 0xc0000000) { ++ i440fx->pci_info.w32.begin = 0xc0000000; ++ } else { ++ i440fx->pci_info.w32.begin = 0xe0000000; ++ } ++ + memory_region_init_alias(&f->pci_hole, "pci-hole", f->pci_address_space, + pci_hole_start, pci_hole_size); + memory_region_add_subregion(f->system_memory, pci_hole_start, &f->pci_hole); ++ ++ pc_init_pci64_hole(&i440fx->pci_info, 0x100000000ULL + above_4g_mem_size, ++ i440fx->pci_hole64_size); + memory_region_init_alias(&f->pci_hole_64bit, "pci-hole64", + f->pci_address_space, +- pci_hole64_start, pci_hole64_size); +- if (pci_hole64_size) { +- memory_region_add_subregion(f->system_memory, pci_hole64_start, ++ i440fx->pci_info.w64.begin, ++ i440fx->pci_hole64_size); ++ if (i440fx->pci_hole64_size) { ++ memory_region_add_subregion(f->system_memory, ++ i440fx->pci_info.w64.begin, + &f->pci_hole_64bit); + } + memory_region_init_alias(&f->smram_region, "smram-region", +@@ -621,6 +703,12 @@ static const TypeInfo i440fx_info = { + .class_init = i440fx_class_init, + }; + ++static Property i440fx_props[] = { ++ DEFINE_PROP_SIZE(PCI_HOST_PROP_PCI_HOLE64_SIZE, I440FXState, ++ pci_hole64_size, DEFAULT_PCI_HOLE64_SIZE), ++ DEFINE_PROP_END_OF_LIST(), ++}; ++ + static void i440fx_pcihost_class_init(ObjectClass *klass, void *data) + { + DeviceClass *dc = DEVICE_CLASS(klass); +@@ -628,6 +716,7 @@ static void i440fx_pcihost_class_init(ObjectClass *klass, void *data) + + k->init = i440fx_pcihost_initfn; + dc->fw_name = "pci"; ++ dc->props = i440fx_props; + } + + static const TypeInfo i440fx_pcihost_info = { +diff --git a/hw/pci-host/q35.c b/hw/pci-host/q35.c +index 0989fc5..be12eee 100644 +--- a/hw/pci-host/q35.c ++++ b/hw/pci-host/q35.c +@@ -29,6 +29,7 @@ + */ + #include "hw/hw.h" + #include "hw/pci-host/q35.h" ++#include "qapi/visitor.h" + + /**************************************************************************** + * Q35 host +@@ -63,9 +64,49 @@ static int q35_host_init(SysBusDevice *dev) + return 0; + } + ++static void q35_host_get_pci_hole_start(Object *obj, Visitor *v, ++ void *opaque, const char *name, ++ Error **errp) ++{ ++ Q35PCIHost *s = Q35_HOST_DEVICE(obj); ++ uint32_t value = s->mch.pci_info.w32.begin; ++ ++ visit_type_uint32(v, &value, name, errp); ++} ++ ++static void q35_host_get_pci_hole_end(Object *obj, Visitor *v, ++ void *opaque, const char *name, ++ Error **errp) ++{ ++ Q35PCIHost *s = Q35_HOST_DEVICE(obj); ++ uint32_t value = s->mch.pci_info.w32.end; ++ ++ visit_type_uint32(v, &value, name, errp); ++} ++ ++static void q35_host_get_pci_hole64_start(Object *obj, Visitor *v, ++ void *opaque, const char *name, ++ Error **errp) ++{ ++ Q35PCIHost *s = Q35_HOST_DEVICE(obj); ++ ++ visit_type_uint64(v, &s->mch.pci_info.w64.begin, name, errp); ++} ++ ++static void q35_host_get_pci_hole64_end(Object *obj, Visitor *v, ++ void *opaque, const char *name, ++ Error **errp) ++{ ++ Q35PCIHost *s = Q35_HOST_DEVICE(obj); ++ ++ visit_type_uint64(v, &s->mch.pci_info.w64.end, name, errp); ++} ++ + static Property mch_props[] = { + DEFINE_PROP_UINT64("MCFG", Q35PCIHost, host.base_addr, + MCH_HOST_BRIDGE_PCIEXBAR_DEFAULT), ++ DEFINE_PROP_SIZE(PCI_HOST_PROP_PCI_HOLE64_SIZE, Q35PCIHost, ++ mch.pci_hole64_size, DEFAULT_PCI_HOLE64_SIZE), + DEFINE_PROP_END_OF_LIST(), + }; + +@@ -88,6 +129,31 @@ static void q35_host_initfn(Object *obj) + object_property_add_child(OBJECT(s), "mch", OBJECT(&s->mch), NULL); + qdev_prop_set_uint32(DEVICE(&s->mch), "addr", PCI_DEVFN(0, 0)); + qdev_prop_set_bit(DEVICE(&s->mch), "multifunction", false); ++ ++ object_property_add(obj, PCI_HOST_PROP_PCI_HOLE_START, "int", ++ q35_host_get_pci_hole_start, ++ NULL, NULL, NULL, NULL); ++ ++ object_property_add(obj, PCI_HOST_PROP_PCI_HOLE_END, "int", ++ q35_host_get_pci_hole_end, ++ NULL, NULL, NULL, NULL); ++ ++ object_property_add(obj, PCI_HOST_PROP_PCI_HOLE64_START, "int", ++ q35_host_get_pci_hole64_start, ++ NULL, NULL, NULL, NULL); ++ ++ object_property_add(obj, PCI_HOST_PROP_PCI_HOLE64_END, "int", ++ q35_host_get_pci_hole64_end, ++ NULL, NULL, NULL, NULL); ++ ++ /* Leave enough space for the biggest MCFG BAR */ ++ /* TODO: this matches current bios behaviour, but ++ * it's not a power of two, which means an MTRR ++ * can't cover it exactly. ++ */ ++ s->mch.pci_info.w32.begin = MCH_HOST_BRIDGE_PCIEXBAR_DEFAULT + ++ MCH_HOST_BRIDGE_PCIEXBAR_MAX; ++ s->mch.pci_info.w32.end = IO_APIC_DEFAULT_ADDRESS; + } + + static const TypeInfo q35_host_info = { +@@ -242,17 +308,8 @@ static void mch_reset(DeviceState *qdev) + static int mch_init(PCIDevice *d) + { + int i; +- hwaddr pci_hole64_size; + MCHPCIState *mch = MCH_PCI_DEVICE(d); + +- /* Leave enough space for the biggest MCFG BAR */ +- /* TODO: this matches current bios behaviour, but +- * it's not a power of two, which means an MTRR +- * can't cover it exactly. +- */ +- mch->guest_info->pci_info.w32.begin = MCH_HOST_BRIDGE_PCIEXBAR_DEFAULT + +- MCH_HOST_BRIDGE_PCIEXBAR_MAX; +- + /* setup pci memory regions */ + memory_region_init_alias(&mch->pci_hole, "pci-hole", + mch->pci_address_space, +@@ -260,15 +317,16 @@ static int mch_init(PCIDevice *d) + 0x100000000ULL - mch->below_4g_mem_size); + memory_region_add_subregion(mch->system_memory, mch->below_4g_mem_size, + &mch->pci_hole); +- pci_hole64_size = (sizeof(hwaddr) == 4 ? 0 : +- ((uint64_t)1 << 62)); ++ ++ pc_init_pci64_hole(&mch->pci_info, 0x100000000ULL + mch->above_4g_mem_size, ++ mch->pci_hole64_size); + memory_region_init_alias(&mch->pci_hole_64bit, "pci-hole64", + mch->pci_address_space, +- 0x100000000ULL + mch->above_4g_mem_size, +- pci_hole64_size); +- if (pci_hole64_size) { ++ mch->pci_info.w64.begin, ++ mch->pci_hole64_size); ++ if (mch->pci_hole64_size) { + memory_region_add_subregion(mch->system_memory, +- 0x100000000ULL + mch->above_4g_mem_size, ++ mch->pci_info.w64.begin, + &mch->pci_hole_64bit); + } + /* smram */ +diff --git a/include/hw/i386/pc.h b/include/hw/i386/pc.h +index 2992464..fe21bc3 100644 +--- a/include/hw/i386/pc.h ++++ b/include/hw/i386/pc.h +@@ -20,7 +20,6 @@ typedef struct PcPciInfo { + } PcPciInfo; + + struct PcGuestInfo { +- PcPciInfo pci_info; + bool has_pci_info; + FWCfgState *fw_cfg; + }; +@@ -101,6 +100,16 @@ void pc_acpi_init(const char *default_dsdt); + PcGuestInfo *pc_guest_info_init(ram_addr_t below_4g_mem_size, + ram_addr_t above_4g_mem_size); + ++#define PCI_HOST_PROP_PCI_HOLE_START "pci-hole-start" ++#define PCI_HOST_PROP_PCI_HOLE_END "pci-hole-end" ++#define PCI_HOST_PROP_PCI_HOLE64_START "pci-hole64-start" ++#define PCI_HOST_PROP_PCI_HOLE64_END "pci-hole64-end" ++#define PCI_HOST_PROP_PCI_HOLE64_SIZE "pci-hole64-size" ++#define DEFAULT_PCI_HOLE64_SIZE (1ULL << 31) ++ ++void pc_init_pci64_hole(PcPciInfo *pci_info, uint64_t pci_hole64_start, ++ uint64_t pci_hole64_size); ++ + FWCfgState *pc_memory_init(MemoryRegion *system_memory, + const char *kernel_filename, + const char *kernel_cmdline, +@@ -150,8 +159,7 @@ PCIBus *i440fx_init(PCII440FXState **pi440fx_state, int *piix_devfn, + ram_addr_t ram_size, + hwaddr pci_hole_start, + hwaddr pci_hole_size, +- hwaddr pci_hole64_start, +- hwaddr pci_hole64_size, ++ ram_addr_t above_4g_mem_size, + MemoryRegion *pci_memory, + MemoryRegion *ram_memory); + +diff --git a/include/hw/pci-host/q35.h b/include/hw/pci-host/q35.h +index b083831..e660a40 100644 +--- a/include/hw/pci-host/q35.h ++++ b/include/hw/pci-host/q35.h +@@ -52,9 +52,11 @@ typedef struct MCHPCIState { + MemoryRegion smram_region; + MemoryRegion pci_hole; + MemoryRegion pci_hole_64bit; ++ PcPciInfo pci_info; + uint8_t smm_enabled; + ram_addr_t below_4g_mem_size; + ram_addr_t above_4g_mem_size; ++ uint64_t pci_hole64_size; + PcGuestInfo *guest_info; + } MCHPCIState; + +-- +1.7.11.7 + diff --git a/SOURCES/kvm-pc-move-IO_APIC_DEFAULT_ADDRESS-to-include-hw-i386-i.patch b/SOURCES/kvm-pc-move-IO_APIC_DEFAULT_ADDRESS-to-include-hw-i386-i.patch new file mode 100644 index 0000000..b462ab1 --- /dev/null +++ b/SOURCES/kvm-pc-move-IO_APIC_DEFAULT_ADDRESS-to-include-hw-i386-i.patch @@ -0,0 +1,69 @@ +From 6b0e2eb81618b85ea078daba4688593d5cfaeba0 Mon Sep 17 00:00:00 2001 +Message-Id: <6b0e2eb81618b85ea078daba4688593d5cfaeba0.1387298827.git.minovotn@redhat.com> +In-Reply-To: <3ed0fb61a3dc912ef036d7ef450bed192090709e.1387298827.git.minovotn@redhat.com> +References: <3ed0fb61a3dc912ef036d7ef450bed192090709e.1387298827.git.minovotn@redhat.com> +From: "Michael S. Tsirkin" +Date: Tue, 17 Dec 2013 15:17:03 +0100 +Subject: [PATCH 06/56] pc: move IO_APIC_DEFAULT_ADDRESS to + include/hw/i386/ioapic.h +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +RH-Author: Michael S. Tsirkin +Message-id: <1387293161-4085-7-git-send-email-mst@redhat.com> +Patchwork-id: 56311 +O-Subject: [PATCH qemu-kvm RHEL7.0 v2 06/57] pc: move IO_APIC_DEFAULT_ADDRESS to include/hw/i386/ioapic.h +Bugzilla: 1034876 +RH-Acked-by: Igor Mammedov +RH-Acked-by: Marcel Apfelbaum +RH-Acked-by: Laszlo Ersek + +Signed-off-by: Michael S. Tsirkin +Signed-off-by: Laszlo Ersek +Signed-off-by: Igor Mammedov +Reviewed-by: Andreas Färber +Reviewed-by: Michael S. Tsirkin +Reviewed-by: Andreas Färber +Message-id: 1375109277-25561-2-git-send-email-imammedo@redhat.com +Signed-off-by: Anthony Liguori +(cherry picked from commit f5338ee30d91693f5805208e58df80f0551c3896) +--- + include/hw/i386/ioapic.h | 1 + + hw/i386/pc.c | 2 -- + 2 files changed, 1 insertion(+), 2 deletions(-) + +Signed-off-by: Michal Novotny +--- + hw/i386/pc.c | 2 -- + include/hw/i386/ioapic.h | 1 + + 2 files changed, 1 insertion(+), 2 deletions(-) + +diff --git a/hw/i386/pc.c b/hw/i386/pc.c +index 9e5a082..333e83f 100644 +--- a/hw/i386/pc.c ++++ b/hw/i386/pc.c +@@ -75,8 +75,6 @@ + #define FW_CFG_E820_TABLE (FW_CFG_ARCH_LOCAL + 3) + #define FW_CFG_HPET (FW_CFG_ARCH_LOCAL + 4) + +-#define IO_APIC_DEFAULT_ADDRESS 0xfec00000 +- + #define E820_NR_ENTRIES 16 + + struct e820_entry { +diff --git a/include/hw/i386/ioapic.h b/include/hw/i386/ioapic.h +index 86e63da..6245388 100644 +--- a/include/hw/i386/ioapic.h ++++ b/include/hw/i386/ioapic.h +@@ -21,6 +21,7 @@ + #define HW_IOAPIC_H + + #define IOAPIC_NUM_PINS 24 ++#define IO_APIC_DEFAULT_ADDRESS 0xfec00000 + + void ioapic_eoi_broadcast(int vector); + +-- +1.7.11.7 + diff --git a/SOURCES/kvm-pc-pass-PCI-hole-ranges-to-Guests.patch b/SOURCES/kvm-pc-pass-PCI-hole-ranges-to-Guests.patch new file mode 100644 index 0000000..b1595e9 --- /dev/null +++ b/SOURCES/kvm-pc-pass-PCI-hole-ranges-to-Guests.patch @@ -0,0 +1,234 @@ +From b70ff3a2191f959098f12965c4c7e5adb60be59e Mon Sep 17 00:00:00 2001 +Message-Id: +In-Reply-To: <3ed0fb61a3dc912ef036d7ef450bed192090709e.1387298827.git.minovotn@redhat.com> +References: <3ed0fb61a3dc912ef036d7ef450bed192090709e.1387298827.git.minovotn@redhat.com> +From: "Michael S. Tsirkin" +Date: Tue, 17 Dec 2013 15:17:24 +0100 +Subject: [PATCH 14/56] pc: pass PCI hole ranges to Guests + +RH-Author: Michael S. Tsirkin +Message-id: <1387293161-4085-15-git-send-email-mst@redhat.com> +Patchwork-id: 56320 +O-Subject: [PATCH qemu-kvm RHEL7.0 v2 14/57] pc: pass PCI hole ranges to Guests +Bugzilla: 1034876 +RH-Acked-by: Igor Mammedov +RH-Acked-by: Marcel Apfelbaum +RH-Acked-by: Laszlo Ersek + +Guest currently has to jump through lots of hoops to guess the PCI hole +ranges. It's fragile, and makes us change BIOS each time we add a new +chipset. Let's report the window in a ROM file, to make BIOS do exactly +what QEMU intends. + +Signed-off-by: Michael S. Tsirkin +(cherry picked from commit f8c457b88d72a48989f190bc3d7b79f4f3b7d11c) + +Conflicts: + hw/i386/pc_piix.c + hw/i386/pc_q35.c +--- + include/hw/i386/pc.h | 1 + + hw/i386/pc.c | 26 ++++++++++++++++++++++++++ + hw/i386/pc_piix.c | 16 +++++++++++++++- + hw/i386/pc_q35.c | 12 ++++++++++-- + 4 files changed, 52 insertions(+), 3 deletions(-) + +Signed-off-by: Michal Novotny +--- + hw/i386/pc.c | 26 ++++++++++++++++++++++++++ + hw/i386/pc_piix.c | 16 +++++++++++++++- + hw/i386/pc_q35.c | 12 ++++++++++-- + include/hw/i386/pc.h | 1 + + 4 files changed, 52 insertions(+), 3 deletions(-) + +diff --git a/hw/i386/pc.c b/hw/i386/pc.c +index 68a8e1b..238f6a0 100644 +--- a/hw/i386/pc.c ++++ b/hw/i386/pc.c +@@ -985,6 +985,31 @@ void pc_cpus_init(const char *cpu_model, DeviceState *icc_bridge) + } + } + ++/* pci-info ROM file. Little endian format */ ++typedef struct PcRomPciInfo { ++ uint64_t w32_min; ++ uint64_t w32_max; ++ uint64_t w64_min; ++ uint64_t w64_max; ++} PcRomPciInfo; ++ ++static void pc_fw_cfg_guest_info(PcGuestInfo *guest_info) ++{ ++ PcRomPciInfo *info; ++ if (!guest_info->has_pci_info) { ++ return; ++ } ++ ++ info = g_malloc(sizeof *info); ++ info->w32_min = cpu_to_le64(guest_info->pci_info.w32.begin); ++ info->w32_max = cpu_to_le64(guest_info->pci_info.w32.end); ++ info->w64_min = cpu_to_le64(guest_info->pci_info.w64.begin); ++ info->w64_max = cpu_to_le64(guest_info->pci_info.w64.end); ++ /* Pass PCI hole info to guest via a side channel. ++ * Required so guest PCI enumeration does the right thing. */ ++ fw_cfg_add_file(guest_info->fw_cfg, "etc/pci-info", info, sizeof *info); ++} ++ + typedef struct PcGuestInfoState { + PcGuestInfo info; + Notifier machine_done; +@@ -996,6 +1021,7 @@ void pc_guest_info_machine_done(Notifier *notifier, void *data) + PcGuestInfoState *guest_info_state = container_of(notifier, + PcGuestInfoState, + machine_done); ++ pc_fw_cfg_guest_info(&guest_info_state->info); + } + + PcGuestInfo *pc_guest_info_init(ram_addr_t below_4g_mem_size, +diff --git a/hw/i386/pc_piix.c b/hw/i386/pc_piix.c +index 3a77998..6d50a4e 100644 +--- a/hw/i386/pc_piix.c ++++ b/hw/i386/pc_piix.c +@@ -59,6 +59,7 @@ static const int ide_iobase2[MAX_IDE_BUS] = { 0x3f6, 0x376 }; + static const int ide_irq[MAX_IDE_BUS] = { 14, 15 }; + + static bool smbios_type1_defaults = true; ++static bool has_pci_info = true; + + /* PC hardware initialisation */ + static void pc_init1(QEMUMachineInitArgs *args, +@@ -122,6 +123,7 @@ static void pc_init1(QEMUMachineInitArgs *args, + } + + guest_info = pc_guest_info_init(below_4g_mem_size, above_4g_mem_size); ++ guest_info->has_pci_info = has_pci_info; + + /* Set PCI window size the way seabios has always done it. */ + /* Power of 2 so bios can cover it with a single MTRR */ +@@ -248,8 +250,15 @@ static void pc_init_pci(QEMUMachineInitArgs *args) + + #if 0 /* Disabled for Red Hat Enterprise Linux */ + ++static void pc_init_pci_1_5(QEMUMachineInitArgs *args) ++{ ++ has_pci_info = false; ++ pc_init_pci(args); ++} ++ + static void pc_init_pci_1_4(QEMUMachineInitArgs *args) + { ++ has_pci_info = false; + x86_cpu_compat_set_features("n270", FEAT_1_ECX, 0, CPUID_EXT_MOVBE); + x86_cpu_compat_set_features("Westmere", FEAT_1_ECX, 0, CPUID_EXT_PCLMULQDQ); + pc_init_pci(args); +@@ -257,6 +266,7 @@ static void pc_init_pci_1_4(QEMUMachineInitArgs *args) + + static void pc_init_pci_1_3(QEMUMachineInitArgs *args) + { ++ has_pci_info = false; + enable_compat_apic_id_mode(); + pc_init_pci(args); + } +@@ -264,6 +274,7 @@ static void pc_init_pci_1_3(QEMUMachineInitArgs *args) + /* PC machine init function for pc-1.1 to pc-1.2 */ + static void pc_init_pci_1_2(QEMUMachineInitArgs *args) + { ++ has_pci_info = false; + disable_kvm_pv_eoi(); + enable_compat_apic_id_mode(); + pc_init_pci(args); +@@ -272,6 +283,7 @@ static void pc_init_pci_1_2(QEMUMachineInitArgs *args) + /* PC machine init function for pc-0.14 to pc-1.0 */ + static void pc_init_pci_1_0(QEMUMachineInitArgs *args) + { ++ has_pci_info = false; + disable_kvm_pv_eoi(); + enable_compat_apic_id_mode(); + pc_init_pci(args); +@@ -280,6 +292,7 @@ static void pc_init_pci_1_0(QEMUMachineInitArgs *args) + /* PC init function for pc-0.10 to pc-0.13, and reused by xenfv */ + static void pc_init_pci_no_kvmclock(QEMUMachineInitArgs *args) + { ++ has_pci_info = false; + disable_kvm_pv_eoi(); + enable_compat_apic_id_mode(); + pc_init1(args, get_system_memory(), get_system_io(), 1, 0); +@@ -290,6 +303,7 @@ static void pc_init_isa(QEMUMachineInitArgs *args) + if (!args->cpu_model) { + args->cpu_model = "486"; + } ++ has_pci_info = false; + disable_kvm_pv_eoi(); + enable_compat_apic_id_mode(); + pc_init1(args, get_system_memory(), get_system_io(), 0, 1); +@@ -310,7 +324,7 @@ static QEMUMachine pc_i440fx_machine_v1_5 = { + .name = "pc-i440fx-1.5", + .alias = "pc", + .desc = "Standard PC (i440FX + PIIX, 1996)", +- .init = pc_init_pci, ++ .init = pc_init_pci_1_5, + .hot_add_cpu = pc_hot_add_cpu, + .max_cpus = 255, + .is_default = 1, +diff --git a/hw/i386/pc_q35.c b/hw/i386/pc_q35.c +index 9fab93c..7a58b61 100644 +--- a/hw/i386/pc_q35.c ++++ b/hw/i386/pc_q35.c +@@ -49,6 +49,7 @@ + #define MAX_SATA_PORTS 6 + + static bool smbios_type1_defaults = true; ++static bool has_pci_info = true; + + /* PC hardware initialisation */ + static void pc_q35_init(QEMUMachineInitArgs *args) +@@ -108,6 +109,7 @@ static void pc_q35_init(QEMUMachineInitArgs *args) + } + + guest_info = pc_guest_info_init(below_4g_mem_size, above_4g_mem_size); ++ guest_info->has_pci_info = has_pci_info; + + /* allocate ram and load rom/bios */ + if (!xen_enabled()) { +@@ -213,18 +215,24 @@ static void pc_q35_init(QEMUMachineInitArgs *args) + + #if 0 /* Disabled for Red Hat Enterprise Linux */ + ++static void pc_q35_init_1_5(QEMUMachineInitArgs *args) ++{ ++ has_pci_info = false; ++ pc_q35_init(args); ++} ++ + static void pc_q35_init_1_4(QEMUMachineInitArgs *args) + { + x86_cpu_compat_set_features("n270", FEAT_1_ECX, 0, CPUID_EXT_MOVBE); + x86_cpu_compat_set_features("Westmere", FEAT_1_ECX, 0, CPUID_EXT_PCLMULQDQ); +- pc_q35_init(args); ++ pc_q35_init_1_5(args); + } + + static QEMUMachine pc_q35_machine_v1_5 = { + .name = "pc-q35-1.5", + .alias = "q35", + .desc = "Standard PC (Q35 + ICH9, 2009)", +- .init = pc_q35_init, ++ .init = pc_q35_init_1_5, + .hot_add_cpu = pc_hot_add_cpu, + .max_cpus = 255, + .compat_props = (GlobalProperty[]) { +diff --git a/include/hw/i386/pc.h b/include/hw/i386/pc.h +index 2518db6..2992464 100644 +--- a/include/hw/i386/pc.h ++++ b/include/hw/i386/pc.h +@@ -21,6 +21,7 @@ typedef struct PcPciInfo { + + struct PcGuestInfo { + PcPciInfo pci_info; ++ bool has_pci_info; + FWCfgState *fw_cfg; + }; + +-- +1.7.11.7 + diff --git a/SOURCES/kvm-pc-replace-i440fx_common_init-with-i440fx_init.patch b/SOURCES/kvm-pc-replace-i440fx_common_init-with-i440fx_init.patch new file mode 100644 index 0000000..10880b7 --- /dev/null +++ b/SOURCES/kvm-pc-replace-i440fx_common_init-with-i440fx_init.patch @@ -0,0 +1,118 @@ +From b1aa978a4310bc3c6811be75be978970022df6d2 Mon Sep 17 00:00:00 2001 +Message-Id: +In-Reply-To: <3ed0fb61a3dc912ef036d7ef450bed192090709e.1387298827.git.minovotn@redhat.com> +References: <3ed0fb61a3dc912ef036d7ef450bed192090709e.1387298827.git.minovotn@redhat.com> +From: "Michael S. Tsirkin" +Date: Tue, 17 Dec 2013 15:17:27 +0100 +Subject: [PATCH 15/56] pc: replace i440fx_common_init() with i440fx_init() +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +RH-Author: Michael S. Tsirkin +Message-id: <1387293161-4085-16-git-send-email-mst@redhat.com> +Patchwork-id: 56321 +O-Subject: [PATCH qemu-kvm RHEL7.0 v2 15/57] pc: replace i440fx_common_init() with i440fx_init() +Bugzilla: 1034876 +RH-Acked-by: Igor Mammedov +RH-Acked-by: Marcel Apfelbaum +RH-Acked-by: Laszlo Ersek + +From: Igor Mammedov + +It isn't used anywhere else. + +Signed-off-by: Igor Mammedov +Reviewed-by: Andreas Färber +Reviewed-by: Michael S. Tsirkin +Reviewed-by: Andreas Färber +Message-id: 1375109277-25561-4-git-send-email-imammedo@redhat.com +Signed-off-by: Anthony Liguori +(cherry picked from commit 44fc8c5e743b84c1d29f603e4014125dcf152d26) +--- + hw/pci-host/piix.c | 50 +++++++++++++------------------------------------- + 1 file changed, 13 insertions(+), 37 deletions(-) + +Signed-off-by: Michal Novotny +--- + hw/pci-host/piix.c | 50 +++++++++++++------------------------------------- + 1 file changed, 13 insertions(+), 37 deletions(-) + +diff --git a/hw/pci-host/piix.c b/hw/pci-host/piix.c +index c89b76b..8894c03 100644 +--- a/hw/pci-host/piix.c ++++ b/hw/pci-host/piix.c +@@ -224,19 +224,18 @@ static int i440fx_initfn(PCIDevice *dev) + return 0; + } + +-static PCIBus *i440fx_common_init(const char *device_name, +- PCII440FXState **pi440fx_state, +- int *piix3_devfn, +- ISABus **isa_bus, qemu_irq *pic, +- MemoryRegion *address_space_mem, +- MemoryRegion *address_space_io, +- ram_addr_t ram_size, +- hwaddr pci_hole_start, +- hwaddr pci_hole_size, +- hwaddr pci_hole64_start, +- hwaddr pci_hole64_size, +- MemoryRegion *pci_address_space, +- MemoryRegion *ram_memory) ++PCIBus *i440fx_init(PCII440FXState **pi440fx_state, ++ int *piix3_devfn, ++ ISABus **isa_bus, qemu_irq *pic, ++ MemoryRegion *address_space_mem, ++ MemoryRegion *address_space_io, ++ ram_addr_t ram_size, ++ hwaddr pci_hole_start, ++ hwaddr pci_hole_size, ++ hwaddr pci_hole64_start, ++ hwaddr pci_hole64_size, ++ MemoryRegion *pci_address_space, ++ MemoryRegion *ram_memory) + { + DeviceState *dev; + PCIBus *b; +@@ -254,7 +253,7 @@ static PCIBus *i440fx_common_init(const char *device_name, + object_property_add_child(qdev_get_machine(), "i440fx", OBJECT(dev), NULL); + qdev_init_nofail(dev); + +- d = pci_create_simple(b, 0, device_name); ++ d = pci_create_simple(b, 0, TYPE_I440FX_PCI_DEVICE); + *pi440fx_state = I440FX_PCI_DEVICE(d); + f = *pi440fx_state; + f->system_memory = address_space_mem; +@@ -314,29 +313,6 @@ static PCIBus *i440fx_common_init(const char *device_name, + return b; + } + +-PCIBus *i440fx_init(PCII440FXState **pi440fx_state, int *piix3_devfn, +- ISABus **isa_bus, qemu_irq *pic, +- MemoryRegion *address_space_mem, +- MemoryRegion *address_space_io, +- ram_addr_t ram_size, +- hwaddr pci_hole_start, +- hwaddr pci_hole_size, +- hwaddr pci_hole64_start, +- hwaddr pci_hole64_size, +- MemoryRegion *pci_memory, MemoryRegion *ram_memory) +- +-{ +- PCIBus *b; +- +- b = i440fx_common_init(TYPE_I440FX_PCI_DEVICE, pi440fx_state, +- piix3_devfn, isa_bus, pic, +- address_space_mem, address_space_io, ram_size, +- pci_hole_start, pci_hole_size, +- pci_hole64_start, pci_hole64_size, +- pci_memory, ram_memory); +- return b; +-} +- + /* PIIX3 PCI to ISA bridge */ + static void piix3_set_irq_pic(PIIX3State *piix3, int pic_irq) + { +-- +1.7.11.7 + diff --git a/SOURCES/kvm-pc-use-new-api-to-add-builtin-tables.patch b/SOURCES/kvm-pc-use-new-api-to-add-builtin-tables.patch new file mode 100644 index 0000000..58ab198 --- /dev/null +++ b/SOURCES/kvm-pc-use-new-api-to-add-builtin-tables.patch @@ -0,0 +1,47 @@ +From bc610d00154bcd6548c84554d7b647a64834a807 Mon Sep 17 00:00:00 2001 +Message-Id: +In-Reply-To: <3ed0fb61a3dc912ef036d7ef450bed192090709e.1387298827.git.minovotn@redhat.com> +References: <3ed0fb61a3dc912ef036d7ef450bed192090709e.1387298827.git.minovotn@redhat.com> +From: "Michael S. Tsirkin" +Date: Tue, 17 Dec 2013 15:19:05 +0100 +Subject: [PATCH 47/56] pc: use new api to add builtin tables + +RH-Author: Michael S. Tsirkin +Message-id: <1387293161-4085-48-git-send-email-mst@redhat.com> +Patchwork-id: 56352 +O-Subject: [PATCH qemu-kvm RHEL7.0 v2 47/57] pc: use new api to add builtin tables +Bugzilla: 1034876 +RH-Acked-by: Igor Mammedov +RH-Acked-by: Marcel Apfelbaum +RH-Acked-by: Laszlo Ersek + +At this point the only builtin table we have is +the DSDT used for Q35. + +Signed-off-by: Michael S. Tsirkin +(cherry picked from commit 1a4b2666dfbd6fbd9b5623a8e0ed6035cd0854fe) +--- + hw/i386/pc.c | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +Signed-off-by: Michal Novotny +--- + hw/i386/pc.c | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/hw/i386/pc.c b/hw/i386/pc.c +index 4d54c0b..041e537 100644 +--- a/hw/i386/pc.c ++++ b/hw/i386/pc.c +@@ -1109,7 +1109,7 @@ void pc_acpi_init(const char *default_dsdt) + opts = qemu_opts_parse(qemu_find_opts("acpi"), arg, 0); + g_assert(opts != NULL); + +- acpi_table_add(opts, &err); ++ acpi_table_add_builtin(opts, &err); + if (err) { + error_report("WARNING: failed to load %s: %s", filename, + error_get_pretty(err)); +-- +1.7.11.7 + diff --git a/SOURCES/kvm-pc_piix-document-gigabyte_align.patch b/SOURCES/kvm-pc_piix-document-gigabyte_align.patch new file mode 100644 index 0000000..00780e9 --- /dev/null +++ b/SOURCES/kvm-pc_piix-document-gigabyte_align.patch @@ -0,0 +1,64 @@ +From 7212bc6c8e9b4a3118e1cc90157c2f123198139e Mon Sep 17 00:00:00 2001 +From: Gerd Hoffmann +Date: Thu, 16 Jan 2014 10:25:57 +0100 +Subject: [PATCH 02/14] pc_piix: document gigabyte_align + +RH-Author: Gerd Hoffmann +Message-id: <1389867959-12463-3-git-send-email-kraxel@redhat.com> +Patchwork-id: 56745 +O-Subject: [RHEL-7 qemu-kvm PATCH 2/4] pc_piix: document gigabyte_align +Bugzilla: 1026548 +RH-Acked-by: Laszlo Ersek +RH-Acked-by: Igor Mammedov +RH-Acked-by: Paolo Bonzini + +From: "Michael S. Tsirkin" + +Document the logic behind the below/above 4G split. + +Signed-off-by: Michael S. Tsirkin +(cherry picked from commit ecdbfceb0f20a3ef784bf522ed7264660aa3d150) + +Conflicts: + hw/i386/pc_piix.c +--- + hw/i386/pc_piix.c | 11 +++++++++++ + 1 file changed, 11 insertions(+) + +Signed-off-by: Miroslav Rezanina +--- + hw/i386/pc_piix.c | 11 +++++++++++ + 1 files changed, 11 insertions(+), 0 deletions(-) + +diff --git a/hw/i386/pc_piix.c b/hw/i386/pc_piix.c +index 9f1d0b5..12351f9 100644 +--- a/hw/i386/pc_piix.c ++++ b/hw/i386/pc_piix.c +@@ -61,6 +61,10 @@ static const int ide_irq[MAX_IDE_BUS] = { 14, 15 }; + static bool smbios_type1_defaults = true; + static bool has_pci_info; + static bool has_acpi_build = true; ++/* Make sure that guest addresses aligned at 1Gbyte boundaries get mapped to ++ * host addresses aligned at 1Gbyte boundaries. This way we can use 1GByte ++ * pages in the host. ++ */ + static bool gigabyte_align = true; + + /* PC hardware initialisation */ +@@ -102,6 +106,13 @@ static void pc_init1(QEMUMachineInitArgs *args, + kvmclock_create(); + } + ++ /* Check whether RAM fits below 4G (leaving 1/2 GByte for IO memory). ++ * If it doesn't, we need to split it in chunks below and above 4G. ++ * In any case, try to make sure that guest addresses aligned at ++ * 1G boundaries get mapped to host addresses aligned at 1G boundaries. ++ * For old machine types, use whatever split we used historically to avoid ++ * breaking migration. ++ */ + if (args->ram_size >= 0xe0000000) { + ram_addr_t lowmem = gigabyte_align ? 0xc0000000 : 0xe0000000; + above_4g_mem_size = args->ram_size - lowmem; +-- +1.7.1 + diff --git a/SOURCES/kvm-pc_sysfw-allow-flash-pflash-memory-to-be-used-with-K.patch b/SOURCES/kvm-pc_sysfw-allow-flash-pflash-memory-to-be-used-with-K.patch new file mode 100644 index 0000000..f38534f --- /dev/null +++ b/SOURCES/kvm-pc_sysfw-allow-flash-pflash-memory-to-be-used-with-K.patch @@ -0,0 +1,111 @@ +From 18238ae670fb38f5ca7002bc8da7b7aa9d612f68 Mon Sep 17 00:00:00 2001 +From: Laszlo Ersek +Date: Sat, 11 Jan 2014 17:59:58 +0100 +Subject: [PATCH 08/22] pc_sysfw: allow flash (-pflash) memory to be used with KVM + +RH-Author: Laszlo Ersek +Message-id: <1389463208-6278-9-git-send-email-lersek@redhat.com> +Patchwork-id: 56621 +O-Subject: [RHEL-7.0 qemu-kvm PATCH 08/18] pc_sysfw: allow flash (-pflash) memory to be used with KVM +Bugzilla: 1032346 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Amos Kong +RH-Acked-by: Andrew Jones + +From: Jordan Justen + +When pc-sysfw.rom_only == 0, flash memory will be +usable with kvm. In order to enable flash memory mode, +a pflash device must be created. (For example, by +using the -pflash command line parameter.) + +Usage of a flash memory device with kvm requires +KVM_CAP_READONLY_MEM, and kvm will abort if +a flash device is used with an older kvm which does +not support this capability. + +If a flash device is not used, then qemu/kvm will +operate in the original rom-mode. + +Signed-off-by: Jordan Justen +Reviewed-by: Paolo Bonzini +Message-id: 1369816047-16384-5-git-send-email-jordan.l.justen@intel.com +Signed-off-by: Anthony Liguori +(cherry picked from commit dafb82e0fc89b631d25f8def649fbfd14fec3db2) +Signed-off-by: Laszlo Ersek +--- + hw/block/pc_sysfw.c | 50 +++++++++++++++++++++++++++++++------------------- + 1 file changed, 31 insertions(+), 19 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + hw/block/pc_sysfw.c | 50 +++++++++++++++++++++++++++++++------------------- + 1 files changed, 31 insertions(+), 19 deletions(-) + +diff --git a/hw/block/pc_sysfw.c b/hw/block/pc_sysfw.c +index 4d82c70..76932fc 100644 +--- a/hw/block/pc_sysfw.c ++++ b/hw/block/pc_sysfw.c +@@ -217,28 +217,40 @@ void pc_system_firmware_init(MemoryRegion *rom_memory) + + qdev_init_nofail(DEVICE(sysfw_dev)); + +- if (sysfw_dev->rom_only) { +- old_pc_system_rom_init(rom_memory, sysfw_dev->isapc_ram_fw); +- return; +- } +- + pflash_drv = drive_get(IF_PFLASH, 0, 0); + +- /* Currently KVM cannot execute from device memory. +- Use old rom based firmware initialization for KVM. */ +- /* +- * This is a Bad Idea, because it makes enabling/disabling KVM +- * guest-visible. Let's fix it for real in QEMU 1.6. +- */ +- if (kvm_enabled()) { +- if (pflash_drv != NULL) { +- fprintf(stderr, "qemu: pflash cannot be used with kvm enabled\n"); +- exit(1); +- } else { +- sysfw_dev->rom_only = 1; +- old_pc_system_rom_init(rom_memory, sysfw_dev->isapc_ram_fw); +- return; ++ if (pc_sysfw_flash_vs_rom_bug_compatible) { ++ /* ++ * This is a Bad Idea, because it makes enabling/disabling KVM ++ * guest-visible. Do it only in bug-compatibility mode. ++ */ ++ if (kvm_enabled()) { ++ if (pflash_drv != NULL) { ++ fprintf(stderr, "qemu: pflash cannot be used with kvm enabled\n"); ++ exit(1); ++ } else { ++ /* In old pc_sysfw_flash_vs_rom_bug_compatible mode, we assume ++ * that KVM cannot execute from device memory. In this case, we ++ * use old rom based firmware initialization for KVM. But, since ++ * this is different from non-kvm mode, this behavior is ++ * undesirable */ ++ sysfw_dev->rom_only = 1; ++ } + } ++ } else if (pflash_drv == NULL) { ++ /* When a pflash drive is not found, use rom-mode */ ++ sysfw_dev->rom_only = 1; ++ } else if (kvm_enabled() && !kvm_readonly_mem_enabled()) { ++ /* Older KVM cannot execute from device memory. So, flash memory ++ * cannot be used unless the readonly memory kvm capability is present. */ ++ fprintf(stderr, "qemu: pflash with kvm requires KVM readonly memory support\n"); ++ exit(1); ++ } ++ ++ /* If rom-mode is active, use the old pc system rom initialization. */ ++ if (sysfw_dev->rom_only) { ++ old_pc_system_rom_init(rom_memory, sysfw_dev->isapc_ram_fw); ++ return; + } + + /* If a pflash drive is not found, then create one using +-- +1.7.1 + diff --git a/SOURCES/kvm-pc_sysfw-do-not-make-it-a-device-anymore.patch b/SOURCES/kvm-pc_sysfw-do-not-make-it-a-device-anymore.patch new file mode 100644 index 0000000..fb73385 --- /dev/null +++ b/SOURCES/kvm-pc_sysfw-do-not-make-it-a-device-anymore.patch @@ -0,0 +1,613 @@ +From b9968ba04f7d8528d07c49bf523474ac4cb63acd Mon Sep 17 00:00:00 2001 +From: Laszlo Ersek +Date: Wed, 29 Jan 2014 07:06:24 +0100 +Subject: [PATCH 12/22] pc_sysfw: do not make it a device anymore + +Message-id: <1389463208-6278-13-git-send-email-lersek@redhat.com> +Patchwork-id: 56625 +O-Subject: [RHEL-7.0 qemu-kvm PATCH 12/18] pc_sysfw: do not make it a device anymore +Bugzilla: 1032346 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Amos Kong +RH-Acked-by: Andrew Jones + +From: Paolo Bonzini + +Move the code to hw/i386, the sole remaining property is available +as !pci_enabled. + +Signed-off-by: Paolo Bonzini +Signed-off-by: Markus Armbruster +Message-id: 1376069702-22330-4-git-send-email-aliguori@us.ibm.com + +Rebased. + +Signed-off-by: Markus Armbruster +Signed-off-by: Anthony Liguori +(cherry picked from commit 6dd2a5c98a6b1c9189d342bcc3493c9b5dd1217e) + +Conflicts: + hw/block/Makefile.objs + hw/i386/pc_q35.c + include/hw/i386/pc.h + +Signed-off-by: Laszlo Ersek +--- + hw/block/Makefile.objs | 1 - + hw/i386/Makefile.objs | 1 + + include/hw/i386/pc.h | 4 ++- + hw/i386/pc.c | 2 +- + hw/i386/pc_piix.c | 6 +---- + hw/i386/pc_q35.c | 1 + + hw/{block => i386}/pc_sysfw.c | 52 +++----------------------------------- + default-configs/i386-softmmu.mak | 1 - + default-configs/x86_64-softmmu.mak | 1 - + 9 files changed, 10 insertions(+), 59 deletions(-) + rename hw/{block => i386}/pc_sysfw.c (81%) + +Signed-off-by: Miroslav Rezanina +--- + default-configs/i386-softmmu.mak | 1 - + default-configs/x86_64-softmmu.mak | 1 - + hw/block/Makefile.objs | 1 - + hw/block/pc_sysfw.c | 231 ------------------------------------ + hw/i386/Makefile.objs | 1 + + hw/i386/pc.c | 2 +- + hw/i386/pc_piix.c | 6 +- + hw/i386/pc_q35.c | 1 + + hw/i386/pc_sysfw.c | 185 +++++++++++++++++++++++++++++ + include/hw/i386/pc.h | 4 +- + 10 files changed, 192 insertions(+), 241 deletions(-) + delete mode 100644 hw/block/pc_sysfw.c + create mode 100644 hw/i386/pc_sysfw.c + +diff --git a/default-configs/i386-softmmu.mak b/default-configs/i386-softmmu.mak +index 03deca2..fb84f80 100644 +--- a/default-configs/i386-softmmu.mak ++++ b/default-configs/i386-softmmu.mak +@@ -34,7 +34,6 @@ CONFIG_PAM=y + CONFIG_PCI_PIIX=y + CONFIG_PCI_HOTPLUG=y + CONFIG_WDT_IB700=y +-CONFIG_PC_SYSFW=y + CONFIG_XEN_I386=$(CONFIG_XEN) + CONFIG_ISA_DEBUG=y + CONFIG_ISA_TESTDEV=y +diff --git a/default-configs/x86_64-softmmu.mak b/default-configs/x86_64-softmmu.mak +index 7b8b05c..a6fdf84 100644 +--- a/default-configs/x86_64-softmmu.mak ++++ b/default-configs/x86_64-softmmu.mak +@@ -27,7 +27,6 @@ CONFIG_PAM=y + CONFIG_PCI_PIIX=y + CONFIG_PCI_HOTPLUG=y + CONFIG_WDT_IB700=y +-CONFIG_PC_SYSFW=y + CONFIG_XEN_I386=$(CONFIG_XEN) + CONFIG_ISA_DEBUG=y + CONFIG_ISA_TESTDEV=y +diff --git a/hw/block/Makefile.objs b/hw/block/Makefile.objs +index e4329a0..94491bf 100644 +--- a/hw/block/Makefile.objs ++++ b/hw/block/Makefile.objs +@@ -7,7 +7,6 @@ common-obj-$(CONFIG_PFLASH_CFI02) += pflash_cfi02.o + common-obj-$(CONFIG_XEN_BACKEND) += xen_disk.o + common-obj-$(CONFIG_ECC) += ecc.o + common-obj-$(CONFIG_ONENAND) += onenand.o +-common-obj-$(CONFIG_PC_SYSFW) += pc_sysfw.o + + obj-$(CONFIG_SH4) += tc58128.o + +diff --git a/hw/block/pc_sysfw.c b/hw/block/pc_sysfw.c +deleted file mode 100644 +index f9c0633..0000000 +--- a/hw/block/pc_sysfw.c ++++ /dev/null +@@ -1,231 +0,0 @@ +-/* +- * QEMU PC System Firmware +- * +- * Copyright (c) 2003-2004 Fabrice Bellard +- * Copyright (c) 2011-2012 Intel Corporation +- * +- * Permission is hereby granted, free of charge, to any person obtaining a copy +- * of this software and associated documentation files (the "Software"), to deal +- * in the Software without restriction, including without limitation the rights +- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +- * copies of the Software, and to permit persons to whom the Software is +- * furnished to do so, subject to the following conditions: +- * +- * The above copyright notice and this permission notice shall be included in +- * all copies or substantial portions of the Software. +- * +- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL +- * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +- * THE SOFTWARE. +- */ +- +-#include "sysemu/blockdev.h" +-#include "qemu/error-report.h" +-#include "hw/sysbus.h" +-#include "hw/hw.h" +-#include "hw/i386/pc.h" +-#include "hw/boards.h" +-#include "hw/loader.h" +-#include "sysemu/sysemu.h" +-#include "hw/block/flash.h" +-#include "sysemu/kvm.h" +- +-#define BIOS_FILENAME "bios.bin" +- +-typedef struct PcSysFwDevice { +- SysBusDevice busdev; +- uint8_t isapc_ram_fw; +-} PcSysFwDevice; +- +-static void pc_isa_bios_init(MemoryRegion *rom_memory, +- MemoryRegion *flash_mem, +- int ram_size) +-{ +- int isa_bios_size; +- MemoryRegion *isa_bios; +- uint64_t flash_size; +- void *flash_ptr, *isa_bios_ptr; +- +- flash_size = memory_region_size(flash_mem); +- +- /* map the last 128KB of the BIOS in ISA space */ +- isa_bios_size = MIN(flash_size, 128 * 1024); +- isa_bios = g_malloc(sizeof(*isa_bios)); +- memory_region_init_ram(isa_bios, "isa-bios", isa_bios_size); +- vmstate_register_ram_global(isa_bios); +- memory_region_add_subregion_overlap(rom_memory, +- 0x100000 - isa_bios_size, +- isa_bios, +- 1); +- +- /* copy ISA rom image from top of flash memory */ +- flash_ptr = memory_region_get_ram_ptr(flash_mem); +- isa_bios_ptr = memory_region_get_ram_ptr(isa_bios); +- memcpy(isa_bios_ptr, +- ((uint8_t*)flash_ptr) + (flash_size - isa_bios_size), +- isa_bios_size); +- +- memory_region_set_readonly(isa_bios, true); +-} +- +-static void pc_system_flash_init(MemoryRegion *rom_memory, +- DriveInfo *pflash_drv) +-{ +- BlockDriverState *bdrv; +- int64_t size; +- hwaddr phys_addr; +- int sector_bits, sector_size; +- pflash_t *system_flash; +- MemoryRegion *flash_mem; +- +- bdrv = pflash_drv->bdrv; +- size = bdrv_getlength(pflash_drv->bdrv); +- sector_bits = 12; +- sector_size = 1 << sector_bits; +- +- if ((size % sector_size) != 0) { +- fprintf(stderr, +- "qemu: PC system firmware (pflash) must be a multiple of 0x%x\n", +- sector_size); +- exit(1); +- } +- +- phys_addr = 0x100000000ULL - size; +- system_flash = pflash_cfi01_register(phys_addr, NULL, "system.flash", size, +- bdrv, sector_size, size >> sector_bits, +- 1, 0x0000, 0x0000, 0x0000, 0x0000, 0); +- flash_mem = pflash_cfi01_get_memory(system_flash); +- +- pc_isa_bios_init(rom_memory, flash_mem, size); +-} +- +-static void old_pc_system_rom_init(MemoryRegion *rom_memory, bool isapc_ram_fw) +-{ +- char *filename; +- MemoryRegion *bios, *isa_bios; +- int bios_size, isa_bios_size; +- int ret; +- +- /* BIOS load */ +- if (bios_name == NULL) { +- bios_name = BIOS_FILENAME; +- } +- filename = qemu_find_file(QEMU_FILE_TYPE_BIOS, bios_name); +- if (filename) { +- bios_size = get_image_size(filename); +- } else { +- bios_size = -1; +- } +- if (bios_size <= 0 || +- (bios_size % 65536) != 0) { +- goto bios_error; +- } +- bios = g_malloc(sizeof(*bios)); +- memory_region_init_ram(bios, "pc.bios", bios_size); +- vmstate_register_ram_global(bios); +- if (!isapc_ram_fw) { +- memory_region_set_readonly(bios, true); +- } +- ret = rom_add_file_fixed(bios_name, (uint32_t)(-bios_size), -1); +- if (ret != 0) { +- bios_error: +- fprintf(stderr, "qemu: could not load PC BIOS '%s'\n", bios_name); +- exit(1); +- } +- if (filename) { +- g_free(filename); +- } +- +- /* map the last 128KB of the BIOS in ISA space */ +- isa_bios_size = bios_size; +- if (isa_bios_size > (128 * 1024)) { +- isa_bios_size = 128 * 1024; +- } +- isa_bios = g_malloc(sizeof(*isa_bios)); +- memory_region_init_alias(isa_bios, "isa-bios", bios, +- bios_size - isa_bios_size, isa_bios_size); +- memory_region_add_subregion_overlap(rom_memory, +- 0x100000 - isa_bios_size, +- isa_bios, +- 1); +- if (!isapc_ram_fw) { +- memory_region_set_readonly(isa_bios, true); +- } +- +- /* map all the bios at the top of memory */ +- memory_region_add_subregion(rom_memory, +- (uint32_t)(-bios_size), +- bios); +-} +- +-void pc_system_firmware_init(MemoryRegion *rom_memory) +-{ +- DriveInfo *pflash_drv; +- PcSysFwDevice *sysfw_dev; +- +- /* +- * TODO This device exists only so that users can switch between +- * use of flash and ROM for the BIOS. The ability to switch was +- * created because flash doesn't work with KVM. Once it does, we +- * should drop this device. +- */ +- sysfw_dev = (PcSysFwDevice*) qdev_create(NULL, "pc-sysfw"); +- +- qdev_init_nofail(DEVICE(sysfw_dev)); +- +- pflash_drv = drive_get(IF_PFLASH, 0, 0); +- +- if (sysfw_dev->isapc_ram_fw || pflash_drv == NULL) { +- /* When a pflash drive is not found, use rom-mode */ +- old_pc_system_rom_init(rom_memory, sysfw_dev->isapc_ram_fw); +- return; +- } +- +- if (kvm_enabled() && !kvm_readonly_mem_enabled()) { +- /* Older KVM cannot execute from device memory. So, flash memory +- * cannot be used unless the readonly memory kvm capability is present. */ +- fprintf(stderr, "qemu: pflash with kvm requires KVM readonly memory support\n"); +- exit(1); +- } +- +- pc_system_flash_init(rom_memory, pflash_drv); +-} +- +-static Property pcsysfw_properties[] = { +- DEFINE_PROP_UINT8("isapc_ram_fw", PcSysFwDevice, isapc_ram_fw, 0), +- DEFINE_PROP_END_OF_LIST(), +-}; +- +-static int pcsysfw_init(DeviceState *dev) +-{ +- return 0; +-} +- +-static void pcsysfw_class_init (ObjectClass *klass, void *data) +-{ +- DeviceClass *dc = DEVICE_CLASS (klass); +- +- set_bit(DEVICE_CATEGORY_STORAGE, dc->categories); +- dc->desc = "PC System Firmware"; +- dc->init = pcsysfw_init; +- dc->props = pcsysfw_properties; +-} +- +-static const TypeInfo pcsysfw_info = { +- .name = "pc-sysfw", +- .parent = TYPE_SYS_BUS_DEVICE, +- .instance_size = sizeof (PcSysFwDevice), +- .class_init = pcsysfw_class_init, +-}; +- +-static void pcsysfw_register (void) +-{ +- type_register_static (&pcsysfw_info); +-} +- +-type_init (pcsysfw_register); +- +diff --git a/hw/i386/Makefile.objs b/hw/i386/Makefile.objs +index 6a17cf8..09ac433 100644 +--- a/hw/i386/Makefile.objs ++++ b/hw/i386/Makefile.objs +@@ -1,6 +1,7 @@ + obj-$(CONFIG_KVM) += kvm/ + obj-y += multiboot.o smbios.o + obj-y += pc.o pc_piix.o pc_q35.o ++obj-y += pc_sysfw.o + obj-$(CONFIG_XEN) += xen_domainbuild.o xen_machine_pv.o + + obj-y += kvmvapic.o +diff --git a/hw/i386/pc.c b/hw/i386/pc.c +index 320f668..a0f0b24 100644 +--- a/hw/i386/pc.c ++++ b/hw/i386/pc.c +@@ -1162,7 +1162,7 @@ FWCfgState *pc_memory_init(MemoryRegion *system_memory, + + + /* Initialize PC system firmware */ +- pc_system_firmware_init(rom_memory); ++ pc_system_firmware_init(rom_memory, guest_info->isapc_ram_fw); + + option_rom_mr = g_malloc(sizeof(*option_rom_mr)); + memory_region_init_ram(option_rom_mr, "pc.rom", PC_ROM_SIZE); +diff --git a/hw/i386/pc_piix.c b/hw/i386/pc_piix.c +index 6f273db..641f3d9 100644 +--- a/hw/i386/pc_piix.c ++++ b/hw/i386/pc_piix.c +@@ -141,6 +141,7 @@ static void pc_init1(QEMUMachineInitArgs *args, + guest_info->has_acpi_build = has_acpi_build; + + guest_info->has_pci_info = has_pci_info; ++ guest_info->isapc_ram_fw = !pci_enabled; + + /* allocate ram and load rom/bios */ + if (!xen_enabled()) { +@@ -705,11 +706,6 @@ static QEMUMachine isapc_machine = { + .init = pc_init_isa, + .max_cpus = 1, + .compat_props = (GlobalProperty[]) { +- { +- .driver = "pc-sysfw", +- .property = "isapc_ram_fw", +- .value = stringify(1), +- }, + { /* end of list */ } + }, + DEFAULT_MACHINE_OPTIONS, +diff --git a/hw/i386/pc_q35.c b/hw/i386/pc_q35.c +index 7e46799..1ac46be 100644 +--- a/hw/i386/pc_q35.c ++++ b/hw/i386/pc_q35.c +@@ -114,6 +114,7 @@ static void pc_q35_init(QEMUMachineInitArgs *args) + guest_info = pc_guest_info_init(below_4g_mem_size, above_4g_mem_size); + guest_info->has_pci_info = has_pci_info; + guest_info->has_acpi_build = has_acpi_build; ++ guest_info->isapc_ram_fw = false; + + /* allocate ram and load rom/bios */ + if (!xen_enabled()) { +diff --git a/hw/i386/pc_sysfw.c b/hw/i386/pc_sysfw.c +new file mode 100644 +index 0000000..eb56dee +--- /dev/null ++++ b/hw/i386/pc_sysfw.c +@@ -0,0 +1,185 @@ ++/* ++ * QEMU PC System Firmware ++ * ++ * Copyright (c) 2003-2004 Fabrice Bellard ++ * Copyright (c) 2011-2012 Intel Corporation ++ * ++ * Permission is hereby granted, free of charge, to any person obtaining a copy ++ * of this software and associated documentation files (the "Software"), to deal ++ * in the Software without restriction, including without limitation the rights ++ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell ++ * copies of the Software, and to permit persons to whom the Software is ++ * furnished to do so, subject to the following conditions: ++ * ++ * The above copyright notice and this permission notice shall be included in ++ * all copies or substantial portions of the Software. ++ * ++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR ++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, ++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL ++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER ++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, ++ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN ++ * THE SOFTWARE. ++ */ ++ ++#include "sysemu/blockdev.h" ++#include "qemu/error-report.h" ++#include "hw/sysbus.h" ++#include "hw/hw.h" ++#include "hw/i386/pc.h" ++#include "hw/boards.h" ++#include "hw/loader.h" ++#include "sysemu/sysemu.h" ++#include "hw/block/flash.h" ++#include "sysemu/kvm.h" ++ ++#define BIOS_FILENAME "bios.bin" ++ ++typedef struct PcSysFwDevice { ++ SysBusDevice busdev; ++ uint8_t isapc_ram_fw; ++} PcSysFwDevice; ++ ++static void pc_isa_bios_init(MemoryRegion *rom_memory, ++ MemoryRegion *flash_mem, ++ int ram_size) ++{ ++ int isa_bios_size; ++ MemoryRegion *isa_bios; ++ uint64_t flash_size; ++ void *flash_ptr, *isa_bios_ptr; ++ ++ flash_size = memory_region_size(flash_mem); ++ ++ /* map the last 128KB of the BIOS in ISA space */ ++ isa_bios_size = MIN(flash_size, 128 * 1024); ++ isa_bios = g_malloc(sizeof(*isa_bios)); ++ memory_region_init_ram(isa_bios, "isa-bios", isa_bios_size); ++ vmstate_register_ram_global(isa_bios); ++ memory_region_add_subregion_overlap(rom_memory, ++ 0x100000 - isa_bios_size, ++ isa_bios, ++ 1); ++ ++ /* copy ISA rom image from top of flash memory */ ++ flash_ptr = memory_region_get_ram_ptr(flash_mem); ++ isa_bios_ptr = memory_region_get_ram_ptr(isa_bios); ++ memcpy(isa_bios_ptr, ++ ((uint8_t*)flash_ptr) + (flash_size - isa_bios_size), ++ isa_bios_size); ++ ++ memory_region_set_readonly(isa_bios, true); ++} ++ ++static void pc_system_flash_init(MemoryRegion *rom_memory, ++ DriveInfo *pflash_drv) ++{ ++ BlockDriverState *bdrv; ++ int64_t size; ++ hwaddr phys_addr; ++ int sector_bits, sector_size; ++ pflash_t *system_flash; ++ MemoryRegion *flash_mem; ++ ++ bdrv = pflash_drv->bdrv; ++ size = bdrv_getlength(pflash_drv->bdrv); ++ sector_bits = 12; ++ sector_size = 1 << sector_bits; ++ ++ if ((size % sector_size) != 0) { ++ fprintf(stderr, ++ "qemu: PC system firmware (pflash) must be a multiple of 0x%x\n", ++ sector_size); ++ exit(1); ++ } ++ ++ phys_addr = 0x100000000ULL - size; ++ system_flash = pflash_cfi01_register(phys_addr, NULL, "system.flash", size, ++ bdrv, sector_size, size >> sector_bits, ++ 1, 0x0000, 0x0000, 0x0000, 0x0000, 0); ++ flash_mem = pflash_cfi01_get_memory(system_flash); ++ ++ pc_isa_bios_init(rom_memory, flash_mem, size); ++} ++ ++static void old_pc_system_rom_init(MemoryRegion *rom_memory, bool isapc_ram_fw) ++{ ++ char *filename; ++ MemoryRegion *bios, *isa_bios; ++ int bios_size, isa_bios_size; ++ int ret; ++ ++ /* BIOS load */ ++ if (bios_name == NULL) { ++ bios_name = BIOS_FILENAME; ++ } ++ filename = qemu_find_file(QEMU_FILE_TYPE_BIOS, bios_name); ++ if (filename) { ++ bios_size = get_image_size(filename); ++ } else { ++ bios_size = -1; ++ } ++ if (bios_size <= 0 || ++ (bios_size % 65536) != 0) { ++ goto bios_error; ++ } ++ bios = g_malloc(sizeof(*bios)); ++ memory_region_init_ram(bios, "pc.bios", bios_size); ++ vmstate_register_ram_global(bios); ++ if (!isapc_ram_fw) { ++ memory_region_set_readonly(bios, true); ++ } ++ ret = rom_add_file_fixed(bios_name, (uint32_t)(-bios_size), -1); ++ if (ret != 0) { ++ bios_error: ++ fprintf(stderr, "qemu: could not load PC BIOS '%s'\n", bios_name); ++ exit(1); ++ } ++ if (filename) { ++ g_free(filename); ++ } ++ ++ /* map the last 128KB of the BIOS in ISA space */ ++ isa_bios_size = bios_size; ++ if (isa_bios_size > (128 * 1024)) { ++ isa_bios_size = 128 * 1024; ++ } ++ isa_bios = g_malloc(sizeof(*isa_bios)); ++ memory_region_init_alias(isa_bios, "isa-bios", bios, ++ bios_size - isa_bios_size, isa_bios_size); ++ memory_region_add_subregion_overlap(rom_memory, ++ 0x100000 - isa_bios_size, ++ isa_bios, ++ 1); ++ if (!isapc_ram_fw) { ++ memory_region_set_readonly(isa_bios, true); ++ } ++ ++ /* map all the bios at the top of memory */ ++ memory_region_add_subregion(rom_memory, ++ (uint32_t)(-bios_size), ++ bios); ++} ++ ++void pc_system_firmware_init(MemoryRegion *rom_memory, bool isapc_ram_fw) ++{ ++ DriveInfo *pflash_drv; ++ ++ pflash_drv = drive_get(IF_PFLASH, 0, 0); ++ ++ if (isapc_ram_fw || pflash_drv == NULL) { ++ /* When a pflash drive is not found, use rom-mode */ ++ old_pc_system_rom_init(rom_memory, isapc_ram_fw); ++ return; ++ } ++ ++ if (kvm_enabled() && !kvm_readonly_mem_enabled()) { ++ /* Older KVM cannot execute from device memory. So, flash memory ++ * cannot be used unless the readonly memory kvm capability is present. */ ++ fprintf(stderr, "qemu: pflash with kvm requires KVM readonly memory support\n"); ++ exit(1); ++ } ++ ++ pc_system_flash_init(rom_memory, pflash_drv); ++} +diff --git a/include/hw/i386/pc.h b/include/hw/i386/pc.h +index 5c69abe..413358f 100644 +--- a/include/hw/i386/pc.h ++++ b/include/hw/i386/pc.h +@@ -34,6 +34,7 @@ typedef struct PcPciInfo { + + struct PcGuestInfo { + bool has_pci_info; ++ bool isapc_ram_fw; + hwaddr ram_size; + unsigned apic_id_limit; + bool apic_xrupt_override; +@@ -228,7 +229,8 @@ static inline bool isa_ne2000_init(ISABus *bus, int base, int irq, NICInfo *nd) + } + + /* pc_sysfw.c */ +-void pc_system_firmware_init(MemoryRegion *rom_memory); ++void pc_system_firmware_init(MemoryRegion *rom_memory, ++ bool isapc_ram_fw); + + /* pvpanic.c */ + void pvpanic_init(ISABus *bus); +-- +1.7.1 + diff --git a/SOURCES/kvm-pc_sysfw-remove-the-rom_only-property.patch b/SOURCES/kvm-pc_sysfw-remove-the-rom_only-property.patch new file mode 100644 index 0000000..601041f --- /dev/null +++ b/SOURCES/kvm-pc_sysfw-remove-the-rom_only-property.patch @@ -0,0 +1,167 @@ +From 5de16aa3c3b28a7a90426e38b06bda827b3c822f Mon Sep 17 00:00:00 2001 +From: Laszlo Ersek +Date: Sat, 11 Jan 2014 18:00:01 +0100 +Subject: [PATCH 11/22] pc_sysfw: remove the rom_only property + +RH-Author: Laszlo Ersek +Message-id: <1389463208-6278-12-git-send-email-lersek@redhat.com> +Patchwork-id: 56623 +O-Subject: [RHEL-7.0 qemu-kvm PATCH 11/18] pc_sysfw: remove the rom_only property +Bugzilla: 1032346 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Amos Kong +RH-Acked-by: Andrew Jones + +From: Paolo Bonzini + +With the new semantics of pc_sysfw (no -pflash implies "old-style" ROM setup, +-pflash implies "new-style" ROM setup), there is no need anymore for a compat +property. Old machines simply will never use -pflash, and thus will always +use old-style setup. + +Signed-off-by: Paolo Bonzini +Message-id: 1376069702-22330-3-git-send-email-aliguori@us.ibm.com +Signed-off-by: Anthony Liguori +(cherry picked from commit a904410af5f1ed6ff031e9e4119ca2f5d99647ce) +Signed-off-by: Laszlo Ersek +--- + hw/block/pc_sysfw.c | 64 ++++++----------------------------------------------- + hw/i386/pc_piix.c | 9 -------- + 2 files changed, 7 insertions(+), 66 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + hw/block/pc_sysfw.c | 64 +++++--------------------------------------------- + hw/i386/pc_piix.c | 9 ------- + 2 files changed, 7 insertions(+), 66 deletions(-) + +diff --git a/hw/block/pc_sysfw.c b/hw/block/pc_sysfw.c +index 38261b1..f9c0633 100644 +--- a/hw/block/pc_sysfw.c ++++ b/hw/block/pc_sysfw.c +@@ -38,7 +38,6 @@ + + typedef struct PcSysFwDevice { + SysBusDevice busdev; +- uint8_t rom_only; + uint8_t isapc_ram_fw; + } PcSysFwDevice; + +@@ -73,39 +72,6 @@ static void pc_isa_bios_init(MemoryRegion *rom_memory, + memory_region_set_readonly(isa_bios, true); + } + +-static void pc_fw_add_pflash_drv(void) +-{ +- QemuOpts *opts; +- QEMUMachine *machine; +- char *filename; +- +- if (bios_name == NULL) { +- bios_name = BIOS_FILENAME; +- } +- filename = qemu_find_file(QEMU_FILE_TYPE_BIOS, bios_name); +- if (!filename) { +- error_report("Can't open BIOS image %s", bios_name); +- exit(1); +- } +- +- opts = drive_add(IF_PFLASH, -1, filename, "readonly=on"); +- +- g_free(filename); +- +- if (opts == NULL) { +- return; +- } +- +- machine = find_default_machine(); +- if (machine == NULL) { +- return; +- } +- +- if (!drive_init(opts, machine->block_default_type)) { +- qemu_opts_del(opts); +- } +-} +- + static void pc_system_flash_init(MemoryRegion *rom_memory, + DriveInfo *pflash_drv) + { +@@ -213,40 +179,24 @@ void pc_system_firmware_init(MemoryRegion *rom_memory) + + pflash_drv = drive_get(IF_PFLASH, 0, 0); + +- if (pflash_drv == NULL) { ++ if (sysfw_dev->isapc_ram_fw || pflash_drv == NULL) { + /* When a pflash drive is not found, use rom-mode */ +- sysfw_dev->rom_only = 1; +- } else if (kvm_enabled() && !kvm_readonly_mem_enabled()) { +- /* Older KVM cannot execute from device memory. So, flash memory +- * cannot be used unless the readonly memory kvm capability is present. */ +- fprintf(stderr, "qemu: pflash with kvm requires KVM readonly memory support\n"); +- exit(1); +- } +- +- /* If rom-mode is active, use the old pc system rom initialization. */ +- if (sysfw_dev->rom_only) { + old_pc_system_rom_init(rom_memory, sysfw_dev->isapc_ram_fw); + return; + } + +- /* If a pflash drive is not found, then create one using +- the bios filename. */ +- if (pflash_drv == NULL) { +- pc_fw_add_pflash_drv(); +- pflash_drv = drive_get(IF_PFLASH, 0, 0); +- } +- +- if (pflash_drv != NULL) { +- pc_system_flash_init(rom_memory, pflash_drv); +- } else { +- fprintf(stderr, "qemu: PC system firmware (pflash) not available\n"); ++ if (kvm_enabled() && !kvm_readonly_mem_enabled()) { ++ /* Older KVM cannot execute from device memory. So, flash memory ++ * cannot be used unless the readonly memory kvm capability is present. */ ++ fprintf(stderr, "qemu: pflash with kvm requires KVM readonly memory support\n"); + exit(1); + } ++ ++ pc_system_flash_init(rom_memory, pflash_drv); + } + + static Property pcsysfw_properties[] = { + DEFINE_PROP_UINT8("isapc_ram_fw", PcSysFwDevice, isapc_ram_fw, 0), +- DEFINE_PROP_UINT8("rom_only", PcSysFwDevice, rom_only, 0), + DEFINE_PROP_END_OF_LIST(), + }; + +diff --git a/hw/i386/pc_piix.c b/hw/i386/pc_piix.c +index 0a8a4e5..6f273db 100644 +--- a/hw/i386/pc_piix.c ++++ b/hw/i386/pc_piix.c +@@ -471,10 +471,6 @@ static QEMUMachine pc_machine_v1_1 = { + #define PC_COMPAT_1_0 \ + PC_COMPAT_1_1,\ + {\ +- .driver = "pc-sysfw",\ +- .property = "rom_only",\ +- .value = stringify(1),\ +- }, {\ + .driver = TYPE_ISA_FDC,\ + .property = "check_media_rate",\ + .value = "off",\ +@@ -711,11 +707,6 @@ static QEMUMachine isapc_machine = { + .compat_props = (GlobalProperty[]) { + { + .driver = "pc-sysfw", +- .property = "rom_only", +- .value = stringify(1), +- }, +- { +- .driver = "pc-sysfw", + .property = "isapc_ram_fw", + .value = stringify(1), + }, +-- +1.7.1 + diff --git a/SOURCES/kvm-pci-add-helper-to-retrieve-the-64-bit-range.patch b/SOURCES/kvm-pci-add-helper-to-retrieve-the-64-bit-range.patch new file mode 100644 index 0000000..429d4af --- /dev/null +++ b/SOURCES/kvm-pci-add-helper-to-retrieve-the-64-bit-range.patch @@ -0,0 +1,109 @@ +From 1e726d2e4db2132cb5f0ee985745c87174e6f599 Mon Sep 17 00:00:00 2001 +Message-Id: <1e726d2e4db2132cb5f0ee985745c87174e6f599.1387298827.git.minovotn@redhat.com> +In-Reply-To: <3ed0fb61a3dc912ef036d7ef450bed192090709e.1387298827.git.minovotn@redhat.com> +References: <3ed0fb61a3dc912ef036d7ef450bed192090709e.1387298827.git.minovotn@redhat.com> +From: "Michael S. Tsirkin" +Date: Tue, 17 Dec 2013 15:17:05 +0100 +Subject: [PATCH 07/56] pci: add helper to retrieve the 64-bit range + +RH-Author: Michael S. Tsirkin +Message-id: <1387293161-4085-8-git-send-email-mst@redhat.com> +Patchwork-id: 56312 +O-Subject: [PATCH qemu-kvm RHEL7.0 v2 07/57] pci: add helper to retrieve the 64-bit range +Bugzilla: 1034876 +RH-Acked-by: Igor Mammedov +RH-Acked-by: Marcel Apfelbaum +RH-Acked-by: Laszlo Ersek + +Signed-off-by: Michael S. Tsirkin +(cherry picked from commit 438640695723f33be6d0081ac1e690aa40975c39) + +Conflicts: + include/hw/pci/pci.h +--- + include/hw/pci/pci.h | 1 + + hw/pci/pci.c | 50 ++++++++++++++++++++++++++++++++++++++++++++++++++ + 2 files changed, 51 insertions(+) + +Signed-off-by: Michal Novotny +--- + hw/pci/pci.c | 50 ++++++++++++++++++++++++++++++++++++++++++++++++++ + include/hw/pci/pci.h | 1 + + 2 files changed, 51 insertions(+) + +diff --git a/hw/pci/pci.c b/hw/pci/pci.c +index 26995d7..d550851 100644 +--- a/hw/pci/pci.c ++++ b/hw/pci/pci.c +@@ -2244,6 +2244,56 @@ void pci_setup_iommu(PCIBus *bus, PCIDMAContextFunc fn, void *opaque) + bus->dma_context_opaque = opaque; + } + ++static void pci_dev_get_w64(PCIBus *b, PCIDevice *dev, void *opaque) ++{ ++ Range *range = opaque; ++ PCIDeviceClass *pc = PCI_DEVICE_GET_CLASS(dev); ++ uint16_t cmd = pci_get_word(dev->config + PCI_COMMAND); ++ int r; ++ ++ if (!(cmd & PCI_COMMAND_MEMORY)) { ++ return; ++ } ++ ++ if (pc->is_bridge) { ++ pcibus_t base = pci_bridge_get_base(dev, PCI_BASE_ADDRESS_MEM_PREFETCH); ++ pcibus_t limit = pci_bridge_get_limit(dev, PCI_BASE_ADDRESS_MEM_PREFETCH); ++ ++ base = MAX(base, 0x1ULL << 32); ++ ++ if (limit >= base) { ++ Range pref_range; ++ pref_range.begin = base; ++ pref_range.end = limit + 1; ++ range_extend(range, &pref_range); ++ } ++ } ++ for (r = 0; r < PCI_NUM_REGIONS; ++r) { ++ PCIIORegion *region = &dev->io_regions[r]; ++ Range region_range; ++ ++ if (!region->size || ++ (region->type & PCI_BASE_ADDRESS_SPACE_IO) || ++ !(region->type & PCI_BASE_ADDRESS_MEM_TYPE_64)) { ++ continue; ++ } ++ region_range.begin = pci_get_quad(dev->config + pci_bar(dev, r)); ++ region_range.end = region_range.begin + region->size; ++ ++ region_range.begin = MAX(region_range.begin, 0x1ULL << 32); ++ ++ if (region_range.end - 1 >= region_range.begin) { ++ range_extend(range, ®ion_range); ++ } ++ } ++} ++ ++void pci_bus_get_w64_range(PCIBus *bus, Range *range) ++{ ++ range->begin = range->end = 0; ++ pci_for_each_device_under_bus(bus, pci_dev_get_w64, range); ++} ++ + static const TypeInfo pci_device_type_info = { + .name = TYPE_PCI_DEVICE, + .parent = TYPE_DEVICE, +diff --git a/include/hw/pci/pci.h b/include/hw/pci/pci.h +index 8d075ab..e7760dd 100644 +--- a/include/hw/pci/pci.h ++++ b/include/hw/pci/pci.h +@@ -395,6 +395,7 @@ int pci_find_domain(const PCIBus *bus); + PCIDevice *pci_find_device(PCIBus *bus, int bus_num, uint8_t devfn); + int pci_qdev_find_device(const char *id, PCIDevice **pdev); + PCIBus *pci_get_bus_devfn(int *devfnp, const char *devaddr); ++void pci_bus_get_w64_range(PCIBus *bus, Range *range); + + int pci_read_devaddr(Monitor *mon, const char *addr, int *domp, int *busp, + unsigned *slotp); +-- +1.7.11.7 + diff --git a/SOURCES/kvm-pci-assign-cap-number-of-devices-that-can-be-assigne.patch b/SOURCES/kvm-pci-assign-cap-number-of-devices-that-can-be-assigne.patch new file mode 100644 index 0000000..59b75c4 --- /dev/null +++ b/SOURCES/kvm-pci-assign-cap-number-of-devices-that-can-be-assigne.patch @@ -0,0 +1,95 @@ +From 53d1ae3ef3ed6959596813e75678fcb4f2aa30c0 Mon Sep 17 00:00:00 2001 +Message-Id: <53d1ae3ef3ed6959596813e75678fcb4f2aa30c0.1387382496.git.minovotn@redhat.com> +In-Reply-To: +References: +From: Bandan Das +Date: Tue, 3 Dec 2013 20:05:12 +0100 +Subject: [PATCH 43/46] pci-assign: cap number of devices that can be assigned + +RH-Author: Bandan Das +Message-id: <1386101113-31560-2-git-send-email-bsd@redhat.com> +Patchwork-id: 55983 +O-Subject: [PATCH RHEL7 qemu-kvm v2 1/2] pci-assign: cap number of devices that can be assigned +Bugzilla: 678368 +RH-Acked-by: Alex Williamson +RH-Acked-by: Marcelo Tosatti +RH-Acked-by: Michael S. Tsirkin + +Legacy device assignment is not supported for RHEL7, nevertheless, +it makes sense to enforce the limit here was well in case we need +to support it in the future. Note that 8 is the limit enforced on +RHEL 6, RHEL 5 too has a static limit of 8 assigned devices. + +Signed-off-by: Bandan Das +--- + hw/i386/kvm/pci-assign.c | 19 ++++++++++++++++++- + 1 file changed, 18 insertions(+), 1 deletion(-) + +Signed-off-by: Michal Novotny +--- + hw/i386/kvm/pci-assign.c | 19 ++++++++++++++++++- + 1 file changed, 18 insertions(+), 1 deletion(-) + +diff --git a/hw/i386/kvm/pci-assign.c b/hw/i386/kvm/pci-assign.c +index 7060605..4a05c0f 100644 +--- a/hw/i386/kvm/pci-assign.c ++++ b/hw/i386/kvm/pci-assign.c +@@ -139,8 +139,12 @@ typedef struct AssignedDevice { + MemoryRegion mmio; + char *configfd_name; + int32_t bootindex; ++ QLIST_ENTRY(AssignedDevice) next; + } AssignedDevice; + ++#define MAX_DEV_ASSIGN_CMDLINE 8 ++static QLIST_HEAD(, AssignedDevice) devs = QLIST_HEAD_INITIALIZER(devs); ++ + static void assigned_dev_update_irq_routing(PCIDevice *dev); + + static void assigned_dev_load_option_rom(AssignedDevice *dev); +@@ -1733,14 +1737,25 @@ static void reset_assigned_device(DeviceState *dev) + static int assigned_initfn(struct PCIDevice *pci_dev) + { + AssignedDevice *dev = DO_UPCAST(AssignedDevice, dev, pci_dev); ++ AssignedDevice *adev; + uint8_t e_intx; +- int r; ++ int r, i = 0; + + if (!kvm_enabled()) { + error_report("pci-assign: error: requires KVM support"); + return -1; + } + ++ QLIST_FOREACH(adev, &devs, next) { ++ i++; ++ } ++ ++ if (i >= MAX_DEV_ASSIGN_CMDLINE) { ++ error_report("pci-assign: Maximum supported assigned devices (%d) " ++ "already attached\n", MAX_DEV_ASSIGN_CMDLINE); ++ return -1; ++ } ++ + if (!dev->host.domain && !dev->host.bus && !dev->host.slot && + !dev->host.function) { + error_report("pci-assign: error: no host device specified"); +@@ -1810,6 +1825,7 @@ static int assigned_initfn(struct PCIDevice *pci_dev) + goto assigned_out; + } + ++ QLIST_INSERT_HEAD(&devs, dev, next); + assigned_dev_load_option_rom(dev); + + add_boot_device_path(dev->bootindex, &pci_dev->qdev, NULL); +@@ -1827,6 +1843,7 @@ static void assigned_exitfn(struct PCIDevice *pci_dev) + { + AssignedDevice *dev = DO_UPCAST(AssignedDevice, dev, pci_dev); + ++ QLIST_REMOVE(dev, next); + deassign_device(dev); + free_assigned_device(dev); + } +-- +1.7.11.7 + diff --git a/SOURCES/kvm-pci-fix-pci-bridge-fw-path.patch b/SOURCES/kvm-pci-fix-pci-bridge-fw-path.patch new file mode 100644 index 0000000..a57ab64 --- /dev/null +++ b/SOURCES/kvm-pci-fix-pci-bridge-fw-path.patch @@ -0,0 +1,52 @@ +From 9bcd11daf18c189b908a752e0a617a564b6b0ca7 Mon Sep 17 00:00:00 2001 +From: Gerd Hoffmann +Date: Thu, 16 Jan 2014 14:28:15 -0500 +Subject: [PATCH 11/14] pci: fix pci bridge fw path + +Message-id: <1389882495-30964-2-git-send-email-kraxel@redhat.com> +Patchwork-id: 56747 +O-Subject: [RHEL-7 qemu-kvm PATCH 1/1] pci: fix pci bridge fw path +Bugzilla: 1034518 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Laszlo Ersek +RH-Acked-by: Bandan Das + +qemu uses "pci" as name for pci bridges in the firmware device path. +seabios expects "pci-bridge". Result is that bootorder is broken for +devices behind pci bridges. + +Some googling suggests that "pci-bridge" is the correct one. At least +PPC-based Apple machines are using this. See question "How do I boot +from a device attached to a PCI card" here: + http://www.netbsd.org/ports/macppc/faq.html + +So lets change qemu to use "pci-bridge" too. + +Signed-off-by: Gerd Hoffmann +Signed-off-by: Michael S. Tsirkin +(cherry picked from commit 4c41425d2e79f267b2236da31abedb866777d92f) +--- + hw/pci/pci.c | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +Signed-off-by: Miroslav Rezanina +--- + hw/pci/pci.c | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/hw/pci/pci.c b/hw/pci/pci.c +index 598d288..d166ab0 100644 +--- a/hw/pci/pci.c ++++ b/hw/pci/pci.c +@@ -1308,7 +1308,7 @@ static const pci_class_desc pci_class_descriptions[] = + { 0x0601, "ISA bridge", "isa"}, + { 0x0602, "EISA bridge", "eisa"}, + { 0x0603, "MC bridge", "mca"}, +- { 0x0604, "PCI bridge", "pci"}, ++ { 0x0604, "PCI bridge", "pci-bridge"}, + { 0x0605, "PCMCIA bridge", "pcmcia"}, + { 0x0606, "NUBUS bridge", "nubus"}, + { 0x0607, "CARDBUS bridge", "cardbus"}, +-- +1.8.3.1 + diff --git a/SOURCES/kvm-pci-fix-up-w64-size-calculation-helper.patch b/SOURCES/kvm-pci-fix-up-w64-size-calculation-helper.patch new file mode 100644 index 0000000..02b5861 --- /dev/null +++ b/SOURCES/kvm-pci-fix-up-w64-size-calculation-helper.patch @@ -0,0 +1,78 @@ +From 2059082c26d40f083807ae81476fedd0c22c613f Mon Sep 17 00:00:00 2001 +Message-Id: <2059082c26d40f083807ae81476fedd0c22c613f.1387298827.git.minovotn@redhat.com> +In-Reply-To: <3ed0fb61a3dc912ef036d7ef450bed192090709e.1387298827.git.minovotn@redhat.com> +References: <3ed0fb61a3dc912ef036d7ef450bed192090709e.1387298827.git.minovotn@redhat.com> +From: "Michael S. Tsirkin" +Date: Tue, 17 Dec 2013 15:17:08 +0100 +Subject: [PATCH 08/56] pci: fix up w64 size calculation helper + +RH-Author: Michael S. Tsirkin +Message-id: <1387293161-4085-9-git-send-email-mst@redhat.com> +Patchwork-id: 56313 +O-Subject: [PATCH qemu-kvm RHEL7.0 v2 08/57] pci: fix up w64 size calculation helper +Bugzilla: 1034876 +RH-Acked-by: Igor Mammedov +RH-Acked-by: Marcel Apfelbaum +RH-Acked-by: Laszlo Ersek + +BAR base was calculated incorrectly. +Use existing pci_bar_address to get it right. + +Tested-by: Igor Mammedov +Reviewed-by: Igor Mammedov +Signed-off-by: Michael S. Tsirkin +(cherry picked from commit 77d6f4ea7608fe7f47c9d7beddd19191b2e852b2) +--- + hw/pci/pci.c | 20 ++++++++++++-------- + 1 file changed, 12 insertions(+), 8 deletions(-) + +Signed-off-by: Michal Novotny +--- + hw/pci/pci.c | 20 ++++++++++++-------- + 1 file changed, 12 insertions(+), 8 deletions(-) + +diff --git a/hw/pci/pci.c b/hw/pci/pci.c +index d550851..598d288 100644 +--- a/hw/pci/pci.c ++++ b/hw/pci/pci.c +@@ -2249,7 +2249,7 @@ static void pci_dev_get_w64(PCIBus *b, PCIDevice *dev, void *opaque) + Range *range = opaque; + PCIDeviceClass *pc = PCI_DEVICE_GET_CLASS(dev); + uint16_t cmd = pci_get_word(dev->config + PCI_COMMAND); +- int r; ++ int i; + + if (!(cmd & PCI_COMMAND_MEMORY)) { + return; +@@ -2268,17 +2268,21 @@ static void pci_dev_get_w64(PCIBus *b, PCIDevice *dev, void *opaque) + range_extend(range, &pref_range); + } + } +- for (r = 0; r < PCI_NUM_REGIONS; ++r) { +- PCIIORegion *region = &dev->io_regions[r]; ++ for (i = 0; i < PCI_NUM_REGIONS; ++i) { ++ PCIIORegion *r = &dev->io_regions[i]; + Range region_range; + +- if (!region->size || +- (region->type & PCI_BASE_ADDRESS_SPACE_IO) || +- !(region->type & PCI_BASE_ADDRESS_MEM_TYPE_64)) { ++ if (!r->size || ++ (r->type & PCI_BASE_ADDRESS_SPACE_IO) || ++ !(r->type & PCI_BASE_ADDRESS_MEM_TYPE_64)) { ++ continue; ++ } ++ region_range.begin = pci_bar_address(dev, i, r->type, r->size); ++ region_range.end = region_range.begin + r->size; ++ ++ if (region_range.begin == PCI_BAR_UNMAPPED) { + continue; + } +- region_range.begin = pci_get_quad(dev->config + pci_bar(dev, r)); +- region_range.end = region_range.begin + region->size; + + region_range.begin = MAX(region_range.begin, 0x1ULL << 32); + +-- +1.7.11.7 + diff --git a/SOURCES/kvm-pci-store-PCI-hole-ranges-in-guestinfo-structure.patch b/SOURCES/kvm-pci-store-PCI-hole-ranges-in-guestinfo-structure.patch new file mode 100644 index 0000000..4aa716d --- /dev/null +++ b/SOURCES/kvm-pci-store-PCI-hole-ranges-in-guestinfo-structure.patch @@ -0,0 +1,292 @@ +From 43d319c65b1a27349fd329cb2f9c6f5c54f32379 Mon Sep 17 00:00:00 2001 +Message-Id: <43d319c65b1a27349fd329cb2f9c6f5c54f32379.1387298827.git.minovotn@redhat.com> +In-Reply-To: <3ed0fb61a3dc912ef036d7ef450bed192090709e.1387298827.git.minovotn@redhat.com> +References: <3ed0fb61a3dc912ef036d7ef450bed192090709e.1387298827.git.minovotn@redhat.com> +From: "Michael S. Tsirkin" +Date: Tue, 17 Dec 2013 15:17:22 +0100 +Subject: [PATCH 13/56] pci: store PCI hole ranges in guestinfo structure + +RH-Author: Michael S. Tsirkin +Message-id: <1387293161-4085-14-git-send-email-mst@redhat.com> +Patchwork-id: 56318 +O-Subject: [PATCH qemu-kvm RHEL7.0 v2 13/57] pci: store PCI hole ranges in guestinfo structure +Bugzilla: 1034876 +RH-Acked-by: Igor Mammedov +RH-Acked-by: Marcel Apfelbaum +RH-Acked-by: Laszlo Ersek + +Will be used to pass hole ranges to guests. + +Signed-off-by: Michael S. Tsirkin +(cherry picked from commit 3459a625215449b67b9c67d9151ff72892d0a42a) + +Conflicts: + hw/i386/pc_piix.c + hw/i386/pc_q35.c +--- + include/hw/i386/pc.h | 19 ++++++++++++++++++- + include/hw/pci-host/q35.h | 2 ++ + include/qemu/typedefs.h | 1 + + hw/i386/pc.c | 46 +++++++++++++++++++++++++++++++++++++++++++++- + hw/i386/pc_piix.c | 14 +++++++++++++- + hw/i386/pc_q35.c | 6 +++++- + hw/pci-host/q35.c | 8 ++++++++ + 7 files changed, 92 insertions(+), 4 deletions(-) + +Signed-off-by: Michal Novotny +--- + hw/i386/pc.c | 46 +++++++++++++++++++++++++++++++++++++++++++++- + hw/i386/pc_piix.c | 14 +++++++++++++- + hw/i386/pc_q35.c | 6 +++++- + hw/pci-host/q35.c | 8 ++++++++ + include/hw/i386/pc.h | 19 ++++++++++++++++++- + include/hw/pci-host/q35.h | 2 ++ + include/qemu/typedefs.h | 1 + + 7 files changed, 92 insertions(+), 4 deletions(-) + +diff --git a/hw/i386/pc.c b/hw/i386/pc.c +index 2948781..68a8e1b 100644 +--- a/hw/i386/pc.c ++++ b/hw/i386/pc.c +@@ -985,6 +985,48 @@ void pc_cpus_init(const char *cpu_model, DeviceState *icc_bridge) + } + } + ++typedef struct PcGuestInfoState { ++ PcGuestInfo info; ++ Notifier machine_done; ++} PcGuestInfoState; ++ ++static ++void pc_guest_info_machine_done(Notifier *notifier, void *data) ++{ ++ PcGuestInfoState *guest_info_state = container_of(notifier, ++ PcGuestInfoState, ++ machine_done); ++} ++ ++PcGuestInfo *pc_guest_info_init(ram_addr_t below_4g_mem_size, ++ ram_addr_t above_4g_mem_size) ++{ ++ PcGuestInfoState *guest_info_state = g_malloc0(sizeof *guest_info_state); ++ PcGuestInfo *guest_info = &guest_info_state->info; ++ ++ guest_info->pci_info.w32.end = IO_APIC_DEFAULT_ADDRESS; ++ if (sizeof(hwaddr) == 4) { ++ guest_info->pci_info.w64.begin = 0; ++ guest_info->pci_info.w64.end = 0; ++ } else { ++ /* ++ * BIOS does not set MTRR entries for the 64 bit window, so no need to ++ * align address to power of two. Align address at 1G, this makes sure ++ * it can be exactly covered with a PAT entry even when using huge ++ * pages. ++ */ ++ guest_info->pci_info.w64.begin = ++ ROUND_UP((0x1ULL << 32) + above_4g_mem_size, 0x1ULL << 30); ++ guest_info->pci_info.w64.end = guest_info->pci_info.w64.begin + ++ (0x1ULL << 62); ++ assert(guest_info->pci_info.w64.begin <= guest_info->pci_info.w64.end); ++ } ++ ++ guest_info_state->machine_done.notify = pc_guest_info_machine_done; ++ qemu_add_machine_init_done_notifier(&guest_info_state->machine_done); ++ return guest_info; ++} ++ + void pc_acpi_init(const char *default_dsdt) + { + char *filename; +@@ -1026,7 +1068,8 @@ FWCfgState *pc_memory_init(MemoryRegion *system_memory, + ram_addr_t below_4g_mem_size, + ram_addr_t above_4g_mem_size, + MemoryRegion *rom_memory, +- MemoryRegion **ram_memory) ++ MemoryRegion **ram_memory, ++ PcGuestInfo *guest_info) + { + int linux_boot, i; + MemoryRegion *ram, *option_rom_mr; +@@ -1078,6 +1121,7 @@ FWCfgState *pc_memory_init(MemoryRegion *system_memory, + for (i = 0; i < nb_option_roms; i++) { + rom_add_option(option_rom[i].name, option_rom[i].bootindex); + } ++ guest_info->fw_cfg = fw_cfg; + return fw_cfg; + } + +diff --git a/hw/i386/pc_piix.c b/hw/i386/pc_piix.c +index 07848c1..3a77998 100644 +--- a/hw/i386/pc_piix.c ++++ b/hw/i386/pc_piix.c +@@ -87,6 +87,7 @@ static void pc_init1(QEMUMachineInitArgs *args, + MemoryRegion *rom_memory; + DeviceState *icc_bridge; + FWCfgState *fw_cfg = NULL; ++ PcGuestInfo *guest_info; + + icc_bridge = qdev_create(NULL, TYPE_ICC_BRIDGE); + object_property_add_child(qdev_get_machine(), "icc-bridge", +@@ -120,13 +121,24 @@ static void pc_init1(QEMUMachineInitArgs *args, + smbios_set_type1_defaults("Red Hat", "KVM", args->machine->desc); + } + ++ guest_info = pc_guest_info_init(below_4g_mem_size, above_4g_mem_size); ++ ++ /* Set PCI window size the way seabios has always done it. */ ++ /* Power of 2 so bios can cover it with a single MTRR */ ++ if (ram_size <= 0x80000000) ++ guest_info->pci_info.w32.begin = 0x80000000; ++ else if (ram_size <= 0xc0000000) ++ guest_info->pci_info.w32.begin = 0xc0000000; ++ else ++ guest_info->pci_info.w32.begin = 0xe0000000; ++ + /* allocate ram and load rom/bios */ + if (!xen_enabled()) { + fw_cfg = pc_memory_init(system_memory, + args->kernel_filename, args->kernel_cmdline, + args->initrd_filename, + below_4g_mem_size, above_4g_mem_size, +- rom_memory, &ram_memory); ++ rom_memory, &ram_memory, guest_info); + } + + gsi_state = g_malloc0(sizeof(*gsi_state)); +diff --git a/hw/i386/pc_q35.c b/hw/i386/pc_q35.c +index 8fa6793..9fab93c 100644 +--- a/hw/i386/pc_q35.c ++++ b/hw/i386/pc_q35.c +@@ -73,6 +73,7 @@ static void pc_q35_init(QEMUMachineInitArgs *args) + ICH9LPCState *ich9_lpc; + PCIDevice *ahci; + DeviceState *icc_bridge; ++ PcGuestInfo *guest_info; + + icc_bridge = qdev_create(NULL, TYPE_ICC_BRIDGE); + object_property_add_child(qdev_get_machine(), "icc-bridge", +@@ -106,13 +107,15 @@ static void pc_q35_init(QEMUMachineInitArgs *args) + smbios_set_type1_defaults("Red Hat", "KVM", args->machine->desc); + } + ++ guest_info = pc_guest_info_init(below_4g_mem_size, above_4g_mem_size); ++ + /* allocate ram and load rom/bios */ + if (!xen_enabled()) { + pc_memory_init(get_system_memory(), + args->kernel_filename, args->kernel_cmdline, + args->initrd_filename, + below_4g_mem_size, above_4g_mem_size, +- rom_memory, &ram_memory); ++ rom_memory, &ram_memory, guest_info); + } + + /* irq lines */ +@@ -134,6 +137,7 @@ static void pc_q35_init(QEMUMachineInitArgs *args) + q35_host->mch.address_space_io = get_system_io(); + q35_host->mch.below_4g_mem_size = below_4g_mem_size; + q35_host->mch.above_4g_mem_size = above_4g_mem_size; ++ q35_host->mch.guest_info = guest_info; + /* pci */ + qdev_init_nofail(DEVICE(q35_host)); + host_bus = q35_host->host.pci.bus; +diff --git a/hw/pci-host/q35.c b/hw/pci-host/q35.c +index ed934c3..0989fc5 100644 +--- a/hw/pci-host/q35.c ++++ b/hw/pci-host/q35.c +@@ -245,6 +245,14 @@ static int mch_init(PCIDevice *d) + hwaddr pci_hole64_size; + MCHPCIState *mch = MCH_PCI_DEVICE(d); + ++ /* Leave enough space for the biggest MCFG BAR */ ++ /* TODO: this matches current bios behaviour, but ++ * it's not a power of two, which means an MTRR ++ * can't cover it exactly. ++ */ ++ mch->guest_info->pci_info.w32.begin = MCH_HOST_BRIDGE_PCIEXBAR_DEFAULT + ++ MCH_HOST_BRIDGE_PCIEXBAR_MAX; ++ + /* setup pci memory regions */ + memory_region_init_alias(&mch->pci_hole, "pci-hole", + mch->pci_address_space, +diff --git a/include/hw/i386/pc.h b/include/hw/i386/pc.h +index 2cf7baa..2518db6 100644 +--- a/include/hw/i386/pc.h ++++ b/include/hw/i386/pc.h +@@ -10,8 +10,20 @@ + #include "exec/memory.h" + #include "hw/i386/ioapic.h" + ++#include "qemu/range.h" ++ + /* PC-style peripherals (also used by other machines). */ + ++typedef struct PcPciInfo { ++ Range w32; ++ Range w64; ++} PcPciInfo; ++ ++struct PcGuestInfo { ++ PcPciInfo pci_info; ++ FWCfgState *fw_cfg; ++}; ++ + /* parallel.c */ + static inline bool parallel_init(ISABus *bus, int index, CharDriverState *chr) + { +@@ -84,6 +96,10 @@ void pc_acpi_smi_interrupt(void *opaque, int irq, int level); + void pc_cpus_init(const char *cpu_model, DeviceState *icc_bridge); + void pc_hot_add_cpu(const int64_t id, Error **errp); + void pc_acpi_init(const char *default_dsdt); ++ ++PcGuestInfo *pc_guest_info_init(ram_addr_t below_4g_mem_size, ++ ram_addr_t above_4g_mem_size); ++ + FWCfgState *pc_memory_init(MemoryRegion *system_memory, + const char *kernel_filename, + const char *kernel_cmdline, +@@ -91,7 +107,8 @@ FWCfgState *pc_memory_init(MemoryRegion *system_memory, + ram_addr_t below_4g_mem_size, + ram_addr_t above_4g_mem_size, + MemoryRegion *rom_memory, +- MemoryRegion **ram_memory); ++ MemoryRegion **ram_memory, ++ PcGuestInfo *guest_info); + qemu_irq *pc_allocate_cpu_irq(void); + DeviceState *pc_vga_init(ISABus *isa_bus, PCIBus *pci_bus); + void pc_basic_device_init(ISABus *isa_bus, qemu_irq *gsi, +diff --git a/include/hw/pci-host/q35.h b/include/hw/pci-host/q35.h +index e182c82..b083831 100644 +--- a/include/hw/pci-host/q35.h ++++ b/include/hw/pci-host/q35.h +@@ -55,6 +55,7 @@ typedef struct MCHPCIState { + uint8_t smm_enabled; + ram_addr_t below_4g_mem_size; + ram_addr_t above_4g_mem_size; ++ PcGuestInfo *guest_info; + } MCHPCIState; + + typedef struct Q35PCIHost { +@@ -81,6 +82,7 @@ typedef struct Q35PCIHost { + #define MCH_HOST_BRIDGE_PCIEXBAR 0x60 /* 64bit register */ + #define MCH_HOST_BRIDGE_PCIEXBAR_SIZE 8 /* 64bit register */ + #define MCH_HOST_BRIDGE_PCIEXBAR_DEFAULT 0xb0000000 ++#define MCH_HOST_BRIDGE_PCIEXBAR_MAX (0x10000000) /* 256M */ + #define MCH_HOST_BRIDGE_PCIEXBAR_ADMSK Q35_MASK(64, 35, 28) + #define MCH_HOST_BRIDGE_PCIEXBAR_128ADMSK ((uint64_t)(1 << 26)) + #define MCH_HOST_BRIDGE_PCIEXBAR_64ADMSK ((uint64_t)(1 << 25)) +diff --git a/include/qemu/typedefs.h b/include/qemu/typedefs.h +index a332d88..70d250f 100644 +--- a/include/qemu/typedefs.h ++++ b/include/qemu/typedefs.h +@@ -64,6 +64,7 @@ typedef struct VirtIODevice VirtIODevice; + typedef struct QEMUSGList QEMUSGList; + typedef struct SHPCDevice SHPCDevice; + typedef struct FWCfgState FWCfgState; ++typedef struct PcGuestInfo PcGuestInfo; + typedef struct Range Range; + + #endif /* QEMU_TYPEDEFS_H */ +-- +1.7.11.7 + diff --git a/SOURCES/kvm-pcie_host-expose-UNMAPPED-macro.patch b/SOURCES/kvm-pcie_host-expose-UNMAPPED-macro.patch new file mode 100644 index 0000000..fbf2dcf --- /dev/null +++ b/SOURCES/kvm-pcie_host-expose-UNMAPPED-macro.patch @@ -0,0 +1,67 @@ +From e1b5da9a17a3c41e469122b76a760be28263a18e Mon Sep 17 00:00:00 2001 +Message-Id: +In-Reply-To: <3ed0fb61a3dc912ef036d7ef450bed192090709e.1387298827.git.minovotn@redhat.com> +References: <3ed0fb61a3dc912ef036d7ef450bed192090709e.1387298827.git.minovotn@redhat.com> +From: "Michael S. Tsirkin" +Date: Tue, 17 Dec 2013 15:18:02 +0100 +Subject: [PATCH 28/56] pcie_host: expose UNMAPPED macro + +RH-Author: Michael S. Tsirkin +Message-id: <1387293161-4085-29-git-send-email-mst@redhat.com> +Patchwork-id: 56334 +O-Subject: [PATCH qemu-kvm RHEL7.0 v2 28/57] pcie_host: expose UNMAPPED macro +Bugzilla: 1034876 +RH-Acked-by: Igor Mammedov +RH-Acked-by: Marcel Apfelbaum +RH-Acked-by: Laszlo Ersek + +Make it possible to test unmapped status through QMP. + +Reviewed-by: Gerd Hoffmann +Tested-by: Gerd Hoffmann +Reviewed-by: Igor Mammedov +Tested-by: Igor Mammedov +Signed-off-by: Michael S. Tsirkin +(cherry picked from commit 079e3e7012a0e3ff80b4786e67f5a5d4341dcd51) +--- + include/hw/pci/pcie_host.h | 3 +++ + hw/pci/pcie_host.c | 3 --- + 2 files changed, 3 insertions(+), 3 deletions(-) + +Signed-off-by: Michal Novotny +--- + hw/pci/pcie_host.c | 3 --- + include/hw/pci/pcie_host.h | 3 +++ + 2 files changed, 3 insertions(+), 3 deletions(-) + +diff --git a/hw/pci/pcie_host.c b/hw/pci/pcie_host.c +index b2d942b..0a78a8f 100644 +--- a/hw/pci/pcie_host.c ++++ b/hw/pci/pcie_host.c +@@ -104,9 +104,6 @@ static const MemoryRegionOps pcie_mmcfg_ops = { + .endianness = DEVICE_NATIVE_ENDIAN, + }; + +-/* pcie_host::base_addr == PCIE_BASE_ADDR_UNMAPPED when it isn't mapped. */ +-#define PCIE_BASE_ADDR_UNMAPPED ((hwaddr)-1ULL) +- + int pcie_host_init(PCIExpressHost *e) + { + e->base_addr = PCIE_BASE_ADDR_UNMAPPED; +diff --git a/include/hw/pci/pcie_host.h b/include/hw/pci/pcie_host.h +index 1228e36..bac3c67 100644 +--- a/include/hw/pci/pcie_host.h ++++ b/include/hw/pci/pcie_host.h +@@ -28,6 +28,9 @@ + #define PCIE_HOST_BRIDGE(obj) \ + OBJECT_CHECK(PCIExpressHost, (obj), TYPE_PCIE_HOST_BRIDGE) + ++/* pcie_host::base_addr == PCIE_BASE_ADDR_UNMAPPED when it isn't mapped. */ ++#define PCIE_BASE_ADDR_UNMAPPED ((hwaddr)-1ULL) ++ + struct PCIExpressHost { + PCIHostState pci; + +-- +1.7.11.7 + diff --git a/SOURCES/kvm-pcie_host-expose-address-format.patch b/SOURCES/kvm-pcie_host-expose-address-format.patch new file mode 100644 index 0000000..9300795 --- /dev/null +++ b/SOURCES/kvm-pcie_host-expose-address-format.patch @@ -0,0 +1,102 @@ +From 35510628e459d51b1ef6048bb307462a75ecf2d2 Mon Sep 17 00:00:00 2001 +Message-Id: <35510628e459d51b1ef6048bb307462a75ecf2d2.1387298827.git.minovotn@redhat.com> +In-Reply-To: <3ed0fb61a3dc912ef036d7ef450bed192090709e.1387298827.git.minovotn@redhat.com> +References: <3ed0fb61a3dc912ef036d7ef450bed192090709e.1387298827.git.minovotn@redhat.com> +From: "Michael S. Tsirkin" +Date: Tue, 17 Dec 2013 15:18:04 +0100 +Subject: [PATCH 29/56] pcie_host: expose address format + +RH-Author: Michael S. Tsirkin +Message-id: <1387293161-4085-30-git-send-email-mst@redhat.com> +Patchwork-id: 56335 +O-Subject: [PATCH qemu-kvm RHEL7.0 v2 29/57] pcie_host: expose address format +Bugzilla: 1034876 +RH-Acked-by: Igor Mammedov +RH-Acked-by: Marcel Apfelbaum +RH-Acked-by: Laszlo Ersek + +Callers pass in the address so it's helpful for +them to be able to decode it. + +Reviewed-by: Gerd Hoffmann +Tested-by: Gerd Hoffmann +Reviewed-by: Igor Mammedov +Tested-by: Igor Mammedov +Signed-off-by: Michael S. Tsirkin +(cherry picked from commit 6f6d282330a3c85ecbeb54dec5b57282bd177b44) +--- + include/hw/pci/pcie_host.h | 21 +++++++++++++++++++++ + hw/pci/pcie_host.c | 21 --------------------- + 2 files changed, 21 insertions(+), 21 deletions(-) + +Signed-off-by: Michal Novotny +--- + hw/pci/pcie_host.c | 21 --------------------- + include/hw/pci/pcie_host.h | 21 +++++++++++++++++++++ + 2 files changed, 21 insertions(+), 21 deletions(-) + +diff --git a/hw/pci/pcie_host.c b/hw/pci/pcie_host.c +index 0a78a8f..a6db258 100644 +--- a/hw/pci/pcie_host.c ++++ b/hw/pci/pcie_host.c +@@ -24,27 +24,6 @@ + #include "hw/pci/pcie_host.h" + #include "exec/address-spaces.h" + +-/* +- * PCI express mmcfig address +- * bit 20 - 28: bus number +- * bit 15 - 19: device number +- * bit 12 - 14: function number +- * bit 0 - 11: offset in configuration space of a given device +- */ +-#define PCIE_MMCFG_SIZE_MAX (1ULL << 28) +-#define PCIE_MMCFG_SIZE_MIN (1ULL << 20) +-#define PCIE_MMCFG_BUS_BIT 20 +-#define PCIE_MMCFG_BUS_MASK 0x1ff +-#define PCIE_MMCFG_DEVFN_BIT 12 +-#define PCIE_MMCFG_DEVFN_MASK 0xff +-#define PCIE_MMCFG_CONFOFFSET_MASK 0xfff +-#define PCIE_MMCFG_BUS(addr) (((addr) >> PCIE_MMCFG_BUS_BIT) & \ +- PCIE_MMCFG_BUS_MASK) +-#define PCIE_MMCFG_DEVFN(addr) (((addr) >> PCIE_MMCFG_DEVFN_BIT) & \ +- PCIE_MMCFG_DEVFN_MASK) +-#define PCIE_MMCFG_CONFOFFSET(addr) ((addr) & PCIE_MMCFG_CONFOFFSET_MASK) +- +- + /* a helper function to get a PCIDevice for a given mmconfig address */ + static inline PCIDevice *pcie_dev_find_by_mmcfg_addr(PCIBus *s, + uint32_t mmcfg_addr) +diff --git a/include/hw/pci/pcie_host.h b/include/hw/pci/pcie_host.h +index bac3c67..da0f275 100644 +--- a/include/hw/pci/pcie_host.h ++++ b/include/hw/pci/pcie_host.h +@@ -54,4 +54,25 @@ void pcie_host_mmcfg_update(PCIExpressHost *e, + hwaddr addr, + uint32_t size); + ++/* ++ * PCI express ECAM (Enhanced Configuration Address Mapping) format. ++ * AKA mmcfg address ++ * bit 20 - 28: bus number ++ * bit 15 - 19: device number ++ * bit 12 - 14: function number ++ * bit 0 - 11: offset in configuration space of a given device ++ */ ++#define PCIE_MMCFG_SIZE_MAX (1ULL << 28) ++#define PCIE_MMCFG_SIZE_MIN (1ULL << 20) ++#define PCIE_MMCFG_BUS_BIT 20 ++#define PCIE_MMCFG_BUS_MASK 0x1ff ++#define PCIE_MMCFG_DEVFN_BIT 12 ++#define PCIE_MMCFG_DEVFN_MASK 0xff ++#define PCIE_MMCFG_CONFOFFSET_MASK 0xfff ++#define PCIE_MMCFG_BUS(addr) (((addr) >> PCIE_MMCFG_BUS_BIT) & \ ++ PCIE_MMCFG_BUS_MASK) ++#define PCIE_MMCFG_DEVFN(addr) (((addr) >> PCIE_MMCFG_DEVFN_BIT) & \ ++ PCIE_MMCFG_DEVFN_MASK) ++#define PCIE_MMCFG_CONFOFFSET(addr) ((addr) & PCIE_MMCFG_CONFOFFSET_MASK) ++ + #endif /* PCIE_HOST_H */ +-- +1.7.11.7 + diff --git a/SOURCES/kvm-piix-APIs-for-pc-guest-info.patch b/SOURCES/kvm-piix-APIs-for-pc-guest-info.patch new file mode 100644 index 0000000..a84c101 --- /dev/null +++ b/SOURCES/kvm-piix-APIs-for-pc-guest-info.patch @@ -0,0 +1,185 @@ +From 364834e660cd4143e69126b2fb9a640c3ee9b9c1 Mon Sep 17 00:00:00 2001 +Message-Id: <364834e660cd4143e69126b2fb9a640c3ee9b9c1.1387298827.git.minovotn@redhat.com> +In-Reply-To: <3ed0fb61a3dc912ef036d7ef450bed192090709e.1387298827.git.minovotn@redhat.com> +References: <3ed0fb61a3dc912ef036d7ef450bed192090709e.1387298827.git.minovotn@redhat.com> +From: "Michael S. Tsirkin" +Date: Tue, 17 Dec 2013 15:18:49 +0100 +Subject: [PATCH 41/56] piix: APIs for pc guest info + +RH-Author: Michael S. Tsirkin +Message-id: <1387293161-4085-42-git-send-email-mst@redhat.com> +Patchwork-id: 56347 +O-Subject: [PATCH qemu-kvm RHEL7.0 v2 41/57] piix: APIs for pc guest info +Bugzilla: 1034876 +RH-Acked-by: Igor Mammedov +RH-Acked-by: Marcel Apfelbaum +RH-Acked-by: Laszlo Ersek + +This adds APIs that will be used to fill in guest acpi tables. +Some required information is still lacking in QOM, so we +fall back on lookups by type and returning explicit types. + +Reviewed-by: Gerd Hoffmann +Tested-by: Gerd Hoffmann +Reviewed-by: Igor Mammedov +Tested-by: Igor Mammedov +Signed-off-by: Michael S. Tsirkin +(cherry picked from commit 277e9340e6a1b0a0e8e988d2f0ac82b18b695c0b) + +Conflicts: + hw/acpi/piix4.c +--- + include/hw/acpi/piix4.h | 8 ++++++++ + include/hw/i386/pc.h | 1 + + hw/acpi/piix4.c | 45 ++++++++++++++++++++++++++++++++++++++++----- + hw/pci-host/piix.c | 8 ++++++++ + 4 files changed, 57 insertions(+), 5 deletions(-) + create mode 100644 include/hw/acpi/piix4.h + +Signed-off-by: Michal Novotny +--- + hw/acpi/piix4.c | 45 ++++++++++++++++++++++++++++++++++++++++----- + hw/pci-host/piix.c | 8 ++++++++ + include/hw/acpi/piix4.h | 8 ++++++++ + include/hw/i386/pc.h | 1 + + 4 files changed, 57 insertions(+), 5 deletions(-) + create mode 100644 include/hw/acpi/piix4.h + +diff --git a/hw/acpi/piix4.c b/hw/acpi/piix4.c +index 18b1300..6ebabe6 100644 +--- a/hw/acpi/piix4.c ++++ b/hw/acpi/piix4.c +@@ -29,6 +29,7 @@ + #include "exec/ioport.h" + #include "hw/nvram/fw_cfg.h" + #include "exec/address-spaces.h" ++#include "hw/acpi/piix4.h" + + //#define DEBUG + +@@ -67,6 +68,8 @@ typedef struct PIIX4PMState { + PCIDevice dev; + + MemoryRegion io; ++ uint32_t io_base; ++ + MemoryRegion io_gpe; + MemoryRegion io_pci; + MemoryRegion io_cpu; +@@ -143,14 +146,12 @@ static void apm_ctrl_changed(uint32_t val, void *arg) + + static void pm_io_space_update(PIIX4PMState *s) + { +- uint32_t pm_io_base; +- +- pm_io_base = le32_to_cpu(*(uint32_t *)(s->dev.config + 0x40)); +- pm_io_base &= 0xffc0; ++ s->io_base = le32_to_cpu(*(uint32_t *)(s->dev.config + 0x40)); ++ s->io_base &= 0xffc0; + + memory_region_transaction_begin(); + memory_region_set_enabled(&s->io, s->dev.config[0x80] & 1); +- memory_region_set_address(&s->io, pm_io_base); ++ memory_region_set_address(&s->io, s->io_base); + memory_region_transaction_commit(); + } + +@@ -393,6 +394,28 @@ static void piix4_pm_machine_ready(Notifier *n, void *opaque) + + } + ++static void piix4_pm_add_propeties(PIIX4PMState *s) ++{ ++ static const uint8_t acpi_enable_cmd = ACPI_ENABLE; ++ static const uint8_t acpi_disable_cmd = ACPI_DISABLE; ++ static const uint32_t gpe0_blk = GPE_BASE; ++ static const uint32_t gpe0_blk_len = GPE_LEN; ++ static const uint16_t sci_int = 9; ++ ++ object_property_add_uint8_ptr(OBJECT(s), ACPI_PM_PROP_ACPI_ENABLE_CMD, ++ &acpi_enable_cmd, NULL); ++ object_property_add_uint8_ptr(OBJECT(s), ACPI_PM_PROP_ACPI_DISABLE_CMD, ++ &acpi_disable_cmd, NULL); ++ object_property_add_uint32_ptr(OBJECT(s), ACPI_PM_PROP_GPE0_BLK, ++ &gpe0_blk, NULL); ++ object_property_add_uint32_ptr(OBJECT(s), ACPI_PM_PROP_GPE0_BLK_LEN, ++ &gpe0_blk_len, NULL); ++ object_property_add_uint16_ptr(OBJECT(s), ACPI_PM_PROP_SCI_INT, ++ &sci_int, NULL); ++ object_property_add_uint32_ptr(OBJECT(s), ACPI_PM_PROP_PM_IO_BASE, ++ &s->io_base, NULL); ++} ++ + static int piix4_pm_initfn(PCIDevice *dev) + { + PIIX4PMState *s = DO_UPCAST(PIIX4PMState, dev, dev); +@@ -442,9 +465,21 @@ static int piix4_pm_initfn(PCIDevice *dev) + + piix4_acpi_system_hot_add_init(pci_address_space_io(dev), dev->bus, s); + ++ piix4_pm_add_propeties(s); + return 0; + } + ++Object *piix4_pm_find(void) ++{ ++ bool ambig; ++ Object *o = object_resolve_path_type("", "PIIX4_PM", &ambig); ++ ++ if (ambig || !o) { ++ return NULL; ++ } ++ return o; ++} ++ + i2c_bus *piix4_pm_init(PCIBus *bus, int devfn, uint32_t smb_io_base, + qemu_irq sci_irq, qemu_irq smi_irq, + int kvm_enabled, FWCfgState *fw_cfg) +diff --git a/hw/pci-host/piix.c b/hw/pci-host/piix.c +index 6502d1c..9284c8d 100644 +--- a/hw/pci-host/piix.c ++++ b/hw/pci-host/piix.c +@@ -408,6 +408,14 @@ PCIBus *i440fx_init(PCII440FXState **pi440fx_state, + return b; + } + ++PCIBus *find_i440fx(void) ++{ ++ PCIHostState *s = OBJECT_CHECK(PCIHostState, ++ object_resolve_path("/machine/i440fx", NULL), ++ TYPE_PCI_HOST_BRIDGE); ++ return s ? s->bus : NULL; ++} ++ + /* PIIX3 PCI to ISA bridge */ + static void piix3_set_irq_pic(PIIX3State *piix3, int pic_irq) + { +diff --git a/include/hw/acpi/piix4.h b/include/hw/acpi/piix4.h +new file mode 100644 +index 0000000..65e6fd7 +--- /dev/null ++++ b/include/hw/acpi/piix4.h +@@ -0,0 +1,8 @@ ++#ifndef HW_ACPI_PIIX4_H ++#define HW_ACPI_PIIX4_H ++ ++#include "qemu/typedefs.h" ++ ++Object *piix4_pm_find(void); ++ ++#endif +diff --git a/include/hw/i386/pc.h b/include/hw/i386/pc.h +index 5011c87..d78e45b 100644 +--- a/include/hw/i386/pc.h ++++ b/include/hw/i386/pc.h +@@ -191,6 +191,7 @@ PCIBus *i440fx_init(PCII440FXState **pi440fx_state, int *piix_devfn, + MemoryRegion *pci_memory, + MemoryRegion *ram_memory); + ++PCIBus *find_i440fx(void); + /* piix4.c */ + extern PCIDevice *piix4_dev; + int piix4_init(PCIBus *bus, ISABus **isa_bus, int devfn); +-- +1.7.11.7 + diff --git a/SOURCES/kvm-piix-fix-32bit-pci-hole.patch b/SOURCES/kvm-piix-fix-32bit-pci-hole.patch new file mode 100644 index 0000000..be6b0c4 --- /dev/null +++ b/SOURCES/kvm-piix-fix-32bit-pci-hole.patch @@ -0,0 +1,70 @@ +From c538b7706e6f03a1eae8f11f9f89b9cbee73dbc9 Mon Sep 17 00:00:00 2001 +From: Laszlo Ersek +Date: Sat, 11 Jan 2014 18:00:08 +0100 +Subject: [PATCH 18/22] piix: fix 32bit pci hole + +RH-Author: Laszlo Ersek +Message-id: <1389463208-6278-19-git-send-email-lersek@redhat.com> +Patchwork-id: 56630 +O-Subject: [RHEL-7.0 qemu-kvm PATCH 18/18] piix: fix 32bit pci hole +Bugzilla: 1032346 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Amos Kong +RH-Acked-by: Andrew Jones + +From: Gerd Hoffmann + +Make the 32bit pci hole start at end of ram, so all possible address +space is covered. + +We used to try and make addresses aligned so they are easier to cover +with MTRRs, but since they are cosmetic on KVM, this is probably not +worth worrying about. +Of course the firmware can use less than that. Leaving space unused is +no problem, mapping pci bars outside the hole causes problems though. + +Signed-off-by: Gerd Hoffmann +Signed-off-by: Laszlo Ersek +Reviewed-by: Michael S. Tsirkin +Signed-off-by: Michael S. Tsirkin +(cherry picked from commit ddaaefb4dd427d6d2e41c1cfbe0cd8d8e8d6aad9) + +Conflicts: + hw/i386/pc_piix.c + hw/pci-host/piix.c + include/hw/i386/pc.h + +Signed-off-by: Laszlo Ersek +--- + hw/pci-host/piix.c | 10 +--------- + 1 file changed, 1 insertion(+), 9 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + hw/pci-host/piix.c | 10 +--------- + 1 files changed, 1 insertions(+), 9 deletions(-) + +diff --git a/hw/pci-host/piix.c b/hw/pci-host/piix.c +index 9284c8d..5757b1d 100644 +--- a/hw/pci-host/piix.c ++++ b/hw/pci-host/piix.c +@@ -337,15 +337,7 @@ PCIBus *i440fx_init(PCII440FXState **pi440fx_state, + f->ram_memory = ram_memory; + + i440fx = I440FX_PCI_HOST_BRIDGE(dev); +- /* Set PCI window size the way seabios has always done it. */ +- /* Power of 2 so bios can cover it with a single MTRR */ +- if (ram_size <= 0x80000000) { +- i440fx->pci_info.w32.begin = 0x80000000; +- } else if (ram_size <= 0xc0000000) { +- i440fx->pci_info.w32.begin = 0xc0000000; +- } else { +- i440fx->pci_info.w32.begin = 0xe0000000; +- } ++ i440fx->pci_info.w32.begin = pci_hole_start; + + memory_region_init_alias(&f->pci_hole, "pci-hole", f->pci_address_space, + pci_hole_start, pci_hole_size); +-- +1.7.1 + diff --git a/SOURCES/kvm-piix-gigabyte-alignment-for-ram.patch b/SOURCES/kvm-piix-gigabyte-alignment-for-ram.patch new file mode 100644 index 0000000..7fb7f96 --- /dev/null +++ b/SOURCES/kvm-piix-gigabyte-alignment-for-ram.patch @@ -0,0 +1,74 @@ +From 8d2dfb2e031ded182868c14423b874464cd98949 Mon Sep 17 00:00:00 2001 +From: Gerd Hoffmann +Date: Mon, 27 Jan 2014 10:31:27 +0100 +Subject: [PATCH 01/14] piix: gigabyte alignment for ram + +Message-id: <1389867959-12463-2-git-send-email-kraxel@redhat.com> +Patchwork-id: 56744 +O-Subject: [RHEL-7 qemu-kvm PATCH 1/4] piix: gigabyte alignment for ram +Bugzilla: 1026548 +RH-Acked-by: Laszlo Ersek +RH-Acked-by: Igor Mammedov +RH-Acked-by: Paolo Bonzini + +Map 3G (i440fx) of memory below 4G, so the RAM pieces +are nicely aligned to gigabyte borders. + +Keep old memory layout for (a) old machine types and (b) in case all +memory fits below 4G and thus we don't have to split RAM into pieces +in the first place. The later makes sure this change doesn't take +away memory from 32bit guests. + +So, with i440fx and up to 3.5 GB of memory, all of it will be mapped +below 4G. With more than 3.5 GB of memory 3 GB will be mapped below +4G and the remaining amount will be mapped above 4G. + +Signed-off-by: Gerd Hoffmann +Signed-off-by: Michael S. Tsirkin +(cherry picked from commit bb43d3839c29b17a2f5c122114cd4ca978065a18) + +Conflicts: + hw/i386/pc_piix.c + +Signed-off-by: Miroslav Rezanina +--- + hw/i386/pc_piix.c | 9 ++++++--- + 1 files changed, 6 insertions(+), 3 deletions(-) + +diff --git a/hw/i386/pc_piix.c b/hw/i386/pc_piix.c +index 663c9d5..9f1d0b5 100644 +--- a/hw/i386/pc_piix.c ++++ b/hw/i386/pc_piix.c +@@ -61,6 +61,7 @@ static const int ide_irq[MAX_IDE_BUS] = { 14, 15 }; + static bool smbios_type1_defaults = true; + static bool has_pci_info; + static bool has_acpi_build = true; ++static bool gigabyte_align = true; + + /* PC hardware initialisation */ + static void pc_init1(QEMUMachineInitArgs *args, +@@ -101,9 +102,10 @@ static void pc_init1(QEMUMachineInitArgs *args, + kvmclock_create(); + } + +- if (args->ram_size >= QEMU_BELOW_4G_RAM_END ) { +- above_4g_mem_size = args->ram_size - QEMU_BELOW_4G_RAM_END; +- below_4g_mem_size = QEMU_BELOW_4G_RAM_END; ++ if (args->ram_size >= 0xe0000000) { ++ ram_addr_t lowmem = gigabyte_align ? 0xc0000000 : 0xe0000000; ++ above_4g_mem_size = args->ram_size - lowmem; ++ below_4g_mem_size = lowmem; + } else { + above_4g_mem_size = 0; + below_4g_mem_size = args->ram_size; +@@ -929,6 +931,7 @@ static void pc_compat_rhel650(QEMUMachineInitArgs *args) + + rom_file_in_ram = false; + has_acpi_build = false; ++ gigabyte_align = false; + } + + static void pc_init_rhel650(QEMUMachineInitArgs *args) +-- +1.7.1 + diff --git a/SOURCES/kvm-piix-use-64-bit-window-programmed-by-guest.patch b/SOURCES/kvm-piix-use-64-bit-window-programmed-by-guest.patch new file mode 100644 index 0000000..772c769 --- /dev/null +++ b/SOURCES/kvm-piix-use-64-bit-window-programmed-by-guest.patch @@ -0,0 +1,67 @@ +From 5c582371601d239c3e8692fa51549ae915a48f41 Mon Sep 17 00:00:00 2001 +Message-Id: <5c582371601d239c3e8692fa51549ae915a48f41.1387298827.git.minovotn@redhat.com> +In-Reply-To: <3ed0fb61a3dc912ef036d7ef450bed192090709e.1387298827.git.minovotn@redhat.com> +References: <3ed0fb61a3dc912ef036d7ef450bed192090709e.1387298827.git.minovotn@redhat.com> +From: "Michael S. Tsirkin" +Date: Tue, 17 Dec 2013 15:17:42 +0100 +Subject: [PATCH 21/56] piix: use 64 bit window programmed by guest + +RH-Author: Michael S. Tsirkin +Message-id: <1387293161-4085-22-git-send-email-mst@redhat.com> +Patchwork-id: 56327 +O-Subject: [PATCH qemu-kvm RHEL7.0 v2 21/57] piix: use 64 bit window programmed by guest +Bugzilla: 1034876 +RH-Acked-by: Igor Mammedov +RH-Acked-by: Marcel Apfelbaum +RH-Acked-by: Laszlo Ersek + +Detect the 64 bit window programmed by firmware +and configure properties accordingly. + +Signed-off-by: Michael S. Tsirkin +(cherry picked from commit 2028fdf3791e14c5ad156252afa0e792192a3e92) +--- + hw/pci-host/piix.c | 14 ++++++++++---- + 1 file changed, 10 insertions(+), 4 deletions(-) + +Signed-off-by: Michal Novotny +--- + hw/pci-host/piix.c | 14 ++++++++++---- + 1 file changed, 10 insertions(+), 4 deletions(-) + +diff --git a/hw/pci-host/piix.c b/hw/pci-host/piix.c +index 167d1fd..0c26835 100644 +--- a/hw/pci-host/piix.c ++++ b/hw/pci-host/piix.c +@@ -229,18 +229,24 @@ static void i440fx_pcihost_get_pci_hole64_start(Object *obj, Visitor *v, + void *opaque, const char *name, + Error **errp) + { +- I440FXState *s = I440FX_PCI_HOST_BRIDGE(obj); ++ PCIHostState *h = PCI_HOST_BRIDGE(obj); ++ Range w64; ++ ++ pci_bus_get_w64_range(h->bus, &w64); + +- visit_type_uint64(v, &s->pci_info.w64.begin, name, errp); ++ visit_type_uint64(v, &w64.begin, name, errp); + } + + static void i440fx_pcihost_get_pci_hole64_end(Object *obj, Visitor *v, + void *opaque, const char *name, + Error **errp) + { +- I440FXState *s = I440FX_PCI_HOST_BRIDGE(obj); ++ PCIHostState *h = PCI_HOST_BRIDGE(obj); ++ Range w64; ++ ++ pci_bus_get_w64_range(h->bus, &w64); + +- visit_type_uint64(v, &s->pci_info.w64.end, name, errp); ++ visit_type_uint64(v, &w64.end, name, errp); + } + + static int i440fx_pcihost_initfn(SysBusDevice *dev) +-- +1.7.11.7 + diff --git a/SOURCES/kvm-pvpanic-add-API-to-access-io-port.patch b/SOURCES/kvm-pvpanic-add-API-to-access-io-port.patch new file mode 100644 index 0000000..9d6a1e3 --- /dev/null +++ b/SOURCES/kvm-pvpanic-add-API-to-access-io-port.patch @@ -0,0 +1,88 @@ +From 1f08d3fe2b08289b3cae10dc91a96b793272801b Mon Sep 17 00:00:00 2001 +Message-Id: <1f08d3fe2b08289b3cae10dc91a96b793272801b.1387298827.git.minovotn@redhat.com> +In-Reply-To: <3ed0fb61a3dc912ef036d7ef450bed192090709e.1387298827.git.minovotn@redhat.com> +References: <3ed0fb61a3dc912ef036d7ef450bed192090709e.1387298827.git.minovotn@redhat.com> +From: "Michael S. Tsirkin" +Date: Tue, 17 Dec 2013 15:18:54 +0100 +Subject: [PATCH 43/56] pvpanic: add API to access io port + +RH-Author: Michael S. Tsirkin +Message-id: <1387293161-4085-44-git-send-email-mst@redhat.com> +Patchwork-id: 56349 +O-Subject: [PATCH qemu-kvm RHEL7.0 v2 43/57] pvpanic: add API to access io port +Bugzilla: 1034876 +RH-Acked-by: Igor Mammedov +RH-Acked-by: Marcel Apfelbaum +RH-Acked-by: Laszlo Ersek + +Add API to find pvpanic device and get its io port. +Will be used to fill in guest info structure. + +Reviewed-by: Gerd Hoffmann +Tested-by: Gerd Hoffmann +Reviewed-by: Igor Mammedov +Tested-by: Igor Mammedov +Signed-off-by: Michael S. Tsirkin +(cherry picked from commit 309cd62d6b2628b4f0e2850b42011077f40956c7) + +Conflicts: + include/hw/i386/pc.h +--- + include/hw/i386/pc.h | 1 + + hw/misc/pvpanic.c | 14 +++++++++++++- + 2 files changed, 14 insertions(+), 1 deletion(-) + +Signed-off-by: Michal Novotny +--- + hw/misc/pvpanic.c | 14 +++++++++++++- + include/hw/i386/pc.h | 1 + + 2 files changed, 14 insertions(+), 1 deletion(-) + +diff --git a/hw/misc/pvpanic.c b/hw/misc/pvpanic.c +index 1838bc7..1377fde 100644 +--- a/hw/misc/pvpanic.c ++++ b/hw/misc/pvpanic.c +@@ -19,6 +19,7 @@ + #include "qemu/log.h" + + #include "hw/nvram/fw_cfg.h" ++#include "hw/i386/pc.h" + + /* The bit of supported pv event */ + #define PVPANIC_F_PANICKED 0 +@@ -107,8 +108,19 @@ static int pvpanic_isa_initfn(ISADevice *dev) + return 0; + } + ++#define PVPANIC_IOPORT_PROP "ioport" ++ ++uint16_t pvpanic_port(void) ++{ ++ Object *o = object_resolve_path_type("", TYPE_ISA_PVPANIC_DEVICE, NULL); ++ if (!o) { ++ return 0; ++ } ++ return object_property_get_int(o, PVPANIC_IOPORT_PROP, NULL); ++} ++ + static Property pvpanic_isa_properties[] = { +- DEFINE_PROP_UINT16("ioport", PVPanicState, ioport, 0x505), ++ DEFINE_PROP_UINT16(PVPANIC_IOPORT_PROP, PVPanicState, ioport, 0x505), + DEFINE_PROP_END_OF_LIST(), + }; + +diff --git a/include/hw/i386/pc.h b/include/hw/i386/pc.h +index d78e45b..8793715 100644 +--- a/include/hw/i386/pc.h ++++ b/include/hw/i386/pc.h +@@ -231,6 +231,7 @@ void pc_system_firmware_init(MemoryRegion *rom_memory); + + /* pvpanic.c */ + void pvpanic_init(ISABus *bus); ++uint16_t pvpanic_port(void); + + /* e820 types */ + #define E820_RAM 1 +-- +1.7.11.7 + diff --git a/SOURCES/kvm-q35-expose-mmcfg-size-as-a-property.patch b/SOURCES/kvm-q35-expose-mmcfg-size-as-a-property.patch new file mode 100644 index 0000000..ac4d16f --- /dev/null +++ b/SOURCES/kvm-q35-expose-mmcfg-size-as-a-property.patch @@ -0,0 +1,83 @@ +From 3d461e82d134f7370f28ff2def581d39a3e19729 Mon Sep 17 00:00:00 2001 +Message-Id: <3d461e82d134f7370f28ff2def581d39a3e19729.1387298827.git.minovotn@redhat.com> +In-Reply-To: <3ed0fb61a3dc912ef036d7ef450bed192090709e.1387298827.git.minovotn@redhat.com> +References: <3ed0fb61a3dc912ef036d7ef450bed192090709e.1387298827.git.minovotn@redhat.com> +From: "Michael S. Tsirkin" +Date: Tue, 17 Dec 2013 15:18:09 +0100 +Subject: [PATCH 31/56] q35: expose mmcfg size as a property + +RH-Author: Michael S. Tsirkin +Message-id: <1387293161-4085-32-git-send-email-mst@redhat.com> +Patchwork-id: 56337 +O-Subject: [PATCH qemu-kvm RHEL7.0 v2 31/57] q35: expose mmcfg size as a property +Bugzilla: 1034876 +RH-Acked-by: Igor Mammedov +RH-Acked-by: Marcel Apfelbaum +RH-Acked-by: Laszlo Ersek + +Address is already exposed, expose size for symmetry. + +Reviewed-by: Gerd Hoffmann +Tested-by: Gerd Hoffmann +Reviewed-by: Igor Mammedov +Tested-by: Igor Mammedov +Signed-off-by: Michael S. Tsirkin +(cherry picked from commit cbcaf79e3ce1b14084f3e3f4f64365e9bfd70e6a) +--- + include/hw/pci/pcie_host.h | 1 + + hw/pci-host/q35.c | 14 ++++++++++++++ + 2 files changed, 15 insertions(+) + +Signed-off-by: Michal Novotny +--- + hw/pci-host/q35.c | 14 ++++++++++++++ + include/hw/pci/pcie_host.h | 1 + + 2 files changed, 15 insertions(+) + +diff --git a/hw/pci-host/q35.c b/hw/pci-host/q35.c +index 72d97c8..87691d1 100644 +--- a/hw/pci-host/q35.c ++++ b/hw/pci-host/q35.c +@@ -108,6 +108,16 @@ static void q35_host_get_pci_hole64_end(Object *obj, Visitor *v, + visit_type_uint64(v, &w64.end, name, errp); + } + ++static void q35_host_get_mmcfg_size(Object *obj, Visitor *v, ++ void *opaque, const char *name, ++ Error **errp) ++{ ++ PCIExpressHost *e = PCIE_HOST_BRIDGE(obj); ++ uint32_t value = e->size; ++ ++ visit_type_uint32(v, &value, name, errp); ++} ++ + static Property mch_props[] = { + DEFINE_PROP_UINT64(PCIE_HOST_MCFG_BASE, Q35PCIHost, host.base_addr, + MCH_HOST_BRIDGE_PCIEXBAR_DEFAULT), +@@ -152,6 +162,10 @@ static void q35_host_initfn(Object *obj) + q35_host_get_pci_hole64_end, + NULL, NULL, NULL, NULL); + ++ object_property_add(obj, PCIE_HOST_MCFG_SIZE, "int", ++ q35_host_get_mmcfg_size, ++ NULL, NULL, NULL, NULL); ++ + /* Leave enough space for the biggest MCFG BAR */ + /* TODO: this matches current bios behaviour, but + * it's not a power of two, which means an MTRR +diff --git a/include/hw/pci/pcie_host.h b/include/hw/pci/pcie_host.h +index 33d75bd..acca45e 100644 +--- a/include/hw/pci/pcie_host.h ++++ b/include/hw/pci/pcie_host.h +@@ -29,6 +29,7 @@ + OBJECT_CHECK(PCIExpressHost, (obj), TYPE_PCIE_HOST_BRIDGE) + + #define PCIE_HOST_MCFG_BASE "MCFG" ++#define PCIE_HOST_MCFG_SIZE "mcfg_size" + + /* pcie_host::base_addr == PCIE_BASE_ADDR_UNMAPPED when it isn't mapped. */ + #define PCIE_BASE_ADDR_UNMAPPED ((hwaddr)-1ULL) +-- +1.7.11.7 + diff --git a/SOURCES/kvm-q35-gigabyle-alignment-for-ram.patch b/SOURCES/kvm-q35-gigabyle-alignment-for-ram.patch new file mode 100644 index 0000000..306bbf5 --- /dev/null +++ b/SOURCES/kvm-q35-gigabyle-alignment-for-ram.patch @@ -0,0 +1,61 @@ +From 6a2046866f4e057da661d496fc8014e5bca0d44e Mon Sep 17 00:00:00 2001 +From: Gerd Hoffmann +Date: Thu, 16 Jan 2014 10:25:59 +0100 +Subject: [PATCH 03/14] q35: gigabyle alignment for ram + +RH-Author: Gerd Hoffmann +Message-id: <1389867959-12463-5-git-send-email-kraxel@redhat.com> +Patchwork-id: 56746 +O-Subject: [RHEL-7 qemu-kvm PATCH 4/4] q35: gigabyle alignment for ram +Bugzilla: 1026548 +RH-Acked-by: Laszlo Ersek +RH-Acked-by: Igor Mammedov +RH-Acked-by: Paolo Bonzini + +Map 2G of memory below 4G, so the two RAM pieces are nicely +aligned to gigabyte borders. + +Keep old memory layout for in case all memory fits below 4G and +thus we don't have to split RAM into pieces in the first place. + +upstream: Not yet. Planned, but want sort mmconf bar issues first. + Put into rhel7 nevertheless to make life simpler for rhel8 + (i.e. no need to support gigabyte alignment the rhel6 way). + +Signed-off-by: Gerd Hoffmann +--- + hw/i386/pc_q35.c | 6 ++++-- + 1 file changed, 4 insertions(+), 2 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + hw/i386/pc_q35.c | 6 ++++-- + 1 files changed, 4 insertions(+), 2 deletions(-) + +diff --git a/hw/i386/pc_q35.c b/hw/i386/pc_q35.c +index 232c62d..7e46799 100644 +--- a/hw/i386/pc_q35.c ++++ b/hw/i386/pc_q35.c +@@ -51,6 +51,7 @@ + static bool smbios_type1_defaults = true; + static bool has_pci_info; + static bool has_acpi_build = true; ++static bool gigabyte_align = true; + + /* PC hardware initialisation */ + static void pc_q35_init(QEMUMachineInitArgs *args) +@@ -87,8 +88,9 @@ static void pc_q35_init(QEMUMachineInitArgs *args) + kvmclock_create(); + + if (args->ram_size >= 0xb0000000) { +- above_4g_mem_size = args->ram_size - 0xb0000000; +- below_4g_mem_size = 0xb0000000; ++ ram_addr_t lowmem = gigabyte_align ? 0x80000000 : 0xb0000000; ++ above_4g_mem_size = args->ram_size - lowmem; ++ below_4g_mem_size = lowmem; + } else { + above_4g_mem_size = 0; + below_4g_mem_size = args->ram_size; +-- +1.7.1 + diff --git a/SOURCES/kvm-q35-make-pci-window-address-size-match-guest-cfg.patch b/SOURCES/kvm-q35-make-pci-window-address-size-match-guest-cfg.patch new file mode 100644 index 0000000..fe20e1f --- /dev/null +++ b/SOURCES/kvm-q35-make-pci-window-address-size-match-guest-cfg.patch @@ -0,0 +1,58 @@ +From d07bebfe0f9a1e1cf3f25449d9c20d4c21c6e2a0 Mon Sep 17 00:00:00 2001 +Message-Id: +In-Reply-To: <3ed0fb61a3dc912ef036d7ef450bed192090709e.1387298827.git.minovotn@redhat.com> +References: <3ed0fb61a3dc912ef036d7ef450bed192090709e.1387298827.git.minovotn@redhat.com> +From: "Michael S. Tsirkin" +Date: Tue, 17 Dec 2013 15:17:37 +0100 +Subject: [PATCH 19/56] q35: make pci window address/size match guest cfg + +RH-Author: Michael S. Tsirkin +Message-id: <1387293161-4085-20-git-send-email-mst@redhat.com> +Patchwork-id: 56325 +O-Subject: [PATCH qemu-kvm RHEL7.0 v2 19/57] q35: make pci window address/size match guest cfg +Bugzilla: 1034876 +RH-Acked-by: Igor Mammedov +RH-Acked-by: Marcel Apfelbaum +RH-Acked-by: Laszlo Ersek + +For Q35, MMCFG address and size are guest configurable. +Update w32 property to make it behave accordingly. + +Signed-off-by: Michael S. Tsirkin +(cherry picked from commit 636228a887c4d5c0dc313bbf936de969b420a91a) + +Conflicts: + hw/pci-host/q35.c +--- + hw/pci-host/q35.c | 10 ++++++++++ + 1 file changed, 10 insertions(+) + +Signed-off-by: Michal Novotny +--- + hw/pci-host/q35.c | 10 ++++++++++ + 1 file changed, 10 insertions(+) + +diff --git a/hw/pci-host/q35.c b/hw/pci-host/q35.c +index be12eee..70ad01f 100644 +--- a/hw/pci-host/q35.c ++++ b/hw/pci-host/q35.c +@@ -207,6 +207,16 @@ static void mch_update_pciexbar(MCHPCIState *mch) + } + addr = pciexbar & addr_mask; + pcie_host_mmcfg_update(&s->host, enable, addr, length); ++ /* Leave enough space for the MCFG BAR */ ++ /* ++ * TODO: this matches current bios behaviour, but it's not a power of two, ++ * which means an MTRR can't cover it exactly. ++ */ ++ if (enable) { ++ mch->pci_info.w32.begin = addr + length; ++ } else { ++ mch->pci_info.w32.begin = MCH_HOST_BRIDGE_PCIEXBAR_DEFAULT; ++ } + } + + /* PAM */ +-- +1.7.11.7 + diff --git a/SOURCES/kvm-q35-use-64-bit-window-programmed-by-guest.patch b/SOURCES/kvm-q35-use-64-bit-window-programmed-by-guest.patch new file mode 100644 index 0000000..39228f0 --- /dev/null +++ b/SOURCES/kvm-q35-use-64-bit-window-programmed-by-guest.patch @@ -0,0 +1,67 @@ +From 05a8be73352b862049cfe74b38b10634187c5830 Mon Sep 17 00:00:00 2001 +Message-Id: <05a8be73352b862049cfe74b38b10634187c5830.1387298827.git.minovotn@redhat.com> +In-Reply-To: <3ed0fb61a3dc912ef036d7ef450bed192090709e.1387298827.git.minovotn@redhat.com> +References: <3ed0fb61a3dc912ef036d7ef450bed192090709e.1387298827.git.minovotn@redhat.com> +From: "Michael S. Tsirkin" +Date: Tue, 17 Dec 2013 15:17:40 +0100 +Subject: [PATCH 20/56] q35: use 64 bit window programmed by guest + +RH-Author: Michael S. Tsirkin +Message-id: <1387293161-4085-21-git-send-email-mst@redhat.com> +Patchwork-id: 56326 +O-Subject: [PATCH qemu-kvm RHEL7.0 v2 20/57] q35: use 64 bit window programmed by guest +Bugzilla: 1034876 +RH-Acked-by: Igor Mammedov +RH-Acked-by: Marcel Apfelbaum +RH-Acked-by: Laszlo Ersek + +Detect the 64 bit window programmed by firmware +and configure properties accordingly. + +Signed-off-by: Michael S. Tsirkin +(cherry picked from commit 8b42d730e3401084720f4ba59d1e18a0d6c67dc6) +--- + hw/pci-host/q35.c | 14 ++++++++++---- + 1 file changed, 10 insertions(+), 4 deletions(-) + +Signed-off-by: Michal Novotny +--- + hw/pci-host/q35.c | 14 ++++++++++---- + 1 file changed, 10 insertions(+), 4 deletions(-) + +diff --git a/hw/pci-host/q35.c b/hw/pci-host/q35.c +index 70ad01f..943e55f 100644 +--- a/hw/pci-host/q35.c ++++ b/hw/pci-host/q35.c +@@ -88,18 +88,24 @@ static void q35_host_get_pci_hole64_start(Object *obj, Visitor *v, + void *opaque, const char *name, + Error **errp) + { +- Q35PCIHost *s = Q35_HOST_DEVICE(obj); ++ PCIHostState *h = PCI_HOST_BRIDGE(obj); ++ Range w64; ++ ++ pci_bus_get_w64_range(h->bus, &w64); + +- visit_type_uint64(v, &s->mch.pci_info.w64.begin, name, errp); ++ visit_type_uint64(v, &w64.begin, name, errp); + } + + static void q35_host_get_pci_hole64_end(Object *obj, Visitor *v, + void *opaque, const char *name, + Error **errp) + { +- Q35PCIHost *s = Q35_HOST_DEVICE(obj); ++ PCIHostState *h = PCI_HOST_BRIDGE(obj); ++ Range w64; ++ ++ pci_bus_get_w64_range(h->bus, &w64); + +- visit_type_uint64(v, &s->mch.pci_info.w64.end, name, errp); ++ visit_type_uint64(v, &w64.end, name, errp); + } + + static Property mch_props[] = { +-- +1.7.11.7 + diff --git a/SOURCES/kvm-q35-use-macro-for-MCFG-property-name.patch b/SOURCES/kvm-q35-use-macro-for-MCFG-property-name.patch new file mode 100644 index 0000000..7ffcb49 --- /dev/null +++ b/SOURCES/kvm-q35-use-macro-for-MCFG-property-name.patch @@ -0,0 +1,70 @@ +From c22f2592addb5fdd998feefc802395cf59095497 Mon Sep 17 00:00:00 2001 +Message-Id: +In-Reply-To: <3ed0fb61a3dc912ef036d7ef450bed192090709e.1387298827.git.minovotn@redhat.com> +References: <3ed0fb61a3dc912ef036d7ef450bed192090709e.1387298827.git.minovotn@redhat.com> +From: "Michael S. Tsirkin" +Date: Tue, 17 Dec 2013 15:18:06 +0100 +Subject: [PATCH 30/56] q35: use macro for MCFG property name + +RH-Author: Michael S. Tsirkin +Message-id: <1387293161-4085-31-git-send-email-mst@redhat.com> +Patchwork-id: 56336 +O-Subject: [PATCH qemu-kvm RHEL7.0 v2 30/57] q35: use macro for MCFG property name +Bugzilla: 1034876 +RH-Acked-by: Igor Mammedov +RH-Acked-by: Marcel Apfelbaum +RH-Acked-by: Laszlo Ersek + +Useful to make it accessible through QOM. + +Reviewed-by: Gerd Hoffmann +Tested-by: Gerd Hoffmann +Reviewed-by: Igor Mammedov +Tested-by: Igor Mammedov +Signed-off-by: Michael S. Tsirkin +(cherry picked from commit 87f65245db4665edff22242c17546954d9d59c82) + +Conflicts: + hw/pci-host/q35.c +--- + include/hw/pci/pcie_host.h | 2 ++ + hw/pci-host/q35.c | 4 ++-- + 2 files changed, 4 insertions(+), 2 deletions(-) + +Signed-off-by: Michal Novotny +--- + hw/pci-host/q35.c | 4 ++-- + include/hw/pci/pcie_host.h | 2 ++ + 2 files changed, 4 insertions(+), 2 deletions(-) + +diff --git a/hw/pci-host/q35.c b/hw/pci-host/q35.c +index 05779b8..72d97c8 100644 +--- a/hw/pci-host/q35.c ++++ b/hw/pci-host/q35.c +@@ -109,8 +109,8 @@ static void q35_host_get_pci_hole64_end(Object *obj, Visitor *v, + } + + static Property mch_props[] = { +- DEFINE_PROP_UINT64("MCFG", Q35PCIHost, host.base_addr, +- MCH_HOST_BRIDGE_PCIEXBAR_DEFAULT), ++ DEFINE_PROP_UINT64(PCIE_HOST_MCFG_BASE, Q35PCIHost, host.base_addr, ++ MCH_HOST_BRIDGE_PCIEXBAR_DEFAULT), + DEFINE_PROP_SIZE(PCI_HOST_PROP_PCI_HOLE64_SIZE, Q35PCIHost, + mch.pci_hole64_size, DEFAULT_PCI_HOLE64_SIZE), + DEFINE_PROP_END_OF_LIST(), +diff --git a/include/hw/pci/pcie_host.h b/include/hw/pci/pcie_host.h +index da0f275..33d75bd 100644 +--- a/include/hw/pci/pcie_host.h ++++ b/include/hw/pci/pcie_host.h +@@ -28,6 +28,8 @@ + #define PCIE_HOST_BRIDGE(obj) \ + OBJECT_CHECK(PCIExpressHost, (obj), TYPE_PCIE_HOST_BRIDGE) + ++#define PCIE_HOST_MCFG_BASE "MCFG" ++ + /* pcie_host::base_addr == PCIE_BASE_ADDR_UNMAPPED when it isn't mapped. */ + #define PCIE_BASE_ADDR_UNMAPPED ((hwaddr)-1ULL) + +-- +1.7.11.7 + diff --git a/SOURCES/kvm-qapi-Add-backing-to-BlockStats.patch b/SOURCES/kvm-qapi-Add-backing-to-BlockStats.patch new file mode 100644 index 0000000..95b59ca --- /dev/null +++ b/SOURCES/kvm-qapi-Add-backing-to-BlockStats.patch @@ -0,0 +1,84 @@ +From ec69926313e8edae11091849f536b1f16da53ab7 Mon Sep 17 00:00:00 2001 +From: Fam Zheng +Date: Mon, 27 Jan 2014 07:46:43 +0100 +Subject: [PATCH 19/22] qapi: Add "backing" to BlockStats + +RH-Author: Fam Zheng +Message-id: <1390808803-6464-1-git-send-email-famz@redhat.com> +Patchwork-id: 56952 +O-Subject: [RHEL-7 qemu-kvm PATCH] qapi: Add "backing" to BlockStats +Bugzilla: 1041564 +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Kevin Wolf +RH-Acked-by: Miroslav Rezanina + +Bugzilla: https://bugzilla.redhat.com/show_bug.cgi?id=1041564 +Brew: https://brewweb.devel.redhat.com/taskinfo?taskID=6949016 + +Currently there is no way to query BlockStats of the backing chain. This +adds "backing" field into BlockStats to make it possible. + +The comment of "parent" is reworded. + +Signed-off-by: Fam Zheng +Reviewed-by: Benoit Canet +Reviewed-by: Eric Blake +Signed-off-by: Kevin Wolf +(cherry picked from commit c8059b97e1f9b4635b836ee98373a0f72f9fc0b4) +Signed-off-by: Fam Zheng +--- + block/qapi.c | 5 +++++ + qapi-schema.json | 10 ++++++---- + 2 files changed, 11 insertions(+), 4 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + block/qapi.c | 5 +++++ + qapi-schema.json | 10 ++++++---- + 2 files changed, 11 insertions(+), 4 deletions(-) + +diff --git a/block/qapi.c b/block/qapi.c +index 87423fb..77e1719 100644 +--- a/block/qapi.c ++++ b/block/qapi.c +@@ -295,6 +295,11 @@ BlockStats *bdrv_query_stats(const BlockDriverState *bs) + s->parent = bdrv_query_stats(bs->file); + } + ++ if (bs->backing_hd) { ++ s->has_backing = true; ++ s->backing = bdrv_query_stats(bs->backing_hd); ++ } ++ + return s; + } + +diff --git a/qapi-schema.json b/qapi-schema.json +index 6158ea5..8b257e2 100644 +--- a/qapi-schema.json ++++ b/qapi-schema.json +@@ -1007,15 +1007,17 @@ + # + # @stats: A @BlockDeviceStats for the device. + # +-# @parent: #optional This may point to the backing block device if this is a +-# a virtual block device. If it's a backing block, this will point +-# to the backing file is one is present. ++# @parent: #optional This describes the file block device if it has one. ++# ++# @backing: #optional This describes the backing block device if it has one. ++# (Since 2.0) + # + # Since: 0.14.0 + ## + { 'type': 'BlockStats', + 'data': {'*device': 'str', 'stats': 'BlockDeviceStats', +- '*parent': 'BlockStats'} } ++ '*parent': 'BlockStats', ++ '*backing': 'BlockStats'} } + + ## + # @query-blockstats: +-- +1.7.1 + diff --git a/SOURCES/kvm-qapi-Introduce-enum-BlockJobType.patch b/SOURCES/kvm-qapi-Introduce-enum-BlockJobType.patch new file mode 100644 index 0000000..5fa35e1 --- /dev/null +++ b/SOURCES/kvm-qapi-Introduce-enum-BlockJobType.patch @@ -0,0 +1,63 @@ +From bcfb39087baadf3aaf96b78f38093e4ed7951df4 Mon Sep 17 00:00:00 2001 +From: Fam Zheng +Date: Fri, 17 Jan 2014 03:07:55 +0100 +Subject: [PATCH 12/34] qapi: Introduce enum BlockJobType + +RH-Author: Fam Zheng +Message-id: <1389928083-8921-11-git-send-email-famz@redhat.com> +Patchwork-id: 56772 +O-Subject: [RHEL-7 qemu-kvm PATCH 10/18] qapi: Introduce enum BlockJobType +Bugzilla: 1041301 +RH-Acked-by: Jeffrey Cody +RH-Acked-by: Kevin Wolf +RH-Acked-by: Stefan Hajnoczi + +This will replace the open coded block job type string for mirror, +commit and backup. + +Signed-off-by: Fam Zheng +Reviewed-by: Eric Blake +Signed-off-by: Kevin Wolf +(cherry picked from commit 2cb5b22286a7546226d9e9363aaee543fcba6b61) +Signed-off-by: Fam Zheng +--- + qapi-schema.json | 18 ++++++++++++++++++ + 1 file changed, 18 insertions(+) + +Signed-off-by: Miroslav Rezanina +--- + qapi-schema.json | 18 ++++++++++++++++++ + 1 files changed, 18 insertions(+), 0 deletions(-) + +diff --git a/qapi-schema.json b/qapi-schema.json +index 761512d..b0bd53c 100644 +--- a/qapi-schema.json ++++ b/qapi-schema.json +@@ -1407,6 +1407,24 @@ + 'data': ['top', 'full', 'none'] } + + ## ++# @BlockJobType: ++# ++# Type of a block job. ++# ++# @commit: block commit job type, see "block-commit" ++# ++# @stream: block stream job type, see "block-stream" ++# ++# @mirror: drive mirror job type, see "drive-mirror" ++# ++# @backup: drive backup job type, see "drive-backup" ++# ++# Since: 1.7 ++## ++{ 'enum': 'BlockJobType', ++ 'data': ['commit', 'stream', 'mirror', 'backup'] } ++ ++## + # @BlockJobInfo: + # + # Information about a long-running block device operation. +-- +1.7.1 + diff --git a/SOURCES/kvm-qapi-add-QMP-input-test-for-large-integers.patch b/SOURCES/kvm-qapi-add-QMP-input-test-for-large-integers.patch new file mode 100644 index 0000000..af3731e --- /dev/null +++ b/SOURCES/kvm-qapi-add-QMP-input-test-for-large-integers.patch @@ -0,0 +1,84 @@ +From 889862b6101fb71fd19fdae0ffa18815446be0a5 Mon Sep 17 00:00:00 2001 +Message-Id: <889862b6101fb71fd19fdae0ffa18815446be0a5.1387369730.git.minovotn@redhat.com> +In-Reply-To: <091eecc4fa42754760dfff393dabcc2b444e9693.1387369730.git.minovotn@redhat.com> +References: <091eecc4fa42754760dfff393dabcc2b444e9693.1387369730.git.minovotn@redhat.com> +From: Markus Armbruster +Date: Tue, 10 Dec 2013 15:29:05 +0100 +Subject: [PATCH 05/21] qapi: add QMP input test for large integers + +RH-Author: Markus Armbruster +Message-id: <1386689361-30281-3-git-send-email-armbru@redhat.com> +Patchwork-id: 56123 +O-Subject: [PATCH 7.0 qemu-kvm 02/18] qapi: add QMP input test for large integers +Bugzilla: 997915 +RH-Acked-by: Laszlo Ersek +RH-Acked-by: Kevin Wolf +RH-Acked-by: Luiz Capitulino + +From: Michael Roth + +Large integers previously got capped to LLONG_MAX/LLONG_MIN so we could +store them as int64_t. This could lead to silent errors occuring. + +Now, we use a double to handle these cases. + +Add a test to confirm that QMPInputVisitor handles this as expected if +we're expected an integer value: errors for out of range integer values +that got promoted to doubles in this fashion. + +Signed-off-by: Michael Roth +Reviewed-by: Laszlo Ersek +Reviewed-by: Amos Kong +Signed-off-by: Luiz Capitulino +(cherry picked from commit e92cfa0d90c618ff1f131c60ef1b27aa6fe69a0a) +Signed-off-by: Markus Armbruster +--- + tests/test-qmp-input-visitor.c | 20 ++++++++++++++++++++ + 1 file changed, 20 insertions(+) + +Signed-off-by: Michal Novotny +--- + tests/test-qmp-input-visitor.c | 20 ++++++++++++++++++++ + 1 file changed, 20 insertions(+) + +diff --git a/tests/test-qmp-input-visitor.c b/tests/test-qmp-input-visitor.c +index 955a4c0..b308cf9 100644 +--- a/tests/test-qmp-input-visitor.c ++++ b/tests/test-qmp-input-visitor.c +@@ -75,6 +75,24 @@ static void test_visitor_in_int(TestInputVisitorData *data, + g_assert_cmpint(res, ==, value); + } + ++static void test_visitor_in_int_overflow(TestInputVisitorData *data, ++ const void *unused) ++{ ++ int64_t res = 0; ++ Error *errp = NULL; ++ Visitor *v; ++ ++ /* this will overflow a Qint/int64, so should be deserialized into ++ * a QFloat/double field instead, leading to an error if we pass it ++ * to visit_type_int. confirm this. ++ */ ++ v = visitor_input_test_init(data, "%f", DBL_MAX); ++ ++ visit_type_int(v, &res, NULL, &errp); ++ g_assert(error_is_set(&errp)); ++ error_free(errp); ++} ++ + static void test_visitor_in_bool(TestInputVisitorData *data, + const void *unused) + { +@@ -292,6 +310,8 @@ int main(int argc, char **argv) + + input_visitor_test_add("/visitor/input/int", + &in_visitor_data, test_visitor_in_int); ++ input_visitor_test_add("/visitor/input/int_overflow", ++ &in_visitor_data, test_visitor_in_int_overflow); + input_visitor_test_add("/visitor/input/bool", + &in_visitor_data, test_visitor_in_bool); + input_visitor_test_add("/visitor/input/number", +-- +1.7.11.7 + diff --git a/SOURCES/kvm-qapi-add-native-list-coverage-for-QMP-input-visitor-.patch b/SOURCES/kvm-qapi-add-native-list-coverage-for-QMP-input-visitor-.patch new file mode 100644 index 0000000..0780109 --- /dev/null +++ b/SOURCES/kvm-qapi-add-native-list-coverage-for-QMP-input-visitor-.patch @@ -0,0 +1,404 @@ +From e88b00eb5e1f4785827445fe5b06b590ebae7d7b Mon Sep 17 00:00:00 2001 +Message-Id: +In-Reply-To: <091eecc4fa42754760dfff393dabcc2b444e9693.1387369730.git.minovotn@redhat.com> +References: <091eecc4fa42754760dfff393dabcc2b444e9693.1387369730.git.minovotn@redhat.com> +From: Markus Armbruster +Date: Tue, 10 Dec 2013 15:29:09 +0100 +Subject: [PATCH 09/21] qapi: add native list coverage for QMP input visitor + tests + +RH-Author: Markus Armbruster +Message-id: <1386689361-30281-7-git-send-email-armbru@redhat.com> +Patchwork-id: 56125 +O-Subject: [PATCH 7.0 qemu-kvm 06/18] qapi: add native list coverage for QMP input visitor tests +Bugzilla: 997915 +RH-Acked-by: Laszlo Ersek +RH-Acked-by: Kevin Wolf +RH-Acked-by: Luiz Capitulino + +From: Michael Roth + +This exercises schema-generated visitors for native list types and does +some sanity checking on validity of deserialized data. + +Signed-off-by: Michael Roth +Reviewed-by: Laszlo Ersek +Reviewed-by: Amos Kong +Signed-off-by: Luiz Capitulino +(cherry picked from commit 199e0f17f23a68c8d619e9e623d970324ed5efc1) +Signed-off-by: Markus Armbruster +--- + tests/test-qmp-input-visitor.c | 338 +++++++++++++++++++++++++++++++++++++++++ + 1 file changed, 338 insertions(+) + +Signed-off-by: Michal Novotny +--- + tests/test-qmp-input-visitor.c | 338 +++++++++++++++++++++++++++++++++++++++++ + 1 file changed, 338 insertions(+) + +diff --git a/tests/test-qmp-input-visitor.c b/tests/test-qmp-input-visitor.c +index b308cf9..2741eef 100644 +--- a/tests/test-qmp-input-visitor.c ++++ b/tests/test-qmp-input-visitor.c +@@ -61,6 +61,31 @@ Visitor *visitor_input_test_init(TestInputVisitorData *data, + return v; + } + ++/* similar to visitor_input_test_init(), but does not expect a string ++ * literal/format json_string argument and so can be used for ++ * programatically generated strings (and we can't pass in programatically ++ * generated strings via %s format parameters since qobject_from_jsonv() ++ * will wrap those in double-quotes and treat the entire object as a ++ * string) ++ */ ++static Visitor *visitor_input_test_init_raw(TestInputVisitorData *data, ++ const char *json_string) ++{ ++ Visitor *v; ++ ++ data->obj = qobject_from_json(json_string); ++ ++ g_assert(data->obj != NULL); ++ ++ data->qiv = qmp_input_visitor_new(data->obj); ++ g_assert(data->qiv != NULL); ++ ++ v = qmp_input_get_visitor(data->qiv); ++ g_assert(v != NULL); ++ ++ return v; ++} ++ + static void test_visitor_in_int(TestInputVisitorData *data, + const void *unused) + { +@@ -277,6 +302,287 @@ static void test_visitor_in_union(TestInputVisitorData *data, + qapi_free_UserDefUnion(tmp); + } + ++static void test_native_list_integer_helper(TestInputVisitorData *data, ++ const void *unused, ++ UserDefNativeListUnionKind kind) ++{ ++ UserDefNativeListUnion *cvalue = NULL; ++ Error *err = NULL; ++ Visitor *v; ++ GString *gstr_list = g_string_new(""); ++ GString *gstr_union = g_string_new(""); ++ int i; ++ ++ for (i = 0; i < 32; i++) { ++ g_string_append_printf(gstr_list, "%d", i); ++ if (i != 31) { ++ g_string_append(gstr_list, ", "); ++ } ++ } ++ g_string_append_printf(gstr_union, "{ 'type': '%s', 'data': [ %s ] }", ++ UserDefNativeListUnionKind_lookup[kind], ++ gstr_list->str); ++ v = visitor_input_test_init_raw(data, gstr_union->str); ++ ++ visit_type_UserDefNativeListUnion(v, &cvalue, NULL, &err); ++ g_assert(err == NULL); ++ g_assert(cvalue != NULL); ++ g_assert_cmpint(cvalue->kind, ==, kind); ++ ++ switch (kind) { ++ case USER_DEF_NATIVE_LIST_UNION_KIND_INTEGER: { ++ intList *elem = NULL; ++ for (i = 0, elem = cvalue->integer; elem; elem = elem->next, i++) { ++ g_assert_cmpint(elem->value, ==, i); ++ } ++ break; ++ } ++ case USER_DEF_NATIVE_LIST_UNION_KIND_S8: { ++ int8List *elem = NULL; ++ for (i = 0, elem = cvalue->s8; elem; elem = elem->next, i++) { ++ g_assert_cmpint(elem->value, ==, i); ++ } ++ break; ++ } ++ case USER_DEF_NATIVE_LIST_UNION_KIND_S16: { ++ int16List *elem = NULL; ++ for (i = 0, elem = cvalue->s16; elem; elem = elem->next, i++) { ++ g_assert_cmpint(elem->value, ==, i); ++ } ++ break; ++ } ++ case USER_DEF_NATIVE_LIST_UNION_KIND_S32: { ++ int32List *elem = NULL; ++ for (i = 0, elem = cvalue->s32; elem; elem = elem->next, i++) { ++ g_assert_cmpint(elem->value, ==, i); ++ } ++ break; ++ } ++ case USER_DEF_NATIVE_LIST_UNION_KIND_S64: { ++ int64List *elem = NULL; ++ for (i = 0, elem = cvalue->s64; elem; elem = elem->next, i++) { ++ g_assert_cmpint(elem->value, ==, i); ++ } ++ break; ++ } ++ case USER_DEF_NATIVE_LIST_UNION_KIND_U8: { ++ uint8List *elem = NULL; ++ for (i = 0, elem = cvalue->u8; elem; elem = elem->next, i++) { ++ g_assert_cmpint(elem->value, ==, i); ++ } ++ break; ++ } ++ case USER_DEF_NATIVE_LIST_UNION_KIND_U16: { ++ uint16List *elem = NULL; ++ for (i = 0, elem = cvalue->u16; elem; elem = elem->next, i++) { ++ g_assert_cmpint(elem->value, ==, i); ++ } ++ break; ++ } ++ case USER_DEF_NATIVE_LIST_UNION_KIND_U32: { ++ uint32List *elem = NULL; ++ for (i = 0, elem = cvalue->u32; elem; elem = elem->next, i++) { ++ g_assert_cmpint(elem->value, ==, i); ++ } ++ break; ++ } ++ case USER_DEF_NATIVE_LIST_UNION_KIND_U64: { ++ uint64List *elem = NULL; ++ for (i = 0, elem = cvalue->u64; elem; elem = elem->next, i++) { ++ g_assert_cmpint(elem->value, ==, i); ++ } ++ break; ++ } ++ default: ++ g_assert(false); ++ } ++ ++ g_string_free(gstr_union, true); ++ g_string_free(gstr_list, true); ++ qapi_free_UserDefNativeListUnion(cvalue); ++} ++ ++static void test_visitor_in_native_list_int(TestInputVisitorData *data, ++ const void *unused) ++{ ++ test_native_list_integer_helper(data, unused, ++ USER_DEF_NATIVE_LIST_UNION_KIND_INTEGER); ++} ++ ++static void test_visitor_in_native_list_int8(TestInputVisitorData *data, ++ const void *unused) ++{ ++ test_native_list_integer_helper(data, unused, ++ USER_DEF_NATIVE_LIST_UNION_KIND_S8); ++} ++ ++static void test_visitor_in_native_list_int16(TestInputVisitorData *data, ++ const void *unused) ++{ ++ test_native_list_integer_helper(data, unused, ++ USER_DEF_NATIVE_LIST_UNION_KIND_S16); ++} ++ ++static void test_visitor_in_native_list_int32(TestInputVisitorData *data, ++ const void *unused) ++{ ++ test_native_list_integer_helper(data, unused, ++ USER_DEF_NATIVE_LIST_UNION_KIND_S32); ++} ++ ++static void test_visitor_in_native_list_int64(TestInputVisitorData *data, ++ const void *unused) ++{ ++ test_native_list_integer_helper(data, unused, ++ USER_DEF_NATIVE_LIST_UNION_KIND_S64); ++} ++ ++static void test_visitor_in_native_list_uint8(TestInputVisitorData *data, ++ const void *unused) ++{ ++ test_native_list_integer_helper(data, unused, ++ USER_DEF_NATIVE_LIST_UNION_KIND_U8); ++} ++ ++static void test_visitor_in_native_list_uint16(TestInputVisitorData *data, ++ const void *unused) ++{ ++ test_native_list_integer_helper(data, unused, ++ USER_DEF_NATIVE_LIST_UNION_KIND_U16); ++} ++ ++static void test_visitor_in_native_list_uint32(TestInputVisitorData *data, ++ const void *unused) ++{ ++ test_native_list_integer_helper(data, unused, ++ USER_DEF_NATIVE_LIST_UNION_KIND_U32); ++} ++ ++static void test_visitor_in_native_list_uint64(TestInputVisitorData *data, ++ const void *unused) ++{ ++ test_native_list_integer_helper(data, unused, ++ USER_DEF_NATIVE_LIST_UNION_KIND_U64); ++} ++ ++static void test_visitor_in_native_list_bool(TestInputVisitorData *data, ++ const void *unused) ++{ ++ UserDefNativeListUnion *cvalue = NULL; ++ boolList *elem = NULL; ++ Error *err = NULL; ++ Visitor *v; ++ GString *gstr_list = g_string_new(""); ++ GString *gstr_union = g_string_new(""); ++ int i; ++ ++ for (i = 0; i < 32; i++) { ++ g_string_append_printf(gstr_list, "%s", ++ (i % 3 == 0) ? "true" : "false"); ++ if (i != 31) { ++ g_string_append(gstr_list, ", "); ++ } ++ } ++ g_string_append_printf(gstr_union, "{ 'type': 'boolean', 'data': [ %s ] }", ++ gstr_list->str); ++ v = visitor_input_test_init_raw(data, gstr_union->str); ++ ++ visit_type_UserDefNativeListUnion(v, &cvalue, NULL, &err); ++ g_assert(err == NULL); ++ g_assert(cvalue != NULL); ++ g_assert_cmpint(cvalue->kind, ==, USER_DEF_NATIVE_LIST_UNION_KIND_BOOLEAN); ++ ++ for (i = 0, elem = cvalue->boolean; elem; elem = elem->next, i++) { ++ g_assert_cmpint(elem->value, ==, (i % 3 == 0) ? 1 : 0); ++ } ++ ++ g_string_free(gstr_union, true); ++ g_string_free(gstr_list, true); ++ qapi_free_UserDefNativeListUnion(cvalue); ++} ++ ++static void test_visitor_in_native_list_string(TestInputVisitorData *data, ++ const void *unused) ++{ ++ UserDefNativeListUnion *cvalue = NULL; ++ strList *elem = NULL; ++ Error *err = NULL; ++ Visitor *v; ++ GString *gstr_list = g_string_new(""); ++ GString *gstr_union = g_string_new(""); ++ int i; ++ ++ for (i = 0; i < 32; i++) { ++ g_string_append_printf(gstr_list, "'%d'", i); ++ if (i != 31) { ++ g_string_append(gstr_list, ", "); ++ } ++ } ++ g_string_append_printf(gstr_union, "{ 'type': 'string', 'data': [ %s ] }", ++ gstr_list->str); ++ v = visitor_input_test_init_raw(data, gstr_union->str); ++ ++ visit_type_UserDefNativeListUnion(v, &cvalue, NULL, &err); ++ g_assert(err == NULL); ++ g_assert(cvalue != NULL); ++ g_assert_cmpint(cvalue->kind, ==, USER_DEF_NATIVE_LIST_UNION_KIND_STRING); ++ ++ for (i = 0, elem = cvalue->string; elem; elem = elem->next, i++) { ++ gchar str[8]; ++ sprintf(str, "%d", i); ++ g_assert_cmpstr(elem->value, ==, str); ++ } ++ ++ g_string_free(gstr_union, true); ++ g_string_free(gstr_list, true); ++ qapi_free_UserDefNativeListUnion(cvalue); ++} ++ ++#define DOUBLE_STR_MAX 16 ++ ++static void test_visitor_in_native_list_number(TestInputVisitorData *data, ++ const void *unused) ++{ ++ UserDefNativeListUnion *cvalue = NULL; ++ numberList *elem = NULL; ++ Error *err = NULL; ++ Visitor *v; ++ GString *gstr_list = g_string_new(""); ++ GString *gstr_union = g_string_new(""); ++ int i; ++ ++ for (i = 0; i < 32; i++) { ++ g_string_append_printf(gstr_list, "%f", (double)i / 3); ++ if (i != 31) { ++ g_string_append(gstr_list, ", "); ++ } ++ } ++ g_string_append_printf(gstr_union, "{ 'type': 'number', 'data': [ %s ] }", ++ gstr_list->str); ++ v = visitor_input_test_init_raw(data, gstr_union->str); ++ ++ visit_type_UserDefNativeListUnion(v, &cvalue, NULL, &err); ++ g_assert(err == NULL); ++ g_assert(cvalue != NULL); ++ g_assert_cmpint(cvalue->kind, ==, USER_DEF_NATIVE_LIST_UNION_KIND_NUMBER); ++ ++ for (i = 0, elem = cvalue->number; elem; elem = elem->next, i++) { ++ GString *double_expected = g_string_new(""); ++ GString *double_actual = g_string_new(""); ++ ++ g_string_printf(double_expected, "%.6f", (double)i / 3); ++ g_string_printf(double_actual, "%.6f", elem->value); ++ g_assert_cmpstr(double_expected->str, ==, double_actual->str); ++ ++ g_string_free(double_expected, true); ++ g_string_free(double_actual, true); ++ } ++ ++ g_string_free(gstr_union, true); ++ g_string_free(gstr_list, true); ++ qapi_free_UserDefNativeListUnion(cvalue); ++} ++ + static void input_visitor_test_add(const char *testpath, + TestInputVisitorData *data, + void (*test_func)(TestInputVisitorData *data, const void *user_data)) +@@ -330,6 +636,38 @@ int main(int argc, char **argv) + &in_visitor_data, test_visitor_in_union); + input_visitor_test_add("/visitor/input/errors", + &in_visitor_data, test_visitor_in_errors); ++ input_visitor_test_add("/visitor/input/native_list/int", ++ &in_visitor_data, ++ test_visitor_in_native_list_int); ++ input_visitor_test_add("/visitor/input/native_list/int8", ++ &in_visitor_data, ++ test_visitor_in_native_list_int8); ++ input_visitor_test_add("/visitor/input/native_list/int16", ++ &in_visitor_data, ++ test_visitor_in_native_list_int16); ++ input_visitor_test_add("/visitor/input/native_list/int32", ++ &in_visitor_data, ++ test_visitor_in_native_list_int32); ++ input_visitor_test_add("/visitor/input/native_list/int64", ++ &in_visitor_data, ++ test_visitor_in_native_list_int64); ++ input_visitor_test_add("/visitor/input/native_list/uint8", ++ &in_visitor_data, ++ test_visitor_in_native_list_uint8); ++ input_visitor_test_add("/visitor/input/native_list/uint16", ++ &in_visitor_data, ++ test_visitor_in_native_list_uint16); ++ input_visitor_test_add("/visitor/input/native_list/uint32", ++ &in_visitor_data, ++ test_visitor_in_native_list_uint32); ++ input_visitor_test_add("/visitor/input/native_list/uint64", ++ &in_visitor_data, test_visitor_in_native_list_uint64); ++ input_visitor_test_add("/visitor/input/native_list/bool", ++ &in_visitor_data, test_visitor_in_native_list_bool); ++ input_visitor_test_add("/visitor/input/native_list/str", ++ &in_visitor_data, test_visitor_in_native_list_string); ++ input_visitor_test_add("/visitor/input/native_list/number", ++ &in_visitor_data, test_visitor_in_native_list_number); + + g_test_run(); + +-- +1.7.11.7 + diff --git a/SOURCES/kvm-qapi-add-native-list-coverage-for-QMP-output-visitor.patch b/SOURCES/kvm-qapi-add-native-list-coverage-for-QMP-output-visitor.patch new file mode 100644 index 0000000..52d5d7e --- /dev/null +++ b/SOURCES/kvm-qapi-add-native-list-coverage-for-QMP-output-visitor.patch @@ -0,0 +1,419 @@ +From 45c69be7596bc6d158f56ec94c5f465a2030a8e5 Mon Sep 17 00:00:00 2001 +Message-Id: <45c69be7596bc6d158f56ec94c5f465a2030a8e5.1387369730.git.minovotn@redhat.com> +In-Reply-To: <091eecc4fa42754760dfff393dabcc2b444e9693.1387369730.git.minovotn@redhat.com> +References: <091eecc4fa42754760dfff393dabcc2b444e9693.1387369730.git.minovotn@redhat.com> +From: Markus Armbruster +Date: Tue, 10 Dec 2013 15:29:08 +0100 +Subject: [PATCH 08/21] qapi: add native list coverage for QMP output visitor + tests + +RH-Author: Markus Armbruster +Message-id: <1386689361-30281-6-git-send-email-armbru@redhat.com> +Patchwork-id: 56135 +O-Subject: [PATCH 7.0 qemu-kvm 05/18] qapi: add native list coverage for QMP output visitor tests +Bugzilla: 997915 +RH-Acked-by: Laszlo Ersek +RH-Acked-by: Kevin Wolf +RH-Acked-by: Luiz Capitulino + +From: Michael Roth + +This exercises schema-generated visitors for native list types and does +some sanity checking on validity of serialized data. + +Signed-off-by: Michael Roth +Reviewed-by: Laszlo Ersek +Reviewed-by: Amos Kong +Signed-off-by: Luiz Capitulino +(cherry picked from commit 83c84667f57637fe5a7a6fc9905d6a9e9589d3e5) +Signed-off-by: Markus Armbruster +--- + qapi-schema-test.json | 15 ++ + tests/test-qmp-output-visitor.c | 332 ++++++++++++++++++++++++++++++++++++++++ + 2 files changed, 347 insertions(+) + +Signed-off-by: Michal Novotny +--- + qapi-schema-test.json | 15 ++ + tests/test-qmp-output-visitor.c | 332 ++++++++++++++++++++++++++++++++++++++++ + 2 files changed, 347 insertions(+) + +diff --git a/qapi-schema-test.json b/qapi-schema-test.json +index 9eae350..4434fa3 100644 +--- a/qapi-schema-test.json ++++ b/qapi-schema-test.json +@@ -32,6 +32,21 @@ + { 'union': 'UserDefUnion', + 'data': { 'a' : 'UserDefA', 'b' : 'UserDefB' } } + ++# for testing native lists ++{ 'union': 'UserDefNativeListUnion', ++ 'data': { 'integer': ['int'], ++ 's8': ['int8'], ++ 's16': ['int16'], ++ 's32': ['int32'], ++ 's64': ['int64'], ++ 'u8': ['uint8'], ++ 'u16': ['uint16'], ++ 'u32': ['uint32'], ++ 'u64': ['uint64'], ++ 'number': ['number'], ++ 'boolean': ['bool'], ++ 'string': ['str'] } } ++ + # testing commands + { 'command': 'user_def_cmd', 'data': {} } + { 'command': 'user_def_cmd1', 'data': {'ud1a': 'UserDefOne'} } +diff --git a/tests/test-qmp-output-visitor.c b/tests/test-qmp-output-visitor.c +index 71367e6..0942a41 100644 +--- a/tests/test-qmp-output-visitor.c ++++ b/tests/test-qmp-output-visitor.c +@@ -431,6 +431,314 @@ static void test_visitor_out_union(TestOutputVisitorData *data, + QDECREF(qdict); + } + ++static void init_native_list(UserDefNativeListUnion *cvalue) ++{ ++ int i; ++ switch (cvalue->kind) { ++ case USER_DEF_NATIVE_LIST_UNION_KIND_INTEGER: { ++ intList **list = &cvalue->integer; ++ for (i = 0; i < 32; i++) { ++ *list = g_new0(intList, 1); ++ (*list)->value = i; ++ (*list)->next = NULL; ++ list = &(*list)->next; ++ } ++ break; ++ } ++ case USER_DEF_NATIVE_LIST_UNION_KIND_S8: { ++ int8List **list = &cvalue->s8; ++ for (i = 0; i < 32; i++) { ++ *list = g_new0(int8List, 1); ++ (*list)->value = i; ++ (*list)->next = NULL; ++ list = &(*list)->next; ++ } ++ break; ++ } ++ case USER_DEF_NATIVE_LIST_UNION_KIND_S16: { ++ int16List **list = &cvalue->s16; ++ for (i = 0; i < 32; i++) { ++ *list = g_new0(int16List, 1); ++ (*list)->value = i; ++ (*list)->next = NULL; ++ list = &(*list)->next; ++ } ++ break; ++ } ++ case USER_DEF_NATIVE_LIST_UNION_KIND_S32: { ++ int32List **list = &cvalue->s32; ++ for (i = 0; i < 32; i++) { ++ *list = g_new0(int32List, 1); ++ (*list)->value = i; ++ (*list)->next = NULL; ++ list = &(*list)->next; ++ } ++ break; ++ } ++ case USER_DEF_NATIVE_LIST_UNION_KIND_S64: { ++ int64List **list = &cvalue->s64; ++ for (i = 0; i < 32; i++) { ++ *list = g_new0(int64List, 1); ++ (*list)->value = i; ++ (*list)->next = NULL; ++ list = &(*list)->next; ++ } ++ break; ++ } ++ case USER_DEF_NATIVE_LIST_UNION_KIND_U8: { ++ uint8List **list = &cvalue->u8; ++ for (i = 0; i < 32; i++) { ++ *list = g_new0(uint8List, 1); ++ (*list)->value = i; ++ (*list)->next = NULL; ++ list = &(*list)->next; ++ } ++ break; ++ } ++ case USER_DEF_NATIVE_LIST_UNION_KIND_U16: { ++ uint16List **list = &cvalue->u16; ++ for (i = 0; i < 32; i++) { ++ *list = g_new0(uint16List, 1); ++ (*list)->value = i; ++ (*list)->next = NULL; ++ list = &(*list)->next; ++ } ++ break; ++ } ++ case USER_DEF_NATIVE_LIST_UNION_KIND_U32: { ++ uint32List **list = &cvalue->u32; ++ for (i = 0; i < 32; i++) { ++ *list = g_new0(uint32List, 1); ++ (*list)->value = i; ++ (*list)->next = NULL; ++ list = &(*list)->next; ++ } ++ break; ++ } ++ case USER_DEF_NATIVE_LIST_UNION_KIND_U64: { ++ uint64List **list = &cvalue->u64; ++ for (i = 0; i < 32; i++) { ++ *list = g_new0(uint64List, 1); ++ (*list)->value = i; ++ (*list)->next = NULL; ++ list = &(*list)->next; ++ } ++ break; ++ } ++ case USER_DEF_NATIVE_LIST_UNION_KIND_BOOLEAN: { ++ boolList **list = &cvalue->boolean; ++ for (i = 0; i < 32; i++) { ++ *list = g_new0(boolList, 1); ++ (*list)->value = (i % 3 == 0); ++ (*list)->next = NULL; ++ list = &(*list)->next; ++ } ++ break; ++ } ++ case USER_DEF_NATIVE_LIST_UNION_KIND_STRING: { ++ strList **list = &cvalue->string; ++ for (i = 0; i < 32; i++) { ++ *list = g_new0(strList, 1); ++ (*list)->value = g_strdup_printf("%d", i); ++ (*list)->next = NULL; ++ list = &(*list)->next; ++ } ++ break; ++ } ++ case USER_DEF_NATIVE_LIST_UNION_KIND_NUMBER: { ++ numberList **list = &cvalue->number; ++ for (i = 0; i < 32; i++) { ++ *list = g_new0(numberList, 1); ++ (*list)->value = (double)i / 3; ++ (*list)->next = NULL; ++ list = &(*list)->next; ++ } ++ break; ++ } ++ default: ++ g_assert(false); ++ } ++} ++ ++static void check_native_list(QObject *qobj, ++ UserDefNativeListUnionKind kind) ++{ ++ QDict *qdict; ++ QList *qlist; ++ int i; ++ ++ g_assert(qobj); ++ g_assert(qobject_type(qobj) == QTYPE_QDICT); ++ qdict = qobject_to_qdict(qobj); ++ g_assert(qdict); ++ g_assert(qdict_haskey(qdict, "data")); ++ qlist = qlist_copy(qobject_to_qlist(qdict_get(qdict, "data"))); ++ ++ switch (kind) { ++ case USER_DEF_NATIVE_LIST_UNION_KIND_S8: ++ case USER_DEF_NATIVE_LIST_UNION_KIND_S16: ++ case USER_DEF_NATIVE_LIST_UNION_KIND_S32: ++ case USER_DEF_NATIVE_LIST_UNION_KIND_S64: ++ case USER_DEF_NATIVE_LIST_UNION_KIND_U8: ++ case USER_DEF_NATIVE_LIST_UNION_KIND_U16: ++ case USER_DEF_NATIVE_LIST_UNION_KIND_U32: ++ case USER_DEF_NATIVE_LIST_UNION_KIND_U64: ++ /* all integer elements in JSON arrays get stored into QInts when ++ * we convert to QObjects, so we can check them all in the same ++ * fashion, so simply fall through here ++ */ ++ case USER_DEF_NATIVE_LIST_UNION_KIND_INTEGER: ++ for (i = 0; i < 32; i++) { ++ QObject *tmp; ++ QInt *qvalue; ++ tmp = qlist_peek(qlist); ++ g_assert(tmp); ++ qvalue = qobject_to_qint(tmp); ++ g_assert_cmpint(qint_get_int(qvalue), ==, i); ++ qobject_decref(qlist_pop(qlist)); ++ } ++ break; ++ case USER_DEF_NATIVE_LIST_UNION_KIND_BOOLEAN: ++ for (i = 0; i < 32; i++) { ++ QObject *tmp; ++ QBool *qvalue; ++ tmp = qlist_peek(qlist); ++ g_assert(tmp); ++ qvalue = qobject_to_qbool(tmp); ++ g_assert_cmpint(qbool_get_int(qvalue), ==, (i % 3 == 0) ? 1 : 0); ++ qobject_decref(qlist_pop(qlist)); ++ } ++ break; ++ case USER_DEF_NATIVE_LIST_UNION_KIND_STRING: ++ for (i = 0; i < 32; i++) { ++ QObject *tmp; ++ QString *qvalue; ++ gchar str[8]; ++ tmp = qlist_peek(qlist); ++ g_assert(tmp); ++ qvalue = qobject_to_qstring(tmp); ++ sprintf(str, "%d", i); ++ g_assert_cmpstr(qstring_get_str(qvalue), ==, str); ++ qobject_decref(qlist_pop(qlist)); ++ } ++ break; ++ case USER_DEF_NATIVE_LIST_UNION_KIND_NUMBER: ++ for (i = 0; i < 32; i++) { ++ QObject *tmp; ++ QFloat *qvalue; ++ GString *double_expected = g_string_new(""); ++ GString *double_actual = g_string_new(""); ++ ++ tmp = qlist_peek(qlist); ++ g_assert(tmp); ++ qvalue = qobject_to_qfloat(tmp); ++ g_string_printf(double_expected, "%.6f", (double)i / 3); ++ g_string_printf(double_actual, "%.6f", qfloat_get_double(qvalue)); ++ g_assert_cmpstr(double_actual->str, ==, double_expected->str); ++ ++ qobject_decref(qlist_pop(qlist)); ++ g_string_free(double_expected, true); ++ g_string_free(double_actual, true); ++ } ++ break; ++ default: ++ g_assert(false); ++ } ++ QDECREF(qlist); ++} ++ ++static void test_native_list(TestOutputVisitorData *data, ++ const void *unused, ++ UserDefNativeListUnionKind kind) ++{ ++ UserDefNativeListUnion *cvalue = g_new0(UserDefNativeListUnion, 1); ++ Error *err = NULL; ++ QObject *obj; ++ ++ cvalue->kind = kind; ++ init_native_list(cvalue); ++ ++ visit_type_UserDefNativeListUnion(data->ov, &cvalue, NULL, &err); ++ g_assert(err == NULL); ++ ++ obj = qmp_output_get_qobject(data->qov); ++ check_native_list(obj, cvalue->kind); ++ qapi_free_UserDefNativeListUnion(cvalue); ++ qobject_decref(obj); ++} ++ ++static void test_visitor_out_native_list_int(TestOutputVisitorData *data, ++ const void *unused) ++{ ++ test_native_list(data, unused, USER_DEF_NATIVE_LIST_UNION_KIND_INTEGER); ++} ++ ++static void test_visitor_out_native_list_int8(TestOutputVisitorData *data, ++ const void *unused) ++{ ++ test_native_list(data, unused, USER_DEF_NATIVE_LIST_UNION_KIND_S8); ++} ++ ++static void test_visitor_out_native_list_int16(TestOutputVisitorData *data, ++ const void *unused) ++{ ++ test_native_list(data, unused, USER_DEF_NATIVE_LIST_UNION_KIND_S16); ++} ++ ++static void test_visitor_out_native_list_int32(TestOutputVisitorData *data, ++ const void *unused) ++{ ++ test_native_list(data, unused, USER_DEF_NATIVE_LIST_UNION_KIND_S32); ++} ++ ++static void test_visitor_out_native_list_int64(TestOutputVisitorData *data, ++ const void *unused) ++{ ++ test_native_list(data, unused, USER_DEF_NATIVE_LIST_UNION_KIND_S64); ++} ++ ++static void test_visitor_out_native_list_uint8(TestOutputVisitorData *data, ++ const void *unused) ++{ ++ test_native_list(data, unused, USER_DEF_NATIVE_LIST_UNION_KIND_U8); ++} ++ ++static void test_visitor_out_native_list_uint16(TestOutputVisitorData *data, ++ const void *unused) ++{ ++ test_native_list(data, unused, USER_DEF_NATIVE_LIST_UNION_KIND_U16); ++} ++ ++static void test_visitor_out_native_list_uint32(TestOutputVisitorData *data, ++ const void *unused) ++{ ++ test_native_list(data, unused, USER_DEF_NATIVE_LIST_UNION_KIND_U32); ++} ++ ++static void test_visitor_out_native_list_uint64(TestOutputVisitorData *data, ++ const void *unused) ++{ ++ test_native_list(data, unused, USER_DEF_NATIVE_LIST_UNION_KIND_U64); ++} ++ ++static void test_visitor_out_native_list_bool(TestOutputVisitorData *data, ++ const void *unused) ++{ ++ test_native_list(data, unused, USER_DEF_NATIVE_LIST_UNION_KIND_BOOLEAN); ++} ++ ++static void test_visitor_out_native_list_str(TestOutputVisitorData *data, ++ const void *unused) ++{ ++ test_native_list(data, unused, USER_DEF_NATIVE_LIST_UNION_KIND_STRING); ++} ++ ++static void test_visitor_out_native_list_number(TestOutputVisitorData *data, ++ const void *unused) ++{ ++ test_native_list(data, unused, USER_DEF_NATIVE_LIST_UNION_KIND_NUMBER); ++} ++ + static void output_visitor_test_add(const char *testpath, + TestOutputVisitorData *data, + void (*test_func)(TestOutputVisitorData *data, const void *user_data)) +@@ -471,6 +779,30 @@ int main(int argc, char **argv) + &out_visitor_data, test_visitor_out_list_qapi_free); + output_visitor_test_add("/visitor/output/union", + &out_visitor_data, test_visitor_out_union); ++ output_visitor_test_add("/visitor/output/native_list/int", ++ &out_visitor_data, test_visitor_out_native_list_int); ++ output_visitor_test_add("/visitor/output/native_list/int8", ++ &out_visitor_data, test_visitor_out_native_list_int8); ++ output_visitor_test_add("/visitor/output/native_list/int16", ++ &out_visitor_data, test_visitor_out_native_list_int16); ++ output_visitor_test_add("/visitor/output/native_list/int32", ++ &out_visitor_data, test_visitor_out_native_list_int32); ++ output_visitor_test_add("/visitor/output/native_list/int64", ++ &out_visitor_data, test_visitor_out_native_list_int64); ++ output_visitor_test_add("/visitor/output/native_list/uint8", ++ &out_visitor_data, test_visitor_out_native_list_uint8); ++ output_visitor_test_add("/visitor/output/native_list/uint16", ++ &out_visitor_data, test_visitor_out_native_list_uint16); ++ output_visitor_test_add("/visitor/output/native_list/uint32", ++ &out_visitor_data, test_visitor_out_native_list_uint32); ++ output_visitor_test_add("/visitor/output/native_list/uint64", ++ &out_visitor_data, test_visitor_out_native_list_uint64); ++ output_visitor_test_add("/visitor/output/native_list/bool", ++ &out_visitor_data, test_visitor_out_native_list_bool); ++ output_visitor_test_add("/visitor/output/native_list/string", ++ &out_visitor_data, test_visitor_out_native_list_str); ++ output_visitor_test_add("/visitor/output/native_list/number", ++ &out_visitor_data, test_visitor_out_native_list_number); + + g_test_run(); + +-- +1.7.11.7 + diff --git a/SOURCES/kvm-qapi-add-native-list-coverage-for-visitor-serializat.patch b/SOURCES/kvm-qapi-add-native-list-coverage-for-visitor-serializat.patch new file mode 100644 index 0000000..4e874cc --- /dev/null +++ b/SOURCES/kvm-qapi-add-native-list-coverage-for-visitor-serializat.patch @@ -0,0 +1,551 @@ +From ee8b63caea8d46e37f7229fc420f4a61ed72a9a6 Mon Sep 17 00:00:00 2001 +Message-Id: +In-Reply-To: <091eecc4fa42754760dfff393dabcc2b444e9693.1387369730.git.minovotn@redhat.com> +References: <091eecc4fa42754760dfff393dabcc2b444e9693.1387369730.git.minovotn@redhat.com> +From: Markus Armbruster +Date: Tue, 10 Dec 2013 15:29:07 +0100 +Subject: [PATCH 07/21] qapi: add native list coverage for visitor + serialization tests + +RH-Author: Markus Armbruster +Message-id: <1386689361-30281-5-git-send-email-armbru@redhat.com> +Patchwork-id: 56124 +O-Subject: [PATCH 7.0 qemu-kvm 04/18] qapi: add native list coverage for visitor serialization tests +Bugzilla: 997915 +RH-Acked-by: Laszlo Ersek +RH-Acked-by: Kevin Wolf +RH-Acked-by: Luiz Capitulino + +From: Michael Roth + +Signed-off-by: Michael Roth +Reviewed-by: Laszlo Ersek +Reviewed-by: Amos Kong +Signed-off-by: Luiz Capitulino +(cherry picked from commit 8addacddfece619f1795fcf6cb9a3c49f800e7b9) +Signed-off-by: Markus Armbruster +--- + tests/test-visitor-serialization.c | 451 +++++++++++++++++++++++++++++++++++-- + 1 file changed, 433 insertions(+), 18 deletions(-) + +Signed-off-by: Michal Novotny +--- + tests/test-visitor-serialization.c | 451 +++++++++++++++++++++++++++++++++++-- + 1 file changed, 433 insertions(+), 18 deletions(-) + +diff --git a/tests/test-visitor-serialization.c b/tests/test-visitor-serialization.c +index fed6810..ee7916b 100644 +--- a/tests/test-visitor-serialization.c ++++ b/tests/test-visitor-serialization.c +@@ -23,6 +23,25 @@ + #include "qapi/qmp-output-visitor.h" + #include "qapi/string-input-visitor.h" + #include "qapi/string-output-visitor.h" ++#include "qapi-types.h" ++#include "qapi-visit.h" ++#include "qapi/dealloc-visitor.h" ++ ++enum PrimitiveTypeKind { ++ PTYPE_STRING = 0, ++ PTYPE_BOOLEAN, ++ PTYPE_NUMBER, ++ PTYPE_INTEGER, ++ PTYPE_U8, ++ PTYPE_U16, ++ PTYPE_U32, ++ PTYPE_U64, ++ PTYPE_S8, ++ PTYPE_S16, ++ PTYPE_S32, ++ PTYPE_S64, ++ PTYPE_EOL, ++}; + + typedef struct PrimitiveType { + union { +@@ -40,26 +59,42 @@ typedef struct PrimitiveType { + int64_t s64; + intmax_t max; + } value; +- enum { +- PTYPE_STRING = 0, +- PTYPE_BOOLEAN, +- PTYPE_NUMBER, +- PTYPE_INTEGER, +- PTYPE_U8, +- PTYPE_U16, +- PTYPE_U32, +- PTYPE_U64, +- PTYPE_S8, +- PTYPE_S16, +- PTYPE_S32, +- PTYPE_S64, +- PTYPE_EOL, +- } type; ++ enum PrimitiveTypeKind type; + const char *description; + } PrimitiveType; + ++typedef struct PrimitiveList { ++ union { ++ strList *strings; ++ boolList *booleans; ++ numberList *numbers; ++ intList *integers; ++ int8List *s8_integers; ++ int16List *s16_integers; ++ int32List *s32_integers; ++ int64List *s64_integers; ++ uint8List *u8_integers; ++ uint16List *u16_integers; ++ uint32List *u32_integers; ++ uint64List *u64_integers; ++ } value; ++ enum PrimitiveTypeKind type; ++ const char *description; ++} PrimitiveList; ++ + /* test helpers */ + ++typedef void (*VisitorFunc)(Visitor *v, void **native, Error **errp); ++ ++static void dealloc_helper(void *native_in, VisitorFunc visit, Error **errp) ++{ ++ QapiDeallocVisitor *qdv = qapi_dealloc_visitor_new(); ++ ++ visit(qapi_dealloc_get_visitor(qdv), &native_in, errp); ++ ++ qapi_dealloc_visitor_cleanup(qdv); ++} ++ + static void visit_primitive_type(Visitor *v, void **native, Error **errp) + { + PrimitiveType *pt = *native; +@@ -105,6 +140,51 @@ static void visit_primitive_type(Visitor *v, void **native, Error **errp) + } + } + ++static void visit_primitive_list(Visitor *v, void **native, Error **errp) ++{ ++ PrimitiveList *pl = *native; ++ switch (pl->type) { ++ case PTYPE_STRING: ++ visit_type_strList(v, &pl->value.strings, NULL, errp); ++ break; ++ case PTYPE_BOOLEAN: ++ visit_type_boolList(v, &pl->value.booleans, NULL, errp); ++ break; ++ case PTYPE_NUMBER: ++ visit_type_numberList(v, &pl->value.numbers, NULL, errp); ++ break; ++ case PTYPE_INTEGER: ++ visit_type_intList(v, &pl->value.integers, NULL, errp); ++ break; ++ case PTYPE_S8: ++ visit_type_int8List(v, &pl->value.s8_integers, NULL, errp); ++ break; ++ case PTYPE_S16: ++ visit_type_int16List(v, &pl->value.s16_integers, NULL, errp); ++ break; ++ case PTYPE_S32: ++ visit_type_int32List(v, &pl->value.s32_integers, NULL, errp); ++ break; ++ case PTYPE_S64: ++ visit_type_int64List(v, &pl->value.s64_integers, NULL, errp); ++ break; ++ case PTYPE_U8: ++ visit_type_uint8List(v, &pl->value.u8_integers, NULL, errp); ++ break; ++ case PTYPE_U16: ++ visit_type_uint16List(v, &pl->value.u16_integers, NULL, errp); ++ break; ++ case PTYPE_U32: ++ visit_type_uint32List(v, &pl->value.u32_integers, NULL, errp); ++ break; ++ case PTYPE_U64: ++ visit_type_uint64List(v, &pl->value.u64_integers, NULL, errp); ++ break; ++ default: ++ g_assert(false); ++ } ++} ++ + typedef struct TestStruct + { + int64_t integer; +@@ -206,12 +286,11 @@ static void visit_nested_struct_list(Visitor *v, void **native, Error **errp) + + /* test cases */ + +-typedef void (*VisitorFunc)(Visitor *v, void **native, Error **errp); +- + typedef enum VisitorCapabilities { + VCAP_PRIMITIVES = 1, + VCAP_STRUCTURES = 2, + VCAP_LISTS = 4, ++ VCAP_PRIMITIVE_LISTS = 8, + } VisitorCapabilities; + + typedef struct SerializeOps { +@@ -270,6 +349,328 @@ static void test_primitives(gconstpointer opaque) + g_free(pt_copy); + } + ++static void test_primitive_lists(gconstpointer opaque) ++{ ++ TestArgs *args = (TestArgs *) opaque; ++ const SerializeOps *ops = args->ops; ++ PrimitiveType *pt = args->test_data; ++ PrimitiveList pl = { .value = { 0 } }; ++ PrimitiveList pl_copy = { .value = { 0 } }; ++ PrimitiveList *pl_copy_ptr = &pl_copy; ++ Error *err = NULL; ++ void *serialize_data; ++ void *cur_head = NULL; ++ int i; ++ ++ pl.type = pl_copy.type = pt->type; ++ ++ /* build up our list of primitive types */ ++ for (i = 0; i < 32; i++) { ++ switch (pl.type) { ++ case PTYPE_STRING: { ++ strList *tmp = g_new0(strList, 1); ++ tmp->value = g_strdup(pt->value.string); ++ if (pl.value.strings == NULL) { ++ pl.value.strings = tmp; ++ } else { ++ tmp->next = pl.value.strings; ++ pl.value.strings = tmp; ++ } ++ break; ++ } ++ case PTYPE_INTEGER: { ++ intList *tmp = g_new0(intList, 1); ++ tmp->value = pt->value.integer; ++ if (pl.value.integers == NULL) { ++ pl.value.integers = tmp; ++ } else { ++ tmp->next = pl.value.integers; ++ pl.value.integers = tmp; ++ } ++ break; ++ } ++ case PTYPE_S8: { ++ int8List *tmp = g_new0(int8List, 1); ++ tmp->value = pt->value.s8; ++ if (pl.value.s8_integers == NULL) { ++ pl.value.s8_integers = tmp; ++ } else { ++ tmp->next = pl.value.s8_integers; ++ pl.value.s8_integers = tmp; ++ } ++ break; ++ } ++ case PTYPE_S16: { ++ int16List *tmp = g_new0(int16List, 1); ++ tmp->value = pt->value.s16; ++ if (pl.value.s16_integers == NULL) { ++ pl.value.s16_integers = tmp; ++ } else { ++ tmp->next = pl.value.s16_integers; ++ pl.value.s16_integers = tmp; ++ } ++ break; ++ } ++ case PTYPE_S32: { ++ int32List *tmp = g_new0(int32List, 1); ++ tmp->value = pt->value.s32; ++ if (pl.value.s32_integers == NULL) { ++ pl.value.s32_integers = tmp; ++ } else { ++ tmp->next = pl.value.s32_integers; ++ pl.value.s32_integers = tmp; ++ } ++ break; ++ } ++ case PTYPE_S64: { ++ int64List *tmp = g_new0(int64List, 1); ++ tmp->value = pt->value.s64; ++ if (pl.value.s64_integers == NULL) { ++ pl.value.s64_integers = tmp; ++ } else { ++ tmp->next = pl.value.s64_integers; ++ pl.value.s64_integers = tmp; ++ } ++ break; ++ } ++ case PTYPE_U8: { ++ uint8List *tmp = g_new0(uint8List, 1); ++ tmp->value = pt->value.u8; ++ if (pl.value.u8_integers == NULL) { ++ pl.value.u8_integers = tmp; ++ } else { ++ tmp->next = pl.value.u8_integers; ++ pl.value.u8_integers = tmp; ++ } ++ break; ++ } ++ case PTYPE_U16: { ++ uint16List *tmp = g_new0(uint16List, 1); ++ tmp->value = pt->value.u16; ++ if (pl.value.u16_integers == NULL) { ++ pl.value.u16_integers = tmp; ++ } else { ++ tmp->next = pl.value.u16_integers; ++ pl.value.u16_integers = tmp; ++ } ++ break; ++ } ++ case PTYPE_U32: { ++ uint32List *tmp = g_new0(uint32List, 1); ++ tmp->value = pt->value.u32; ++ if (pl.value.u32_integers == NULL) { ++ pl.value.u32_integers = tmp; ++ } else { ++ tmp->next = pl.value.u32_integers; ++ pl.value.u32_integers = tmp; ++ } ++ break; ++ } ++ case PTYPE_U64: { ++ uint64List *tmp = g_new0(uint64List, 1); ++ tmp->value = pt->value.u64; ++ if (pl.value.u64_integers == NULL) { ++ pl.value.u64_integers = tmp; ++ } else { ++ tmp->next = pl.value.u64_integers; ++ pl.value.u64_integers = tmp; ++ } ++ break; ++ } ++ case PTYPE_NUMBER: { ++ numberList *tmp = g_new0(numberList, 1); ++ tmp->value = pt->value.number; ++ if (pl.value.numbers == NULL) { ++ pl.value.numbers = tmp; ++ } else { ++ tmp->next = pl.value.numbers; ++ pl.value.numbers = tmp; ++ } ++ break; ++ } ++ case PTYPE_BOOLEAN: { ++ boolList *tmp = g_new0(boolList, 1); ++ tmp->value = pt->value.boolean; ++ if (pl.value.booleans == NULL) { ++ pl.value.booleans = tmp; ++ } else { ++ tmp->next = pl.value.booleans; ++ pl.value.booleans = tmp; ++ } ++ break; ++ } ++ default: ++ g_assert(0); ++ } ++ } ++ ++ ops->serialize((void **)&pl, &serialize_data, visit_primitive_list, &err); ++ ops->deserialize((void **)&pl_copy_ptr, serialize_data, visit_primitive_list, &err); ++ ++ g_assert(err == NULL); ++ i = 0; ++ ++ /* compare our deserialized list of primitives to the original */ ++ do { ++ switch (pl_copy.type) { ++ case PTYPE_STRING: { ++ strList *ptr; ++ if (cur_head) { ++ ptr = cur_head; ++ cur_head = ptr->next; ++ } else { ++ cur_head = ptr = pl_copy.value.strings; ++ } ++ g_assert_cmpstr(pt->value.string, ==, ptr->value); ++ break; ++ } ++ case PTYPE_INTEGER: { ++ intList *ptr; ++ if (cur_head) { ++ ptr = cur_head; ++ cur_head = ptr->next; ++ } else { ++ cur_head = ptr = pl_copy.value.integers; ++ } ++ g_assert_cmpint(pt->value.integer, ==, ptr->value); ++ break; ++ } ++ case PTYPE_S8: { ++ int8List *ptr; ++ if (cur_head) { ++ ptr = cur_head; ++ cur_head = ptr->next; ++ } else { ++ cur_head = ptr = pl_copy.value.s8_integers; ++ } ++ g_assert_cmpint(pt->value.s8, ==, ptr->value); ++ break; ++ } ++ case PTYPE_S16: { ++ int16List *ptr; ++ if (cur_head) { ++ ptr = cur_head; ++ cur_head = ptr->next; ++ } else { ++ cur_head = ptr = pl_copy.value.s16_integers; ++ } ++ g_assert_cmpint(pt->value.s16, ==, ptr->value); ++ break; ++ } ++ case PTYPE_S32: { ++ int32List *ptr; ++ if (cur_head) { ++ ptr = cur_head; ++ cur_head = ptr->next; ++ } else { ++ cur_head = ptr = pl_copy.value.s32_integers; ++ } ++ g_assert_cmpint(pt->value.s32, ==, ptr->value); ++ break; ++ } ++ case PTYPE_S64: { ++ int64List *ptr; ++ if (cur_head) { ++ ptr = cur_head; ++ cur_head = ptr->next; ++ } else { ++ cur_head = ptr = pl_copy.value.s64_integers; ++ } ++ g_assert_cmpint(pt->value.s64, ==, ptr->value); ++ break; ++ } ++ case PTYPE_U8: { ++ uint8List *ptr; ++ if (cur_head) { ++ ptr = cur_head; ++ cur_head = ptr->next; ++ } else { ++ cur_head = ptr = pl_copy.value.u8_integers; ++ } ++ g_assert_cmpint(pt->value.u8, ==, ptr->value); ++ break; ++ } ++ case PTYPE_U16: { ++ uint16List *ptr; ++ if (cur_head) { ++ ptr = cur_head; ++ cur_head = ptr->next; ++ } else { ++ cur_head = ptr = pl_copy.value.u16_integers; ++ } ++ g_assert_cmpint(pt->value.u16, ==, ptr->value); ++ break; ++ } ++ case PTYPE_U32: { ++ uint32List *ptr; ++ if (cur_head) { ++ ptr = cur_head; ++ cur_head = ptr->next; ++ } else { ++ cur_head = ptr = pl_copy.value.u32_integers; ++ } ++ g_assert_cmpint(pt->value.u32, ==, ptr->value); ++ break; ++ } ++ case PTYPE_U64: { ++ uint64List *ptr; ++ if (cur_head) { ++ ptr = cur_head; ++ cur_head = ptr->next; ++ } else { ++ cur_head = ptr = pl_copy.value.u64_integers; ++ } ++ g_assert_cmpint(pt->value.u64, ==, ptr->value); ++ break; ++ } ++ case PTYPE_NUMBER: { ++ numberList *ptr; ++ GString *double_expected = g_string_new(""); ++ GString *double_actual = g_string_new(""); ++ if (cur_head) { ++ ptr = cur_head; ++ cur_head = ptr->next; ++ } else { ++ cur_head = ptr = pl_copy.value.numbers; ++ } ++ /* we serialize with %f for our reference visitors, so rather than ++ * fuzzy floating math to test "equality", just compare the ++ * formatted values ++ */ ++ g_string_printf(double_expected, "%.6f", pt->value.number); ++ g_string_printf(double_actual, "%.6f", ptr->value); ++ g_assert_cmpstr(double_actual->str, ==, double_expected->str); ++ g_string_free(double_expected, true); ++ g_string_free(double_actual, true); ++ break; ++ } ++ case PTYPE_BOOLEAN: { ++ boolList *ptr; ++ if (cur_head) { ++ ptr = cur_head; ++ cur_head = ptr->next; ++ } else { ++ cur_head = ptr = pl_copy.value.booleans; ++ } ++ g_assert_cmpint(!!pt->value.boolean, ==, !!ptr->value); ++ break; ++ } ++ default: ++ g_assert(0); ++ } ++ i++; ++ } while (cur_head); ++ ++ g_assert_cmpint(i, ==, 33); ++ ++ ops->cleanup(serialize_data); ++ dealloc_helper(&pl, visit_primitive_list, &err); ++ g_assert(!err); ++ dealloc_helper(&pl_copy, visit_primitive_list, &err); ++ g_assert(!err); ++ g_free(args); ++} ++ + static void test_struct(gconstpointer opaque) + { + TestArgs *args = (TestArgs *) opaque; +@@ -719,7 +1120,8 @@ static const SerializeOps visitors[] = { + .serialize = qmp_serialize, + .deserialize = qmp_deserialize, + .cleanup = qmp_cleanup, +- .caps = VCAP_PRIMITIVES | VCAP_STRUCTURES | VCAP_LISTS ++ .caps = VCAP_PRIMITIVES | VCAP_STRUCTURES | VCAP_LISTS | ++ VCAP_PRIMITIVE_LISTS + }, + { + .type = "String", +@@ -773,6 +1175,19 @@ static void add_visitor_type(const SerializeOps *ops) + args->test_data = NULL; + g_test_add_data_func(testname, args, test_nested_struct_list); + } ++ ++ if (ops->caps & VCAP_PRIMITIVE_LISTS) { ++ i = 0; ++ while (pt_values[i].type != PTYPE_EOL) { ++ sprintf(testname, "%s/primitive_list/%s", testname_prefix, ++ pt_values[i].description); ++ args = g_malloc0(sizeof(*args)); ++ args->ops = ops; ++ args->test_data = &pt_values[i]; ++ g_test_add_data_func(testname, args, test_primitive_lists); ++ i++; ++ } ++ } + } + + int main(int argc, char **argv) +-- +1.7.11.7 + diff --git a/SOURCES/kvm-qapi-fix-visitor-serialization-tests-for-numbers-dou.patch b/SOURCES/kvm-qapi-fix-visitor-serialization-tests-for-numbers-dou.patch new file mode 100644 index 0000000..fee1da7 --- /dev/null +++ b/SOURCES/kvm-qapi-fix-visitor-serialization-tests-for-numbers-dou.patch @@ -0,0 +1,101 @@ +From e9f800ec6e87d1fee21c59dc83236456ee7f91f8 Mon Sep 17 00:00:00 2001 +Message-Id: +In-Reply-To: <091eecc4fa42754760dfff393dabcc2b444e9693.1387369730.git.minovotn@redhat.com> +References: <091eecc4fa42754760dfff393dabcc2b444e9693.1387369730.git.minovotn@redhat.com> +From: Markus Armbruster +Date: Tue, 10 Dec 2013 15:29:06 +0100 +Subject: [PATCH 06/21] qapi: fix visitor serialization tests for + numbers/doubles + +RH-Author: Markus Armbruster +Message-id: <1386689361-30281-4-git-send-email-armbru@redhat.com> +Patchwork-id: 56121 +O-Subject: [PATCH 7.0 qemu-kvm 03/18] qapi: fix visitor serialization tests for numbers/doubles +Bugzilla: 997915 +RH-Acked-by: Laszlo Ersek +RH-Acked-by: Kevin Wolf +RH-Acked-by: Luiz Capitulino + +From: Michael Roth + +We never actually stored the stringified double values into the strings +before we did the comparisons. This left number/double values completely +uncovered in test-visitor-serialization tests. + +Fixing this exposed a bug in our handling of large whole number values +in QEMU's JSON parser which is now fixed. + +Simplify the code while we're at it by dropping the +calc_float_string_storage() craziness in favor of GStrings. + +Signed-off-by: Michael Roth +Reviewed-by: Laszlo Ersek +Reviewed-by: Amos Kong +Signed-off-by: Luiz Capitulino +(cherry picked from commit 089f26bb735fb414b79f5fa3753910d5339d2a1d) +Signed-off-by: Markus Armbruster +--- + tests/test-visitor-serialization.c | 25 ++++++++----------------- + 1 file changed, 8 insertions(+), 17 deletions(-) + +Signed-off-by: Michal Novotny +--- + tests/test-visitor-serialization.c | 25 ++++++++----------------- + 1 file changed, 8 insertions(+), 17 deletions(-) + +diff --git a/tests/test-visitor-serialization.c b/tests/test-visitor-serialization.c +index 8c8adac..fed6810 100644 +--- a/tests/test-visitor-serialization.c ++++ b/tests/test-visitor-serialization.c +@@ -229,17 +229,6 @@ typedef struct TestArgs { + void *test_data; + } TestArgs; + +-#define FLOAT_STRING_PRECISION 6 /* corresponding to n in %.nf formatting */ +-static gsize calc_float_string_storage(double value) +-{ +- int whole_value = value; +- gsize i = 0; +- do { +- i++; +- } while (whole_value /= 10); +- return i + 2 + FLOAT_STRING_PRECISION; +-} +- + static void test_primitives(gconstpointer opaque) + { + TestArgs *args = (TestArgs *) opaque; +@@ -248,7 +237,6 @@ static void test_primitives(gconstpointer opaque) + PrimitiveType *pt_copy = g_malloc0(sizeof(*pt_copy)); + Error *err = NULL; + void *serialize_data; +- char *double1, *double2; + + pt_copy->type = pt->type; + ops->serialize(pt, &serialize_data, visit_primitive_type, &err); +@@ -260,14 +248,17 @@ static void test_primitives(gconstpointer opaque) + g_assert_cmpstr(pt->value.string, ==, pt_copy->value.string); + g_free((char *)pt_copy->value.string); + } else if (pt->type == PTYPE_NUMBER) { ++ GString *double_expected = g_string_new(""); ++ GString *double_actual = g_string_new(""); + /* we serialize with %f for our reference visitors, so rather than fuzzy + * floating math to test "equality", just compare the formatted values + */ +- double1 = g_malloc0(calc_float_string_storage(pt->value.number)); +- double2 = g_malloc0(calc_float_string_storage(pt_copy->value.number)); +- g_assert_cmpstr(double1, ==, double2); +- g_free(double1); +- g_free(double2); ++ g_string_printf(double_expected, "%.6f", pt->value.number); ++ g_string_printf(double_actual, "%.6f", pt_copy->value.number); ++ g_assert_cmpstr(double_actual->str, ==, double_expected->str); ++ ++ g_string_free(double_expected, true); ++ g_string_free(double_actual, true); + } else if (pt->type == PTYPE_BOOLEAN) { + g_assert_cmpint(!!pt->value.max, ==, !!pt->value.max); + } else { +-- +1.7.11.7 + diff --git a/SOURCES/kvm-qapi-lack-of-two-commas-in-dict.patch b/SOURCES/kvm-qapi-lack-of-two-commas-in-dict.patch new file mode 100644 index 0000000..88af55e --- /dev/null +++ b/SOURCES/kvm-qapi-lack-of-two-commas-in-dict.patch @@ -0,0 +1,57 @@ +From a68d863151dead2ce6d54a8838607a771f78c4b0 Mon Sep 17 00:00:00 2001 +Message-Id: +In-Reply-To: <091eecc4fa42754760dfff393dabcc2b444e9693.1387369730.git.minovotn@redhat.com> +References: <091eecc4fa42754760dfff393dabcc2b444e9693.1387369730.git.minovotn@redhat.com> +From: Markus Armbruster +Date: Tue, 10 Dec 2013 15:29:10 +0100 +Subject: [PATCH 10/21] qapi: lack of two commas in dict + +RH-Author: Markus Armbruster +Message-id: <1386689361-30281-8-git-send-email-armbru@redhat.com> +Patchwork-id: 56136 +O-Subject: [PATCH 7.0 qemu-kvm 07/18] qapi: lack of two commas in dict +Bugzilla: 997915 +RH-Acked-by: Laszlo Ersek +RH-Acked-by: Kevin Wolf +RH-Acked-by: Luiz Capitulino + +From: Amos Kong + +Signed-off-by: Amos Kong +Signed-off-by: Michael Tokarev +(cherry picked from commit ad0f171e25fb60b385dc7d07632916d3b1043d81) +Signed-off-by: Markus Armbruster +--- + qapi-schema.json | 4 ++-- + 1 file changed, 2 insertions(+), 2 deletions(-) + +Signed-off-by: Michal Novotny +--- + qapi-schema.json | 4 ++-- + 1 file changed, 2 insertions(+), 2 deletions(-) + +diff --git a/qapi-schema.json b/qapi-schema.json +index 92fcd54..b27108f 100644 +--- a/qapi-schema.json ++++ b/qapi-schema.json +@@ -447,7 +447,7 @@ + # + # Since: 1.4 + ## +-{ 'enum': 'DataFormat' ++{ 'enum': 'DataFormat', + 'data': [ 'utf8', 'base64' ] } + + ## +@@ -1693,7 +1693,7 @@ + # + # Since: 1.1 + ## +-{ 'enum': 'NewImageMode' ++{ 'enum': 'NewImageMode', + 'data': [ 'existing', 'absolute-paths' ] } + + ## +-- +1.7.11.7 + diff --git a/SOURCES/kvm-qapi-make-use-of-new-BlockJobType.patch b/SOURCES/kvm-qapi-make-use-of-new-BlockJobType.patch new file mode 100644 index 0000000..5084dd6 --- /dev/null +++ b/SOURCES/kvm-qapi-make-use-of-new-BlockJobType.patch @@ -0,0 +1,122 @@ +From ce9a0218020c6f9c97eb787eb3381344759becc9 Mon Sep 17 00:00:00 2001 +From: Fam Zheng +Date: Fri, 17 Jan 2014 03:07:56 +0100 +Subject: [PATCH 13/34] qapi: make use of new BlockJobType + +RH-Author: Fam Zheng +Message-id: <1389928083-8921-12-git-send-email-famz@redhat.com> +Patchwork-id: 56773 +O-Subject: [RHEL-7 qemu-kvm PATCH 11/18] qapi: make use of new BlockJobType +Bugzilla: 1041301 +RH-Acked-by: Jeffrey Cody +RH-Acked-by: Kevin Wolf +RH-Acked-by: Stefan Hajnoczi + +Switch the string to enum type BlockJobType in BlockJobDriver. + +Signed-off-by: Fam Zheng +Reviewed-by: Eric Blake +Signed-off-by: Kevin Wolf +(cherry picked from commit 79e14bf7782d861d3d773a67680de07a8f354f4e) +Signed-off-by: Fam Zheng + +Conflicts: + block/backup.c + +Not present downstream. + +Signed-off-by: Fam Zheng +--- + block/commit.c | 2 +- + block/mirror.c | 2 +- + block/stream.c | 2 +- + blockjob.c | 4 ++-- + include/block/blockjob.h | 2 +- + 5 files changed, 6 insertions(+), 6 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + block/commit.c | 2 +- + block/mirror.c | 2 +- + block/stream.c | 2 +- + blockjob.c | 4 ++-- + include/block/blockjob.h | 2 +- + 5 files changed, 6 insertions(+), 6 deletions(-) + +diff --git a/block/commit.c b/block/commit.c +index 28f45e4..d237729 100644 +--- a/block/commit.c ++++ b/block/commit.c +@@ -175,7 +175,7 @@ static void commit_set_speed(BlockJob *job, int64_t speed, Error **errp) + + static const BlockJobDriver commit_job_driver = { + .instance_size = sizeof(CommitBlockJob), +- .job_type = "commit", ++ .job_type = BLOCK_JOB_TYPE_COMMIT, + .set_speed = commit_set_speed, + }; + +diff --git a/block/mirror.c b/block/mirror.c +index 139be06..8837186 100644 +--- a/block/mirror.c ++++ b/block/mirror.c +@@ -527,7 +527,7 @@ static void mirror_complete(BlockJob *job, Error **errp) + + static const BlockJobDriver mirror_job_driver = { + .instance_size = sizeof(MirrorBlockJob), +- .job_type = "mirror", ++ .job_type = BLOCK_JOB_TYPE_MIRROR, + .set_speed = mirror_set_speed, + .iostatus_reset= mirror_iostatus_reset, + .complete = mirror_complete, +diff --git a/block/stream.c b/block/stream.c +index ffa4e9a..1420d09 100644 +--- a/block/stream.c ++++ b/block/stream.c +@@ -206,7 +206,7 @@ static void stream_set_speed(BlockJob *job, int64_t speed, Error **errp) + + static const BlockJobDriver stream_job_driver = { + .instance_size = sizeof(StreamBlockJob), +- .job_type = "stream", ++ .job_type = BLOCK_JOB_TYPE_STREAM, + .set_speed = stream_set_speed, + }; + +diff --git a/blockjob.c b/blockjob.c +index dc0fa6d..a4430a0 100644 +--- a/blockjob.c ++++ b/blockjob.c +@@ -209,7 +209,7 @@ void block_job_sleep_ns(BlockJob *job, QEMUClock *clock, int64_t ns) + BlockJobInfo *block_job_query(BlockJob *job) + { + BlockJobInfo *info = g_new0(BlockJobInfo, 1); +- info->type = g_strdup(job->driver->job_type); ++ info->type = g_strdup(BlockJobType_lookup[job->driver->job_type]); + info->device = g_strdup(bdrv_get_device_name(job->bs)); + info->len = job->len; + info->busy = job->busy; +@@ -236,7 +236,7 @@ QObject *qobject_from_block_job(BlockJob *job) + "'len': %" PRId64 "," + "'offset': %" PRId64 "," + "'speed': %" PRId64 " }", +- job->driver->job_type, ++ BlockJobType_lookup[job->driver->job_type], + bdrv_get_device_name(job->bs), + job->len, + job->offset, +diff --git a/include/block/blockjob.h b/include/block/blockjob.h +index dadcd48..5a7d859 100644 +--- a/include/block/blockjob.h ++++ b/include/block/blockjob.h +@@ -37,7 +37,7 @@ typedef struct BlockJobDriver { + size_t instance_size; + + /** String describing the operation, part of query-block-jobs QMP API */ +- const char *job_type; ++ BlockJobType job_type; + + /** Optional callback for job types that support setting a speed limit */ + void (*set_speed)(BlockJob *job, int64_t speed, Error **errp); +-- +1.7.1 + diff --git a/SOURCES/kvm-qapi-make-visit_type_size-fallback-to-type_int.patch b/SOURCES/kvm-qapi-make-visit_type_size-fallback-to-type_int.patch new file mode 100644 index 0000000..cd8956e --- /dev/null +++ b/SOURCES/kvm-qapi-make-visit_type_size-fallback-to-type_int.patch @@ -0,0 +1,70 @@ +From 9bce100f4930cb500127110999c63474e9a6cfe2 Mon Sep 17 00:00:00 2001 +Message-Id: <9bce100f4930cb500127110999c63474e9a6cfe2.1387298827.git.minovotn@redhat.com> +In-Reply-To: <3ed0fb61a3dc912ef036d7ef450bed192090709e.1387298827.git.minovotn@redhat.com> +References: <3ed0fb61a3dc912ef036d7ef450bed192090709e.1387298827.git.minovotn@redhat.com> +From: "Michael S. Tsirkin" +Date: Tue, 17 Dec 2013 15:17:00 +0100 +Subject: [PATCH 05/56] qapi: make visit_type_size fallback to type_int +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +RH-Author: Michael S. Tsirkin +Message-id: <1387293161-4085-6-git-send-email-mst@redhat.com> +Patchwork-id: 56310 +O-Subject: [PATCH qemu-kvm RHEL7.0 v2 05/57] qapi: make visit_type_size fallback to type_int +Bugzilla: 1034876 +RH-Acked-by: Igor Mammedov +RH-Acked-by: Marcel Apfelbaum +RH-Acked-by: Laszlo Ersek + +From: Vasilis Liaskovitis + +Currently visit_type_size checks if the visitor's type_size function pointer is +NULL. If not, it calls it, otherwise it calls v->type_uint64(). But neither of +these pointers are ever set. Fallback to calling v->type_int() in this third +(default) case. + +Signed-off-by: Vasilis Liaskovitis +Signed-off-by: Hu Tao +Signed-off-by: Igor Mammedov +Reviewed-by: Michael S. Tsirkin +Reviewed-by: Andreas Färber +Message-id: 1375109277-25561-6-git-send-email-imammedo@redhat.com +Signed-off-by: Anthony Liguori +(cherry picked from commit b887796217b7f5b754657e85760693e4ced63356) +--- + qapi/qapi-visit-core.c | 11 ++++++++++- + 1 file changed, 10 insertions(+), 1 deletion(-) + +Signed-off-by: Michal Novotny +--- + qapi/qapi-visit-core.c | 11 ++++++++++- + 1 file changed, 10 insertions(+), 1 deletion(-) + +diff --git a/qapi/qapi-visit-core.c b/qapi/qapi-visit-core.c +index d6a4012..6451a21 100644 +--- a/qapi/qapi-visit-core.c ++++ b/qapi/qapi-visit-core.c +@@ -263,8 +263,17 @@ void visit_type_int64(Visitor *v, int64_t *obj, const char *name, Error **errp) + + void visit_type_size(Visitor *v, uint64_t *obj, const char *name, Error **errp) + { ++ int64_t value; + if (!error_is_set(errp)) { +- (v->type_size ? v->type_size : v->type_uint64)(v, obj, name, errp); ++ if (v->type_size) { ++ v->type_size(v, obj, name, errp); ++ } else if (v->type_uint64) { ++ v->type_uint64(v, obj, name, errp); ++ } else { ++ value = *obj; ++ v->type_int(v, &value, name, errp); ++ *obj = value; ++ } + } + } + +-- +1.7.11.7 + diff --git a/SOURCES/kvm-qapi-schema-Update-description-for-NewImageMode.patch b/SOURCES/kvm-qapi-schema-Update-description-for-NewImageMode.patch new file mode 100644 index 0000000..f094802 --- /dev/null +++ b/SOURCES/kvm-qapi-schema-Update-description-for-NewImageMode.patch @@ -0,0 +1,54 @@ +From 80d8289fb554704ed21000baaf334d549641804d Mon Sep 17 00:00:00 2001 +From: Max Reitz +Date: Sun, 19 Jan 2014 18:07:59 +0100 +Subject: [PATCH 25/34] qapi-schema: Update description for NewImageMode + +RH-Author: Max Reitz +Message-id: <1390154881-17140-6-git-send-email-mreitz@redhat.com> +Patchwork-id: 56818 +O-Subject: [RHEL-7.0 qemu-kvm PATCH v2 5/7] qapi-schema: Update description for NewImageMode +Bugzilla: 921890 +RH-Acked-by: Fam Zheng +RH-Acked-by: Kevin Wolf +RH-Acked-by: Jeffrey Cody + +BZ: 921890 + +If the NewImageMode is "absolute-paths" but no backing file is available +(e.g., when mirroring a device with an unbacked image), the target image +will not be backed either. This patch updates the documentation in +qapi-schema.json accordingly. + +Signed-off-by: Max Reitz +Reviewed-by: Eric Blake +Reviewed-by: Benoit Canet +Signed-off-by: Kevin Wolf +(cherry picked from commit 1296c2f0bc8283164c925bf587e497511de7f569) + +Signed-off-by: Max Reitz +--- + qapi-schema.json | 3 ++- + 1 file changed, 2 insertions(+), 1 deletion(-) + +Signed-off-by: Miroslav Rezanina +--- + qapi-schema.json | 3 ++- + 1 files changed, 2 insertions(+), 1 deletions(-) + +diff --git a/qapi-schema.json b/qapi-schema.json +index a783e8e..6158ea5 100644 +--- a/qapi-schema.json ++++ b/qapi-schema.json +@@ -1722,7 +1722,8 @@ + # @existing: QEMU should look for an existing image file. + # + # @absolute-paths: QEMU should create a new image with absolute paths +-# for the backing file. ++# for the backing file. If there is no backing file available, the new ++# image will not be backed either. + # + # Since: 1.1 + ## +-- +1.7.1 + diff --git a/SOURCES/kvm-qapi.py-Decent-syntax-error-reporting.patch b/SOURCES/kvm-qapi.py-Decent-syntax-error-reporting.patch new file mode 100644 index 0000000..e9098f7 --- /dev/null +++ b/SOURCES/kvm-qapi.py-Decent-syntax-error-reporting.patch @@ -0,0 +1,128 @@ +From b63bf0c1731359b15ec94c233bc5b3e11db089b4 Mon Sep 17 00:00:00 2001 +Message-Id: +In-Reply-To: <091eecc4fa42754760dfff393dabcc2b444e9693.1387369730.git.minovotn@redhat.com> +References: <091eecc4fa42754760dfff393dabcc2b444e9693.1387369730.git.minovotn@redhat.com> +From: Markus Armbruster +Date: Tue, 10 Dec 2013 15:29:14 +0100 +Subject: [PATCH 14/21] qapi.py: Decent syntax error reporting + +RH-Author: Markus Armbruster +Message-id: <1386689361-30281-12-git-send-email-armbru@redhat.com> +Patchwork-id: 56126 +O-Subject: [PATCH 7.0 qemu-kvm 11/18] qapi.py: Decent syntax error reporting +Bugzilla: 997915 +RH-Acked-by: Laszlo Ersek +RH-Acked-by: Kevin Wolf +RH-Acked-by: Luiz Capitulino + +From: Markus Armbruster + +Signed-off-by: Markus Armbruster +Reviewed-by: Eric Blake +Message-id: 1374939721-7876-5-git-send-email-armbru@redhat.com +Signed-off-by: Anthony Liguori +(cherry picked from commit 2caba36cc61ee3993334bc423f0852f8006fdfcf) +--- + scripts/qapi.py | 29 +++++++++++++++++++++++++++-- + tests/qapi-schema/test-qapi.py | 2 ++ + tests/qapi-schema/unclosed-string.err | 2 +- + 3 files changed, 30 insertions(+), 3 deletions(-) + +Signed-off-by: Michal Novotny +--- + scripts/qapi.py | 29 +++++++++++++++++++++++++++-- + tests/qapi-schema/test-qapi.py | 2 ++ + tests/qapi-schema/unclosed-string.err | 2 +- + 3 files changed, 30 insertions(+), 3 deletions(-) + +diff --git a/scripts/qapi.py b/scripts/qapi.py +index 58e315b..342d16c 100644 +--- a/scripts/qapi.py ++++ b/scripts/qapi.py +@@ -12,6 +12,7 @@ + # See the COPYING.LIB file in the top-level directory. + + from ordereddict import OrderedDict ++import sys + + builtin_types = [ + 'str', 'int', 'number', 'bool', +@@ -34,6 +35,23 @@ builtin_type_qtypes = { + 'uint64': 'QTYPE_QINT', + } + ++class QAPISchemaError(Exception): ++ def __init__(self, schema, msg): ++ self.fp = schema.fp ++ self.msg = msg ++ self.line = self.col = 1 ++ for ch in schema.src[0:schema.pos]: ++ if ch == '\n': ++ self.line += 1 ++ self.col = 1 ++ elif ch == '\t': ++ self.col = (self.col + 7) % 8 + 1 ++ else: ++ self.col += 1 ++ ++ def __str__(self): ++ return "%s:%s:%s: %s" % (self.fp.name, self.line, self.col, self.msg) ++ + class QAPISchema: + + def __init__(self, fp): +@@ -52,6 +70,7 @@ class QAPISchema: + while True: + bol = self.cursor == 0 or self.src[self.cursor-1] == '\n' + self.tok = self.src[self.cursor] ++ self.pos = self.cursor + self.cursor += 1 + self.val = None + +@@ -66,7 +85,8 @@ class QAPISchema: + ch = self.src[self.cursor] + self.cursor += 1 + if ch == '\n': +- raise Exception("Mismatched quotes") ++ raise QAPISchemaError(self, ++ 'Missing terminating "\'"') + if esc: + string += ch + esc = False +@@ -116,7 +136,12 @@ class QAPISchema: + return expr + + def parse_schema(fp): +- schema = QAPISchema(fp) ++ try: ++ schema = QAPISchema(fp) ++ except QAPISchemaError as e: ++ print >>sys.stderr, e ++ exit(1) ++ + exprs = [] + + for expr_eval in schema.exprs: +diff --git a/tests/qapi-schema/test-qapi.py b/tests/qapi-schema/test-qapi.py +index 3280eff..b3d1e1d 100644 +--- a/tests/qapi-schema/test-qapi.py ++++ b/tests/qapi-schema/test-qapi.py +@@ -16,6 +16,8 @@ import sys + + try: + exprs = parse_schema(sys.stdin) ++except SystemExit: ++ raise + except: + print >>sys.stderr, "Crashed:", sys.exc_info()[0] + exit(1) +diff --git a/tests/qapi-schema/unclosed-string.err b/tests/qapi-schema/unclosed-string.err +index 5af46c2..948d883 100644 +--- a/tests/qapi-schema/unclosed-string.err ++++ b/tests/qapi-schema/unclosed-string.err +@@ -1 +1 @@ +-Crashed: ++:1:11: Missing terminating "'" +-- +1.7.11.7 + diff --git a/SOURCES/kvm-qapi.py-Fix-diagnosing-non-objects-at-a-schema-s-top.patch b/SOURCES/kvm-qapi.py-Fix-diagnosing-non-objects-at-a-schema-s-top.patch new file mode 100644 index 0000000..d6b5fa3 --- /dev/null +++ b/SOURCES/kvm-qapi.py-Fix-diagnosing-non-objects-at-a-schema-s-top.patch @@ -0,0 +1,99 @@ +From 73cd8a69f21978e950706a633d9a25e10fe6ad2d Mon Sep 17 00:00:00 2001 +Message-Id: <73cd8a69f21978e950706a633d9a25e10fe6ad2d.1387369730.git.minovotn@redhat.com> +In-Reply-To: <091eecc4fa42754760dfff393dabcc2b444e9693.1387369730.git.minovotn@redhat.com> +References: <091eecc4fa42754760dfff393dabcc2b444e9693.1387369730.git.minovotn@redhat.com> +From: Markus Armbruster +Date: Tue, 10 Dec 2013 15:29:17 +0100 +Subject: [PATCH 17/21] qapi.py: Fix diagnosing non-objects at a schema's + top-level + +RH-Author: Markus Armbruster +Message-id: <1386689361-30281-15-git-send-email-armbru@redhat.com> +Patchwork-id: 56129 +O-Subject: [PATCH 7.0 qemu-kvm 14/18] qapi.py: Fix diagnosing non-objects at a schema's top-level +Bugzilla: 997915 +RH-Acked-by: Laszlo Ersek +RH-Acked-by: Kevin Wolf +RH-Acked-by: Luiz Capitulino + +From: Markus Armbruster + +Report syntax error instead of crashing. + +Signed-off-by: Markus Armbruster +Reviewed-by: Eric Blake +Message-id: 1374939721-7876-8-git-send-email-armbru@redhat.com +Signed-off-by: Anthony Liguori +(cherry picked from commit 5f3cd2b717c949f3afb502fb4c81193eb18ce6aa) +--- + scripts/qapi.py | 10 ++++++---- + tests/qapi-schema/non-objects.err | 2 +- + tests/qapi-schema/quoted-structural-chars.err | 2 +- + 3 files changed, 8 insertions(+), 6 deletions(-) + +Signed-off-by: Michal Novotny +--- + scripts/qapi.py | 10 ++++++---- + tests/qapi-schema/non-objects.err | 2 +- + tests/qapi-schema/quoted-structural-chars.err | 2 +- + 3 files changed, 8 insertions(+), 6 deletions(-) + +diff --git a/scripts/qapi.py b/scripts/qapi.py +index 12fb29a..75fc282 100644 +--- a/scripts/qapi.py ++++ b/scripts/qapi.py +@@ -64,7 +64,7 @@ class QAPISchema: + self.accept() + + while self.tok != None: +- self.exprs.append(self.get_expr()) ++ self.exprs.append(self.get_expr(False)) + + def accept(self): + while True: +@@ -117,7 +117,7 @@ class QAPISchema: + if self.tok != ':': + raise QAPISchemaError(self, 'Expected ":"') + self.accept() +- expr[key] = self.get_expr() ++ expr[key] = self.get_expr(True) + if self.tok == '}': + self.accept() + return expr +@@ -135,7 +135,7 @@ class QAPISchema: + if not self.tok in [ '{', '[', "'" ]: + raise QAPISchemaError(self, 'Expected "{", "[", "]" or string') + while True: +- expr.append(self.get_expr()) ++ expr.append(self.get_expr(True)) + if self.tok == ']': + self.accept() + return expr +@@ -143,7 +143,9 @@ class QAPISchema: + raise QAPISchemaError(self, 'Expected "," or "]"') + self.accept() + +- def get_expr(self): ++ def get_expr(self, nested): ++ if self.tok != '{' and not nested: ++ raise QAPISchemaError(self, 'Expected "{"') + if self.tok == '{': + self.accept() + expr = self.get_members() +diff --git a/tests/qapi-schema/non-objects.err b/tests/qapi-schema/non-objects.err +index 48c849d..a6c2dc2 100644 +--- a/tests/qapi-schema/non-objects.err ++++ b/tests/qapi-schema/non-objects.err +@@ -1 +1 @@ +-Crashed: ++:1:1: Expected "{" +diff --git a/tests/qapi-schema/quoted-structural-chars.err b/tests/qapi-schema/quoted-structural-chars.err +index 48c849d..a6c2dc2 100644 +--- a/tests/qapi-schema/quoted-structural-chars.err ++++ b/tests/qapi-schema/quoted-structural-chars.err +@@ -1 +1 @@ +-Crashed: ++:1:1: Expected "{" +-- +1.7.11.7 + diff --git a/SOURCES/kvm-qapi.py-Fix-schema-parser-to-check-syntax-systematic.patch b/SOURCES/kvm-qapi.py-Fix-schema-parser-to-check-syntax-systematic.patch new file mode 100644 index 0000000..9485d55 --- /dev/null +++ b/SOURCES/kvm-qapi.py-Fix-schema-parser-to-check-syntax-systematic.patch @@ -0,0 +1,267 @@ +From d7e41b169b7c97953ceda7b7e617ae3f3dc5ae49 Mon Sep 17 00:00:00 2001 +Message-Id: +In-Reply-To: <091eecc4fa42754760dfff393dabcc2b444e9693.1387369730.git.minovotn@redhat.com> +References: <091eecc4fa42754760dfff393dabcc2b444e9693.1387369730.git.minovotn@redhat.com> +From: Markus Armbruster +Date: Tue, 10 Dec 2013 15:29:16 +0100 +Subject: [PATCH 16/21] qapi.py: Fix schema parser to check syntax + systematically + +RH-Author: Markus Armbruster +Message-id: <1386689361-30281-14-git-send-email-armbru@redhat.com> +Patchwork-id: 56134 +O-Subject: [PATCH 7.0 qemu-kvm 13/18] qapi.py: Fix schema parser to check syntax systematically +Bugzilla: 997915 +RH-Acked-by: Laszlo Ersek +RH-Acked-by: Kevin Wolf +RH-Acked-by: Luiz Capitulino + +From: Markus Armbruster + +Fixes at least the following parser bugs: + +* accepts any token in place of a colon + +* treats comma as optional + +* crashes when closing braces or brackets are missing + +Signed-off-by: Markus Armbruster +Reviewed-by: Eric Blake +Message-id: 1374939721-7876-7-git-send-email-armbru@redhat.com +Signed-off-by: Anthony Liguori +(cherry picked from commit 6974ccd542d11ae5fb1e56dd3d753f2de5cc097e) +--- + scripts/qapi.py | 40 +++++++++++++++++++++------- + tests/qapi-schema/missing-colon.err | 1 + + tests/qapi-schema/missing-colon.exit | 2 +- + tests/qapi-schema/missing-colon.out | 3 --- + tests/qapi-schema/missing-comma-list.err | 1 + + tests/qapi-schema/missing-comma-list.exit | 2 +- + tests/qapi-schema/missing-comma-list.out | 3 --- + tests/qapi-schema/missing-comma-object.err | 1 + + tests/qapi-schema/missing-comma-object.exit | 2 +- + tests/qapi-schema/missing-comma-object.out | 3 --- + tests/qapi-schema/trailing-comma-list.err | 1 + + tests/qapi-schema/trailing-comma-list.exit | 2 +- + tests/qapi-schema/trailing-comma-list.out | 3 --- + tests/qapi-schema/trailing-comma-object.err | 1 + + tests/qapi-schema/trailing-comma-object.exit | 2 +- + tests/qapi-schema/trailing-comma-object.out | 3 --- + tests/qapi-schema/unclosed-list.err | 2 +- + tests/qapi-schema/unclosed-object.err | 2 +- + 18 files changed, 42 insertions(+), 32 deletions(-) + +Signed-off-by: Michal Novotny +--- + scripts/qapi.py | 40 +++++++++++++++++++++------- + tests/qapi-schema/missing-colon.err | 1 + + tests/qapi-schema/missing-colon.exit | 2 +- + tests/qapi-schema/missing-colon.out | 3 --- + tests/qapi-schema/missing-comma-list.err | 1 + + tests/qapi-schema/missing-comma-list.exit | 2 +- + tests/qapi-schema/missing-comma-list.out | 3 --- + tests/qapi-schema/missing-comma-object.err | 1 + + tests/qapi-schema/missing-comma-object.exit | 2 +- + tests/qapi-schema/missing-comma-object.out | 3 --- + tests/qapi-schema/trailing-comma-list.err | 1 + + tests/qapi-schema/trailing-comma-list.exit | 2 +- + tests/qapi-schema/trailing-comma-list.out | 3 --- + tests/qapi-schema/trailing-comma-object.err | 1 + + tests/qapi-schema/trailing-comma-object.exit | 2 +- + tests/qapi-schema/trailing-comma-object.out | 3 --- + tests/qapi-schema/unclosed-list.err | 2 +- + tests/qapi-schema/unclosed-object.err | 2 +- + 18 files changed, 42 insertions(+), 32 deletions(-) + +diff --git a/scripts/qapi.py b/scripts/qapi.py +index 0b48a1e..12fb29a 100644 +--- a/scripts/qapi.py ++++ b/scripts/qapi.py +@@ -106,24 +106,42 @@ class QAPISchema: + + def get_members(self): + expr = OrderedDict() +- while self.tok != '}': ++ if self.tok == '}': ++ self.accept() ++ return expr ++ if self.tok != "'": ++ raise QAPISchemaError(self, 'Expected string or "}"') ++ while True: + key = self.val + self.accept() +- self.accept() # : ++ if self.tok != ':': ++ raise QAPISchemaError(self, 'Expected ":"') ++ self.accept() + expr[key] = self.get_expr() +- if self.tok == ',': ++ if self.tok == '}': + self.accept() +- self.accept() +- return expr ++ return expr ++ if self.tok != ',': ++ raise QAPISchemaError(self, 'Expected "," or "}"') ++ self.accept() ++ if self.tok != "'": ++ raise QAPISchemaError(self, 'Expected string') + + def get_values(self): + expr = [] +- while self.tok != ']': ++ if self.tok == ']': ++ self.accept() ++ return expr ++ if not self.tok in [ '{', '[', "'" ]: ++ raise QAPISchemaError(self, 'Expected "{", "[", "]" or string') ++ while True: + expr.append(self.get_expr()) +- if self.tok == ',': ++ if self.tok == ']': + self.accept() +- self.accept() +- return expr ++ return expr ++ if self.tok != ',': ++ raise QAPISchemaError(self, 'Expected "," or "]"') ++ self.accept() + + def get_expr(self): + if self.tok == '{': +@@ -132,9 +150,11 @@ class QAPISchema: + elif self.tok == '[': + self.accept() + expr = self.get_values() +- else: ++ elif self.tok == "'": + expr = self.val + self.accept() ++ else: ++ raise QAPISchemaError(self, 'Expected "{", "[" or string') + return expr + + def parse_schema(fp): +diff --git a/tests/qapi-schema/missing-colon.err b/tests/qapi-schema/missing-colon.err +index e69de29..9f2a355 100644 +--- a/tests/qapi-schema/missing-colon.err ++++ b/tests/qapi-schema/missing-colon.err +@@ -0,0 +1 @@ ++:1:10: Expected ":" +diff --git a/tests/qapi-schema/missing-colon.exit b/tests/qapi-schema/missing-colon.exit +index 573541a..d00491f 100644 +--- a/tests/qapi-schema/missing-colon.exit ++++ b/tests/qapi-schema/missing-colon.exit +@@ -1 +1 @@ +-0 ++1 +diff --git a/tests/qapi-schema/missing-colon.out b/tests/qapi-schema/missing-colon.out +index e67068c..e69de29 100644 +--- a/tests/qapi-schema/missing-colon.out ++++ b/tests/qapi-schema/missing-colon.out +@@ -1,3 +0,0 @@ +-[OrderedDict([('enum', None), ('data', ['good', 'bad', 'ugly'])])] +-[None] +-[] +diff --git a/tests/qapi-schema/missing-comma-list.err b/tests/qapi-schema/missing-comma-list.err +index e69de29..4fe0700 100644 +--- a/tests/qapi-schema/missing-comma-list.err ++++ b/tests/qapi-schema/missing-comma-list.err +@@ -0,0 +1 @@ ++:2:20: Expected "," or "]" +diff --git a/tests/qapi-schema/missing-comma-list.exit b/tests/qapi-schema/missing-comma-list.exit +index 573541a..d00491f 100644 +--- a/tests/qapi-schema/missing-comma-list.exit ++++ b/tests/qapi-schema/missing-comma-list.exit +@@ -1 +1 @@ +-0 ++1 +diff --git a/tests/qapi-schema/missing-comma-list.out b/tests/qapi-schema/missing-comma-list.out +index e3bd904..e69de29 100644 +--- a/tests/qapi-schema/missing-comma-list.out ++++ b/tests/qapi-schema/missing-comma-list.out +@@ -1,3 +0,0 @@ +-[OrderedDict([('enum', 'Status'), ('data', ['good', 'bad', 'ugly'])])] +-['Status'] +-[] +diff --git a/tests/qapi-schema/missing-comma-object.err b/tests/qapi-schema/missing-comma-object.err +index e69de29..b0121b5 100644 +--- a/tests/qapi-schema/missing-comma-object.err ++++ b/tests/qapi-schema/missing-comma-object.err +@@ -0,0 +1 @@ ++:2:3: Expected "," or "}" +diff --git a/tests/qapi-schema/missing-comma-object.exit b/tests/qapi-schema/missing-comma-object.exit +index 573541a..d00491f 100644 +--- a/tests/qapi-schema/missing-comma-object.exit ++++ b/tests/qapi-schema/missing-comma-object.exit +@@ -1 +1 @@ +-0 ++1 +diff --git a/tests/qapi-schema/missing-comma-object.out b/tests/qapi-schema/missing-comma-object.out +index e3bd904..e69de29 100644 +--- a/tests/qapi-schema/missing-comma-object.out ++++ b/tests/qapi-schema/missing-comma-object.out +@@ -1,3 +0,0 @@ +-[OrderedDict([('enum', 'Status'), ('data', ['good', 'bad', 'ugly'])])] +-['Status'] +-[] +diff --git a/tests/qapi-schema/trailing-comma-list.err b/tests/qapi-schema/trailing-comma-list.err +index e69de29..ff839a3 100644 +--- a/tests/qapi-schema/trailing-comma-list.err ++++ b/tests/qapi-schema/trailing-comma-list.err +@@ -0,0 +1 @@ ++:2:36: Expected "{", "[" or string +diff --git a/tests/qapi-schema/trailing-comma-list.exit b/tests/qapi-schema/trailing-comma-list.exit +index 573541a..d00491f 100644 +--- a/tests/qapi-schema/trailing-comma-list.exit ++++ b/tests/qapi-schema/trailing-comma-list.exit +@@ -1 +1 @@ +-0 ++1 +diff --git a/tests/qapi-schema/trailing-comma-list.out b/tests/qapi-schema/trailing-comma-list.out +index e3bd904..e69de29 100644 +--- a/tests/qapi-schema/trailing-comma-list.out ++++ b/tests/qapi-schema/trailing-comma-list.out +@@ -1,3 +0,0 @@ +-[OrderedDict([('enum', 'Status'), ('data', ['good', 'bad', 'ugly'])])] +-['Status'] +-[] +diff --git a/tests/qapi-schema/trailing-comma-object.err b/tests/qapi-schema/trailing-comma-object.err +index e69de29..f540962 100644 +--- a/tests/qapi-schema/trailing-comma-object.err ++++ b/tests/qapi-schema/trailing-comma-object.err +@@ -0,0 +1 @@ ++:2:38: Expected string +diff --git a/tests/qapi-schema/trailing-comma-object.exit b/tests/qapi-schema/trailing-comma-object.exit +index 573541a..d00491f 100644 +--- a/tests/qapi-schema/trailing-comma-object.exit ++++ b/tests/qapi-schema/trailing-comma-object.exit +@@ -1 +1 @@ +-0 ++1 +diff --git a/tests/qapi-schema/trailing-comma-object.out b/tests/qapi-schema/trailing-comma-object.out +index e3bd904..e69de29 100644 +--- a/tests/qapi-schema/trailing-comma-object.out ++++ b/tests/qapi-schema/trailing-comma-object.out +@@ -1,3 +0,0 @@ +-[OrderedDict([('enum', 'Status'), ('data', ['good', 'bad', 'ugly'])])] +-['Status'] +-[] +diff --git a/tests/qapi-schema/unclosed-list.err b/tests/qapi-schema/unclosed-list.err +index f9a9c2a..0e837a7 100644 +--- a/tests/qapi-schema/unclosed-list.err ++++ b/tests/qapi-schema/unclosed-list.err +@@ -1 +1 @@ +-Crashed: ++:1:20: Expected "," or "]" +diff --git a/tests/qapi-schema/unclosed-object.err b/tests/qapi-schema/unclosed-object.err +index f9a9c2a..e6dc950 100644 +--- a/tests/qapi-schema/unclosed-object.err ++++ b/tests/qapi-schema/unclosed-object.err +@@ -1 +1 @@ +-Crashed: ++:1:21: Expected "," or "}" +-- +1.7.11.7 + diff --git a/SOURCES/kvm-qapi.py-Permit-comments-starting-anywhere-on-the-lin.patch b/SOURCES/kvm-qapi.py-Permit-comments-starting-anywhere-on-the-lin.patch new file mode 100644 index 0000000..e5a0cbf --- /dev/null +++ b/SOURCES/kvm-qapi.py-Permit-comments-starting-anywhere-on-the-lin.patch @@ -0,0 +1,100 @@ +From eee270ab05e29d24d26d8834a00ec0dfcfc99d66 Mon Sep 17 00:00:00 2001 +Message-Id: +In-Reply-To: <091eecc4fa42754760dfff393dabcc2b444e9693.1387369730.git.minovotn@redhat.com> +References: <091eecc4fa42754760dfff393dabcc2b444e9693.1387369730.git.minovotn@redhat.com> +From: Markus Armbruster +Date: Tue, 10 Dec 2013 15:29:19 +0100 +Subject: [PATCH 19/21] qapi.py: Permit comments starting anywhere on the line + +RH-Author: Markus Armbruster +Message-id: <1386689361-30281-17-git-send-email-armbru@redhat.com> +Patchwork-id: 56128 +O-Subject: [PATCH 7.0 qemu-kvm 16/18] qapi.py: Permit comments starting anywhere on the line +Bugzilla: 997915 +RH-Acked-by: Laszlo Ersek +RH-Acked-by: Kevin Wolf +RH-Acked-by: Luiz Capitulino + +From: Markus Armbruster + +Signed-off-by: Markus Armbruster +Reviewed-by: Eric Blake +Message-id: 1374939721-7876-10-git-send-email-armbru@redhat.com +Signed-off-by: Anthony Liguori +(cherry picked from commit f1a145e154b0a227a1e192009ca30b351de0a8ef) + +Backporting hack: now that indented comments work properly, revert the +damage to qapi-schema.json. +--- + qapi-schema.json | 2 +- + scripts/qapi.py | 3 +-- + tests/qapi-schema/comments.err | 1 - + tests/qapi-schema/comments.exit | 2 +- + tests/qapi-schema/comments.out | 3 +++ + 5 files changed, 6 insertions(+), 5 deletions(-) + +Signed-off-by: Michal Novotny +--- + qapi-schema.json | 2 +- + scripts/qapi.py | 3 +-- + tests/qapi-schema/comments.err | 1 - + tests/qapi-schema/comments.exit | 2 +- + tests/qapi-schema/comments.out | 3 +++ + 5 files changed, 6 insertions(+), 5 deletions(-) + +diff --git a/qapi-schema.json b/qapi-schema.json +index 81fe591..b27108f 100644 +--- a/qapi-schema.json ++++ b/qapi-schema.json +@@ -3437,7 +3437,7 @@ + 'spiceport' : 'ChardevSpicePort', + 'vc' : 'ChardevVC', + 'ringbuf': 'ChardevRingbuf', +-# next one is just for compatibility ++ # next one is just for compatibility + 'memory' : 'ChardevRingbuf' } } + + ## +diff --git a/scripts/qapi.py b/scripts/qapi.py +index f64b7b2..0ebea94 100644 +--- a/scripts/qapi.py ++++ b/scripts/qapi.py +@@ -68,13 +68,12 @@ class QAPISchema: + + def accept(self): + while True: +- bol = self.cursor == 0 or self.src[self.cursor-1] == '\n' + self.tok = self.src[self.cursor] + self.pos = self.cursor + self.cursor += 1 + self.val = None + +- if self.tok == '#' and bol: ++ if self.tok == '#': + self.cursor = self.src.find('\n', self.cursor) + elif self.tok in ['{', '}', ':', ',', '[', ']']: + return +diff --git a/tests/qapi-schema/comments.err b/tests/qapi-schema/comments.err +index 4a82b26..e69de29 100644 +--- a/tests/qapi-schema/comments.err ++++ b/tests/qapi-schema/comments.err +@@ -1 +0,0 @@ +-:2:33: Stray "#" +diff --git a/tests/qapi-schema/comments.exit b/tests/qapi-schema/comments.exit +index d00491f..573541a 100644 +--- a/tests/qapi-schema/comments.exit ++++ b/tests/qapi-schema/comments.exit +@@ -1 +1 @@ +-1 ++0 +diff --git a/tests/qapi-schema/comments.out b/tests/qapi-schema/comments.out +index e69de29..e3bd904 100644 +--- a/tests/qapi-schema/comments.out ++++ b/tests/qapi-schema/comments.out +@@ -0,0 +1,3 @@ ++[OrderedDict([('enum', 'Status'), ('data', ['good', 'bad', 'ugly'])])] ++['Status'] ++[] +-- +1.7.11.7 + diff --git a/SOURCES/kvm-qapi.py-Reject-invalid-characters-in-schema-file.patch b/SOURCES/kvm-qapi.py-Reject-invalid-characters-in-schema-file.patch new file mode 100644 index 0000000..0fa2da4 --- /dev/null +++ b/SOURCES/kvm-qapi.py-Reject-invalid-characters-in-schema-file.patch @@ -0,0 +1,128 @@ +From b6e8e4d8b191e48d0a850eb6715ff2d70dd1ed8b Mon Sep 17 00:00:00 2001 +Message-Id: +In-Reply-To: <091eecc4fa42754760dfff393dabcc2b444e9693.1387369730.git.minovotn@redhat.com> +References: <091eecc4fa42754760dfff393dabcc2b444e9693.1387369730.git.minovotn@redhat.com> +From: Markus Armbruster +Date: Tue, 10 Dec 2013 15:29:15 +0100 +Subject: [PATCH 15/21] qapi.py: Reject invalid characters in schema file + +RH-Author: Markus Armbruster +Message-id: <1386689361-30281-13-git-send-email-armbru@redhat.com> +Patchwork-id: 56131 +O-Subject: [PATCH 7.0 qemu-kvm 12/18] qapi.py: Reject invalid characters in schema file +Bugzilla: 997915 +RH-Acked-by: Laszlo Ersek +RH-Acked-by: Kevin Wolf +RH-Acked-by: Luiz Capitulino + +From: Markus Armbruster + +Signed-off-by: Markus Armbruster +Reviewed-by: Eric Blake +Message-id: 1374939721-7876-6-git-send-email-armbru@redhat.com +Signed-off-by: Anthony Liguori +(cherry picked from commit 9213aa5391f7c8d3766420d96888f1353af4c890) + +Backporting hack: need to unindent a comment in qapi-schem.json we got +from commit 8707cd1 via v1.5.3. The upstream trunk has the commit +after the QAPI parser rewrite. Indented comments just work there. +The stable branch doesn't have the QAPI parser rewrite. It works only +because it silently ignores invalid characters. Misfeature, cleaned +up in this commit. + +The comment will be reindented in the backport of the commit that +makes indented comments work properly. +--- + qapi-schema.json | 2 +- + scripts/qapi.py | 2 ++ + tests/qapi-schema/comments.err | 1 + + tests/qapi-schema/comments.exit | 2 +- + tests/qapi-schema/comments.out | 3 --- + tests/qapi-schema/funny-char.err | 1 + + tests/qapi-schema/funny-char.exit | 2 +- + tests/qapi-schema/funny-char.out | 3 --- + 8 files changed, 7 insertions(+), 9 deletions(-) + +Signed-off-by: Michal Novotny +--- + qapi-schema.json | 2 +- + scripts/qapi.py | 2 ++ + tests/qapi-schema/comments.err | 1 + + tests/qapi-schema/comments.exit | 2 +- + tests/qapi-schema/comments.out | 3 --- + tests/qapi-schema/funny-char.err | 1 + + tests/qapi-schema/funny-char.exit | 2 +- + tests/qapi-schema/funny-char.out | 3 --- + 8 files changed, 7 insertions(+), 9 deletions(-) + +diff --git a/qapi-schema.json b/qapi-schema.json +index b27108f..81fe591 100644 +--- a/qapi-schema.json ++++ b/qapi-schema.json +@@ -3437,7 +3437,7 @@ + 'spiceport' : 'ChardevSpicePort', + 'vc' : 'ChardevVC', + 'ringbuf': 'ChardevRingbuf', +- # next one is just for compatibility ++# next one is just for compatibility + 'memory' : 'ChardevRingbuf' } } + + ## +diff --git a/scripts/qapi.py b/scripts/qapi.py +index 342d16c..0b48a1e 100644 +--- a/scripts/qapi.py ++++ b/scripts/qapi.py +@@ -101,6 +101,8 @@ class QAPISchema: + if self.cursor == len(self.src): + self.tok = None + return ++ elif not self.tok.isspace(): ++ raise QAPISchemaError(self, 'Stray "%s"' % self.tok) + + def get_members(self): + expr = OrderedDict() +diff --git a/tests/qapi-schema/comments.err b/tests/qapi-schema/comments.err +index e69de29..4a82b26 100644 +--- a/tests/qapi-schema/comments.err ++++ b/tests/qapi-schema/comments.err +@@ -0,0 +1 @@ ++:2:33: Stray "#" +diff --git a/tests/qapi-schema/comments.exit b/tests/qapi-schema/comments.exit +index 573541a..d00491f 100644 +--- a/tests/qapi-schema/comments.exit ++++ b/tests/qapi-schema/comments.exit +@@ -1 +1 @@ +-0 ++1 +diff --git a/tests/qapi-schema/comments.out b/tests/qapi-schema/comments.out +index e3bd904..e69de29 100644 +--- a/tests/qapi-schema/comments.out ++++ b/tests/qapi-schema/comments.out +@@ -1,3 +0,0 @@ +-[OrderedDict([('enum', 'Status'), ('data', ['good', 'bad', 'ugly'])])] +-['Status'] +-[] +diff --git a/tests/qapi-schema/funny-char.err b/tests/qapi-schema/funny-char.err +index e69de29..d3dd293 100644 +--- a/tests/qapi-schema/funny-char.err ++++ b/tests/qapi-schema/funny-char.err +@@ -0,0 +1 @@ ++:2:36: Stray ";" +diff --git a/tests/qapi-schema/funny-char.exit b/tests/qapi-schema/funny-char.exit +index 573541a..d00491f 100644 +--- a/tests/qapi-schema/funny-char.exit ++++ b/tests/qapi-schema/funny-char.exit +@@ -1 +1 @@ +-0 ++1 +diff --git a/tests/qapi-schema/funny-char.out b/tests/qapi-schema/funny-char.out +index e3bd904..e69de29 100644 +--- a/tests/qapi-schema/funny-char.out ++++ b/tests/qapi-schema/funny-char.out +@@ -1,3 +0,0 @@ +-[OrderedDict([('enum', 'Status'), ('data', ['good', 'bad', 'ugly'])])] +-['Status'] +-[] +-- +1.7.11.7 + diff --git a/SOURCES/kvm-qapi.py-Rename-expr_eval-to-expr-in-parse_schema.patch b/SOURCES/kvm-qapi.py-Rename-expr_eval-to-expr-in-parse_schema.patch new file mode 100644 index 0000000..3da085b --- /dev/null +++ b/SOURCES/kvm-qapi.py-Rename-expr_eval-to-expr-in-parse_schema.patch @@ -0,0 +1,65 @@ +From 51b573c7eea7a3bcaa7cd45c0b0ee39c6c912414 Mon Sep 17 00:00:00 2001 +Message-Id: <51b573c7eea7a3bcaa7cd45c0b0ee39c6c912414.1387369730.git.minovotn@redhat.com> +In-Reply-To: <091eecc4fa42754760dfff393dabcc2b444e9693.1387369730.git.minovotn@redhat.com> +References: <091eecc4fa42754760dfff393dabcc2b444e9693.1387369730.git.minovotn@redhat.com> +From: Markus Armbruster +Date: Tue, 10 Dec 2013 15:29:18 +0100 +Subject: [PATCH 18/21] qapi.py: Rename expr_eval to expr in parse_schema() + +RH-Author: Markus Armbruster +Message-id: <1386689361-30281-16-git-send-email-armbru@redhat.com> +Patchwork-id: 56132 +O-Subject: [PATCH 7.0 qemu-kvm 15/18] qapi.py: Rename expr_eval to expr in parse_schema() +Bugzilla: 997915 +RH-Acked-by: Laszlo Ersek +RH-Acked-by: Kevin Wolf +RH-Acked-by: Luiz Capitulino + +From: Markus Armbruster + +Signed-off-by: Markus Armbruster +Reviewed-by: Eric Blake +Message-id: 1374939721-7876-9-git-send-email-armbru@redhat.com +Signed-off-by: Anthony Liguori +(cherry picked from commit 28b8bd4c759389bdc8430acfa588a23e4a9a7fb8) +--- + scripts/qapi.py | 18 +++++++++--------- + 1 file changed, 9 insertions(+), 9 deletions(-) + +Signed-off-by: Michal Novotny +--- + scripts/qapi.py | 18 +++++++++--------- + 1 file changed, 9 insertions(+), 9 deletions(-) + +diff --git a/scripts/qapi.py b/scripts/qapi.py +index 75fc282..f64b7b2 100644 +--- a/scripts/qapi.py ++++ b/scripts/qapi.py +@@ -168,15 +168,15 @@ def parse_schema(fp): + + exprs = [] + +- for expr_eval in schema.exprs: +- if expr_eval.has_key('enum'): +- add_enum(expr_eval['enum']) +- elif expr_eval.has_key('union'): +- add_union(expr_eval) +- add_enum('%sKind' % expr_eval['union']) +- elif expr_eval.has_key('type'): +- add_struct(expr_eval) +- exprs.append(expr_eval) ++ for expr in schema.exprs: ++ if expr.has_key('enum'): ++ add_enum(expr['enum']) ++ elif expr.has_key('union'): ++ add_union(expr) ++ add_enum('%sKind' % expr['union']) ++ elif expr.has_key('type'): ++ add_struct(expr) ++ exprs.append(expr) + + return exprs + +-- +1.7.11.7 + diff --git a/SOURCES/kvm-qapi.py-Restructure-lexer-and-parser.patch b/SOURCES/kvm-qapi.py-Restructure-lexer-and-parser.patch new file mode 100644 index 0000000..3a82e26 --- /dev/null +++ b/SOURCES/kvm-qapi.py-Restructure-lexer-and-parser.patch @@ -0,0 +1,333 @@ +From db918ab21be13a3c1f3c65d3821c06cf12528099 Mon Sep 17 00:00:00 2001 +Message-Id: +In-Reply-To: <091eecc4fa42754760dfff393dabcc2b444e9693.1387369730.git.minovotn@redhat.com> +References: <091eecc4fa42754760dfff393dabcc2b444e9693.1387369730.git.minovotn@redhat.com> +From: Markus Armbruster +Date: Tue, 10 Dec 2013 15:29:13 +0100 +Subject: [PATCH 13/21] qapi.py: Restructure lexer and parser + +RH-Author: Markus Armbruster +Message-id: <1386689361-30281-11-git-send-email-armbru@redhat.com> +Patchwork-id: 56127 +O-Subject: [PATCH 7.0 qemu-kvm 10/18] qapi.py: Restructure lexer and parser +Bugzilla: 997915 +RH-Acked-by: Laszlo Ersek +RH-Acked-by: Kevin Wolf +RH-Acked-by: Luiz Capitulino + +From: Markus Armbruster + +The parser has a rather unorthodox structure: + + Until EOF: + + Read a section: + + Generator function get_expr() yields one section after the + other, as a string. An unindented, non-empty line that + isn't a comment starts a new section. + + Lexing: + + Split section into a list of tokens (strings), with help + of generator function tokenize(). + + Parsing: + + Parse the first expression from the list of tokens, with + parse(), throw away any remaining tokens. + + In parse_schema(): record value of an enum, union or + struct key (if any) in the appropriate global table, + append expression to the list of expressions. + + Return list of expressions. + +Known issues: + +(1) Indentation is significant, unlike in real JSON. + +(2) Neither lexer nor parser have any idea of source positions. Error + reporting is hard, let's go shopping. + +(3) The one error we bother to detect, we "report" via raise. + +(4) The lexer silently ignores invalid characters. + +(5) If everything in a section gets ignored, the parser crashes. + +(6) The lexer treats a string containing a structural character exactly + like the structural character. + +(7) Tokens trailing the first expression in a section are silently + ignored. + +(8) The parser accepts any token in place of a colon. + +(9) The parser treats comma as optional. + +(10) parse() crashes on unexpected EOF. + +(11) parse_schema() crashes when a section's expression isn't a JSON + object. + +Replace this piece of original art by a thoroughly unoriginal design. +Takes care of (1), (2), (5), (6) and (7), and lays the groundwork for +addressing the others. Generated source files remain unchanged. + +Signed-off-by: Markus Armbruster +Reviewed-by: Eric Blake +Message-id: 1374939721-7876-4-git-send-email-armbru@redhat.com +Signed-off-by: Anthony Liguori +(cherry picked from commit c7a3f25200c8692e969f21c7f2555630ec0d0d30) +--- + scripts/qapi.py | 163 +++++++++++++------------ + tests/qapi-schema/indented-expr.out | 2 +- + tests/qapi-schema/missing-colon.out | 4 +- + tests/qapi-schema/quoted-structural-chars.err | 1 + + tests/qapi-schema/quoted-structural-chars.exit | 2 +- + tests/qapi-schema/quoted-structural-chars.out | 3 - + 6 files changed, 88 insertions(+), 87 deletions(-) + +Signed-off-by: Michal Novotny +--- + scripts/qapi.py | 163 +++++++++++++------------ + tests/qapi-schema/indented-expr.out | 2 +- + tests/qapi-schema/missing-colon.out | 4 +- + tests/qapi-schema/quoted-structural-chars.err | 1 + + tests/qapi-schema/quoted-structural-chars.exit | 2 +- + tests/qapi-schema/quoted-structural-chars.out | 3 - + 6 files changed, 88 insertions(+), 87 deletions(-) + +diff --git a/scripts/qapi.py b/scripts/qapi.py +index 38c808e..58e315b 100644 +--- a/scripts/qapi.py ++++ b/scripts/qapi.py +@@ -2,9 +2,11 @@ + # QAPI helper library + # + # Copyright IBM, Corp. 2011 ++# Copyright (c) 2013 Red Hat Inc. + # + # Authors: + # Anthony Liguori ++# Markus Armbruster + # + # This work is licensed under the terms of the GNU GPLv2. + # See the COPYING.LIB file in the top-level directory. +@@ -32,91 +34,92 @@ builtin_type_qtypes = { + 'uint64': 'QTYPE_QINT', + } + +-def tokenize(data): +- while len(data): +- ch = data[0] +- data = data[1:] +- if ch in ['{', '}', ':', ',', '[', ']']: +- yield ch +- elif ch in ' \n': +- None +- elif ch == "'": +- string = '' +- esc = False +- while True: +- if (data == ''): +- raise Exception("Mismatched quotes") +- ch = data[0] +- data = data[1:] +- if esc: +- string += ch +- esc = False +- elif ch == "\\": +- esc = True +- elif ch == "'": +- break +- else: +- string += ch +- yield string +- +-def parse(tokens): +- if tokens[0] == '{': +- ret = OrderedDict() +- tokens = tokens[1:] +- while tokens[0] != '}': +- key = tokens[0] +- tokens = tokens[1:] +- +- tokens = tokens[1:] # : +- +- value, tokens = parse(tokens) +- +- if tokens[0] == ',': +- tokens = tokens[1:] +- +- ret[key] = value +- tokens = tokens[1:] +- return ret, tokens +- elif tokens[0] == '[': +- ret = [] +- tokens = tokens[1:] +- while tokens[0] != ']': +- value, tokens = parse(tokens) +- if tokens[0] == ',': +- tokens = tokens[1:] +- ret.append(value) +- tokens = tokens[1:] +- return ret, tokens +- else: +- return tokens[0], tokens[1:] +- +-def evaluate(string): +- return parse(map(lambda x: x, tokenize(string)))[0] +- +-def get_expr(fp): +- expr = '' +- +- for line in fp: +- if line.startswith('#') or line == '\n': +- continue +- +- if line.startswith(' '): +- expr += line +- elif expr: +- yield expr +- expr = line ++class QAPISchema: ++ ++ def __init__(self, fp): ++ self.fp = fp ++ self.src = fp.read() ++ if self.src == '' or self.src[-1] != '\n': ++ self.src += '\n' ++ self.cursor = 0 ++ self.exprs = [] ++ self.accept() ++ ++ while self.tok != None: ++ self.exprs.append(self.get_expr()) ++ ++ def accept(self): ++ while True: ++ bol = self.cursor == 0 or self.src[self.cursor-1] == '\n' ++ self.tok = self.src[self.cursor] ++ self.cursor += 1 ++ self.val = None ++ ++ if self.tok == '#' and bol: ++ self.cursor = self.src.find('\n', self.cursor) ++ elif self.tok in ['{', '}', ':', ',', '[', ']']: ++ return ++ elif self.tok == "'": ++ string = '' ++ esc = False ++ while True: ++ ch = self.src[self.cursor] ++ self.cursor += 1 ++ if ch == '\n': ++ raise Exception("Mismatched quotes") ++ if esc: ++ string += ch ++ esc = False ++ elif ch == "\\": ++ esc = True ++ elif ch == "'": ++ self.val = string ++ return ++ else: ++ string += ch ++ elif self.tok == '\n': ++ if self.cursor == len(self.src): ++ self.tok = None ++ return ++ ++ def get_members(self): ++ expr = OrderedDict() ++ while self.tok != '}': ++ key = self.val ++ self.accept() ++ self.accept() # : ++ expr[key] = self.get_expr() ++ if self.tok == ',': ++ self.accept() ++ self.accept() ++ return expr ++ ++ def get_values(self): ++ expr = [] ++ while self.tok != ']': ++ expr.append(self.get_expr()) ++ if self.tok == ',': ++ self.accept() ++ self.accept() ++ return expr ++ ++ def get_expr(self): ++ if self.tok == '{': ++ self.accept() ++ expr = self.get_members() ++ elif self.tok == '[': ++ self.accept() ++ expr = self.get_values() + else: +- expr += line +- +- if expr: +- yield expr ++ expr = self.val ++ self.accept() ++ return expr + + def parse_schema(fp): ++ schema = QAPISchema(fp) + exprs = [] + +- for expr in get_expr(fp): +- expr_eval = evaluate(expr) +- ++ for expr_eval in schema.exprs: + if expr_eval.has_key('enum'): + add_enum(expr_eval['enum']) + elif expr_eval.has_key('union'): +diff --git a/tests/qapi-schema/indented-expr.out b/tests/qapi-schema/indented-expr.out +index 98ae692..98af89a 100644 +--- a/tests/qapi-schema/indented-expr.out ++++ b/tests/qapi-schema/indented-expr.out +@@ -1,3 +1,3 @@ +-[OrderedDict([('id', 'eins')])] ++[OrderedDict([('id', 'eins')]), OrderedDict([('id', 'zwei')])] + [] + [] +diff --git a/tests/qapi-schema/missing-colon.out b/tests/qapi-schema/missing-colon.out +index 50f827e..e67068c 100644 +--- a/tests/qapi-schema/missing-colon.out ++++ b/tests/qapi-schema/missing-colon.out +@@ -1,3 +1,3 @@ +-[OrderedDict([('enum', ','), ('data', ['good', 'bad', 'ugly'])])] +-[','] ++[OrderedDict([('enum', None), ('data', ['good', 'bad', 'ugly'])])] ++[None] + [] +diff --git a/tests/qapi-schema/quoted-structural-chars.err b/tests/qapi-schema/quoted-structural-chars.err +index e69de29..48c849d 100644 +--- a/tests/qapi-schema/quoted-structural-chars.err ++++ b/tests/qapi-schema/quoted-structural-chars.err +@@ -0,0 +1 @@ ++Crashed: +diff --git a/tests/qapi-schema/quoted-structural-chars.exit b/tests/qapi-schema/quoted-structural-chars.exit +index 573541a..d00491f 100644 +--- a/tests/qapi-schema/quoted-structural-chars.exit ++++ b/tests/qapi-schema/quoted-structural-chars.exit +@@ -1 +1 @@ +-0 ++1 +diff --git a/tests/qapi-schema/quoted-structural-chars.out b/tests/qapi-schema/quoted-structural-chars.out +index 85405be..e69de29 100644 +--- a/tests/qapi-schema/quoted-structural-chars.out ++++ b/tests/qapi-schema/quoted-structural-chars.out +@@ -1,3 +0,0 @@ +-[OrderedDict([('key1', 'value1'), ('key2', [])])] +-[] +-[] +-- +1.7.11.7 + diff --git a/SOURCES/kvm-qcow2-Add-missing-space-in-error-message.patch b/SOURCES/kvm-qcow2-Add-missing-space-in-error-message.patch new file mode 100644 index 0000000..bb1ed41 --- /dev/null +++ b/SOURCES/kvm-qcow2-Add-missing-space-in-error-message.patch @@ -0,0 +1,49 @@ +From 6f9e5c8e3d7e3251af3e047e01ae38cc26b41a4e Mon Sep 17 00:00:00 2001 +From: Max Reitz +Date: Tue, 7 Jan 2014 21:57:16 +0100 +Subject: [PATCH 11/14] qcow2: Add missing space in error message + +RH-Author: Max Reitz +Message-id: <1389131839-12920-12-git-send-email-mreitz@redhat.com> +Patchwork-id: 56547 +O-Subject: [RHEL-7.0 qemu-kvm PATCH v2 11/14] qcow2: Add missing space in error message +Bugzilla: 1033490 +RH-Acked-by: Kevin Wolf +RH-Acked-by: Fam Zheng +RH-Acked-by: Stefan Hajnoczi + +BZ: 1033490 + +The error message in qcow2_downgrade about an unsupported refcount +order is missing a space. This patch adds it. + +Signed-off-by: Max Reitz +Signed-off-by: Kevin Wolf +(cherry picked from commit 9e3f08923a14ba0655c6797edd9ffef44bb8cbf2) + +Signed-off-by: Max Reitz +--- + block/qcow2.c | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +Signed-off-by: Miroslav Rezanina +--- + block/qcow2.c | 2 +- + 1 files changed, 1 insertions(+), 1 deletions(-) + +diff --git a/block/qcow2.c b/block/qcow2.c +index 5b28259..3f7fd51 100644 +--- a/block/qcow2.c ++++ b/block/qcow2.c +@@ -2013,7 +2013,7 @@ static int qcow2_downgrade(BlockDriverState *bs, int target_version) + * support anything different than 4 anyway, there is no point in doing + * so right now; however, we should error out (if qemu supports this in + * the future and this code has not been adapted) */ +- error_report("qcow2_downgrade: Image refcount orders other than 4 are" ++ error_report("qcow2_downgrade: Image refcount orders other than 4 are " + "currently not supported."); + return -ENOTSUP; + } +-- +1.7.1 + diff --git a/SOURCES/kvm-qcow2-Avoid-integer-overflow-in-get_refcount-CVE-201.patch b/SOURCES/kvm-qcow2-Avoid-integer-overflow-in-get_refcount-CVE-201.patch new file mode 100644 index 0000000..a202fe4 --- /dev/null +++ b/SOURCES/kvm-qcow2-Avoid-integer-overflow-in-get_refcount-CVE-201.patch @@ -0,0 +1,41 @@ +From e6dafe932ca93e980ae277ad34926385dd78b75f Mon Sep 17 00:00:00 2001 +From: Kevin Wolf +Date: Tue, 25 Mar 2014 14:23:35 +0100 +Subject: [PATCH 28/49] qcow2: Avoid integer overflow in get_refcount (CVE-2014-0143) + +RH-Author: Kevin Wolf +Message-id: <1395753835-7591-29-git-send-email-kwolf@redhat.com> +Patchwork-id: n/a +O-Subject: [virt-devel] [EMBARGOED RHEL-7.0 qemu-kvm PATCH 28/48] qcow2: Avoid integer overflow in get_refcount (CVE-2014-0143) +Bugzilla: 1079320 +RH-Acked-by: Jeff Cody +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Paolo Bonzini + +Bugzilla: https://bugzilla.redhat.com/show_bug.cgi?id=1079320 +Upstream status: Embargoed + +This ensures that the checks catch all invalid cluster indexes +instead of returning the refcount of a wrong cluster. + +Signed-off-by: Kevin Wolf +--- + block/qcow2-refcount.c | 2 +- + 1 files changed, 1 insertions(+), 1 deletions(-) + +diff --git a/block/qcow2-refcount.c b/block/qcow2-refcount.c +index 54bcbd1..c08fb08 100644 +--- a/block/qcow2-refcount.c ++++ b/block/qcow2-refcount.c +@@ -89,7 +89,7 @@ static int load_refcount_block(BlockDriverState *bs, + static int get_refcount(BlockDriverState *bs, int64_t cluster_index) + { + BDRVQcowState *s = bs->opaque; +- int refcount_table_index, block_index; ++ uint64_t refcount_table_index, block_index; + int64_t refcount_block_offset; + int ret; + uint16_t *refcount_block; +-- +1.7.1 + diff --git a/SOURCES/kvm-qcow2-Change-default-for-new-images-to-compat-1.1.patch b/SOURCES/kvm-qcow2-Change-default-for-new-images-to-compat-1.1.patch new file mode 100644 index 0000000..5776ece --- /dev/null +++ b/SOURCES/kvm-qcow2-Change-default-for-new-images-to-compat-1.1.patch @@ -0,0 +1,56 @@ +From 4c29b332e7b5f03619481a6eab9690f96ae665f2 Mon Sep 17 00:00:00 2001 +From: Kevin Wolf +Date: Fri, 22 Nov 2013 14:23:29 +0100 +Subject: [PATCH 11/14] qcow2: Change default for new images to compat=1.1 + +RH-Author: Kevin Wolf +Message-id: <1385130210-31063-2-git-send-email-kwolf@redhat.com> +Patchwork-id: 55856 +O-Subject: [RHEL-7.0 qemu-kvm PATCH 1/2] qcow2: Change default for new images to compat=1.1 +Bugzilla: 1026739 +RH-Acked-by: Max Reitz +RH-Acked-by: Fam Zheng +RH-Acked-by: Paolo Bonzini + +By the time that qemu 1.7 will be released, enough time will have passed +since qemu 1.1, which is the first version to understand version 3 +images, that changing the default shouldn't hurt many people any more +and the benefits of using the new format outweigh the pain. + +qemu-iotests already runs with compat=1.1 by default. + +Signed-off-by: Kevin Wolf +Reviewed-by: Stefan Hajnoczi +Reviewed-by: Eric Blake +Signed-off-by: Stefan Hajnoczi +(cherry picked from commit 8ad1898cf1f5314731123afce057e5cf74fd2f01) + +Conflicts: + block/qcow2.c + +Signed-off-by: Kevin Wolf +--- + block/qcow2.c | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +Signed-off-by: Miroslav Rezanina +--- + block/qcow2.c | 2 +- + 1 files changed, 1 insertions(+), 1 deletions(-) + +diff --git a/block/qcow2.c b/block/qcow2.c +index f852d64..897e48a 100644 +--- a/block/qcow2.c ++++ b/block/qcow2.c +@@ -1598,7 +1598,7 @@ static int qcow2_create(const char *filename, QEMUOptionParameter *options, + int flags = 0; + size_t cluster_size = DEFAULT_CLUSTER_SIZE; + int prealloc = 0; +- int version = 2; ++ int version = 3; + Error *local_err = NULL; + int ret; + +-- +1.7.1 + diff --git a/SOURCES/kvm-qcow2-Check-backing_file_offset-CVE-2014-0144.patch b/SOURCES/kvm-qcow2-Check-backing_file_offset-CVE-2014-0144.patch new file mode 100644 index 0000000..9d5a8da --- /dev/null +++ b/SOURCES/kvm-qcow2-Check-backing_file_offset-CVE-2014-0144.patch @@ -0,0 +1,95 @@ +From ffbffdc438191db5bfa6ae6da52f0578db0fe7ac Mon Sep 17 00:00:00 2001 +From: Kevin Wolf +Date: Tue, 25 Mar 2014 14:23:28 +0100 +Subject: [PATCH 21/49] qcow2: Check backing_file_offset (CVE-2014-0144) + +RH-Author: Kevin Wolf +Message-id: <1395753835-7591-22-git-send-email-kwolf@redhat.com> +Patchwork-id: n/a +O-Subject: [virt-devel] [EMBARGOED RHEL-7.0 qemu-kvm PATCH 21/48] qcow2: Check backing_file_offset (CVE-2014-0144) +Bugzilla: 1079455 +RH-Acked-by: Jeff Cody +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Paolo Bonzini + +Bugzilla: https://bugzilla.redhat.com/show_bug.cgi?id=1079455 +Upstream status: Embargoed + +Header, header extension and the backing file name must all be stored in +the first cluster. Setting the backing file to a much higher value +allowed header extensions to become much bigger than we want them to be +(unbounded allocation). + +Signed-off-by: Kevin Wolf +--- + block/qcow2.c | 6 ++++++ + tests/qemu-iotests/080 | 12 ++++++++++++ + tests/qemu-iotests/080.out | 7 +++++++ + 3 files changed, 25 insertions(+), 0 deletions(-) + +diff --git a/block/qcow2.c b/block/qcow2.c +index ea51f8e..5568cf9 100644 +--- a/block/qcow2.c ++++ b/block/qcow2.c +@@ -511,6 +511,12 @@ static int qcow2_open(BlockDriverState *bs, QDict *options, int flags, + } + } + ++ if (header.backing_file_offset > s->cluster_size) { ++ error_setg(errp, "Invalid backing file offset"); ++ ret = -EINVAL; ++ goto fail; ++ } ++ + if (header.backing_file_offset) { + ext_end = header.backing_file_offset; + } else { +diff --git a/tests/qemu-iotests/080 b/tests/qemu-iotests/080 +index 6512701..6d588dd 100755 +--- a/tests/qemu-iotests/080 ++++ b/tests/qemu-iotests/080 +@@ -43,6 +43,8 @@ _supported_proto generic + _supported_os Linux + + header_size=104 ++ ++offset_backing_file_offset=8 + offset_header_size=100 + offset_ext_magic=$header_size + offset_ext_size=$((header_size + 4)) +@@ -55,6 +57,16 @@ poke_file "$TEST_IMG" "$offset_header_size" "\xff\xff\xff\xff" + poke_file "$TEST_IMG" "$offset_header_size" "\x7f\xff\xff\xff" + { $QEMU_IO -c "read 0 512" $TEST_IMG; } 2>&1 | _filter_qemu_io | _filter_testdir + ++echo ++echo "== Huge unknown header extension ==" ++_make_test_img 64M ++poke_file "$TEST_IMG" "$offset_backing_file_offset" "\xff\xff\xff\xff\xff\xff\xff\xff" ++poke_file "$TEST_IMG" "$offset_ext_magic" "\x12\x34\x56\x78" ++poke_file "$TEST_IMG" "$offset_ext_size" "\x7f\xff\xff\xff" ++{ $QEMU_IO -c "read 0 512" $TEST_IMG; } 2>&1 | _filter_qemu_io | _filter_testdir ++poke_file "$TEST_IMG" "$offset_backing_file_offset" "\x00\x00\x00\x00\x00\x00\x00\x00" ++{ $QEMU_IO -c "read 0 512" $TEST_IMG; } 2>&1 | _filter_qemu_io | _filter_testdir ++ + # success, all done + echo "*** done" + rm -f $seq.full +diff --git a/tests/qemu-iotests/080.out b/tests/qemu-iotests/080.out +index 41a166a..48c40aa 100644 +--- a/tests/qemu-iotests/080.out ++++ b/tests/qemu-iotests/080.out +@@ -6,4 +6,11 @@ qemu-io: can't open device TEST_DIR/t.qcow2: qcow2 header exceeds cluster size + no file open, try 'help open' + qemu-io: can't open device TEST_DIR/t.qcow2: qcow2 header exceeds cluster size + no file open, try 'help open' ++ ++== Huge unknown header extension == ++Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864 ++qemu-io: can't open device TEST_DIR/t.qcow2: Invalid backing file offset ++no file open, try 'help open' ++qemu-io: can't open device TEST_DIR/t.qcow2: Header extension too large ++no file open, try 'help open' + *** done +-- +1.7.1 + diff --git a/SOURCES/kvm-qcow2-Check-bs-drv-in-copy_sectors.patch b/SOURCES/kvm-qcow2-Check-bs-drv-in-copy_sectors.patch new file mode 100644 index 0000000..612eba3 --- /dev/null +++ b/SOURCES/kvm-qcow2-Check-bs-drv-in-copy_sectors.patch @@ -0,0 +1,53 @@ +From d8f974ead4b4c1f549441e7aac96262cf2b754ee Mon Sep 17 00:00:00 2001 +From: Max Reitz +Date: Mon, 17 Mar 2014 22:45:29 +0100 +Subject: [PATCH 4/6] qcow2: Check bs->drv in copy_sectors() + +RH-Author: Max Reitz +Message-id: <1395096331-12610-2-git-send-email-mreitz@redhat.com> +Patchwork-id: 58119 +O-Subject: [RHEL-7.0 qemu-kvm PATCH 1/3] qcow2: Check bs->drv in copy_sectors() +Bugzilla: 1048575 +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Kevin Wolf +RH-Acked-by: Fam Zheng + +BZ: 1048575 + +Before dereferencing bs->drv for a call to its member bdrv_co_readv(), +copy_sectors() should check whether that pointer is indeed valid, since +it may have been set to NULL by e.g. a concurrent write triggering the +corruption prevention mechanism. + +Signed-off-by: Max Reitz +Signed-off-by: Stefan Hajnoczi +(cherry picked from commit dba2855572c746836ad90ce9154403b5929d996b) + +Signed-off-by: Max Reitz +--- + block/qcow2-cluster.c | 4 ++++ + 1 file changed, 4 insertions(+) + +Signed-off-by: Miroslav Rezanina +--- + block/qcow2-cluster.c | 4 ++++ + 1 files changed, 4 insertions(+), 0 deletions(-) + +diff --git a/block/qcow2-cluster.c b/block/qcow2-cluster.c +index 862df0f..87c13ce 100644 +--- a/block/qcow2-cluster.c ++++ b/block/qcow2-cluster.c +@@ -370,6 +370,10 @@ static int coroutine_fn copy_sectors(BlockDriverState *bs, + + BLKDBG_EVENT(bs->file, BLKDBG_COW_READ); + ++ if (!bs->drv) { ++ return -ENOMEDIUM; ++ } ++ + /* Call .bdrv_co_readv() directly instead of using the public block-layer + * interface. This avoids double I/O throttling and request tracking, + * which can lead to deadlock when block layer copy-on-read is enabled. +-- +1.7.1 + diff --git a/SOURCES/kvm-qcow2-Check-header_length-CVE-2014-0144.patch b/SOURCES/kvm-qcow2-Check-header_length-CVE-2014-0144.patch new file mode 100644 index 0000000..fa78632 --- /dev/null +++ b/SOURCES/kvm-qcow2-Check-header_length-CVE-2014-0144.patch @@ -0,0 +1,197 @@ +From 34d9d86de2d566b4c9ecd1ed0294edc0bb95bec6 Mon Sep 17 00:00:00 2001 +From: Kevin Wolf +Date: Tue, 25 Mar 2014 14:23:27 +0100 +Subject: [PATCH 20/49] qcow2: Check header_length (CVE-2014-0144) + +RH-Author: Kevin Wolf +Message-id: <1395753835-7591-21-git-send-email-kwolf@redhat.com> +Patchwork-id: n/a +O-Subject: [virt-devel] [EMBARGOED RHEL-7.0 qemu-kvm PATCH 20/48] qcow2: Check header_length (CVE-2014-0144) +Bugzilla: 1079455 +RH-Acked-by: Jeff Cody +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Paolo Bonzini + +Bugzilla: https://bugzilla.redhat.com/show_bug.cgi?id=1079455 +Upstream status: Embargoed + +This fixes an unbounded allocation for s->unknown_header_fields. + +Signed-off-by: Kevin Wolf + +Conflicts: +tests/qemu-iotests/group + +Signed-off-by: Kevin Wolf +--- + block/qcow2.c | 34 ++++++++++++++++++------ + tests/qemu-iotests/080 | 61 ++++++++++++++++++++++++++++++++++++++++++++ + tests/qemu-iotests/080.out | 9 ++++++ + tests/qemu-iotests/group | 1 + + 4 files changed, 96 insertions(+), 9 deletions(-) + create mode 100755 tests/qemu-iotests/080 + create mode 100644 tests/qemu-iotests/080.out + +diff --git a/block/qcow2.c b/block/qcow2.c +index 18e136e..ea51f8e 100644 +--- a/block/qcow2.c ++++ b/block/qcow2.c +@@ -460,6 +460,18 @@ static int qcow2_open(BlockDriverState *bs, QDict *options, int flags, + + s->qcow_version = header.version; + ++ /* Initialise cluster size */ ++ if (header.cluster_bits < MIN_CLUSTER_BITS || ++ header.cluster_bits > MAX_CLUSTER_BITS) { ++ error_setg(errp, "Unsupported cluster size: 2^%i", header.cluster_bits); ++ ret = -EINVAL; ++ goto fail; ++ } ++ ++ s->cluster_bits = header.cluster_bits; ++ s->cluster_size = 1 << s->cluster_bits; ++ s->cluster_sectors = 1 << (s->cluster_bits - 9); ++ + /* Initialise version 3 header fields */ + if (header.version == 2) { + header.incompatible_features = 0; +@@ -473,6 +485,18 @@ static int qcow2_open(BlockDriverState *bs, QDict *options, int flags, + be64_to_cpus(&header.autoclear_features); + be32_to_cpus(&header.refcount_order); + be32_to_cpus(&header.header_length); ++ ++ if (header.header_length < 104) { ++ error_setg(errp, "qcow2 header too short"); ++ ret = -EINVAL; ++ goto fail; ++ } ++ } ++ ++ if (header.header_length > s->cluster_size) { ++ error_setg(errp, "qcow2 header exceeds cluster size"); ++ ret = -EINVAL; ++ goto fail; + } + + if (header.header_length > sizeof(header)) { +@@ -529,12 +553,6 @@ static int qcow2_open(BlockDriverState *bs, QDict *options, int flags, + } + s->refcount_order = header.refcount_order; + +- if (header.cluster_bits < MIN_CLUSTER_BITS || +- header.cluster_bits > MAX_CLUSTER_BITS) { +- error_setg(errp, "Unsupported cluster size: 2^%i", header.cluster_bits); +- ret = -EINVAL; +- goto fail; +- } + if (header.crypt_method > QCOW_CRYPT_AES) { + error_setg(errp, "Unsupported encryption method: %i", + header.crypt_method); +@@ -545,9 +563,7 @@ static int qcow2_open(BlockDriverState *bs, QDict *options, int flags, + if (s->crypt_method_header) { + bs->encrypted = 1; + } +- s->cluster_bits = header.cluster_bits; +- s->cluster_size = 1 << s->cluster_bits; +- s->cluster_sectors = 1 << (s->cluster_bits - 9); ++ + s->l2_bits = s->cluster_bits - 3; /* L2 is always one cluster */ + s->l2_size = 1 << s->l2_bits; + bs->total_sectors = header.size / 512; +diff --git a/tests/qemu-iotests/080 b/tests/qemu-iotests/080 +new file mode 100755 +index 0000000..6512701 +--- /dev/null ++++ b/tests/qemu-iotests/080 +@@ -0,0 +1,61 @@ ++#!/bin/bash ++# ++# qcow2 format input validation tests ++# ++# Copyright (C) 2013 Red Hat, Inc. ++# ++# This program is free software; you can redistribute it and/or modify ++# it under the terms of the GNU General Public License as published by ++# the Free Software Foundation; either version 2 of the License, or ++# (at your option) any later version. ++# ++# This program is distributed in the hope that it will be useful, ++# but WITHOUT ANY WARRANTY; without even the implied warranty of ++# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++# GNU General Public License for more details. ++# ++# You should have received a copy of the GNU General Public License ++# along with this program. If not, see . ++# ++ ++# creator ++owner=kwolf@redhat.com ++ ++seq=`basename $0` ++echo "QA output created by $seq" ++ ++here=`pwd` ++tmp=/tmp/$$ ++status=1 # failure is the default! ++ ++_cleanup() ++{ ++ _cleanup_test_img ++} ++trap "_cleanup; exit \$status" 0 1 2 3 15 ++ ++# get standard environment, filters and checks ++. ./common.rc ++. ./common.filter ++ ++_supported_fmt qcow2 ++_supported_proto generic ++_supported_os Linux ++ ++header_size=104 ++offset_header_size=100 ++offset_ext_magic=$header_size ++offset_ext_size=$((header_size + 4)) ++ ++echo ++echo "== Huge header size ==" ++_make_test_img 64M ++poke_file "$TEST_IMG" "$offset_header_size" "\xff\xff\xff\xff" ++{ $QEMU_IO -c "read 0 512" $TEST_IMG; } 2>&1 | _filter_qemu_io | _filter_testdir ++poke_file "$TEST_IMG" "$offset_header_size" "\x7f\xff\xff\xff" ++{ $QEMU_IO -c "read 0 512" $TEST_IMG; } 2>&1 | _filter_qemu_io | _filter_testdir ++ ++# success, all done ++echo "*** done" ++rm -f $seq.full ++status=0 +diff --git a/tests/qemu-iotests/080.out b/tests/qemu-iotests/080.out +new file mode 100644 +index 0000000..41a166a +--- /dev/null ++++ b/tests/qemu-iotests/080.out +@@ -0,0 +1,9 @@ ++QA output created by 080 ++ ++== Huge header size == ++Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864 ++qemu-io: can't open device TEST_DIR/t.qcow2: qcow2 header exceeds cluster size ++no file open, try 'help open' ++qemu-io: can't open device TEST_DIR/t.qcow2: qcow2 header exceeds cluster size ++no file open, try 'help open' ++*** done +diff --git a/tests/qemu-iotests/group b/tests/qemu-iotests/group +index 7d0d07e..fc34194 100644 +--- a/tests/qemu-iotests/group ++++ b/tests/qemu-iotests/group +@@ -75,6 +75,7 @@ + 077 rw auto + 078 rw auto + 079 rw auto ++080 rw auto + 082 rw auto quick + 086 rw auto quick + 088 rw auto +-- +1.7.1 + diff --git a/SOURCES/kvm-qcow2-Check-maximum-L1-size-in-qcow2_snapshot_load_t.patch b/SOURCES/kvm-qcow2-Check-maximum-L1-size-in-qcow2_snapshot_load_t.patch new file mode 100644 index 0000000..13472e1 --- /dev/null +++ b/SOURCES/kvm-qcow2-Check-maximum-L1-size-in-qcow2_snapshot_load_t.patch @@ -0,0 +1,137 @@ +From b2472117867fc233fcb634b7370051bcb7fc892c Mon Sep 17 00:00:00 2001 +From: Kevin Wolf +Date: Tue, 25 Mar 2014 14:23:52 +0100 +Subject: [PATCH 45/49] qcow2: Check maximum L1 size in qcow2_snapshot_load_tmp() (CVE-2014-0143) + +RH-Author: Kevin Wolf +Message-id: <1395753835-7591-46-git-send-email-kwolf@redhat.com> +Patchwork-id: n/a +O-Subject: [virt-devel] [EMBARGOED RHEL-7.0 qemu-kvm PATCH 45/48] qcow2: Check maximum L1 size in qcow2_snapshot_load_tmp() (CVE-2014-0143) +Bugzilla: 1079320 +RH-Acked-by: Jeff Cody +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Paolo Bonzini + +Bugzilla: https://bugzilla.redhat.com/show_bug.cgi?id=1079320 +Upstream status: Embargoed + +This avoids an unbounded allocation. + +Signed-off-by: Kevin Wolf + +RHEL 7.0 doesn't have commit 7b4c4781, so use error_report() instead of +error_setg(). + +Signed-off-by: Kevin Wolf +--- + block/qcow2-snapshot.c | 4 ++++ + block/qcow2.c | 4 +--- + block/qcow2.h | 4 ++++ + tests/qemu-iotests/080 | 15 ++++++++++++++- + tests/qemu-iotests/080.out | 7 +++++++ + 5 files changed, 30 insertions(+), 4 deletions(-) + +diff --git a/block/qcow2-snapshot.c b/block/qcow2-snapshot.c +index b29f7bd..626a8d4 100644 +--- a/block/qcow2-snapshot.c ++++ b/block/qcow2-snapshot.c +@@ -635,6 +635,10 @@ int qcow2_snapshot_load_tmp(BlockDriverState *bs, const char *snapshot_name) + sn = &s->snapshots[snapshot_index]; + + /* Allocate and read in the snapshot's L1 table */ ++ if (sn->l1_size > QCOW_MAX_L1_SIZE) { ++ error_report("Snapshot L1 table too large"); ++ return -EFBIG; ++ } + new_l1_bytes = sn->l1_size * sizeof(uint64_t); + new_l1_table = g_malloc0(align_offset(new_l1_bytes, 512)); + +diff --git a/block/qcow2.c b/block/qcow2.c +index 33b46b8..3f8febc 100644 +--- a/block/qcow2.c ++++ b/block/qcow2.c +@@ -637,9 +637,7 @@ static int qcow2_open(BlockDriverState *bs, QDict *options, int flags, + } + + /* read the level 1 table */ +- if (header.l1_size > 0x2000000) { +- /* 32 MB L1 table is enough for 2 PB images at 64k cluster size +- * (128 GB for 512 byte clusters, 2 EB for 2 MB clusters) */ ++ if (header.l1_size > QCOW_MAX_L1_SIZE) { + error_setg(errp, "Active L1 table too large"); + ret = -EFBIG; + goto fail; +diff --git a/block/qcow2.h b/block/qcow2.h +index 9f9f5ae..87e256a 100644 +--- a/block/qcow2.h ++++ b/block/qcow2.h +@@ -44,6 +44,10 @@ + * (128 GB for 512 byte clusters, 2 EB for 2 MB clusters) */ + #define QCOW_MAX_REFTABLE_SIZE 0x800000 + ++/* 32 MB L1 table is enough for 2 PB images at 64k cluster size ++ * (128 GB for 512 byte clusters, 2 EB for 2 MB clusters) */ ++#define QCOW_MAX_L1_SIZE 0x2000000 ++ + /* indicate that the refcount of the referenced cluster is exactly one. */ + #define QCOW_OFLAG_COPIED (1LL << 63) + /* indicate that the cluster is compressed (they never have the copied flag) */ +diff --git a/tests/qemu-iotests/080 b/tests/qemu-iotests/080 +index 59e7a44..6b3a3e7 100755 +--- a/tests/qemu-iotests/080 ++++ b/tests/qemu-iotests/080 +@@ -30,7 +30,8 @@ status=1 # failure is the default! + + _cleanup() + { +- _cleanup_test_img ++ rm -f $TEST_IMG.snap ++ _cleanup_test_img + } + trap "_cleanup; exit \$status" 0 1 2 3 15 + +@@ -58,6 +59,10 @@ offset_ext_size=$((header_size + 4)) + + offset_l2_table_0=$((0x40000)) + ++offset_snap1=$((0x70000)) ++offset_snap1_l1_offset=$((offset_snap1 + 0)) ++offset_snap1_l1_size=$((offset_snap1 + 8)) ++ + echo + echo "== Huge header size ==" + _make_test_img 64M +@@ -161,6 +166,14 @@ poke_file "$TEST_IMG" "$offset_l2_table_0" "\xbf\xff\xff\xff\xff\xff\x00\x00" + poke_file "$TEST_IMG" "$offset_l2_table_0" "\x80\x00\x00\xff\xff\xff\x00\x00" + { $QEMU_IMG snapshot -c test $TEST_IMG; } 2>&1 | _filter_qemu_io | _filter_testdir + ++echo ++echo "== Invalid snapshot L1 table ==" ++_make_test_img 64M ++{ $QEMU_IO -c "write 0 512" $TEST_IMG; } 2>&1 | _filter_qemu_io | _filter_testdir ++{ $QEMU_IMG snapshot -c test $TEST_IMG; } 2>&1 | _filter_testdir ++poke_file "$TEST_IMG" "$offset_snap1_l1_size" "\x10\x00\x00\x00" ++{ $QEMU_IMG convert -s test $TEST_IMG $TEST_IMG.snap; } 2>&1 | _filter_testdir ++ + # success, all done + echo "*** done" + rm -f $seq.full +diff --git a/tests/qemu-iotests/080.out b/tests/qemu-iotests/080.out +index 4d84fbf..1fa0672 100644 +--- a/tests/qemu-iotests/080.out ++++ b/tests/qemu-iotests/080.out +@@ -74,4 +74,11 @@ wrote 512/512 bytes at offset 0 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) + qemu-img: Could not create snapshot 'test': -27 (File too large) + qemu-img: Could not create snapshot 'test': -11 (Resource temporarily unavailable) ++ ++== Invalid snapshot L1 table == ++Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864 ++wrote 512/512 bytes at offset 0 ++512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) ++qemu-img: Snapshot L1 table too large ++qemu-img: Failed to load snapshot + *** done +-- +1.7.1 + diff --git a/SOURCES/kvm-qcow2-Check-new-refcount-table-size-on-growth.patch b/SOURCES/kvm-qcow2-Check-new-refcount-table-size-on-growth.patch new file mode 100644 index 0000000..0f40181 --- /dev/null +++ b/SOURCES/kvm-qcow2-Check-new-refcount-table-size-on-growth.patch @@ -0,0 +1,92 @@ +From b2cd8e043a6b66ba225b98b6235fc050f956bf5b Mon Sep 17 00:00:00 2001 +From: Kevin Wolf +Date: Tue, 25 Mar 2014 14:23:36 +0100 +Subject: [PATCH 29/49] qcow2: Check new refcount table size on growth + +RH-Author: Kevin Wolf +Message-id: <1395753835-7591-30-git-send-email-kwolf@redhat.com> +Patchwork-id: n/a +O-Subject: [virt-devel] [EMBARGOED RHEL-7.0 qemu-kvm PATCH 29/48] qcow2: Check new refcount table size on growth +Bugzilla: 1066691 +RH-Acked-by: Jeff Cody +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Paolo Bonzini + +Bugzilla: https://bugzilla.redhat.com/show_bug.cgi?id=1066691 +Upstream status: Series embargoed + +If the size becomes larger than what qcow2_open() would accept, fail the +growing operation. + +Signed-off-by: Kevin Wolf + +Conflicts: +block/qcow2.h + +Signed-off-by: Kevin Wolf +--- + block/qcow2-refcount.c | 4 ++++ + block/qcow2.c | 4 +--- + block/qcow2.h | 9 +++++++++ + 3 files changed, 14 insertions(+), 3 deletions(-) + +diff --git a/block/qcow2-refcount.c b/block/qcow2-refcount.c +index c08fb08..7b00dda 100644 +--- a/block/qcow2-refcount.c ++++ b/block/qcow2-refcount.c +@@ -310,6 +310,10 @@ static int alloc_refcount_block(BlockDriverState *bs, + uint64_t refcount_block_clusters = 1 << (s->cluster_bits - REFCOUNT_SHIFT); + uint64_t blocks_used = DIV_ROUND_UP(cluster_index, refcount_block_clusters); + ++ if (blocks_used > QCOW_MAX_REFTABLE_SIZE / sizeof(uint64_t)) { ++ return -EFBIG; ++ } ++ + /* And now we need at least one block more for the new metadata */ + uint64_t table_size = next_refcount_table_size(s, blocks_used + 1); + uint64_t last_table_size; +diff --git a/block/qcow2.c b/block/qcow2.c +index 87f2958..db9f667 100644 +--- a/block/qcow2.c ++++ b/block/qcow2.c +@@ -608,9 +608,7 @@ static int qcow2_open(BlockDriverState *bs, QDict *options, int flags, + s->refcount_table_size = + header.refcount_table_clusters << (s->cluster_bits - 3); + +- if (header.refcount_table_clusters > (0x800000 >> s->cluster_bits)) { +- /* 8 MB refcount table is enough for 2 PB images at 64k cluster size +- * (128 GB for 512 byte clusters, 2 EB for 2 MB clusters) */ ++ if (header.refcount_table_clusters > qcow2_max_refcount_clusters(s)) { + error_setg(errp, "Reference count table too large"); + ret = -EINVAL; + goto fail; +diff --git a/block/qcow2.h b/block/qcow2.h +index 5efc96e..0173d95 100644 +--- a/block/qcow2.h ++++ b/block/qcow2.h +@@ -40,6 +40,10 @@ + #define QCOW_MAX_CRYPT_CLUSTERS 32 + #define QCOW_MAX_SNAPSHOTS 65536 + ++/* 8 MB refcount table is enough for 2 PB images at 64k cluster size ++ * (128 GB for 512 byte clusters, 2 EB for 2 MB clusters) */ ++#define QCOW_MAX_REFTABLE_SIZE 0x800000 ++ + /* indicate that the refcount of the referenced cluster is exactly one. */ + #define QCOW_OFLAG_COPIED (1LL << 63) + /* indicate that the cluster is compressed (they never have the copied flag) */ +@@ -405,6 +409,11 @@ static inline int64_t align_offset(int64_t offset, int n) + return offset; + } + ++static inline uint64_t qcow2_max_refcount_clusters(BDRVQcowState *s) ++{ ++ return QCOW_MAX_REFTABLE_SIZE >> s->cluster_bits; ++} ++ + static inline int qcow2_get_cluster_type(uint64_t l2_entry) + { + if (l2_entry & QCOW_OFLAG_COMPRESSED) { +-- +1.7.1 + diff --git a/SOURCES/kvm-qcow2-Check-refcount-table-size-CVE-2014-0144.patch b/SOURCES/kvm-qcow2-Check-refcount-table-size-CVE-2014-0144.patch new file mode 100644 index 0000000..85180c8 --- /dev/null +++ b/SOURCES/kvm-qcow2-Check-refcount-table-size-CVE-2014-0144.patch @@ -0,0 +1,116 @@ +From 0f9e33b29b76a647c903753a0758b9c85e75d73a Mon Sep 17 00:00:00 2001 +From: Kevin Wolf +Date: Tue, 25 Mar 2014 14:23:29 +0100 +Subject: [PATCH 22/49] qcow2: Check refcount table size (CVE-2014-0144) + +RH-Author: Kevin Wolf +Message-id: <1395753835-7591-23-git-send-email-kwolf@redhat.com> +Patchwork-id: n/a +O-Subject: [virt-devel] [EMBARGOED RHEL-7.0 qemu-kvm PATCH 22/48] qcow2: Check refcount table size (CVE-2014-0144) +Bugzilla: 1079455 +RH-Acked-by: Jeff Cody +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Paolo Bonzini + +Bugzilla: https://bugzilla.redhat.com/show_bug.cgi?id=1079455 +Upstream status: Embargoed + +Limit the in-memory reference count table size to 8 MB, it's enough in +practice. This fixes an unbounded allocation as well as a buffer +overflow in qcow2_refcount_init(). + +Signed-off-by: Kevin Wolf +--- + block/qcow2-refcount.c | 4 +++- + block/qcow2.c | 9 +++++++++ + tests/qemu-iotests/080 | 10 ++++++++++ + tests/qemu-iotests/080.out | 7 +++++++ + 4 files changed, 29 insertions(+), 1 deletions(-) + +diff --git a/block/qcow2-refcount.c b/block/qcow2-refcount.c +index 09c638f..13ea5f7 100644 +--- a/block/qcow2-refcount.c ++++ b/block/qcow2-refcount.c +@@ -40,8 +40,10 @@ static int QEMU_WARN_UNUSED_RESULT update_refcount(BlockDriverState *bs, + int qcow2_refcount_init(BlockDriverState *bs) + { + BDRVQcowState *s = bs->opaque; +- int ret, refcount_table_size2, i; ++ unsigned int refcount_table_size2, i; ++ int ret; + ++ assert(s->refcount_table_size <= INT_MAX / sizeof(uint64_t)); + refcount_table_size2 = s->refcount_table_size * sizeof(uint64_t); + s->refcount_table = g_malloc(refcount_table_size2); + if (s->refcount_table_size > 0) { +diff --git a/block/qcow2.c b/block/qcow2.c +index 5568cf9..a7780ac 100644 +--- a/block/qcow2.c ++++ b/block/qcow2.c +@@ -576,10 +576,19 @@ static int qcow2_open(BlockDriverState *bs, QDict *options, int flags, + s->csize_shift = (62 - (s->cluster_bits - 8)); + s->csize_mask = (1 << (s->cluster_bits - 8)) - 1; + s->cluster_offset_mask = (1LL << s->csize_shift) - 1; ++ + s->refcount_table_offset = header.refcount_table_offset; + s->refcount_table_size = + header.refcount_table_clusters << (s->cluster_bits - 3); + ++ if (header.refcount_table_clusters > (0x800000 >> s->cluster_bits)) { ++ /* 8 MB refcount table is enough for 2 PB images at 64k cluster size ++ * (128 GB for 512 byte clusters, 2 EB for 2 MB clusters) */ ++ error_setg(errp, "Reference count table too large"); ++ ret = -EINVAL; ++ goto fail; ++ } ++ + s->snapshots_offset = header.snapshots_offset; + s->nb_snapshots = header.nb_snapshots; + +diff --git a/tests/qemu-iotests/080 b/tests/qemu-iotests/080 +index 6d588dd..6179e05 100755 +--- a/tests/qemu-iotests/080 ++++ b/tests/qemu-iotests/080 +@@ -45,6 +45,7 @@ _supported_os Linux + header_size=104 + + offset_backing_file_offset=8 ++offset_refcount_table_clusters=56 + offset_header_size=100 + offset_ext_magic=$header_size + offset_ext_size=$((header_size + 4)) +@@ -67,6 +68,15 @@ poke_file "$TEST_IMG" "$offset_ext_size" "\x7f\xff\xff\xff" + poke_file "$TEST_IMG" "$offset_backing_file_offset" "\x00\x00\x00\x00\x00\x00\x00\x00" + { $QEMU_IO -c "read 0 512" $TEST_IMG; } 2>&1 | _filter_qemu_io | _filter_testdir + ++echo ++echo "== Huge refcount table size ==" ++_make_test_img 64M ++poke_file "$TEST_IMG" "$offset_refcount_table_clusters" "\xff\xff\xff\xff" ++{ $QEMU_IO -c "read 0 512" $TEST_IMG; } 2>&1 | _filter_qemu_io | _filter_testdir ++poke_file "$TEST_IMG" "$offset_refcount_table_clusters" "\x00\x02\x00\x01" ++{ $QEMU_IO -c "read 0 512" $TEST_IMG; } 2>&1 | _filter_qemu_io | _filter_testdir ++ ++ + # success, all done + echo "*** done" + rm -f $seq.full +diff --git a/tests/qemu-iotests/080.out b/tests/qemu-iotests/080.out +index 48c40aa..6fef6d9 100644 +--- a/tests/qemu-iotests/080.out ++++ b/tests/qemu-iotests/080.out +@@ -13,4 +13,11 @@ qemu-io: can't open device TEST_DIR/t.qcow2: Invalid backing file offset + no file open, try 'help open' + qemu-io: can't open device TEST_DIR/t.qcow2: Header extension too large + no file open, try 'help open' ++ ++== Huge refcount table size == ++Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864 ++qemu-io: can't open device TEST_DIR/t.qcow2: Reference count table too large ++no file open, try 'help open' ++qemu-io: can't open device TEST_DIR/t.qcow2: Reference count table too large ++no file open, try 'help open' + *** done +-- +1.7.1 + diff --git a/SOURCES/kvm-qcow2-Correct-bitmap-size-in-zero-expansion.patch b/SOURCES/kvm-qcow2-Correct-bitmap-size-in-zero-expansion.patch new file mode 100644 index 0000000..7c73e3a --- /dev/null +++ b/SOURCES/kvm-qcow2-Correct-bitmap-size-in-zero-expansion.patch @@ -0,0 +1,127 @@ +From 6529ac40614e6b28a9c52de40defb6e2f455698b Mon Sep 17 00:00:00 2001 +From: Max Reitz +Date: Tue, 7 Jan 2014 21:57:14 +0100 +Subject: [PATCH 09/14] qcow2: Correct bitmap size in zero expansion + +RH-Author: Max Reitz +Message-id: <1389131839-12920-10-git-send-email-mreitz@redhat.com> +Patchwork-id: 56545 +O-Subject: [RHEL-7.0 qemu-kvm PATCH v2 09/14] qcow2: Correct bitmap size in zero expansion +Bugzilla: 1033490 +RH-Acked-by: Kevin Wolf +RH-Acked-by: Fam Zheng +RH-Acked-by: Stefan Hajnoczi + +BZ: 1033490 + +Since the expanded_clusters bitmap is addressed using host offsets in +the underlying image file, the correct size to use for allocating the +bitmap is not determined by the guest disk image but by the underlying +host image file. + +Furthermore, this size may change during the expansion due to cluster +allocations on growable image files. In this case, the bitmap needs to +be resized as well to reflect the growth. + +Signed-off-by: Max Reitz +Signed-off-by: Kevin Wolf +(cherry picked from commit e390cf5a9722d3f3cc54efb505f6ff37fa554b11) + +Signed-off-by: Max Reitz +--- + block/qcow2-cluster.c | 38 +++++++++++++++++++++++++++----------- + 1 file changed, 27 insertions(+), 11 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + block/qcow2-cluster.c | 38 +++++++++++++++++++++++++++----------- + 1 files changed, 27 insertions(+), 11 deletions(-) + +diff --git a/block/qcow2-cluster.c b/block/qcow2-cluster.c +index 796d7c5..bfdc83a 100644 +--- a/block/qcow2-cluster.c ++++ b/block/qcow2-cluster.c +@@ -1511,8 +1511,8 @@ fail: + * i.e., the number of bits in expanded_clusters. + */ + static int expand_zero_clusters_in_l1(BlockDriverState *bs, uint64_t *l1_table, +- int l1_size, uint8_t *expanded_clusters, +- uint64_t nb_clusters) ++ int l1_size, uint8_t **expanded_clusters, ++ uint64_t *nb_clusters) + { + BDRVQcowState *s = bs->opaque; + bool is_active_l1 = (l1_table == s->l1_table); +@@ -1555,8 +1555,8 @@ static int expand_zero_clusters_in_l1(BlockDriverState *bs, uint64_t *l1_table, + + if (cluster_type == QCOW2_CLUSTER_NORMAL) { + cluster_index = offset >> s->cluster_bits; +- assert((cluster_index >= 0) && (cluster_index < nb_clusters)); +- if (expanded_clusters[cluster_index / 8] & ++ assert((cluster_index >= 0) && (cluster_index < *nb_clusters)); ++ if ((*expanded_clusters)[cluster_index / 8] & + (1 << (cluster_index % 8))) { + /* Probably a shared L2 table; this cluster was a zero + * cluster which has been expanded, its refcount +@@ -1613,8 +1613,25 @@ static int expand_zero_clusters_in_l1(BlockDriverState *bs, uint64_t *l1_table, + l2_dirty = true; + + cluster_index = offset >> s->cluster_bits; +- assert((cluster_index >= 0) && (cluster_index < nb_clusters)); +- expanded_clusters[cluster_index / 8] |= 1 << (cluster_index % 8); ++ ++ if (cluster_index >= *nb_clusters) { ++ uint64_t old_bitmap_size = (*nb_clusters + 7) / 8; ++ uint64_t new_bitmap_size; ++ /* The offset may lie beyond the old end of the underlying image ++ * file for growable files only */ ++ assert(bs->file->growable); ++ *nb_clusters = size_to_clusters(s, bs->file->total_sectors * ++ BDRV_SECTOR_SIZE); ++ new_bitmap_size = (*nb_clusters + 7) / 8; ++ *expanded_clusters = g_realloc(*expanded_clusters, ++ new_bitmap_size); ++ /* clear the newly allocated space */ ++ memset(&(*expanded_clusters)[old_bitmap_size], 0, ++ new_bitmap_size - old_bitmap_size); ++ } ++ ++ assert((cluster_index >= 0) && (cluster_index < *nb_clusters)); ++ (*expanded_clusters)[cluster_index / 8] |= 1 << (cluster_index % 8); + } + + if (is_active_l1) { +@@ -1673,18 +1690,17 @@ int qcow2_expand_zero_clusters(BlockDriverState *bs) + { + BDRVQcowState *s = bs->opaque; + uint64_t *l1_table = NULL; +- int cluster_to_sector_bits = s->cluster_bits - BDRV_SECTOR_BITS; + uint64_t nb_clusters; + uint8_t *expanded_clusters; + int ret; + int i, j; + +- nb_clusters = (bs->total_sectors + (1 << cluster_to_sector_bits) - 1) +- >> cluster_to_sector_bits; ++ nb_clusters = size_to_clusters(s, bs->file->total_sectors * ++ BDRV_SECTOR_SIZE); + expanded_clusters = g_malloc0((nb_clusters + 7) / 8); + + ret = expand_zero_clusters_in_l1(bs, s->l1_table, s->l1_size, +- expanded_clusters, nb_clusters); ++ &expanded_clusters, &nb_clusters); + if (ret < 0) { + goto fail; + } +@@ -1718,7 +1734,7 @@ int qcow2_expand_zero_clusters(BlockDriverState *bs) + } + + ret = expand_zero_clusters_in_l1(bs, l1_table, s->snapshots[i].l1_size, +- expanded_clusters, nb_clusters); ++ &expanded_clusters, &nb_clusters); + if (ret < 0) { + goto fail; + } +-- +1.7.1 + diff --git a/SOURCES/kvm-qcow2-Don-t-rely-on-free_cluster_index-in-alloc_refc.patch b/SOURCES/kvm-qcow2-Don-t-rely-on-free_cluster_index-in-alloc_refc.patch new file mode 100644 index 0000000..c06d832 --- /dev/null +++ b/SOURCES/kvm-qcow2-Don-t-rely-on-free_cluster_index-in-alloc_refc.patch @@ -0,0 +1,284 @@ +From a2b10eec76a72aa7fe63e797181b93f69de9600e Mon Sep 17 00:00:00 2001 +From: Kevin Wolf +Date: Tue, 25 Mar 2014 14:23:34 +0100 +Subject: [PATCH 27/49] qcow2: Don't rely on free_cluster_index in alloc_refcount_block() (CVE-2014-0147) + +RH-Author: Kevin Wolf +Message-id: <1395753835-7591-28-git-send-email-kwolf@redhat.com> +Patchwork-id: n/a +O-Subject: [virt-devel] [EMBARGOED RHEL-7.0 qemu-kvm PATCH 27/48] qcow2: Don't rely on free_cluster_index in alloc_refcount_block() (CVE-2014-0147) +Bugzilla: 1079339 +RH-Acked-by: Jeff Cody +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Paolo Bonzini + +Bugzilla: https://bugzilla.redhat.com/show_bug.cgi?id=1079339 +Upstream status: Embargoed + +free_cluster_index is only correct if update_refcount() was called from +an allocation function, and even there it's brittle because it's used to +protect unfinished allocations which still have a refcount of 0 - if it +moves in the wrong place, the unfinished allocation can be corrupted. + +So not using it any more seems to be a good idea. Instead, use the +first requested cluster to do the calculations. Return -EAGAIN if +unfinished allocations could become invalid and let the caller restart +its search for some free clusters. + +The context of creating a snapsnot is one situation where +update_refcount() is called outside of a cluster allocation. For this +case, the change fixes a buffer overflow if a cluster is referenced in +an L2 table that cannot be represented by an existing refcount block. +(new_table[refcount_table_index] was out of bounds) + +Signed-off-by: Kevin Wolf +--- + block/qcow2-refcount.c | 74 ++++++++++++++++++++++--------------------- + block/qcow2.c | 7 ++-- + tests/qemu-iotests/044.out | 2 +- + tests/qemu-iotests/080 | 11 ++++++ + tests/qemu-iotests/080.out | 7 ++++ + 5 files changed, 61 insertions(+), 40 deletions(-) + +diff --git a/block/qcow2-refcount.c b/block/qcow2-refcount.c +index 13ea5f7..54bcbd1 100644 +--- a/block/qcow2-refcount.c ++++ b/block/qcow2-refcount.c +@@ -193,10 +193,11 @@ static int alloc_refcount_block(BlockDriverState *bs, + * they can describe them themselves. + * + * - We need to consider that at this point we are inside update_refcounts +- * and doing the initial refcount increase. This means that some clusters +- * have already been allocated by the caller, but their refcount isn't +- * accurate yet. free_cluster_index tells us where this allocation ends +- * as long as we don't overwrite it by freeing clusters. ++ * and potentially doing an initial refcount increase. This means that ++ * some clusters have already been allocated by the caller, but their ++ * refcount isn't accurate yet. If we allocate clusters for metadata, we ++ * need to return -EAGAIN to signal the caller that it needs to restart ++ * the search for free clusters. + * + * - alloc_clusters_noref and qcow2_free_clusters may load a different + * refcount block into the cache +@@ -281,7 +282,10 @@ static int alloc_refcount_block(BlockDriverState *bs, + } + + s->refcount_table[refcount_table_index] = new_block; +- return 0; ++ ++ /* The new refcount block may be where the caller intended to put its ++ * data, so let it restart the search. */ ++ return -EAGAIN; + } + + ret = qcow2_cache_put(bs, s->refcount_block_cache, (void**) refcount_block); +@@ -304,8 +308,7 @@ static int alloc_refcount_block(BlockDriverState *bs, + + /* Calculate the number of refcount blocks needed so far */ + uint64_t refcount_block_clusters = 1 << (s->cluster_bits - REFCOUNT_SHIFT); +- uint64_t blocks_used = (s->free_cluster_index + +- refcount_block_clusters - 1) / refcount_block_clusters; ++ uint64_t blocks_used = DIV_ROUND_UP(cluster_index, refcount_block_clusters); + + /* And now we need at least one block more for the new metadata */ + uint64_t table_size = next_refcount_table_size(s, blocks_used + 1); +@@ -338,8 +341,6 @@ static int alloc_refcount_block(BlockDriverState *bs, + uint16_t *new_blocks = g_malloc0(blocks_clusters * s->cluster_size); + uint64_t *new_table = g_malloc0(table_size * sizeof(uint64_t)); + +- assert(meta_offset >= (s->free_cluster_index * s->cluster_size)); +- + /* Fill the new refcount table */ + memcpy(new_table, s->refcount_table, + s->refcount_table_size * sizeof(uint64_t)); +@@ -402,18 +403,19 @@ static int alloc_refcount_block(BlockDriverState *bs, + s->refcount_table_size = table_size; + s->refcount_table_offset = table_offset; + +- /* Free old table. Remember, we must not change free_cluster_index */ +- uint64_t old_free_cluster_index = s->free_cluster_index; ++ /* Free old table. */ + qcow2_free_clusters(bs, old_table_offset, old_table_size * sizeof(uint64_t), + QCOW2_DISCARD_OTHER); +- s->free_cluster_index = old_free_cluster_index; + + ret = load_refcount_block(bs, new_block, (void**) refcount_block); + if (ret < 0) { + return ret; + } + +- return 0; ++ /* If we were trying to do the initial refcount update for some cluster ++ * allocation, we might have used the same clusters to store newly ++ * allocated metadata. Make the caller search some new space. */ ++ return -EAGAIN; + + fail_table: + g_free(new_table); +@@ -659,12 +661,15 @@ int64_t qcow2_alloc_clusters(BlockDriverState *bs, int64_t size) + int ret; + + BLKDBG_EVENT(bs->file, BLKDBG_CLUSTER_ALLOC); +- offset = alloc_clusters_noref(bs, size); +- if (offset < 0) { +- return offset; +- } ++ do { ++ offset = alloc_clusters_noref(bs, size); ++ if (offset < 0) { ++ return offset; ++ } ++ ++ ret = update_refcount(bs, offset, size, 1, QCOW2_DISCARD_NEVER); ++ } while (ret == -EAGAIN); + +- ret = update_refcount(bs, offset, size, 1, QCOW2_DISCARD_NEVER); + if (ret < 0) { + return ret; + } +@@ -677,7 +682,6 @@ int qcow2_alloc_clusters_at(BlockDriverState *bs, uint64_t offset, + { + BDRVQcowState *s = bs->opaque; + uint64_t cluster_index; +- uint64_t old_free_cluster_index; + uint64_t i; + int refcount, ret; + +@@ -686,30 +690,28 @@ int qcow2_alloc_clusters_at(BlockDriverState *bs, uint64_t offset, + return 0; + } + +- /* Check how many clusters there are free */ +- cluster_index = offset >> s->cluster_bits; +- for(i = 0; i < nb_clusters; i++) { +- refcount = get_refcount(bs, cluster_index++); ++ do { ++ /* Check how many clusters there are free */ ++ cluster_index = offset >> s->cluster_bits; ++ for(i = 0; i < nb_clusters; i++) { ++ refcount = get_refcount(bs, cluster_index++); + +- if (refcount < 0) { +- return refcount; +- } else if (refcount != 0) { +- break; ++ if (refcount < 0) { ++ return refcount; ++ } else if (refcount != 0) { ++ break; ++ } + } +- } + +- /* And then allocate them */ +- old_free_cluster_index = s->free_cluster_index; +- s->free_cluster_index = cluster_index + i; ++ /* And then allocate them */ ++ ret = update_refcount(bs, offset, i << s->cluster_bits, 1, ++ QCOW2_DISCARD_NEVER); ++ } while (ret == -EAGAIN); + +- ret = update_refcount(bs, offset, i << s->cluster_bits, 1, +- QCOW2_DISCARD_NEVER); + if (ret < 0) { + return ret; + } + +- s->free_cluster_index = old_free_cluster_index; +- + return i; + } + +diff --git a/block/qcow2.c b/block/qcow2.c +index a8ad9e1..87f2958 100644 +--- a/block/qcow2.c ++++ b/block/qcow2.c +@@ -1580,7 +1580,7 @@ static int qcow2_create2(const char *filename, int64_t total_size, + */ + BlockDriverState* bs; + QCowHeader *header; +- uint8_t* refcount_table; ++ uint64_t* refcount_table; + Error *local_err = NULL; + int ret; + +@@ -1630,8 +1630,9 @@ static int qcow2_create2(const char *filename, int64_t total_size, + goto out; + } + +- /* Write an empty refcount table */ ++ /* Write a refcount table with one refcount block */ + refcount_table = g_malloc0(cluster_size); ++ refcount_table[0] = cpu_to_be64(2 * cluster_size); + ret = bdrv_pwrite(bs, cluster_size, refcount_table, cluster_size); + g_free(refcount_table); + +@@ -1656,7 +1657,7 @@ static int qcow2_create2(const char *filename, int64_t total_size, + goto out; + } + +- ret = qcow2_alloc_clusters(bs, 2 * cluster_size); ++ ret = qcow2_alloc_clusters(bs, 3 * cluster_size); + if (ret < 0) { + error_setg_errno(errp, -ret, "Could not allocate clusters for qcow2 " + "header and refcount table"); +diff --git a/tests/qemu-iotests/044.out b/tests/qemu-iotests/044.out +index 5c5aa92..4789a53 100644 +--- a/tests/qemu-iotests/044.out ++++ b/tests/qemu-iotests/044.out +@@ -1,6 +1,6 @@ + No errors were found on the image. + 7292415/33554432 = 21.73% allocated, 0.00% fragmented, 0.00% compressed clusters +-Image end offset: 4296448000 ++Image end offset: 4296152064 + . + ---------------------------------------------------------------------- + Ran 1 tests +diff --git a/tests/qemu-iotests/080 b/tests/qemu-iotests/080 +index f3091a9..56f8903 100755 +--- a/tests/qemu-iotests/080 ++++ b/tests/qemu-iotests/080 +@@ -56,6 +56,8 @@ offset_header_size=100 + offset_ext_magic=$header_size + offset_ext_size=$((header_size + 4)) + ++offset_l2_table_0=$((0x40000)) ++ + echo + echo "== Huge header size ==" + _make_test_img 64M +@@ -143,6 +145,15 @@ poke_file "$TEST_IMG" "$offset_backing_file_offset" "\x00\x00\x00\x00\x00\x00\x1 + poke_file "$TEST_IMG" "$offset_backing_file_size" "\xff\xff\xff\xff" + { $QEMU_IO -c "read 0 512" $TEST_IMG; } 2>&1 | _filter_qemu_io | _filter_testdir + ++echo ++echo "== Invalid L2 entry (huge physical offset) ==" ++_make_test_img 64M ++{ $QEMU_IO -c "write 0 512" $TEST_IMG; } 2>&1 | _filter_qemu_io | _filter_testdir ++poke_file "$TEST_IMG" "$offset_l2_table_0" "\xbf\xff\xff\xff\xff\xff\x00\x00" ++{ $QEMU_IMG snapshot -c test $TEST_IMG; } 2>&1 | _filter_qemu_io | _filter_testdir ++poke_file "$TEST_IMG" "$offset_l2_table_0" "\x80\x00\x00\xff\xff\xff\x00\x00" ++{ $QEMU_IMG snapshot -c test $TEST_IMG; } 2>&1 | _filter_qemu_io | _filter_testdir ++ + # success, all done + echo "*** done" + rm -f $seq.full +diff --git a/tests/qemu-iotests/080.out b/tests/qemu-iotests/080.out +index 8103211..303d6c3 100644 +--- a/tests/qemu-iotests/080.out ++++ b/tests/qemu-iotests/080.out +@@ -63,4 +63,11 @@ no file open, try 'help open' + Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864 + qemu-io: can't open device TEST_DIR/t.qcow2: Backing file name too long + no file open, try 'help open' ++ ++== Invalid L2 entry (huge physical offset) == ++Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864 ++wrote 512/512 bytes at offset 0 ++512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) ++qemu-img: Could not create snapshot 'test': -27 (File too large) ++qemu-img: Could not create snapshot 'test': -11 (Resource temporarily unavailable) + *** done +-- +1.7.1 + diff --git a/SOURCES/kvm-qcow2-Fix-L1-allocation-size-in-qcow2_snapshot_load_.patch b/SOURCES/kvm-qcow2-Fix-L1-allocation-size-in-qcow2_snapshot_load_.patch new file mode 100644 index 0000000..1c056d2 --- /dev/null +++ b/SOURCES/kvm-qcow2-Fix-L1-allocation-size-in-qcow2_snapshot_load_.patch @@ -0,0 +1,101 @@ +From 1235b1580890e2a034bb24f89a89311d296d2622 Mon Sep 17 00:00:00 2001 +From: Kevin Wolf +Date: Tue, 25 Mar 2014 14:23:51 +0100 +Subject: [PATCH 44/49] qcow2: Fix L1 allocation size in qcow2_snapshot_load_tmp() (CVE-2014-0145) + +RH-Author: Kevin Wolf +Message-id: <1395753835-7591-45-git-send-email-kwolf@redhat.com> +Patchwork-id: n/a +O-Subject: [virt-devel] [EMBARGOED RHEL-7.0 qemu-kvm PATCH 44/48] qcow2: Fix L1 allocation size in qcow2_snapshot_load_tmp() (CVE-2014-0145) +Bugzilla: 1079325 +RH-Acked-by: Jeff Cody +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Paolo Bonzini + +Bugzilla: https://bugzilla.redhat.com/show_bug.cgi?id=1079325 +Upstream status: Embargoed + +For the L1 table to loaded for an internal snapshot, the code allocated +only enough memory to hold the currently active L1 table. If the +snapshot's L1 table is actually larger than the current one, this leads +to a buffer overflow. + +Signed-off-by: Kevin Wolf +--- + block/qcow2-snapshot.c | 2 +- + tests/qemu-iotests/029 | 18 +++++++++++++++++- + tests/qemu-iotests/029.out | 4 ++++ + 3 files changed, 22 insertions(+), 2 deletions(-) + +diff --git a/block/qcow2-snapshot.c b/block/qcow2-snapshot.c +index 5d73506..b29f7bd 100644 +--- a/block/qcow2-snapshot.c ++++ b/block/qcow2-snapshot.c +@@ -635,7 +635,7 @@ int qcow2_snapshot_load_tmp(BlockDriverState *bs, const char *snapshot_name) + sn = &s->snapshots[snapshot_index]; + + /* Allocate and read in the snapshot's L1 table */ +- new_l1_bytes = s->l1_size * sizeof(uint64_t); ++ new_l1_bytes = sn->l1_size * sizeof(uint64_t); + new_l1_table = g_malloc0(align_offset(new_l1_bytes, 512)); + + ret = bdrv_pread(bs->file, sn->l1_table_offset, new_l1_table, new_l1_bytes); +diff --git a/tests/qemu-iotests/029 b/tests/qemu-iotests/029 +index 567e071..fa46ace 100755 +--- a/tests/qemu-iotests/029 ++++ b/tests/qemu-iotests/029 +@@ -30,7 +30,8 @@ status=1 # failure is the default! + + _cleanup() + { +- _cleanup_test_img ++ rm -f $TEST_IMG.snap ++ _cleanup_test_img + } + trap "_cleanup; exit \$status" 0 1 2 3 15 + +@@ -44,6 +45,9 @@ _supported_fmt qcow2 + _supported_proto generic + _supported_os Linux + ++offset_size=24 ++offset_l1_size=36 ++ + echo + echo Test loading internal snapshots where the L1 table of the snapshot + echo is smaller than the current L1 table. +@@ -77,6 +81,18 @@ _make_test_img 64M + _check_test_img + + ++echo ++echo "qcow2_snapshot_load_tmp() should take the L1 size from the snapshot" ++echo ++ ++CLUSTER_SIZE=512 ++_make_test_img 64M ++{ $QEMU_IMG snapshot -c foo $TEST_IMG; } 2>&1 | _filter_qemu_io | _filter_testdir ++poke_file "$TEST_IMG" "$offset_size" "\x00\x00\x00\x00\x00\x00\x02\x00" ++poke_file "$TEST_IMG" "$offset_l1_size" "\x00\x00\x00\x01" ++{ $QEMU_IMG convert -s foo $TEST_IMG $TEST_IMG.snap; } 2>&1 | _filter_qemu_io | _filter_testdir ++ ++ + # success, all done + echo "*** done" + rm -f $seq.full +diff --git a/tests/qemu-iotests/029.out b/tests/qemu-iotests/029.out +index 9029698..ce0e64d 100644 +--- a/tests/qemu-iotests/029.out ++++ b/tests/qemu-iotests/029.out +@@ -20,4 +20,8 @@ wrote 4096/4096 bytes at offset 1099511627776 + read 4096/4096 bytes at offset 1099511627776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) + No errors were found on the image. ++ ++qcow2_snapshot_load_tmp() should take the L1 size from the snapshot ++ ++Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864 + *** done +-- +1.7.1 + diff --git a/SOURCES/kvm-qcow2-Fix-NULL-dereference-in-qcow2_open-error-path-.patch b/SOURCES/kvm-qcow2-Fix-NULL-dereference-in-qcow2_open-error-path-.patch new file mode 100644 index 0000000..1c46d0e --- /dev/null +++ b/SOURCES/kvm-qcow2-Fix-NULL-dereference-in-qcow2_open-error-path-.patch @@ -0,0 +1,91 @@ +From 4ce3cdbea5f0006ec857767f2dc74a02fffd0cb5 Mon Sep 17 00:00:00 2001 +From: Kevin Wolf +Date: Tue, 25 Mar 2014 14:23:50 +0100 +Subject: [PATCH 43/49] qcow2: Fix NULL dereference in qcow2_open() error path (CVE-2014-0146) + +RH-Author: Kevin Wolf +Message-id: <1395753835-7591-44-git-send-email-kwolf@redhat.com> +Patchwork-id: n/a +O-Subject: [virt-devel] [EMBARGOED RHEL-7.0 qemu-kvm PATCH 43/48] qcow2: Fix NULL dereference in qcow2_open() error path (CVE-2014-0146) +Bugzilla: 1079333 +RH-Acked-by: Jeff Cody +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Paolo Bonzini + +Bugzilla: https://bugzilla.redhat.com/show_bug.cgi?id=1079333 +Upstream status: Embargoed + +The qcow2 code assumes that s->snapshots is non-NULL if s->nb_snapshots +!= 0. By having the initialisation of both fields separated in +qcow2_open(), any error occuring in between would cause the error path +to dereference NULL in qcow2_free_snapshots() if the image had any +snapshots. + +Signed-off-by: Kevin Wolf +--- + block/qcow2.c | 7 ++++--- + tests/qemu-iotests/080 | 7 +++++++ + tests/qemu-iotests/080.out | 4 ++++ + 3 files changed, 15 insertions(+), 3 deletions(-) + +diff --git a/block/qcow2.c b/block/qcow2.c +index db9f667..33b46b8 100644 +--- a/block/qcow2.c ++++ b/block/qcow2.c +@@ -636,9 +636,6 @@ static int qcow2_open(BlockDriverState *bs, QDict *options, int flags, + goto fail; + } + +- s->snapshots_offset = header.snapshots_offset; +- s->nb_snapshots = header.nb_snapshots; +- + /* read the level 1 table */ + if (header.l1_size > 0x2000000) { + /* 32 MB L1 table is enough for 2 PB images at 64k cluster size +@@ -733,6 +730,10 @@ static int qcow2_open(BlockDriverState *bs, QDict *options, int flags, + bs->backing_file[len] = '\0'; + } + ++ /* Internal snapshots */ ++ s->snapshots_offset = header.snapshots_offset; ++ s->nb_snapshots = header.nb_snapshots; ++ + ret = qcow2_read_snapshots(bs); + if (ret < 0) { + error_setg_errno(errp, -ret, "Could not read snapshots"); +diff --git a/tests/qemu-iotests/080 b/tests/qemu-iotests/080 +index 56f8903..59e7a44 100755 +--- a/tests/qemu-iotests/080 ++++ b/tests/qemu-iotests/080 +@@ -139,6 +139,13 @@ poke_file "$TEST_IMG" "$offset_l1_size" "\x00\x00\x00\x01" + { $QEMU_IO -c "read 0 512" $TEST_IMG; } 2>&1 | _filter_qemu_io | _filter_testdir + + echo ++echo "== Invalid L1 table (with internal snapshot in the image) ==" ++_make_test_img 64M ++{ $QEMU_IMG snapshot -c foo $TEST_IMG; } 2>&1 | _filter_qemu_io | _filter_testdir ++poke_file "$TEST_IMG" "$offset_l1_size" "\x00\x00\x00\x00" ++_img_info ++ ++echo + echo "== Invalid backing file size ==" + _make_test_img 64M + poke_file "$TEST_IMG" "$offset_backing_file_offset" "\x00\x00\x00\x00\x00\x00\x10\x00" +diff --git a/tests/qemu-iotests/080.out b/tests/qemu-iotests/080.out +index 303d6c3..4d84fbf 100644 +--- a/tests/qemu-iotests/080.out ++++ b/tests/qemu-iotests/080.out +@@ -59,6 +59,10 @@ no file open, try 'help open' + qemu-io: can't open device TEST_DIR/t.qcow2: Invalid L1 table offset + no file open, try 'help open' + ++== Invalid L1 table (with internal snapshot in the image) == ++Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864 ++qemu-img: Could not open 'TEST_DIR/t.IMGFMT': L1 table is too small ++ + == Invalid backing file size == + Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864 + qemu-io: can't open device TEST_DIR/t.qcow2: Backing file name too long +-- +1.7.1 + diff --git a/SOURCES/kvm-qcow2-Fix-backing-file-name-length-check.patch b/SOURCES/kvm-qcow2-Fix-backing-file-name-length-check.patch new file mode 100644 index 0000000..9c919a8 --- /dev/null +++ b/SOURCES/kvm-qcow2-Fix-backing-file-name-length-check.patch @@ -0,0 +1,101 @@ +From 38b7ffbe3a1fa62f4d5177a3a572aa1c9abb1963 Mon Sep 17 00:00:00 2001 +From: Kevin Wolf +Date: Tue, 25 Mar 2014 14:23:33 +0100 +Subject: [PATCH 26/49] qcow2: Fix backing file name length check + +RH-Author: Kevin Wolf +Message-id: <1395753835-7591-27-git-send-email-kwolf@redhat.com> +Patchwork-id: n/a +O-Subject: [virt-devel] [EMBARGOED RHEL-7.0 qemu-kvm PATCH 26/48] qcow2: Fix backing file name length check +Bugzilla: 1066691 +RH-Acked-by: Jeff Cody +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Paolo Bonzini + +Bugzilla: https://bugzilla.redhat.com/show_bug.cgi?id=1066691 +Upstream status: Series embargoed + +len could become negative and would pass the check then. Nothing bad +happened because bdrv_pread() happens to return an error for negative +length values, but make variables for sizes unsigned anyway. + +This patch also changes the behaviour to error out on invalid lengths +instead of silently truncating it to 1023. + +Signed-off-by: Kevin Wolf +--- + block/qcow2.c | 9 ++++++--- + tests/qemu-iotests/080 | 8 ++++++++ + tests/qemu-iotests/080.out | 5 +++++ + 3 files changed, 19 insertions(+), 3 deletions(-) + +diff --git a/block/qcow2.c b/block/qcow2.c +index 8be82f0..a8ad9e1 100644 +--- a/block/qcow2.c ++++ b/block/qcow2.c +@@ -445,7 +445,8 @@ static int qcow2_open(BlockDriverState *bs, QDict *options, int flags, + Error **errp) + { + BDRVQcowState *s = bs->opaque; +- int len, i, ret = 0; ++ unsigned int len, i; ++ int ret = 0; + QCowHeader header; + QemuOpts *opts; + Error *local_err = NULL; +@@ -720,8 +721,10 @@ static int qcow2_open(BlockDriverState *bs, QDict *options, int flags, + /* read the backing file name */ + if (header.backing_file_offset != 0) { + len = header.backing_file_size; +- if (len > 1023) { +- len = 1023; ++ if (len > MIN(1023, s->cluster_size - header.backing_file_offset)) { ++ error_setg(errp, "Backing file name too long"); ++ ret = -EINVAL; ++ goto fail; + } + ret = bdrv_pread(bs->file, header.backing_file_offset, + bs->backing_file, len); +diff --git a/tests/qemu-iotests/080 b/tests/qemu-iotests/080 +index 7255b6c..f3091a9 100755 +--- a/tests/qemu-iotests/080 ++++ b/tests/qemu-iotests/080 +@@ -45,6 +45,7 @@ _supported_os Linux + header_size=104 + + offset_backing_file_offset=8 ++offset_backing_file_size=16 + offset_l1_size=36 + offset_l1_table_offset=40 + offset_refcount_table_offset=48 +@@ -135,6 +136,13 @@ poke_file "$TEST_IMG" "$offset_l1_table_offset" "\x12\x34\x56\x78\x90\xab\xcd\xe + poke_file "$TEST_IMG" "$offset_l1_size" "\x00\x00\x00\x01" + { $QEMU_IO -c "read 0 512" $TEST_IMG; } 2>&1 | _filter_qemu_io | _filter_testdir + ++echo ++echo "== Invalid backing file size ==" ++_make_test_img 64M ++poke_file "$TEST_IMG" "$offset_backing_file_offset" "\x00\x00\x00\x00\x00\x00\x10\x00" ++poke_file "$TEST_IMG" "$offset_backing_file_size" "\xff\xff\xff\xff" ++{ $QEMU_IO -c "read 0 512" $TEST_IMG; } 2>&1 | _filter_qemu_io | _filter_testdir ++ + # success, all done + echo "*** done" + rm -f $seq.full +diff --git a/tests/qemu-iotests/080.out b/tests/qemu-iotests/080.out +index 4ec2545..8103211 100644 +--- a/tests/qemu-iotests/080.out ++++ b/tests/qemu-iotests/080.out +@@ -58,4 +58,9 @@ qemu-io: can't open device TEST_DIR/t.qcow2: Invalid L1 table offset + no file open, try 'help open' + qemu-io: can't open device TEST_DIR/t.qcow2: Invalid L1 table offset + no file open, try 'help open' ++ ++== Invalid backing file size == ++Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864 ++qemu-io: can't open device TEST_DIR/t.qcow2: Backing file name too long ++no file open, try 'help open' + *** done +-- +1.7.1 + diff --git a/SOURCES/kvm-qcow2-Fix-copy_sectors-with-VM-state.patch b/SOURCES/kvm-qcow2-Fix-copy_sectors-with-VM-state.patch new file mode 100644 index 0000000..121c5b3 --- /dev/null +++ b/SOURCES/kvm-qcow2-Fix-copy_sectors-with-VM-state.patch @@ -0,0 +1,130 @@ +From c861019bd5799f76c3e2e42835b10baec1888293 Mon Sep 17 00:00:00 2001 +From: Kevin Wolf +Date: Tue, 25 Mar 2014 14:23:49 +0100 +Subject: [PATCH 42/49] qcow2: Fix copy_sectors() with VM state + +RH-Author: Kevin Wolf +Message-id: <1395753835-7591-43-git-send-email-kwolf@redhat.com> +Patchwork-id: n/a +O-Subject: [virt-devel] [EMBARGOED RHEL-7.0 qemu-kvm PATCH 42/48] qcow2: Fix copy_sectors() with VM state +Bugzilla: 1066691 +RH-Acked-by: Jeff Cody +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Paolo Bonzini + +Bugzilla: https://bugzilla.redhat.com/show_bug.cgi?id=1066691 +Upstream status: Series embargoed + +bs->total_sectors is not the highest possible sector number that could +be involved in a copy on write operation: VM state is after the end of +the virtual disk. This resulted in wrong values for the number of +sectors to be copied (n). + +The code that checks for the end of the image isn't required any more +because the code hasn't been calling the block layer's bdrv_read() for a +long time; instead, it directly calls qcow2_readv(), which doesn't error +out on VM state sector numbers. + +Signed-off-by: Kevin Wolf +--- + block/qcow2-cluster.c | 9 --------- + tests/qemu-iotests/029 | 22 ++++++++++++++++++++-- + tests/qemu-iotests/029.out | 13 +++++++++++++ + 3 files changed, 33 insertions(+), 11 deletions(-) + +diff --git a/block/qcow2-cluster.c b/block/qcow2-cluster.c +index 943e3c6..67f1393 100644 +--- a/block/qcow2-cluster.c ++++ b/block/qcow2-cluster.c +@@ -349,15 +349,6 @@ static int coroutine_fn copy_sectors(BlockDriverState *bs, + struct iovec iov; + int n, ret; + +- /* +- * If this is the last cluster and it is only partially used, we must only +- * copy until the end of the image, or bdrv_check_request will fail for the +- * bdrv_read/write calls below. +- */ +- if (start_sect + n_end > bs->total_sectors) { +- n_end = bs->total_sectors - start_sect; +- } +- + n = n_end - n_start; + if (n <= 0) { + return 0; +diff --git a/tests/qemu-iotests/029 b/tests/qemu-iotests/029 +index b424726..567e071 100755 +--- a/tests/qemu-iotests/029 ++++ b/tests/qemu-iotests/029 +@@ -1,7 +1,6 @@ + #!/bin/bash + # +-# Test loading internal snapshots where the L1 table of the snapshot +-# is smaller than the current L1 table. ++# qcow2 internal snapshots/VM state tests + # + # Copyright (C) 2011 Red Hat, Inc. + # +@@ -45,6 +44,11 @@ _supported_fmt qcow2 + _supported_proto generic + _supported_os Linux + ++echo ++echo Test loading internal snapshots where the L1 table of the snapshot ++echo is smaller than the current L1 table. ++echo ++ + CLUSTER_SIZE=65536 + _make_test_img 64M + $QEMU_IMG snapshot -c foo "$TEST_IMG" +@@ -59,6 +63,20 @@ $QEMU_IO -c 'write -b 0 4M' "$TEST_IMG" | _filter_qemu_io + $QEMU_IMG snapshot -a foo "$TEST_IMG" + _check_test_img + ++ ++echo ++echo Try using a huge VM state ++echo ++ ++CLUSTER_SIZE=65536 ++_make_test_img 64M ++{ $QEMU_IO -c "write -b -P 0x11 1T 4k" $TEST_IMG; } 2>&1 | _filter_qemu_io | _filter_testdir ++{ $QEMU_IMG snapshot -c foo $TEST_IMG; } 2>&1 | _filter_qemu_io | _filter_testdir ++{ $QEMU_IMG snapshot -a foo $TEST_IMG; } 2>&1 | _filter_qemu_io | _filter_testdir ++{ $QEMU_IO -c "read -b -P 0x11 1T 4k" $TEST_IMG; } 2>&1 | _filter_qemu_io | _filter_testdir ++_check_test_img ++ ++ + # success, all done + echo "*** done" + rm -f $seq.full +diff --git a/tests/qemu-iotests/029.out b/tests/qemu-iotests/029.out +index 0eedb3a..9029698 100644 +--- a/tests/qemu-iotests/029.out ++++ b/tests/qemu-iotests/029.out +@@ -1,4 +1,8 @@ + QA output created by 029 ++ ++Test loading internal snapshots where the L1 table of the snapshot ++is smaller than the current L1 table. ++ + Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864 + wrote 4096/4096 bytes at offset 0 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +@@ -7,4 +11,13 @@ Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=16777216 + wrote 4194304/4194304 bytes at offset 0 + 4 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) + No errors were found on the image. ++ ++Try using a huge VM state ++ ++Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864 ++wrote 4096/4096 bytes at offset 1099511627776 ++4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) ++read 4096/4096 bytes at offset 1099511627776 ++4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) ++No errors were found on the image. + *** done +-- +1.7.1 + diff --git a/SOURCES/kvm-qcow2-Fix-new-L1-table-size-check-CVE-2014-0143.patch b/SOURCES/kvm-qcow2-Fix-new-L1-table-size-check-CVE-2014-0143.patch new file mode 100644 index 0000000..c9551c5 --- /dev/null +++ b/SOURCES/kvm-qcow2-Fix-new-L1-table-size-check-CVE-2014-0143.patch @@ -0,0 +1,41 @@ +From b71e1cbac708fc3e6659b2356f365dd223e3ac01 Mon Sep 17 00:00:00 2001 +From: Kevin Wolf +Date: Tue, 25 Mar 2014 14:23:39 +0100 +Subject: [PATCH 32/49] qcow2: Fix new L1 table size check (CVE-2014-0143) + +RH-Author: Kevin Wolf +Message-id: <1395753835-7591-33-git-send-email-kwolf@redhat.com> +Patchwork-id: n/a +O-Subject: [virt-devel] [EMBARGOED RHEL-7.0 qemu-kvm PATCH 32/48] qcow2: Fix new L1 table size check (CVE-2014-0143) +Bugzilla: 1079320 +RH-Acked-by: Jeff Cody +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Paolo Bonzini + +Bugzilla: https://bugzilla.redhat.com/show_bug.cgi?id=1079320 +Upstream status: Embargoed + +The size in bytes is assigned to an int later, so check that instead of +the number of entries. + +Signed-off-by: Kevin Wolf +--- + block/qcow2-cluster.c | 2 +- + 1 files changed, 1 insertions(+), 1 deletions(-) + +diff --git a/block/qcow2-cluster.c b/block/qcow2-cluster.c +index 87c13ce..943e3c6 100644 +--- a/block/qcow2-cluster.c ++++ b/block/qcow2-cluster.c +@@ -55,7 +55,7 @@ int qcow2_grow_l1_table(BlockDriverState *bs, uint64_t min_size, + } + } + +- if (new_l1_size > INT_MAX) { ++ if (new_l1_size > INT_MAX / sizeof(uint64_t)) { + return -EFBIG; + } + +-- +1.7.1 + diff --git a/SOURCES/kvm-qcow2-Fix-types-in-qcow2_alloc_clusters-and-alloc_cl.patch b/SOURCES/kvm-qcow2-Fix-types-in-qcow2_alloc_clusters-and-alloc_cl.patch new file mode 100644 index 0000000..5d9d8b8 --- /dev/null +++ b/SOURCES/kvm-qcow2-Fix-types-in-qcow2_alloc_clusters-and-alloc_cl.patch @@ -0,0 +1,94 @@ +From e1547d9eea752dde38bee613afb5cfb7bb26f0f8 Mon Sep 17 00:00:00 2001 +From: Kevin Wolf +Date: Tue, 25 Mar 2014 14:23:37 +0100 +Subject: [PATCH 30/49] qcow2: Fix types in qcow2_alloc_clusters and alloc_clusters_noref + +RH-Author: Kevin Wolf +Message-id: <1395753835-7591-31-git-send-email-kwolf@redhat.com> +Patchwork-id: n/a +O-Subject: [virt-devel] [EMBARGOED RHEL-7.0 qemu-kvm PATCH 30/48] qcow2: Fix types in qcow2_alloc_clusters and alloc_clusters_noref +Bugzilla: 1066691 +RH-Acked-by: Jeff Cody +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Paolo Bonzini + +Bugzilla: https://bugzilla.redhat.com/show_bug.cgi?id=1066691 +Upstream status: Series embargoed + +In order to avoid integer overflows. + +Signed-off-by: Kevin Wolf +--- + block/qcow2-refcount.c | 11 ++++++----- + block/qcow2.h | 6 +++--- + 2 files changed, 9 insertions(+), 8 deletions(-) + +diff --git a/block/qcow2-refcount.c b/block/qcow2-refcount.c +index 7b00dda..fb57c10 100644 +--- a/block/qcow2-refcount.c ++++ b/block/qcow2-refcount.c +@@ -28,7 +28,7 @@ + #include "qemu/range.h" + #include "qapi/qmp/types.h" + +-static int64_t alloc_clusters_noref(BlockDriverState *bs, int64_t size); ++static int64_t alloc_clusters_noref(BlockDriverState *bs, uint64_t size); + static int QEMU_WARN_UNUSED_RESULT update_refcount(BlockDriverState *bs, + int64_t offset, int64_t length, + int addend, enum qcow2_discard_type type); +@@ -634,15 +634,16 @@ int qcow2_update_cluster_refcount(BlockDriverState *bs, + + + /* return < 0 if error */ +-static int64_t alloc_clusters_noref(BlockDriverState *bs, int64_t size) ++static int64_t alloc_clusters_noref(BlockDriverState *bs, uint64_t size) + { + BDRVQcowState *s = bs->opaque; +- int i, nb_clusters, refcount; ++ uint64_t i, nb_clusters; ++ int refcount; + + nb_clusters = size_to_clusters(s, size); + retry: + for(i = 0; i < nb_clusters; i++) { +- int64_t next_cluster_index = s->free_cluster_index++; ++ uint64_t next_cluster_index = s->free_cluster_index++; + refcount = get_refcount(bs, next_cluster_index); + + if (refcount < 0) { +@@ -659,7 +660,7 @@ retry: + return (s->free_cluster_index - nb_clusters) << s->cluster_bits; + } + +-int64_t qcow2_alloc_clusters(BlockDriverState *bs, int64_t size) ++int64_t qcow2_alloc_clusters(BlockDriverState *bs, uint64_t size) + { + int64_t offset; + int ret; +diff --git a/block/qcow2.h b/block/qcow2.h +index 0173d95..9f9f5ae 100644 +--- a/block/qcow2.h ++++ b/block/qcow2.h +@@ -222,8 +222,8 @@ typedef struct BDRVQcowState { + uint64_t *refcount_table; + uint64_t refcount_table_offset; + uint32_t refcount_table_size; +- int64_t free_cluster_index; +- int64_t free_byte_offset; ++ uint64_t free_cluster_index; ++ uint64_t free_byte_offset; + + CoMutex lock; + +@@ -462,7 +462,7 @@ void qcow2_refcount_close(BlockDriverState *bs); + int qcow2_update_cluster_refcount(BlockDriverState *bs, int64_t cluster_index, + int addend, enum qcow2_discard_type type); + +-int64_t qcow2_alloc_clusters(BlockDriverState *bs, int64_t size); ++int64_t qcow2_alloc_clusters(BlockDriverState *bs, uint64_t size); + int qcow2_alloc_clusters_at(BlockDriverState *bs, uint64_t offset, + int nb_clusters); + int64_t qcow2_alloc_bytes(BlockDriverState *bs, int size); +-- +1.7.1 + diff --git a/SOURCES/kvm-qcow2-Free-only-newly-allocated-clusters-on-error.patch b/SOURCES/kvm-qcow2-Free-only-newly-allocated-clusters-on-error.patch new file mode 100644 index 0000000..0a80d1f --- /dev/null +++ b/SOURCES/kvm-qcow2-Free-only-newly-allocated-clusters-on-error.patch @@ -0,0 +1,84 @@ +From f39d8d56b3cf31f293465bd912ae623ada8152c0 Mon Sep 17 00:00:00 2001 +From: Max Reitz +Date: Tue, 7 Jan 2014 21:57:15 +0100 +Subject: [PATCH 10/14] qcow2: Free only newly allocated clusters on error + +RH-Author: Max Reitz +Message-id: <1389131839-12920-11-git-send-email-mreitz@redhat.com> +Patchwork-id: 56546 +O-Subject: [RHEL-7.0 qemu-kvm PATCH v2 10/14] qcow2: Free only newly allocated clusters on error +Bugzilla: 1033490 +RH-Acked-by: Kevin Wolf +RH-Acked-by: Fam Zheng +RH-Acked-by: Stefan Hajnoczi + +BZ: 1033490 + +In expand_zero_clusters_in_l1, a new cluster is only allocated if it was +not already preallocated. On error, such preallocated clusters should +not be freed, but only the newly allocated ones. + +Signed-off-by: Max Reitz +Signed-off-by: Kevin Wolf +(cherry picked from commit 320c70666687db4dd4df8165f9fe6960de782ca9) + +Signed-off-by: Max Reitz +--- + block/qcow2-cluster.c | 16 ++++++++++------ + 1 file changed, 10 insertions(+), 6 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + block/qcow2-cluster.c | 16 ++++++++++------ + 1 files changed, 10 insertions(+), 6 deletions(-) + +diff --git a/block/qcow2-cluster.c b/block/qcow2-cluster.c +index bfdc83a..79c3ae0 100644 +--- a/block/qcow2-cluster.c ++++ b/block/qcow2-cluster.c +@@ -1552,6 +1552,7 @@ static int expand_zero_clusters_in_l1(BlockDriverState *bs, uint64_t *l1_table, + uint64_t l2_entry = be64_to_cpu(l2_table[j]); + int64_t offset = l2_entry & L2E_OFFSET_MASK, cluster_index; + int cluster_type = qcow2_get_cluster_type(l2_entry); ++ bool preallocated = offset != 0; + + if (cluster_type == QCOW2_CLUSTER_NORMAL) { + cluster_index = offset >> s->cluster_bits; +@@ -1577,8 +1578,7 @@ static int expand_zero_clusters_in_l1(BlockDriverState *bs, uint64_t *l1_table, + continue; + } + +- if (!offset) { +- /* not preallocated */ ++ if (!preallocated) { + if (!bs->backing_hd) { + /* not backed; therefore we can simply deallocate the + * cluster */ +@@ -1596,16 +1596,20 @@ static int expand_zero_clusters_in_l1(BlockDriverState *bs, uint64_t *l1_table, + + ret = qcow2_pre_write_overlap_check(bs, 0, offset, s->cluster_size); + if (ret < 0) { +- qcow2_free_clusters(bs, offset, s->cluster_size, +- QCOW2_DISCARD_ALWAYS); ++ if (!preallocated) { ++ qcow2_free_clusters(bs, offset, s->cluster_size, ++ QCOW2_DISCARD_ALWAYS); ++ } + goto fail; + } + + ret = bdrv_write_zeroes(bs->file, offset / BDRV_SECTOR_SIZE, + s->cluster_sectors, 0); + if (ret < 0) { +- qcow2_free_clusters(bs, offset, s->cluster_size, +- QCOW2_DISCARD_ALWAYS); ++ if (!preallocated) { ++ qcow2_free_clusters(bs, offset, s->cluster_size, ++ QCOW2_DISCARD_ALWAYS); ++ } + goto fail; + } + +-- +1.7.1 + diff --git a/SOURCES/kvm-qcow2-Implement-bdrv_amend_options.patch b/SOURCES/kvm-qcow2-Implement-bdrv_amend_options.patch new file mode 100644 index 0000000..9ae0003 --- /dev/null +++ b/SOURCES/kvm-qcow2-Implement-bdrv_amend_options.patch @@ -0,0 +1,252 @@ +From 53db4963174d9f65bd8ba04636ba0adba7615996 Mon Sep 17 00:00:00 2001 +From: Max Reitz +Date: Tue, 7 Jan 2014 21:57:13 +0100 +Subject: [PATCH 08/14] qcow2: Implement bdrv_amend_options + +RH-Author: Max Reitz +Message-id: <1389131839-12920-9-git-send-email-mreitz@redhat.com> +Patchwork-id: 56544 +O-Subject: [RHEL-7.0 qemu-kvm PATCH v2 08/14] qcow2: Implement bdrv_amend_options +Bugzilla: 1033490 +RH-Acked-by: Kevin Wolf +RH-Acked-by: Fam Zheng +RH-Acked-by: Stefan Hajnoczi + +BZ: 1033490 + +Implement bdrv_amend_options for compat, size, backing_file, backing_fmt +and lazy_refcounts. + +Downgrading images from compat=1.1 to compat=0.10 is achieved through +handling all incompatible flags accordingly, clearing all compatible and +autoclear flags and expanding all zero clusters. + +Signed-off-by: Max Reitz +Signed-off-by: Kevin Wolf +(cherry picked from commit 9296b3ed7050cc6e0645fbc3b0aea74406d7eeb2) + +Signed-off-by: Max Reitz +--- + block/qcow2.c | 194 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + 1 file changed, 194 insertions(+) + +Signed-off-by: Miroslav Rezanina +--- + block/qcow2.c | 194 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + 1 files changed, 194 insertions(+), 0 deletions(-) + +diff --git a/block/qcow2.c b/block/qcow2.c +index 0a53a3c..5b28259 100644 +--- a/block/qcow2.c ++++ b/block/qcow2.c +@@ -1989,6 +1989,199 @@ static int qcow2_load_vmstate(BlockDriverState *bs, uint8_t *buf, + return ret; + } + ++/* ++ * Downgrades an image's version. To achieve this, any incompatible features ++ * have to be removed. ++ */ ++static int qcow2_downgrade(BlockDriverState *bs, int target_version) ++{ ++ BDRVQcowState *s = bs->opaque; ++ int current_version = s->qcow_version; ++ int ret; ++ ++ if (target_version == current_version) { ++ return 0; ++ } else if (target_version > current_version) { ++ return -EINVAL; ++ } else if (target_version != 2) { ++ return -EINVAL; ++ } ++ ++ if (s->refcount_order != 4) { ++ /* we would have to convert the image to a refcount_order == 4 image ++ * here; however, since qemu (at the time of writing this) does not ++ * support anything different than 4 anyway, there is no point in doing ++ * so right now; however, we should error out (if qemu supports this in ++ * the future and this code has not been adapted) */ ++ error_report("qcow2_downgrade: Image refcount orders other than 4 are" ++ "currently not supported."); ++ return -ENOTSUP; ++ } ++ ++ /* clear incompatible features */ ++ if (s->incompatible_features & QCOW2_INCOMPAT_DIRTY) { ++ ret = qcow2_mark_clean(bs); ++ if (ret < 0) { ++ return ret; ++ } ++ } ++ ++ /* with QCOW2_INCOMPAT_CORRUPT, it is pretty much impossible to get here in ++ * the first place; if that happens nonetheless, returning -ENOTSUP is the ++ * best thing to do anyway */ ++ ++ if (s->incompatible_features) { ++ return -ENOTSUP; ++ } ++ ++ /* since we can ignore compatible features, we can set them to 0 as well */ ++ s->compatible_features = 0; ++ /* if lazy refcounts have been used, they have already been fixed through ++ * clearing the dirty flag */ ++ ++ /* clearing autoclear features is trivial */ ++ s->autoclear_features = 0; ++ ++ ret = qcow2_expand_zero_clusters(bs); ++ if (ret < 0) { ++ return ret; ++ } ++ ++ s->qcow_version = target_version; ++ ret = qcow2_update_header(bs); ++ if (ret < 0) { ++ s->qcow_version = current_version; ++ return ret; ++ } ++ return 0; ++} ++ ++static int qcow2_amend_options(BlockDriverState *bs, ++ QEMUOptionParameter *options) ++{ ++ BDRVQcowState *s = bs->opaque; ++ int old_version = s->qcow_version, new_version = old_version; ++ uint64_t new_size = 0; ++ const char *backing_file = NULL, *backing_format = NULL; ++ bool lazy_refcounts = s->use_lazy_refcounts; ++ int ret; ++ int i; ++ ++ for (i = 0; options[i].name; i++) ++ { ++ if (!options[i].assigned) { ++ /* only change explicitly defined options */ ++ continue; ++ } ++ ++ if (!strcmp(options[i].name, "compat")) { ++ if (!options[i].value.s) { ++ /* preserve default */ ++ } else if (!strcmp(options[i].value.s, "0.10")) { ++ new_version = 2; ++ } else if (!strcmp(options[i].value.s, "1.1")) { ++ new_version = 3; ++ } else { ++ fprintf(stderr, "Unknown compatibility level %s.\n", ++ options[i].value.s); ++ return -EINVAL; ++ } ++ } else if (!strcmp(options[i].name, "preallocation")) { ++ fprintf(stderr, "Cannot change preallocation mode.\n"); ++ return -ENOTSUP; ++ } else if (!strcmp(options[i].name, "size")) { ++ new_size = options[i].value.n; ++ } else if (!strcmp(options[i].name, "backing_file")) { ++ backing_file = options[i].value.s; ++ } else if (!strcmp(options[i].name, "backing_fmt")) { ++ backing_format = options[i].value.s; ++ } else if (!strcmp(options[i].name, "encryption")) { ++ if ((options[i].value.n != !!s->crypt_method)) { ++ fprintf(stderr, "Changing the encryption flag is not " ++ "supported.\n"); ++ return -ENOTSUP; ++ } ++ } else if (!strcmp(options[i].name, "cluster_size")) { ++ if (options[i].value.n != s->cluster_size) { ++ fprintf(stderr, "Changing the cluster size is not " ++ "supported.\n"); ++ return -ENOTSUP; ++ } ++ } else if (!strcmp(options[i].name, "lazy_refcounts")) { ++ lazy_refcounts = options[i].value.n; ++ } else { ++ /* if this assertion fails, this probably means a new option was ++ * added without having it covered here */ ++ assert(false); ++ } ++ } ++ ++ if (new_version != old_version) { ++ if (new_version > old_version) { ++ /* Upgrade */ ++ s->qcow_version = new_version; ++ ret = qcow2_update_header(bs); ++ if (ret < 0) { ++ s->qcow_version = old_version; ++ return ret; ++ } ++ } else { ++ ret = qcow2_downgrade(bs, new_version); ++ if (ret < 0) { ++ return ret; ++ } ++ } ++ } ++ ++ if (backing_file || backing_format) { ++ ret = qcow2_change_backing_file(bs, backing_file ?: bs->backing_file, ++ backing_format ?: bs->backing_format); ++ if (ret < 0) { ++ return ret; ++ } ++ } ++ ++ if (s->use_lazy_refcounts != lazy_refcounts) { ++ if (lazy_refcounts) { ++ if (s->qcow_version < 3) { ++ fprintf(stderr, "Lazy refcounts only supported with compatibility " ++ "level 1.1 and above (use compat=1.1 or greater)\n"); ++ return -EINVAL; ++ } ++ s->compatible_features |= QCOW2_COMPAT_LAZY_REFCOUNTS; ++ ret = qcow2_update_header(bs); ++ if (ret < 0) { ++ s->compatible_features &= ~QCOW2_COMPAT_LAZY_REFCOUNTS; ++ return ret; ++ } ++ s->use_lazy_refcounts = true; ++ } else { ++ /* make image clean first */ ++ ret = qcow2_mark_clean(bs); ++ if (ret < 0) { ++ return ret; ++ } ++ /* now disallow lazy refcounts */ ++ s->compatible_features &= ~QCOW2_COMPAT_LAZY_REFCOUNTS; ++ ret = qcow2_update_header(bs); ++ if (ret < 0) { ++ s->compatible_features |= QCOW2_COMPAT_LAZY_REFCOUNTS; ++ return ret; ++ } ++ s->use_lazy_refcounts = false; ++ } ++ } ++ ++ if (new_size) { ++ ret = bdrv_truncate(bs, new_size); ++ if (ret < 0) { ++ return ret; ++ } ++ } ++ ++ return 0; ++} ++ + static QEMUOptionParameter qcow2_create_options[] = { + { + .name = BLOCK_OPT_SIZE, +@@ -2073,6 +2266,7 @@ static BlockDriver bdrv_qcow2 = { + + .create_options = qcow2_create_options, + .bdrv_check = qcow2_check, ++ .bdrv_amend_options = qcow2_amend_options, + }; + + static void bdrv_qcow2_init(void) +-- +1.7.1 + diff --git a/SOURCES/kvm-qcow2-Keep-option-in-qcow2_invalidate_cache.patch b/SOURCES/kvm-qcow2-Keep-option-in-qcow2_invalidate_cache.patch new file mode 100644 index 0000000..45979b5 --- /dev/null +++ b/SOURCES/kvm-qcow2-Keep-option-in-qcow2_invalidate_cache.patch @@ -0,0 +1,56 @@ +From ac25e461b9f69a91349aa00531e42dea604b92a7 Mon Sep 17 00:00:00 2001 +From: Kevin Wolf +Date: Mon, 17 Mar 2014 13:29:27 +0100 +Subject: [PATCH 3/6] qcow2: Keep option in qcow2_invalidate_cache() + +RH-Author: Kevin Wolf +Message-id: <1395062967-16867-3-git-send-email-kwolf@redhat.com> +Patchwork-id: 58112 +O-Subject: [RHEL-7.0 qemu-kvm PATCH 2/2] qcow2: Keep option in qcow2_invalidate_cache() +Bugzilla: 1048575 +RH-Acked-by: Max Reitz +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Fam Zheng + +Instead of manually building a list of all options from BDRVQcowState +values just reuse the options that were used to open the image. +qcow2_open() won't fully use all of the options in the QDict, but that's +okay. + +This fixes all of the driver-specific options in qcow2, except for +lazy-refcounts, which was special cased before. + +Signed-off-by: Kevin Wolf +Reviewed-by: Max Reitz +Signed-off-by: Stefan Hajnoczi +(cherry picked from commit d475e5acd2f4679d6ce458369ee658dbd60227e9) +Signed-off-by: Kevin Wolf +--- + block/qcow2.c | 5 +---- + 1 file changed, 1 insertion(+), 4 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + block/qcow2.c | 5 +---- + 1 files changed, 1 insertions(+), 4 deletions(-) + +diff --git a/block/qcow2.c b/block/qcow2.c +index e9bd9c9..18e136e 100644 +--- a/block/qcow2.c ++++ b/block/qcow2.c +@@ -1178,11 +1178,8 @@ static void qcow2_invalidate_cache(BlockDriverState *bs) + + bdrv_invalidate_cache(bs->file); + +- options = qdict_new(); +- qdict_put(options, QCOW2_OPT_LAZY_REFCOUNTS, +- qbool_from_int(s->use_lazy_refcounts)); +- + memset(s, 0, sizeof(BDRVQcowState)); ++ options = qdict_clone_shallow(bs->options); + qcow2_open(bs, options, flags, NULL); + + QDECREF(options); +-- +1.7.1 + diff --git a/SOURCES/kvm-qcow2-Limit-snapshot-table-size.patch b/SOURCES/kvm-qcow2-Limit-snapshot-table-size.patch new file mode 100644 index 0000000..060ae59 --- /dev/null +++ b/SOURCES/kvm-qcow2-Limit-snapshot-table-size.patch @@ -0,0 +1,85 @@ +From 427c0839e73f5bb1b3b0fa33afd4a9e5ea3eb34b Mon Sep 17 00:00:00 2001 +From: Kevin Wolf +Date: Tue, 25 Mar 2014 14:23:53 +0100 +Subject: [PATCH 46/49] qcow2: Limit snapshot table size + +RH-Author: Kevin Wolf +Message-id: <1395753835-7591-47-git-send-email-kwolf@redhat.com> +Patchwork-id: n/a +O-Subject: [virt-devel] [EMBARGOED RHEL-7.0 qemu-kvm PATCH 46/48] qcow2: Limit snapshot table size +Bugzilla: 1066691 +RH-Acked-by: Jeff Cody +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Paolo Bonzini + +Bugzilla: https://bugzilla.redhat.com/show_bug.cgi?id=1066691 +Upstream status: Series embargoed + +Even with a limit of 64k snapshots, each snapshot could have a filename +and an ID with up to 64k, which would still lead to pretty large +allocations, which could potentially lead to qemu aborting. Limit the +total size of the snapshot table to an average of 1k per entry when +the limit of 64k snapshots is fully used. This should be plenty for any +reasonable user. + +This also fixes potential integer overflows of s->snapshot_size. + +Suggested-by: Max Reitz +Signed-off-by: Kevin Wolf +--- + block/qcow2-snapshot.c | 13 +++++++++++++ + block/qcow2.h | 4 ++++ + 2 files changed, 17 insertions(+), 0 deletions(-) + +diff --git a/block/qcow2-snapshot.c b/block/qcow2-snapshot.c +index 626a8d4..84481be 100644 +--- a/block/qcow2-snapshot.c ++++ b/block/qcow2-snapshot.c +@@ -116,8 +116,14 @@ int qcow2_read_snapshots(BlockDriverState *bs) + } + offset += name_size; + sn->name[name_size] = '\0'; ++ ++ if (offset - s->snapshots_offset > QCOW_MAX_SNAPSHOTS_SIZE) { ++ ret = -EFBIG; ++ goto fail; ++ } + } + ++ assert(offset - s->snapshots_offset <= INT_MAX); + s->snapshots_size = offset - s->snapshots_offset; + return 0; + +@@ -150,7 +156,14 @@ static int qcow2_write_snapshots(BlockDriverState *bs) + offset += sizeof(extra); + offset += strlen(sn->id_str); + offset += strlen(sn->name); ++ ++ if (offset > QCOW_MAX_SNAPSHOTS_SIZE) { ++ ret = -EFBIG; ++ goto fail; ++ } + } ++ ++ assert(offset <= INT_MAX); + snapshots_size = offset; + + /* Allocate space for the new snapshot list */ +diff --git a/block/qcow2.h b/block/qcow2.h +index 87e256a..1cc1ef0 100644 +--- a/block/qcow2.h ++++ b/block/qcow2.h +@@ -48,6 +48,10 @@ + * (128 GB for 512 byte clusters, 2 EB for 2 MB clusters) */ + #define QCOW_MAX_L1_SIZE 0x2000000 + ++/* Allow for an average of 1k per snapshot table entry, should be plenty of ++ * space for snapshot names and IDs */ ++#define QCOW_MAX_SNAPSHOTS_SIZE (1024 * QCOW_MAX_SNAPSHOTS) ++ + /* indicate that the refcount of the referenced cluster is exactly one. */ + #define QCOW_OFLAG_COPIED (1LL << 63) + /* indicate that the cluster is compressed (they never have the copied flag) */ +-- +1.7.1 + diff --git a/SOURCES/kvm-qcow2-Protect-against-some-integer-overflows-in-bdrv.patch b/SOURCES/kvm-qcow2-Protect-against-some-integer-overflows-in-bdrv.patch new file mode 100644 index 0000000..2410eea --- /dev/null +++ b/SOURCES/kvm-qcow2-Protect-against-some-integer-overflows-in-bdrv.patch @@ -0,0 +1,74 @@ +From 339f13dfd338d88192a11231f4a60bec57b3b66b Mon Sep 17 00:00:00 2001 +From: Kevin Wolf +Date: Tue, 25 Mar 2014 14:23:38 +0100 +Subject: [PATCH 31/49] qcow2: Protect against some integer overflows in bdrv_check + +RH-Author: Kevin Wolf +Message-id: <1395753835-7591-32-git-send-email-kwolf@redhat.com> +Patchwork-id: n/a +O-Subject: [virt-devel] [EMBARGOED RHEL-7.0 qemu-kvm PATCH 31/48] qcow2: Protect against some integer overflows in bdrv_check +Bugzilla: 1066691 +RH-Acked-by: Jeff Cody +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Paolo Bonzini + +Bugzilla: https://bugzilla.redhat.com/show_bug.cgi?id=1066691 +Upstream status: Series embargoed + +Signed-off-by: Kevin Wolf +--- + block/qcow2-refcount.c | 18 +++++++++--------- + 1 files changed, 9 insertions(+), 9 deletions(-) + +diff --git a/block/qcow2-refcount.c b/block/qcow2-refcount.c +index fb57c10..73ae4e3 100644 +--- a/block/qcow2-refcount.c ++++ b/block/qcow2-refcount.c +@@ -1018,8 +1018,7 @@ static void inc_refcounts(BlockDriverState *bs, + int64_t offset, int64_t size) + { + BDRVQcowState *s = bs->opaque; +- int64_t start, last, cluster_offset; +- int k; ++ uint64_t start, last, cluster_offset, k; + + if (size <= 0) + return; +@@ -1029,11 +1028,7 @@ static void inc_refcounts(BlockDriverState *bs, + for(cluster_offset = start; cluster_offset <= last; + cluster_offset += s->cluster_size) { + k = cluster_offset >> s->cluster_bits; +- if (k < 0) { +- fprintf(stderr, "ERROR: invalid cluster offset=0x%" PRIx64 "\n", +- cluster_offset); +- res->corruptions++; +- } else if (k >= refcount_table_size) { ++ if (k >= refcount_table_size) { + fprintf(stderr, "Warning: cluster offset=0x%" PRIx64 " is after " + "the end of the image file, can't properly check refcounts.\n", + cluster_offset); +@@ -1474,14 +1469,19 @@ int qcow2_check_refcounts(BlockDriverState *bs, BdrvCheckResult *res, + BdrvCheckMode fix) + { + BDRVQcowState *s = bs->opaque; +- int64_t size, i, highest_cluster; +- int nb_clusters, refcount1, refcount2; ++ int64_t size, i, highest_cluster, nb_clusters; ++ int refcount1, refcount2; + QCowSnapshot *sn; + uint16_t *refcount_table; + int ret; + + size = bdrv_getlength(bs->file); + nb_clusters = size_to_clusters(s, size); ++ if (nb_clusters > INT_MAX) { ++ res->check_errors++; ++ return -EFBIG; ++ } ++ + refcount_table = g_malloc0(nb_clusters * sizeof(uint16_t)); + + res->bfi.total_clusters = +-- +1.7.1 + diff --git a/SOURCES/kvm-qcow2-Save-refcount-order-in-BDRVQcowState.patch b/SOURCES/kvm-qcow2-Save-refcount-order-in-BDRVQcowState.patch new file mode 100644 index 0000000..dcd9460 --- /dev/null +++ b/SOURCES/kvm-qcow2-Save-refcount-order-in-BDRVQcowState.patch @@ -0,0 +1,73 @@ +From a6f84b8fefe3225f3fb6969c5f763bb7151f740e Mon Sep 17 00:00:00 2001 +From: Max Reitz +Date: Tue, 7 Jan 2014 21:57:12 +0100 +Subject: [PATCH 07/14] qcow2: Save refcount order in BDRVQcowState + +RH-Author: Max Reitz +Message-id: <1389131839-12920-8-git-send-email-mreitz@redhat.com> +Patchwork-id: 56543 +O-Subject: [RHEL-7.0 qemu-kvm PATCH v2 07/14] qcow2: Save refcount order in BDRVQcowState +Bugzilla: 1033490 +RH-Acked-by: Kevin Wolf +RH-Acked-by: Fam Zheng +RH-Acked-by: Stefan Hajnoczi + +BZ: 1033490 + +Save the image refcount order in BDRVQcowState. This will be relevant +for future code supporting different refcount orders than four and also +for code that needs to verify a certain refcount order for an opened +image. + +Signed-off-by: Max Reitz +Signed-off-by: Kevin Wolf +(cherry picked from commit b6481f376bc65894910dd98db3f299d698817106) + +Signed-off-by: Max Reitz +--- + block/qcow2.c | 3 ++- + block/qcow2.h | 1 + + 2 files changed, 3 insertions(+), 1 deletion(-) + +Signed-off-by: Miroslav Rezanina +--- + block/qcow2.c | 3 ++- + block/qcow2.h | 1 + + 2 files changed, 3 insertions(+), 1 deletions(-) + +diff --git a/block/qcow2.c b/block/qcow2.c +index f5f68f8..0a53a3c 100644 +--- a/block/qcow2.c ++++ b/block/qcow2.c +@@ -527,6 +527,7 @@ static int qcow2_open(BlockDriverState *bs, QDict *options, int flags, + ret = -ENOTSUP; + goto fail; + } ++ s->refcount_order = header.refcount_order; + + if (header.cluster_bits < MIN_CLUSTER_BITS || + header.cluster_bits > MAX_CLUSTER_BITS) { +@@ -1255,7 +1256,7 @@ int qcow2_update_header(BlockDriverState *bs) + .incompatible_features = cpu_to_be64(s->incompatible_features), + .compatible_features = cpu_to_be64(s->compatible_features), + .autoclear_features = cpu_to_be64(s->autoclear_features), +- .refcount_order = cpu_to_be32(3 + REFCOUNT_SHIFT), ++ .refcount_order = cpu_to_be32(s->refcount_order), + .header_length = cpu_to_be32(header_length), + }; + +diff --git a/block/qcow2.h b/block/qcow2.h +index 2660483..9749f03 100644 +--- a/block/qcow2.h ++++ b/block/qcow2.h +@@ -208,6 +208,7 @@ typedef struct BDRVQcowState { + int flags; + int qcow_version; + bool use_lazy_refcounts; ++ int refcount_order; + + bool discard_passthrough[QCOW2_DISCARD_MAX]; + +-- +1.7.1 + diff --git a/SOURCES/kvm-qcow2-Validate-active-L1-table-offset-and-size-CVE-2.patch b/SOURCES/kvm-qcow2-Validate-active-L1-table-offset-and-size-CVE-2.patch new file mode 100644 index 0000000..bbb4cea --- /dev/null +++ b/SOURCES/kvm-qcow2-Validate-active-L1-table-offset-and-size-CVE-2.patch @@ -0,0 +1,120 @@ +From fdbe21cc29a983e05b6df725a75b1a1b15d7795e Mon Sep 17 00:00:00 2001 +From: Kevin Wolf +Date: Tue, 25 Mar 2014 14:23:32 +0100 +Subject: [PATCH 25/49] qcow2: Validate active L1 table offset and size (CVE-2014-0144) + +RH-Author: Kevin Wolf +Message-id: <1395753835-7591-26-git-send-email-kwolf@redhat.com> +Patchwork-id: n/a +O-Subject: [virt-devel] [EMBARGOED RHEL-7.0 qemu-kvm PATCH 25/48] qcow2: Validate active L1 table offset and size (CVE-2014-0144) +Bugzilla: 1079455 +RH-Acked-by: Jeff Cody +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Paolo Bonzini + +Bugzilla: https://bugzilla.redhat.com/show_bug.cgi?id=1079455 +Upstream status: Embargoed + +This avoids an unbounded allocation. + +Signed-off-by: Kevin Wolf +--- + block/qcow2.c | 16 ++++++++++++++++ + tests/qemu-iotests/080 | 18 ++++++++++++++++++ + tests/qemu-iotests/080.out | 11 +++++++++++ + 3 files changed, 45 insertions(+), 0 deletions(-) + +diff --git a/block/qcow2.c b/block/qcow2.c +index 8c74dea..8be82f0 100644 +--- a/block/qcow2.c ++++ b/block/qcow2.c +@@ -641,6 +641,13 @@ static int qcow2_open(BlockDriverState *bs, QDict *options, int flags, + s->nb_snapshots = header.nb_snapshots; + + /* read the level 1 table */ ++ if (header.l1_size > 0x2000000) { ++ /* 32 MB L1 table is enough for 2 PB images at 64k cluster size ++ * (128 GB for 512 byte clusters, 2 EB for 2 MB clusters) */ ++ error_setg(errp, "Active L1 table too large"); ++ ret = -EFBIG; ++ goto fail; ++ } + s->l1_size = header.l1_size; + + l1_vm_state_index = size_to_l1(s, header.size); +@@ -658,7 +665,16 @@ static int qcow2_open(BlockDriverState *bs, QDict *options, int flags, + ret = -EINVAL; + goto fail; + } ++ ++ ret = validate_table_offset(bs, header.l1_table_offset, ++ header.l1_size, sizeof(uint64_t)); ++ if (ret < 0) { ++ error_setg(errp, "Invalid L1 table offset"); ++ goto fail; ++ } + s->l1_table_offset = header.l1_table_offset; ++ ++ + if (s->l1_size > 0) { + s->l1_table = g_malloc0( + align_offset(s->l1_size * sizeof(uint64_t), 512)); +diff --git a/tests/qemu-iotests/080 b/tests/qemu-iotests/080 +index 8a8b460..7255b6c 100755 +--- a/tests/qemu-iotests/080 ++++ b/tests/qemu-iotests/080 +@@ -45,6 +45,8 @@ _supported_os Linux + header_size=104 + + offset_backing_file_offset=8 ++offset_l1_size=36 ++offset_l1_table_offset=40 + offset_refcount_table_offset=48 + offset_refcount_table_clusters=56 + offset_nb_snapshots=60 +@@ -117,6 +119,22 @@ poke_file "$TEST_IMG" "$offset_nb_snapshots" "\x00\x01\x00\x00" + { $QEMU_IMG snapshot -c test $TEST_IMG; } 2>&1 | _filter_testdir + { $QEMU_IO -c "read 0 512" $TEST_IMG; } 2>&1 | _filter_qemu_io | _filter_testdir + ++echo ++echo "== Invalid L1 table ==" ++_make_test_img 64M ++poke_file "$TEST_IMG" "$offset_l1_size" "\xff\xff\xff\xff" ++{ $QEMU_IO -c "read 0 512" $TEST_IMG; } 2>&1 | _filter_qemu_io | _filter_testdir ++poke_file "$TEST_IMG" "$offset_l1_size" "\x7f\xff\xff\xff" ++{ $QEMU_IO -c "read 0 512" $TEST_IMG; } 2>&1 | _filter_qemu_io | _filter_testdir ++ ++poke_file "$TEST_IMG" "$offset_l1_table_offset" "\x7f\xff\xff\xff\xff\xff\x00\x00" ++poke_file "$TEST_IMG" "$offset_l1_size" "\x00\x00\xff\xff" ++{ $QEMU_IO -c "read 0 512" $TEST_IMG; } 2>&1 | _filter_qemu_io | _filter_testdir ++ ++poke_file "$TEST_IMG" "$offset_l1_table_offset" "\x12\x34\x56\x78\x90\xab\xcd\xef" ++poke_file "$TEST_IMG" "$offset_l1_size" "\x00\x00\x00\x01" ++{ $QEMU_IO -c "read 0 512" $TEST_IMG; } 2>&1 | _filter_qemu_io | _filter_testdir ++ + # success, all done + echo "*** done" + rm -f $seq.full +diff --git a/tests/qemu-iotests/080.out b/tests/qemu-iotests/080.out +index b06f47f..4ec2545 100644 +--- a/tests/qemu-iotests/080.out ++++ b/tests/qemu-iotests/080.out +@@ -47,4 +47,15 @@ Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864 + qemu-img: Could not create snapshot 'test': -27 (File too large) + read 512/512 bytes at offset 0 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) ++ ++== Invalid L1 table == ++Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864 ++qemu-io: can't open device TEST_DIR/t.qcow2: Active L1 table too large ++no file open, try 'help open' ++qemu-io: can't open device TEST_DIR/t.qcow2: Active L1 table too large ++no file open, try 'help open' ++qemu-io: can't open device TEST_DIR/t.qcow2: Invalid L1 table offset ++no file open, try 'help open' ++qemu-io: can't open device TEST_DIR/t.qcow2: Invalid L1 table offset ++no file open, try 'help open' + *** done +-- +1.7.1 + diff --git a/SOURCES/kvm-qcow2-Validate-refcount-table-offset.patch b/SOURCES/kvm-qcow2-Validate-refcount-table-offset.patch new file mode 100644 index 0000000..fc03d1a --- /dev/null +++ b/SOURCES/kvm-qcow2-Validate-refcount-table-offset.patch @@ -0,0 +1,135 @@ +From 6707cb9501355de8244d224b3a8140c0fe62a983 Mon Sep 17 00:00:00 2001 +From: Kevin Wolf +Date: Tue, 25 Mar 2014 14:23:30 +0100 +Subject: [PATCH 23/49] qcow2: Validate refcount table offset + +RH-Author: Kevin Wolf +Message-id: <1395753835-7591-24-git-send-email-kwolf@redhat.com> +Patchwork-id: n/a +O-Subject: [virt-devel] [EMBARGOED RHEL-7.0 qemu-kvm PATCH 23/48] qcow2: Validate refcount table offset +Bugzilla: 1066691 +RH-Acked-by: Jeff Cody +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Paolo Bonzini + +Bugzilla: https://bugzilla.redhat.com/show_bug.cgi?id=1066691 +Upstream status: Series embargoed + +The end of the refcount table must not exceed INT64_MAX so that integer +overflows are avoided. + +Also check for misaligned refcount table. Such images are invalid and +probably the result of data corruption. Error out to avoid further +corruption. + +Signed-off-by: Kevin Wolf +--- + block/qcow2.c | 33 +++++++++++++++++++++++++++++++++ + tests/qemu-iotests/080 | 13 +++++++++++++ + tests/qemu-iotests/080.out | 10 ++++++++++ + 3 files changed, 56 insertions(+), 0 deletions(-) + +diff --git a/block/qcow2.c b/block/qcow2.c +index a7780ac..5513fac 100644 +--- a/block/qcow2.c ++++ b/block/qcow2.c +@@ -329,6 +329,32 @@ static int qcow2_check(BlockDriverState *bs, BdrvCheckResult *result, + return ret; + } + ++static int validate_table_offset(BlockDriverState *bs, uint64_t offset, ++ uint64_t entries, size_t entry_len) ++{ ++ BDRVQcowState *s = bs->opaque; ++ uint64_t size; ++ ++ /* Use signed INT64_MAX as the maximum even for uint64_t header fields, ++ * because values will be passed to qemu functions taking int64_t. */ ++ if (entries > INT64_MAX / entry_len) { ++ return -EINVAL; ++ } ++ ++ size = entries * entry_len; ++ ++ if (INT64_MAX - size < offset) { ++ return -EINVAL; ++ } ++ ++ /* Tables must be cluster aligned */ ++ if (offset & (s->cluster_size - 1)) { ++ return -EINVAL; ++ } ++ ++ return 0; ++} ++ + static QemuOptsList qcow2_runtime_opts = { + .name = "qcow2", + .head = QTAILQ_HEAD_INITIALIZER(qcow2_runtime_opts.head), +@@ -589,6 +615,13 @@ static int qcow2_open(BlockDriverState *bs, QDict *options, int flags, + goto fail; + } + ++ ret = validate_table_offset(bs, s->refcount_table_offset, ++ s->refcount_table_size, sizeof(uint64_t)); ++ if (ret < 0) { ++ error_setg(errp, "Invalid reference count table offset"); ++ goto fail; ++ } ++ + s->snapshots_offset = header.snapshots_offset; + s->nb_snapshots = header.nb_snapshots; + +diff --git a/tests/qemu-iotests/080 b/tests/qemu-iotests/080 +index 6179e05..f58ac73 100755 +--- a/tests/qemu-iotests/080 ++++ b/tests/qemu-iotests/080 +@@ -45,6 +45,7 @@ _supported_os Linux + header_size=104 + + offset_backing_file_offset=8 ++offset_refcount_table_offset=48 + offset_refcount_table_clusters=56 + offset_header_size=100 + offset_ext_magic=$header_size +@@ -76,6 +77,18 @@ poke_file "$TEST_IMG" "$offset_refcount_table_clusters" "\xff\xff\xff\xff" + poke_file "$TEST_IMG" "$offset_refcount_table_clusters" "\x00\x02\x00\x01" + { $QEMU_IO -c "read 0 512" $TEST_IMG; } 2>&1 | _filter_qemu_io | _filter_testdir + ++echo ++echo "== Misaligned refcount table ==" ++_make_test_img 64M ++poke_file "$TEST_IMG" "$offset_refcount_table_offset" "\x12\x34\x56\x78\x90\xab\xcd\xef" ++{ $QEMU_IO -c "read 0 512" $TEST_IMG; } 2>&1 | _filter_qemu_io | _filter_testdir ++ ++echo ++echo "== Huge refcount offset ==" ++_make_test_img 64M ++poke_file "$TEST_IMG" "$offset_refcount_table_offset" "\xff\xff\xff\xff\xff\xff\x00\x00" ++poke_file "$TEST_IMG" "$offset_refcount_table_clusters" "\x00\x00\x00\x7f" ++{ $QEMU_IO -c "read 0 512" $TEST_IMG; } 2>&1 | _filter_qemu_io | _filter_testdir + + # success, all done + echo "*** done" +diff --git a/tests/qemu-iotests/080.out b/tests/qemu-iotests/080.out +index 6fef6d9..f919b58 100644 +--- a/tests/qemu-iotests/080.out ++++ b/tests/qemu-iotests/080.out +@@ -20,4 +20,14 @@ qemu-io: can't open device TEST_DIR/t.qcow2: Reference count table too large + no file open, try 'help open' + qemu-io: can't open device TEST_DIR/t.qcow2: Reference count table too large + no file open, try 'help open' ++ ++== Misaligned refcount table == ++Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864 ++qemu-io: can't open device TEST_DIR/t.qcow2: Invalid reference count table offset ++no file open, try 'help open' ++ ++== Huge refcount offset == ++Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864 ++qemu-io: can't open device TEST_DIR/t.qcow2: Invalid reference count table offset ++no file open, try 'help open' + *** done +-- +1.7.1 + diff --git a/SOURCES/kvm-qcow2-Validate-snapshot-table-offset-size-CVE-2014-0.patch b/SOURCES/kvm-qcow2-Validate-snapshot-table-offset-size-CVE-2014-0.patch new file mode 100644 index 0000000..d7ff2be --- /dev/null +++ b/SOURCES/kvm-qcow2-Validate-snapshot-table-offset-size-CVE-2014-0.patch @@ -0,0 +1,230 @@ +From 2318681bf850996a3e9c682ca3290aa9f05fd15c Mon Sep 17 00:00:00 2001 +From: Kevin Wolf +Date: Tue, 25 Mar 2014 14:23:31 +0100 +Subject: [PATCH 24/49] qcow2: Validate snapshot table offset/size (CVE-2014-0144) + +RH-Author: Kevin Wolf +Message-id: <1395753835-7591-25-git-send-email-kwolf@redhat.com> +Patchwork-id: n/a +O-Subject: [virt-devel] [EMBARGOED RHEL-7.0 qemu-kvm PATCH 24/48] qcow2: Validate snapshot table offset/size (CVE-2014-0144) +Bugzilla: 1079455 +RH-Acked-by: Jeff Cody +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Paolo Bonzini + +Bugzilla: https://bugzilla.redhat.com/show_bug.cgi?id=1079455 +Upstream status: Embargoed + +This avoid unbounded memory allocation and fixes a potential buffer +overflow on 32 bit hosts. + +Signed-off-by: Kevin Wolf +--- + block/qcow2-snapshot.c | 29 ++++------------------------- + block/qcow2.c | 15 +++++++++++++++ + block/qcow2.h | 29 ++++++++++++++++++++++++++++- + tests/qemu-iotests/080 | 27 +++++++++++++++++++++++++++ + tests/qemu-iotests/080.out | 17 +++++++++++++++++ + 5 files changed, 91 insertions(+), 26 deletions(-) + +diff --git a/block/qcow2-snapshot.c b/block/qcow2-snapshot.c +index aa88c51..5d73506 100644 +--- a/block/qcow2-snapshot.c ++++ b/block/qcow2-snapshot.c +@@ -26,31 +26,6 @@ + #include "block/block_int.h" + #include "block/qcow2.h" + +-typedef struct QEMU_PACKED QCowSnapshotHeader { +- /* header is 8 byte aligned */ +- uint64_t l1_table_offset; +- +- uint32_t l1_size; +- uint16_t id_str_size; +- uint16_t name_size; +- +- uint32_t date_sec; +- uint32_t date_nsec; +- +- uint64_t vm_clock_nsec; +- +- uint32_t vm_state_size; +- uint32_t extra_data_size; /* for extension */ +- /* extra data follows */ +- /* id_str follows */ +- /* name follows */ +-} QCowSnapshotHeader; +- +-typedef struct QEMU_PACKED QCowSnapshotExtraData { +- uint64_t vm_state_size_large; +- uint64_t disk_size; +-} QCowSnapshotExtraData; +- + void qcow2_free_snapshots(BlockDriverState *bs) + { + BDRVQcowState *s = bs->opaque; +@@ -334,6 +309,10 @@ int qcow2_snapshot_create(BlockDriverState *bs, QEMUSnapshotInfo *sn_info) + uint64_t *l1_table = NULL; + int64_t l1_table_offset; + ++ if (s->nb_snapshots >= QCOW_MAX_SNAPSHOTS) { ++ return -EFBIG; ++ } ++ + memset(sn, 0, sizeof(*sn)); + + /* Generate an ID if it wasn't passed */ +diff --git a/block/qcow2.c b/block/qcow2.c +index 5513fac..8c74dea 100644 +--- a/block/qcow2.c ++++ b/block/qcow2.c +@@ -622,6 +622,21 @@ static int qcow2_open(BlockDriverState *bs, QDict *options, int flags, + goto fail; + } + ++ /* Snapshot table offset/length */ ++ if (header.nb_snapshots > QCOW_MAX_SNAPSHOTS) { ++ error_setg(errp, "Too many snapshots"); ++ ret = -EINVAL; ++ goto fail; ++ } ++ ++ ret = validate_table_offset(bs, header.snapshots_offset, ++ header.nb_snapshots, ++ sizeof(QCowSnapshotHeader)); ++ if (ret < 0) { ++ error_setg(errp, "Invalid snapshot table offset"); ++ goto fail; ++ } ++ + s->snapshots_offset = header.snapshots_offset; + s->nb_snapshots = header.nb_snapshots; + +diff --git a/block/qcow2.h b/block/qcow2.h +index 4a653c5..5efc96e 100644 +--- a/block/qcow2.h ++++ b/block/qcow2.h +@@ -38,6 +38,7 @@ + #define QCOW_CRYPT_AES 1 + + #define QCOW_MAX_CRYPT_CLUSTERS 32 ++#define QCOW_MAX_SNAPSHOTS 65536 + + /* indicate that the refcount of the referenced cluster is exactly one. */ + #define QCOW_OFLAG_COPIED (1LL << 63) +@@ -97,6 +98,32 @@ typedef struct QCowHeader { + uint32_t header_length; + } QCowHeader; + ++typedef struct QEMU_PACKED QCowSnapshotHeader { ++ /* header is 8 byte aligned */ ++ uint64_t l1_table_offset; ++ ++ uint32_t l1_size; ++ uint16_t id_str_size; ++ uint16_t name_size; ++ ++ uint32_t date_sec; ++ uint32_t date_nsec; ++ ++ uint64_t vm_clock_nsec; ++ ++ uint32_t vm_state_size; ++ uint32_t extra_data_size; /* for extension */ ++ /* extra data follows */ ++ /* id_str follows */ ++ /* name follows */ ++} QCowSnapshotHeader; ++ ++typedef struct QEMU_PACKED QCowSnapshotExtraData { ++ uint64_t vm_state_size_large; ++ uint64_t disk_size; ++} QCowSnapshotExtraData; ++ ++ + typedef struct QCowSnapshot { + uint64_t l1_table_offset; + uint32_t l1_size; +@@ -202,7 +229,7 @@ typedef struct BDRVQcowState { + AES_KEY aes_decrypt_key; + uint64_t snapshots_offset; + int snapshots_size; +- int nb_snapshots; ++ unsigned int nb_snapshots; + QCowSnapshot *snapshots; + + int flags; +diff --git a/tests/qemu-iotests/080 b/tests/qemu-iotests/080 +index f58ac73..8a8b460 100755 +--- a/tests/qemu-iotests/080 ++++ b/tests/qemu-iotests/080 +@@ -47,6 +47,8 @@ header_size=104 + offset_backing_file_offset=8 + offset_refcount_table_offset=48 + offset_refcount_table_clusters=56 ++offset_nb_snapshots=60 ++offset_snapshots_offset=64 + offset_header_size=100 + offset_ext_magic=$header_size + offset_ext_size=$((header_size + 4)) +@@ -90,6 +92,31 @@ poke_file "$TEST_IMG" "$offset_refcount_table_offset" "\xff\xff\xff\xff\xff\xff\ + poke_file "$TEST_IMG" "$offset_refcount_table_clusters" "\x00\x00\x00\x7f" + { $QEMU_IO -c "read 0 512" $TEST_IMG; } 2>&1 | _filter_qemu_io | _filter_testdir + ++echo ++echo "== Invalid snapshot table ==" ++_make_test_img 64M ++poke_file "$TEST_IMG" "$offset_nb_snapshots" "\xff\xff\xff\xff" ++{ $QEMU_IO -c "read 0 512" $TEST_IMG; } 2>&1 | _filter_qemu_io | _filter_testdir ++poke_file "$TEST_IMG" "$offset_nb_snapshots" "\x7f\xff\xff\xff" ++{ $QEMU_IO -c "read 0 512" $TEST_IMG; } 2>&1 | _filter_qemu_io | _filter_testdir ++ ++poke_file "$TEST_IMG" "$offset_snapshots_offset" "\xff\xff\xff\xff\xff\xff\x00\x00" ++poke_file "$TEST_IMG" "$offset_nb_snapshots" "\x00\x00\xff\xff" ++{ $QEMU_IO -c "read 0 512" $TEST_IMG; } 2>&1 | _filter_qemu_io | _filter_testdir ++ ++poke_file "$TEST_IMG" "$offset_snapshots_offset" "\x12\x34\x56\x78\x90\xab\xcd\xef" ++poke_file "$TEST_IMG" "$offset_nb_snapshots" "\x00\x00\x00\x00" ++{ $QEMU_IO -c "read 0 512" $TEST_IMG; } 2>&1 | _filter_qemu_io | _filter_testdir ++ ++echo ++echo "== Hitting snapshot table size limit ==" ++_make_test_img 64M ++# Put the refcount table in a more or less safe place (16 MB) ++poke_file "$TEST_IMG" "$offset_snapshots_offset" "\x00\x00\x00\x00\x01\x00\x00\x00" ++poke_file "$TEST_IMG" "$offset_nb_snapshots" "\x00\x01\x00\x00" ++{ $QEMU_IMG snapshot -c test $TEST_IMG; } 2>&1 | _filter_testdir ++{ $QEMU_IO -c "read 0 512" $TEST_IMG; } 2>&1 | _filter_qemu_io | _filter_testdir ++ + # success, all done + echo "*** done" + rm -f $seq.full +diff --git a/tests/qemu-iotests/080.out b/tests/qemu-iotests/080.out +index f919b58..b06f47f 100644 +--- a/tests/qemu-iotests/080.out ++++ b/tests/qemu-iotests/080.out +@@ -30,4 +30,21 @@ no file open, try 'help open' + Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864 + qemu-io: can't open device TEST_DIR/t.qcow2: Invalid reference count table offset + no file open, try 'help open' ++ ++== Invalid snapshot table == ++Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864 ++qemu-io: can't open device TEST_DIR/t.qcow2: Too many snapshots ++no file open, try 'help open' ++qemu-io: can't open device TEST_DIR/t.qcow2: Too many snapshots ++no file open, try 'help open' ++qemu-io: can't open device TEST_DIR/t.qcow2: Invalid snapshot table offset ++no file open, try 'help open' ++qemu-io: can't open device TEST_DIR/t.qcow2: Invalid snapshot table offset ++no file open, try 'help open' ++ ++== Hitting snapshot table size limit == ++Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864 ++qemu-img: Could not create snapshot 'test': -27 (File too large) ++read 512/512 bytes at offset 0 ++512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) + *** done +-- +1.7.1 + diff --git a/SOURCES/kvm-qcow2-Zero-initialise-first-cluster-for-new-images.patch b/SOURCES/kvm-qcow2-Zero-initialise-first-cluster-for-new-images.patch new file mode 100644 index 0000000..f8f7dca --- /dev/null +++ b/SOURCES/kvm-qcow2-Zero-initialise-first-cluster-for-new-images.patch @@ -0,0 +1,107 @@ +From a27b645ebf68deff6658389f34ee938ba042a2dd Mon Sep 17 00:00:00 2001 +From: Kevin Wolf +Date: Tue, 7 Jan 2014 12:44:44 +0100 +Subject: [PATCH 8/8] qcow2: Zero-initialise first cluster for new images + +RH-Author: Kevin Wolf +Message-id: <1389098684-1559-1-git-send-email-kwolf@redhat.com> +Patchwork-id: 56522 +O-Subject: [RHEL-7.0 qemu-kvm PATCH] qcow2: Zero-initialise first cluster for new images +Bugzilla: 1032904 +RH-Acked-by: Max Reitz +RH-Acked-by: Fam Zheng +RH-Acked-by: Stefan Hajnoczi + +Bugzilla: 1032904 +Brew: http://brewweb.devel.redhat.com/brew/taskinfo?taskID=6817817 + +Strictly speaking, this is only required for has_zero_init() == false, +but it's easy enough to just do a cluster-aligned write that is padded +with zeros after the header. + +This fixes that after 'qemu-img create' header extensions are attempted +to be parsed that are really just random leftover data. + +Cc: qemu-stable@nongnu.org +Signed-off-by: Kevin Wolf +Reviewed-by: Fam Zheng +Reviewed-by: Paolo Bonzini +Signed-off-by: Stefan Hajnoczi +(cherry picked from commit f8413b3c23b08a547ce18609acc6fae5fd04ed5c) + +Signed-off-by: Kevin Wolf +--- + block/qcow2.c | 36 ++++++++++++++++++++---------------- + 1 file changed, 20 insertions(+), 16 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + block/qcow2.c | 36 ++++++++++++++++++++---------------- + 1 files changed, 20 insertions(+), 16 deletions(-) + +diff --git a/block/qcow2.c b/block/qcow2.c +index bf1f66f..f5f68f8 100644 +--- a/block/qcow2.c ++++ b/block/qcow2.c +@@ -1471,7 +1471,7 @@ static int qcow2_create2(const char *filename, int64_t total_size, + * size for any qcow2 image. + */ + BlockDriverState* bs; +- QCowHeader header; ++ QCowHeader *header; + uint8_t* refcount_table; + Error *local_err = NULL; + int ret; +@@ -1489,30 +1489,34 @@ static int qcow2_create2(const char *filename, int64_t total_size, + } + + /* Write the header */ +- memset(&header, 0, sizeof(header)); +- header.magic = cpu_to_be32(QCOW_MAGIC); +- header.version = cpu_to_be32(version); +- header.cluster_bits = cpu_to_be32(cluster_bits); +- header.size = cpu_to_be64(0); +- header.l1_table_offset = cpu_to_be64(0); +- header.l1_size = cpu_to_be32(0); +- header.refcount_table_offset = cpu_to_be64(cluster_size); +- header.refcount_table_clusters = cpu_to_be32(1); +- header.refcount_order = cpu_to_be32(3 + REFCOUNT_SHIFT); +- header.header_length = cpu_to_be32(sizeof(header)); ++ QEMU_BUILD_BUG_ON((1 << MIN_CLUSTER_BITS) < sizeof(*header)); ++ header = g_malloc0(cluster_size); ++ *header = (QCowHeader) { ++ .magic = cpu_to_be32(QCOW_MAGIC), ++ .version = cpu_to_be32(version), ++ .cluster_bits = cpu_to_be32(cluster_bits), ++ .size = cpu_to_be64(0), ++ .l1_table_offset = cpu_to_be64(0), ++ .l1_size = cpu_to_be32(0), ++ .refcount_table_offset = cpu_to_be64(cluster_size), ++ .refcount_table_clusters = cpu_to_be32(1), ++ .refcount_order = cpu_to_be32(3 + REFCOUNT_SHIFT), ++ .header_length = cpu_to_be32(sizeof(*header)), ++ }; + + if (flags & BLOCK_FLAG_ENCRYPT) { +- header.crypt_method = cpu_to_be32(QCOW_CRYPT_AES); ++ header->crypt_method = cpu_to_be32(QCOW_CRYPT_AES); + } else { +- header.crypt_method = cpu_to_be32(QCOW_CRYPT_NONE); ++ header->crypt_method = cpu_to_be32(QCOW_CRYPT_NONE); + } + + if (flags & BLOCK_FLAG_LAZY_REFCOUNTS) { +- header.compatible_features |= ++ header->compatible_features |= + cpu_to_be64(QCOW2_COMPAT_LAZY_REFCOUNTS); + } + +- ret = bdrv_pwrite(bs, 0, &header, sizeof(header)); ++ ret = bdrv_pwrite(bs, 0, header, cluster_size); ++ g_free(header); + if (ret < 0) { + error_setg_errno(errp, -ret, "Could not write qcow2 header"); + goto out; +-- +1.7.1 + diff --git a/SOURCES/kvm-qcow2-cache-Empty-cache.patch b/SOURCES/kvm-qcow2-cache-Empty-cache.patch new file mode 100644 index 0000000..2b48ce3 --- /dev/null +++ b/SOURCES/kvm-qcow2-cache-Empty-cache.patch @@ -0,0 +1,80 @@ +From 3a454be93c4750bad515dc3dacc83a3feff5e02c Mon Sep 17 00:00:00 2001 +From: Max Reitz +Date: Tue, 7 Jan 2014 21:57:10 +0100 +Subject: [PATCH 05/14] qcow2-cache: Empty cache + +RH-Author: Max Reitz +Message-id: <1389131839-12920-6-git-send-email-mreitz@redhat.com> +Patchwork-id: 56541 +O-Subject: [RHEL-7.0 qemu-kvm PATCH v2 05/14] qcow2-cache: Empty cache +Bugzilla: 1033490 +RH-Acked-by: Kevin Wolf +RH-Acked-by: Fam Zheng +RH-Acked-by: Stefan Hajnoczi + +BZ: 1033490 + +Add a function for emptying a cache, i.e., flushing it and marking all +elements invalid. + +Signed-off-by: Max Reitz +Signed-off-by: Kevin Wolf +(cherry picked from commit e7108feaace8e02b3a4bf010448fc2744f753381) + +Signed-off-by: Max Reitz +--- + block/qcow2-cache.c | 18 ++++++++++++++++++ + block/qcow2.h | 2 ++ + 2 files changed, 20 insertions(+) + +Signed-off-by: Miroslav Rezanina +--- + block/qcow2-cache.c | 18 ++++++++++++++++++ + block/qcow2.h | 2 ++ + 2 files changed, 20 insertions(+), 0 deletions(-) + +diff --git a/block/qcow2-cache.c b/block/qcow2-cache.c +index eb1d69b..8ecbb5b 100644 +--- a/block/qcow2-cache.c ++++ b/block/qcow2-cache.c +@@ -200,6 +200,24 @@ void qcow2_cache_depends_on_flush(Qcow2Cache *c) + c->depends_on_flush = true; + } + ++int qcow2_cache_empty(BlockDriverState *bs, Qcow2Cache *c) ++{ ++ int ret, i; ++ ++ ret = qcow2_cache_flush(bs, c); ++ if (ret < 0) { ++ return ret; ++ } ++ ++ for (i = 0; i < c->size; i++) { ++ assert(c->entries[i].ref == 0); ++ c->entries[i].offset = 0; ++ c->entries[i].cache_hits = 0; ++ } ++ ++ return 0; ++} ++ + static int qcow2_cache_find_entry_to_replace(Qcow2Cache *c) + { + int i; +diff --git a/block/qcow2.h b/block/qcow2.h +index e4c140c..5ca6b78 100644 +--- a/block/qcow2.h ++++ b/block/qcow2.h +@@ -489,6 +489,8 @@ int qcow2_cache_set_dependency(BlockDriverState *bs, Qcow2Cache *c, + Qcow2Cache *dependency); + void qcow2_cache_depends_on_flush(Qcow2Cache *c); + ++int qcow2_cache_empty(BlockDriverState *bs, Qcow2Cache *c); ++ + int qcow2_cache_get(BlockDriverState *bs, Qcow2Cache *c, uint64_t offset, + void **table); + int qcow2_cache_get_empty(BlockDriverState *bs, Qcow2Cache *c, uint64_t offset, +-- +1.7.1 + diff --git a/SOURCES/kvm-qcow2-change-default-for-new-images-to-compat-1.1-pa.patch b/SOURCES/kvm-qcow2-change-default-for-new-images-to-compat-1.1-pa.patch new file mode 100644 index 0000000..664d209 --- /dev/null +++ b/SOURCES/kvm-qcow2-change-default-for-new-images-to-compat-1.1-pa.patch @@ -0,0 +1,53 @@ +From 05ce2d88bccb8c43141ff2f03795c505eff247b8 Mon Sep 17 00:00:00 2001 +From: Kevin Wolf +Date: Fri, 22 Nov 2013 14:23:30 +0100 +Subject: [PATCH 12/14] qcow2: change default for new images to compat=1.1, part2 + +RH-Author: Kevin Wolf +Message-id: <1385130210-31063-3-git-send-email-kwolf@redhat.com> +Patchwork-id: 55857 +O-Subject: [RHEL-7.0 qemu-kvm PATCH 2/2] qcow2: Change default for new images to compat=1.1 +Bugzilla: 1026739 +RH-Acked-by: Max Reitz +RH-Acked-by: Fam Zheng +RH-Acked-by: Paolo Bonzini + +By the time that qemu 1.7 will be released, enough time will have passed +since qemu 1.1, which is the first version to understand version 3 +images, that changing the default shouldn't hurt many people any more +and the benefits of using the new format outweigh the pain. + +qemu-iotests already runs with compat=1.1 by default. + +Signed-off-by: Kevin Wolf +Reviewed-by: Eric Blake +(cherry picked from commit 9117b47717ad208b12786ce88eacb013f9b3dd1c) + +Signed-off-by: Kevin Wolf +--- + block/qcow2.c | 4 +++- + 1 file changed, 3 insertions(+), 1 deletion(-) + +Signed-off-by: Miroslav Rezanina +--- + block/qcow2.c | 4 +++- + 1 files changed, 3 insertions(+), 1 deletions(-) + +diff --git a/block/qcow2.c b/block/qcow2.c +index 897e48a..850d1c2 100644 +--- a/block/qcow2.c ++++ b/block/qcow2.c +@@ -1627,7 +1627,9 @@ static int qcow2_create(const char *filename, QEMUOptionParameter *options, + return -EINVAL; + } + } else if (!strcmp(options->name, BLOCK_OPT_COMPAT_LEVEL)) { +- if (!options->value.s || !strcmp(options->value.s, "0.10")) { ++ if (!options->value.s) { ++ /* keep the default */ ++ } else if (!strcmp(options->value.s, "0.10")) { + version = 2; + } else if (!strcmp(options->value.s, "1.1")) { + version = 3; +-- +1.7.1 + diff --git a/SOURCES/kvm-qcow2-check-for-NULL-l2meta.patch b/SOURCES/kvm-qcow2-check-for-NULL-l2meta.patch new file mode 100644 index 0000000..549df70 --- /dev/null +++ b/SOURCES/kvm-qcow2-check-for-NULL-l2meta.patch @@ -0,0 +1,111 @@ +From 11e8c9b1857d272cfe6f38e83ae70478c15214eb Mon Sep 17 00:00:00 2001 +From: Max Reitz +Date: Sat, 15 Feb 2014 16:03:49 +0100 +Subject: [PATCH 4/5] qcow2: check for NULL l2meta + +RH-Author: Max Reitz +Message-id: <1392480230-24011-4-git-send-email-mreitz@redhat.com> +Patchwork-id: 57294 +O-Subject: [RHEL-7.0 qemu-kvm PATCH 3/4] qcow2: check for NULL l2meta +Bugzilla: 1055848 +RH-Acked-by: Kevin Wolf +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Fam Zheng + +From: Hu Tao + +BZ: 1049176 +BZ: 1055848 + +In the case of a metadata preallocation with a large cluster size, +qcow2_alloc_cluster_offset() can allocate nothing and returns a +NULL l2meta. This patch checks for it and link2 l2 with only valid +l2meta. + +Replace 9 and 512 with BDRV_SECTOR_BITS, BDRV_SECTOR_SIZE +respectively while at the function. + +Signed-off-by: Hu Tao +Reviewed-by: Max Reitz +Reviewed-by: Benoit Canet +Signed-off-by: Kevin Wolf +(cherry picked from commit 7c2bbf4aa66ca5a9fc2ca147e0e6cb6f407a3aa2) + +Signed-off-by: Max Reitz +--- + block/qcow2.c | 31 ++++++++++++++++--------------- + 1 file changed, 16 insertions(+), 15 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + block/qcow2.c | 31 ++++++++++++++++--------------- + 1 files changed, 16 insertions(+), 15 deletions(-) + +diff --git a/block/qcow2.c b/block/qcow2.c +index fe950b4..daad932 100644 +--- a/block/qcow2.c ++++ b/block/qcow2.c +@@ -1404,34 +1404,34 @@ static int preallocate(BlockDriverState *bs) + int ret; + QCowL2Meta *meta; + +- nb_sectors = bdrv_getlength(bs) >> 9; ++ nb_sectors = bdrv_getlength(bs) >> BDRV_SECTOR_BITS; + offset = 0; + + while (nb_sectors) { +- num = MIN(nb_sectors, INT_MAX >> 9); ++ num = MIN(nb_sectors, INT_MAX >> BDRV_SECTOR_BITS); + ret = qcow2_alloc_cluster_offset(bs, offset, &num, + &host_offset, &meta); + if (ret < 0) { + return ret; + } + +- ret = qcow2_alloc_cluster_link_l2(bs, meta); +- if (ret < 0) { +- qcow2_free_any_clusters(bs, meta->alloc_offset, meta->nb_clusters, +- QCOW2_DISCARD_NEVER); +- return ret; +- } +- +- /* There are no dependent requests, but we need to remove our request +- * from the list of in-flight requests */ + if (meta != NULL) { ++ ret = qcow2_alloc_cluster_link_l2(bs, meta); ++ if (ret < 0) { ++ qcow2_free_any_clusters(bs, meta->alloc_offset, ++ meta->nb_clusters, QCOW2_DISCARD_NEVER); ++ return ret; ++ } ++ ++ /* There are no dependent requests, but we need to remove our ++ * request from the list of in-flight requests */ + QLIST_REMOVE(meta, next_in_flight); + } + + /* TODO Preallocate data if requested */ + + nb_sectors -= num; +- offset += num << 9; ++ offset += num << BDRV_SECTOR_BITS; + } + + /* +@@ -1440,9 +1440,10 @@ static int preallocate(BlockDriverState *bs) + * EOF). Extend the image to the last allocated sector. + */ + if (host_offset != 0) { +- uint8_t buf[512]; +- memset(buf, 0, 512); +- ret = bdrv_write(bs->file, (host_offset >> 9) + num - 1, buf, 1); ++ uint8_t buf[BDRV_SECTOR_SIZE]; ++ memset(buf, 0, BDRV_SECTOR_SIZE); ++ ret = bdrv_write(bs->file, (host_offset >> BDRV_SECTOR_BITS) + num - 1, ++ buf, 1); + if (ret < 0) { + return ret; + } +-- +1.7.1 + diff --git a/SOURCES/kvm-qcow2-cluster-Expand-zero-clusters.patch b/SOURCES/kvm-qcow2-cluster-Expand-zero-clusters.patch new file mode 100644 index 0000000..8fba46b --- /dev/null +++ b/SOURCES/kvm-qcow2-cluster-Expand-zero-clusters.patch @@ -0,0 +1,391 @@ +From 1d6333da24b0175691d25b06c92a3eb7717a8a78 Mon Sep 17 00:00:00 2001 +From: Max Reitz +Date: Tue, 7 Jan 2014 21:57:11 +0100 +Subject: [PATCH 06/14] qcow2-cluster: Expand zero clusters + +RH-Author: Max Reitz +Message-id: <1389131839-12920-7-git-send-email-mreitz@redhat.com> +Patchwork-id: 56542 +O-Subject: [RHEL-7.0 qemu-kvm PATCH v2 06/14] qcow2-cluster: Expand zero clusters +Bugzilla: 1033490 +RH-Acked-by: Kevin Wolf +RH-Acked-by: Fam Zheng +RH-Acked-by: Stefan Hajnoczi + +BZ: 1033490 + +Add functionality for expanding zero clusters. This is necessary for +downgrading the image version to one without zero cluster support. + +For non-backed images, this function may also just discard zero clusters +instead of truly expanding them. + +Signed-off-by: Max Reitz +Signed-off-by: Kevin Wolf +(cherry picked from commit 32b6444d23d0ff618d73e5b766600cd258066169) + +Signed-off-by: Max Reitz + +Conflicts: + block/qcow2-cluster.c + +Conflicts since the changes omitted from downstream commit +ca635f6c3ae10562a2165590bb84667aa61ad12f (because this particular commit +had not been backported then) have to be included here. + +The same applies to the change in qcow2-cluster.c omitted from +downstream commit 0f795e4e9e128f9ff88a128ed8590d2357228b80. +--- + block/qcow2-cluster.c | 232 +++++++++++++++++++++++++++++++++++++++++++++++++ + block/qcow2-refcount.c | 29 ++++--- + block/qcow2.h | 5 ++ + 3 files changed, 252 insertions(+), 14 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + block/qcow2-cluster.c | 232 ++++++++++++++++++++++++++++++++++++++++++++++++ + block/qcow2-refcount.c | 29 +++--- + block/qcow2.h | 5 + + 3 files changed, 252 insertions(+), 14 deletions(-) + +diff --git a/block/qcow2-cluster.c b/block/qcow2-cluster.c +index 5d13515..796d7c5 100644 +--- a/block/qcow2-cluster.c ++++ b/block/qcow2-cluster.c +@@ -1499,3 +1499,235 @@ fail: + + return ret; + } ++ ++/* ++ * Expands all zero clusters in a specific L1 table (or deallocates them, for ++ * non-backed non-pre-allocated zero clusters). ++ * ++ * expanded_clusters is a bitmap where every bit corresponds to one cluster in ++ * the image file; a bit gets set if the corresponding cluster has been used for ++ * zero expansion (i.e., has been filled with zeroes and is referenced from an ++ * L2 table). nb_clusters contains the total cluster count of the image file, ++ * i.e., the number of bits in expanded_clusters. ++ */ ++static int expand_zero_clusters_in_l1(BlockDriverState *bs, uint64_t *l1_table, ++ int l1_size, uint8_t *expanded_clusters, ++ uint64_t nb_clusters) ++{ ++ BDRVQcowState *s = bs->opaque; ++ bool is_active_l1 = (l1_table == s->l1_table); ++ uint64_t *l2_table = NULL; ++ int ret; ++ int i, j; ++ ++ if (!is_active_l1) { ++ /* inactive L2 tables require a buffer to be stored in when loading ++ * them from disk */ ++ l2_table = qemu_blockalign(bs, s->cluster_size); ++ } ++ ++ for (i = 0; i < l1_size; i++) { ++ uint64_t l2_offset = l1_table[i] & L1E_OFFSET_MASK; ++ bool l2_dirty = false; ++ ++ if (!l2_offset) { ++ /* unallocated */ ++ continue; ++ } ++ ++ if (is_active_l1) { ++ /* get active L2 tables from cache */ ++ ret = qcow2_cache_get(bs, s->l2_table_cache, l2_offset, ++ (void **)&l2_table); ++ } else { ++ /* load inactive L2 tables from disk */ ++ ret = bdrv_read(bs->file, l2_offset / BDRV_SECTOR_SIZE, ++ (void *)l2_table, s->cluster_sectors); ++ } ++ if (ret < 0) { ++ goto fail; ++ } ++ ++ for (j = 0; j < s->l2_size; j++) { ++ uint64_t l2_entry = be64_to_cpu(l2_table[j]); ++ int64_t offset = l2_entry & L2E_OFFSET_MASK, cluster_index; ++ int cluster_type = qcow2_get_cluster_type(l2_entry); ++ ++ if (cluster_type == QCOW2_CLUSTER_NORMAL) { ++ cluster_index = offset >> s->cluster_bits; ++ assert((cluster_index >= 0) && (cluster_index < nb_clusters)); ++ if (expanded_clusters[cluster_index / 8] & ++ (1 << (cluster_index % 8))) { ++ /* Probably a shared L2 table; this cluster was a zero ++ * cluster which has been expanded, its refcount ++ * therefore most likely requires an update. */ ++ ret = qcow2_update_cluster_refcount(bs, cluster_index, 1, ++ QCOW2_DISCARD_NEVER); ++ if (ret < 0) { ++ goto fail; ++ } ++ /* Since we just increased the refcount, the COPIED flag may ++ * no longer be set. */ ++ l2_table[j] = cpu_to_be64(l2_entry & ~QCOW_OFLAG_COPIED); ++ l2_dirty = true; ++ } ++ continue; ++ } ++ else if (qcow2_get_cluster_type(l2_entry) != QCOW2_CLUSTER_ZERO) { ++ continue; ++ } ++ ++ if (!offset) { ++ /* not preallocated */ ++ if (!bs->backing_hd) { ++ /* not backed; therefore we can simply deallocate the ++ * cluster */ ++ l2_table[j] = 0; ++ l2_dirty = true; ++ continue; ++ } ++ ++ offset = qcow2_alloc_clusters(bs, s->cluster_size); ++ if (offset < 0) { ++ ret = offset; ++ goto fail; ++ } ++ } ++ ++ ret = qcow2_pre_write_overlap_check(bs, 0, offset, s->cluster_size); ++ if (ret < 0) { ++ qcow2_free_clusters(bs, offset, s->cluster_size, ++ QCOW2_DISCARD_ALWAYS); ++ goto fail; ++ } ++ ++ ret = bdrv_write_zeroes(bs->file, offset / BDRV_SECTOR_SIZE, ++ s->cluster_sectors, 0); ++ if (ret < 0) { ++ qcow2_free_clusters(bs, offset, s->cluster_size, ++ QCOW2_DISCARD_ALWAYS); ++ goto fail; ++ } ++ ++ l2_table[j] = cpu_to_be64(offset | QCOW_OFLAG_COPIED); ++ l2_dirty = true; ++ ++ cluster_index = offset >> s->cluster_bits; ++ assert((cluster_index >= 0) && (cluster_index < nb_clusters)); ++ expanded_clusters[cluster_index / 8] |= 1 << (cluster_index % 8); ++ } ++ ++ if (is_active_l1) { ++ if (l2_dirty) { ++ qcow2_cache_entry_mark_dirty(s->l2_table_cache, l2_table); ++ qcow2_cache_depends_on_flush(s->l2_table_cache); ++ } ++ ret = qcow2_cache_put(bs, s->l2_table_cache, (void **)&l2_table); ++ if (ret < 0) { ++ l2_table = NULL; ++ goto fail; ++ } ++ } else { ++ if (l2_dirty) { ++ ret = qcow2_pre_write_overlap_check(bs, ++ QCOW2_OL_INACTIVE_L2 | QCOW2_OL_ACTIVE_L2, l2_offset, ++ s->cluster_size); ++ if (ret < 0) { ++ goto fail; ++ } ++ ++ ret = bdrv_write(bs->file, l2_offset / BDRV_SECTOR_SIZE, ++ (void *)l2_table, s->cluster_sectors); ++ if (ret < 0) { ++ goto fail; ++ } ++ } ++ } ++ } ++ ++ ret = 0; ++ ++fail: ++ if (l2_table) { ++ if (!is_active_l1) { ++ qemu_vfree(l2_table); ++ } else { ++ if (ret < 0) { ++ qcow2_cache_put(bs, s->l2_table_cache, (void **)&l2_table); ++ } else { ++ ret = qcow2_cache_put(bs, s->l2_table_cache, ++ (void **)&l2_table); ++ } ++ } ++ } ++ return ret; ++} ++ ++/* ++ * For backed images, expands all zero clusters on the image. For non-backed ++ * images, deallocates all non-pre-allocated zero clusters (and claims the ++ * allocation for pre-allocated ones). This is important for downgrading to a ++ * qcow2 version which doesn't yet support metadata zero clusters. ++ */ ++int qcow2_expand_zero_clusters(BlockDriverState *bs) ++{ ++ BDRVQcowState *s = bs->opaque; ++ uint64_t *l1_table = NULL; ++ int cluster_to_sector_bits = s->cluster_bits - BDRV_SECTOR_BITS; ++ uint64_t nb_clusters; ++ uint8_t *expanded_clusters; ++ int ret; ++ int i, j; ++ ++ nb_clusters = (bs->total_sectors + (1 << cluster_to_sector_bits) - 1) ++ >> cluster_to_sector_bits; ++ expanded_clusters = g_malloc0((nb_clusters + 7) / 8); ++ ++ ret = expand_zero_clusters_in_l1(bs, s->l1_table, s->l1_size, ++ expanded_clusters, nb_clusters); ++ if (ret < 0) { ++ goto fail; ++ } ++ ++ /* Inactive L1 tables may point to active L2 tables - therefore it is ++ * necessary to flush the L2 table cache before trying to access the L2 ++ * tables pointed to by inactive L1 entries (else we might try to expand ++ * zero clusters that have already been expanded); furthermore, it is also ++ * necessary to empty the L2 table cache, since it may contain tables which ++ * are now going to be modified directly on disk, bypassing the cache. ++ * qcow2_cache_empty() does both for us. */ ++ ret = qcow2_cache_empty(bs, s->l2_table_cache); ++ if (ret < 0) { ++ goto fail; ++ } ++ ++ for (i = 0; i < s->nb_snapshots; i++) { ++ int l1_sectors = (s->snapshots[i].l1_size * sizeof(uint64_t) + ++ BDRV_SECTOR_SIZE - 1) / BDRV_SECTOR_SIZE; ++ ++ l1_table = g_realloc(l1_table, l1_sectors * BDRV_SECTOR_SIZE); ++ ++ ret = bdrv_read(bs->file, s->snapshots[i].l1_table_offset / ++ BDRV_SECTOR_SIZE, (void *)l1_table, l1_sectors); ++ if (ret < 0) { ++ goto fail; ++ } ++ ++ for (j = 0; j < s->snapshots[i].l1_size; j++) { ++ be64_to_cpus(&l1_table[j]); ++ } ++ ++ ret = expand_zero_clusters_in_l1(bs, l1_table, s->snapshots[i].l1_size, ++ expanded_clusters, nb_clusters); ++ if (ret < 0) { ++ goto fail; ++ } ++ } ++ ++ ret = 0; ++ ++fail: ++ g_free(expanded_clusters); ++ g_free(l1_table); ++ return ret; ++} +diff --git a/block/qcow2-refcount.c b/block/qcow2-refcount.c +index 2b72d5e..389a837 100644 +--- a/block/qcow2-refcount.c ++++ b/block/qcow2-refcount.c +@@ -601,10 +601,10 @@ fail: + * If the return value is non-negative, it is the new refcount of the cluster. + * If it is negative, it is -errno and indicates an error. + */ +-static int update_cluster_refcount(BlockDriverState *bs, +- int64_t cluster_index, +- int addend, +- enum qcow2_discard_type type) ++int qcow2_update_cluster_refcount(BlockDriverState *bs, ++ int64_t cluster_index, ++ int addend, ++ enum qcow2_discard_type type) + { + BDRVQcowState *s = bs->opaque; + int ret; +@@ -733,8 +733,8 @@ int64_t qcow2_alloc_bytes(BlockDriverState *bs, int size) + if (free_in_cluster == 0) + s->free_byte_offset = 0; + if ((offset & (s->cluster_size - 1)) != 0) +- update_cluster_refcount(bs, offset >> s->cluster_bits, 1, +- QCOW2_DISCARD_NEVER); ++ qcow2_update_cluster_refcount(bs, offset >> s->cluster_bits, 1, ++ QCOW2_DISCARD_NEVER); + } else { + offset = qcow2_alloc_clusters(bs, s->cluster_size); + if (offset < 0) { +@@ -744,8 +744,8 @@ int64_t qcow2_alloc_bytes(BlockDriverState *bs, int size) + if ((cluster_offset + s->cluster_size) == offset) { + /* we are lucky: contiguous data */ + offset = s->free_byte_offset; +- update_cluster_refcount(bs, offset >> s->cluster_bits, 1, +- QCOW2_DISCARD_NEVER); ++ qcow2_update_cluster_refcount(bs, offset >> s->cluster_bits, 1, ++ QCOW2_DISCARD_NEVER); + s->free_byte_offset += size; + } else { + s->free_byte_offset = offset; +@@ -754,8 +754,8 @@ int64_t qcow2_alloc_bytes(BlockDriverState *bs, int size) + } + + /* The cluster refcount was incremented, either by qcow2_alloc_clusters() +- * or explicitly by update_cluster_refcount(). Refcount blocks must be +- * flushed before the caller's L2 table updates. ++ * or explicitly by qcow2_update_cluster_refcount(). Refcount blocks must ++ * be flushed before the caller's L2 table updates. + */ + qcow2_cache_set_dependency(bs, s->l2_table_cache, s->refcount_block_cache); + return offset; +@@ -896,8 +896,9 @@ int qcow2_update_snapshot_refcount(BlockDriverState *bs, + break; + } + if (addend != 0) { +- refcount = update_cluster_refcount(bs, cluster_index, addend, +- QCOW2_DISCARD_SNAPSHOT); ++ refcount = qcow2_update_cluster_refcount(bs, ++ cluster_index, addend, ++ QCOW2_DISCARD_SNAPSHOT); + } else { + refcount = get_refcount(bs, cluster_index); + } +@@ -936,8 +937,8 @@ int qcow2_update_snapshot_refcount(BlockDriverState *bs, + + + if (addend != 0) { +- refcount = update_cluster_refcount(bs, l2_offset >> s->cluster_bits, addend, +- QCOW2_DISCARD_SNAPSHOT); ++ refcount = qcow2_update_cluster_refcount(bs, l2_offset >> ++ s->cluster_bits, addend, QCOW2_DISCARD_SNAPSHOT); + } else { + refcount = get_refcount(bs, l2_offset >> s->cluster_bits); + } +diff --git a/block/qcow2.h b/block/qcow2.h +index 5ca6b78..2660483 100644 +--- a/block/qcow2.h ++++ b/block/qcow2.h +@@ -422,6 +422,9 @@ int qcow2_update_header(BlockDriverState *bs); + int qcow2_refcount_init(BlockDriverState *bs); + void qcow2_refcount_close(BlockDriverState *bs); + ++int qcow2_update_cluster_refcount(BlockDriverState *bs, int64_t cluster_index, ++ int addend, enum qcow2_discard_type type); ++ + int64_t qcow2_alloc_clusters(BlockDriverState *bs, int64_t size); + int qcow2_alloc_clusters_at(BlockDriverState *bs, uint64_t offset, + int nb_clusters); +@@ -469,6 +472,8 @@ int qcow2_discard_clusters(BlockDriverState *bs, uint64_t offset, + int nb_sectors); + int qcow2_zero_clusters(BlockDriverState *bs, uint64_t offset, int nb_sectors); + ++int qcow2_expand_zero_clusters(BlockDriverState *bs); ++ + /* qcow2-snapshot.c functions */ + int qcow2_snapshot_create(BlockDriverState *bs, QEMUSnapshotInfo *sn_info); + int qcow2_snapshot_goto(BlockDriverState *bs, const char *snapshot_id); +-- +1.7.1 + diff --git a/SOURCES/kvm-qcow2-fix-dangling-refcount-table-entry.patch b/SOURCES/kvm-qcow2-fix-dangling-refcount-table-entry.patch new file mode 100644 index 0000000..22434bd --- /dev/null +++ b/SOURCES/kvm-qcow2-fix-dangling-refcount-table-entry.patch @@ -0,0 +1,64 @@ +From d13533fb4dada401eb437454ce348caa1ab94fe6 Mon Sep 17 00:00:00 2001 +From: Stefan Hajnoczi +Date: Fri, 28 Mar 2014 18:46:57 +0100 +Subject: [PATCH 1/2] qcow2: fix dangling refcount table entry + +RH-Author: Stefan Hajnoczi +Message-id: <1396032417-10176-1-git-send-email-stefanha@redhat.com> +Patchwork-id: 58281 +O-Subject: [RHEL7 qemu-kvm PATCH] qcow2: fix dangling refcount table entry +Bugzilla: 1081793 +RH-Acked-by: Fam Zheng +RH-Acked-by: Kevin Wolf +RH-Acked-by: Juan Quintela + +BZ: 1081793 +Upstream: Downstream only but same fix in https://lists.gnu.org/archive/html/qemu-devel/2014-03/msg05605.html +BREW: http://brewweb.devel.redhat.com/brew/taskinfo?taskID=7272001 + +In qcow2_create2() we first manually populate a minimal image file with +the qcow2 header, refcount table, and one refcount block. Then can open +the minimal image as a valid file and fill in the remaining information. + +In commit a2b10eec76a72aa7fe63e797181b93f69de9600e ("qcow2: Don't rely +on free_cluster_index in alloc_refcount_block() (CVE-2014-0147)") a +dangling refcount table entry was introduced. This works for image +files but fails for host block devices that already contain data because +we follow the dangling refcount table entry and read bogus data. + +This patch zeroes the refcount block so the refcount table entry is +pointing to initialized data. + +This patch is downstream-only because the broken commit was not merged +yet upstream. Therefore upstream has a v2 patch but we need a separate +bugfix for downstream. + +Signed-off-by: Stefan Hajnoczi +--- + block/qcow2.c | 4 ++-- + 1 file changed, 2 insertions(+), 2 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + block/qcow2.c | 4 ++-- + 1 files changed, 2 insertions(+), 2 deletions(-) + +diff --git a/block/qcow2.c b/block/qcow2.c +index 3f8febc..66ed906 100644 +--- a/block/qcow2.c ++++ b/block/qcow2.c +@@ -1628,9 +1628,9 @@ static int qcow2_create2(const char *filename, int64_t total_size, + } + + /* Write a refcount table with one refcount block */ +- refcount_table = g_malloc0(cluster_size); ++ refcount_table = g_malloc0(2 * cluster_size); + refcount_table[0] = cpu_to_be64(2 * cluster_size); +- ret = bdrv_pwrite(bs, cluster_size, refcount_table, cluster_size); ++ ret = bdrv_pwrite(bs, cluster_size, refcount_table, 2 * cluster_size); + g_free(refcount_table); + + if (ret < 0) { +-- +1.7.1 + diff --git a/SOURCES/kvm-qcow2-fix-offset-overflow-in-qcow2_alloc_clusters_at.patch b/SOURCES/kvm-qcow2-fix-offset-overflow-in-qcow2_alloc_clusters_at.patch new file mode 100644 index 0000000..dcbfaea --- /dev/null +++ b/SOURCES/kvm-qcow2-fix-offset-overflow-in-qcow2_alloc_clusters_at.patch @@ -0,0 +1,71 @@ +From ac19619fcd0eb051d57e5519a9fe8983b9e02fc0 Mon Sep 17 00:00:00 2001 +From: Max Reitz +Date: Sat, 15 Feb 2014 16:03:48 +0100 +Subject: [PATCH 3/5] qcow2: fix offset overflow in qcow2_alloc_clusters_at() + +RH-Author: Max Reitz +Message-id: <1392480230-24011-3-git-send-email-mreitz@redhat.com> +Patchwork-id: 57293 +O-Subject: [RHEL-7.0 qemu-kvm PATCH 2/4] qcow2: fix offset overflow in qcow2_alloc_clusters_at() +Bugzilla: 1049176 +RH-Acked-by: Kevin Wolf +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Fam Zheng + +From: Hu Tao + +BZ: 1049176 +BZ: 1055848 + +When cluster size is big enough it can lead to an offset overflow +in qcow2_alloc_clusters_at(). This patch fixes it. + +The allocation is stopped each time at L2 table boundary +(see handle_alloc()), so the possible maximum bytes could be + + 2^(cluster_bits - 3 + cluster_bits) + +cluster_bits - 3 is used to compute the number of entry by L2 +and the additional cluster_bits is to take into account each +clusters referenced by the L2 entries. + +so int is safe for cluster_bits<=17, unsafe otherwise. + +Signed-off-by: Hu Tao +Reviewed-by: Max Reitz +Reviewed-by: Benoit Canet +Signed-off-by: Kevin Wolf +(cherry picked from commit 33304ec9fa484e765c6249673e09e1b7d49c5b85) + +Signed-off-by: Max Reitz +--- + block/qcow2-refcount.c | 8 +++++++- + 1 file changed, 7 insertions(+), 1 deletion(-) + +Signed-off-by: Miroslav Rezanina +--- + block/qcow2-refcount.c | 8 +++++++- + 1 files changed, 7 insertions(+), 1 deletions(-) + +diff --git a/block/qcow2-refcount.c b/block/qcow2-refcount.c +index 389a837..09c638f 100644 +--- a/block/qcow2-refcount.c ++++ b/block/qcow2-refcount.c +@@ -676,7 +676,13 @@ int qcow2_alloc_clusters_at(BlockDriverState *bs, uint64_t offset, + BDRVQcowState *s = bs->opaque; + uint64_t cluster_index; + uint64_t old_free_cluster_index; +- int i, refcount, ret; ++ uint64_t i; ++ int refcount, ret; ++ ++ assert(nb_clusters >= 0); ++ if (nb_clusters == 0) { ++ return 0; ++ } + + /* Check how many clusters there are free */ + cluster_index = offset >> s->cluster_bits; +-- +1.7.1 + diff --git a/SOURCES/kvm-qcow2-link-all-L2-meta-updates-in-preallocate.patch b/SOURCES/kvm-qcow2-link-all-L2-meta-updates-in-preallocate.patch new file mode 100644 index 0000000..3dd0c1f --- /dev/null +++ b/SOURCES/kvm-qcow2-link-all-L2-meta-updates-in-preallocate.patch @@ -0,0 +1,69 @@ +From 8be02a0613ef6aee7a95ab7dae3d0aa489b65249 Mon Sep 17 00:00:00 2001 +From: Stefan Hajnoczi +Date: Tue, 1 Apr 2014 09:45:35 +0200 +Subject: [PATCH 2/2] qcow2: link all L2 meta updates in preallocate() + +RH-Author: Stefan Hajnoczi +Message-id: <1396345535-19829-1-git-send-email-stefanha@redhat.com> +Patchwork-id: 58320 +O-Subject: [RHEL7 qemu-kvm PATCH] qcow2: link all L2 meta updates in preallocate() +Bugzilla: 1081393 +RH-Acked-by: Kevin Wolf +RH-Acked-by: Laszlo Ersek +RH-Acked-by: Jeffrey Cody + +BZ: 1081393 +Upstream: not merged yet, http://article.gmane.org/gmane.comp.emulators.qemu/264904 +BREW: http://brewweb.devel.redhat.com/brew/taskinfo?taskID=7282765 + +preallocate() only links the first QCowL2Meta's data clusters into the +L2 table and ignores any chained QCowL2Metas in the linked list. + +Chains of QCowL2Meta structs are built up when contiguous clusters span +L2 tables. Each QCowL2Meta describes one L2 table update. This is a +rare case in preallocate() but can happen. + +This patch fixes preallocate() by iterating over the whole list of +QCowL2Metas. Compare with the qcow2_co_writev() function's +implementation, which is similar but also also handles request +dependencies. preallocate() only performs one allocation at a time so +there can be no dependencies. + +Signed-off-by: Stefan Hajnoczi +--- + block/qcow2.c | 7 ++++++- + 1 file changed, 6 insertions(+), 1 deletion(-) + +Signed-off-by: Miroslav Rezanina +--- + block/qcow2.c | 7 ++++++- + 1 files changed, 6 insertions(+), 1 deletions(-) + +diff --git a/block/qcow2.c b/block/qcow2.c +index 66ed906..7398b16 100644 +--- a/block/qcow2.c ++++ b/block/qcow2.c +@@ -1509,7 +1509,9 @@ static int preallocate(BlockDriverState *bs) + return ret; + } + +- if (meta != NULL) { ++ while (meta) { ++ QCowL2Meta *next = meta->next; ++ + ret = qcow2_alloc_cluster_link_l2(bs, meta); + if (ret < 0) { + qcow2_free_any_clusters(bs, meta->alloc_offset, +@@ -1520,6 +1522,9 @@ static int preallocate(BlockDriverState *bs) + /* There are no dependent requests, but we need to remove our + * request from the list of in-flight requests */ + QLIST_REMOVE(meta, next_in_flight); ++ ++ g_free(meta); ++ meta = next; + } + + /* TODO Preallocate data if requested */ +-- +1.7.1 + diff --git a/SOURCES/kvm-qcow2-refcount-Snapshot-update-for-zero-clusters.patch b/SOURCES/kvm-qcow2-refcount-Snapshot-update-for-zero-clusters.patch new file mode 100644 index 0000000..29a4cf8 --- /dev/null +++ b/SOURCES/kvm-qcow2-refcount-Snapshot-update-for-zero-clusters.patch @@ -0,0 +1,120 @@ +From 4d45b1791fb8bc24c17045a91b39c1d62e9e47c3 Mon Sep 17 00:00:00 2001 +From: Max Reitz +Date: Tue, 7 Jan 2014 21:57:07 +0100 +Subject: [PATCH 02/14] qcow2-refcount: Snapshot update for zero clusters + +RH-Author: Max Reitz +Message-id: <1389131839-12920-3-git-send-email-mreitz@redhat.com> +Patchwork-id: 56538 +O-Subject: [RHEL-7.0 qemu-kvm PATCH v2 02/14] qcow2-refcount: Snapshot update for zero clusters +Bugzilla: 1033490 +RH-Acked-by: Kevin Wolf +RH-Acked-by: Fam Zheng +RH-Acked-by: Stefan Hajnoczi + +BZ: 1033490 + +Account for all cluster types in qcow2_update_snapshot_refcounts; +this prevents this function from updating the refcount of unallocated +zero clusters which effectively led to wrong adjustments of the refcount +of cluster 0 (the main qcow2 header). This in turn resulted in images +with (unallocated) zero clusters having a cluster 0 refcount greater +than one after creating a snapshot. + +Signed-off-by: Max Reitz +Signed-off-by: Kevin Wolf +(cherry picked from commit 8b81a7b6ba8686f35f9cb0acdd54004d63206f03) + +Signed-off-by: Max Reitz +--- + block/qcow2-refcount.c | 52 +++++++++++++++++++++++++++++++++----------------- + 1 file changed, 35 insertions(+), 17 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + block/qcow2-refcount.c | 52 ++++++++++++++++++++++++++++++++--------------- + 1 files changed, 35 insertions(+), 17 deletions(-) + +diff --git a/block/qcow2-refcount.c b/block/qcow2-refcount.c +index 3787314..2b72d5e 100644 +--- a/block/qcow2-refcount.c ++++ b/block/qcow2-refcount.c +@@ -863,11 +863,14 @@ int qcow2_update_snapshot_refcount(BlockDriverState *bs, + } + + for(j = 0; j < s->l2_size; j++) { ++ uint64_t cluster_index; ++ + offset = be64_to_cpu(l2_table[j]); +- if (offset != 0) { +- old_offset = offset; +- offset &= ~QCOW_OFLAG_COPIED; +- if (offset & QCOW_OFLAG_COMPRESSED) { ++ old_offset = offset; ++ offset &= ~QCOW_OFLAG_COPIED; ++ ++ switch (qcow2_get_cluster_type(offset)) { ++ case QCOW2_CLUSTER_COMPRESSED: + nb_csectors = ((offset >> s->csize_shift) & + s->csize_mask) + 1; + if (addend != 0) { +@@ -882,8 +885,16 @@ int qcow2_update_snapshot_refcount(BlockDriverState *bs, + } + /* compressed clusters are never modified */ + refcount = 2; +- } else { +- uint64_t cluster_index = (offset & L2E_OFFSET_MASK) >> s->cluster_bits; ++ break; ++ ++ case QCOW2_CLUSTER_NORMAL: ++ case QCOW2_CLUSTER_ZERO: ++ cluster_index = (offset & L2E_OFFSET_MASK) >> s->cluster_bits; ++ if (!cluster_index) { ++ /* unallocated */ ++ refcount = 0; ++ break; ++ } + if (addend != 0) { + refcount = update_cluster_refcount(bs, cluster_index, addend, + QCOW2_DISCARD_SNAPSHOT); +@@ -895,19 +906,26 @@ int qcow2_update_snapshot_refcount(BlockDriverState *bs, + ret = refcount; + goto fail; + } +- } ++ break; + +- if (refcount == 1) { +- offset |= QCOW_OFLAG_COPIED; +- } +- if (offset != old_offset) { +- if (addend > 0) { +- qcow2_cache_set_dependency(bs, s->l2_table_cache, +- s->refcount_block_cache); +- } +- l2_table[j] = cpu_to_be64(offset); +- qcow2_cache_entry_mark_dirty(s->l2_table_cache, l2_table); ++ case QCOW2_CLUSTER_UNALLOCATED: ++ refcount = 0; ++ break; ++ ++ default: ++ abort(); ++ } ++ ++ if (refcount == 1) { ++ offset |= QCOW_OFLAG_COPIED; ++ } ++ if (offset != old_offset) { ++ if (addend > 0) { ++ qcow2_cache_set_dependency(bs, s->l2_table_cache, ++ s->refcount_block_cache); + } ++ l2_table[j] = cpu_to_be64(offset); ++ qcow2_cache_entry_mark_dirty(s->l2_table_cache, l2_table); + } + } + +-- +1.7.1 + diff --git a/SOURCES/kvm-qcow2-remove-n_start-and-n_end-of-qcow2_alloc_cluste.patch b/SOURCES/kvm-qcow2-remove-n_start-and-n_end-of-qcow2_alloc_cluste.patch new file mode 100644 index 0000000..c2b74ba --- /dev/null +++ b/SOURCES/kvm-qcow2-remove-n_start-and-n_end-of-qcow2_alloc_cluste.patch @@ -0,0 +1,166 @@ +From 68066d2b824a88a45b3263dd1ceb18307c92581f Mon Sep 17 00:00:00 2001 +From: Max Reitz +Date: Sat, 15 Feb 2014 16:03:47 +0100 +Subject: [PATCH 2/5] qcow2: remove n_start and n_end of qcow2_alloc_cluster_offset() + +RH-Author: Max Reitz +Message-id: <1392480230-24011-2-git-send-email-mreitz@redhat.com> +Patchwork-id: 57292 +O-Subject: [RHEL-7.0 qemu-kvm PATCH 1/4] qcow2: remove n_start and n_end of qcow2_alloc_cluster_offset() +Bugzilla: 1049176 +RH-Acked-by: Kevin Wolf +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Fam Zheng + +From: Hu Tao + +BZ: 1049176 +BZ: 1055848 + +n_start can be actually calculated from offset. The number of +sectors to be allocated(n_end - n_start) can be passed in in +num. By removing n_start and n_end, we can save two parameters. + +The side effect is there is a bug in qcow2.c:preallocate() that +passes incorrect n_start to qcow2_alloc_cluster_offset() is +fixed. The bug can be triggerred by a larger cluster size than +the default value(65536), for example: + +./qemu-img create -f qcow2 \ + -o 'cluster_size=131072,preallocation=metadata' file.img 4G + +Signed-off-by: Hu Tao +Reviewed-by: Max Reitz +Reviewed-by: Benoit Canet +Signed-off-by: Kevin Wolf +(cherry picked from commit 16f0587e0a5da5b1ad76cb7c3739491bc042201c) + +Signed-off-by: Max Reitz +--- + block/qcow2-cluster.c | 14 ++++++-------- + block/qcow2.c | 13 +++++++------ + block/qcow2.h | 2 +- + trace-events | 2 +- + 4 files changed, 15 insertions(+), 16 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + block/qcow2-cluster.c | 14 ++++++-------- + block/qcow2.c | 13 +++++++------ + block/qcow2.h | 2 +- + trace-events | 2 +- + 4 files changed, 15 insertions(+), 16 deletions(-) + +diff --git a/block/qcow2-cluster.c b/block/qcow2-cluster.c +index 79c3ae0..862df0f 100644 +--- a/block/qcow2-cluster.c ++++ b/block/qcow2-cluster.c +@@ -1173,7 +1173,7 @@ fail: + * Return 0 on success and -errno in error cases + */ + int qcow2_alloc_cluster_offset(BlockDriverState *bs, uint64_t offset, +- int n_start, int n_end, int *num, uint64_t *host_offset, QCowL2Meta **m) ++ int *num, uint64_t *host_offset, QCowL2Meta **m) + { + BDRVQcowState *s = bs->opaque; + uint64_t start, remaining; +@@ -1181,15 +1181,13 @@ int qcow2_alloc_cluster_offset(BlockDriverState *bs, uint64_t offset, + uint64_t cur_bytes; + int ret; + +- trace_qcow2_alloc_clusters_offset(qemu_coroutine_self(), offset, +- n_start, n_end); ++ trace_qcow2_alloc_clusters_offset(qemu_coroutine_self(), offset, *num); + +- assert(n_start * BDRV_SECTOR_SIZE == offset_into_cluster(s, offset)); +- offset = start_of_cluster(s, offset); ++ assert((offset & ~BDRV_SECTOR_MASK) == 0); + + again: +- start = offset + (n_start << BDRV_SECTOR_BITS); +- remaining = (n_end - n_start) << BDRV_SECTOR_BITS; ++ start = offset; ++ remaining = *num << BDRV_SECTOR_BITS; + cluster_offset = 0; + *host_offset = 0; + cur_bytes = 0; +@@ -1275,7 +1273,7 @@ again: + } + } + +- *num = (n_end - n_start) - (remaining >> BDRV_SECTOR_BITS); ++ *num -= remaining >> BDRV_SECTOR_BITS; + assert(*num > 0); + assert(*host_offset != 0); + +diff --git a/block/qcow2.c b/block/qcow2.c +index 25a5b5e..fe950b4 100644 +--- a/block/qcow2.c ++++ b/block/qcow2.c +@@ -1000,7 +1000,6 @@ static coroutine_fn int qcow2_co_writev(BlockDriverState *bs, + { + BDRVQcowState *s = bs->opaque; + int index_in_cluster; +- int n_end; + int ret; + int cur_nr_sectors; /* number of sectors in current iteration */ + uint64_t cluster_offset; +@@ -1024,14 +1023,16 @@ static coroutine_fn int qcow2_co_writev(BlockDriverState *bs, + + trace_qcow2_writev_start_part(qemu_coroutine_self()); + index_in_cluster = sector_num & (s->cluster_sectors - 1); +- n_end = index_in_cluster + remaining_sectors; ++ cur_nr_sectors = remaining_sectors; + if (s->crypt_method && +- n_end > QCOW_MAX_CRYPT_CLUSTERS * s->cluster_sectors) { +- n_end = QCOW_MAX_CRYPT_CLUSTERS * s->cluster_sectors; ++ cur_nr_sectors > ++ QCOW_MAX_CRYPT_CLUSTERS * s->cluster_sectors - index_in_cluster) { ++ cur_nr_sectors = ++ QCOW_MAX_CRYPT_CLUSTERS * s->cluster_sectors - index_in_cluster; + } + + ret = qcow2_alloc_cluster_offset(bs, sector_num << 9, +- index_in_cluster, n_end, &cur_nr_sectors, &cluster_offset, &l2meta); ++ &cur_nr_sectors, &cluster_offset, &l2meta); + if (ret < 0) { + goto fail; + } +@@ -1408,7 +1409,7 @@ static int preallocate(BlockDriverState *bs) + + while (nb_sectors) { + num = MIN(nb_sectors, INT_MAX >> 9); +- ret = qcow2_alloc_cluster_offset(bs, offset, 0, num, &num, ++ ret = qcow2_alloc_cluster_offset(bs, offset, &num, + &host_offset, &meta); + if (ret < 0) { + return ret; +diff --git a/block/qcow2.h b/block/qcow2.h +index 9749f03..4a653c5 100644 +--- a/block/qcow2.h ++++ b/block/qcow2.h +@@ -463,7 +463,7 @@ void qcow2_encrypt_sectors(BDRVQcowState *s, int64_t sector_num, + int qcow2_get_cluster_offset(BlockDriverState *bs, uint64_t offset, + int *num, uint64_t *cluster_offset); + int qcow2_alloc_cluster_offset(BlockDriverState *bs, uint64_t offset, +- int n_start, int n_end, int *num, uint64_t *host_offset, QCowL2Meta **m); ++ int *num, uint64_t *host_offset, QCowL2Meta **m); + uint64_t qcow2_alloc_compressed_cluster_offset(BlockDriverState *bs, + uint64_t offset, + int compressed_size); +diff --git a/trace-events b/trace-events +index 5d86cf3..b9144b2 100644 +--- a/trace-events ++++ b/trace-events +@@ -485,7 +485,7 @@ qcow2_writev_done_part(void *co, int cur_nr_sectors) "co %p cur_nr_sectors %d" + qcow2_writev_data(void *co, uint64_t offset) "co %p offset %" PRIx64 + + # block/qcow2-cluster.c +-qcow2_alloc_clusters_offset(void *co, uint64_t offset, int n_start, int n_end) "co %p offet %" PRIx64 " n_start %d n_end %d" ++qcow2_alloc_clusters_offset(void *co, uint64_t offset, int num) "co %p offet %" PRIx64 " num %d" + qcow2_handle_copied(void *co, uint64_t guest_offset, uint64_t host_offset, uint64_t bytes) "co %p guest_offet %" PRIx64 " host_offset %" PRIx64 " bytes %" PRIx64 + qcow2_handle_alloc(void *co, uint64_t guest_offset, uint64_t host_offset, uint64_t bytes) "co %p guest_offet %" PRIx64 " host_offset %" PRIx64 " bytes %" PRIx64 + qcow2_do_alloc_clusters_offset(void *co, uint64_t guest_offset, uint64_t host_offset, int nb_clusters) "co %p guest_offet %" PRIx64 " host_offset %" PRIx64 " nb_clusters %d" +-- +1.7.1 + diff --git a/SOURCES/kvm-qcow2.py-Subcommand-for-changing-header-fields.patch b/SOURCES/kvm-qcow2.py-Subcommand-for-changing-header-fields.patch new file mode 100644 index 0000000..67f7fad --- /dev/null +++ b/SOURCES/kvm-qcow2.py-Subcommand-for-changing-header-fields.patch @@ -0,0 +1,69 @@ +From c8da29122142f498215881e8bb933de278a3809a Mon Sep 17 00:00:00 2001 +From: Max Reitz +Date: Sun, 29 Dec 2013 22:06:54 +0100 +Subject: [PATCH 3/8] qcow2.py: Subcommand for changing header fields + +RH-Author: Max Reitz +Message-id: <1388354817-3013-3-git-send-email-mreitz@redhat.com> +Patchwork-id: 56444 +O-Subject: [RHEL-7.0 qemu-kvm PATCH 2/5] qcow2.py: Subcommand for changing header fields +Bugzilla: 1004347 +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Fam Zheng +RH-Acked-by: Kevin Wolf + +From: Kevin Wolf + +BZ: 1004347 + +Signed-off-by: Kevin Wolf +(cherry picked from commit c93331c9146719958a4b102435fcd0566da45ea2) + +Signed-off-by: Max Reitz +--- + tests/qemu-iotests/qcow2.py | 17 +++++++++++++++++ + 1 file changed, 17 insertions(+) + +Signed-off-by: Miroslav Rezanina +--- + tests/qemu-iotests/qcow2.py | 17 +++++++++++++++++ + 1 files changed, 17 insertions(+), 0 deletions(-) + +diff --git a/tests/qemu-iotests/qcow2.py b/tests/qemu-iotests/qcow2.py +index fecf5b9..44a2b45 100755 +--- a/tests/qemu-iotests/qcow2.py ++++ b/tests/qemu-iotests/qcow2.py +@@ -149,6 +149,22 @@ def cmd_dump_header(fd): + h.dump() + h.dump_extensions() + ++def cmd_set_header(fd, name, value): ++ try: ++ value = int(value, 0) ++ except: ++ print "'%s' is not a valid number" % value ++ sys.exit(1) ++ ++ fields = (field[2] for field in QcowHeader.fields) ++ if not name in fields: ++ print "'%s' is not a known header field" % name ++ sys.exit(1) ++ ++ h = QcowHeader(fd) ++ h.__dict__[name] = value ++ h.update(fd) ++ + def cmd_add_header_ext(fd, magic, data): + try: + magic = int(magic, 0) +@@ -205,6 +221,7 @@ def cmd_set_feature_bit(fd, group, bit): + + cmds = [ + [ 'dump-header', cmd_dump_header, 0, 'Dump image header and header extensions' ], ++ [ 'set-header', cmd_set_header, 2, 'Set a field in the header'], + [ 'add-header-ext', cmd_add_header_ext, 2, 'Add a header extension' ], + [ 'del-header-ext', cmd_del_header_ext, 1, 'Delete a header extension' ], + [ 'set-feature-bit', cmd_set_feature_bit, 2, 'Set a feature bit'], +-- +1.7.1 + diff --git a/SOURCES/kvm-qdev-Add-SIZE-type-to-qdev-properties.patch b/SOURCES/kvm-qdev-Add-SIZE-type-to-qdev-properties.patch new file mode 100644 index 0000000..34e1807 --- /dev/null +++ b/SOURCES/kvm-qdev-Add-SIZE-type-to-qdev-properties.patch @@ -0,0 +1,163 @@ +From 6f520cfdd487bc2c8032b61ff48706a65345bad5 Mon Sep 17 00:00:00 2001 +Message-Id: <6f520cfdd487bc2c8032b61ff48706a65345bad5.1387298827.git.minovotn@redhat.com> +In-Reply-To: <3ed0fb61a3dc912ef036d7ef450bed192090709e.1387298827.git.minovotn@redhat.com> +References: <3ed0fb61a3dc912ef036d7ef450bed192090709e.1387298827.git.minovotn@redhat.com> +From: "Michael S. Tsirkin" +Date: Tue, 17 Dec 2013 15:16:58 +0100 +Subject: [PATCH 04/56] qdev: Add SIZE type to qdev properties +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +RH-Author: Michael S. Tsirkin +Message-id: <1387293161-4085-5-git-send-email-mst@redhat.com> +Patchwork-id: 56309 +O-Subject: [PATCH qemu-kvm RHEL7.0 v2 04/57] qdev: Add SIZE type to qdev properties +Bugzilla: 1034876 +RH-Acked-by: Igor Mammedov +RH-Acked-by: Marcel Apfelbaum +RH-Acked-by: Laszlo Ersek + +From: Vasilis Liaskovitis + +This patch adds a 'SIZE' type property to qdev. + +Signed-off-by: Ian Molton +Signed-off-by: Vasilis Liaskovitis +Signed-off-by: Hu Tao +Signed-off-by: Igor Mammedov +Reviewed-by: Michael S. Tsirkin +Reviewed-by: Andreas Färber +Message-id: 1375109277-25561-7-git-send-email-imammedo@redhat.com +Signed-off-by: Anthony Liguori +(cherry picked from commit e8cd45c78f53501e75bd455140da63d1b7ed3685) +--- + include/hw/qdev-properties.h | 3 +++ + include/qemu/option.h | 2 ++ + hw/core/qdev-properties.c | 55 ++++++++++++++++++++++++++++++++++++++++++++ + util/qemu-option.c | 4 ++-- + 4 files changed, 62 insertions(+), 2 deletions(-) + +Signed-off-by: Michal Novotny +--- + hw/core/qdev-properties.c | 55 ++++++++++++++++++++++++++++++++++++++++++++ + include/hw/qdev-properties.h | 3 +++ + include/qemu/option.h | 2 ++ + util/qemu-option.c | 4 ++-- + 4 files changed, 62 insertions(+), 2 deletions(-) + +diff --git a/hw/core/qdev-properties.c b/hw/core/qdev-properties.c +index 6e1ed1e..8d43a8d 100644 +--- a/hw/core/qdev-properties.c ++++ b/hw/core/qdev-properties.c +@@ -1135,3 +1135,58 @@ void qdev_prop_set_globals(DeviceState *dev, Error **errp) + class = object_class_get_parent(class); + } while (class); + } ++ ++/* --- 64bit unsigned int 'size' type --- */ ++ ++static void get_size(Object *obj, Visitor *v, void *opaque, ++ const char *name, Error **errp) ++{ ++ DeviceState *dev = DEVICE(obj); ++ Property *prop = opaque; ++ uint64_t *ptr = qdev_get_prop_ptr(dev, prop); ++ ++ visit_type_size(v, ptr, name, errp); ++} ++ ++static void set_size(Object *obj, Visitor *v, void *opaque, ++ const char *name, Error **errp) ++{ ++ DeviceState *dev = DEVICE(obj); ++ Property *prop = opaque; ++ uint64_t *ptr = qdev_get_prop_ptr(dev, prop); ++ ++ visit_type_size(v, ptr, name, errp); ++} ++ ++static int parse_size(DeviceState *dev, Property *prop, const char *str) ++{ ++ uint64_t *ptr = qdev_get_prop_ptr(dev, prop); ++ Error *errp = NULL; ++ ++ if (str != NULL) { ++ parse_option_size(prop->name, str, ptr, &errp); ++ } ++ assert_no_error(errp); ++ return 0; ++} ++ ++static int print_size(DeviceState *dev, Property *prop, char *dest, size_t len) ++{ ++ uint64_t *ptr = qdev_get_prop_ptr(dev, prop); ++ char suffixes[] = {'T', 'G', 'M', 'K', 'B'}; ++ int i = 0; ++ uint64_t div; ++ ++ for (div = (long int)1 << 40; !(*ptr / div) ; div >>= 10) { ++ i++; ++ } ++ return snprintf(dest, len, "%0.03f%c", (double)*ptr/div, suffixes[i]); ++} ++ ++PropertyInfo qdev_prop_size = { ++ .name = "size", ++ .parse = parse_size, ++ .print = print_size, ++ .get = get_size, ++ .set = set_size, ++}; +diff --git a/include/hw/qdev-properties.h b/include/hw/qdev-properties.h +index 39448b7..692f82e 100644 +--- a/include/hw/qdev-properties.h ++++ b/include/hw/qdev-properties.h +@@ -15,6 +15,7 @@ extern PropertyInfo qdev_prop_uint64; + extern PropertyInfo qdev_prop_hex8; + extern PropertyInfo qdev_prop_hex32; + extern PropertyInfo qdev_prop_hex64; ++extern PropertyInfo qdev_prop_size; + extern PropertyInfo qdev_prop_string; + extern PropertyInfo qdev_prop_chr; + extern PropertyInfo qdev_prop_ptr; +@@ -116,6 +117,8 @@ extern PropertyInfo qdev_prop_arraylen; + DEFINE_PROP_DEFAULT(_n, _s, _f, _d, qdev_prop_hex32, uint32_t) + #define DEFINE_PROP_HEX64(_n, _s, _f, _d) \ + DEFINE_PROP_DEFAULT(_n, _s, _f, _d, qdev_prop_hex64, uint64_t) ++#define DEFINE_PROP_SIZE(_n, _s, _f, _d) \ ++ DEFINE_PROP_DEFAULT(_n, _s, _f, _d, qdev_prop_size, uint64_t) + #define DEFINE_PROP_PCI_DEVFN(_n, _s, _f, _d) \ + DEFINE_PROP_DEFAULT(_n, _s, _f, _d, qdev_prop_pci_devfn, int32_t) + +diff --git a/include/qemu/option.h b/include/qemu/option.h +index f5ebb05..96f70b6 100644 +--- a/include/qemu/option.h ++++ b/include/qemu/option.h +@@ -73,6 +73,8 @@ QEMUOptionParameter *append_option_parameters(QEMUOptionParameter *dest, + QEMUOptionParameter *list); + QEMUOptionParameter *parse_option_parameters(const char *param, + QEMUOptionParameter *list, QEMUOptionParameter *dest); ++void parse_option_size(const char *name, const char *value, ++ uint64_t *ret, Error **errp); + void free_option_parameters(QEMUOptionParameter *list); + void print_option_parameters(QEMUOptionParameter *list); + void print_option_help(QEMUOptionParameter *list); +diff --git a/util/qemu-option.c b/util/qemu-option.c +index fcbd1b8..1cefbfe 100644 +--- a/util/qemu-option.c ++++ b/util/qemu-option.c +@@ -173,8 +173,8 @@ static void parse_option_number(const char *name, const char *value, + } + } + +-static void parse_option_size(const char *name, const char *value, +- uint64_t *ret, Error **errp) ++void parse_option_size(const char *name, const char *value, ++ uint64_t *ret, Error **errp) + { + char *postfix; + double sizef; +-- +1.7.11.7 + diff --git a/SOURCES/kvm-qdev-Do-not-let-the-user-try-to-device_add-when-it.2.patch.patch b/SOURCES/kvm-qdev-Do-not-let-the-user-try-to-device_add-when-it.2.patch.patch new file mode 100644 index 0000000..ff1b1c9 --- /dev/null +++ b/SOURCES/kvm-qdev-Do-not-let-the-user-try-to-device_add-when-it.2.patch.patch @@ -0,0 +1,61 @@ +From 48aa83a2a3e42665e3e3e390909ebc147e234f73 Mon Sep 17 00:00:00 2001 +From: Markus Armbruster +Date: Fri, 17 Jan 2014 17:07:57 +0100 +Subject: [PATCH 07/11] qdev: Do not let the user try to device_add when it cannot work +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +RH-Author: Markus Armbruster +Message-id: <1389978479-30595-8-git-send-email-armbru@redhat.com> +Patchwork-id: 56788 +O-Subject: [PATCH 7.0 qemu-kvm 7/9] qdev: Do not let the user try to device_add when it cannot work +Bugzilla: 669524 +RH-Acked-by: Eduardo Habkost +RH-Acked-by: Michael S. Tsirkin +RH-Acked-by: Marcel Apfelbaum + +Such devices have always been unavailable and omitted from the list of +available devices shown by device_add help. Until commit 18b6dad +silently broke the former, setting up nasty traps for unwary users, +like this one: + + $ qemu-system-x86_64 -nodefaults -monitor stdio -display none + QEMU 1.6.50 monitor - type 'help' for more information + (qemu) device_add apic + Segmentation fault (core dumped) + +I call that a regression. Fix it. + +Signed-off-by: Markus Armbruster +Reviewed-by: Marcel Apfelbaum +Signed-off-by: Andreas Färber +(cherry picked from commit 7ea5e78f3d8d64e99c4017ea211b7518f2629756) +--- + qdev-monitor.c | 5 +++++ + 1 file changed, 5 insertions(+) + +Signed-off-by: Miroslav Rezanina +--- + qdev-monitor.c | 5 +++++ + 1 files changed, 5 insertions(+), 0 deletions(-) + +diff --git a/qdev-monitor.c b/qdev-monitor.c +index eb05b4c..da7fe0d 100644 +--- a/qdev-monitor.c ++++ b/qdev-monitor.c +@@ -490,6 +490,11 @@ DeviceState *qdev_device_add(QemuOpts *opts) + } + + dc = DEVICE_CLASS(oc); ++ if (dc->cannot_instantiate_with_device_add_yet) { ++ qerror_report(QERR_INVALID_PARAMETER_VALUE, "driver", ++ "pluggable device type"); ++ return NULL; ++ } + + /* find bus */ + path = qemu_opt_get(opts, "bus"); +-- +1.7.1 + diff --git a/SOURCES/kvm-qdev-Document-that-pointer-properties-kill-device_ad.patch b/SOURCES/kvm-qdev-Document-that-pointer-properties-kill-device_ad.patch new file mode 100644 index 0000000..57a7b88 --- /dev/null +++ b/SOURCES/kvm-qdev-Document-that-pointer-properties-kill-device_ad.patch @@ -0,0 +1,65 @@ +From 695e02fdf90a0487f70b26b276e71e0924a817dc Mon Sep 17 00:00:00 2001 +From: Markus Armbruster +Date: Thu, 16 Jan 2014 15:25:19 -0500 +Subject: [PATCH 13/14] qdev: Document that pointer properties kill device_add +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +Message-id: <1389885919-16158-3-git-send-email-armbru@redhat.com> +Patchwork-id: 56749 +O-Subject: [PATCH 7.0 qemu-kvm 2/2] qdev: Document that pointer properties kill device_add +Bugzilla: 1031098 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Laszlo Ersek +RH-Acked-by: Miroslav Rezanina + +Ask users of DEFINE_PROP_PTR() to set +cannot_instantiate_with_device_add_yet, or explain why it's not +needed. + +Signed-off-by: Markus Armbruster +Signed-off-by: Andreas Färber +(cherry picked from commit c272758f93b9c88c884461a2baa37b8f4008bf02) +--- + include/hw/qdev-properties.h | 17 +++++++++++++++++ + 1 file changed, 17 insertions(+) + +Signed-off-by: Miroslav Rezanina +--- + include/hw/qdev-properties.h | 17 +++++++++++++++++ + 1 file changed, 17 insertions(+) + +diff --git a/include/hw/qdev-properties.h b/include/hw/qdev-properties.h +index 692f82e..77c6f7c 100644 +--- a/include/hw/qdev-properties.h ++++ b/include/hw/qdev-properties.h +@@ -122,8 +122,25 @@ extern PropertyInfo qdev_prop_arraylen; + #define DEFINE_PROP_PCI_DEVFN(_n, _s, _f, _d) \ + DEFINE_PROP_DEFAULT(_n, _s, _f, _d, qdev_prop_pci_devfn, int32_t) + ++/* ++ * Please avoid pointer properties. If you must use them, you must ++ * cover them in their device's class init function as follows: ++ * ++ * - If the property must be set, the device cannot be used with ++ * device_add, so add code like this: ++ * |* Reason: pointer property "NAME-OF-YOUR-PROP" *| ++ * DeviceClass *dc = DEVICE_CLASS(class); ++ * dc->cannot_instantiate_with_device_add_yet = true; ++ * ++ * - If the property may safely remain null, document it like this: ++ * |* ++ * * Note: pointer property "interrupt_vector" may remain null, thus ++ * * no need for dc->cannot_instantiate_with_device_add_yet = true; ++ * *| ++ */ + #define DEFINE_PROP_PTR(_n, _s, _f) \ + DEFINE_PROP(_n, _s, _f, qdev_prop_ptr, void*) ++ + #define DEFINE_PROP_CHR(_n, _s, _f) \ + DEFINE_PROP(_n, _s, _f, qdev_prop_chr, CharDriverState*) + #define DEFINE_PROP_STRING(_n, _s, _f) \ +-- +1.8.3.1 + diff --git a/SOURCES/kvm-qdev-Drop-misleading-qdev_free-function.patch b/SOURCES/kvm-qdev-Drop-misleading-qdev_free-function.patch new file mode 100644 index 0000000..382bd9c --- /dev/null +++ b/SOURCES/kvm-qdev-Drop-misleading-qdev_free-function.patch @@ -0,0 +1,339 @@ +From c2d17bffc7268369f912357d7061db65e398432f Mon Sep 17 00:00:00 2001 +Message-Id: +In-Reply-To: <527da6c2ce2c09d0183aa8595fc95f136f61b6df.1387288155.git.minovotn@redhat.com> +References: <527da6c2ce2c09d0183aa8595fc95f136f61b6df.1387288155.git.minovotn@redhat.com> +From: Stefan Hajnoczi +Date: Thu, 12 Dec 2013 16:21:22 +0100 +Subject: [PATCH 2/8] qdev: Drop misleading qdev_free() function +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +RH-Author: Stefan Hajnoczi +Message-id: <1386865288-1575-3-git-send-email-stefanha@redhat.com> +Patchwork-id: 56256 +O-Subject: [RHEL7 qemu-kvm PATCH 2/8] qdev: Drop misleading qdev_free() function +Bugzilla: 1003773 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Jeffrey Cody +RH-Acked-by: Markus Armbruster + +The qdev_free() function name is misleading since all the function does +is unlink the device from its parent. The device is not necessarily +freed. + +The device will be freed when its QObject refcount reaches zero. It is +usual for the parent (bus) to hold the final reference but there are +cases where something else holds a reference so "free" is a misleading +name. + +Call object_unparent(obj) directly instead of having a qdev wrapper +function. + +Signed-off-by: Stefan Hajnoczi +Reviewed-by: Eric Blake +Signed-off-by: Andreas Färber +(cherry picked from commit 02a5c4c97422b40034f31265e0f139f7846172a8) + +Signed-off-by: Stefan Hajnoczi + +Conflicts: + hw/scsi/scsi-bus.c + hw/xen/xen_platform.c + +The conflicts are straightforward. +--- + hw/acpi/piix4.c | 2 +- + hw/core/qdev.c | 12 +++--------- + hw/pci/pci-hotplug.c | 2 +- + hw/pci/pci_bridge.c | 2 +- + hw/pci/pcie.c | 2 +- + hw/pci/shpc.c | 2 +- + hw/s390x/virtio-ccw.c | 2 +- + hw/scsi/scsi-bus.c | 4 ++-- + hw/usb/bus.c | 7 ++++--- + hw/usb/dev-storage.c | 2 +- + hw/usb/host-legacy.c | 2 +- + hw/virtio/virtio-bus.c | 4 +--- + hw/xen/xen_platform.c | 2 +- + include/hw/qdev-core.h | 1 - + qdev-monitor.c | 2 +- + 15 files changed, 20 insertions(+), 28 deletions(-) + +Signed-off-by: Michal Novotny +--- + hw/acpi/piix4.c | 2 +- + hw/core/qdev.c | 12 +++--------- + hw/pci/pci-hotplug.c | 2 +- + hw/pci/pci_bridge.c | 2 +- + hw/pci/pcie.c | 2 +- + hw/pci/shpc.c | 2 +- + hw/s390x/virtio-ccw.c | 2 +- + hw/scsi/scsi-bus.c | 4 ++-- + hw/usb/bus.c | 7 ++++--- + hw/usb/dev-storage.c | 2 +- + hw/usb/host-legacy.c | 2 +- + hw/virtio/virtio-bus.c | 4 +--- + hw/xen/xen_platform.c | 2 +- + include/hw/qdev-core.h | 1 - + qdev-monitor.c | 2 +- + 15 files changed, 20 insertions(+), 28 deletions(-) + +diff --git a/hw/acpi/piix4.c b/hw/acpi/piix4.c +index d79a7b0..8af97cf 100644 +--- a/hw/acpi/piix4.c ++++ b/hw/acpi/piix4.c +@@ -315,7 +315,7 @@ static void acpi_piix_eject_slot(PIIX4PMState *s, unsigned slots) + if (pc->no_hotplug) { + slot_free = false; + } else { +- qdev_free(qdev); ++ object_unparent(OBJECT(qdev)); + } + } + } +diff --git a/hw/core/qdev.c b/hw/core/qdev.c +index 9190a7e..70a0dee 100644 +--- a/hw/core/qdev.c ++++ b/hw/core/qdev.c +@@ -164,7 +164,7 @@ int qdev_init(DeviceState *dev) + if (local_err != NULL) { + qerror_report_err(local_err); + error_free(local_err); +- qdev_free(dev); ++ object_unparent(OBJECT(dev)); + return -1; + } + return 0; +@@ -258,7 +258,7 @@ void qbus_reset_all_fn(void *opaque) + int qdev_simple_unplug_cb(DeviceState *dev) + { + /* just zap it */ +- qdev_free(dev); ++ object_unparent(OBJECT(dev)); + return 0; + } + +@@ -280,12 +280,6 @@ void qdev_init_nofail(DeviceState *dev) + } + } + +-/* Unlink device from bus and free the structure. */ +-void qdev_free(DeviceState *dev) +-{ +- object_unparent(OBJECT(dev)); +-} +- + void qdev_machine_creation_done(void) + { + /* +@@ -458,7 +452,7 @@ static void bus_unparent(Object *obj) + + while ((kid = QTAILQ_FIRST(&bus->children)) != NULL) { + DeviceState *dev = kid->child; +- qdev_free(dev); ++ object_unparent(OBJECT(dev)); + } + if (bus->parent) { + QLIST_REMOVE(bus, sibling); +diff --git a/hw/pci/pci-hotplug.c b/hw/pci/pci-hotplug.c +index c708752..667e40c 100644 +--- a/hw/pci/pci-hotplug.c ++++ b/hw/pci/pci-hotplug.c +@@ -224,7 +224,7 @@ static PCIDevice *qemu_pci_hot_add_storage(Monitor *mon, + } + dev = pci_create(bus, devfn, "virtio-blk-pci"); + if (qdev_prop_set_drive(&dev->qdev, "drive", dinfo->bdrv) < 0) { +- qdev_free(&dev->qdev); ++ object_unparent(OBJECT(dev)); + dev = NULL; + break; + } +diff --git a/hw/pci/pci_bridge.c b/hw/pci/pci_bridge.c +index 3897bd8..a786f26 100644 +--- a/hw/pci/pci_bridge.c ++++ b/hw/pci/pci_bridge.c +@@ -386,7 +386,7 @@ void pci_bridge_exitfn(PCIDevice *pci_dev) + pci_bridge_region_cleanup(s, s->windows); + memory_region_destroy(&s->address_space_mem); + memory_region_destroy(&s->address_space_io); +- /* qbus_free() is called automatically by qdev_free() */ ++ /* qbus_free() is called automatically during device deletion */ + } + + /* +diff --git a/hw/pci/pcie.c b/hw/pci/pcie.c +index 62bd0b8..4b84443 100644 +--- a/hw/pci/pcie.c ++++ b/hw/pci/pcie.c +@@ -251,7 +251,7 @@ static int pcie_cap_slot_hotplug(DeviceState *qdev, + PCI_EXP_SLTSTA_PDS); + pcie_cap_slot_event(d, PCI_EXP_HP_EV_PDC); + } else { +- qdev_free(&pci_dev->qdev); ++ object_unparent(OBJECT(pci_dev)); + pci_word_test_and_clear_mask(exp_cap + PCI_EXP_SLTSTA, + PCI_EXP_SLTSTA_PDS); + pcie_cap_slot_event(d, PCI_EXP_HP_EV_PDC); +diff --git a/hw/pci/shpc.c b/hw/pci/shpc.c +index d35c2ee..1e57952 100644 +--- a/hw/pci/shpc.c ++++ b/hw/pci/shpc.c +@@ -254,7 +254,7 @@ static void shpc_free_devices_in_slot(SHPCDevice *shpc, int slot) + ++devfn) { + PCIDevice *affected_dev = shpc->sec_bus->devices[devfn]; + if (affected_dev) { +- qdev_free(&affected_dev->qdev); ++ object_unparent(OBJECT(affected_dev)); + } + } + } +diff --git a/hw/s390x/virtio-ccw.c b/hw/s390x/virtio-ccw.c +index d981101..7ba1376 100644 +--- a/hw/s390x/virtio-ccw.c ++++ b/hw/s390x/virtio-ccw.c +@@ -1036,7 +1036,7 @@ static int virtio_ccw_busdev_unplug(DeviceState *dev) + + css_generate_sch_crws(sch->cssid, sch->ssid, sch->schid, 1, 0); + +- qdev_free(dev); ++ object_unparent(OBJECT(dev)); + return 0; + } + +diff --git a/hw/scsi/scsi-bus.c b/hw/scsi/scsi-bus.c +index 9082ea7..6733c1a 100644 +--- a/hw/scsi/scsi-bus.c ++++ b/hw/scsi/scsi-bus.c +@@ -178,7 +178,7 @@ static int scsi_qdev_init(DeviceState *qdev) + d = scsi_device_find(bus, dev->channel, dev->id, dev->lun); + assert(d); + if (d->lun == dev->lun && dev != d) { +- qdev_free(&d->qdev); ++ object_unparent(OBJECT(d)); + } + } + +@@ -229,7 +229,7 @@ SCSIDevice *scsi_bus_legacy_add_drive(SCSIBus *bus, BlockDriverState *bdrv, + qdev_prop_set_string(dev, "serial", serial); + } + if (qdev_prop_set_drive(dev, "drive", bdrv) < 0) { +- qdev_free(dev); ++ object_unparent(OBJECT(dev)); + return NULL; + } + if (qdev_init(dev) < 0) +diff --git a/hw/usb/bus.c b/hw/usb/bus.c +index f83d1de..ade9abc 100644 +--- a/hw/usb/bus.c ++++ b/hw/usb/bus.c +@@ -351,8 +351,9 @@ void usb_port_location(USBPort *downstream, USBPort *upstream, int portnr) + + void usb_unregister_port(USBBus *bus, USBPort *port) + { +- if (port->dev) +- qdev_free(&port->dev->qdev); ++ if (port->dev) { ++ object_unparent(OBJECT(port->dev)); ++ } + QTAILQ_REMOVE(&bus->free, port, next); + bus->nfree--; + } +@@ -500,7 +501,7 @@ int usb_device_delete_addr(int busnr, int addr) + return -1; + dev = port->dev; + +- qdev_free(&dev->qdev); ++ object_unparent(OBJECT(dev)); + return 0; + } + +diff --git a/hw/usb/dev-storage.c b/hw/usb/dev-storage.c +index 44a0e34..f60b048 100644 +--- a/hw/usb/dev-storage.c ++++ b/hw/usb/dev-storage.c +@@ -699,7 +699,7 @@ static USBDevice *usb_msd_init(USBBus *bus, const char *filename) + return NULL; + } + if (qdev_prop_set_drive(&dev->qdev, "drive", dinfo->bdrv) < 0) { +- qdev_free(&dev->qdev); ++ object_unparent(OBJECT(dev)); + return NULL; + } + if (qdev_init(&dev->qdev) < 0) +diff --git a/hw/usb/host-legacy.c b/hw/usb/host-legacy.c +index 3a5f705..3cc9c42 100644 +--- a/hw/usb/host-legacy.c ++++ b/hw/usb/host-legacy.c +@@ -132,7 +132,7 @@ USBDevice *usb_host_device_open(USBBus *bus, const char *devname) + return dev; + + fail: +- qdev_free(&dev->qdev); ++ object_unparent(OBJECT(dev)); + return NULL; + } + +diff --git a/hw/virtio/virtio-bus.c b/hw/virtio/virtio-bus.c +index 6849a01..e6b103c 100644 +--- a/hw/virtio/virtio-bus.c ++++ b/hw/virtio/virtio-bus.c +@@ -67,7 +67,6 @@ void virtio_bus_reset(VirtioBusState *bus) + /* Destroy the VirtIODevice */ + void virtio_bus_destroy_device(VirtioBusState *bus) + { +- DeviceState *qdev; + BusState *qbus = BUS(bus); + VirtioBusClass *klass = VIRTIO_BUS_GET_CLASS(bus); + DPRINTF("%s: remove device.\n", qbus->name); +@@ -76,8 +75,7 @@ void virtio_bus_destroy_device(VirtioBusState *bus) + if (klass->device_unplug != NULL) { + klass->device_unplug(qbus->parent); + } +- qdev = DEVICE(bus->vdev); +- qdev_free(qdev); ++ object_unparent(OBJECT(bus->vdev)); + bus->vdev = NULL; + } + } +diff --git a/hw/xen/xen_platform.c b/hw/xen/xen_platform.c +index bb9d0cd..98fe405 100644 +--- a/hw/xen/xen_platform.c ++++ b/hw/xen/xen_platform.c +@@ -88,7 +88,7 @@ static void unplug_nic(PCIBus *b, PCIDevice *d, void *o) + if (pci_get_word(d->config + PCI_CLASS_DEVICE) == + PCI_CLASS_NETWORK_ETHERNET + && strcmp(d->name, "xen-pci-passthrough") != 0) { +- qdev_free(&d->qdev); ++ object_unparent(OBJECT(d)); + } + } + +diff --git a/include/hw/qdev-core.h b/include/hw/qdev-core.h +index 44feb54..ad39ea9 100644 +--- a/include/hw/qdev-core.h ++++ b/include/hw/qdev-core.h +@@ -232,7 +232,6 @@ void qdev_init_nofail(DeviceState *dev); + void qdev_set_legacy_instance_id(DeviceState *dev, int alias_id, + int required_for_version); + void qdev_unplug(DeviceState *dev, Error **errp); +-void qdev_free(DeviceState *dev); + int qdev_simple_unplug_cb(DeviceState *dev); + void qdev_machine_creation_done(void); + bool qdev_machine_modified(void); +diff --git a/qdev-monitor.c b/qdev-monitor.c +index 9d4f61d..f78ff64 100644 +--- a/qdev-monitor.c ++++ b/qdev-monitor.c +@@ -521,7 +521,7 @@ DeviceState *qdev_device_add(QemuOpts *opts) + qdev->id = id; + } + if (qemu_opt_foreach(opts, set_property, qdev, 1) != 0) { +- qdev_free(qdev); ++ object_unparent(OBJECT(qdev)); + object_unref(OBJECT(qdev)); + return NULL; + } +-- +1.7.11.7 + diff --git a/SOURCES/kvm-qdev-Fix-32-bit-compilation-in-print_size.patch b/SOURCES/kvm-qdev-Fix-32-bit-compilation-in-print_size.patch new file mode 100644 index 0000000..e78c232 --- /dev/null +++ b/SOURCES/kvm-qdev-Fix-32-bit-compilation-in-print_size.patch @@ -0,0 +1,47 @@ +From 4796cbee4433654a54303102b9cc88f9c352b1b5 Mon Sep 17 00:00:00 2001 +From: Markus Armbruster +Date: Wed, 22 Jan 2014 12:13:54 +0100 +Subject: [PATCH 3/4] qdev: Fix 32-bit compilation in print_size + +RH-Author: Markus Armbruster +Message-id: <1390392835-21809-2-git-send-email-armbru@redhat.com> +Patchwork-id: 56889 +O-Subject: [PATCH 7.0 qemu-kvm 1/2] qdev: Fix 32-bit compilation in print_size +Bugzilla: 1034876 +RH-Acked-by: Marcel Apfelbaum +RH-Acked-by: Orit Wasserman +RH-Acked-by: Dr. David Alan Gilbert (git) +RH-Acked-by: Michael S. Tsirkin + +From: Richard Henderson + +Signed-off-by: Richard Henderson +Message-id: 1375208443-17288-2-git-send-email-rth@twiddle.net +Signed-off-by: Anthony Liguori +(cherry picked from commit e76c756fd3d3b652c6a65ebe16f2bfb25b8d025e) +Signed-off-by: Markus Armbruster +--- + hw/core/qdev-properties.c | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +Signed-off-by: Miroslav Rezanina +--- + hw/core/qdev-properties.c | 2 +- + 1 files changed, 1 insertions(+), 1 deletions(-) + +diff --git a/hw/core/qdev-properties.c b/hw/core/qdev-properties.c +index 8d43a8d..d6d10c9 100644 +--- a/hw/core/qdev-properties.c ++++ b/hw/core/qdev-properties.c +@@ -1177,7 +1177,7 @@ static int print_size(DeviceState *dev, Property *prop, char *dest, size_t len) + int i = 0; + uint64_t div; + +- for (div = (long int)1 << 40; !(*ptr / div) ; div >>= 10) { ++ for (div = 1ULL << 40; !(*ptr / div) ; div >>= 10) { + i++; + } + return snprintf(dest, len, "%0.03f%c", (double)*ptr/div, suffixes[i]); +-- +1.7.1 + diff --git a/SOURCES/kvm-qdev-Use-clz-in-print_size.patch b/SOURCES/kvm-qdev-Use-clz-in-print_size.patch new file mode 100644 index 0000000..8b8371a --- /dev/null +++ b/SOURCES/kvm-qdev-Use-clz-in-print_size.patch @@ -0,0 +1,69 @@ +From 5a3112e24aa41c50703739ccf419bad6136eb797 Mon Sep 17 00:00:00 2001 +From: Markus Armbruster +Date: Wed, 22 Jan 2014 12:13:55 +0100 +Subject: [PATCH 4/4] qdev: Use clz in print_size + +RH-Author: Markus Armbruster +Message-id: <1390392835-21809-3-git-send-email-armbru@redhat.com> +Patchwork-id: 56888 +O-Subject: [PATCH 7.0 qemu-kvm 2/2] qdev: Use clz in print_size +Bugzilla: 1034876 +RH-Acked-by: Marcel Apfelbaum +RH-Acked-by: Orit Wasserman +RH-Acked-by: Dr. David Alan Gilbert (git) +RH-Acked-by: Michael S. Tsirkin + +From: Richard Henderson + +We can compute a floor log2 value with clz rather than a division loop. + +Signed-off-by: Richard Henderson +Message-id: 1375208443-17288-3-git-send-email-rth@twiddle.net +Signed-off-by: Anthony Liguori +(cherry picked from commit 1197cbb9eda1dc82e2fa1815ca62bc3de158353e) +Signed-off-by: Markus Armbruster +--- + hw/core/qdev-properties.c | 20 +++++++++++++------- + 1 file changed, 13 insertions(+), 7 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + hw/core/qdev-properties.c | 20 +++++++++++++------- + 1 files changed, 13 insertions(+), 7 deletions(-) + +diff --git a/hw/core/qdev-properties.c b/hw/core/qdev-properties.c +index d6d10c9..dc8ae69 100644 +--- a/hw/core/qdev-properties.c ++++ b/hw/core/qdev-properties.c +@@ -1172,15 +1172,21 @@ static int parse_size(DeviceState *dev, Property *prop, const char *str) + + static int print_size(DeviceState *dev, Property *prop, char *dest, size_t len) + { +- uint64_t *ptr = qdev_get_prop_ptr(dev, prop); +- char suffixes[] = {'T', 'G', 'M', 'K', 'B'}; +- int i = 0; +- uint64_t div; ++ static const char suffixes[] = { 'B', 'K', 'M', 'G', 'T' }; ++ uint64_t div, val = *(uint64_t *)qdev_get_prop_ptr(dev, prop); ++ int i; + +- for (div = 1ULL << 40; !(*ptr / div) ; div >>= 10) { +- i++; ++ /* Compute floor(log2(val)). */ ++ i = 64 - clz64(val); ++ ++ /* Find the power of 1024 that we'll display as the units. */ ++ i /= 10; ++ if (i >= ARRAY_SIZE(suffixes)) { ++ i = ARRAY_SIZE(suffixes) - 1; + } +- return snprintf(dest, len, "%0.03f%c", (double)*ptr/div, suffixes[i]); ++ div = 1ULL << (i * 10); ++ ++ return snprintf(dest, len, "%0.03f%c", (double)val/div, suffixes[i]); + } + + PropertyInfo qdev_prop_size = { +-- +1.7.1 + diff --git a/SOURCES/kvm-qdev-monitor-Avoid-device_add-crashing-on-non-device.patch b/SOURCES/kvm-qdev-monitor-Avoid-device_add-crashing-on-non-device.patch new file mode 100644 index 0000000..36eae10 --- /dev/null +++ b/SOURCES/kvm-qdev-monitor-Avoid-device_add-crashing-on-non-device.patch @@ -0,0 +1,57 @@ +From d2b004602412ce65613b30f28d07ef8607e0d505 Mon Sep 17 00:00:00 2001 +From: Markus Armbruster +Date: Fri, 17 Jan 2014 17:07:58 +0100 +Subject: [PATCH 08/11] qdev-monitor: Avoid device_add crashing on non-device driver name +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +RH-Author: Markus Armbruster +Message-id: <1389978479-30595-9-git-send-email-armbru@redhat.com> +Patchwork-id: 56795 +O-Subject: [PATCH 7.0 qemu-kvm 8/9] qdev-monitor: Avoid device_add crashing on non-device driver name +Bugzilla: 669524 +RH-Acked-by: Eduardo Habkost +RH-Acked-by: Michael S. Tsirkin +RH-Acked-by: Marcel Apfelbaum + +Watch this: + + $ upstream-qemu -nodefaults -S -display none -monitor stdio + QEMU 1.7.50 monitor - type 'help' for more information + (qemu) device_add rng-egd + /work/armbru/qemu/qdev-monitor.c:491:qdev_device_add: Object 0x2089b00 is not an instance of type device + Aborted (core dumped) + +Crashes because "rng-egd" exists, but isn't a subtype of TYPE_DEVICE. +Broken in commit 18b6dad. + +Cc: qemu-stable@nongnu.org +Signed-off-by: Markus Armbruster +Signed-off-by: Andreas Färber +(cherry picked from commit 061e84f7a469ad1f94f3b5f6a5361b346ab990e8) +--- + qdev-monitor.c | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +Signed-off-by: Miroslav Rezanina +--- + qdev-monitor.c | 2 +- + 1 files changed, 1 insertions(+), 1 deletions(-) + +diff --git a/qdev-monitor.c b/qdev-monitor.c +index da7fe0d..55a476b 100644 +--- a/qdev-monitor.c ++++ b/qdev-monitor.c +@@ -478,7 +478,7 @@ DeviceState *qdev_device_add(QemuOpts *opts) + } + } + +- if (!oc) { ++ if (!object_class_dynamic_cast(oc, TYPE_DEVICE)) { + qerror_report(QERR_INVALID_PARAMETER_VALUE, "driver", "device type"); + return NULL; + } +-- +1.7.1 + diff --git a/SOURCES/kvm-qdev-monitor-Avoid-qdev-as-variable-name.patch b/SOURCES/kvm-qdev-monitor-Avoid-qdev-as-variable-name.patch new file mode 100644 index 0000000..7081507 --- /dev/null +++ b/SOURCES/kvm-qdev-monitor-Avoid-qdev-as-variable-name.patch @@ -0,0 +1,107 @@ +From 7f65c774ae1c40ca38de8db14ad5637390c6c2e7 Mon Sep 17 00:00:00 2001 +From: Markus Armbruster +Date: Fri, 17 Jan 2014 17:07:55 +0100 +Subject: [PATCH 05/11] qdev-monitor: Avoid qdev as variable name +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +RH-Author: Markus Armbruster +Message-id: <1389978479-30595-6-git-send-email-armbru@redhat.com> +Patchwork-id: 56791 +O-Subject: [PATCH 7.0 qemu-kvm 5/9] qdev-monitor: Avoid qdev as variable name +Bugzilla: 669524 +RH-Acked-by: Eduardo Habkost +RH-Acked-by: Michael S. Tsirkin +RH-Acked-by: Marcel Apfelbaum + +From: Andreas Färber + +Prepares for bringing error cleanup code into canonical QOM form. + +Includes a whitespace removal after curly brace by Stefan. + +Signed-off-by: Stefan Hajnoczi +Reviewed-by: Igor Mammedov +Signed-off-by: Andreas Färber +(cherry picked from commit 2bcb0c62f620a7033e9e25c5b645d50bf9e6a8f2) +Signed-off-by: Markus Armbruster +--- + qdev-monitor.c | 32 ++++++++++++++++---------------- + 1 file changed, 16 insertions(+), 16 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + qdev-monitor.c | 32 ++++++++++++++++---------------- + 1 files changed, 16 insertions(+), 16 deletions(-) + +diff --git a/qdev-monitor.c b/qdev-monitor.c +index f313a94..464e7bd 100644 +--- a/qdev-monitor.c ++++ b/qdev-monitor.c +@@ -457,7 +457,7 @@ DeviceState *qdev_device_add(QemuOpts *opts) + ObjectClass *oc; + DeviceClass *dc; + const char *driver, *path, *id; +- DeviceState *qdev; ++ DeviceState *dev; + BusState *bus = NULL; + + driver = qemu_opt_get(opts, "driver"); +@@ -516,38 +516,38 @@ DeviceState *qdev_device_add(QemuOpts *opts) + } + + /* create device, set properties */ +- qdev = DEVICE(object_new(driver)); ++ dev = DEVICE(object_new(driver)); + + if (bus) { +- qdev_set_parent_bus(qdev, bus); ++ qdev_set_parent_bus(dev, bus); + } + + id = qemu_opts_id(opts); + if (id) { +- qdev->id = id; ++ dev->id = id; + } +- if (qemu_opt_foreach(opts, set_property, qdev, 1) != 0) { +- object_unparent(OBJECT(qdev)); +- object_unref(OBJECT(qdev)); ++ if (qemu_opt_foreach(opts, set_property, dev, 1) != 0) { ++ object_unparent(OBJECT(dev)); ++ object_unref(OBJECT(dev)); + return NULL; + } +- if (qdev->id) { +- object_property_add_child(qdev_get_peripheral(), qdev->id, +- OBJECT(qdev), NULL); ++ if (dev->id) { ++ object_property_add_child(qdev_get_peripheral(), dev->id, ++ OBJECT(dev), NULL); + } else { + static int anon_count; + gchar *name = g_strdup_printf("device[%d]", anon_count++); + object_property_add_child(qdev_get_peripheral_anon(), name, +- OBJECT(qdev), NULL); ++ OBJECT(dev), NULL); + g_free(name); +- } +- if (qdev_init(qdev) < 0) { +- object_unref(OBJECT(qdev)); ++ } ++ if (qdev_init(dev) < 0) { ++ object_unref(OBJECT(dev)); + qerror_report(QERR_DEVICE_INIT_FAILED, driver); + return NULL; + } +- qdev->opts = opts; +- return qdev; ++ dev->opts = opts; ++ return dev; + } + + +-- +1.7.1 + diff --git a/SOURCES/kvm-qdev-monitor-Clean-up-qdev_device_add-variable-namin.patch b/SOURCES/kvm-qdev-monitor-Clean-up-qdev_device_add-variable-namin.patch new file mode 100644 index 0000000..1e80125 --- /dev/null +++ b/SOURCES/kvm-qdev-monitor-Clean-up-qdev_device_add-variable-namin.patch @@ -0,0 +1,101 @@ +From 4767cbd32744d8dff462233b6509f31ebe826588 Mon Sep 17 00:00:00 2001 +From: Markus Armbruster +Date: Fri, 17 Jan 2014 17:07:53 +0100 +Subject: [PATCH 03/11] qdev-monitor: Clean up qdev_device_add() variable naming +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +RH-Author: Markus Armbruster +Message-id: <1389978479-30595-4-git-send-email-armbru@redhat.com> +Patchwork-id: 56786 +O-Subject: [PATCH 7.0 qemu-kvm 3/9] qdev-monitor: Clean up qdev_device_add() variable naming +Bugzilla: 669524 +RH-Acked-by: Eduardo Habkost +RH-Acked-by: Michael S. Tsirkin +RH-Acked-by: Marcel Apfelbaum + +From: Andreas Färber + +Avoid confusion between object (obj) and object class (oc). +Tidy DeviceClass variable while at it (k -> dc). + +Signed-off-by: Andreas Färber +(cherry picked from commit f4d85795605c7dc594c013221a4b6d62967bd8ab) +Signed-off-by: Markus Armbruster +--- + qdev-monitor.c | 22 +++++++++++----------- + 1 file changed, 11 insertions(+), 11 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + qdev-monitor.c | 22 +++++++++++----------- + 1 files changed, 11 insertions(+), 11 deletions(-) + +diff --git a/qdev-monitor.c b/qdev-monitor.c +index d187db5..5b45d02 100644 +--- a/qdev-monitor.c ++++ b/qdev-monitor.c +@@ -454,8 +454,8 @@ static BusState *qbus_find(const char *path) + + DeviceState *qdev_device_add(QemuOpts *opts) + { +- ObjectClass *obj; +- DeviceClass *k; ++ ObjectClass *oc; ++ DeviceClass *dc; + const char *driver, *path, *id; + DeviceState *qdev; + BusState *bus = NULL; +@@ -467,22 +467,22 @@ DeviceState *qdev_device_add(QemuOpts *opts) + } + + /* find driver */ +- obj = object_class_by_name(driver); +- if (!obj) { ++ oc = object_class_by_name(driver); ++ if (!oc) { + const char *typename = find_typename_by_alias(driver); + + if (typename) { + driver = typename; +- obj = object_class_by_name(driver); ++ oc = object_class_by_name(driver); + } + } + +- if (!obj) { ++ if (!oc) { + qerror_report(QERR_INVALID_PARAMETER_VALUE, "driver", "device type"); + return NULL; + } + +- k = DEVICE_CLASS(obj); ++ dc = DEVICE_CLASS(oc); + + /* find bus */ + path = qemu_opt_get(opts, "bus"); +@@ -491,16 +491,16 @@ DeviceState *qdev_device_add(QemuOpts *opts) + if (!bus) { + return NULL; + } +- if (!object_dynamic_cast(OBJECT(bus), k->bus_type)) { ++ if (!object_dynamic_cast(OBJECT(bus), dc->bus_type)) { + qerror_report(QERR_BAD_BUS_FOR_DEVICE, + driver, object_get_typename(OBJECT(bus))); + return NULL; + } +- } else if (k->bus_type != NULL) { +- bus = qbus_find_recursive(sysbus_get_default(), NULL, k->bus_type); ++ } else if (dc->bus_type != NULL) { ++ bus = qbus_find_recursive(sysbus_get_default(), NULL, dc->bus_type); + if (!bus) { + qerror_report(QERR_NO_BUS_FOR_DEVICE, +- k->bus_type, driver); ++ dc->bus_type, driver); + return NULL; + } + } +-- +1.7.1 + diff --git a/SOURCES/kvm-qdev-monitor-Fix-crash-when-device_add-is-called-wit.patch b/SOURCES/kvm-qdev-monitor-Fix-crash-when-device_add-is-called-wit.patch new file mode 100644 index 0000000..6126084 --- /dev/null +++ b/SOURCES/kvm-qdev-monitor-Fix-crash-when-device_add-is-called-wit.patch @@ -0,0 +1,71 @@ +From 3e97a22728afed3c77140486ec3863eba941535b Mon Sep 17 00:00:00 2001 +From: Michael S. Tsirkin +Date: Mon, 13 Jan 2014 13:45:57 +0100 +Subject: [PATCH 11/16] qdev-monitor: Fix crash when device_add is called with abstract driver +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +RH-Author: Michael S. Tsirkin +Message-id: <1389620557-30050-1-git-send-email-mst@redhat.com> +Patchwork-id: 56642 +O-Subject: [PATCH qemu-kvm RHEL7.0] qdev-monitor: Fix crash when device_add is called with abstract driver +Bugzilla: 1026712 +RH-Acked-by: Amos Kong +RH-Acked-by: Marcel Apfelbaum +RH-Acked-by: Markus Armbruster +RH-Acked-by: Igor Mammedov + +From: Igor Mammedov + +User is able to crash running QEMU when following monitor +command is called: + + device_add intel-hda-generic + +Crash is caused by assertion in object_initialize_with_type() +when type is abstract. + +Checking if type is abstract before instance is created in +qdev_device_add() allows to prevent crash on incorrect user input. + +Cc: qemu-stable@nongnu.org +Signed-off-by: Igor Mammedov +Signed-off-by: Andreas Färber +(cherry picked from commit 2fa4e56d88aa0039062bbc7f9a88e9f90c77ed94) + +Conflicts: + qdev-monitor.c + +Brew build: http://brewweb.devel.redhat.com/brew/taskinfo?taskID=6859928 +Bugzilla: https://bugzilla.redhat.com/show_bug.cgi?id=1046007 + +--- + qdev-monitor.c | 6 ++++++ + 1 file changed, 6 insertions(+) + +Signed-off-by: Miroslav Rezanina +--- + qdev-monitor.c | 6 ++++++ + 1 files changed, 6 insertions(+), 0 deletions(-) + +diff --git a/qdev-monitor.c b/qdev-monitor.c +index f78ff64..979502e 100644 +--- a/qdev-monitor.c ++++ b/qdev-monitor.c +@@ -477,6 +477,12 @@ DeviceState *qdev_device_add(QemuOpts *opts) + } + } + ++ if (object_class_is_abstract(obj)) { ++ qerror_report(QERR_INVALID_PARAMETER_VALUE, "driver", ++ "non-abstract device type"); ++ return NULL; ++ } ++ + k = DEVICE_CLASS(obj); + + if (!k || k->cannot_instantiate_with_device_add_yet) { +-- +1.7.1 + diff --git a/SOURCES/kvm-qdev-monitor-Fix-crash-when-device_add-is-called.2.patch.patch b/SOURCES/kvm-qdev-monitor-Fix-crash-when-device_add-is-called.2.patch.patch new file mode 100644 index 0000000..7aadf36 --- /dev/null +++ b/SOURCES/kvm-qdev-monitor-Fix-crash-when-device_add-is-called.2.patch.patch @@ -0,0 +1,64 @@ +From 26c346739c8772521b68e4763321d7bdfc49efd4 Mon Sep 17 00:00:00 2001 +From: Markus Armbruster +Date: Fri, 17 Jan 2014 17:07:54 +0100 +Subject: [PATCH 04/11] qdev-monitor: Fix crash when device_add is called with abstract driver +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +RH-Author: Markus Armbruster +Message-id: <1389978479-30595-5-git-send-email-armbru@redhat.com> +Patchwork-id: 56787 +O-Subject: [PATCH 7.0 qemu-kvm 4/9] qdev-monitor: Fix crash when device_add is called with abstract driver +Bugzilla: 669524 +RH-Acked-by: Eduardo Habkost +RH-Acked-by: Michael S. Tsirkin +RH-Acked-by: Marcel Apfelbaum + +From: Igor Mammedov + +User is able to crash running QEMU when following monitor +command is called: + + device_add intel-hda-generic + +Crash is caused by assertion in object_initialize_with_type() +when type is abstract. + +Checking if type is abstract before instance is created in +qdev_device_add() allows to prevent crash on incorrect user input. + +Cc: qemu-stable@nongnu.org +Signed-off-by: Igor Mammedov +Signed-off-by: Andreas Färber +(cherry picked from commit 2fa4e56d88aa0039062bbc7f9a88e9f90c77ed94) +Signed-off-by: Markus Armbruster +--- + qdev-monitor.c | 6 ++++++ + 1 file changed, 6 insertions(+) + +Signed-off-by: Miroslav Rezanina +--- + qdev-monitor.c | 6 ++++++ + 1 files changed, 6 insertions(+), 0 deletions(-) + +diff --git a/qdev-monitor.c b/qdev-monitor.c +index 5b45d02..f313a94 100644 +--- a/qdev-monitor.c ++++ b/qdev-monitor.c +@@ -482,6 +482,12 @@ DeviceState *qdev_device_add(QemuOpts *opts) + return NULL; + } + ++ if (object_class_is_abstract(oc)) { ++ qerror_report(QERR_INVALID_PARAMETER_VALUE, "driver", ++ "non-abstract device type"); ++ return NULL; ++ } ++ + dc = DEVICE_CLASS(oc); + + /* find bus */ +-- +1.7.1 + diff --git a/SOURCES/kvm-qdev-monitor-Improve-error-message-for-device-nonexi.patch b/SOURCES/kvm-qdev-monitor-Improve-error-message-for-device-nonexi.patch new file mode 100644 index 0000000..b735041 --- /dev/null +++ b/SOURCES/kvm-qdev-monitor-Improve-error-message-for-device-nonexi.patch @@ -0,0 +1,70 @@ +From 41eb96b80b2e805573cc79e3b6e7eff49892dd47 Mon Sep 17 00:00:00 2001 +From: Markus Armbruster +Date: Fri, 17 Jan 2014 17:07:59 +0100 +Subject: [PATCH 09/11] qdev-monitor: Improve error message for -device nonexistant +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +RH-Author: Markus Armbruster +Message-id: <1389978479-30595-10-git-send-email-armbru@redhat.com> +Patchwork-id: 56794 +O-Subject: [PATCH 7.0 qemu-kvm 9/9] qdev-monitor: Improve error message for -device nonexistant +Bugzilla: 669524 +RH-Acked-by: Eduardo Habkost +RH-Acked-by: Michael S. Tsirkin +RH-Acked-by: Marcel Apfelbaum + +Once upon a time, the error message was: + + qemu: -device nonexistant: Device "nonexistant" not found. Try -device '?' for a list. + +But progress marches on, and conversion to QError (commit 0204276) +changed it into: + + Invalid parameter 'driver' + Try with argument '?' for a list. + +Progress didn't stop there, of course. After a couple of iterations, +we arrived at the current message (commit 6acbe4c): + + qemu: -device nonexistant: Parameter 'driver' expects device type + +Mission accomplished: this is complete mush. + +We've since abandoned our quest for "rich" error objects, fortunately +before it turned all error messages into mush. Time to undo the +damage to this one. Make it: + + qemu: -device nonexistant: nonexistant is not a valid device model name + +Signed-off-by: Markus Armbruster +Reviewed-by: Eric Blake +Signed-off-by: Andreas Färber +(cherry picked from commit 11c308b17a34932033cceca4f88b5e67009e3ebd) +--- + qdev-monitor.c | 3 ++- + 1 file changed, 2 insertions(+), 1 deletion(-) + +Signed-off-by: Miroslav Rezanina +--- + qdev-monitor.c | 3 ++- + 1 files changed, 2 insertions(+), 1 deletions(-) + +diff --git a/qdev-monitor.c b/qdev-monitor.c +index 55a476b..ac65a10 100644 +--- a/qdev-monitor.c ++++ b/qdev-monitor.c +@@ -479,7 +479,8 @@ DeviceState *qdev_device_add(QemuOpts *opts) + } + + if (!object_class_dynamic_cast(oc, TYPE_DEVICE)) { +- qerror_report(QERR_INVALID_PARAMETER_VALUE, "driver", "device type"); ++ qerror_report(ERROR_CLASS_GENERIC_ERROR, ++ "'%s' is not a valid device model name", driver); + return NULL; + } + +-- +1.7.1 + diff --git a/SOURCES/kvm-qdev-monitor-Inline-qdev_init-for-device_add.patch b/SOURCES/kvm-qdev-monitor-Inline-qdev_init-for-device_add.patch new file mode 100644 index 0000000..57c5f22 --- /dev/null +++ b/SOURCES/kvm-qdev-monitor-Inline-qdev_init-for-device_add.patch @@ -0,0 +1,63 @@ +From 69d7d4071c52078ff3040d693e07063de2730925 Mon Sep 17 00:00:00 2001 +From: Markus Armbruster +Date: Fri, 17 Jan 2014 17:07:56 +0100 +Subject: [PATCH 06/11] qdev-monitor: Inline qdev_init() for device_add +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +RH-Author: Markus Armbruster +Message-id: <1389978479-30595-7-git-send-email-armbru@redhat.com> +Patchwork-id: 56793 +O-Subject: [PATCH 7.0 qemu-kvm 6/9] qdev-monitor: Inline qdev_init() for device_add +Bugzilla: 669524 +RH-Acked-by: Eduardo Habkost +RH-Acked-by: Michael S. Tsirkin +RH-Acked-by: Marcel Apfelbaum + +From: Andreas Färber + +For historic reasons, qdev_init() unparents the device on failure. +Inline this to make the error paths clearer and consistent. + +Reviewed-by: Igor Mammedov +Signed-off-by: Andreas Färber +(cherry picked from commit 852e2c5008563692a8868260480e76b95bb9018c) +Signed-off-by: Markus Armbruster +--- + qdev-monitor.c | 7 ++++++- + 1 file changed, 6 insertions(+), 1 deletion(-) + +Signed-off-by: Miroslav Rezanina +--- + qdev-monitor.c | 7 ++++++- + 1 files changed, 6 insertions(+), 1 deletions(-) + +diff --git a/qdev-monitor.c b/qdev-monitor.c +index 464e7bd..eb05b4c 100644 +--- a/qdev-monitor.c ++++ b/qdev-monitor.c +@@ -459,6 +459,7 @@ DeviceState *qdev_device_add(QemuOpts *opts) + const char *driver, *path, *id; + DeviceState *dev; + BusState *bus = NULL; ++ Error *err = NULL; + + driver = qemu_opt_get(opts, "driver"); + if (!driver) { +@@ -541,7 +542,11 @@ DeviceState *qdev_device_add(QemuOpts *opts) + OBJECT(dev), NULL); + g_free(name); + } +- if (qdev_init(dev) < 0) { ++ object_property_set_bool(OBJECT(dev), true, "realized", &err); ++ if (err != NULL) { ++ qerror_report_err(err); ++ error_free(err); ++ object_unparent(OBJECT(dev)); + object_unref(OBJECT(dev)); + qerror_report(QERR_DEVICE_INIT_FAILED, driver); + return NULL; +-- +1.7.1 + diff --git a/SOURCES/kvm-qdev-monitor-Set-properties-after-parent-is-assigned.patch b/SOURCES/kvm-qdev-monitor-Set-properties-after-parent-is-assigned.patch new file mode 100644 index 0000000..52c8660 --- /dev/null +++ b/SOURCES/kvm-qdev-monitor-Set-properties-after-parent-is-assigned.patch @@ -0,0 +1,91 @@ +From b4d1a1c8b3448337e9b5e33706913b82356d22a7 Mon Sep 17 00:00:00 2001 +From: Amos Kong +Date: Tue, 11 Mar 2014 23:59:22 +0100 +Subject: [PATCH 1/6] qdev-monitor: Set properties after parent is assigned in device_add +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +RH-Author: Amos Kong +Message-id: <1394582362-8252-1-git-send-email-akong@redhat.com> +Patchwork-id: 58081 +O-Subject: [RHEL-7.0 qemu-kvm PATCH] qdev-monitor: Set properties after parent is assigned in device_add +Bugzilla: 1046248 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Xiao Wang +RH-Acked-by: Igor Mammedov + +Bugzilla: 1046248 +Brew: https://brewweb.devel.redhat.com/taskinfo?taskID=7190260 +Upstream: backported from qemu-cpu subtree (qom-next branch) + commit bd140cf43d0373cca4c17efaf2ce730cdcbc0c4e + +Test steps: + (qemu) device_add e1000,addr=adsf + Property 'e1000.addr' doesn't take value 'adsf' + (qemu) info qtree + Then qemu crashed. + +Currently we set a link to the new device from its parent bus, but the +device hasn't been added to QOM tree yet. When it fails to set properties, +object_unparent() can't clean up the device. + +Delay setting of device properties until the device has been added to +the QOM composition tree. This way, when setting a property fails, +object_unparent() can clean up the device properly. + +Signed-off-by: Amos Kong +Reviewed-by: Igor Mammedov +Signed-off-by: Andreas Färber +--- + qdev-monitor.c | 15 +++++++++------ + 1 file changed, 9 insertions(+), 6 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + qdev-monitor.c | 15 +++++++++------ + 1 files changed, 9 insertions(+), 6 deletions(-) + +diff --git a/qdev-monitor.c b/qdev-monitor.c +index d7b9f04..ee891ea 100644 +--- a/qdev-monitor.c ++++ b/qdev-monitor.c +@@ -522,7 +522,7 @@ DeviceState *qdev_device_add(QemuOpts *opts) + return NULL; + } + +- /* create device, set properties */ ++ /* create device */ + dev = DEVICE(object_new(driver)); + + if (bus) { +@@ -533,11 +533,7 @@ DeviceState *qdev_device_add(QemuOpts *opts) + if (id) { + dev->id = id; + } +- if (qemu_opt_foreach(opts, set_property, dev, 1) != 0) { +- object_unparent(OBJECT(dev)); +- object_unref(OBJECT(dev)); +- return NULL; +- } ++ + if (dev->id) { + object_property_add_child(qdev_get_peripheral(), dev->id, + OBJECT(dev), NULL); +@@ -549,6 +545,13 @@ DeviceState *qdev_device_add(QemuOpts *opts) + g_free(name); + } + ++ /* set properties */ ++ if (qemu_opt_foreach(opts, set_property, dev, 1) != 0) { ++ object_unparent(OBJECT(dev)); ++ object_unref(OBJECT(dev)); ++ return NULL; ++ } ++ + dev->opts = opts; + object_property_set_bool(OBJECT(dev), true, "realized", &err); + if (err != NULL) { +-- +1.7.1 + diff --git a/SOURCES/kvm-qdev-monitor-Unref-device-when-device_add-fails.patch b/SOURCES/kvm-qdev-monitor-Unref-device-when-device_add-fails.patch new file mode 100644 index 0000000..39ebd0a --- /dev/null +++ b/SOURCES/kvm-qdev-monitor-Unref-device-when-device_add-fails.patch @@ -0,0 +1,61 @@ +From 527da6c2ce2c09d0183aa8595fc95f136f61b6df Mon Sep 17 00:00:00 2001 +Message-Id: <527da6c2ce2c09d0183aa8595fc95f136f61b6df.1387288155.git.minovotn@redhat.com> +From: Stefan Hajnoczi +Date: Thu, 12 Dec 2013 16:21:21 +0100 +Subject: [PATCH 1/8] qdev-monitor: Unref device when device_add fails +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +RH-Author: Stefan Hajnoczi +Message-id: <1386865288-1575-2-git-send-email-stefanha@redhat.com> +Patchwork-id: 56255 +O-Subject: [RHEL7 qemu-kvm PATCH 1/8] qdev-monitor: Unref device when device_add fails +Bugzilla: 1003773 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Jeffrey Cody +RH-Acked-by: Markus Armbruster + +qdev_device_add() leaks the created device upon failure. I suspect this +problem crept in because qdev_free() unparents the device but does not +drop a reference - confusing name. + +Cc: qemu-stable@nongnu.org +Signed-off-by: Stefan Hajnoczi +Reviewed-by: Eric Blake +Signed-off-by: Andreas Färber +(cherry picked from commit ee6abeb6ec08473713848ce9028110f1684853b7) + +Signed-off-by: Stefan Hajnoczi +--- + qdev-monitor.c | 2 ++ + 1 file changed, 2 insertions(+) + +Signed-off-by: Michal Novotny +--- + qdev-monitor.c | 2 ++ + 1 file changed, 2 insertions(+) + +diff --git a/qdev-monitor.c b/qdev-monitor.c +index 39d030b..9d4f61d 100644 +--- a/qdev-monitor.c ++++ b/qdev-monitor.c +@@ -522,6 +522,7 @@ DeviceState *qdev_device_add(QemuOpts *opts) + } + if (qemu_opt_foreach(opts, set_property, qdev, 1) != 0) { + qdev_free(qdev); ++ object_unref(OBJECT(qdev)); + return NULL; + } + if (qdev->id) { +@@ -535,6 +536,7 @@ DeviceState *qdev_device_add(QemuOpts *opts) + g_free(name); + } + if (qdev_init(qdev) < 0) { ++ object_unref(OBJECT(qdev)); + qerror_report(QERR_DEVICE_INIT_FAILED, driver); + return NULL; + } +-- +1.7.11.7 + diff --git a/SOURCES/kvm-qdev-monitor-set-DeviceState-opts-before-calling-rea.patch b/SOURCES/kvm-qdev-monitor-set-DeviceState-opts-before-calling-rea.patch new file mode 100644 index 0000000..19c3c80 --- /dev/null +++ b/SOURCES/kvm-qdev-monitor-set-DeviceState-opts-before-calling-rea.patch @@ -0,0 +1,62 @@ +From 0bc5bd314b821409555ed0c0b281733a8c66d39d Mon Sep 17 00:00:00 2001 +From: Bandan Das +Date: Thu, 27 Feb 2014 18:31:16 +0100 +Subject: [PATCH 4/6] qdev-monitor: set DeviceState opts before calling realize +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +RH-Author: Bandan Das +Message-id: <1393525877-32262-2-git-send-email-bsd@redhat.com> +Patchwork-id: 57932 +O-Subject: [PATCH RHEL-7.0 qemu-kvm v2 1/2] qdev-monitor: set DeviceState opts before calling realize +Bugzilla: 1037956 +RH-Acked-by: Alex Williamson +RH-Acked-by: Michael S. Tsirkin +RH-Acked-by: Marcel Apfelbaum + +Setting opts before the realize property is set allows the +following patch to make decisions based on whether the user +specified "rombar". This also avoids having to create a new +tristate property especially for this purpose + +Reviewed-by: Andreas Färber +Signed-off-by: Bandan Das +Signed-off-by: Alex Williamson +(cherry picked from commit 52aa17cbd800b9e71b67cf7f80c3498183d34ec8) +--- + qdev-monitor.c | 4 +++- + 1 file changed, 3 insertions(+), 1 deletion(-) + +Signed-off-by: Miroslav Rezanina +--- + qdev-monitor.c | 4 +++- + 1 files changed, 3 insertions(+), 1 deletions(-) + +diff --git a/qdev-monitor.c b/qdev-monitor.c +index ac65a10..d7b9f04 100644 +--- a/qdev-monitor.c ++++ b/qdev-monitor.c +@@ -548,16 +548,18 @@ DeviceState *qdev_device_add(QemuOpts *opts) + OBJECT(dev), NULL); + g_free(name); + } ++ ++ dev->opts = opts; + object_property_set_bool(OBJECT(dev), true, "realized", &err); + if (err != NULL) { + qerror_report_err(err); + error_free(err); ++ dev->opts = NULL; + object_unparent(OBJECT(dev)); + object_unref(OBJECT(dev)); + qerror_report(QERR_DEVICE_INIT_FAILED, driver); + return NULL; + } +- dev->opts = opts; + return dev; + } + +-- +1.7.1 + diff --git a/SOURCES/kvm-qdev-monitor-test-add-device_add-leak-test-cases.patch b/SOURCES/kvm-qdev-monitor-test-add-device_add-leak-test-cases.patch new file mode 100644 index 0000000..fd09d36 --- /dev/null +++ b/SOURCES/kvm-qdev-monitor-test-add-device_add-leak-test-cases.patch @@ -0,0 +1,154 @@ +From e1cfab2e4723088d7fb011c1deda763c03682f81 Mon Sep 17 00:00:00 2001 +Message-Id: +In-Reply-To: <527da6c2ce2c09d0183aa8595fc95f136f61b6df.1387288155.git.minovotn@redhat.com> +References: <527da6c2ce2c09d0183aa8595fc95f136f61b6df.1387288155.git.minovotn@redhat.com> +From: Stefan Hajnoczi +Date: Thu, 12 Dec 2013 16:21:27 +0100 +Subject: [PATCH 7/8] qdev-monitor-test: add device_add leak test cases + +RH-Author: Stefan Hajnoczi +Message-id: <1386865288-1575-8-git-send-email-stefanha@redhat.com> +Patchwork-id: 56261 +O-Subject: [RHEL7 qemu-kvm PATCH 7/8] qdev-monitor-test: add device_add leak test cases +Bugzilla: 1003773 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Jeffrey Cody +RH-Acked-by: Markus Armbruster + +Ensure that the device_add error code path deletes device objects. +Failure to do so not only leaks the objects but can also keep other +objects (like drive or netdev) alive due to qdev properties holding +references. + +Signed-off-by: Stefan Hajnoczi +Reviewed-by: Eric Blake +(cherry picked from commit 43cd209803d6cffb1e1a028c9ff2fd0ff4fce954) +Signed-off-by: Stefan Hajnoczi + +Conflicts: + tests/Makefile + +Makefile diff context conflict. +--- + tests/Makefile | 2 ++ + tests/qdev-monitor-test.c | 81 +++++++++++++++++++++++++++++++++++++++++++++++ + 2 files changed, 83 insertions(+) + create mode 100644 tests/qdev-monitor-test.c + +Signed-off-by: Michal Novotny +--- + tests/Makefile | 2 ++ + tests/qdev-monitor-test.c | 81 +++++++++++++++++++++++++++++++++++++++++++++++ + 2 files changed, 83 insertions(+) + create mode 100644 tests/qdev-monitor-test.c + +diff --git a/tests/Makefile b/tests/Makefile +index 91231e8..2e9093e 100644 +--- a/tests/Makefile ++++ b/tests/Makefile +@@ -59,6 +59,7 @@ check-qtest-i386-y += tests/rtc-test$(EXESUF) + check-qtest-i386-y += tests/i440fx-test$(EXESUF) + check-qtest-i386-y += tests/fw_cfg-test$(EXESUF) + check-qtest-i386-y += tests/blockdev-test$(EXESUF) ++check-qtest-i386-y += tests/qdev-monitor-test$(EXESUF) + check-qtest-x86_64-y = $(check-qtest-i386-y) + gcov-files-i386-y += i386-softmmu/hw/mc146818rtc.c + gcov-files-x86_64-y = $(subst i386-softmmu/,x86_64-softmmu/,$(gcov-files-i386-y)) +@@ -137,6 +138,7 @@ tests/tmp105-test$(EXESUF): tests/tmp105-test.o $(libqos-omap-obj-y) + tests/i440fx-test$(EXESUF): tests/i440fx-test.o $(libqos-pc-obj-y) + tests/fw_cfg-test$(EXESUF): tests/fw_cfg-test.o $(libqos-pc-obj-y) + tests/blockdev-test$(EXESUF): tests/blockdev-test.o $(libqos-pc-obj-y) ++tests/qdev-monitor-test$(EXESUF): tests/qdev-monitor-test.o $(libqos-pc-obj-y) + + # QTest rules + +diff --git a/tests/qdev-monitor-test.c b/tests/qdev-monitor-test.c +new file mode 100644 +index 0000000..33a8ea4 +--- /dev/null ++++ b/tests/qdev-monitor-test.c +@@ -0,0 +1,81 @@ ++/* ++ * qdev-monitor.c test cases ++ * ++ * Copyright (C) 2013 Red Hat Inc. ++ * ++ * Authors: ++ * Stefan Hajnoczi ++ * ++ * This work is licensed under the terms of the GNU LGPL, version 2.1 or later. ++ * See the COPYING.LIB file in the top-level directory. ++ */ ++ ++#include ++#include ++#include "libqtest.h" ++#include "qapi/qmp/qjson.h" ++ ++static void test_device_add(void) ++{ ++ QDict *response; ++ QDict *error; ++ ++ qtest_start("-drive if=none,id=drive0"); ++ ++ /* Make device_add fail. If this leaks the virtio-blk-pci device then a ++ * reference to drive0 will also be held (via qdev properties). ++ */ ++ response = qmp("{\"execute\": \"device_add\"," ++ " \"arguments\": {" ++ " \"driver\": \"virtio-blk-pci\"," ++ " \"drive\": \"drive0\"" ++ "}}"); ++ g_assert(response); ++ error = qdict_get_qdict(response, "error"); ++ g_assert(!strcmp(qdict_get_try_str(error, "class") ?: "", ++ "GenericError")); ++ g_assert(!strcmp(qdict_get_try_str(error, "desc") ?: "", ++ "Device initialization failed.")); ++ QDECREF(response); ++ ++ /* Delete the drive */ ++ response = qmp("{\"execute\": \"human-monitor-command\"," ++ " \"arguments\": {" ++ " \"command-line\": \"drive_del drive0\"" ++ "}}"); ++ g_assert(response); ++ g_assert(!strcmp(qdict_get_try_str(response, "return") ?: "(null)", "")); ++ QDECREF(response); ++ ++ /* Try to re-add the drive. This fails with duplicate IDs if a leaked ++ * virtio-blk-pci exists that holds a reference to the old drive0. ++ */ ++ response = qmp("{\"execute\": \"human-monitor-command\"," ++ " \"arguments\": {" ++ " \"command-line\": \"drive_add pci-addr=auto if=none,id=drive0\"" ++ "}}"); ++ g_assert(response); ++ g_assert(!strcmp(qdict_get_try_str(response, "return") ?: "", ++ "OK\r\n")); ++ QDECREF(response); ++ ++ qtest_end(); ++} ++ ++int main(int argc, char **argv) ++{ ++ const char *arch = qtest_get_arch(); ++ ++ /* Check architecture */ ++ if (strcmp(arch, "i386") && strcmp(arch, "x86_64")) { ++ g_test_message("Skipping test for non-x86\n"); ++ return 0; ++ } ++ ++ /* Run the tests */ ++ g_test_init(&argc, &argv, NULL); ++ ++ qtest_add_func("/qmp/device_add", test_device_add); ++ ++ return g_test_run(); ++} +-- +1.7.11.7 + diff --git a/SOURCES/kvm-qemu-img-Allow-o-help-with-incomplete-argument-list.patch b/SOURCES/kvm-qemu-img-Allow-o-help-with-incomplete-argument-list.patch new file mode 100644 index 0000000..57e3b76 --- /dev/null +++ b/SOURCES/kvm-qemu-img-Allow-o-help-with-incomplete-argument-list.patch @@ -0,0 +1,160 @@ +From e8f877d31ff4ffbd7c09744f7244b21c728281be Mon Sep 17 00:00:00 2001 +From: Kevin Wolf +Date: Tue, 25 Feb 2014 15:00:04 +0100 +Subject: [PATCH 6/7] qemu-img: Allow -o help with incomplete argument list + +RH-Author: Kevin Wolf +Message-id: <1393340405-9936-6-git-send-email-kwolf@redhat.com> +Patchwork-id: 57796 +O-Subject: [RHEL-7.0 qemu-kvm PATCH 5/6] qemu-img: Allow -o help with incomplete argument list +Bugzilla: 1065873 +RH-Acked-by: Juan Quintela +RH-Acked-by: Fam Zheng +RH-Acked-by: Miroslav Rezanina + +This patch allows using 'qemu-img $subcmd -o help' for the create, +convert and amend subcommands, without specifying the previously +required filename arguments. + +Note that it's still allowed and meaningful to specify a filename: An +invocation like 'qemu-img create -o help sheepdog:foo' will also display +options that are provided by the Sheepdog driver. + +Signed-off-by: Kevin Wolf +Reviewed-by: Jeff Cody +Reviewed-by: Eric Blake +(cherry picked from commit a283cb6e58fca846c658360971d23fdd1129db65) + +Signed-off-by: Kevin Wolf +--- + qemu-img.c | 58 +++++++++++++++++++++++++++++++++++----------------------- + 1 file changed, 35 insertions(+), 23 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + qemu-img.c | 58 +++++++++++++++++++++++++++++++++++----------------------- + 1 files changed, 35 insertions(+), 23 deletions(-) + +diff --git a/qemu-img.c b/qemu-img.c +index 5002a56..3dc325e 100644 +--- a/qemu-img.c ++++ b/qemu-img.c +@@ -244,16 +244,19 @@ static int print_block_option_help(const char *filename, const char *fmt) + return 1; + } + +- proto_drv = bdrv_find_protocol(filename, true); +- if (!proto_drv) { +- error_report("Unknown protocol '%s'", filename); +- return 1; +- } +- + create_options = append_option_parameters(create_options, + drv->create_options); +- create_options = append_option_parameters(create_options, +- proto_drv->create_options); ++ ++ if (filename) { ++ proto_drv = bdrv_find_protocol(filename, true); ++ if (!proto_drv) { ++ error_report("Unknown protocol '%s'", filename); ++ return 1; ++ } ++ create_options = append_option_parameters(create_options, ++ proto_drv->create_options); ++ } ++ + print_option_help(create_options); + free_option_parameters(create_options); + return 0; +@@ -390,10 +393,16 @@ static int img_create(int argc, char **argv) + } + + /* Get the filename */ ++ filename = (optind < argc) ? argv[optind] : NULL; ++ if (options && has_help_option(options)) { ++ g_free(options); ++ return print_block_option_help(filename, fmt); ++ } ++ + if (optind >= argc) { + help(); + } +- filename = argv[optind++]; ++ optind++; + + /* Get image size, if specified */ + if (optind < argc) { +@@ -416,11 +425,6 @@ static int img_create(int argc, char **argv) + help(); + } + +- if (options && has_help_option(options)) { +- g_free(options); +- return print_block_option_help(filename, fmt); +- } +- + bdrv_img_create(filename, fmt, base_filename, base_fmt, + options, img_size, BDRV_O_FLAGS, &local_err, quiet); + if (error_is_set(&local_err)) { +@@ -1251,17 +1255,18 @@ static int img_convert(int argc, char **argv) + } + + bs_n = argc - optind - 1; +- if (bs_n < 1) { +- help(); +- } +- +- out_filename = argv[argc - 1]; ++ out_filename = bs_n >= 1 ? argv[argc - 1] : NULL; + + if (options && has_help_option(options)) { + ret = print_block_option_help(out_filename, out_fmt); + goto out; + } + ++ if (bs_n < 1) { ++ help(); ++ } ++ ++ + if (bs_n > 1 && out_baseimg) { + error_report("-B makes no sense when concatenating multiple input " + "images"); +@@ -2639,15 +2644,21 @@ static int img_amend(int argc, char **argv) + } + } + +- if (optind != argc - 1) { ++ if (!options) { + help(); + } + +- if (!options) { +- help(); ++ filename = (optind == argc - 1) ? argv[argc - 1] : NULL; ++ if (fmt && has_help_option(options)) { ++ /* If a format is explicitly specified (and possibly no filename is ++ * given), print option help here */ ++ ret = print_block_option_help(filename, fmt); ++ goto out; + } + +- filename = argv[argc - 1]; ++ if (optind != argc - 1) { ++ help(); ++ } + + bs = bdrv_new_open(filename, fmt, BDRV_O_FLAGS | BDRV_O_RDWR, true, quiet); + if (!bs) { +@@ -2659,6 +2670,7 @@ static int img_amend(int argc, char **argv) + fmt = bs->drv->format_name; + + if (has_help_option(options)) { ++ /* If the format was auto-detected, print option help here */ + ret = print_block_option_help(filename, fmt); + goto out; + } +-- +1.7.1 + diff --git a/SOURCES/kvm-qemu-img-add-support-for-fully-allocated-images.patch.patch.patch b/SOURCES/kvm-qemu-img-add-support-for-fully-allocated-images.patch.patch.patch new file mode 100644 index 0000000..845c632 --- /dev/null +++ b/SOURCES/kvm-qemu-img-add-support-for-fully-allocated-images.patch.patch.patch @@ -0,0 +1,81 @@ +From cf918fe08d1cf84f3825cea464c93278c647df52 Mon Sep 17 00:00:00 2001 +Message-Id: +In-Reply-To: +References: +From: Paolo Bonzini +Date: Mon, 9 Dec 2013 14:09:09 +0100 +Subject: [PATCH 21/50] qemu-img: add support for fully allocated images + +RH-Author: Paolo Bonzini +Message-id: <1386598178-11845-24-git-send-email-pbonzini@redhat.com> +Patchwork-id: 56060 +O-Subject: [RHEL 7.0 qemu-kvm PATCH 23/52] qemu-img: add support for fully allocated images +Bugzilla: 1007815 +RH-Acked-by: Jeffrey Cody +RH-Acked-by: Fam Zheng +RH-Acked-by: Stefan Hajnoczi + +From: Peter Lieven + +Signed-off-by: Peter Lieven +Signed-off-by: Stefan Hajnoczi +(cherry picked from commit 11b6699af59b8684128debacfc7c44cbaa6ac53b) +--- + qemu-img.c | 10 +++++++--- + qemu-img.texi | 6 ++++++ + 2 files changed, 13 insertions(+), 3 deletions(-) + +Signed-off-by: Michal Novotny +--- + qemu-img.c | 10 +++++++--- + qemu-img.texi | 6 ++++++ + 2 files changed, 13 insertions(+), 3 deletions(-) + +diff --git a/qemu-img.c b/qemu-img.c +index fa0fd0e..dfd8a92 100644 +--- a/qemu-img.c ++++ b/qemu-img.c +@@ -99,8 +99,12 @@ static void help(void) + " '-h' with or without a command shows this help and lists the supported formats\n" + " '-p' show progress of command (only certain commands)\n" + " '-q' use Quiet mode - do not print any output (except errors)\n" +- " '-S' indicates the consecutive number of bytes that must contain only zeros\n" +- " for qemu-img to create a sparse image during conversion\n" ++ " '-S' indicates the consecutive number of bytes (defaults to 4k) that must\n" ++ " contain only zeros for qemu-img to create a sparse image during\n" ++ " conversion. If the number of bytes is 0, the source will not be scanned for\n" ++ " unallocated or zero sectors, and the destination image will always be\n" ++ " fully allocated\n" ++ " images will always be fully allocated\n" + " '--output' takes the format in which the output must be done (human or json)\n" + " '-n' skips the target volume creation (useful if the volume is created\n" + " prior to running qemu-img)\n" +@@ -1463,7 +1467,7 @@ static int img_convert(int argc, char **argv) + /* signal EOF to align */ + bdrv_write_compressed(out_bs, 0, NULL, 0); + } else { +- int has_zero_init = bdrv_has_zero_init(out_bs); ++ int has_zero_init = min_sparse ? bdrv_has_zero_init(out_bs) : 0; + + sector_num = 0; // total number of sectors converted so far + nb_sectors = total_sectors - sector_num; +diff --git a/qemu-img.texi b/qemu-img.texi +index 43ee4eb..dc578bb 100644 +--- a/qemu-img.texi ++++ b/qemu-img.texi +@@ -193,6 +193,12 @@ Image conversion is also useful to get smaller image when using a + growable format such as @code{qcow} or @code{cow}: the empty sectors + are detected and suppressed from the destination image. + ++@var{sparse_size} indicates the consecutive number of bytes (defaults to 4k) ++that must contain only zeros for qemu-img to create a sparse image during ++conversion. If @var{sparse_size} is 0, the source will not be scanned for ++unallocated or zero sectors, and the destination image will always be ++fully allocated. ++ + You can use the @var{backing_file} option to force the output image to be + created as a copy on write image of the specified base image; the + @var{backing_file} should have the same content as the input's base image, +-- +1.7.11.7 + diff --git a/SOURCES/kvm-qemu-img-add-support-for-skipping-zeroes-in-input-du.patch.patch b/SOURCES/kvm-qemu-img-add-support-for-skipping-zeroes-in-input-du.patch.patch new file mode 100644 index 0000000..31e387a --- /dev/null +++ b/SOURCES/kvm-qemu-img-add-support-for-skipping-zeroes-in-input-du.patch.patch @@ -0,0 +1,201 @@ +From bd15ec3302904c9293bba0c1bac7225943b0e3fb Mon Sep 17 00:00:00 2001 +Message-Id: +In-Reply-To: +References: +From: Paolo Bonzini +Date: Mon, 9 Dec 2013 14:09:31 +0100 +Subject: [PATCH 43/50] qemu-img: add support for skipping zeroes in input + during convert + +RH-Author: Paolo Bonzini +Message-id: <1386598178-11845-46-git-send-email-pbonzini@redhat.com> +Patchwork-id: 56082 +O-Subject: [RHEL 7.0 qemu-kvm PATCH 45/52] qemu-img: add support for skipping zeroes in input during convert +Bugzilla: 1007815 +RH-Acked-by: Jeffrey Cody +RH-Acked-by: Fam Zheng +RH-Acked-by: Stefan Hajnoczi + +From: Peter Lieven + +we currently do not check if a sector is allocated during convert. +This means if a sector is unallocated that we allocate a bounce +buffer of zeroes, find out its zero later and do not write it +in the best case. In the worst case this can lead to reading +blocks from a raw device (like iSCSI) altough we could easily +know via get_block_status that they are zero and simply skip them. + +This patch also fixes the progress output not being at 100% after +a successful conversion. + +Signed-off-by: Peter Lieven +Reviewed-by: Paolo Bonzini +Signed-off-by: Stefan Hajnoczi +(cherry picked from commit 13c28af87a5541a9b09a59502b876a1725fb502d) +--- + qemu-img.c | 80 +++++++++++++++++++++++++++++++++----------------------------- + 1 file changed, 42 insertions(+), 38 deletions(-) + +Signed-off-by: Michal Novotny +--- + qemu-img.c | 80 +++++++++++++++++++++++++++++++++----------------------------- + 1 file changed, 42 insertions(+), 38 deletions(-) + +diff --git a/qemu-img.c b/qemu-img.c +index 3dacbec..a8e2d8c 100644 +--- a/qemu-img.c ++++ b/qemu-img.c +@@ -1123,13 +1123,15 @@ out3: + + static int img_convert(int argc, char **argv) + { +- int c, ret = 0, n, n1, bs_n, bs_i, compress, cluster_size, ++ int c, n, n1, bs_n, bs_i, compress, cluster_size, + cluster_sectors, skip_create; ++ int64_t ret = 0; + int progress = 0, flags; + const char *fmt, *out_fmt, *cache, *out_baseimg, *out_filename; + BlockDriver *drv, *proto_drv; + BlockDriverState **bs = NULL, *out_bs = NULL; +- int64_t total_sectors, nb_sectors, sector_num, bs_offset; ++ int64_t total_sectors, nb_sectors, sector_num, bs_offset, ++ sector_num_next_status = 0; + uint64_t bs_sectors; + uint8_t * buf = NULL; + const uint8_t *buf1; +@@ -1138,7 +1140,6 @@ static int img_convert(int argc, char **argv) + QEMUOptionParameter *out_baseimg_param; + char *options = NULL; + const char *snapshot_name = NULL; +- float local_progress = 0; + int min_sparse = 8; /* Need at least 4k of zeros for sparse detection */ + bool quiet = false; + Error *local_err = NULL; +@@ -1401,10 +1402,6 @@ static int img_convert(int argc, char **argv) + sector_num = 0; + + nb_sectors = total_sectors; +- if (nb_sectors != 0) { +- local_progress = (float)100 / +- (nb_sectors / MIN(nb_sectors, cluster_sectors)); +- } + + for(;;) { + int64_t bs_num; +@@ -1462,7 +1459,7 @@ static int img_convert(int argc, char **argv) + } + } + sector_num += n; +- qemu_progress_print(local_progress, 100); ++ qemu_progress_print(100.0 * sector_num / total_sectors, 0); + } + /* signal EOF to align */ + bdrv_write_compressed(out_bs, 0, NULL, 0); +@@ -1479,21 +1476,13 @@ static int img_convert(int argc, char **argv) + + sector_num = 0; // total number of sectors converted so far + nb_sectors = total_sectors - sector_num; +- if (nb_sectors != 0) { +- local_progress = (float)100 / +- (nb_sectors / MIN(nb_sectors, IO_BUF_SIZE / 512)); +- } + + for(;;) { + nb_sectors = total_sectors - sector_num; + if (nb_sectors <= 0) { ++ ret = 0; + break; + } +- if (nb_sectors >= (IO_BUF_SIZE / 512)) { +- n = (IO_BUF_SIZE / 512); +- } else { +- n = nb_sectors; +- } + + while (sector_num - bs_offset >= bs_sectors) { + bs_i ++; +@@ -1505,34 +1494,46 @@ static int img_convert(int argc, char **argv) + sector_num, bs_i, bs_offset, bs_sectors); */ + } + +- if (n > bs_offset + bs_sectors - sector_num) { +- n = bs_offset + bs_sectors - sector_num; +- } +- +- /* If the output image is being created as a copy on write image, +- assume that sectors which are unallocated in the input image +- are present in both the output's and input's base images (no +- need to copy them). */ +- if (out_baseimg) { +- ret = bdrv_is_allocated(bs[bs_i], sector_num - bs_offset, +- n, &n1); ++ if ((out_baseimg || has_zero_init) && ++ sector_num >= sector_num_next_status) { ++ n = nb_sectors > INT_MAX ? INT_MAX : nb_sectors; ++ ret = bdrv_get_block_status(bs[bs_i], sector_num - bs_offset, ++ n, &n1); + if (ret < 0) { +- error_report("error while reading metadata for sector " +- "%" PRId64 ": %s", +- sector_num - bs_offset, strerror(-ret)); ++ error_report("error while reading block status of sector %" ++ PRId64 ": %s", sector_num - bs_offset, ++ strerror(-ret)); + goto out; + } +- if (!ret) { ++ /* If the output image is zero initialized, we are not working ++ * on a shared base and the input is zero we can skip the next ++ * n1 sectors */ ++ if (has_zero_init && !out_baseimg && (ret & BDRV_BLOCK_ZERO)) { + sector_num += n1; + continue; + } +- /* The next 'n1' sectors are allocated in the input image. Copy +- only those as they may be followed by unallocated sectors. */ +- n = n1; +- } else { +- n1 = n; ++ /* If the output image is being created as a copy on write ++ * image, assume that sectors which are unallocated in the ++ * input image are present in both the output's and input's ++ * base images (no need to copy them). */ ++ if (out_baseimg) { ++ if (!(ret & BDRV_BLOCK_DATA)) { ++ sector_num += n1; ++ continue; ++ } ++ /* The next 'n1' sectors are allocated in the input image. ++ * Copy only those as they may be followed by unallocated ++ * sectors. */ ++ nb_sectors = n1; ++ } ++ /* avoid redundant callouts to get_block_status */ ++ sector_num_next_status = sector_num + n1; + } + ++ n = MIN(nb_sectors, IO_BUF_SIZE / 512); ++ n = MIN(n, bs_sectors - (sector_num - bs_offset)); ++ n1 = n; ++ + ret = bdrv_read(bs[bs_i], sector_num - bs_offset, buf, n); + if (ret < 0) { + error_report("error while reading sector %" PRId64 ": %s", +@@ -1557,10 +1558,13 @@ static int img_convert(int argc, char **argv) + n -= n1; + buf1 += n1 * 512; + } +- qemu_progress_print(local_progress, 100); ++ qemu_progress_print(100.0 * sector_num / total_sectors, 0); + } + } + out: ++ if (!ret) { ++ qemu_progress_print(100, 0); ++ } + qemu_progress_end(); + free_option_parameters(create_options); + free_option_parameters(param); +-- +1.7.11.7 + diff --git a/SOURCES/kvm-qemu-img-amend-Support-multiple-o-options.patch b/SOURCES/kvm-qemu-img-amend-Support-multiple-o-options.patch new file mode 100644 index 0000000..0527e46 --- /dev/null +++ b/SOURCES/kvm-qemu-img-amend-Support-multiple-o-options.patch @@ -0,0 +1,78 @@ +From 867469aa337ac206ee6f4ea1b5c4c0f1ec36696d Mon Sep 17 00:00:00 2001 +From: Kevin Wolf +Date: Tue, 25 Feb 2014 15:00:03 +0100 +Subject: [PATCH 5/7] qemu-img amend: Support multiple -o options + +RH-Author: Kevin Wolf +Message-id: <1393340405-9936-5-git-send-email-kwolf@redhat.com> +Patchwork-id: 57794 +O-Subject: [RHEL-7.0 qemu-kvm PATCH 4/6] qemu-img amend: Support multiple -o options +Bugzilla: 1065873 +RH-Acked-by: Juan Quintela +RH-Acked-by: Fam Zheng +RH-Acked-by: Miroslav Rezanina + +Instead of ignoring all option values but the last one, multiple -o +options now have the same meaning as having a single option with all +settings in the order of their respective -o options. + +Signed-off-by: Kevin Wolf +Reviewed-by: Jeff Cody +Reviewed-by: Eric Blake +(cherry picked from commit 626f84f39d4ae365a44dbbc0d0dd3c7739c3971a) + +Signed-off-by: Kevin Wolf +--- + qemu-img.c | 17 +++++++++++++++-- + 1 file changed, 15 insertions(+), 2 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + qemu-img.c | 17 +++++++++++++++-- + 1 files changed, 15 insertions(+), 2 deletions(-) + +diff --git a/qemu-img.c b/qemu-img.c +index e7b12c2..5002a56 100644 +--- a/qemu-img.c ++++ b/qemu-img.c +@@ -2617,7 +2617,18 @@ static int img_amend(int argc, char **argv) + help(); + break; + case 'o': +- options = optarg; ++ if (!is_valid_option_list(optarg)) { ++ error_report("Invalid option list: %s", optarg); ++ ret = -1; ++ goto out; ++ } ++ if (!options) { ++ options = g_strdup(optarg); ++ } else { ++ char *old_options = options; ++ options = g_strdup_printf("%s,%s", options, optarg); ++ g_free(old_options); ++ } + break; + case 'f': + fmt = optarg; +@@ -2647,7 +2658,7 @@ static int img_amend(int argc, char **argv) + + fmt = bs->drv->format_name; + +- if (is_help_option(options)) { ++ if (has_help_option(options)) { + ret = print_block_option_help(filename, fmt); + goto out; + } +@@ -2674,6 +2685,8 @@ out: + } + free_option_parameters(create_options); + free_option_parameters(options_param); ++ g_free(options); ++ + if (ret) { + return 1; + } +-- +1.7.1 + diff --git a/SOURCES/kvm-qemu-img-conditionally-zero-out-target-on-convert.patch.patch.patch b/SOURCES/kvm-qemu-img-conditionally-zero-out-target-on-convert.patch.patch.patch new file mode 100644 index 0000000..75d7c6d --- /dev/null +++ b/SOURCES/kvm-qemu-img-conditionally-zero-out-target-on-convert.patch.patch.patch @@ -0,0 +1,69 @@ +From 33d075d8a2d5c6f22aaefb5fcfbee61e0c46586b Mon Sep 17 00:00:00 2001 +Message-Id: <33d075d8a2d5c6f22aaefb5fcfbee61e0c46586b.1389014116.git.minovotn@redhat.com> +In-Reply-To: +References: +From: Paolo Bonzini +Date: Mon, 9 Dec 2013 14:09:10 +0100 +Subject: [PATCH 22/50] qemu-img: conditionally zero out target on convert + +RH-Author: Paolo Bonzini +Message-id: <1386598178-11845-25-git-send-email-pbonzini@redhat.com> +Patchwork-id: 56061 +O-Subject: [RHEL 7.0 qemu-kvm PATCH 24/52] qemu-img: conditionally zero out target on convert +Bugzilla: 1007815 +RH-Acked-by: Jeffrey Cody +RH-Acked-by: Fam Zheng +RH-Acked-by: Stefan Hajnoczi + +From: Peter Lieven + +If the target has_zero_init = 0, but supports efficiently +writing zeroes by unmapping we call bdrv_make_zero to +avoid fully allocating the target. This currently works +only for iscsi. It can be extended to raw with +BLKDISCARDZEROES for example. + +Reviewed-by: Eric Blake +Signed-off-by: Peter Lieven +Signed-off-by: Stefan Hajnoczi +(cherry picked from commit 5a37b60a61c4c334e3b194758871f41494317d42) +--- + qemu-img.c | 10 +++++++++- + 1 file changed, 9 insertions(+), 1 deletion(-) + +Signed-off-by: Michal Novotny +--- + qemu-img.c | 10 +++++++++- + 1 file changed, 9 insertions(+), 1 deletion(-) + +diff --git a/qemu-img.c b/qemu-img.c +index dfd8a92..3dacbec 100644 +--- a/qemu-img.c ++++ b/qemu-img.c +@@ -1353,7 +1353,7 @@ static int img_convert(int argc, char **argv) + } + } + +- flags = BDRV_O_RDWR; ++ flags = min_sparse ? (BDRV_O_RDWR | BDRV_O_UNMAP) : BDRV_O_RDWR; + ret = bdrv_parse_cache_flags(cache, &flags); + if (ret < 0) { + error_report("Invalid cache option: %s", cache); +@@ -1469,6 +1469,14 @@ static int img_convert(int argc, char **argv) + } else { + int has_zero_init = min_sparse ? bdrv_has_zero_init(out_bs) : 0; + ++ if (!has_zero_init && bdrv_can_write_zeroes_with_unmap(out_bs)) { ++ ret = bdrv_make_zero(out_bs, BDRV_REQ_MAY_UNMAP); ++ if (ret < 0) { ++ goto out; ++ } ++ has_zero_init = 1; ++ } ++ + sector_num = 0; // total number of sectors converted so far + nb_sectors = total_sectors - sector_num; + if (nb_sectors != 0) { +-- +1.7.11.7 + diff --git a/SOURCES/kvm-qemu-img-convert-Fix-progress-output.patch b/SOURCES/kvm-qemu-img-convert-Fix-progress-output.patch new file mode 100644 index 0000000..cd01a8a --- /dev/null +++ b/SOURCES/kvm-qemu-img-convert-Fix-progress-output.patch @@ -0,0 +1,116 @@ +From b099e03cdfbf175bf8b2368b83348ca2359004c7 Mon Sep 17 00:00:00 2001 +From: Kevin Wolf +Date: Mon, 10 Mar 2014 10:33:22 +0100 +Subject: [PATCH 11/16] qemu-img convert: Fix progress output + +RH-Author: Kevin Wolf +Message-id: <1394447603-30527-2-git-send-email-kwolf@redhat.com> +Patchwork-id: 58060 +O-Subject: [RHEL-7.0 qemu-kvm PATCH 1/2] qemu-img convert: Fix progress output +Bugzilla: 1073728 +RH-Acked-by: Laszlo Ersek +RH-Acked-by: Max Reitz +RH-Acked-by: Jeffrey Cody +RH-Acked-by: Stefan Hajnoczi + +Initialise progress output only when the -p and -q options have already +been parsed, otherwise it's always disabled. + +Reported-by: Peter Lieven +Signed-off-by: Kevin Wolf +Reviewed-by: Eric Blake +(cherry picked from commit 64bb01aa35a24bea7ad0a1a8713991bab5020d12) + +Conflicts: + qemu-img.c + +Conflicts because RHEL 7 doesn't support -l in qemu-img convert. + +Signed-off-by: Kevin Wolf +--- + qemu-img.c | 18 ++++++++++-------- + 1 file changed, 10 insertions(+), 8 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + qemu-img.c | 18 ++++++++++-------- + 1 files changed, 10 insertions(+), 8 deletions(-) + +diff --git a/qemu-img.c b/qemu-img.c +index 3dc325e..dcce380 100644 +--- a/qemu-img.c ++++ b/qemu-img.c +@@ -1163,9 +1163,6 @@ static int img_convert(int argc, char **argv) + bool quiet = false; + Error *local_err = NULL; + +- /* Initialize before goto out */ +- qemu_progress_init(progress, 1.0); +- + fmt = NULL; + out_fmt = "raw"; + cache = "unsafe"; +@@ -1198,17 +1195,17 @@ static int img_convert(int argc, char **argv) + error_report("option -e is deprecated, please use \'-o " + "encryption\' instead!"); + ret = -1; +- goto out; ++ goto fail_getopt; + case '6': + error_report("option -6 is deprecated, please use \'-o " + "compat6\' instead!"); + ret = -1; +- goto out; ++ goto fail_getopt; + case 'o': + if (!is_valid_option_list(optarg)) { + error_report("Invalid option list: %s", optarg); + ret = -1; +- goto out; ++ goto fail_getopt; + } + if (!options) { + options = g_strdup(optarg); +@@ -1229,7 +1226,7 @@ static int img_convert(int argc, char **argv) + if (sval < 0 || *end) { + error_report("Invalid minimum zero buffer size for sparse output specified"); + ret = -1; +- goto out; ++ goto fail_getopt; + } + + min_sparse = sval / BDRV_SECTOR_SIZE; +@@ -1250,9 +1247,12 @@ static int img_convert(int argc, char **argv) + } + } + ++ /* Initialize before goto out */ + if (quiet) { + progress = 0; + } ++ qemu_progress_init(progress, 1.0); ++ + + bs_n = argc - optind - 1; + out_filename = bs_n >= 1 ? argv[argc - 1] : NULL; +@@ -1629,7 +1629,6 @@ out: + free_option_parameters(create_options); + free_option_parameters(param); + qemu_vfree(buf); +- g_free(options); + if (out_bs) { + bdrv_unref(out_bs); + } +@@ -1641,6 +1640,9 @@ out: + } + g_free(bs); + } ++fail_getopt: ++ g_free(options); ++ + if (ret) { + return 1; + } +-- +1.7.1 + diff --git a/SOURCES/kvm-qemu-img-convert-Support-multiple-o-options.patch b/SOURCES/kvm-qemu-img-convert-Support-multiple-o-options.patch new file mode 100644 index 0000000..6e70abc --- /dev/null +++ b/SOURCES/kvm-qemu-img-convert-Support-multiple-o-options.patch @@ -0,0 +1,115 @@ +From a20760c046f133055cedaba6952f49758e0d9cbf Mon Sep 17 00:00:00 2001 +From: Kevin Wolf +Date: Tue, 25 Feb 2014 15:00:02 +0100 +Subject: [PATCH 4/7] qemu-img convert: Support multiple -o options + +RH-Author: Kevin Wolf +Message-id: <1393340405-9936-4-git-send-email-kwolf@redhat.com> +Patchwork-id: 57799 +O-Subject: [RHEL-7.0 qemu-kvm PATCH 3/6] qemu-img convert: Support multiple -o options +Bugzilla: 1065873 +RH-Acked-by: Juan Quintela +RH-Acked-by: Fam Zheng +RH-Acked-by: Miroslav Rezanina + +Instead of ignoring all option values but the last one, multiple -o +options now have the same meaning as having a single option with all +settings in the order of their respective -o options. + +Signed-off-by: Kevin Wolf +Reviewed-by: Jeff Cody +Reviewed-by: Eric Blake +(cherry picked from commit 2dc8328b4c6aba60f4ad543186f4e8aec2e9287e) + +Conflicts: + qemu-img.c + +Conflicts because qemu-img convert doesn't have an -l option in RHEL 7. + +Signed-off-by: Kevin Wolf +--- + qemu-img.c | 31 +++++++++++++++++++++++-------- + 1 file changed, 23 insertions(+), 8 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + qemu-img.c | 31 +++++++++++++++++++++++-------- + 1 files changed, 23 insertions(+), 8 deletions(-) + +diff --git a/qemu-img.c b/qemu-img.c +index 12bf996..e7b12c2 100644 +--- a/qemu-img.c ++++ b/qemu-img.c +@@ -1159,6 +1159,9 @@ static int img_convert(int argc, char **argv) + bool quiet = false; + Error *local_err = NULL; + ++ /* Initialize before goto out */ ++ qemu_progress_init(progress, 1.0); ++ + fmt = NULL; + out_fmt = "raw"; + cache = "unsafe"; +@@ -1190,13 +1193,26 @@ static int img_convert(int argc, char **argv) + case 'e': + error_report("option -e is deprecated, please use \'-o " + "encryption\' instead!"); +- return 1; ++ ret = -1; ++ goto out; + case '6': + error_report("option -6 is deprecated, please use \'-o " + "compat6\' instead!"); +- return 1; ++ ret = -1; ++ goto out; + case 'o': +- options = optarg; ++ if (!is_valid_option_list(optarg)) { ++ error_report("Invalid option list: %s", optarg); ++ ret = -1; ++ goto out; ++ } ++ if (!options) { ++ options = g_strdup(optarg); ++ } else { ++ char *old_options = options; ++ options = g_strdup_printf("%s,%s", options, optarg); ++ g_free(old_options); ++ } + break; + case 's': + snapshot_name = optarg; +@@ -1208,7 +1224,8 @@ static int img_convert(int argc, char **argv) + sval = strtosz_suffix(optarg, &end, STRTOSZ_DEFSUFFIX_B); + if (sval < 0 || *end) { + error_report("Invalid minimum zero buffer size for sparse output specified"); +- return 1; ++ ret = -1; ++ goto out; + } + + min_sparse = sval / BDRV_SECTOR_SIZE; +@@ -1240,10 +1257,7 @@ static int img_convert(int argc, char **argv) + + out_filename = argv[argc - 1]; + +- /* Initialize before goto out */ +- qemu_progress_init(progress, 1.0); +- +- if (options && is_help_option(options)) { ++ if (options && has_help_option(options)) { + ret = print_block_option_help(out_filename, out_fmt); + goto out; + } +@@ -1610,6 +1624,7 @@ out: + free_option_parameters(create_options); + free_option_parameters(param); + qemu_vfree(buf); ++ g_free(options); + if (out_bs) { + bdrv_unref(out_bs); + } +-- +1.7.1 + diff --git a/SOURCES/kvm-qemu-img-create-Support-multiple-o-options.patch b/SOURCES/kvm-qemu-img-create-Support-multiple-o-options.patch new file mode 100644 index 0000000..867b820 --- /dev/null +++ b/SOURCES/kvm-qemu-img-create-Support-multiple-o-options.patch @@ -0,0 +1,105 @@ +From 6814f2b17eecd9ab6fde0fc38450632cae930a94 Mon Sep 17 00:00:00 2001 +From: Kevin Wolf +Date: Tue, 25 Feb 2014 15:00:01 +0100 +Subject: [PATCH 3/7] qemu-img create: Support multiple -o options + +RH-Author: Kevin Wolf +Message-id: <1393340405-9936-3-git-send-email-kwolf@redhat.com> +Patchwork-id: 57797 +O-Subject: [RHEL-7.0 qemu-kvm PATCH 2/6] qemu-img create: Support multiple -o options +Bugzilla: 1065873 +RH-Acked-by: Juan Quintela +RH-Acked-by: Fam Zheng +RH-Acked-by: Miroslav Rezanina + +If you specified multiple -o options for qemu-img create, it would +silently ignore all but the last one. This patch fixes the problem. + +Now multiple -o options has the same meaning as having a single option +with all settings in the order of their respective -o options. + +Signed-off-by: Kevin Wolf +Reviewed-by: Jeff Cody +Reviewed-by: Eric Blake +(cherry picked from commit 77386bf6ebe67164a2d102b207fb3bc11af8c1e8) + +Signed-off-by: Kevin Wolf +--- + qemu-img.c | 28 ++++++++++++++++++++++------ + 1 file changed, 22 insertions(+), 6 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + qemu-img.c | 28 ++++++++++++++++++++++------ + 1 files changed, 22 insertions(+), 6 deletions(-) + +diff --git a/qemu-img.c b/qemu-img.c +index bc48dc1..12bf996 100644 +--- a/qemu-img.c ++++ b/qemu-img.c +@@ -365,13 +365,23 @@ static int img_create(int argc, char **argv) + case 'e': + error_report("option -e is deprecated, please use \'-o " + "encryption\' instead!"); +- return 1; ++ goto fail; + case '6': + error_report("option -6 is deprecated, please use \'-o " + "compat6\' instead!"); +- return 1; ++ goto fail; + case 'o': +- options = optarg; ++ if (!is_valid_option_list(optarg)) { ++ error_report("Invalid option list: %s", optarg); ++ goto fail; ++ } ++ if (!options) { ++ options = g_strdup(optarg); ++ } else { ++ char *old_options = options; ++ options = g_strdup_printf("%s,%s", options, optarg); ++ g_free(old_options); ++ } + break; + case 'q': + quiet = true; +@@ -398,7 +408,7 @@ static int img_create(int argc, char **argv) + "G or T suffixes for "); + error_report("kilobytes, megabytes, gigabytes and terabytes."); + } +- return 1; ++ goto fail; + } + img_size = (uint64_t)sval; + } +@@ -406,7 +416,8 @@ static int img_create(int argc, char **argv) + help(); + } + +- if (options && is_help_option(options)) { ++ if (options && has_help_option(options)) { ++ g_free(options); + return print_block_option_help(filename, fmt); + } + +@@ -415,10 +426,15 @@ static int img_create(int argc, char **argv) + if (error_is_set(&local_err)) { + error_report("%s: %s", filename, error_get_pretty(local_err)); + error_free(local_err); +- return 1; ++ goto fail; + } + ++ g_free(options); + return 0; ++ ++fail: ++ g_free(options); ++ return 1; + } + + static void dump_json_image_check(ImageCheck *check, bool quiet) +-- +1.7.1 + diff --git a/SOURCES/kvm-qemu-img-decrease-progress-update-interval-on-conver.patch.patch b/SOURCES/kvm-qemu-img-decrease-progress-update-interval-on-conver.patch.patch new file mode 100644 index 0000000..47adbad --- /dev/null +++ b/SOURCES/kvm-qemu-img-decrease-progress-update-interval-on-conver.patch.patch @@ -0,0 +1,50 @@ +From e81aa6e8c41c14f1ff46dfe7085174bc8331fbe1 Mon Sep 17 00:00:00 2001 +Message-Id: +In-Reply-To: +References: +From: Paolo Bonzini +Date: Mon, 9 Dec 2013 14:09:38 +0100 +Subject: [PATCH 50/50] qemu-img: decrease progress update interval on convert + +RH-Author: Paolo Bonzini +Message-id: <1386598178-11845-53-git-send-email-pbonzini@redhat.com> +Patchwork-id: 56089 +O-Subject: [RHEL 7.0 qemu-kvm PATCH 52/52] qemu-img: decrease progress update interval on convert +Bugzilla: 1039557 +RH-Acked-by: Jeffrey Cody +RH-Acked-by: Fam Zheng +RH-Acked-by: Stefan Hajnoczi + +From: Peter Lieven + +when doing very large jobs updating the progress only every 2% +is too rare. + +Signed-off-by: Peter Lieven +Signed-off-by: Stefan Hajnoczi +(cherry picked from commit 405889820bcd5c2abf4eb70598e96f525f862c0f) +--- + qemu-img.c | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +Signed-off-by: Michal Novotny +--- + qemu-img.c | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/qemu-img.c b/qemu-img.c +index 55bb82c..1fe175b 100644 +--- a/qemu-img.c ++++ b/qemu-img.c +@@ -1225,7 +1225,7 @@ static int img_convert(int argc, char **argv) + out_filename = argv[argc - 1]; + + /* Initialize before goto out */ +- qemu_progress_init(progress, 2.0); ++ qemu_progress_init(progress, 1.0); + + if (options && is_help_option(options)) { + ret = print_block_option_help(out_filename, out_fmt); +-- +1.7.11.7 + diff --git a/SOURCES/kvm-qemu-img-dynamically-adjust-iobuffer-size-during-con.patch.patch b/SOURCES/kvm-qemu-img-dynamically-adjust-iobuffer-size-during-con.patch.patch new file mode 100644 index 0000000..4db8e9a --- /dev/null +++ b/SOURCES/kvm-qemu-img-dynamically-adjust-iobuffer-size-during-con.patch.patch @@ -0,0 +1,92 @@ +From ba5bef1bb19b97c88b2e99071ffab067b7f3b9d3 Mon Sep 17 00:00:00 2001 +Message-Id: +In-Reply-To: +References: +From: Paolo Bonzini +Date: Mon, 9 Dec 2013 14:09:36 +0100 +Subject: [PATCH 48/50] qemu-img: dynamically adjust iobuffer size during + convert + +RH-Author: Paolo Bonzini +Message-id: <1386598178-11845-51-git-send-email-pbonzini@redhat.com> +Patchwork-id: 56087 +O-Subject: [RHEL 7.0 qemu-kvm PATCH 50/52] qemu-img: dynamically adjust iobuffer size during convert +Bugzilla: 1039557 +RH-Acked-by: Jeffrey Cody +RH-Acked-by: Fam Zheng +RH-Acked-by: Stefan Hajnoczi + +From: Peter Lieven + +since the convert process is basically a sync operation it might +be benificial in some case to change the hardcoded I/O buffer +size to a greater value. + +This patch increases the I/O buffer size if the output +driver advertises an optimal transfer length or discard alignment +that is greater than the default buffer size of 2M. + +Reviewed-by: Paolo Bonzini +Signed-off-by: Peter Lieven +Signed-off-by: Stefan Hajnoczi +(cherry picked from commit f2521c9023067a007d18b844fe7639c1c5b6f2ac) +--- + qemu-img.c | 16 +++++++++++++--- + 1 file changed, 13 insertions(+), 3 deletions(-) + +Signed-off-by: Michal Novotny +--- + qemu-img.c | 16 +++++++++++++--- + 1 file changed, 13 insertions(+), 3 deletions(-) + +diff --git a/qemu-img.c b/qemu-img.c +index c81d70a..6890bb1 100644 +--- a/qemu-img.c ++++ b/qemu-img.c +@@ -1133,6 +1133,7 @@ static int img_convert(int argc, char **argv) + sector_num_next_status = 0; + uint64_t bs_sectors; + uint8_t * buf = NULL; ++ size_t bufsectors = IO_BUF_SIZE / BDRV_SECTOR_SIZE; + const uint8_t *buf1; + BlockDriverInfo bdi; + QEMUOptionParameter *param = NULL, *create_options = NULL; +@@ -1369,7 +1370,16 @@ static int img_convert(int argc, char **argv) + bs_i = 0; + bs_offset = 0; + bdrv_get_geometry(bs[0], &bs_sectors); +- buf = qemu_blockalign(out_bs, IO_BUF_SIZE); ++ ++ /* increase bufsectors from the default 4096 (2M) if opt_transfer_length ++ * or discard_alignment of the out_bs is greater. Limit to 32768 (16MB) ++ * as maximum. */ ++ bufsectors = MIN(32768, ++ MAX(bufsectors, MAX(out_bs->bl.opt_transfer_length, ++ out_bs->bl.discard_alignment)) ++ ); ++ ++ buf = qemu_blockalign(out_bs, bufsectors * BDRV_SECTOR_SIZE); + + if (skip_create) { + int64_t output_length = bdrv_getlength(out_bs); +@@ -1392,7 +1402,7 @@ static int img_convert(int argc, char **argv) + goto out; + } + cluster_size = bdi.cluster_size; +- if (cluster_size <= 0 || cluster_size > IO_BUF_SIZE) { ++ if (cluster_size <= 0 || cluster_size > bufsectors * BDRV_SECTOR_SIZE) { + error_report("invalid cluster size"); + ret = -1; + goto out; +@@ -1529,7 +1539,7 @@ static int img_convert(int argc, char **argv) + sector_num_next_status = sector_num + n1; + } + +- n = MIN(nb_sectors, IO_BUF_SIZE / 512); ++ n = MIN(nb_sectors, bufsectors); + n = MIN(n, bs_sectors - (sector_num - bs_offset)); + n1 = n; + +-- +1.7.11.7 + diff --git a/SOURCES/kvm-qemu-img-fix-usage-instruction-for-qemu-img-convert.patch.patch b/SOURCES/kvm-qemu-img-fix-usage-instruction-for-qemu-img-convert.patch.patch new file mode 100644 index 0000000..80ade64 --- /dev/null +++ b/SOURCES/kvm-qemu-img-fix-usage-instruction-for-qemu-img-convert.patch.patch @@ -0,0 +1,48 @@ +From d539424eccda7109d56332b2091863ff694a095d Mon Sep 17 00:00:00 2001 +Message-Id: +In-Reply-To: +References: +From: Paolo Bonzini +Date: Mon, 9 Dec 2013 14:09:32 +0100 +Subject: [PATCH 44/50] qemu-img: fix usage instruction for qemu-img convert + +RH-Author: Paolo Bonzini +Message-id: <1386598178-11845-47-git-send-email-pbonzini@redhat.com> +Patchwork-id: 56084 +O-Subject: [RHEL 7.0 qemu-kvm PATCH 46/52] qemu-img: fix usage instruction for qemu-img convert +Bugzilla: 1007815 +RH-Acked-by: Jeffrey Cody +RH-Acked-by: Fam Zheng +RH-Acked-by: Stefan Hajnoczi + +From: Peter Lieven + +Reviewed-by: Eric Blake +Reviewed-by: Paolo Bonzini +Signed-off-by: Peter Lieven +Signed-off-by: Stefan Hajnoczi +(cherry picked from commit 049b09825fe479f4caa013ccde0ff87fc9d82856) +--- + qemu-img.c | 1 - + 1 file changed, 1 deletion(-) + +Signed-off-by: Michal Novotny +--- + qemu-img.c | 1 - + 1 file changed, 1 deletion(-) + +diff --git a/qemu-img.c b/qemu-img.c +index a8e2d8c..c81d70a 100644 +--- a/qemu-img.c ++++ b/qemu-img.c +@@ -104,7 +104,6 @@ static void help(void) + " conversion. If the number of bytes is 0, the source will not be scanned for\n" + " unallocated or zero sectors, and the destination image will always be\n" + " fully allocated\n" +- " images will always be fully allocated\n" + " '--output' takes the format in which the output must be done (human or json)\n" + " '-n' skips the target volume creation (useful if the volume is created\n" + " prior to running qemu-img)\n" +-- +1.7.11.7 + diff --git a/SOURCES/kvm-qemu-img-round-down-request-length-to-an-aligned-sec.patch.patch b/SOURCES/kvm-qemu-img-round-down-request-length-to-an-aligned-sec.patch.patch new file mode 100644 index 0000000..a5da861 --- /dev/null +++ b/SOURCES/kvm-qemu-img-round-down-request-length-to-an-aligned-sec.patch.patch @@ -0,0 +1,107 @@ +From 070f95bad47e0d0f1884b93184369b3c9322cd4c Mon Sep 17 00:00:00 2001 +Message-Id: <070f95bad47e0d0f1884b93184369b3c9322cd4c.1389014116.git.minovotn@redhat.com> +In-Reply-To: +References: +From: Paolo Bonzini +Date: Mon, 9 Dec 2013 14:09:37 +0100 +Subject: [PATCH 49/50] qemu-img: round down request length to an aligned + sector + +RH-Author: Paolo Bonzini +Message-id: <1386598178-11845-52-git-send-email-pbonzini@redhat.com> +Patchwork-id: 56088 +O-Subject: [RHEL 7.0 qemu-kvm PATCH 51/52] qemu-img: round down request length to an aligned sector +Bugzilla: 1039557 +RH-Acked-by: Jeffrey Cody +RH-Acked-by: Fam Zheng +RH-Acked-by: Stefan Hajnoczi + +From: Peter Lieven + +this patch shortens requests to end at an aligned sector so that +the next request starts aligned. + +[Squashed Peter's fix for bdrv_get_info() failure discussed on the +mailing list. +--Stefan] + +Reviewed-by: Paolo Bonzini +Signed-off-by: Peter Lieven +Signed-off-by: Stefan Hajnoczi +(cherry picked from commit 24f833cd43dbfb5f8ae99e8a6d3691671622d3ea) +--- + qemu-img.c | 32 ++++++++++++++++++++++++-------- + 1 file changed, 24 insertions(+), 8 deletions(-) + +Signed-off-by: Michal Novotny +--- + qemu-img.c | 32 ++++++++++++++++++++++++-------- + 1 file changed, 24 insertions(+), 8 deletions(-) + +diff --git a/qemu-img.c b/qemu-img.c +index 6890bb1..55bb82c 100644 +--- a/qemu-img.c ++++ b/qemu-img.c +@@ -1122,8 +1122,7 @@ out3: + + static int img_convert(int argc, char **argv) + { +- int c, n, n1, bs_n, bs_i, compress, cluster_size, +- cluster_sectors, skip_create; ++ int c, n, n1, bs_n, bs_i, compress, cluster_sectors, skip_create; + int64_t ret = 0; + int progress = 0, flags; + const char *fmt, *out_fmt, *cache, *out_baseimg, *out_filename; +@@ -1395,19 +1394,23 @@ static int img_convert(int argc, char **argv) + } + } + +- if (compress) { +- ret = bdrv_get_info(out_bs, &bdi); +- if (ret < 0) { ++ cluster_sectors = 0; ++ ret = bdrv_get_info(out_bs, &bdi); ++ if (ret < 0) { ++ if (compress) { + error_report("could not get block driver info"); + goto out; + } +- cluster_size = bdi.cluster_size; +- if (cluster_size <= 0 || cluster_size > bufsectors * BDRV_SECTOR_SIZE) { ++ } else { ++ cluster_sectors = bdi.cluster_size / BDRV_SECTOR_SIZE; ++ } ++ ++ if (compress) { ++ if (cluster_sectors <= 0 || cluster_sectors > bufsectors) { + error_report("invalid cluster size"); + ret = -1; + goto out; + } +- cluster_sectors = cluster_size >> 9; + sector_num = 0; + + nb_sectors = total_sectors; +@@ -1540,6 +1543,19 @@ static int img_convert(int argc, char **argv) + } + + n = MIN(nb_sectors, bufsectors); ++ ++ /* round down request length to an aligned sector, but ++ * do not bother doing this on short requests. They happen ++ * when we found an all-zero area, and the next sector to ++ * write will not be sector_num + n. */ ++ if (cluster_sectors > 0 && n >= cluster_sectors) { ++ int64_t next_aligned_sector = (sector_num + n); ++ next_aligned_sector -= next_aligned_sector % cluster_sectors; ++ if (sector_num + n > next_aligned_sector) { ++ n = next_aligned_sector - sector_num; ++ } ++ } ++ + n = MIN(n, bs_sectors - (sector_num - bs_offset)); + n1 = n; + +-- +1.7.11.7 + diff --git a/SOURCES/kvm-qemu-io-Let-open-pass-options-to-block-driver.patch b/SOURCES/kvm-qemu-io-Let-open-pass-options-to-block-driver.patch new file mode 100644 index 0000000..cc680e4 --- /dev/null +++ b/SOURCES/kvm-qemu-io-Let-open-pass-options-to-block-driver.patch @@ -0,0 +1,159 @@ +From 0ba83ccbe597ebcaca69a3363d8bc2a5dd74e0c7 Mon Sep 17 00:00:00 2001 +From: Max Reitz +Date: Sun, 29 Dec 2013 22:06:53 +0100 +Subject: [PATCH 2/8] qemu-io: Let "open" pass options to block driver + +RH-Author: Max Reitz +Message-id: <1388354817-3013-2-git-send-email-mreitz@redhat.com> +Patchwork-id: 56443 +O-Subject: [RHEL-7.0 qemu-kvm PATCH 1/5] qemu-io: Let "open" pass options to block driver +Bugzilla: 1004347 +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Fam Zheng +RH-Acked-by: Kevin Wolf + +BZ: 1004347 + +Add an option to the open command to specify runtime options for the +block driver used. + +Signed-off-by: Max Reitz +Signed-off-by: Kevin Wolf +(cherry picked from commit b543c5cdcb818ffed90cfc97aa8e297214650d84) + +Signed-off-by: Max Reitz + +Conflicts: + qemu-io.c + +Conflicts because 797ac58cb2093ab9192d8998a1fef85d87cc8661 has not been +backported, which splits qemu-io-cmds.c from qemu-io.c. +--- + qemu-io.c | 39 +++++++++++++++++++++++++++++++-------- + 1 file changed, 31 insertions(+), 8 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + qemu-io.c | 39 +++++++++++++++++++++++++++++++-------- + 1 files changed, 31 insertions(+), 8 deletions(-) + +diff --git a/qemu-io.c b/qemu-io.c +index 393c2c8..64b060c 100644 +--- a/qemu-io.c ++++ b/qemu-io.c +@@ -16,6 +16,8 @@ + + #include "qemu-common.h" + #include "qemu/main-loop.h" ++#include "qemu/option.h" ++#include "qemu/config-file.h" + #include "block/block_int.h" + #include "block/qapi.h" + #include "cmd.h" +@@ -1771,7 +1773,7 @@ static const cmdinfo_t close_cmd = { + .oneline = "close the current open file", + }; + +-static int openfile(char *name, int flags, int growable) ++static int openfile(char *name, int flags, int growable, QDict *opts) + { + Error *local_err = NULL; + +@@ -1781,7 +1783,7 @@ static int openfile(char *name, int flags, int growable) + } + + if (growable) { +- if (bdrv_file_open(&bs, name, NULL, flags, &local_err)) { ++ if (bdrv_file_open(&bs, name, opts, flags, &local_err)) { + fprintf(stderr, "%s: can't open device %s: %s\n", progname, name, + error_get_pretty(local_err)); + error_free(local_err); +@@ -1790,7 +1792,7 @@ static int openfile(char *name, int flags, int growable) + } else { + bs = bdrv_new("hda"); + +- if (bdrv_open(bs, name, NULL, flags, NULL, &local_err) < 0) { ++ if (bdrv_open(bs, name, opts, flags, NULL, &local_err) < 0) { + fprintf(stderr, "%s: can't open device %s: %s\n", progname, name, + error_get_pretty(local_err)); + error_free(local_err); +@@ -1816,7 +1818,8 @@ static void open_help(void) + " -r, -- open file read-only\n" + " -s, -- use snapshot file\n" + " -n, -- disable host cache\n" +-" -g, -- allow file to grow (only applies to protocols)" ++" -g, -- allow file to grow (only applies to protocols)\n" ++" -o, -- options to be given to the block driver" + "\n"); + } + +@@ -1829,19 +1832,30 @@ static const cmdinfo_t open_cmd = { + .argmin = 1, + .argmax = -1, + .flags = CMD_NOFILE_OK, +- .args = "[-Crsn] [path]", ++ .args = "[-Crsn] [-o options] [path]", + .oneline = "open the file specified by path", + .help = open_help, + }; + ++static QemuOptsList empty_opts = { ++ .name = "drive", ++ .head = QTAILQ_HEAD_INITIALIZER(empty_opts.head), ++ .desc = { ++ /* no elements => accept any params */ ++ { /* end of list */ } ++ }, ++}; ++ + static int open_f(int argc, char **argv) + { + int flags = 0; + int readonly = 0; + int growable = 0; + int c; ++ QemuOpts *qopts; ++ QDict *opts = NULL; + +- while ((c = getopt(argc, argv, "snrg")) != EOF) { ++ while ((c = getopt(argc, argv, "snrgo:")) != EOF) { + switch (c) { + case 's': + flags |= BDRV_O_SNAPSHOT; +@@ -1855,6 +1869,15 @@ static int open_f(int argc, char **argv) + case 'g': + growable = 1; + break; ++ case 'o': ++ qopts = qemu_opts_parse(&empty_opts, optarg, 0); ++ if (qopts == NULL) { ++ printf("could not parse option list -- %s\n", optarg); ++ return 0; ++ } ++ opts = qemu_opts_to_qdict(qopts, opts); ++ qemu_opts_del(qopts); ++ break; + default: + return command_usage(&open_cmd); + } +@@ -1868,7 +1891,7 @@ static int open_f(int argc, char **argv) + return command_usage(&open_cmd); + } + +- return openfile(argv[optind], flags, growable); ++ return openfile(argv[optind], flags, growable, opts); + } + + static int init_args_command(int index) +@@ -2039,7 +2062,7 @@ int main(int argc, char **argv) + } + + if ((argc - optind) == 1) { +- openfile(argv[optind], flags, growable); ++ openfile(argv[optind], flags, growable, NULL); + } + command_loop(); + +-- +1.7.1 + diff --git a/SOURCES/kvm-qemu-io-New-command-sleep.patch b/SOURCES/kvm-qemu-io-New-command-sleep.patch new file mode 100644 index 0000000..89625d4 --- /dev/null +++ b/SOURCES/kvm-qemu-io-New-command-sleep.patch @@ -0,0 +1,104 @@ +From 714dfa20586988e535dc7290be0d5d8d6b0853f3 Mon Sep 17 00:00:00 2001 +From: Kevin Wolf +Date: Wed, 15 Jan 2014 15:39:10 +0100 +Subject: [PATCH 33/37] qemu-io: New command 'sleep' + +Message-id: <1392117622-28812-34-git-send-email-kwolf@redhat.com> +Patchwork-id: 57198 +O-Subject: [RHEL-7.0 qemu-kvm PATCH v2 33/37] qemu-io: New command 'sleep' +Bugzilla: 748906 +RH-Acked-by: Laszlo Ersek +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Max Reitz + +There is no easy way to check that a request correctly waits for a +different request. With a sleep command we can at least approximate it. + +Signed-off-by: Kevin Wolf +(cherry picked from commit cd33d02a1012e58ee0d3c8259159e8c60cfa0a4d) + +Conflicts: + qemu-io-cmds.c + +Conflicts because RHEL 7 doesn't have... +- ...the qemu-io refactoring for supporting qemu-io from the monitor +- ...the new timer API + +Signed-off-by: Kevin Wolf +--- + qemu-io.c | 42 ++++++++++++++++++++++++++++++++++++++++++ + 1 file changed, 42 insertions(+) +--- + qemu-io.c | 42 ++++++++++++++++++++++++++++++++++++++++++ + 1 files changed, 42 insertions(+), 0 deletions(-) + +diff --git a/qemu-io.c b/qemu-io.c +index 7e258a5..0959178 100644 +--- a/qemu-io.c ++++ b/qemu-io.c +@@ -22,6 +22,7 @@ + #include "block/qapi.h" + #include "cmd.h" + #include "trace/control.h" ++#include "qemu/timer.h" + + #define VERSION "0.0.1" + +@@ -1773,6 +1774,46 @@ static const cmdinfo_t close_cmd = { + .oneline = "close the current open file", + }; + ++static void sleep_cb(void *opaque) ++{ ++ bool *expired = opaque; ++ *expired = true; ++} ++ ++static int sleep_f(int argc, char **argv) ++{ ++ char *endptr; ++ long ms; ++ struct QEMUTimer *timer; ++ bool expired = false; ++ ++ ms = strtol(argv[1], &endptr, 0); ++ if (ms < 0 || *endptr != '\0') { ++ printf("%s is not a valid number\n", argv[1]); ++ return 0; ++ } ++ ++ timer = qemu_new_timer_ns(host_clock, sleep_cb, &expired); ++ qemu_mod_timer(timer, qemu_get_clock_ns(host_clock) + SCALE_MS * ms); ++ ++ while (!expired) { ++ main_loop_wait(false); ++ } ++ ++ qemu_free_timer(timer); ++ ++ return 0; ++} ++ ++static const cmdinfo_t sleep_cmd = { ++ .name = "sleep", ++ .argmin = 1, ++ .argmax = 1, ++ .cfunc = sleep_f, ++ .flags = CMD_NOFILE_OK, ++ .oneline = "waits for the given value in milliseconds", ++}; ++ + static int openfile(char *name, int flags, int growable, QDict *opts) + { + Error *local_err = NULL; +@@ -2052,6 +2093,7 @@ int main(int argc, char **argv) + add_command(&resume_cmd); + add_command(&wait_break_cmd); + add_command(&abort_cmd); ++ add_command(&sleep_cmd); + + add_args_command(init_args_command); + add_check_command(init_check_command); +-- +1.7.1 + diff --git a/SOURCES/kvm-qemu-iotest-qcow2-image-option-amendment.patch b/SOURCES/kvm-qemu-iotest-qcow2-image-option-amendment.patch new file mode 100644 index 0000000..4eebf32 --- /dev/null +++ b/SOURCES/kvm-qemu-iotest-qcow2-image-option-amendment.patch @@ -0,0 +1,593 @@ +From 63a9a6b55ad06913d6ed8c83708d8828149ad24b Mon Sep 17 00:00:00 2001 +From: Signed-off-by: Max Reitz +Date: Thu, 9 Jan 2014 09:19:58 +0100 +Subject: [PATCH 12/14] qemu-iotest: qcow2 image option amendment + +Message-id: <1389131839-12920-13-git-send-email-mreitz@redhat.com> +Patchwork-id: 56548 +O-Subject: [RHEL-7.0 qemu-kvm PATCH v2 12/14] qemu-iotest: qcow2 image option amendment +Bugzilla: 1033490 +RH-Acked-by: Kevin Wolf +RH-Acked-by: Fam Zheng +RH-Acked-by: Stefan Hajnoczi + +BZ: 1033490 + +Add tests for qemu-img amend on qcow2 image files. + +Signed-off-by: Max Reitz +Signed-off-by: Kevin Wolf +(cherry picked from commit a8110c3d327cabff8dc258c5c8705903b56c1513) + +Signed-off-by: Max Reitz +--- + tests/qemu-iotests/061 | 178 +++++++++++++++++++++++ + tests/qemu-iotests/061.out | 349 +++++++++++++++++++++++++++++++++++++++++++++ + tests/qemu-iotests/group | 1 + + 3 files changed, 528 insertions(+) + create mode 100755 tests/qemu-iotests/061 + create mode 100644 tests/qemu-iotests/061.out + +Signed-off-by: Miroslav Rezanina +--- + tests/qemu-iotests/061 | 178 ++++++++++++++++++++++ + tests/qemu-iotests/061.out | 349 ++++++++++++++++++++++++++++++++++++++++++++ + tests/qemu-iotests/group | 1 + + 3 files changed, 528 insertions(+), 0 deletions(-) + create mode 100644 tests/qemu-iotests/061 + create mode 100644 tests/qemu-iotests/061.out + +diff --git a/tests/qemu-iotests/061 b/tests/qemu-iotests/061 +new file mode 100644 +index 0000000..86404e6 +--- /dev/null ++++ b/tests/qemu-iotests/061 +@@ -0,0 +1,178 @@ ++#!/bin/bash ++# ++# Test case for image option amendment in qcow2. ++# ++# Copyright (C) 2013 Red Hat, Inc. ++# ++# This program is free software; you can redistribute it and/or modify ++# it under the terms of the GNU General Public License as published by ++# the Free Software Foundation; either version 2 of the License, or ++# (at your option) any later version. ++# ++# This program is distributed in the hope that it will be useful, ++# but WITHOUT ANY WARRANTY; without even the implied warranty of ++# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++# GNU General Public License for more details. ++# ++# You should have received a copy of the GNU General Public License ++# along with this program. If not, see . ++# ++ ++# creator ++owner=mreitz@redhat.com ++ ++seq=`basename $0` ++echo "QA output created by $seq" ++ ++here=`pwd` ++tmp=/tmp/$$ ++status=1 # failure is the default! ++ ++_cleanup() ++{ ++ _cleanup_test_img ++} ++trap "_cleanup; exit \$status" 0 1 2 3 15 ++ ++# get standard environment, filters and checks ++. ./common.rc ++. ./common.filter ++ ++# This tests qocw2-specific low-level functionality ++_supported_fmt qcow2 ++_supported_proto generic ++_supported_os Linux ++ ++echo ++echo "=== Testing version downgrade with zero expansion ===" ++echo ++IMGOPTS="compat=1.1,lazy_refcounts=on" _make_test_img 64M ++$QEMU_IO -c "write -z 0 128k" "$TEST_IMG" | _filter_qemu_io ++./qcow2.py "$TEST_IMG" dump-header ++$QEMU_IMG amend -o "compat=0.10" "$TEST_IMG" ++./qcow2.py "$TEST_IMG" dump-header ++$QEMU_IO -c "read -P 0 0 128k" "$TEST_IMG" | _filter_qemu_io ++_check_test_img ++ ++echo ++echo "=== Testing dirty version downgrade ===" ++echo ++IMGOPTS="compat=1.1,lazy_refcounts=on" _make_test_img 64M ++$QEMU_IO -c "write -P 0x2a 0 128k" -c flush -c abort "$TEST_IMG" | _filter_qemu_io ++./qcow2.py "$TEST_IMG" dump-header ++$QEMU_IMG amend -o "compat=0.10" "$TEST_IMG" ++./qcow2.py "$TEST_IMG" dump-header ++$QEMU_IO -c "read -P 0x2a 0 128k" "$TEST_IMG" | _filter_qemu_io ++_check_test_img ++ ++echo ++echo "=== Testing version downgrade with unknown compat/autoclear flags ===" ++echo ++IMGOPTS="compat=1.1" _make_test_img 64M ++./qcow2.py "$TEST_IMG" set-feature-bit compatible 42 ++./qcow2.py "$TEST_IMG" set-feature-bit autoclear 42 ++./qcow2.py "$TEST_IMG" dump-header ++$QEMU_IMG amend -o "compat=0.10" "$TEST_IMG" ++./qcow2.py "$TEST_IMG" dump-header ++_check_test_img ++ ++echo ++echo "=== Testing version upgrade and resize ===" ++echo ++IMGOPTS="compat=0.10" _make_test_img 64M ++$QEMU_IO -c "write -P 0x2a 42M 64k" "$TEST_IMG" | _filter_qemu_io ++./qcow2.py "$TEST_IMG" dump-header ++$QEMU_IMG amend -o "compat=1.1,lazy_refcounts=on,size=128M" "$TEST_IMG" ++./qcow2.py "$TEST_IMG" dump-header ++$QEMU_IO -c "read -P 0x2a 42M 64k" "$TEST_IMG" | _filter_qemu_io ++_check_test_img ++ ++echo ++echo "=== Testing dirty lazy_refcounts=off ===" ++echo ++IMGOPTS="compat=1.1,lazy_refcounts=on" _make_test_img 64M ++$QEMU_IO -c "write -P 0x2a 0 128k" -c flush -c abort "$TEST_IMG" | _filter_qemu_io ++./qcow2.py "$TEST_IMG" dump-header ++$QEMU_IMG amend -o "lazy_refcounts=off" "$TEST_IMG" ++./qcow2.py "$TEST_IMG" dump-header ++$QEMU_IO -c "read -P 0x2a 0 128k" "$TEST_IMG" | _filter_qemu_io ++_check_test_img ++ ++echo ++echo "=== Testing backing file ===" ++echo ++IMGOPTS="compat=1.1" _make_test_img 64M ++IMGOPTS="compat=1.1" TEST_IMG="$TEST_IMG.base" _make_test_img 64M ++$QEMU_IO -c "write -P 0x2a 0 128k" "$TEST_IMG.base" | _filter_qemu_io ++$QEMU_IO -c "read -P 0 0 128k" "$TEST_IMG" | _filter_qemu_io ++$QEMU_IMG amend -o "backing_file=$TEST_IMG.base,backing_fmt=qcow2" "$TEST_IMG" ++$QEMU_IO -c "read -P 0x2a 0 128k" "$TEST_IMG" | _filter_qemu_io ++_check_test_img ++ ++echo ++echo "=== Testing invalid configurations ===" ++echo ++IMGOPTS="compat=0.10" _make_test_img 64M ++$QEMU_IMG amend -o "lazy_refcounts=on" "$TEST_IMG" ++$QEMU_IMG amend -o "compat=1.1" "$TEST_IMG" # actually valid ++$QEMU_IMG amend -o "compat=0.10,lazy_refcounts=on" "$TEST_IMG" ++$QEMU_IMG amend -o "compat=0.42" "$TEST_IMG" ++$QEMU_IMG amend -o "foo=bar" "$TEST_IMG" ++$QEMU_IMG amend -o "cluster_size=1k" "$TEST_IMG" ++$QEMU_IMG amend -o "encryption=on" "$TEST_IMG" ++$QEMU_IMG amend -o "preallocation=on" "$TEST_IMG" ++ ++echo ++echo "=== Testing correct handling of unset value ===" ++echo ++IMGOPTS="compat=1.1,cluster_size=1k" _make_test_img 64M ++echo "Should work:" ++$QEMU_IMG amend -o "lazy_refcounts=on" "$TEST_IMG" ++echo "Should not work:" # Just to know which of these tests actually fails ++$QEMU_IMG amend -o "cluster_size=64k" "$TEST_IMG" ++ ++echo ++echo "=== Testing zero expansion on inactive clusters ===" ++echo ++IMGOPTS="compat=1.1" _make_test_img 64M ++$QEMU_IO -c "write -z 0 128k" "$TEST_IMG" | _filter_qemu_io ++$QEMU_IMG snapshot -c foo "$TEST_IMG" ++$QEMU_IO -c "write -P 0x2a 0 128k" "$TEST_IMG" | _filter_qemu_io ++$QEMU_IMG amend -o "compat=0.10" "$TEST_IMG" ++_check_test_img ++$QEMU_IO -c "read -P 0x2a 0 128k" "$TEST_IMG" | _filter_qemu_io ++$QEMU_IMG snapshot -a foo "$TEST_IMG" ++_check_test_img ++$QEMU_IO -c "read -P 0 0 128k" "$TEST_IMG" | _filter_qemu_io ++ ++echo ++echo "=== Testing zero expansion on backed image ===" ++echo ++IMGOPTS="compat=1.1" TEST_IMG="$TEST_IMG.base" _make_test_img 64M ++$QEMU_IO -c "write -P 0x2a 0 128k" "$TEST_IMG.base" | _filter_qemu_io ++IMGOPTS="compat=1.1,backing_file=$TEST_IMG.base" _make_test_img 64M ++$QEMU_IO -c "read -P 0x2a 0 128k" -c "write -z 0 64k" "$TEST_IMG" | _filter_qemu_io ++$QEMU_IMG amend -o "compat=0.10" "$TEST_IMG" ++_check_test_img ++$QEMU_IO -c "read -P 0 0 64k" -c "read -P 0x2a 64k 64k" "$TEST_IMG" | _filter_qemu_io ++ ++echo ++echo "=== Testing zero expansion on backed inactive clusters ===" ++echo ++IMGOPTS="compat=1.1" TEST_IMG="$TEST_IMG.base" _make_test_img 64M ++$QEMU_IO -c "write -P 0x2a 0 128k" "$TEST_IMG.base" | _filter_qemu_io ++IMGOPTS="compat=1.1,backing_file=$TEST_IMG.base" _make_test_img 64M ++$QEMU_IO -c "write -z 0 64k" "$TEST_IMG" | _filter_qemu_io ++$QEMU_IMG snapshot -c foo "$TEST_IMG" ++$QEMU_IO -c "write -P 0x42 0 128k" "$TEST_IMG" | _filter_qemu_io ++$QEMU_IMG amend -o "compat=0.10" "$TEST_IMG" ++_check_test_img ++$QEMU_IO -c "read -P 0x42 0 128k" "$TEST_IMG" | _filter_qemu_io ++$QEMU_IMG snapshot -a foo "$TEST_IMG" ++_check_test_img ++$QEMU_IO -c "read -P 0 0 64k" -c "read -P 0x2a 64k 64k" "$TEST_IMG" | _filter_qemu_io ++ ++# success, all done ++echo "*** done" ++rm -f $seq.full ++status=0 +diff --git a/tests/qemu-iotests/061.out b/tests/qemu-iotests/061.out +new file mode 100644 +index 0000000..05bd1d5 +--- /dev/null ++++ b/tests/qemu-iotests/061.out +@@ -0,0 +1,349 @@ ++QA output created by 061 ++ ++=== Testing version downgrade with zero expansion === ++ ++Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864 ++wrote 131072/131072 bytes at offset 0 ++128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) ++magic 0x514649fb ++version 3 ++backing_file_offset 0x0 ++backing_file_size 0x0 ++cluster_bits 16 ++size 67108864 ++crypt_method 0 ++l1_size 1 ++l1_table_offset 0x30000 ++refcount_table_offset 0x10000 ++refcount_table_clusters 1 ++nb_snapshots 0 ++snapshot_offset 0x0 ++incompatible_features 0x0 ++compatible_features 0x1 ++autoclear_features 0x0 ++refcount_order 4 ++header_length 104 ++ ++magic 0x514649fb ++version 2 ++backing_file_offset 0x0 ++backing_file_size 0x0 ++cluster_bits 16 ++size 67108864 ++crypt_method 0 ++l1_size 1 ++l1_table_offset 0x30000 ++refcount_table_offset 0x10000 ++refcount_table_clusters 1 ++nb_snapshots 0 ++snapshot_offset 0x0 ++incompatible_features 0x0 ++compatible_features 0x0 ++autoclear_features 0x0 ++refcount_order 4 ++header_length 72 ++ ++Header extension: ++magic 0x6803f857 ++length 144 ++data ++ ++read 131072/131072 bytes at offset 0 ++128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) ++No errors were found on the image. ++ ++=== Testing dirty version downgrade === ++ ++Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864 ++wrote 131072/131072 bytes at offset 0 ++128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) ++magic 0x514649fb ++version 3 ++backing_file_offset 0x0 ++backing_file_size 0x0 ++cluster_bits 16 ++size 67108864 ++crypt_method 0 ++l1_size 1 ++l1_table_offset 0x30000 ++refcount_table_offset 0x10000 ++refcount_table_clusters 1 ++nb_snapshots 0 ++snapshot_offset 0x0 ++incompatible_features 0x1 ++compatible_features 0x1 ++autoclear_features 0x0 ++refcount_order 4 ++header_length 104 ++ ++Repairing cluster 5 refcount=0 reference=1 ++Repairing cluster 6 refcount=0 reference=1 ++magic 0x514649fb ++version 2 ++backing_file_offset 0x0 ++backing_file_size 0x0 ++cluster_bits 16 ++size 67108864 ++crypt_method 0 ++l1_size 1 ++l1_table_offset 0x30000 ++refcount_table_offset 0x10000 ++refcount_table_clusters 1 ++nb_snapshots 0 ++snapshot_offset 0x0 ++incompatible_features 0x0 ++compatible_features 0x0 ++autoclear_features 0x0 ++refcount_order 4 ++header_length 72 ++ ++Header extension: ++magic 0x6803f857 ++length 144 ++data ++ ++read 131072/131072 bytes at offset 0 ++128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) ++No errors were found on the image. ++ ++=== Testing version downgrade with unknown compat/autoclear flags === ++ ++Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864 ++magic 0x514649fb ++version 3 ++backing_file_offset 0x0 ++backing_file_size 0x0 ++cluster_bits 16 ++size 67108864 ++crypt_method 0 ++l1_size 1 ++l1_table_offset 0x30000 ++refcount_table_offset 0x10000 ++refcount_table_clusters 1 ++nb_snapshots 0 ++snapshot_offset 0x0 ++incompatible_features 0x0 ++compatible_features 0x40000000000 ++autoclear_features 0x40000000000 ++refcount_order 4 ++header_length 104 ++ ++magic 0x514649fb ++version 2 ++backing_file_offset 0x0 ++backing_file_size 0x0 ++cluster_bits 16 ++size 67108864 ++crypt_method 0 ++l1_size 1 ++l1_table_offset 0x30000 ++refcount_table_offset 0x10000 ++refcount_table_clusters 1 ++nb_snapshots 0 ++snapshot_offset 0x0 ++incompatible_features 0x0 ++compatible_features 0x0 ++autoclear_features 0x0 ++refcount_order 4 ++header_length 72 ++ ++Header extension: ++magic 0x6803f857 ++length 144 ++data ++ ++No errors were found on the image. ++ ++=== Testing version upgrade and resize === ++ ++Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864 ++wrote 65536/65536 bytes at offset 44040192 ++64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) ++magic 0x514649fb ++version 2 ++backing_file_offset 0x0 ++backing_file_size 0x0 ++cluster_bits 16 ++size 67108864 ++crypt_method 0 ++l1_size 1 ++l1_table_offset 0x30000 ++refcount_table_offset 0x10000 ++refcount_table_clusters 1 ++nb_snapshots 0 ++snapshot_offset 0x0 ++incompatible_features 0x0 ++compatible_features 0x0 ++autoclear_features 0x0 ++refcount_order 4 ++header_length 72 ++ ++magic 0x514649fb ++version 3 ++backing_file_offset 0x0 ++backing_file_size 0x0 ++cluster_bits 16 ++size 134217728 ++crypt_method 0 ++l1_size 1 ++l1_table_offset 0x30000 ++refcount_table_offset 0x10000 ++refcount_table_clusters 1 ++nb_snapshots 0 ++snapshot_offset 0x0 ++incompatible_features 0x0 ++compatible_features 0x1 ++autoclear_features 0x0 ++refcount_order 4 ++header_length 104 ++ ++Header extension: ++magic 0x6803f857 ++length 144 ++data ++ ++read 65536/65536 bytes at offset 44040192 ++64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) ++No errors were found on the image. ++ ++=== Testing dirty lazy_refcounts=off === ++ ++Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864 ++wrote 131072/131072 bytes at offset 0 ++128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) ++magic 0x514649fb ++version 3 ++backing_file_offset 0x0 ++backing_file_size 0x0 ++cluster_bits 16 ++size 67108864 ++crypt_method 0 ++l1_size 1 ++l1_table_offset 0x30000 ++refcount_table_offset 0x10000 ++refcount_table_clusters 1 ++nb_snapshots 0 ++snapshot_offset 0x0 ++incompatible_features 0x1 ++compatible_features 0x1 ++autoclear_features 0x0 ++refcount_order 4 ++header_length 104 ++ ++Repairing cluster 5 refcount=0 reference=1 ++Repairing cluster 6 refcount=0 reference=1 ++magic 0x514649fb ++version 3 ++backing_file_offset 0x0 ++backing_file_size 0x0 ++cluster_bits 16 ++size 67108864 ++crypt_method 0 ++l1_size 1 ++l1_table_offset 0x30000 ++refcount_table_offset 0x10000 ++refcount_table_clusters 1 ++nb_snapshots 0 ++snapshot_offset 0x0 ++incompatible_features 0x0 ++compatible_features 0x0 ++autoclear_features 0x0 ++refcount_order 4 ++header_length 104 ++ ++Header extension: ++magic 0x6803f857 ++length 144 ++data ++ ++read 131072/131072 bytes at offset 0 ++128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) ++No errors were found on the image. ++ ++=== Testing backing file === ++ ++Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864 ++Formatting 'TEST_DIR/t.IMGFMT.base', fmt=IMGFMT size=67108864 ++wrote 131072/131072 bytes at offset 0 ++128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) ++read 131072/131072 bytes at offset 0 ++128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) ++read 131072/131072 bytes at offset 0 ++128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) ++No errors were found on the image. ++ ++=== Testing invalid configurations === ++ ++Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864 ++Lazy refcounts only supported with compatibility level 1.1 and above (use compat=1.1 or greater) ++qemu-img: Error while amending options: Invalid argument ++Lazy refcounts only supported with compatibility level 1.1 and above (use compat=1.1 or greater) ++qemu-img: Error while amending options: Invalid argument ++Unknown compatibility level 0.42. ++qemu-img: Error while amending options: Invalid argument ++Unknown option 'foo' ++qemu-img: Invalid options for file format 'qcow2' ++Changing the cluster size is not supported. ++qemu-img: Error while amending options: Operation not supported ++Changing the encryption flag is not supported. ++qemu-img: Error while amending options: Operation not supported ++Cannot change preallocation mode. ++qemu-img: Error while amending options: Operation not supported ++ ++=== Testing correct handling of unset value === ++ ++Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864 ++Should work: ++Should not work: ++Changing the cluster size is not supported. ++qemu-img: Error while amending options: Operation not supported ++ ++=== Testing zero expansion on inactive clusters === ++ ++Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864 ++wrote 131072/131072 bytes at offset 0 ++128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) ++wrote 131072/131072 bytes at offset 0 ++128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) ++No errors were found on the image. ++read 131072/131072 bytes at offset 0 ++128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) ++No errors were found on the image. ++read 131072/131072 bytes at offset 0 ++128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) ++ ++=== Testing zero expansion on backed image === ++ ++Formatting 'TEST_DIR/t.IMGFMT.base', fmt=IMGFMT size=67108864 ++wrote 131072/131072 bytes at offset 0 ++128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) ++Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864 backing_file='TEST_DIR/t.IMGFMT.base' ++read 131072/131072 bytes at offset 0 ++128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) ++wrote 65536/65536 bytes at offset 0 ++64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) ++No errors were found on the image. ++read 65536/65536 bytes at offset 0 ++64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) ++read 65536/65536 bytes at offset 65536 ++64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) ++ ++=== Testing zero expansion on backed inactive clusters === ++ ++Formatting 'TEST_DIR/t.IMGFMT.base', fmt=IMGFMT size=67108864 ++wrote 131072/131072 bytes at offset 0 ++128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) ++Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864 backing_file='TEST_DIR/t.IMGFMT.base' ++wrote 65536/65536 bytes at offset 0 ++64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) ++wrote 131072/131072 bytes at offset 0 ++128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) ++No errors were found on the image. ++read 131072/131072 bytes at offset 0 ++128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) ++No errors were found on the image. ++read 65536/65536 bytes at offset 0 ++64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) ++read 65536/65536 bytes at offset 65536 ++64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) ++*** done +diff --git a/tests/qemu-iotests/group b/tests/qemu-iotests/group +index 2d0aba0..50a726e 100644 +--- a/tests/qemu-iotests/group ++++ b/tests/qemu-iotests/group +@@ -63,6 +63,7 @@ + 054 rw auto + 059 rw auto + 060 rw auto ++061 rw auto + 062 rw auto + 063 rw auto + 064 rw auto +-- +1.7.1 + diff --git a/SOURCES/kvm-qemu-iotests-033-is-fast.patch.patch b/SOURCES/kvm-qemu-iotests-033-is-fast.patch.patch new file mode 100644 index 0000000..dc1beeb --- /dev/null +++ b/SOURCES/kvm-qemu-iotests-033-is-fast.patch.patch @@ -0,0 +1,45 @@ +From b9e9b6957a0b66f26de128069d6f191c480cf928 Mon Sep 17 00:00:00 2001 +Message-Id: +In-Reply-To: +References: +From: Paolo Bonzini +Date: Mon, 9 Dec 2013 14:09:30 +0100 +Subject: [PATCH 42/50] qemu-iotests: 033 is fast + +RH-Author: Paolo Bonzini +Message-id: <1386598178-11845-45-git-send-email-pbonzini@redhat.com> +Patchwork-id: 56081 +O-Subject: [RHEL 7.0 qemu-kvm PATCH 44/52] qemu-iotests: 033 is fast +Bugzilla: 1007815 +RH-Acked-by: Jeffrey Cody +RH-Acked-by: Fam Zheng +RH-Acked-by: Stefan Hajnoczi + +Signed-off-by: Paolo Bonzini +Signed-off-by: Stefan Hajnoczi +(cherry picked from commit e18d90c15bab0d47d8f30696058abfb78396081f) +--- + tests/qemu-iotests/group | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +Signed-off-by: Michal Novotny +--- + tests/qemu-iotests/group | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/tests/qemu-iotests/group b/tests/qemu-iotests/group +index 68c056b..4a211bf 100644 +--- a/tests/qemu-iotests/group ++++ b/tests/qemu-iotests/group +@@ -39,7 +39,7 @@ + 030 rw auto backing + 031 rw auto quick + 032 rw auto +-033 rw auto ++033 rw auto quick + 034 rw auto backing + 035 rw auto quick + 036 rw auto quick +-- +1.7.11.7 + diff --git a/SOURCES/kvm-qemu-iotests-Add-test-for-inactive-L2-overlap.patch b/SOURCES/kvm-qemu-iotests-Add-test-for-inactive-L2-overlap.patch new file mode 100644 index 0000000..acbdb81 --- /dev/null +++ b/SOURCES/kvm-qemu-iotests-Add-test-for-inactive-L2-overlap.patch @@ -0,0 +1,196 @@ +From f52b3a7ce94fb9a5e6feaac513940e6f4cb95fb0 Mon Sep 17 00:00:00 2001 +From: Max Reitz +Date: Sun, 29 Dec 2013 22:06:56 +0100 +Subject: [PATCH 5/8] qemu-iotests: Add test for inactive L2 overlap + +RH-Author: Max Reitz +Message-id: <1388354817-3013-5-git-send-email-mreitz@redhat.com> +Patchwork-id: 56446 +O-Subject: [RHEL-7.0 qemu-kvm PATCH 4/5] qemu-iotests: Add test for inactive L2 overlap +Bugzilla: 1004347 +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Fam Zheng +RH-Acked-by: Kevin Wolf + +BZ: 1004347 + +Extend 060 by a test which creates a corrupted image with an active L2 +entry pointing to an inactive L2 table and writes to the corresponding +guest offset. + +Also, use overlap-check=all for all tests in 060. + +Signed-off-by: Max Reitz +Signed-off-by: Kevin Wolf +(cherry picked from commit 34eeb82de65ce9f83081a3357b0afe80a6a1d86a) + +Signed-off-by: Max Reitz +--- + tests/qemu-iotests/060 | 47 +++++++++++++++++++++++++++++++++++++++------- + tests/qemu-iotests/060.out | 40 ++++++++++++++++++++++++++++++++++++++- + 2 files changed, 79 insertions(+), 8 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + tests/qemu-iotests/060 | 47 +++++++++++++++++++++++++++++++++++++------ + tests/qemu-iotests/060.out | 40 ++++++++++++++++++++++++++++++++++++- + 2 files changed, 79 insertions(+), 8 deletions(-) + +diff --git a/tests/qemu-iotests/060 b/tests/qemu-iotests/060 +index 9bbc43b..bbb1909 100644 +--- a/tests/qemu-iotests/060 ++++ b/tests/qemu-iotests/060 +@@ -21,10 +21,10 @@ + # creator + owner=mreitz@redhat.com + +-seq=`basename $0` ++seq="$(basename $0)" + echo "QA output created by $seq" + +-here=`pwd` ++here="$PWD" + tmp=/tmp/$$ + status=1 # failure is the default! + +@@ -47,9 +47,15 @@ rt_offset=65536 # 0x10000 (XXX: just an assumption) + rb_offset=131072 # 0x20000 (XXX: just an assumption) + l1_offset=196608 # 0x30000 (XXX: just an assumption) + l2_offset=262144 # 0x40000 (XXX: just an assumption) ++l2_offset_after_snapshot=524288 # 0x80000 (XXX: just an assumption) + + IMGOPTS="compat=1.1" + ++OPEN_RW="open -o overlap-check=all $TEST_IMG" ++# Overlap checks are done before write operations only, therefore opening an ++# image read-only makes the overlap-check option irrelevant ++OPEN_RO="open -r $TEST_IMG" ++ + echo + echo "=== Testing L2 reference into L1 ===" + echo +@@ -65,16 +71,18 @@ _check_test_img + ./qcow2.py "$TEST_IMG" dump-header | grep incompatible_features + + # Try to write something, thereby forcing the corrupt bit to be set +-$QEMU_IO -c "write -P 0x2a 0 512" "$TEST_IMG" | _filter_qemu_io ++$QEMU_IO -c "$OPEN_RW" -c "write -P 0x2a 0 512" | _filter_qemu_io + + # The corrupt bit must now be set + ./qcow2.py "$TEST_IMG" dump-header | grep incompatible_features + + # Try to open the image R/W (which should fail) +-$QEMU_IO -c "read 0 512" "$TEST_IMG" 2>&1 | _filter_qemu_io | _filter_testdir | _filter_imgfmt ++$QEMU_IO -c "$OPEN_RW" -c "read 0 512" 2>&1 | _filter_qemu_io \ ++ | _filter_testdir \ ++ | _filter_imgfmt + + # Try to open it RO (which should succeed) +-$QEMU_IO -c "read 0 512" -r "$TEST_IMG" | _filter_qemu_io ++$QEMU_IO -c "$OPEN_RO" -c "read 0 512" | _filter_qemu_io + + # We could now try to fix the image, but this would probably fail (how should an + # L2 table linked onto the L1 table be fixed?) +@@ -92,7 +100,7 @@ poke_file "$TEST_IMG" "$(($rb_offset+8))" "\x00\x01" + poke_file "$TEST_IMG" "$l2_offset" "\x80\x00\x00\x00\x00\x02\x00\x00" + _check_test_img + ./qcow2.py "$TEST_IMG" dump-header | grep incompatible_features +-$QEMU_IO -c "write -P 0x2a 0 512" "$TEST_IMG" | _filter_qemu_io ++$QEMU_IO -c "$OPEN_RW" -c "write -P 0x2a 0 512" | _filter_qemu_io + ./qcow2.py "$TEST_IMG" dump-header | grep incompatible_features + + # Try to fix it +@@ -102,8 +110,33 @@ _check_test_img -r all + ./qcow2.py "$TEST_IMG" dump-header | grep incompatible_features + + # Look if it's really really fixed +-$QEMU_IO -c "write -P 0x2a 0 512" "$TEST_IMG" | _filter_qemu_io ++$QEMU_IO -c "$OPEN_RW" -c "write -P 0x2a 0 512" | _filter_qemu_io ++./qcow2.py "$TEST_IMG" dump-header | grep incompatible_features ++ ++echo ++echo "=== Testing cluster data reference into inactive L2 table ===" ++echo ++_make_test_img 64M ++$QEMU_IO -c "$OPEN_RW" -c "write -P 1 0 512" | _filter_qemu_io ++$QEMU_IMG snapshot -c foo "$TEST_IMG" ++$QEMU_IO -c "$OPEN_RW" -c "write -P 2 0 512" | _filter_qemu_io ++# The inactive L2 table remains at its old offset ++poke_file "$TEST_IMG" "$l2_offset_after_snapshot" \ ++ "\x80\x00\x00\x00\x00\x04\x00\x00" ++_check_test_img + ./qcow2.py "$TEST_IMG" dump-header | grep incompatible_features ++$QEMU_IO -c "$OPEN_RW" -c "write -P 3 0 512" | _filter_qemu_io ++./qcow2.py "$TEST_IMG" dump-header | grep incompatible_features ++_check_test_img -r all ++./qcow2.py "$TEST_IMG" dump-header | grep incompatible_features ++$QEMU_IO -c "$OPEN_RW" -c "write -P 4 0 512" | _filter_qemu_io ++./qcow2.py "$TEST_IMG" dump-header | grep incompatible_features ++ ++# Check data ++$QEMU_IO -c "$OPEN_RO" -c "read -P 4 0 512" | _filter_qemu_io ++$QEMU_IMG snapshot -a foo "$TEST_IMG" ++_check_test_img ++$QEMU_IO -c "$OPEN_RO" -c "read -P 1 0 512" | _filter_qemu_io + + # success, all done + echo "*** done" +diff --git a/tests/qemu-iotests/060.out b/tests/qemu-iotests/060.out +index 648f743..6c7bdbb 100644 +--- a/tests/qemu-iotests/060.out ++++ b/tests/qemu-iotests/060.out +@@ -12,7 +12,6 @@ qcow2: Preventing invalid write on metadata (overlaps with active L1 table); ima + write failed: Input/output error + incompatible_features 0x2 + qemu-io: can't open device TEST_DIR/t.IMGFMT: IMGFMT: Image is corrupt; cannot be opened read/write +-no file open, try 'help open' + read 512/512 bytes at offset 0 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) + +@@ -40,4 +39,43 @@ incompatible_features 0x0 + wrote 512/512 bytes at offset 0 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) + incompatible_features 0x0 ++ ++=== Testing cluster data reference into inactive L2 table === ++ ++Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864 ++wrote 512/512 bytes at offset 0 ++512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) ++wrote 512/512 bytes at offset 0 ++512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) ++ERROR cluster 4 refcount=1 reference=2 ++Leaked cluster 9 refcount=1 reference=0 ++ ++1 errors were found on the image. ++Data may be corrupted, or further writes to the image may corrupt it. ++ ++1 leaked clusters were found on the image. ++This means waste of disk space, but no harm to data. ++incompatible_features 0x0 ++qcow2: Preventing invalid write on metadata (overlaps with inactive L2 table); image marked as corrupt. ++write failed: Input/output error ++incompatible_features 0x2 ++Repairing cluster 4 refcount=1 reference=2 ++Repairing cluster 9 refcount=1 reference=0 ++Repairing OFLAG_COPIED data cluster: l2_entry=8000000000040000 refcount=2 ++The following inconsistencies were found and repaired: ++ ++ 1 leaked clusters ++ 2 corruptions ++ ++Double checking the fixed image now... ++No errors were found on the image. ++incompatible_features 0x0 ++wrote 512/512 bytes at offset 0 ++512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) ++incompatible_features 0x0 ++read 512/512 bytes at offset 0 ++512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) ++No errors were found on the image. ++read 512/512 bytes at offset 0 ++512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) + *** done +-- +1.7.1 + diff --git a/SOURCES/kvm-qemu-iotests-Adjust-test-result-039.patch b/SOURCES/kvm-qemu-iotests-Adjust-test-result-039.patch new file mode 100644 index 0000000..3b2536a --- /dev/null +++ b/SOURCES/kvm-qemu-iotests-Adjust-test-result-039.patch @@ -0,0 +1,68 @@ +From 762c6ae0424c3389e432ea40d2559abac2eb3566 Mon Sep 17 00:00:00 2001 +From: Max Reitz +Date: Sun, 29 Dec 2013 22:06:57 +0100 +Subject: [PATCH 6/8] qemu-iotests: Adjust test result 039 + +RH-Author: Max Reitz +Message-id: <1388354817-3013-6-git-send-email-mreitz@redhat.com> +Patchwork-id: 56447 +O-Subject: [RHEL-7.0 qemu-kvm PATCH 5/5] qemu-iotests: Adjust test result 039 +Bugzilla: 1004347 +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Fam Zheng +RH-Acked-by: Kevin Wolf + +BZ: 1004347 + +The moved OFLAG_COPIED check in qcow2_check_refcounts results in a +different output from test 039 (mismatches are now found after the +general refcount check (as far as any remain)). This patch adjusts the +expected test result accordingly. + +Signed-off-by: Max Reitz +Signed-off-by: Stefan Hajnoczi +(cherry picked from commit b3f3a30f387f34308b3e4d910a2824e69c34182f) + +Signed-off-by: Max Reitz +--- + tests/qemu-iotests/039.out | 4 +--- + 1 file changed, 1 insertion(+), 3 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + tests/qemu-iotests/039.out | 4 +--- + 1 files changed, 1 insertions(+), 3 deletions(-) + +diff --git a/tests/qemu-iotests/039.out b/tests/qemu-iotests/039.out +index cb510d6..077fa64 100644 +--- a/tests/qemu-iotests/039.out ++++ b/tests/qemu-iotests/039.out +@@ -12,8 +12,8 @@ Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=134217728 + wrote 512/512 bytes at offset 0 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) + incompatible_features 0x1 +-ERROR OFLAG_COPIED: offset=8000000000050000 refcount=0 + ERROR cluster 5 refcount=0 reference=1 ++ERROR OFLAG_COPIED data cluster: l2_entry=8000000000050000 refcount=0 + + 2 errors were found on the image. + Data may be corrupted, or further writes to the image may corrupt it. +@@ -24,7 +24,6 @@ read 512/512 bytes at offset 0 + incompatible_features 0x1 + + == Repairing the image file must succeed == +-ERROR OFLAG_COPIED: offset=8000000000050000 refcount=0 + Repairing cluster 5 refcount=0 reference=1 + The following inconsistencies were found and repaired: + +@@ -44,7 +43,6 @@ Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=134217728 + wrote 512/512 bytes at offset 0 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) + incompatible_features 0x1 +-ERROR OFLAG_COPIED: offset=8000000000050000 refcount=0 + Repairing cluster 5 refcount=0 reference=1 + wrote 512/512 bytes at offset 0 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-- +1.7.1 + diff --git a/SOURCES/kvm-qemu-iotests-Check-qemu-img-command-line-parsing.patch b/SOURCES/kvm-qemu-iotests-Check-qemu-img-command-line-parsing.patch new file mode 100644 index 0000000..4c3320f --- /dev/null +++ b/SOURCES/kvm-qemu-iotests-Check-qemu-img-command-line-parsing.patch @@ -0,0 +1,801 @@ +From 6b1816a687831a1622637ed10605759d9e90aa9c Mon Sep 17 00:00:00 2001 +From: Kevin Wolf +Date: Tue, 25 Feb 2014 15:00:05 +0100 +Subject: [PATCH 7/7] qemu-iotests: Check qemu-img command line parsing + +RH-Author: Kevin Wolf +Message-id: <1393340405-9936-7-git-send-email-kwolf@redhat.com> +Patchwork-id: 57798 +O-Subject: [RHEL-7.0 qemu-kvm PATCH 6/6] qemu-iotests: Check qemu-img command line parsing +Bugzilla: 1065873 +RH-Acked-by: Juan Quintela +RH-Acked-by: Fam Zheng +RH-Acked-by: Miroslav Rezanina + +Signed-off-by: Kevin Wolf +Reviewed-by: Jeff Cody +Reviewed-by: Eric Blake +(cherry picked from commit a33cc31d08eb46ec2a4f214087c99e4bd4c907e9) + +Changed reference test output for RHEL 7, which has different error +messages than upstream. + +Signed-off-by: Kevin Wolf +--- + tests/qemu-iotests/082 | 208 ++++++++++++++++++ + tests/qemu-iotests/082.out | 529 +++++++++++++++++++++++++++++++++++++++++++++ + tests/qemu-iotests/group | 1 + + 3 files changed, 738 insertions(+) + create mode 100755 tests/qemu-iotests/082 + create mode 100644 tests/qemu-iotests/082.out + +Signed-off-by: Miroslav Rezanina +--- + tests/qemu-iotests/082 | 208 +++++++++++++++++ + tests/qemu-iotests/082.out | 529 ++++++++++++++++++++++++++++++++++++++++++++ + tests/qemu-iotests/group | 1 + + 3 files changed, 738 insertions(+), 0 deletions(-) + create mode 100755 tests/qemu-iotests/082 + create mode 100644 tests/qemu-iotests/082.out + +diff --git a/tests/qemu-iotests/082 b/tests/qemu-iotests/082 +new file mode 100755 +index 0000000..f6eb75f +--- /dev/null ++++ b/tests/qemu-iotests/082 +@@ -0,0 +1,208 @@ ++#!/bin/bash ++# ++# Test qemu-img command line parsing ++# ++# Copyright (C) 2014 Red Hat, Inc. ++# ++# This program is free software; you can redistribute it and/or modify ++# it under the terms of the GNU General Public License as published by ++# the Free Software Foundation; either version 2 of the License, or ++# (at your option) any later version. ++# ++# This program is distributed in the hope that it will be useful, ++# but WITHOUT ANY WARRANTY; without even the implied warranty of ++# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++# GNU General Public License for more details. ++# ++# You should have received a copy of the GNU General Public License ++# along with this program. If not, see . ++# ++ ++# creator ++owner=kwolf@redhat.com ++ ++seq=`basename $0` ++echo "QA output created by $seq" ++ ++here=`pwd` ++tmp=/tmp/$$ ++status=1 # failure is the default! ++ ++_cleanup() ++{ ++ _cleanup_test_img ++} ++trap "_cleanup; exit \$status" 0 1 2 3 15 ++ ++# get standard environment, filters and checks ++. ./common.rc ++. ./common.filter ++ ++_supported_fmt qcow2 ++_supported_proto file ++_supported_os Linux ++ ++function run_qemu_img() ++{ ++ echo ++ echo Testing: "$@" | _filter_testdir ++ "$QEMU_IMG" "$@" 2>&1 | _filter_testdir ++} ++ ++size=128M ++ ++echo ++echo === create: Options specified more than once === ++ ++# Last -f should win ++run_qemu_img create -f foo -f $IMGFMT "$TEST_IMG" $size ++run_qemu_img info "$TEST_IMG" ++ ++# Multiple -o should be merged ++run_qemu_img create -f $IMGFMT -o cluster_size=4k -o lazy_refcounts=on "$TEST_IMG" $size ++run_qemu_img info "$TEST_IMG" ++ ++# If the same -o key is specified more than once, the last one wins ++run_qemu_img create -f $IMGFMT -o cluster_size=4k -o lazy_refcounts=on -o cluster_size=8k "$TEST_IMG" $size ++run_qemu_img info "$TEST_IMG" ++run_qemu_img create -f $IMGFMT -o cluster_size=4k,cluster_size=8k "$TEST_IMG" $size ++run_qemu_img info "$TEST_IMG" ++ ++echo ++echo === create: help for -o === ++ ++# Adding the help option to a command without other -o options ++run_qemu_img create -f $IMGFMT -o help "$TEST_IMG" $size ++run_qemu_img create -f $IMGFMT -o \? "$TEST_IMG" $size ++ ++# Adding the help option to the same -o option ++run_qemu_img create -f $IMGFMT -o cluster_size=4k,help "$TEST_IMG" $size ++run_qemu_img create -f $IMGFMT -o cluster_size=4k,\? "$TEST_IMG" $size ++run_qemu_img create -f $IMGFMT -o help,cluster_size=4k "$TEST_IMG" $size ++run_qemu_img create -f $IMGFMT -o \?,cluster_size=4k "$TEST_IMG" $size ++ ++# Adding the help option to a separate -o option ++run_qemu_img create -f $IMGFMT -o cluster_size=4k -o help "$TEST_IMG" $size ++run_qemu_img create -f $IMGFMT -o cluster_size=4k -o \? "$TEST_IMG" $size ++ ++# Looks like a help option, but is part of the backing file name ++run_qemu_img create -f $IMGFMT -o backing_file="$TEST_IMG",,help "$TEST_IMG" $size ++run_qemu_img create -f $IMGFMT -o backing_file="$TEST_IMG",,\? "$TEST_IMG" $size ++ ++# Try to trick qemu-img into creating escaped commas ++run_qemu_img create -f $IMGFMT -o backing_file="$TEST_IMG", -o help "$TEST_IMG" $size ++run_qemu_img create -f $IMGFMT -o backing_file="$TEST_IMG" -o ,help "$TEST_IMG" $size ++run_qemu_img create -f $IMGFMT -o backing_file="$TEST_IMG" -o ,, -o help "$TEST_IMG" $size ++ ++# Leave out everything that isn't needed ++run_qemu_img create -f $IMGFMT -o help ++run_qemu_img create -o help ++ ++echo ++echo === convert: Options specified more than once === ++ ++# We need a valid source image ++run_qemu_img create -f $IMGFMT "$TEST_IMG" $size ++ ++# Last -f should win ++run_qemu_img convert -f foo -f $IMGFMT "$TEST_IMG" "$TEST_IMG".base ++run_qemu_img info "$TEST_IMG".base ++ ++# Last -O should win ++run_qemu_img convert -O foo -O $IMGFMT "$TEST_IMG" "$TEST_IMG".base ++run_qemu_img info "$TEST_IMG".base ++ ++# Multiple -o should be merged ++run_qemu_img convert -O $IMGFMT -o cluster_size=4k -o lazy_refcounts=on "$TEST_IMG" "$TEST_IMG".base ++run_qemu_img info "$TEST_IMG".base ++ ++# If the same -o key is specified more than once, the last one wins ++run_qemu_img convert -O $IMGFMT -o cluster_size=4k -o lazy_refcounts=on -o cluster_size=8k "$TEST_IMG" "$TEST_IMG".base ++run_qemu_img info "$TEST_IMG".base ++run_qemu_img convert -O $IMGFMT -o cluster_size=4k,cluster_size=8k "$TEST_IMG" "$TEST_IMG".base ++run_qemu_img info "$TEST_IMG".base ++ ++echo ++echo === convert: help for -o === ++ ++# Adding the help option to a command without other -o options ++run_qemu_img convert -O $IMGFMT -o help "$TEST_IMG" "$TEST_IMG".base ++run_qemu_img convert -O $IMGFMT -o \? "$TEST_IMG" "$TEST_IMG".base ++ ++# Adding the help option to the same -o option ++run_qemu_img convert -O $IMGFMT -o cluster_size=4k,help "$TEST_IMG" "$TEST_IMG".base ++run_qemu_img convert -O $IMGFMT -o cluster_size=4k,\? "$TEST_IMG" "$TEST_IMG".base ++run_qemu_img convert -O $IMGFMT -o help,cluster_size=4k "$TEST_IMG" "$TEST_IMG".base ++run_qemu_img convert -O $IMGFMT -o \?,cluster_size=4k "$TEST_IMG" "$TEST_IMG".base ++ ++# Adding the help option to a separate -o option ++run_qemu_img convert -O $IMGFMT -o cluster_size=4k -o help "$TEST_IMG" "$TEST_IMG".base ++run_qemu_img convert -O $IMGFMT -o cluster_size=4k -o \? "$TEST_IMG" "$TEST_IMG".base ++ ++# Looks like a help option, but is part of the backing file name ++run_qemu_img convert -O $IMGFMT -o backing_file="$TEST_IMG",,help "$TEST_IMG" "$TEST_IMG".base ++run_qemu_img convert -O $IMGFMT -o backing_file="$TEST_IMG",,\? "$TEST_IMG" "$TEST_IMG".base ++ ++# Try to trick qemu-img into creating escaped commas ++run_qemu_img convert -O $IMGFMT -o backing_file="$TEST_IMG", -o help "$TEST_IMG" "$TEST_IMG".base ++run_qemu_img convert -O $IMGFMT -o backing_file="$TEST_IMG" -o ,help "$TEST_IMG" "$TEST_IMG".base ++run_qemu_img convert -O $IMGFMT -o backing_file="$TEST_IMG" -o ,, -o help "$TEST_IMG" "$TEST_IMG".base ++ ++# Leave out everything that isn't needed ++run_qemu_img convert -O $IMGFMT -o help ++run_qemu_img convert -o help ++ ++echo ++echo === amend: Options specified more than once === ++ ++# Last -f should win ++run_qemu_img amend -f foo -f $IMGFMT -o lazy_refcounts=on "$TEST_IMG" ++run_qemu_img info "$TEST_IMG" ++ ++# Multiple -o should be merged ++run_qemu_img amend -f $IMGFMT -o size=130M -o lazy_refcounts=off "$TEST_IMG" ++run_qemu_img info "$TEST_IMG" ++ ++# If the same -o key is specified more than once, the last one wins ++run_qemu_img amend -f $IMGFMT -o size=8M -o lazy_refcounts=on -o size=132M "$TEST_IMG" ++run_qemu_img info "$TEST_IMG" ++run_qemu_img amend -f $IMGFMT -o size=4M,size=148M "$TEST_IMG" ++run_qemu_img info "$TEST_IMG" ++ ++echo ++echo === amend: help for -o === ++ ++# Adding the help option to a command without other -o options ++run_qemu_img amend -f $IMGFMT -o help "$TEST_IMG" ++run_qemu_img amend -f $IMGFMT -o \? "$TEST_IMG" ++ ++# Adding the help option to the same -o option ++run_qemu_img amend -f $IMGFMT -o cluster_size=4k,help "$TEST_IMG" ++run_qemu_img amend -f $IMGFMT -o cluster_size=4k,\? "$TEST_IMG" ++run_qemu_img amend -f $IMGFMT -o help,cluster_size=4k "$TEST_IMG" ++run_qemu_img amend -f $IMGFMT -o \?,cluster_size=4k "$TEST_IMG" ++ ++# Adding the help option to a separate -o option ++run_qemu_img amend -f $IMGFMT -o cluster_size=4k -o help "$TEST_IMG" ++run_qemu_img amend -f $IMGFMT -o cluster_size=4k -o \? "$TEST_IMG" ++ ++# Looks like a help option, but is part of the backing file name ++run_qemu_img amend -f $IMGFMT -o backing_file="$TEST_IMG",,help "$TEST_IMG" ++run_qemu_img rebase -u -b "" -f $IMGFMT "$TEST_IMG" ++ ++run_qemu_img amend -f $IMGFMT -o backing_file="$TEST_IMG",,\? "$TEST_IMG" ++run_qemu_img rebase -u -b "" -f $IMGFMT "$TEST_IMG" ++ ++# Try to trick qemu-img into creating escaped commas ++run_qemu_img amend -f $IMGFMT -o backing_file="$TEST_IMG", -o help "$TEST_IMG" ++run_qemu_img amend -f $IMGFMT -o backing_file="$TEST_IMG" -o ,help "$TEST_IMG" ++run_qemu_img amend -f $IMGFMT -o backing_file="$TEST_IMG" -o ,, -o help "$TEST_IMG" ++ ++# Leave out everything that isn't needed ++run_qemu_img amend -f $IMGFMT -o help ++run_qemu_img convert -o help ++ ++# success, all done ++echo "*** done" ++rm -f $seq.full ++status=0 +diff --git a/tests/qemu-iotests/082.out b/tests/qemu-iotests/082.out +new file mode 100644 +index 0000000..d71610b +--- /dev/null ++++ b/tests/qemu-iotests/082.out +@@ -0,0 +1,529 @@ ++QA output created by 082 ++ ++=== create: Options specified more than once === ++ ++Testing: create -f foo -f qcow2 TEST_DIR/t.qcow2 128M ++Formatting 'TEST_DIR/t.qcow2', fmt=qcow2 size=134217728 encryption=off cluster_size=65536 lazy_refcounts=off ++ ++Testing: info TEST_DIR/t.qcow2 ++image: TEST_DIR/t.qcow2 ++file format: qcow2 ++virtual size: 128M (134217728 bytes) ++disk size: 196K ++cluster_size: 65536 ++Format specific information: ++ compat: 1.1 ++ lazy refcounts: false ++ ++Testing: create -f qcow2 -o cluster_size=4k -o lazy_refcounts=on TEST_DIR/t.qcow2 128M ++Formatting 'TEST_DIR/t.qcow2', fmt=qcow2 size=134217728 encryption=off cluster_size=4096 lazy_refcounts=on ++ ++Testing: info TEST_DIR/t.qcow2 ++image: TEST_DIR/t.qcow2 ++file format: qcow2 ++virtual size: 128M (134217728 bytes) ++disk size: 16K ++cluster_size: 4096 ++Format specific information: ++ compat: 1.1 ++ lazy refcounts: true ++ ++Testing: create -f qcow2 -o cluster_size=4k -o lazy_refcounts=on -o cluster_size=8k TEST_DIR/t.qcow2 128M ++Formatting 'TEST_DIR/t.qcow2', fmt=qcow2 size=134217728 encryption=off cluster_size=8192 lazy_refcounts=on ++ ++Testing: info TEST_DIR/t.qcow2 ++image: TEST_DIR/t.qcow2 ++file format: qcow2 ++virtual size: 128M (134217728 bytes) ++disk size: 28K ++cluster_size: 8192 ++Format specific information: ++ compat: 1.1 ++ lazy refcounts: true ++ ++Testing: create -f qcow2 -o cluster_size=4k,cluster_size=8k TEST_DIR/t.qcow2 128M ++Formatting 'TEST_DIR/t.qcow2', fmt=qcow2 size=134217728 encryption=off cluster_size=8192 lazy_refcounts=off ++ ++Testing: info TEST_DIR/t.qcow2 ++image: TEST_DIR/t.qcow2 ++file format: qcow2 ++virtual size: 128M (134217728 bytes) ++disk size: 28K ++cluster_size: 8192 ++Format specific information: ++ compat: 1.1 ++ lazy refcounts: false ++ ++=== create: help for -o === ++ ++Testing: create -f qcow2 -o help TEST_DIR/t.qcow2 128M ++Supported options: ++size Virtual disk size ++compat Compatibility level (0.10 or 1.1) ++backing_file File name of a base image ++backing_fmt Image format of the base image ++encryption Encrypt the image ++cluster_size qcow2 cluster size ++preallocation Preallocation mode (allowed values: off, metadata) ++lazy_refcounts Postpone refcount updates ++ ++Testing: create -f qcow2 -o ? TEST_DIR/t.qcow2 128M ++Supported options: ++size Virtual disk size ++compat Compatibility level (0.10 or 1.1) ++backing_file File name of a base image ++backing_fmt Image format of the base image ++encryption Encrypt the image ++cluster_size qcow2 cluster size ++preallocation Preallocation mode (allowed values: off, metadata) ++lazy_refcounts Postpone refcount updates ++ ++Testing: create -f qcow2 -o cluster_size=4k,help TEST_DIR/t.qcow2 128M ++Supported options: ++size Virtual disk size ++compat Compatibility level (0.10 or 1.1) ++backing_file File name of a base image ++backing_fmt Image format of the base image ++encryption Encrypt the image ++cluster_size qcow2 cluster size ++preallocation Preallocation mode (allowed values: off, metadata) ++lazy_refcounts Postpone refcount updates ++ ++Testing: create -f qcow2 -o cluster_size=4k,? TEST_DIR/t.qcow2 128M ++Supported options: ++size Virtual disk size ++compat Compatibility level (0.10 or 1.1) ++backing_file File name of a base image ++backing_fmt Image format of the base image ++encryption Encrypt the image ++cluster_size qcow2 cluster size ++preallocation Preallocation mode (allowed values: off, metadata) ++lazy_refcounts Postpone refcount updates ++ ++Testing: create -f qcow2 -o help,cluster_size=4k TEST_DIR/t.qcow2 128M ++Supported options: ++size Virtual disk size ++compat Compatibility level (0.10 or 1.1) ++backing_file File name of a base image ++backing_fmt Image format of the base image ++encryption Encrypt the image ++cluster_size qcow2 cluster size ++preallocation Preallocation mode (allowed values: off, metadata) ++lazy_refcounts Postpone refcount updates ++ ++Testing: create -f qcow2 -o ?,cluster_size=4k TEST_DIR/t.qcow2 128M ++Supported options: ++size Virtual disk size ++compat Compatibility level (0.10 or 1.1) ++backing_file File name of a base image ++backing_fmt Image format of the base image ++encryption Encrypt the image ++cluster_size qcow2 cluster size ++preallocation Preallocation mode (allowed values: off, metadata) ++lazy_refcounts Postpone refcount updates ++ ++Testing: create -f qcow2 -o cluster_size=4k -o help TEST_DIR/t.qcow2 128M ++Supported options: ++size Virtual disk size ++compat Compatibility level (0.10 or 1.1) ++backing_file File name of a base image ++backing_fmt Image format of the base image ++encryption Encrypt the image ++cluster_size qcow2 cluster size ++preallocation Preallocation mode (allowed values: off, metadata) ++lazy_refcounts Postpone refcount updates ++ ++Testing: create -f qcow2 -o cluster_size=4k -o ? TEST_DIR/t.qcow2 128M ++Supported options: ++size Virtual disk size ++compat Compatibility level (0.10 or 1.1) ++backing_file File name of a base image ++backing_fmt Image format of the base image ++encryption Encrypt the image ++cluster_size qcow2 cluster size ++preallocation Preallocation mode (allowed values: off, metadata) ++lazy_refcounts Postpone refcount updates ++ ++Testing: create -f qcow2 -o backing_file=TEST_DIR/t.qcow2,,help TEST_DIR/t.qcow2 128M ++Formatting 'TEST_DIR/t.qcow2', fmt=qcow2 size=134217728 backing_file='TEST_DIR/t.qcow2,help' encryption=off cluster_size=65536 lazy_refcounts=off ++ ++Testing: create -f qcow2 -o backing_file=TEST_DIR/t.qcow2,,? TEST_DIR/t.qcow2 128M ++Formatting 'TEST_DIR/t.qcow2', fmt=qcow2 size=134217728 backing_file='TEST_DIR/t.qcow2,?' encryption=off cluster_size=65536 lazy_refcounts=off ++ ++Testing: create -f qcow2 -o backing_file=TEST_DIR/t.qcow2, -o help TEST_DIR/t.qcow2 128M ++qemu-img: Invalid option list: backing_file=TEST_DIR/t.qcow2, ++ ++Testing: create -f qcow2 -o backing_file=TEST_DIR/t.qcow2 -o ,help TEST_DIR/t.qcow2 128M ++qemu-img: Invalid option list: ,help ++ ++Testing: create -f qcow2 -o backing_file=TEST_DIR/t.qcow2 -o ,, -o help TEST_DIR/t.qcow2 128M ++qemu-img: Invalid option list: ,, ++ ++Testing: create -f qcow2 -o help ++Supported options: ++size Virtual disk size ++compat Compatibility level (0.10 or 1.1) ++backing_file File name of a base image ++backing_fmt Image format of the base image ++encryption Encrypt the image ++cluster_size qcow2 cluster size ++preallocation Preallocation mode (allowed values: off, metadata) ++lazy_refcounts Postpone refcount updates ++ ++Testing: create -o help ++Supported options: ++size Virtual disk size ++ ++=== convert: Options specified more than once === ++ ++Testing: create -f qcow2 TEST_DIR/t.qcow2 128M ++Formatting 'TEST_DIR/t.qcow2', fmt=qcow2 size=134217728 encryption=off cluster_size=65536 lazy_refcounts=off ++ ++Testing: convert -f foo -f qcow2 TEST_DIR/t.qcow2 TEST_DIR/t.qcow2.base ++ ++Testing: info TEST_DIR/t.qcow2.base ++image: TEST_DIR/t.qcow2.base ++file format: raw ++virtual size: 128M (134217728 bytes) ++disk size: 0 ++ ++Testing: convert -O foo -O qcow2 TEST_DIR/t.qcow2 TEST_DIR/t.qcow2.base ++ ++Testing: info TEST_DIR/t.qcow2.base ++image: TEST_DIR/t.qcow2.base ++file format: qcow2 ++virtual size: 128M (134217728 bytes) ++disk size: 196K ++cluster_size: 65536 ++Format specific information: ++ compat: 1.1 ++ lazy refcounts: false ++ ++Testing: convert -O qcow2 -o cluster_size=4k -o lazy_refcounts=on TEST_DIR/t.qcow2 TEST_DIR/t.qcow2.base ++ ++Testing: info TEST_DIR/t.qcow2.base ++image: TEST_DIR/t.qcow2.base ++file format: qcow2 ++virtual size: 128M (134217728 bytes) ++disk size: 16K ++cluster_size: 4096 ++Format specific information: ++ compat: 1.1 ++ lazy refcounts: true ++ ++Testing: convert -O qcow2 -o cluster_size=4k -o lazy_refcounts=on -o cluster_size=8k TEST_DIR/t.qcow2 TEST_DIR/t.qcow2.base ++ ++Testing: info TEST_DIR/t.qcow2.base ++image: TEST_DIR/t.qcow2.base ++file format: qcow2 ++virtual size: 128M (134217728 bytes) ++disk size: 28K ++cluster_size: 8192 ++Format specific information: ++ compat: 1.1 ++ lazy refcounts: true ++ ++Testing: convert -O qcow2 -o cluster_size=4k,cluster_size=8k TEST_DIR/t.qcow2 TEST_DIR/t.qcow2.base ++ ++Testing: info TEST_DIR/t.qcow2.base ++image: TEST_DIR/t.qcow2.base ++file format: qcow2 ++virtual size: 128M (134217728 bytes) ++disk size: 28K ++cluster_size: 8192 ++Format specific information: ++ compat: 1.1 ++ lazy refcounts: false ++ ++=== convert: help for -o === ++ ++Testing: convert -O qcow2 -o help TEST_DIR/t.qcow2 TEST_DIR/t.qcow2.base ++Supported options: ++size Virtual disk size ++compat Compatibility level (0.10 or 1.1) ++backing_file File name of a base image ++backing_fmt Image format of the base image ++encryption Encrypt the image ++cluster_size qcow2 cluster size ++preallocation Preallocation mode (allowed values: off, metadata) ++lazy_refcounts Postpone refcount updates ++ ++Testing: convert -O qcow2 -o ? TEST_DIR/t.qcow2 TEST_DIR/t.qcow2.base ++Supported options: ++size Virtual disk size ++compat Compatibility level (0.10 or 1.1) ++backing_file File name of a base image ++backing_fmt Image format of the base image ++encryption Encrypt the image ++cluster_size qcow2 cluster size ++preallocation Preallocation mode (allowed values: off, metadata) ++lazy_refcounts Postpone refcount updates ++ ++Testing: convert -O qcow2 -o cluster_size=4k,help TEST_DIR/t.qcow2 TEST_DIR/t.qcow2.base ++Supported options: ++size Virtual disk size ++compat Compatibility level (0.10 or 1.1) ++backing_file File name of a base image ++backing_fmt Image format of the base image ++encryption Encrypt the image ++cluster_size qcow2 cluster size ++preallocation Preallocation mode (allowed values: off, metadata) ++lazy_refcounts Postpone refcount updates ++ ++Testing: convert -O qcow2 -o cluster_size=4k,? TEST_DIR/t.qcow2 TEST_DIR/t.qcow2.base ++Supported options: ++size Virtual disk size ++compat Compatibility level (0.10 or 1.1) ++backing_file File name of a base image ++backing_fmt Image format of the base image ++encryption Encrypt the image ++cluster_size qcow2 cluster size ++preallocation Preallocation mode (allowed values: off, metadata) ++lazy_refcounts Postpone refcount updates ++ ++Testing: convert -O qcow2 -o help,cluster_size=4k TEST_DIR/t.qcow2 TEST_DIR/t.qcow2.base ++Supported options: ++size Virtual disk size ++compat Compatibility level (0.10 or 1.1) ++backing_file File name of a base image ++backing_fmt Image format of the base image ++encryption Encrypt the image ++cluster_size qcow2 cluster size ++preallocation Preallocation mode (allowed values: off, metadata) ++lazy_refcounts Postpone refcount updates ++ ++Testing: convert -O qcow2 -o ?,cluster_size=4k TEST_DIR/t.qcow2 TEST_DIR/t.qcow2.base ++Supported options: ++size Virtual disk size ++compat Compatibility level (0.10 or 1.1) ++backing_file File name of a base image ++backing_fmt Image format of the base image ++encryption Encrypt the image ++cluster_size qcow2 cluster size ++preallocation Preallocation mode (allowed values: off, metadata) ++lazy_refcounts Postpone refcount updates ++ ++Testing: convert -O qcow2 -o cluster_size=4k -o help TEST_DIR/t.qcow2 TEST_DIR/t.qcow2.base ++Supported options: ++size Virtual disk size ++compat Compatibility level (0.10 or 1.1) ++backing_file File name of a base image ++backing_fmt Image format of the base image ++encryption Encrypt the image ++cluster_size qcow2 cluster size ++preallocation Preallocation mode (allowed values: off, metadata) ++lazy_refcounts Postpone refcount updates ++ ++Testing: convert -O qcow2 -o cluster_size=4k -o ? TEST_DIR/t.qcow2 TEST_DIR/t.qcow2.base ++Supported options: ++size Virtual disk size ++compat Compatibility level (0.10 or 1.1) ++backing_file File name of a base image ++backing_fmt Image format of the base image ++encryption Encrypt the image ++cluster_size qcow2 cluster size ++preallocation Preallocation mode (allowed values: off, metadata) ++lazy_refcounts Postpone refcount updates ++ ++Testing: convert -O qcow2 -o backing_file=TEST_DIR/t.qcow2,,help TEST_DIR/t.qcow2 TEST_DIR/t.qcow2.base ++qemu-img: Could not open 'TEST_DIR/t.qcow2.base': Could not open file: No such file or directory ++ ++Testing: convert -O qcow2 -o backing_file=TEST_DIR/t.qcow2,,? TEST_DIR/t.qcow2 TEST_DIR/t.qcow2.base ++qemu-img: Could not open 'TEST_DIR/t.qcow2.base': Could not open file: No such file or directory ++ ++Testing: convert -O qcow2 -o backing_file=TEST_DIR/t.qcow2, -o help TEST_DIR/t.qcow2 TEST_DIR/t.qcow2.base ++qemu-img: Invalid option list: backing_file=TEST_DIR/t.qcow2, ++ ++Testing: convert -O qcow2 -o backing_file=TEST_DIR/t.qcow2 -o ,help TEST_DIR/t.qcow2 TEST_DIR/t.qcow2.base ++qemu-img: Invalid option list: ,help ++ ++Testing: convert -O qcow2 -o backing_file=TEST_DIR/t.qcow2 -o ,, -o help TEST_DIR/t.qcow2 TEST_DIR/t.qcow2.base ++qemu-img: Invalid option list: ,, ++ ++Testing: convert -O qcow2 -o help ++Supported options: ++size Virtual disk size ++compat Compatibility level (0.10 or 1.1) ++backing_file File name of a base image ++backing_fmt Image format of the base image ++encryption Encrypt the image ++cluster_size qcow2 cluster size ++preallocation Preallocation mode (allowed values: off, metadata) ++lazy_refcounts Postpone refcount updates ++ ++Testing: convert -o help ++Supported options: ++size Virtual disk size ++ ++=== amend: Options specified more than once === ++ ++Testing: amend -f foo -f qcow2 -o lazy_refcounts=on TEST_DIR/t.qcow2 ++ ++Testing: info TEST_DIR/t.qcow2 ++image: TEST_DIR/t.qcow2 ++file format: qcow2 ++virtual size: 128M (134217728 bytes) ++disk size: 196K ++cluster_size: 65536 ++Format specific information: ++ compat: 1.1 ++ lazy refcounts: true ++ ++Testing: amend -f qcow2 -o size=130M -o lazy_refcounts=off TEST_DIR/t.qcow2 ++ ++Testing: info TEST_DIR/t.qcow2 ++image: TEST_DIR/t.qcow2 ++file format: qcow2 ++virtual size: 130M (136314880 bytes) ++disk size: 196K ++cluster_size: 65536 ++Format specific information: ++ compat: 1.1 ++ lazy refcounts: false ++ ++Testing: amend -f qcow2 -o size=8M -o lazy_refcounts=on -o size=132M TEST_DIR/t.qcow2 ++ ++Testing: info TEST_DIR/t.qcow2 ++image: TEST_DIR/t.qcow2 ++file format: qcow2 ++virtual size: 132M (138412032 bytes) ++disk size: 196K ++cluster_size: 65536 ++Format specific information: ++ compat: 1.1 ++ lazy refcounts: true ++ ++Testing: amend -f qcow2 -o size=4M,size=148M TEST_DIR/t.qcow2 ++ ++Testing: info TEST_DIR/t.qcow2 ++image: TEST_DIR/t.qcow2 ++file format: qcow2 ++virtual size: 148M (155189248 bytes) ++disk size: 196K ++cluster_size: 65536 ++Format specific information: ++ compat: 1.1 ++ lazy refcounts: true ++ ++=== amend: help for -o === ++ ++Testing: amend -f qcow2 -o help TEST_DIR/t.qcow2 ++Supported options: ++size Virtual disk size ++compat Compatibility level (0.10 or 1.1) ++backing_file File name of a base image ++backing_fmt Image format of the base image ++encryption Encrypt the image ++cluster_size qcow2 cluster size ++preallocation Preallocation mode (allowed values: off, metadata) ++lazy_refcounts Postpone refcount updates ++ ++Testing: amend -f qcow2 -o ? TEST_DIR/t.qcow2 ++Supported options: ++size Virtual disk size ++compat Compatibility level (0.10 or 1.1) ++backing_file File name of a base image ++backing_fmt Image format of the base image ++encryption Encrypt the image ++cluster_size qcow2 cluster size ++preallocation Preallocation mode (allowed values: off, metadata) ++lazy_refcounts Postpone refcount updates ++ ++Testing: amend -f qcow2 -o cluster_size=4k,help TEST_DIR/t.qcow2 ++Supported options: ++size Virtual disk size ++compat Compatibility level (0.10 or 1.1) ++backing_file File name of a base image ++backing_fmt Image format of the base image ++encryption Encrypt the image ++cluster_size qcow2 cluster size ++preallocation Preallocation mode (allowed values: off, metadata) ++lazy_refcounts Postpone refcount updates ++ ++Testing: amend -f qcow2 -o cluster_size=4k,? TEST_DIR/t.qcow2 ++Supported options: ++size Virtual disk size ++compat Compatibility level (0.10 or 1.1) ++backing_file File name of a base image ++backing_fmt Image format of the base image ++encryption Encrypt the image ++cluster_size qcow2 cluster size ++preallocation Preallocation mode (allowed values: off, metadata) ++lazy_refcounts Postpone refcount updates ++ ++Testing: amend -f qcow2 -o help,cluster_size=4k TEST_DIR/t.qcow2 ++Supported options: ++size Virtual disk size ++compat Compatibility level (0.10 or 1.1) ++backing_file File name of a base image ++backing_fmt Image format of the base image ++encryption Encrypt the image ++cluster_size qcow2 cluster size ++preallocation Preallocation mode (allowed values: off, metadata) ++lazy_refcounts Postpone refcount updates ++ ++Testing: amend -f qcow2 -o ?,cluster_size=4k TEST_DIR/t.qcow2 ++Supported options: ++size Virtual disk size ++compat Compatibility level (0.10 or 1.1) ++backing_file File name of a base image ++backing_fmt Image format of the base image ++encryption Encrypt the image ++cluster_size qcow2 cluster size ++preallocation Preallocation mode (allowed values: off, metadata) ++lazy_refcounts Postpone refcount updates ++ ++Testing: amend -f qcow2 -o cluster_size=4k -o help TEST_DIR/t.qcow2 ++Supported options: ++size Virtual disk size ++compat Compatibility level (0.10 or 1.1) ++backing_file File name of a base image ++backing_fmt Image format of the base image ++encryption Encrypt the image ++cluster_size qcow2 cluster size ++preallocation Preallocation mode (allowed values: off, metadata) ++lazy_refcounts Postpone refcount updates ++ ++Testing: amend -f qcow2 -o cluster_size=4k -o ? TEST_DIR/t.qcow2 ++Supported options: ++size Virtual disk size ++compat Compatibility level (0.10 or 1.1) ++backing_file File name of a base image ++backing_fmt Image format of the base image ++encryption Encrypt the image ++cluster_size qcow2 cluster size ++preallocation Preallocation mode (allowed values: off, metadata) ++lazy_refcounts Postpone refcount updates ++ ++Testing: amend -f qcow2 -o backing_file=TEST_DIR/t.qcow2,,help TEST_DIR/t.qcow2 ++ ++Testing: rebase -u -b -f qcow2 TEST_DIR/t.qcow2 ++ ++Testing: amend -f qcow2 -o backing_file=TEST_DIR/t.qcow2,,? TEST_DIR/t.qcow2 ++ ++Testing: rebase -u -b -f qcow2 TEST_DIR/t.qcow2 ++ ++Testing: amend -f qcow2 -o backing_file=TEST_DIR/t.qcow2, -o help TEST_DIR/t.qcow2 ++qemu-img: Invalid option list: backing_file=TEST_DIR/t.qcow2, ++ ++Testing: amend -f qcow2 -o backing_file=TEST_DIR/t.qcow2 -o ,help TEST_DIR/t.qcow2 ++qemu-img: Invalid option list: ,help ++ ++Testing: amend -f qcow2 -o backing_file=TEST_DIR/t.qcow2 -o ,, -o help TEST_DIR/t.qcow2 ++qemu-img: Invalid option list: ,, ++ ++Testing: amend -f qcow2 -o help ++Supported options: ++size Virtual disk size ++compat Compatibility level (0.10 or 1.1) ++backing_file File name of a base image ++backing_fmt Image format of the base image ++encryption Encrypt the image ++cluster_size qcow2 cluster size ++preallocation Preallocation mode (allowed values: off, metadata) ++lazy_refcounts Postpone refcount updates ++ ++Testing: convert -o help ++Supported options: ++size Virtual disk size ++*** done +diff --git a/tests/qemu-iotests/group b/tests/qemu-iotests/group +index fce6ca8..ee95d6e 100644 +--- a/tests/qemu-iotests/group ++++ b/tests/qemu-iotests/group +@@ -73,3 +73,4 @@ + 070 rw auto + 077 rw auto + 079 rw auto ++082 rw auto quick +-- +1.7.1 + diff --git a/SOURCES/kvm-qemu-iotests-Extend-041-for-unbacked-mirroring.patch b/SOURCES/kvm-qemu-iotests-Extend-041-for-unbacked-mirroring.patch new file mode 100644 index 0000000..805ba8b --- /dev/null +++ b/SOURCES/kvm-qemu-iotests-Extend-041-for-unbacked-mirroring.patch @@ -0,0 +1,88 @@ +From 728f93f0bf205f8b4ebbf2c4f0e57ecd63e1ea98 Mon Sep 17 00:00:00 2001 +From: Max Reitz +Date: Sun, 19 Jan 2014 18:07:58 +0100 +Subject: [PATCH 24/34] qemu-iotests: Extend 041 for unbacked mirroring + +RH-Author: Max Reitz +Message-id: <1390154881-17140-5-git-send-email-mreitz@redhat.com> +Patchwork-id: 56817 +O-Subject: [RHEL-7.0 qemu-kvm PATCH v2 4/7] qemu-iotests: Extend 041 for unbacked mirroring +Bugzilla: 921890 +RH-Acked-by: Fam Zheng +RH-Acked-by: Kevin Wolf +RH-Acked-by: Jeffrey Cody + +BZ: 921890 + +Add a new test case in file 041 for mirroring unbacked images in +"absolute-paths" mode. This should work, if possible, but most +importantly, qemu should never crash. + +Signed-off-by: Max Reitz +Reviewed-by: Wenchao Xia +Reviewed-by: Paolo Bonzini +Signed-off-by: Kevin Wolf +(cherry picked from commit c15badee200f9e743e3639cc5e3e7dd62c69332f) + +Signed-off-by: Max Reitz +--- + tests/qemu-iotests/041 | 25 +++++++++++++++++++++++++ + tests/qemu-iotests/041.out | 4 ++-- + 2 files changed, 27 insertions(+), 2 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + tests/qemu-iotests/041 | 25 +++++++++++++++++++++++++ + tests/qemu-iotests/041.out | 4 ++-- + 2 files changed, 27 insertions(+), 2 deletions(-) + +diff --git a/tests/qemu-iotests/041 b/tests/qemu-iotests/041 +index ff89427..eccfe38 100755 +--- a/tests/qemu-iotests/041 ++++ b/tests/qemu-iotests/041 +@@ -736,5 +736,30 @@ class TestSetSpeed(ImageMirroringTestCase): + + self.cancel_and_wait() + ++class TestUnbackedSource(ImageMirroringTestCase): ++ image_len = 2 * 1024 * 1024 # MB ++ ++ def setUp(self): ++ qemu_img('create', '-f', iotests.imgfmt, test_img, ++ str(TestUnbackedSource.image_len)) ++ self.vm = iotests.VM().add_drive(test_img) ++ self.vm.launch() ++ ++ def tearDown(self): ++ self.vm.shutdown() ++ os.remove(test_img) ++ os.remove(target_img) ++ ++ def test_absolute_paths(self): ++ self.assert_no_active_block_jobs() ++ ++ for sync_mode in ['full', 'top', 'none']: ++ result = self.vm.qmp('drive-mirror', device='drive0', ++ sync=sync_mode, target=target_img, ++ mode='absolute-paths') ++ self.assert_qmp(result, 'return', {}) ++ self.complete_and_wait() ++ self.assert_no_active_block_jobs() ++ + if __name__ == '__main__': + iotests.main(supported_fmts=['qcow2', 'qed']) +diff --git a/tests/qemu-iotests/041.out b/tests/qemu-iotests/041.out +index 42314e9..4fd1c2d 100644 +--- a/tests/qemu-iotests/041.out ++++ b/tests/qemu-iotests/041.out +@@ -1,5 +1,5 @@ +-........................ ++......................... + ---------------------------------------------------------------------- +-Ran 24 tests ++Ran 25 tests + + OK +-- +1.7.1 + diff --git a/SOURCES/kvm-qemu-iotests-Filter-out-qemu-io-prompt.patch b/SOURCES/kvm-qemu-iotests-Filter-out-qemu-io-prompt.patch new file mode 100644 index 0000000..2431f21 --- /dev/null +++ b/SOURCES/kvm-qemu-iotests-Filter-out-qemu-io-prompt.patch @@ -0,0 +1,225458 @@ +From 20316e8a2cb7499d5430382b6cf85e34308304a4 Mon Sep 17 00:00:00 2001 +From: Kevin Wolf +Date: Mon, 18 Nov 2013 15:13:01 +0800 +Subject: [PATCH 34/37] qemu-iotests: Filter out 'qemu-io> ' prompt + +Message-id: n/a, patch too big +Patchwork-id: n/a, patch too big +O-Subject: n/a, patch too big +Bugzilla: 748906 +RH-Acked-by: Laszlo Ersek +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Max Reitz + +This removes "qemu-io> " prompt from qemu-io output in _filter_qemu_io, +and updates all the output files with the following command: + + cd tests/qemu-iotests && sed -i "s/qemu-io> //g" *.out + +Signed-off-by: Fam Zheng +Reviewed-by: Eric Blake +Signed-off-by: Kevin Wolf +(cherry picked from commit c34b8012e877f494c7be5abdfb67b51242a6935e) + +Conflicts: + tests/qemu-iotests/048.out + +Signed-off-by: Kevin Wolf +--- + tests/qemu-iotests/013.out |44080 +++++++++++++------------- + tests/qemu-iotests/014.out |64204 +++++++++++++++++++------------------- + tests/qemu-iotests/017.out | 1080 +- + tests/qemu-iotests/018.out | 1080 +- + tests/qemu-iotests/019.out | 1636 +- + tests/qemu-iotests/020.out | 1080 +- + tests/qemu-iotests/022.out | 8816 +++--- + tests/qemu-iotests/023.out |26800 ++++++++-------- + tests/qemu-iotests/024.out | 164 +- + tests/qemu-iotests/025.out | 18 +- + tests/qemu-iotests/028.out | 458 +- + tests/qemu-iotests/032.out | 68 +- + tests/qemu-iotests/035.out | 2 +- + tests/qemu-iotests/037.out | 616 +- + tests/qemu-iotests/038.out | 714 +- + tests/qemu-iotests/046.out | 232 +- + tests/qemu-iotests/047.out | 20 +- + tests/qemu-iotests/048.out | 18 +- + tests/qemu-iotests/common.filter | 3 +- + 19 files changed, 75545 insertions(+), 75544 deletions(-) + +diff --git a/tests/qemu-iotests/013.out b/tests/qemu-iotests/013.out +index 0d57187..43a414c 100644 +--- a/tests/qemu-iotests/013.out ++++ b/tests/qemu-iotests/013.out +@@ -4,43980 +4,43980 @@ Testing empty image + + At offset 0: + === IO: pattern 0 +-qemu-io> wrote 4096/4096 bytes at offset 0 ++wrote 4096/4096 bytes at offset 0 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4096 ++wrote 4096/4096 bytes at offset 4096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8192 ++wrote 4096/4096 bytes at offset 8192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 12288 ++wrote 4096/4096 bytes at offset 12288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 16384 ++wrote 4096/4096 bytes at offset 16384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 20480 ++wrote 4096/4096 bytes at offset 20480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 24576 ++wrote 4096/4096 bytes at offset 24576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 28672 ++wrote 4096/4096 bytes at offset 28672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 32768 ++wrote 4096/4096 bytes at offset 32768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 36864 ++wrote 4096/4096 bytes at offset 36864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 40960 ++wrote 4096/4096 bytes at offset 40960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 45056 ++wrote 4096/4096 bytes at offset 45056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 49152 ++wrote 4096/4096 bytes at offset 49152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 53248 ++wrote 4096/4096 bytes at offset 53248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 57344 ++wrote 4096/4096 bytes at offset 57344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 61440 ++wrote 4096/4096 bytes at offset 61440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 65536 ++wrote 4096/4096 bytes at offset 65536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 69632 ++wrote 4096/4096 bytes at offset 69632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 73728 ++wrote 4096/4096 bytes at offset 73728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 77824 ++wrote 4096/4096 bytes at offset 77824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 81920 ++wrote 4096/4096 bytes at offset 81920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 86016 ++wrote 4096/4096 bytes at offset 86016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 90112 ++wrote 4096/4096 bytes at offset 90112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 94208 ++wrote 4096/4096 bytes at offset 94208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 98304 ++wrote 4096/4096 bytes at offset 98304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 102400 ++wrote 4096/4096 bytes at offset 102400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 106496 ++wrote 4096/4096 bytes at offset 106496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 110592 ++wrote 4096/4096 bytes at offset 110592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 114688 ++wrote 4096/4096 bytes at offset 114688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 118784 ++wrote 4096/4096 bytes at offset 118784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 122880 ++wrote 4096/4096 bytes at offset 122880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 126976 ++wrote 4096/4096 bytes at offset 126976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 131072 ++wrote 4096/4096 bytes at offset 131072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 135168 ++wrote 4096/4096 bytes at offset 135168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 139264 ++wrote 4096/4096 bytes at offset 139264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 143360 ++wrote 4096/4096 bytes at offset 143360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 147456 ++wrote 4096/4096 bytes at offset 147456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 151552 ++wrote 4096/4096 bytes at offset 151552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 155648 ++wrote 4096/4096 bytes at offset 155648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 159744 ++wrote 4096/4096 bytes at offset 159744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 163840 ++wrote 4096/4096 bytes at offset 163840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 167936 ++wrote 4096/4096 bytes at offset 167936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 172032 ++wrote 4096/4096 bytes at offset 172032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 176128 ++wrote 4096/4096 bytes at offset 176128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 180224 ++wrote 4096/4096 bytes at offset 180224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 184320 ++wrote 4096/4096 bytes at offset 184320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 188416 ++wrote 4096/4096 bytes at offset 188416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 192512 ++wrote 4096/4096 bytes at offset 192512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 196608 ++wrote 4096/4096 bytes at offset 196608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 200704 ++wrote 4096/4096 bytes at offset 200704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 204800 ++wrote 4096/4096 bytes at offset 204800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 208896 ++wrote 4096/4096 bytes at offset 208896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 212992 ++wrote 4096/4096 bytes at offset 212992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 217088 ++wrote 4096/4096 bytes at offset 217088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 221184 ++wrote 4096/4096 bytes at offset 221184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 225280 ++wrote 4096/4096 bytes at offset 225280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 229376 ++wrote 4096/4096 bytes at offset 229376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 233472 ++wrote 4096/4096 bytes at offset 233472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 237568 ++wrote 4096/4096 bytes at offset 237568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 241664 ++wrote 4096/4096 bytes at offset 241664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 245760 ++wrote 4096/4096 bytes at offset 245760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 249856 ++wrote 4096/4096 bytes at offset 249856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 253952 ++wrote 4096/4096 bytes at offset 253952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 258048 ++wrote 4096/4096 bytes at offset 258048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 262144 ++wrote 4096/4096 bytes at offset 262144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 266240 ++wrote 4096/4096 bytes at offset 266240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 270336 ++wrote 4096/4096 bytes at offset 270336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 274432 ++wrote 4096/4096 bytes at offset 274432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 278528 ++wrote 4096/4096 bytes at offset 278528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 282624 ++wrote 4096/4096 bytes at offset 282624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 286720 ++wrote 4096/4096 bytes at offset 286720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 290816 ++wrote 4096/4096 bytes at offset 290816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 294912 ++wrote 4096/4096 bytes at offset 294912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 299008 ++wrote 4096/4096 bytes at offset 299008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 303104 ++wrote 4096/4096 bytes at offset 303104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 307200 ++wrote 4096/4096 bytes at offset 307200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 311296 ++wrote 4096/4096 bytes at offset 311296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 315392 ++wrote 4096/4096 bytes at offset 315392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 319488 ++wrote 4096/4096 bytes at offset 319488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 323584 ++wrote 4096/4096 bytes at offset 323584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 327680 ++wrote 4096/4096 bytes at offset 327680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 331776 ++wrote 4096/4096 bytes at offset 331776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 335872 ++wrote 4096/4096 bytes at offset 335872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 339968 ++wrote 4096/4096 bytes at offset 339968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 344064 ++wrote 4096/4096 bytes at offset 344064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 348160 ++wrote 4096/4096 bytes at offset 348160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 352256 ++wrote 4096/4096 bytes at offset 352256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 356352 ++wrote 4096/4096 bytes at offset 356352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 360448 ++wrote 4096/4096 bytes at offset 360448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 364544 ++wrote 4096/4096 bytes at offset 364544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 368640 ++wrote 4096/4096 bytes at offset 368640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 372736 ++wrote 4096/4096 bytes at offset 372736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 376832 ++wrote 4096/4096 bytes at offset 376832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 380928 ++wrote 4096/4096 bytes at offset 380928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 385024 ++wrote 4096/4096 bytes at offset 385024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 389120 ++wrote 4096/4096 bytes at offset 389120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 393216 ++wrote 4096/4096 bytes at offset 393216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 397312 ++wrote 4096/4096 bytes at offset 397312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 401408 ++wrote 4096/4096 bytes at offset 401408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 405504 ++wrote 4096/4096 bytes at offset 405504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 409600 ++wrote 4096/4096 bytes at offset 409600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 413696 ++wrote 4096/4096 bytes at offset 413696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 417792 ++wrote 4096/4096 bytes at offset 417792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 421888 ++wrote 4096/4096 bytes at offset 421888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 425984 ++wrote 4096/4096 bytes at offset 425984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 430080 ++wrote 4096/4096 bytes at offset 430080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 434176 ++wrote 4096/4096 bytes at offset 434176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 438272 ++wrote 4096/4096 bytes at offset 438272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 442368 ++wrote 4096/4096 bytes at offset 442368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 446464 ++wrote 4096/4096 bytes at offset 446464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 450560 ++wrote 4096/4096 bytes at offset 450560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 454656 ++wrote 4096/4096 bytes at offset 454656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 458752 ++wrote 4096/4096 bytes at offset 458752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 462848 ++wrote 4096/4096 bytes at offset 462848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 466944 ++wrote 4096/4096 bytes at offset 466944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 471040 ++wrote 4096/4096 bytes at offset 471040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 475136 ++wrote 4096/4096 bytes at offset 475136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 479232 ++wrote 4096/4096 bytes at offset 479232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 483328 ++wrote 4096/4096 bytes at offset 483328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 487424 ++wrote 4096/4096 bytes at offset 487424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 491520 ++wrote 4096/4096 bytes at offset 491520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 495616 ++wrote 4096/4096 bytes at offset 495616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 499712 ++wrote 4096/4096 bytes at offset 499712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 503808 ++wrote 4096/4096 bytes at offset 503808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 507904 ++wrote 4096/4096 bytes at offset 507904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 512000 ++wrote 4096/4096 bytes at offset 512000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 516096 ++wrote 4096/4096 bytes at offset 516096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 520192 ++wrote 4096/4096 bytes at offset 520192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 524288 ++wrote 4096/4096 bytes at offset 524288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 528384 ++wrote 4096/4096 bytes at offset 528384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 532480 ++wrote 4096/4096 bytes at offset 532480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 536576 ++wrote 4096/4096 bytes at offset 536576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 540672 ++wrote 4096/4096 bytes at offset 540672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 544768 ++wrote 4096/4096 bytes at offset 544768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 548864 ++wrote 4096/4096 bytes at offset 548864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 552960 ++wrote 4096/4096 bytes at offset 552960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 557056 ++wrote 4096/4096 bytes at offset 557056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 561152 ++wrote 4096/4096 bytes at offset 561152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 565248 ++wrote 4096/4096 bytes at offset 565248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 569344 ++wrote 4096/4096 bytes at offset 569344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 573440 ++wrote 4096/4096 bytes at offset 573440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 577536 ++wrote 4096/4096 bytes at offset 577536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 581632 ++wrote 4096/4096 bytes at offset 581632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 585728 ++wrote 4096/4096 bytes at offset 585728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 589824 ++wrote 4096/4096 bytes at offset 589824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 593920 ++wrote 4096/4096 bytes at offset 593920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 598016 ++wrote 4096/4096 bytes at offset 598016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 602112 ++wrote 4096/4096 bytes at offset 602112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 606208 ++wrote 4096/4096 bytes at offset 606208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 610304 ++wrote 4096/4096 bytes at offset 610304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 614400 ++wrote 4096/4096 bytes at offset 614400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 618496 ++wrote 4096/4096 bytes at offset 618496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 622592 ++wrote 4096/4096 bytes at offset 622592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 626688 ++wrote 4096/4096 bytes at offset 626688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 630784 ++wrote 4096/4096 bytes at offset 630784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 634880 ++wrote 4096/4096 bytes at offset 634880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 638976 ++wrote 4096/4096 bytes at offset 638976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 643072 ++wrote 4096/4096 bytes at offset 643072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 647168 ++wrote 4096/4096 bytes at offset 647168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 651264 ++wrote 4096/4096 bytes at offset 651264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 655360 ++wrote 4096/4096 bytes at offset 655360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 659456 ++wrote 4096/4096 bytes at offset 659456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 663552 ++wrote 4096/4096 bytes at offset 663552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 667648 ++wrote 4096/4096 bytes at offset 667648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 671744 ++wrote 4096/4096 bytes at offset 671744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 675840 ++wrote 4096/4096 bytes at offset 675840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 679936 ++wrote 4096/4096 bytes at offset 679936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 684032 ++wrote 4096/4096 bytes at offset 684032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 688128 ++wrote 4096/4096 bytes at offset 688128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 692224 ++wrote 4096/4096 bytes at offset 692224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 696320 ++wrote 4096/4096 bytes at offset 696320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 700416 ++wrote 4096/4096 bytes at offset 700416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 704512 ++wrote 4096/4096 bytes at offset 704512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 708608 ++wrote 4096/4096 bytes at offset 708608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 712704 ++wrote 4096/4096 bytes at offset 712704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 716800 ++wrote 4096/4096 bytes at offset 716800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 720896 ++wrote 4096/4096 bytes at offset 720896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 724992 ++wrote 4096/4096 bytes at offset 724992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 729088 ++wrote 4096/4096 bytes at offset 729088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 733184 ++wrote 4096/4096 bytes at offset 733184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 737280 ++wrote 4096/4096 bytes at offset 737280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 741376 ++wrote 4096/4096 bytes at offset 741376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 745472 ++wrote 4096/4096 bytes at offset 745472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 749568 ++wrote 4096/4096 bytes at offset 749568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 753664 ++wrote 4096/4096 bytes at offset 753664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 757760 ++wrote 4096/4096 bytes at offset 757760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 761856 ++wrote 4096/4096 bytes at offset 761856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 765952 ++wrote 4096/4096 bytes at offset 765952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 770048 ++wrote 4096/4096 bytes at offset 770048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 774144 ++wrote 4096/4096 bytes at offset 774144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 778240 ++wrote 4096/4096 bytes at offset 778240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 782336 ++wrote 4096/4096 bytes at offset 782336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 786432 ++wrote 4096/4096 bytes at offset 786432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 790528 ++wrote 4096/4096 bytes at offset 790528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 794624 ++wrote 4096/4096 bytes at offset 794624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 798720 ++wrote 4096/4096 bytes at offset 798720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 802816 ++wrote 4096/4096 bytes at offset 802816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 806912 ++wrote 4096/4096 bytes at offset 806912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 811008 ++wrote 4096/4096 bytes at offset 811008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 815104 ++wrote 4096/4096 bytes at offset 815104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 819200 ++wrote 4096/4096 bytes at offset 819200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 823296 ++wrote 4096/4096 bytes at offset 823296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 827392 ++wrote 4096/4096 bytes at offset 827392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 831488 ++wrote 4096/4096 bytes at offset 831488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 835584 ++wrote 4096/4096 bytes at offset 835584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 839680 ++wrote 4096/4096 bytes at offset 839680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 843776 ++wrote 4096/4096 bytes at offset 843776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 847872 ++wrote 4096/4096 bytes at offset 847872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 851968 ++wrote 4096/4096 bytes at offset 851968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 856064 ++wrote 4096/4096 bytes at offset 856064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 860160 ++wrote 4096/4096 bytes at offset 860160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 864256 ++wrote 4096/4096 bytes at offset 864256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 868352 ++wrote 4096/4096 bytes at offset 868352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 872448 ++wrote 4096/4096 bytes at offset 872448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 876544 ++wrote 4096/4096 bytes at offset 876544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 880640 ++wrote 4096/4096 bytes at offset 880640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 884736 ++wrote 4096/4096 bytes at offset 884736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 888832 ++wrote 4096/4096 bytes at offset 888832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 892928 ++wrote 4096/4096 bytes at offset 892928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 897024 ++wrote 4096/4096 bytes at offset 897024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 901120 ++wrote 4096/4096 bytes at offset 901120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 905216 ++wrote 4096/4096 bytes at offset 905216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 909312 ++wrote 4096/4096 bytes at offset 909312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 913408 ++wrote 4096/4096 bytes at offset 913408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 917504 ++wrote 4096/4096 bytes at offset 917504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 921600 ++wrote 4096/4096 bytes at offset 921600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 925696 ++wrote 4096/4096 bytes at offset 925696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 929792 ++wrote 4096/4096 bytes at offset 929792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 933888 ++wrote 4096/4096 bytes at offset 933888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 937984 ++wrote 4096/4096 bytes at offset 937984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 942080 ++wrote 4096/4096 bytes at offset 942080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 946176 ++wrote 4096/4096 bytes at offset 946176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 950272 ++wrote 4096/4096 bytes at offset 950272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 954368 ++wrote 4096/4096 bytes at offset 954368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 958464 ++wrote 4096/4096 bytes at offset 958464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 962560 ++wrote 4096/4096 bytes at offset 962560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 966656 ++wrote 4096/4096 bytes at offset 966656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 970752 ++wrote 4096/4096 bytes at offset 970752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 974848 ++wrote 4096/4096 bytes at offset 974848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 978944 ++wrote 4096/4096 bytes at offset 978944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 983040 ++wrote 4096/4096 bytes at offset 983040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 987136 ++wrote 4096/4096 bytes at offset 987136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 991232 ++wrote 4096/4096 bytes at offset 991232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 995328 ++wrote 4096/4096 bytes at offset 995328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 999424 ++wrote 4096/4096 bytes at offset 999424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1003520 ++wrote 4096/4096 bytes at offset 1003520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1007616 ++wrote 4096/4096 bytes at offset 1007616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1011712 ++wrote 4096/4096 bytes at offset 1011712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1015808 ++wrote 4096/4096 bytes at offset 1015808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1019904 ++wrote 4096/4096 bytes at offset 1019904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1024000 ++wrote 4096/4096 bytes at offset 1024000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1028096 ++wrote 4096/4096 bytes at offset 1028096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1032192 ++wrote 4096/4096 bytes at offset 1032192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1036288 ++wrote 4096/4096 bytes at offset 1036288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1040384 ++wrote 4096/4096 bytes at offset 1040384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1044480 ++wrote 4096/4096 bytes at offset 1044480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 4 +-qemu-io> wrote 2048/2048 bytes at offset 1050624 ++=== IO: pattern 4 ++wrote 2048/2048 bytes at offset 1050624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1054720 ++wrote 2048/2048 bytes at offset 1054720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1058816 ++wrote 2048/2048 bytes at offset 1058816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1062912 ++wrote 2048/2048 bytes at offset 1062912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1067008 ++wrote 2048/2048 bytes at offset 1067008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1071104 ++wrote 2048/2048 bytes at offset 1071104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1075200 ++wrote 2048/2048 bytes at offset 1075200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1079296 ++wrote 2048/2048 bytes at offset 1079296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1083392 ++wrote 2048/2048 bytes at offset 1083392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1087488 ++wrote 2048/2048 bytes at offset 1087488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1091584 ++wrote 2048/2048 bytes at offset 1091584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1095680 ++wrote 2048/2048 bytes at offset 1095680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1099776 ++wrote 2048/2048 bytes at offset 1099776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1103872 ++wrote 2048/2048 bytes at offset 1103872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1107968 ++wrote 2048/2048 bytes at offset 1107968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1112064 ++wrote 2048/2048 bytes at offset 1112064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1116160 ++wrote 2048/2048 bytes at offset 1116160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1120256 ++wrote 2048/2048 bytes at offset 1120256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1124352 ++wrote 2048/2048 bytes at offset 1124352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1128448 ++wrote 2048/2048 bytes at offset 1128448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1132544 ++wrote 2048/2048 bytes at offset 1132544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1136640 ++wrote 2048/2048 bytes at offset 1136640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1140736 ++wrote 2048/2048 bytes at offset 1140736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1144832 ++wrote 2048/2048 bytes at offset 1144832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1148928 ++wrote 2048/2048 bytes at offset 1148928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1153024 ++wrote 2048/2048 bytes at offset 1153024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1157120 ++wrote 2048/2048 bytes at offset 1157120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1161216 ++wrote 2048/2048 bytes at offset 1161216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1165312 ++wrote 2048/2048 bytes at offset 1165312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1169408 ++wrote 2048/2048 bytes at offset 1169408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1173504 ++wrote 2048/2048 bytes at offset 1173504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1177600 ++wrote 2048/2048 bytes at offset 1177600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1181696 ++wrote 2048/2048 bytes at offset 1181696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1185792 ++wrote 2048/2048 bytes at offset 1185792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1189888 ++wrote 2048/2048 bytes at offset 1189888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1193984 ++wrote 2048/2048 bytes at offset 1193984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1198080 ++wrote 2048/2048 bytes at offset 1198080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1202176 ++wrote 2048/2048 bytes at offset 1202176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1206272 ++wrote 2048/2048 bytes at offset 1206272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1210368 ++wrote 2048/2048 bytes at offset 1210368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1214464 ++wrote 2048/2048 bytes at offset 1214464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1218560 ++wrote 2048/2048 bytes at offset 1218560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1222656 ++wrote 2048/2048 bytes at offset 1222656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1226752 ++wrote 2048/2048 bytes at offset 1226752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1230848 ++wrote 2048/2048 bytes at offset 1230848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1234944 ++wrote 2048/2048 bytes at offset 1234944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1239040 ++wrote 2048/2048 bytes at offset 1239040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1243136 ++wrote 2048/2048 bytes at offset 1243136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1247232 ++wrote 2048/2048 bytes at offset 1247232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1251328 ++wrote 2048/2048 bytes at offset 1251328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1255424 ++wrote 2048/2048 bytes at offset 1255424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1259520 ++wrote 2048/2048 bytes at offset 1259520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1263616 ++wrote 2048/2048 bytes at offset 1263616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1267712 ++wrote 2048/2048 bytes at offset 1267712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1271808 ++wrote 2048/2048 bytes at offset 1271808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1275904 ++wrote 2048/2048 bytes at offset 1275904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1280000 ++wrote 2048/2048 bytes at offset 1280000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1284096 ++wrote 2048/2048 bytes at offset 1284096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1288192 ++wrote 2048/2048 bytes at offset 1288192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1292288 ++wrote 2048/2048 bytes at offset 1292288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1296384 ++wrote 2048/2048 bytes at offset 1296384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1300480 ++wrote 2048/2048 bytes at offset 1300480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1304576 ++wrote 2048/2048 bytes at offset 1304576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1308672 ++wrote 2048/2048 bytes at offset 1308672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1312768 ++wrote 2048/2048 bytes at offset 1312768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1316864 ++wrote 2048/2048 bytes at offset 1316864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1320960 ++wrote 2048/2048 bytes at offset 1320960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1325056 ++wrote 2048/2048 bytes at offset 1325056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1329152 ++wrote 2048/2048 bytes at offset 1329152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1333248 ++wrote 2048/2048 bytes at offset 1333248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1337344 ++wrote 2048/2048 bytes at offset 1337344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1341440 ++wrote 2048/2048 bytes at offset 1341440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1345536 ++wrote 2048/2048 bytes at offset 1345536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1349632 ++wrote 2048/2048 bytes at offset 1349632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1353728 ++wrote 2048/2048 bytes at offset 1353728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1357824 ++wrote 2048/2048 bytes at offset 1357824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1361920 ++wrote 2048/2048 bytes at offset 1361920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1366016 ++wrote 2048/2048 bytes at offset 1366016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1370112 ++wrote 2048/2048 bytes at offset 1370112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1374208 ++wrote 2048/2048 bytes at offset 1374208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1378304 ++wrote 2048/2048 bytes at offset 1378304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1382400 ++wrote 2048/2048 bytes at offset 1382400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1386496 ++wrote 2048/2048 bytes at offset 1386496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1390592 ++wrote 2048/2048 bytes at offset 1390592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1394688 ++wrote 2048/2048 bytes at offset 1394688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1398784 ++wrote 2048/2048 bytes at offset 1398784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1402880 ++wrote 2048/2048 bytes at offset 1402880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1406976 ++wrote 2048/2048 bytes at offset 1406976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1411072 ++wrote 2048/2048 bytes at offset 1411072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1415168 ++wrote 2048/2048 bytes at offset 1415168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1419264 ++wrote 2048/2048 bytes at offset 1419264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1423360 ++wrote 2048/2048 bytes at offset 1423360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1427456 ++wrote 2048/2048 bytes at offset 1427456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1431552 ++wrote 2048/2048 bytes at offset 1431552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1435648 ++wrote 2048/2048 bytes at offset 1435648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1439744 ++wrote 2048/2048 bytes at offset 1439744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1443840 ++wrote 2048/2048 bytes at offset 1443840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1447936 ++wrote 2048/2048 bytes at offset 1447936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1452032 ++wrote 2048/2048 bytes at offset 1452032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1456128 ++wrote 2048/2048 bytes at offset 1456128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1460224 ++wrote 2048/2048 bytes at offset 1460224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1464320 ++wrote 2048/2048 bytes at offset 1464320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1468416 ++wrote 2048/2048 bytes at offset 1468416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1472512 ++wrote 2048/2048 bytes at offset 1472512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1476608 ++wrote 2048/2048 bytes at offset 1476608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1480704 ++wrote 2048/2048 bytes at offset 1480704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1484800 ++wrote 2048/2048 bytes at offset 1484800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1488896 ++wrote 2048/2048 bytes at offset 1488896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1492992 ++wrote 2048/2048 bytes at offset 1492992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1497088 ++wrote 2048/2048 bytes at offset 1497088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1501184 ++wrote 2048/2048 bytes at offset 1501184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1505280 ++wrote 2048/2048 bytes at offset 1505280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1509376 ++wrote 2048/2048 bytes at offset 1509376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1513472 ++wrote 2048/2048 bytes at offset 1513472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1517568 ++wrote 2048/2048 bytes at offset 1517568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1521664 ++wrote 2048/2048 bytes at offset 1521664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1525760 ++wrote 2048/2048 bytes at offset 1525760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1529856 ++wrote 2048/2048 bytes at offset 1529856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1533952 ++wrote 2048/2048 bytes at offset 1533952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1538048 ++wrote 2048/2048 bytes at offset 1538048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1542144 ++wrote 2048/2048 bytes at offset 1542144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1546240 ++wrote 2048/2048 bytes at offset 1546240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1550336 ++wrote 2048/2048 bytes at offset 1550336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1554432 ++wrote 2048/2048 bytes at offset 1554432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1558528 ++wrote 2048/2048 bytes at offset 1558528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1562624 ++wrote 2048/2048 bytes at offset 1562624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1566720 ++wrote 2048/2048 bytes at offset 1566720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1570816 ++wrote 2048/2048 bytes at offset 1570816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1574912 ++wrote 2048/2048 bytes at offset 1574912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1579008 ++wrote 2048/2048 bytes at offset 1579008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1583104 ++wrote 2048/2048 bytes at offset 1583104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1587200 ++wrote 2048/2048 bytes at offset 1587200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1591296 ++wrote 2048/2048 bytes at offset 1591296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1595392 ++wrote 2048/2048 bytes at offset 1595392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1599488 ++wrote 2048/2048 bytes at offset 1599488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1603584 ++wrote 2048/2048 bytes at offset 1603584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1607680 ++wrote 2048/2048 bytes at offset 1607680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1611776 ++wrote 2048/2048 bytes at offset 1611776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1615872 ++wrote 2048/2048 bytes at offset 1615872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1619968 ++wrote 2048/2048 bytes at offset 1619968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1624064 ++wrote 2048/2048 bytes at offset 1624064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1628160 ++wrote 2048/2048 bytes at offset 1628160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1632256 ++wrote 2048/2048 bytes at offset 1632256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1636352 ++wrote 2048/2048 bytes at offset 1636352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1640448 ++wrote 2048/2048 bytes at offset 1640448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1644544 ++wrote 2048/2048 bytes at offset 1644544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1648640 ++wrote 2048/2048 bytes at offset 1648640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1652736 ++wrote 2048/2048 bytes at offset 1652736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1656832 ++wrote 2048/2048 bytes at offset 1656832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1660928 ++wrote 2048/2048 bytes at offset 1660928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1665024 ++wrote 2048/2048 bytes at offset 1665024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1669120 ++wrote 2048/2048 bytes at offset 1669120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1673216 ++wrote 2048/2048 bytes at offset 1673216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1677312 ++wrote 2048/2048 bytes at offset 1677312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1681408 ++wrote 2048/2048 bytes at offset 1681408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1685504 ++wrote 2048/2048 bytes at offset 1685504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1689600 ++wrote 2048/2048 bytes at offset 1689600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1693696 ++wrote 2048/2048 bytes at offset 1693696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1697792 ++wrote 2048/2048 bytes at offset 1697792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1701888 ++wrote 2048/2048 bytes at offset 1701888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1705984 ++wrote 2048/2048 bytes at offset 1705984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1710080 ++wrote 2048/2048 bytes at offset 1710080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1714176 ++wrote 2048/2048 bytes at offset 1714176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1718272 ++wrote 2048/2048 bytes at offset 1718272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1722368 ++wrote 2048/2048 bytes at offset 1722368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1726464 ++wrote 2048/2048 bytes at offset 1726464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1730560 ++wrote 2048/2048 bytes at offset 1730560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1734656 ++wrote 2048/2048 bytes at offset 1734656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1738752 ++wrote 2048/2048 bytes at offset 1738752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1742848 ++wrote 2048/2048 bytes at offset 1742848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1746944 ++wrote 2048/2048 bytes at offset 1746944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1751040 ++wrote 2048/2048 bytes at offset 1751040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1755136 ++wrote 2048/2048 bytes at offset 1755136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1759232 ++wrote 2048/2048 bytes at offset 1759232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1763328 ++wrote 2048/2048 bytes at offset 1763328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1767424 ++wrote 2048/2048 bytes at offset 1767424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1771520 ++wrote 2048/2048 bytes at offset 1771520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1775616 ++wrote 2048/2048 bytes at offset 1775616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1779712 ++wrote 2048/2048 bytes at offset 1779712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1783808 ++wrote 2048/2048 bytes at offset 1783808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1787904 ++wrote 2048/2048 bytes at offset 1787904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1792000 ++wrote 2048/2048 bytes at offset 1792000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1796096 ++wrote 2048/2048 bytes at offset 1796096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1800192 ++wrote 2048/2048 bytes at offset 1800192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1804288 ++wrote 2048/2048 bytes at offset 1804288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1808384 ++wrote 2048/2048 bytes at offset 1808384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1812480 ++wrote 2048/2048 bytes at offset 1812480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1816576 ++wrote 2048/2048 bytes at offset 1816576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1820672 ++wrote 2048/2048 bytes at offset 1820672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1824768 ++wrote 2048/2048 bytes at offset 1824768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1828864 ++wrote 2048/2048 bytes at offset 1828864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1832960 ++wrote 2048/2048 bytes at offset 1832960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1837056 ++wrote 2048/2048 bytes at offset 1837056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1841152 ++wrote 2048/2048 bytes at offset 1841152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1845248 ++wrote 2048/2048 bytes at offset 1845248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1849344 ++wrote 2048/2048 bytes at offset 1849344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1853440 ++wrote 2048/2048 bytes at offset 1853440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1857536 ++wrote 2048/2048 bytes at offset 1857536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1861632 ++wrote 2048/2048 bytes at offset 1861632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1865728 ++wrote 2048/2048 bytes at offset 1865728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1869824 ++wrote 2048/2048 bytes at offset 1869824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1873920 ++wrote 2048/2048 bytes at offset 1873920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1878016 ++wrote 2048/2048 bytes at offset 1878016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1882112 ++wrote 2048/2048 bytes at offset 1882112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1886208 ++wrote 2048/2048 bytes at offset 1886208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1890304 ++wrote 2048/2048 bytes at offset 1890304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1894400 ++wrote 2048/2048 bytes at offset 1894400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1898496 ++wrote 2048/2048 bytes at offset 1898496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1902592 ++wrote 2048/2048 bytes at offset 1902592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1906688 ++wrote 2048/2048 bytes at offset 1906688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1910784 ++wrote 2048/2048 bytes at offset 1910784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1914880 ++wrote 2048/2048 bytes at offset 1914880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1918976 ++wrote 2048/2048 bytes at offset 1918976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1923072 ++wrote 2048/2048 bytes at offset 1923072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1927168 ++wrote 2048/2048 bytes at offset 1927168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1931264 ++wrote 2048/2048 bytes at offset 1931264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1935360 ++wrote 2048/2048 bytes at offset 1935360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1939456 ++wrote 2048/2048 bytes at offset 1939456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1943552 ++wrote 2048/2048 bytes at offset 1943552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1947648 ++wrote 2048/2048 bytes at offset 1947648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1951744 ++wrote 2048/2048 bytes at offset 1951744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1955840 ++wrote 2048/2048 bytes at offset 1955840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1959936 ++wrote 2048/2048 bytes at offset 1959936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1964032 ++wrote 2048/2048 bytes at offset 1964032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1968128 ++wrote 2048/2048 bytes at offset 1968128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1972224 ++wrote 2048/2048 bytes at offset 1972224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1976320 ++wrote 2048/2048 bytes at offset 1976320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1980416 ++wrote 2048/2048 bytes at offset 1980416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1984512 ++wrote 2048/2048 bytes at offset 1984512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1988608 ++wrote 2048/2048 bytes at offset 1988608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1992704 ++wrote 2048/2048 bytes at offset 1992704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1996800 ++wrote 2048/2048 bytes at offset 1996800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2000896 ++wrote 2048/2048 bytes at offset 2000896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2004992 ++wrote 2048/2048 bytes at offset 2004992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2009088 ++wrote 2048/2048 bytes at offset 2009088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2013184 ++wrote 2048/2048 bytes at offset 2013184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2017280 ++wrote 2048/2048 bytes at offset 2017280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2021376 ++wrote 2048/2048 bytes at offset 2021376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2025472 ++wrote 2048/2048 bytes at offset 2025472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2029568 ++wrote 2048/2048 bytes at offset 2029568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2033664 ++wrote 2048/2048 bytes at offset 2033664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2037760 ++wrote 2048/2048 bytes at offset 2037760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2041856 ++wrote 2048/2048 bytes at offset 2041856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2045952 ++wrote 2048/2048 bytes at offset 2045952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2050048 ++wrote 2048/2048 bytes at offset 2050048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2054144 ++wrote 2048/2048 bytes at offset 2054144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2058240 ++wrote 2048/2048 bytes at offset 2058240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2062336 ++wrote 2048/2048 bytes at offset 2062336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2066432 ++wrote 2048/2048 bytes at offset 2066432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2070528 ++wrote 2048/2048 bytes at offset 2070528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2074624 ++wrote 2048/2048 bytes at offset 2074624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2078720 ++wrote 2048/2048 bytes at offset 2078720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2082816 ++wrote 2048/2048 bytes at offset 2082816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2086912 ++wrote 2048/2048 bytes at offset 2086912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2091008 ++wrote 2048/2048 bytes at offset 2091008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2095104 ++wrote 2048/2048 bytes at offset 2095104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> wrote 2048/2048 bytes at offset 2097152 ++=== IO: pattern 0 ++wrote 2048/2048 bytes at offset 2097152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2101248 ++wrote 2048/2048 bytes at offset 2101248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2105344 ++wrote 2048/2048 bytes at offset 2105344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2109440 ++wrote 2048/2048 bytes at offset 2109440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2113536 ++wrote 2048/2048 bytes at offset 2113536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2117632 ++wrote 2048/2048 bytes at offset 2117632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2121728 ++wrote 2048/2048 bytes at offset 2121728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2125824 ++wrote 2048/2048 bytes at offset 2125824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2129920 ++wrote 2048/2048 bytes at offset 2129920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2134016 ++wrote 2048/2048 bytes at offset 2134016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2138112 ++wrote 2048/2048 bytes at offset 2138112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2142208 ++wrote 2048/2048 bytes at offset 2142208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2146304 ++wrote 2048/2048 bytes at offset 2146304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2150400 ++wrote 2048/2048 bytes at offset 2150400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2154496 ++wrote 2048/2048 bytes at offset 2154496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2158592 ++wrote 2048/2048 bytes at offset 2158592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2162688 ++wrote 2048/2048 bytes at offset 2162688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2166784 ++wrote 2048/2048 bytes at offset 2166784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2170880 ++wrote 2048/2048 bytes at offset 2170880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2174976 ++wrote 2048/2048 bytes at offset 2174976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2179072 ++wrote 2048/2048 bytes at offset 2179072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2183168 ++wrote 2048/2048 bytes at offset 2183168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2187264 ++wrote 2048/2048 bytes at offset 2187264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2191360 ++wrote 2048/2048 bytes at offset 2191360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2195456 ++wrote 2048/2048 bytes at offset 2195456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2199552 ++wrote 2048/2048 bytes at offset 2199552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2203648 ++wrote 2048/2048 bytes at offset 2203648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2207744 ++wrote 2048/2048 bytes at offset 2207744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2211840 ++wrote 2048/2048 bytes at offset 2211840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2215936 ++wrote 2048/2048 bytes at offset 2215936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2220032 ++wrote 2048/2048 bytes at offset 2220032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2224128 ++wrote 2048/2048 bytes at offset 2224128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2228224 ++wrote 2048/2048 bytes at offset 2228224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2232320 ++wrote 2048/2048 bytes at offset 2232320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2236416 ++wrote 2048/2048 bytes at offset 2236416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2240512 ++wrote 2048/2048 bytes at offset 2240512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2244608 ++wrote 2048/2048 bytes at offset 2244608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2248704 ++wrote 2048/2048 bytes at offset 2248704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2252800 ++wrote 2048/2048 bytes at offset 2252800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2256896 ++wrote 2048/2048 bytes at offset 2256896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2260992 ++wrote 2048/2048 bytes at offset 2260992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2265088 ++wrote 2048/2048 bytes at offset 2265088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2269184 ++wrote 2048/2048 bytes at offset 2269184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2273280 ++wrote 2048/2048 bytes at offset 2273280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2277376 ++wrote 2048/2048 bytes at offset 2277376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2281472 ++wrote 2048/2048 bytes at offset 2281472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2285568 ++wrote 2048/2048 bytes at offset 2285568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2289664 ++wrote 2048/2048 bytes at offset 2289664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2293760 ++wrote 2048/2048 bytes at offset 2293760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2297856 ++wrote 2048/2048 bytes at offset 2297856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2301952 ++wrote 2048/2048 bytes at offset 2301952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2306048 ++wrote 2048/2048 bytes at offset 2306048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2310144 ++wrote 2048/2048 bytes at offset 2310144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2314240 ++wrote 2048/2048 bytes at offset 2314240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2318336 ++wrote 2048/2048 bytes at offset 2318336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2322432 ++wrote 2048/2048 bytes at offset 2322432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2326528 ++wrote 2048/2048 bytes at offset 2326528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2330624 ++wrote 2048/2048 bytes at offset 2330624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2334720 ++wrote 2048/2048 bytes at offset 2334720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2338816 ++wrote 2048/2048 bytes at offset 2338816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2342912 ++wrote 2048/2048 bytes at offset 2342912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2347008 ++wrote 2048/2048 bytes at offset 2347008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2351104 ++wrote 2048/2048 bytes at offset 2351104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2355200 ++wrote 2048/2048 bytes at offset 2355200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2359296 ++wrote 2048/2048 bytes at offset 2359296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2363392 ++wrote 2048/2048 bytes at offset 2363392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2367488 ++wrote 2048/2048 bytes at offset 2367488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2371584 ++wrote 2048/2048 bytes at offset 2371584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2375680 ++wrote 2048/2048 bytes at offset 2375680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2379776 ++wrote 2048/2048 bytes at offset 2379776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2383872 ++wrote 2048/2048 bytes at offset 2383872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2387968 ++wrote 2048/2048 bytes at offset 2387968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2392064 ++wrote 2048/2048 bytes at offset 2392064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2396160 ++wrote 2048/2048 bytes at offset 2396160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2400256 ++wrote 2048/2048 bytes at offset 2400256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2404352 ++wrote 2048/2048 bytes at offset 2404352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2408448 ++wrote 2048/2048 bytes at offset 2408448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2412544 ++wrote 2048/2048 bytes at offset 2412544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2416640 ++wrote 2048/2048 bytes at offset 2416640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2420736 ++wrote 2048/2048 bytes at offset 2420736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2424832 ++wrote 2048/2048 bytes at offset 2424832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2428928 ++wrote 2048/2048 bytes at offset 2428928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2433024 ++wrote 2048/2048 bytes at offset 2433024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2437120 ++wrote 2048/2048 bytes at offset 2437120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2441216 ++wrote 2048/2048 bytes at offset 2441216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2445312 ++wrote 2048/2048 bytes at offset 2445312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2449408 ++wrote 2048/2048 bytes at offset 2449408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2453504 ++wrote 2048/2048 bytes at offset 2453504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2457600 ++wrote 2048/2048 bytes at offset 2457600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2461696 ++wrote 2048/2048 bytes at offset 2461696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2465792 ++wrote 2048/2048 bytes at offset 2465792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2469888 ++wrote 2048/2048 bytes at offset 2469888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2473984 ++wrote 2048/2048 bytes at offset 2473984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2478080 ++wrote 2048/2048 bytes at offset 2478080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2482176 ++wrote 2048/2048 bytes at offset 2482176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2486272 ++wrote 2048/2048 bytes at offset 2486272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2490368 ++wrote 2048/2048 bytes at offset 2490368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2494464 ++wrote 2048/2048 bytes at offset 2494464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2498560 ++wrote 2048/2048 bytes at offset 2498560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2502656 ++wrote 2048/2048 bytes at offset 2502656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2506752 ++wrote 2048/2048 bytes at offset 2506752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2510848 ++wrote 2048/2048 bytes at offset 2510848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2514944 ++wrote 2048/2048 bytes at offset 2514944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2519040 ++wrote 2048/2048 bytes at offset 2519040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2523136 ++wrote 2048/2048 bytes at offset 2523136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2527232 ++wrote 2048/2048 bytes at offset 2527232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2531328 ++wrote 2048/2048 bytes at offset 2531328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2535424 ++wrote 2048/2048 bytes at offset 2535424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2539520 ++wrote 2048/2048 bytes at offset 2539520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2543616 ++wrote 2048/2048 bytes at offset 2543616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2547712 ++wrote 2048/2048 bytes at offset 2547712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2551808 ++wrote 2048/2048 bytes at offset 2551808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2555904 ++wrote 2048/2048 bytes at offset 2555904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2560000 ++wrote 2048/2048 bytes at offset 2560000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2564096 ++wrote 2048/2048 bytes at offset 2564096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2568192 ++wrote 2048/2048 bytes at offset 2568192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2572288 ++wrote 2048/2048 bytes at offset 2572288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2576384 ++wrote 2048/2048 bytes at offset 2576384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2580480 ++wrote 2048/2048 bytes at offset 2580480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2584576 ++wrote 2048/2048 bytes at offset 2584576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2588672 ++wrote 2048/2048 bytes at offset 2588672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2592768 ++wrote 2048/2048 bytes at offset 2592768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2596864 ++wrote 2048/2048 bytes at offset 2596864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2600960 ++wrote 2048/2048 bytes at offset 2600960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2605056 ++wrote 2048/2048 bytes at offset 2605056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2609152 ++wrote 2048/2048 bytes at offset 2609152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2613248 ++wrote 2048/2048 bytes at offset 2613248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2617344 ++wrote 2048/2048 bytes at offset 2617344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2621440 ++wrote 2048/2048 bytes at offset 2621440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2625536 ++wrote 2048/2048 bytes at offset 2625536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2629632 ++wrote 2048/2048 bytes at offset 2629632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2633728 ++wrote 2048/2048 bytes at offset 2633728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2637824 ++wrote 2048/2048 bytes at offset 2637824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2641920 ++wrote 2048/2048 bytes at offset 2641920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2646016 ++wrote 2048/2048 bytes at offset 2646016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2650112 ++wrote 2048/2048 bytes at offset 2650112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2654208 ++wrote 2048/2048 bytes at offset 2654208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2658304 ++wrote 2048/2048 bytes at offset 2658304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2662400 ++wrote 2048/2048 bytes at offset 2662400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2666496 ++wrote 2048/2048 bytes at offset 2666496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2670592 ++wrote 2048/2048 bytes at offset 2670592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2674688 ++wrote 2048/2048 bytes at offset 2674688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2678784 ++wrote 2048/2048 bytes at offset 2678784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2682880 ++wrote 2048/2048 bytes at offset 2682880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2686976 ++wrote 2048/2048 bytes at offset 2686976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2691072 ++wrote 2048/2048 bytes at offset 2691072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2695168 ++wrote 2048/2048 bytes at offset 2695168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2699264 ++wrote 2048/2048 bytes at offset 2699264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2703360 ++wrote 2048/2048 bytes at offset 2703360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2707456 ++wrote 2048/2048 bytes at offset 2707456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2711552 ++wrote 2048/2048 bytes at offset 2711552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2715648 ++wrote 2048/2048 bytes at offset 2715648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2719744 ++wrote 2048/2048 bytes at offset 2719744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2723840 ++wrote 2048/2048 bytes at offset 2723840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2727936 ++wrote 2048/2048 bytes at offset 2727936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2732032 ++wrote 2048/2048 bytes at offset 2732032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2736128 ++wrote 2048/2048 bytes at offset 2736128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2740224 ++wrote 2048/2048 bytes at offset 2740224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2744320 ++wrote 2048/2048 bytes at offset 2744320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2748416 ++wrote 2048/2048 bytes at offset 2748416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2752512 ++wrote 2048/2048 bytes at offset 2752512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2756608 ++wrote 2048/2048 bytes at offset 2756608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2760704 ++wrote 2048/2048 bytes at offset 2760704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2764800 ++wrote 2048/2048 bytes at offset 2764800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2768896 ++wrote 2048/2048 bytes at offset 2768896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2772992 ++wrote 2048/2048 bytes at offset 2772992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2777088 ++wrote 2048/2048 bytes at offset 2777088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2781184 ++wrote 2048/2048 bytes at offset 2781184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2785280 ++wrote 2048/2048 bytes at offset 2785280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2789376 ++wrote 2048/2048 bytes at offset 2789376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2793472 ++wrote 2048/2048 bytes at offset 2793472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2797568 ++wrote 2048/2048 bytes at offset 2797568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2801664 ++wrote 2048/2048 bytes at offset 2801664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2805760 ++wrote 2048/2048 bytes at offset 2805760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2809856 ++wrote 2048/2048 bytes at offset 2809856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2813952 ++wrote 2048/2048 bytes at offset 2813952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2818048 ++wrote 2048/2048 bytes at offset 2818048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2822144 ++wrote 2048/2048 bytes at offset 2822144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2826240 ++wrote 2048/2048 bytes at offset 2826240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2830336 ++wrote 2048/2048 bytes at offset 2830336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2834432 ++wrote 2048/2048 bytes at offset 2834432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2838528 ++wrote 2048/2048 bytes at offset 2838528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2842624 ++wrote 2048/2048 bytes at offset 2842624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2846720 ++wrote 2048/2048 bytes at offset 2846720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2850816 ++wrote 2048/2048 bytes at offset 2850816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2854912 ++wrote 2048/2048 bytes at offset 2854912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2859008 ++wrote 2048/2048 bytes at offset 2859008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2863104 ++wrote 2048/2048 bytes at offset 2863104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2867200 ++wrote 2048/2048 bytes at offset 2867200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2871296 ++wrote 2048/2048 bytes at offset 2871296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2875392 ++wrote 2048/2048 bytes at offset 2875392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2879488 ++wrote 2048/2048 bytes at offset 2879488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2883584 ++wrote 2048/2048 bytes at offset 2883584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2887680 ++wrote 2048/2048 bytes at offset 2887680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2891776 ++wrote 2048/2048 bytes at offset 2891776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2895872 ++wrote 2048/2048 bytes at offset 2895872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2899968 ++wrote 2048/2048 bytes at offset 2899968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2904064 ++wrote 2048/2048 bytes at offset 2904064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2908160 ++wrote 2048/2048 bytes at offset 2908160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2912256 ++wrote 2048/2048 bytes at offset 2912256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2916352 ++wrote 2048/2048 bytes at offset 2916352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2920448 ++wrote 2048/2048 bytes at offset 2920448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2924544 ++wrote 2048/2048 bytes at offset 2924544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2928640 ++wrote 2048/2048 bytes at offset 2928640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2932736 ++wrote 2048/2048 bytes at offset 2932736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2936832 ++wrote 2048/2048 bytes at offset 2936832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2940928 ++wrote 2048/2048 bytes at offset 2940928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2945024 ++wrote 2048/2048 bytes at offset 2945024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2949120 ++wrote 2048/2048 bytes at offset 2949120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2953216 ++wrote 2048/2048 bytes at offset 2953216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2957312 ++wrote 2048/2048 bytes at offset 2957312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2961408 ++wrote 2048/2048 bytes at offset 2961408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2965504 ++wrote 2048/2048 bytes at offset 2965504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2969600 ++wrote 2048/2048 bytes at offset 2969600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2973696 ++wrote 2048/2048 bytes at offset 2973696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2977792 ++wrote 2048/2048 bytes at offset 2977792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2981888 ++wrote 2048/2048 bytes at offset 2981888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2985984 ++wrote 2048/2048 bytes at offset 2985984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2990080 ++wrote 2048/2048 bytes at offset 2990080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2994176 ++wrote 2048/2048 bytes at offset 2994176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2998272 ++wrote 2048/2048 bytes at offset 2998272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3002368 ++wrote 2048/2048 bytes at offset 3002368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3006464 ++wrote 2048/2048 bytes at offset 3006464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3010560 ++wrote 2048/2048 bytes at offset 3010560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3014656 ++wrote 2048/2048 bytes at offset 3014656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3018752 ++wrote 2048/2048 bytes at offset 3018752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3022848 ++wrote 2048/2048 bytes at offset 3022848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3026944 ++wrote 2048/2048 bytes at offset 3026944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3031040 ++wrote 2048/2048 bytes at offset 3031040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3035136 ++wrote 2048/2048 bytes at offset 3035136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3039232 ++wrote 2048/2048 bytes at offset 3039232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3043328 ++wrote 2048/2048 bytes at offset 3043328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3047424 ++wrote 2048/2048 bytes at offset 3047424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3051520 ++wrote 2048/2048 bytes at offset 3051520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3055616 ++wrote 2048/2048 bytes at offset 3055616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3059712 ++wrote 2048/2048 bytes at offset 3059712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3063808 ++wrote 2048/2048 bytes at offset 3063808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3067904 ++wrote 2048/2048 bytes at offset 3067904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3072000 ++wrote 2048/2048 bytes at offset 3072000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3076096 ++wrote 2048/2048 bytes at offset 3076096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3080192 ++wrote 2048/2048 bytes at offset 3080192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3084288 ++wrote 2048/2048 bytes at offset 3084288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3088384 ++wrote 2048/2048 bytes at offset 3088384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3092480 ++wrote 2048/2048 bytes at offset 3092480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3096576 ++wrote 2048/2048 bytes at offset 3096576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3100672 ++wrote 2048/2048 bytes at offset 3100672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3104768 ++wrote 2048/2048 bytes at offset 3104768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3108864 ++wrote 2048/2048 bytes at offset 3108864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3112960 ++wrote 2048/2048 bytes at offset 3112960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3117056 ++wrote 2048/2048 bytes at offset 3117056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3121152 ++wrote 2048/2048 bytes at offset 3121152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3125248 ++wrote 2048/2048 bytes at offset 3125248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3129344 ++wrote 2048/2048 bytes at offset 3129344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3133440 ++wrote 2048/2048 bytes at offset 3133440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3137536 ++wrote 2048/2048 bytes at offset 3137536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3141632 ++wrote 2048/2048 bytes at offset 3141632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 2 +-qemu-io> wrote 2048/2048 bytes at offset 3146752 ++=== IO: pattern 2 ++wrote 2048/2048 bytes at offset 3146752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3150848 ++wrote 2048/2048 bytes at offset 3150848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3154944 ++wrote 2048/2048 bytes at offset 3154944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3159040 ++wrote 2048/2048 bytes at offset 3159040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3163136 ++wrote 2048/2048 bytes at offset 3163136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3167232 ++wrote 2048/2048 bytes at offset 3167232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3171328 ++wrote 2048/2048 bytes at offset 3171328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3175424 ++wrote 2048/2048 bytes at offset 3175424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3179520 ++wrote 2048/2048 bytes at offset 3179520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3183616 ++wrote 2048/2048 bytes at offset 3183616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3187712 ++wrote 2048/2048 bytes at offset 3187712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3191808 ++wrote 2048/2048 bytes at offset 3191808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3195904 ++wrote 2048/2048 bytes at offset 3195904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3200000 ++wrote 2048/2048 bytes at offset 3200000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3204096 ++wrote 2048/2048 bytes at offset 3204096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3208192 ++wrote 2048/2048 bytes at offset 3208192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3212288 ++wrote 2048/2048 bytes at offset 3212288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3216384 ++wrote 2048/2048 bytes at offset 3216384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3220480 ++wrote 2048/2048 bytes at offset 3220480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3224576 ++wrote 2048/2048 bytes at offset 3224576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3228672 ++wrote 2048/2048 bytes at offset 3228672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3232768 ++wrote 2048/2048 bytes at offset 3232768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3236864 ++wrote 2048/2048 bytes at offset 3236864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3240960 ++wrote 2048/2048 bytes at offset 3240960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3245056 ++wrote 2048/2048 bytes at offset 3245056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3249152 ++wrote 2048/2048 bytes at offset 3249152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3253248 ++wrote 2048/2048 bytes at offset 3253248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3257344 ++wrote 2048/2048 bytes at offset 3257344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3261440 ++wrote 2048/2048 bytes at offset 3261440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3265536 ++wrote 2048/2048 bytes at offset 3265536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3269632 ++wrote 2048/2048 bytes at offset 3269632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3273728 ++wrote 2048/2048 bytes at offset 3273728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3277824 ++wrote 2048/2048 bytes at offset 3277824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3281920 ++wrote 2048/2048 bytes at offset 3281920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3286016 ++wrote 2048/2048 bytes at offset 3286016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3290112 ++wrote 2048/2048 bytes at offset 3290112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3294208 ++wrote 2048/2048 bytes at offset 3294208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3298304 ++wrote 2048/2048 bytes at offset 3298304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3302400 ++wrote 2048/2048 bytes at offset 3302400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3306496 ++wrote 2048/2048 bytes at offset 3306496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3310592 ++wrote 2048/2048 bytes at offset 3310592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3314688 ++wrote 2048/2048 bytes at offset 3314688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3318784 ++wrote 2048/2048 bytes at offset 3318784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3322880 ++wrote 2048/2048 bytes at offset 3322880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3326976 ++wrote 2048/2048 bytes at offset 3326976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3331072 ++wrote 2048/2048 bytes at offset 3331072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3335168 ++wrote 2048/2048 bytes at offset 3335168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3339264 ++wrote 2048/2048 bytes at offset 3339264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3343360 ++wrote 2048/2048 bytes at offset 3343360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3347456 ++wrote 2048/2048 bytes at offset 3347456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3351552 ++wrote 2048/2048 bytes at offset 3351552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3355648 ++wrote 2048/2048 bytes at offset 3355648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3359744 ++wrote 2048/2048 bytes at offset 3359744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3363840 ++wrote 2048/2048 bytes at offset 3363840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3367936 ++wrote 2048/2048 bytes at offset 3367936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3372032 ++wrote 2048/2048 bytes at offset 3372032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3376128 ++wrote 2048/2048 bytes at offset 3376128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3380224 ++wrote 2048/2048 bytes at offset 3380224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3384320 ++wrote 2048/2048 bytes at offset 3384320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3388416 ++wrote 2048/2048 bytes at offset 3388416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3392512 ++wrote 2048/2048 bytes at offset 3392512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3396608 ++wrote 2048/2048 bytes at offset 3396608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3400704 ++wrote 2048/2048 bytes at offset 3400704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3404800 ++wrote 2048/2048 bytes at offset 3404800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3408896 ++wrote 2048/2048 bytes at offset 3408896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3412992 ++wrote 2048/2048 bytes at offset 3412992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3417088 ++wrote 2048/2048 bytes at offset 3417088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3421184 ++wrote 2048/2048 bytes at offset 3421184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3425280 ++wrote 2048/2048 bytes at offset 3425280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3429376 ++wrote 2048/2048 bytes at offset 3429376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3433472 ++wrote 2048/2048 bytes at offset 3433472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3437568 ++wrote 2048/2048 bytes at offset 3437568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3441664 ++wrote 2048/2048 bytes at offset 3441664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3445760 ++wrote 2048/2048 bytes at offset 3445760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3449856 ++wrote 2048/2048 bytes at offset 3449856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3453952 ++wrote 2048/2048 bytes at offset 3453952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3458048 ++wrote 2048/2048 bytes at offset 3458048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3462144 ++wrote 2048/2048 bytes at offset 3462144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3466240 ++wrote 2048/2048 bytes at offset 3466240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3470336 ++wrote 2048/2048 bytes at offset 3470336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3474432 ++wrote 2048/2048 bytes at offset 3474432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3478528 ++wrote 2048/2048 bytes at offset 3478528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3482624 ++wrote 2048/2048 bytes at offset 3482624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3486720 ++wrote 2048/2048 bytes at offset 3486720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3490816 ++wrote 2048/2048 bytes at offset 3490816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3494912 ++wrote 2048/2048 bytes at offset 3494912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3499008 ++wrote 2048/2048 bytes at offset 3499008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3503104 ++wrote 2048/2048 bytes at offset 3503104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3507200 ++wrote 2048/2048 bytes at offset 3507200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3511296 ++wrote 2048/2048 bytes at offset 3511296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3515392 ++wrote 2048/2048 bytes at offset 3515392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3519488 ++wrote 2048/2048 bytes at offset 3519488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3523584 ++wrote 2048/2048 bytes at offset 3523584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3527680 ++wrote 2048/2048 bytes at offset 3527680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3531776 ++wrote 2048/2048 bytes at offset 3531776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3535872 ++wrote 2048/2048 bytes at offset 3535872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3539968 ++wrote 2048/2048 bytes at offset 3539968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3544064 ++wrote 2048/2048 bytes at offset 3544064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3548160 ++wrote 2048/2048 bytes at offset 3548160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3552256 ++wrote 2048/2048 bytes at offset 3552256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3556352 ++wrote 2048/2048 bytes at offset 3556352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3560448 ++wrote 2048/2048 bytes at offset 3560448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3564544 ++wrote 2048/2048 bytes at offset 3564544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3568640 ++wrote 2048/2048 bytes at offset 3568640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3572736 ++wrote 2048/2048 bytes at offset 3572736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3576832 ++wrote 2048/2048 bytes at offset 3576832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3580928 ++wrote 2048/2048 bytes at offset 3580928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3585024 ++wrote 2048/2048 bytes at offset 3585024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3589120 ++wrote 2048/2048 bytes at offset 3589120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3593216 ++wrote 2048/2048 bytes at offset 3593216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3597312 ++wrote 2048/2048 bytes at offset 3597312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3601408 ++wrote 2048/2048 bytes at offset 3601408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3605504 ++wrote 2048/2048 bytes at offset 3605504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3609600 ++wrote 2048/2048 bytes at offset 3609600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3613696 ++wrote 2048/2048 bytes at offset 3613696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3617792 ++wrote 2048/2048 bytes at offset 3617792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3621888 ++wrote 2048/2048 bytes at offset 3621888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3625984 ++wrote 2048/2048 bytes at offset 3625984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3630080 ++wrote 2048/2048 bytes at offset 3630080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3634176 ++wrote 2048/2048 bytes at offset 3634176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3638272 ++wrote 2048/2048 bytes at offset 3638272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3642368 ++wrote 2048/2048 bytes at offset 3642368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3646464 ++wrote 2048/2048 bytes at offset 3646464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3650560 ++wrote 2048/2048 bytes at offset 3650560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3654656 ++wrote 2048/2048 bytes at offset 3654656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3658752 ++wrote 2048/2048 bytes at offset 3658752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3662848 ++wrote 2048/2048 bytes at offset 3662848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3666944 ++wrote 2048/2048 bytes at offset 3666944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3671040 ++wrote 2048/2048 bytes at offset 3671040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3675136 ++wrote 2048/2048 bytes at offset 3675136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3679232 ++wrote 2048/2048 bytes at offset 3679232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3683328 ++wrote 2048/2048 bytes at offset 3683328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3687424 ++wrote 2048/2048 bytes at offset 3687424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3691520 ++wrote 2048/2048 bytes at offset 3691520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3695616 ++wrote 2048/2048 bytes at offset 3695616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3699712 ++wrote 2048/2048 bytes at offset 3699712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3703808 ++wrote 2048/2048 bytes at offset 3703808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3707904 ++wrote 2048/2048 bytes at offset 3707904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3712000 ++wrote 2048/2048 bytes at offset 3712000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3716096 ++wrote 2048/2048 bytes at offset 3716096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3720192 ++wrote 2048/2048 bytes at offset 3720192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3724288 ++wrote 2048/2048 bytes at offset 3724288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3728384 ++wrote 2048/2048 bytes at offset 3728384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3732480 ++wrote 2048/2048 bytes at offset 3732480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3736576 ++wrote 2048/2048 bytes at offset 3736576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3740672 ++wrote 2048/2048 bytes at offset 3740672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3744768 ++wrote 2048/2048 bytes at offset 3744768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3748864 ++wrote 2048/2048 bytes at offset 3748864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3752960 ++wrote 2048/2048 bytes at offset 3752960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3757056 ++wrote 2048/2048 bytes at offset 3757056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3761152 ++wrote 2048/2048 bytes at offset 3761152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3765248 ++wrote 2048/2048 bytes at offset 3765248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3769344 ++wrote 2048/2048 bytes at offset 3769344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3773440 ++wrote 2048/2048 bytes at offset 3773440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3777536 ++wrote 2048/2048 bytes at offset 3777536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3781632 ++wrote 2048/2048 bytes at offset 3781632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3785728 ++wrote 2048/2048 bytes at offset 3785728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3789824 ++wrote 2048/2048 bytes at offset 3789824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3793920 ++wrote 2048/2048 bytes at offset 3793920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3798016 ++wrote 2048/2048 bytes at offset 3798016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3802112 ++wrote 2048/2048 bytes at offset 3802112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3806208 ++wrote 2048/2048 bytes at offset 3806208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3810304 ++wrote 2048/2048 bytes at offset 3810304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3814400 ++wrote 2048/2048 bytes at offset 3814400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3818496 ++wrote 2048/2048 bytes at offset 3818496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3822592 ++wrote 2048/2048 bytes at offset 3822592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3826688 ++wrote 2048/2048 bytes at offset 3826688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3830784 ++wrote 2048/2048 bytes at offset 3830784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3834880 ++wrote 2048/2048 bytes at offset 3834880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3838976 ++wrote 2048/2048 bytes at offset 3838976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3843072 ++wrote 2048/2048 bytes at offset 3843072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3847168 ++wrote 2048/2048 bytes at offset 3847168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3851264 ++wrote 2048/2048 bytes at offset 3851264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3855360 ++wrote 2048/2048 bytes at offset 3855360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3859456 ++wrote 2048/2048 bytes at offset 3859456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3863552 ++wrote 2048/2048 bytes at offset 3863552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3867648 ++wrote 2048/2048 bytes at offset 3867648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3871744 ++wrote 2048/2048 bytes at offset 3871744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3875840 ++wrote 2048/2048 bytes at offset 3875840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3879936 ++wrote 2048/2048 bytes at offset 3879936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3884032 ++wrote 2048/2048 bytes at offset 3884032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3888128 ++wrote 2048/2048 bytes at offset 3888128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3892224 ++wrote 2048/2048 bytes at offset 3892224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3896320 ++wrote 2048/2048 bytes at offset 3896320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3900416 ++wrote 2048/2048 bytes at offset 3900416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3904512 ++wrote 2048/2048 bytes at offset 3904512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3908608 ++wrote 2048/2048 bytes at offset 3908608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3912704 ++wrote 2048/2048 bytes at offset 3912704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3916800 ++wrote 2048/2048 bytes at offset 3916800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3920896 ++wrote 2048/2048 bytes at offset 3920896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3924992 ++wrote 2048/2048 bytes at offset 3924992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3929088 ++wrote 2048/2048 bytes at offset 3929088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3933184 ++wrote 2048/2048 bytes at offset 3933184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3937280 ++wrote 2048/2048 bytes at offset 3937280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3941376 ++wrote 2048/2048 bytes at offset 3941376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3945472 ++wrote 2048/2048 bytes at offset 3945472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3949568 ++wrote 2048/2048 bytes at offset 3949568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3953664 ++wrote 2048/2048 bytes at offset 3953664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3957760 ++wrote 2048/2048 bytes at offset 3957760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3961856 ++wrote 2048/2048 bytes at offset 3961856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3965952 ++wrote 2048/2048 bytes at offset 3965952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3970048 ++wrote 2048/2048 bytes at offset 3970048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3974144 ++wrote 2048/2048 bytes at offset 3974144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3978240 ++wrote 2048/2048 bytes at offset 3978240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3982336 ++wrote 2048/2048 bytes at offset 3982336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3986432 ++wrote 2048/2048 bytes at offset 3986432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3990528 ++wrote 2048/2048 bytes at offset 3990528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3994624 ++wrote 2048/2048 bytes at offset 3994624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3998720 ++wrote 2048/2048 bytes at offset 3998720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4002816 ++wrote 2048/2048 bytes at offset 4002816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4006912 ++wrote 2048/2048 bytes at offset 4006912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4011008 ++wrote 2048/2048 bytes at offset 4011008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4015104 ++wrote 2048/2048 bytes at offset 4015104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4019200 ++wrote 2048/2048 bytes at offset 4019200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4023296 ++wrote 2048/2048 bytes at offset 4023296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4027392 ++wrote 2048/2048 bytes at offset 4027392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4031488 ++wrote 2048/2048 bytes at offset 4031488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4035584 ++wrote 2048/2048 bytes at offset 4035584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4039680 ++wrote 2048/2048 bytes at offset 4039680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4043776 ++wrote 2048/2048 bytes at offset 4043776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4047872 ++wrote 2048/2048 bytes at offset 4047872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4051968 ++wrote 2048/2048 bytes at offset 4051968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4056064 ++wrote 2048/2048 bytes at offset 4056064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4060160 ++wrote 2048/2048 bytes at offset 4060160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4064256 ++wrote 2048/2048 bytes at offset 4064256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4068352 ++wrote 2048/2048 bytes at offset 4068352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4072448 ++wrote 2048/2048 bytes at offset 4072448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4076544 ++wrote 2048/2048 bytes at offset 4076544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4080640 ++wrote 2048/2048 bytes at offset 4080640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4084736 ++wrote 2048/2048 bytes at offset 4084736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4088832 ++wrote 2048/2048 bytes at offset 4088832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4092928 ++wrote 2048/2048 bytes at offset 4092928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4097024 ++wrote 2048/2048 bytes at offset 4097024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4101120 ++wrote 2048/2048 bytes at offset 4101120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4105216 ++wrote 2048/2048 bytes at offset 4105216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4109312 ++wrote 2048/2048 bytes at offset 4109312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4113408 ++wrote 2048/2048 bytes at offset 4113408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4117504 ++wrote 2048/2048 bytes at offset 4117504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4121600 ++wrote 2048/2048 bytes at offset 4121600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4125696 ++wrote 2048/2048 bytes at offset 4125696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4129792 ++wrote 2048/2048 bytes at offset 4129792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4133888 ++wrote 2048/2048 bytes at offset 4133888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4137984 ++wrote 2048/2048 bytes at offset 4137984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4142080 ++wrote 2048/2048 bytes at offset 4142080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4146176 ++wrote 2048/2048 bytes at offset 4146176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4150272 ++wrote 2048/2048 bytes at offset 4150272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4154368 ++wrote 2048/2048 bytes at offset 4154368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4158464 ++wrote 2048/2048 bytes at offset 4158464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4162560 ++wrote 2048/2048 bytes at offset 4162560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4166656 ++wrote 2048/2048 bytes at offset 4166656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4170752 ++wrote 2048/2048 bytes at offset 4170752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4174848 ++wrote 2048/2048 bytes at offset 4174848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4178944 ++wrote 2048/2048 bytes at offset 4178944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4183040 ++wrote 2048/2048 bytes at offset 4183040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4187136 ++wrote 2048/2048 bytes at offset 4187136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4191232 ++wrote 2048/2048 bytes at offset 4191232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 4 +-qemu-io> wrote 8192/8192 bytes at offset 4196352 ++=== IO: pattern 4 ++wrote 8192/8192 bytes at offset 4196352 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4208640 ++wrote 8192/8192 bytes at offset 4208640 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4220928 ++wrote 8192/8192 bytes at offset 4220928 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4233216 ++wrote 8192/8192 bytes at offset 4233216 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4245504 ++wrote 8192/8192 bytes at offset 4245504 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4257792 ++wrote 8192/8192 bytes at offset 4257792 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4270080 ++wrote 8192/8192 bytes at offset 4270080 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4282368 ++wrote 8192/8192 bytes at offset 4282368 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4294656 ++wrote 8192/8192 bytes at offset 4294656 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4306944 ++wrote 8192/8192 bytes at offset 4306944 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4319232 ++wrote 8192/8192 bytes at offset 4319232 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4331520 ++wrote 8192/8192 bytes at offset 4331520 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4343808 ++wrote 8192/8192 bytes at offset 4343808 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4356096 ++wrote 8192/8192 bytes at offset 4356096 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4368384 ++wrote 8192/8192 bytes at offset 4368384 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4380672 ++wrote 8192/8192 bytes at offset 4380672 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4392960 ++wrote 8192/8192 bytes at offset 4392960 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4405248 ++wrote 8192/8192 bytes at offset 4405248 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4417536 ++wrote 8192/8192 bytes at offset 4417536 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4429824 ++wrote 8192/8192 bytes at offset 4429824 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4442112 ++wrote 8192/8192 bytes at offset 4442112 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4454400 ++wrote 8192/8192 bytes at offset 4454400 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4466688 ++wrote 8192/8192 bytes at offset 4466688 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4478976 ++wrote 8192/8192 bytes at offset 4478976 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4491264 ++wrote 8192/8192 bytes at offset 4491264 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4503552 ++wrote 8192/8192 bytes at offset 4503552 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4515840 ++wrote 8192/8192 bytes at offset 4515840 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4528128 ++wrote 8192/8192 bytes at offset 4528128 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4540416 ++wrote 8192/8192 bytes at offset 4540416 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4552704 ++wrote 8192/8192 bytes at offset 4552704 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4564992 ++wrote 8192/8192 bytes at offset 4564992 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4577280 ++wrote 8192/8192 bytes at offset 4577280 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4589568 ++wrote 8192/8192 bytes at offset 4589568 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4601856 ++wrote 8192/8192 bytes at offset 4601856 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4614144 ++wrote 8192/8192 bytes at offset 4614144 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4626432 ++wrote 8192/8192 bytes at offset 4626432 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4638720 ++wrote 8192/8192 bytes at offset 4638720 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4651008 ++wrote 8192/8192 bytes at offset 4651008 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4663296 ++wrote 8192/8192 bytes at offset 4663296 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4675584 ++wrote 8192/8192 bytes at offset 4675584 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4687872 ++wrote 8192/8192 bytes at offset 4687872 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4700160 ++wrote 8192/8192 bytes at offset 4700160 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4712448 ++wrote 8192/8192 bytes at offset 4712448 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4724736 ++wrote 8192/8192 bytes at offset 4724736 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4737024 ++wrote 8192/8192 bytes at offset 4737024 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4749312 ++wrote 8192/8192 bytes at offset 4749312 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4761600 ++wrote 8192/8192 bytes at offset 4761600 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4773888 ++wrote 8192/8192 bytes at offset 4773888 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4786176 ++wrote 8192/8192 bytes at offset 4786176 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4798464 ++wrote 8192/8192 bytes at offset 4798464 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4810752 ++wrote 8192/8192 bytes at offset 4810752 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4823040 ++wrote 8192/8192 bytes at offset 4823040 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4835328 ++wrote 8192/8192 bytes at offset 4835328 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4847616 ++wrote 8192/8192 bytes at offset 4847616 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4859904 ++wrote 8192/8192 bytes at offset 4859904 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4872192 ++wrote 8192/8192 bytes at offset 4872192 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4884480 ++wrote 8192/8192 bytes at offset 4884480 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4896768 ++wrote 8192/8192 bytes at offset 4896768 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4909056 ++wrote 8192/8192 bytes at offset 4909056 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4921344 ++wrote 8192/8192 bytes at offset 4921344 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4933632 ++wrote 8192/8192 bytes at offset 4933632 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4945920 ++wrote 8192/8192 bytes at offset 4945920 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4958208 ++wrote 8192/8192 bytes at offset 4958208 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4970496 ++wrote 8192/8192 bytes at offset 4970496 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 244 +-qemu-io> wrote 12288/12288 bytes at offset 6285312 ++=== IO: pattern 244 ++wrote 12288/12288 bytes at offset 6285312 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 8384512 ++wrote 12288/12288 bytes at offset 8384512 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 10483712 ++wrote 12288/12288 bytes at offset 10483712 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 12582912 ++wrote 12288/12288 bytes at offset 12582912 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 14682112 ++wrote 12288/12288 bytes at offset 14682112 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 16781312 ++wrote 12288/12288 bytes at offset 16781312 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 18880512 ++wrote 12288/12288 bytes at offset 18880512 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 20979712 ++wrote 12288/12288 bytes at offset 20979712 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> read 4096/4096 bytes at offset 0 ++=== IO: pattern 0 ++read 4096/4096 bytes at offset 0 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4096 ++read 4096/4096 bytes at offset 4096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 8192 ++read 4096/4096 bytes at offset 8192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 12288 ++read 4096/4096 bytes at offset 12288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 16384 ++read 4096/4096 bytes at offset 16384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 20480 ++read 4096/4096 bytes at offset 20480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 24576 ++read 4096/4096 bytes at offset 24576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 28672 ++read 4096/4096 bytes at offset 28672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 32768 ++read 4096/4096 bytes at offset 32768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 36864 ++read 4096/4096 bytes at offset 36864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 40960 ++read 4096/4096 bytes at offset 40960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 45056 ++read 4096/4096 bytes at offset 45056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 49152 ++read 4096/4096 bytes at offset 49152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 53248 ++read 4096/4096 bytes at offset 53248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 57344 ++read 4096/4096 bytes at offset 57344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 61440 ++read 4096/4096 bytes at offset 61440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 65536 ++read 4096/4096 bytes at offset 65536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 69632 ++read 4096/4096 bytes at offset 69632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 73728 ++read 4096/4096 bytes at offset 73728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 77824 ++read 4096/4096 bytes at offset 77824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 81920 ++read 4096/4096 bytes at offset 81920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 86016 ++read 4096/4096 bytes at offset 86016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 90112 ++read 4096/4096 bytes at offset 90112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 94208 ++read 4096/4096 bytes at offset 94208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 98304 ++read 4096/4096 bytes at offset 98304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 102400 ++read 4096/4096 bytes at offset 102400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 106496 ++read 4096/4096 bytes at offset 106496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 110592 ++read 4096/4096 bytes at offset 110592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 114688 ++read 4096/4096 bytes at offset 114688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 118784 ++read 4096/4096 bytes at offset 118784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 122880 ++read 4096/4096 bytes at offset 122880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 126976 ++read 4096/4096 bytes at offset 126976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 131072 ++read 4096/4096 bytes at offset 131072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 135168 ++read 4096/4096 bytes at offset 135168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 139264 ++read 4096/4096 bytes at offset 139264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 143360 ++read 4096/4096 bytes at offset 143360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 147456 ++read 4096/4096 bytes at offset 147456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 151552 ++read 4096/4096 bytes at offset 151552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 155648 ++read 4096/4096 bytes at offset 155648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 159744 ++read 4096/4096 bytes at offset 159744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 163840 ++read 4096/4096 bytes at offset 163840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 167936 ++read 4096/4096 bytes at offset 167936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 172032 ++read 4096/4096 bytes at offset 172032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 176128 ++read 4096/4096 bytes at offset 176128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 180224 ++read 4096/4096 bytes at offset 180224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 184320 ++read 4096/4096 bytes at offset 184320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 188416 ++read 4096/4096 bytes at offset 188416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 192512 ++read 4096/4096 bytes at offset 192512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 196608 ++read 4096/4096 bytes at offset 196608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 200704 ++read 4096/4096 bytes at offset 200704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 204800 ++read 4096/4096 bytes at offset 204800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 208896 ++read 4096/4096 bytes at offset 208896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 212992 ++read 4096/4096 bytes at offset 212992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 217088 ++read 4096/4096 bytes at offset 217088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 221184 ++read 4096/4096 bytes at offset 221184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 225280 ++read 4096/4096 bytes at offset 225280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 229376 ++read 4096/4096 bytes at offset 229376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 233472 ++read 4096/4096 bytes at offset 233472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 237568 ++read 4096/4096 bytes at offset 237568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 241664 ++read 4096/4096 bytes at offset 241664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 245760 ++read 4096/4096 bytes at offset 245760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 249856 ++read 4096/4096 bytes at offset 249856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 253952 ++read 4096/4096 bytes at offset 253952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 258048 ++read 4096/4096 bytes at offset 258048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 262144 ++read 4096/4096 bytes at offset 262144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 266240 ++read 4096/4096 bytes at offset 266240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 270336 ++read 4096/4096 bytes at offset 270336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 274432 ++read 4096/4096 bytes at offset 274432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 278528 ++read 4096/4096 bytes at offset 278528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 282624 ++read 4096/4096 bytes at offset 282624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 286720 ++read 4096/4096 bytes at offset 286720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 290816 ++read 4096/4096 bytes at offset 290816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 294912 ++read 4096/4096 bytes at offset 294912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 299008 ++read 4096/4096 bytes at offset 299008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 303104 ++read 4096/4096 bytes at offset 303104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 307200 ++read 4096/4096 bytes at offset 307200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 311296 ++read 4096/4096 bytes at offset 311296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 315392 ++read 4096/4096 bytes at offset 315392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 319488 ++read 4096/4096 bytes at offset 319488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 323584 ++read 4096/4096 bytes at offset 323584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 327680 ++read 4096/4096 bytes at offset 327680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 331776 ++read 4096/4096 bytes at offset 331776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 335872 ++read 4096/4096 bytes at offset 335872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 339968 ++read 4096/4096 bytes at offset 339968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 344064 ++read 4096/4096 bytes at offset 344064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 348160 ++read 4096/4096 bytes at offset 348160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 352256 ++read 4096/4096 bytes at offset 352256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 356352 ++read 4096/4096 bytes at offset 356352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 360448 ++read 4096/4096 bytes at offset 360448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 364544 ++read 4096/4096 bytes at offset 364544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 368640 ++read 4096/4096 bytes at offset 368640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 372736 ++read 4096/4096 bytes at offset 372736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 376832 ++read 4096/4096 bytes at offset 376832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 380928 ++read 4096/4096 bytes at offset 380928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 385024 ++read 4096/4096 bytes at offset 385024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 389120 ++read 4096/4096 bytes at offset 389120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 393216 ++read 4096/4096 bytes at offset 393216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 397312 ++read 4096/4096 bytes at offset 397312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 401408 ++read 4096/4096 bytes at offset 401408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 405504 ++read 4096/4096 bytes at offset 405504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 409600 ++read 4096/4096 bytes at offset 409600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 413696 ++read 4096/4096 bytes at offset 413696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 417792 ++read 4096/4096 bytes at offset 417792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 421888 ++read 4096/4096 bytes at offset 421888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 425984 ++read 4096/4096 bytes at offset 425984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 430080 ++read 4096/4096 bytes at offset 430080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 434176 ++read 4096/4096 bytes at offset 434176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 438272 ++read 4096/4096 bytes at offset 438272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 442368 ++read 4096/4096 bytes at offset 442368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 446464 ++read 4096/4096 bytes at offset 446464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 450560 ++read 4096/4096 bytes at offset 450560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 454656 ++read 4096/4096 bytes at offset 454656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 458752 ++read 4096/4096 bytes at offset 458752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 462848 ++read 4096/4096 bytes at offset 462848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 466944 ++read 4096/4096 bytes at offset 466944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 471040 ++read 4096/4096 bytes at offset 471040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 475136 ++read 4096/4096 bytes at offset 475136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 479232 ++read 4096/4096 bytes at offset 479232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 483328 ++read 4096/4096 bytes at offset 483328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 487424 ++read 4096/4096 bytes at offset 487424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 491520 ++read 4096/4096 bytes at offset 491520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 495616 ++read 4096/4096 bytes at offset 495616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 499712 ++read 4096/4096 bytes at offset 499712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 503808 ++read 4096/4096 bytes at offset 503808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 507904 ++read 4096/4096 bytes at offset 507904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 512000 ++read 4096/4096 bytes at offset 512000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 516096 ++read 4096/4096 bytes at offset 516096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 520192 ++read 4096/4096 bytes at offset 520192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 524288 ++read 4096/4096 bytes at offset 524288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 528384 ++read 4096/4096 bytes at offset 528384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 532480 ++read 4096/4096 bytes at offset 532480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 536576 ++read 4096/4096 bytes at offset 536576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 540672 ++read 4096/4096 bytes at offset 540672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 544768 ++read 4096/4096 bytes at offset 544768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 548864 ++read 4096/4096 bytes at offset 548864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 552960 ++read 4096/4096 bytes at offset 552960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 557056 ++read 4096/4096 bytes at offset 557056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 561152 ++read 4096/4096 bytes at offset 561152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 565248 ++read 4096/4096 bytes at offset 565248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 569344 ++read 4096/4096 bytes at offset 569344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 573440 ++read 4096/4096 bytes at offset 573440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 577536 ++read 4096/4096 bytes at offset 577536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 581632 ++read 4096/4096 bytes at offset 581632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 585728 ++read 4096/4096 bytes at offset 585728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 589824 ++read 4096/4096 bytes at offset 589824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 593920 ++read 4096/4096 bytes at offset 593920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 598016 ++read 4096/4096 bytes at offset 598016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 602112 ++read 4096/4096 bytes at offset 602112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 606208 ++read 4096/4096 bytes at offset 606208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 610304 ++read 4096/4096 bytes at offset 610304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 614400 ++read 4096/4096 bytes at offset 614400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 618496 ++read 4096/4096 bytes at offset 618496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 622592 ++read 4096/4096 bytes at offset 622592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 626688 ++read 4096/4096 bytes at offset 626688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 630784 ++read 4096/4096 bytes at offset 630784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 634880 ++read 4096/4096 bytes at offset 634880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 638976 ++read 4096/4096 bytes at offset 638976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 643072 ++read 4096/4096 bytes at offset 643072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 647168 ++read 4096/4096 bytes at offset 647168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 651264 ++read 4096/4096 bytes at offset 651264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 655360 ++read 4096/4096 bytes at offset 655360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 659456 ++read 4096/4096 bytes at offset 659456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 663552 ++read 4096/4096 bytes at offset 663552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 667648 ++read 4096/4096 bytes at offset 667648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 671744 ++read 4096/4096 bytes at offset 671744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 675840 ++read 4096/4096 bytes at offset 675840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 679936 ++read 4096/4096 bytes at offset 679936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 684032 ++read 4096/4096 bytes at offset 684032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 688128 ++read 4096/4096 bytes at offset 688128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 692224 ++read 4096/4096 bytes at offset 692224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 696320 ++read 4096/4096 bytes at offset 696320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 700416 ++read 4096/4096 bytes at offset 700416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 704512 ++read 4096/4096 bytes at offset 704512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 708608 ++read 4096/4096 bytes at offset 708608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 712704 ++read 4096/4096 bytes at offset 712704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 716800 ++read 4096/4096 bytes at offset 716800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 720896 ++read 4096/4096 bytes at offset 720896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 724992 ++read 4096/4096 bytes at offset 724992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 729088 ++read 4096/4096 bytes at offset 729088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 733184 ++read 4096/4096 bytes at offset 733184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 737280 ++read 4096/4096 bytes at offset 737280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 741376 ++read 4096/4096 bytes at offset 741376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 745472 ++read 4096/4096 bytes at offset 745472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 749568 ++read 4096/4096 bytes at offset 749568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 753664 ++read 4096/4096 bytes at offset 753664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 757760 ++read 4096/4096 bytes at offset 757760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 761856 ++read 4096/4096 bytes at offset 761856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 765952 ++read 4096/4096 bytes at offset 765952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 770048 ++read 4096/4096 bytes at offset 770048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 774144 ++read 4096/4096 bytes at offset 774144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 778240 ++read 4096/4096 bytes at offset 778240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 782336 ++read 4096/4096 bytes at offset 782336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 786432 ++read 4096/4096 bytes at offset 786432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 790528 ++read 4096/4096 bytes at offset 790528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 794624 ++read 4096/4096 bytes at offset 794624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 798720 ++read 4096/4096 bytes at offset 798720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 802816 ++read 4096/4096 bytes at offset 802816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 806912 ++read 4096/4096 bytes at offset 806912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 811008 ++read 4096/4096 bytes at offset 811008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 815104 ++read 4096/4096 bytes at offset 815104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 819200 ++read 4096/4096 bytes at offset 819200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 823296 ++read 4096/4096 bytes at offset 823296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 827392 ++read 4096/4096 bytes at offset 827392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 831488 ++read 4096/4096 bytes at offset 831488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 835584 ++read 4096/4096 bytes at offset 835584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 839680 ++read 4096/4096 bytes at offset 839680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 843776 ++read 4096/4096 bytes at offset 843776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 847872 ++read 4096/4096 bytes at offset 847872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 851968 ++read 4096/4096 bytes at offset 851968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 856064 ++read 4096/4096 bytes at offset 856064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 860160 ++read 4096/4096 bytes at offset 860160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 864256 ++read 4096/4096 bytes at offset 864256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 868352 ++read 4096/4096 bytes at offset 868352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 872448 ++read 4096/4096 bytes at offset 872448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 876544 ++read 4096/4096 bytes at offset 876544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 880640 ++read 4096/4096 bytes at offset 880640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 884736 ++read 4096/4096 bytes at offset 884736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 888832 ++read 4096/4096 bytes at offset 888832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 892928 ++read 4096/4096 bytes at offset 892928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 897024 ++read 4096/4096 bytes at offset 897024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 901120 ++read 4096/4096 bytes at offset 901120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 905216 ++read 4096/4096 bytes at offset 905216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 909312 ++read 4096/4096 bytes at offset 909312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 913408 ++read 4096/4096 bytes at offset 913408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 917504 ++read 4096/4096 bytes at offset 917504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 921600 ++read 4096/4096 bytes at offset 921600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 925696 ++read 4096/4096 bytes at offset 925696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 929792 ++read 4096/4096 bytes at offset 929792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 933888 ++read 4096/4096 bytes at offset 933888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 937984 ++read 4096/4096 bytes at offset 937984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 942080 ++read 4096/4096 bytes at offset 942080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 946176 ++read 4096/4096 bytes at offset 946176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 950272 ++read 4096/4096 bytes at offset 950272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 954368 ++read 4096/4096 bytes at offset 954368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 958464 ++read 4096/4096 bytes at offset 958464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 962560 ++read 4096/4096 bytes at offset 962560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 966656 ++read 4096/4096 bytes at offset 966656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 970752 ++read 4096/4096 bytes at offset 970752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 974848 ++read 4096/4096 bytes at offset 974848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 978944 ++read 4096/4096 bytes at offset 978944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 983040 ++read 4096/4096 bytes at offset 983040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 987136 ++read 4096/4096 bytes at offset 987136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 991232 ++read 4096/4096 bytes at offset 991232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 995328 ++read 4096/4096 bytes at offset 995328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 999424 ++read 4096/4096 bytes at offset 999424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1003520 ++read 4096/4096 bytes at offset 1003520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1007616 ++read 4096/4096 bytes at offset 1007616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1011712 ++read 4096/4096 bytes at offset 1011712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1015808 ++read 4096/4096 bytes at offset 1015808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1019904 ++read 4096/4096 bytes at offset 1019904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1024000 ++read 4096/4096 bytes at offset 1024000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1028096 ++read 4096/4096 bytes at offset 1028096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1032192 ++read 4096/4096 bytes at offset 1032192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1036288 ++read 4096/4096 bytes at offset 1036288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1040384 ++read 4096/4096 bytes at offset 1040384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1044480 ++read 4096/4096 bytes at offset 1044480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 4 +-qemu-io> read 2048/2048 bytes at offset 1050624 ++=== IO: pattern 4 ++read 2048/2048 bytes at offset 1050624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1054720 ++read 2048/2048 bytes at offset 1054720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1058816 ++read 2048/2048 bytes at offset 1058816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1062912 ++read 2048/2048 bytes at offset 1062912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1067008 ++read 2048/2048 bytes at offset 1067008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1071104 ++read 2048/2048 bytes at offset 1071104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1075200 ++read 2048/2048 bytes at offset 1075200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1079296 ++read 2048/2048 bytes at offset 1079296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1083392 ++read 2048/2048 bytes at offset 1083392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1087488 ++read 2048/2048 bytes at offset 1087488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1091584 ++read 2048/2048 bytes at offset 1091584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1095680 ++read 2048/2048 bytes at offset 1095680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1099776 ++read 2048/2048 bytes at offset 1099776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1103872 ++read 2048/2048 bytes at offset 1103872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1107968 ++read 2048/2048 bytes at offset 1107968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1112064 ++read 2048/2048 bytes at offset 1112064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1116160 ++read 2048/2048 bytes at offset 1116160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1120256 ++read 2048/2048 bytes at offset 1120256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1124352 ++read 2048/2048 bytes at offset 1124352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1128448 ++read 2048/2048 bytes at offset 1128448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1132544 ++read 2048/2048 bytes at offset 1132544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1136640 ++read 2048/2048 bytes at offset 1136640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1140736 ++read 2048/2048 bytes at offset 1140736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1144832 ++read 2048/2048 bytes at offset 1144832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1148928 ++read 2048/2048 bytes at offset 1148928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1153024 ++read 2048/2048 bytes at offset 1153024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1157120 ++read 2048/2048 bytes at offset 1157120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1161216 ++read 2048/2048 bytes at offset 1161216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1165312 ++read 2048/2048 bytes at offset 1165312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1169408 ++read 2048/2048 bytes at offset 1169408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1173504 ++read 2048/2048 bytes at offset 1173504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1177600 ++read 2048/2048 bytes at offset 1177600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1181696 ++read 2048/2048 bytes at offset 1181696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1185792 ++read 2048/2048 bytes at offset 1185792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1189888 ++read 2048/2048 bytes at offset 1189888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1193984 ++read 2048/2048 bytes at offset 1193984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1198080 ++read 2048/2048 bytes at offset 1198080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1202176 ++read 2048/2048 bytes at offset 1202176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1206272 ++read 2048/2048 bytes at offset 1206272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1210368 ++read 2048/2048 bytes at offset 1210368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1214464 ++read 2048/2048 bytes at offset 1214464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1218560 ++read 2048/2048 bytes at offset 1218560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1222656 ++read 2048/2048 bytes at offset 1222656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1226752 ++read 2048/2048 bytes at offset 1226752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1230848 ++read 2048/2048 bytes at offset 1230848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1234944 ++read 2048/2048 bytes at offset 1234944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1239040 ++read 2048/2048 bytes at offset 1239040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1243136 ++read 2048/2048 bytes at offset 1243136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1247232 ++read 2048/2048 bytes at offset 1247232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1251328 ++read 2048/2048 bytes at offset 1251328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1255424 ++read 2048/2048 bytes at offset 1255424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1259520 ++read 2048/2048 bytes at offset 1259520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1263616 ++read 2048/2048 bytes at offset 1263616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1267712 ++read 2048/2048 bytes at offset 1267712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1271808 ++read 2048/2048 bytes at offset 1271808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1275904 ++read 2048/2048 bytes at offset 1275904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1280000 ++read 2048/2048 bytes at offset 1280000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1284096 ++read 2048/2048 bytes at offset 1284096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1288192 ++read 2048/2048 bytes at offset 1288192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1292288 ++read 2048/2048 bytes at offset 1292288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1296384 ++read 2048/2048 bytes at offset 1296384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1300480 ++read 2048/2048 bytes at offset 1300480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1304576 ++read 2048/2048 bytes at offset 1304576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1308672 ++read 2048/2048 bytes at offset 1308672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1312768 ++read 2048/2048 bytes at offset 1312768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1316864 ++read 2048/2048 bytes at offset 1316864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1320960 ++read 2048/2048 bytes at offset 1320960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1325056 ++read 2048/2048 bytes at offset 1325056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1329152 ++read 2048/2048 bytes at offset 1329152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1333248 ++read 2048/2048 bytes at offset 1333248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1337344 ++read 2048/2048 bytes at offset 1337344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1341440 ++read 2048/2048 bytes at offset 1341440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1345536 ++read 2048/2048 bytes at offset 1345536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1349632 ++read 2048/2048 bytes at offset 1349632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1353728 ++read 2048/2048 bytes at offset 1353728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1357824 ++read 2048/2048 bytes at offset 1357824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1361920 ++read 2048/2048 bytes at offset 1361920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1366016 ++read 2048/2048 bytes at offset 1366016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1370112 ++read 2048/2048 bytes at offset 1370112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1374208 ++read 2048/2048 bytes at offset 1374208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1378304 ++read 2048/2048 bytes at offset 1378304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1382400 ++read 2048/2048 bytes at offset 1382400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1386496 ++read 2048/2048 bytes at offset 1386496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1390592 ++read 2048/2048 bytes at offset 1390592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1394688 ++read 2048/2048 bytes at offset 1394688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1398784 ++read 2048/2048 bytes at offset 1398784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1402880 ++read 2048/2048 bytes at offset 1402880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1406976 ++read 2048/2048 bytes at offset 1406976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1411072 ++read 2048/2048 bytes at offset 1411072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1415168 ++read 2048/2048 bytes at offset 1415168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1419264 ++read 2048/2048 bytes at offset 1419264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1423360 ++read 2048/2048 bytes at offset 1423360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1427456 ++read 2048/2048 bytes at offset 1427456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1431552 ++read 2048/2048 bytes at offset 1431552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1435648 ++read 2048/2048 bytes at offset 1435648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1439744 ++read 2048/2048 bytes at offset 1439744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1443840 ++read 2048/2048 bytes at offset 1443840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1447936 ++read 2048/2048 bytes at offset 1447936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1452032 ++read 2048/2048 bytes at offset 1452032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1456128 ++read 2048/2048 bytes at offset 1456128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1460224 ++read 2048/2048 bytes at offset 1460224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1464320 ++read 2048/2048 bytes at offset 1464320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1468416 ++read 2048/2048 bytes at offset 1468416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1472512 ++read 2048/2048 bytes at offset 1472512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1476608 ++read 2048/2048 bytes at offset 1476608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1480704 ++read 2048/2048 bytes at offset 1480704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1484800 ++read 2048/2048 bytes at offset 1484800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1488896 ++read 2048/2048 bytes at offset 1488896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1492992 ++read 2048/2048 bytes at offset 1492992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1497088 ++read 2048/2048 bytes at offset 1497088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1501184 ++read 2048/2048 bytes at offset 1501184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1505280 ++read 2048/2048 bytes at offset 1505280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1509376 ++read 2048/2048 bytes at offset 1509376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1513472 ++read 2048/2048 bytes at offset 1513472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1517568 ++read 2048/2048 bytes at offset 1517568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1521664 ++read 2048/2048 bytes at offset 1521664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1525760 ++read 2048/2048 bytes at offset 1525760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1529856 ++read 2048/2048 bytes at offset 1529856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1533952 ++read 2048/2048 bytes at offset 1533952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1538048 ++read 2048/2048 bytes at offset 1538048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1542144 ++read 2048/2048 bytes at offset 1542144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1546240 ++read 2048/2048 bytes at offset 1546240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1550336 ++read 2048/2048 bytes at offset 1550336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1554432 ++read 2048/2048 bytes at offset 1554432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1558528 ++read 2048/2048 bytes at offset 1558528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1562624 ++read 2048/2048 bytes at offset 1562624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1566720 ++read 2048/2048 bytes at offset 1566720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1570816 ++read 2048/2048 bytes at offset 1570816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1574912 ++read 2048/2048 bytes at offset 1574912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1579008 ++read 2048/2048 bytes at offset 1579008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1583104 ++read 2048/2048 bytes at offset 1583104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1587200 ++read 2048/2048 bytes at offset 1587200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1591296 ++read 2048/2048 bytes at offset 1591296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1595392 ++read 2048/2048 bytes at offset 1595392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1599488 ++read 2048/2048 bytes at offset 1599488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1603584 ++read 2048/2048 bytes at offset 1603584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1607680 ++read 2048/2048 bytes at offset 1607680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1611776 ++read 2048/2048 bytes at offset 1611776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1615872 ++read 2048/2048 bytes at offset 1615872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1619968 ++read 2048/2048 bytes at offset 1619968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1624064 ++read 2048/2048 bytes at offset 1624064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1628160 ++read 2048/2048 bytes at offset 1628160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1632256 ++read 2048/2048 bytes at offset 1632256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1636352 ++read 2048/2048 bytes at offset 1636352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1640448 ++read 2048/2048 bytes at offset 1640448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1644544 ++read 2048/2048 bytes at offset 1644544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1648640 ++read 2048/2048 bytes at offset 1648640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1652736 ++read 2048/2048 bytes at offset 1652736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1656832 ++read 2048/2048 bytes at offset 1656832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1660928 ++read 2048/2048 bytes at offset 1660928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1665024 ++read 2048/2048 bytes at offset 1665024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1669120 ++read 2048/2048 bytes at offset 1669120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1673216 ++read 2048/2048 bytes at offset 1673216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1677312 ++read 2048/2048 bytes at offset 1677312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1681408 ++read 2048/2048 bytes at offset 1681408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1685504 ++read 2048/2048 bytes at offset 1685504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1689600 ++read 2048/2048 bytes at offset 1689600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1693696 ++read 2048/2048 bytes at offset 1693696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1697792 ++read 2048/2048 bytes at offset 1697792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1701888 ++read 2048/2048 bytes at offset 1701888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1705984 ++read 2048/2048 bytes at offset 1705984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1710080 ++read 2048/2048 bytes at offset 1710080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1714176 ++read 2048/2048 bytes at offset 1714176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1718272 ++read 2048/2048 bytes at offset 1718272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1722368 ++read 2048/2048 bytes at offset 1722368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1726464 ++read 2048/2048 bytes at offset 1726464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1730560 ++read 2048/2048 bytes at offset 1730560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1734656 ++read 2048/2048 bytes at offset 1734656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1738752 ++read 2048/2048 bytes at offset 1738752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1742848 ++read 2048/2048 bytes at offset 1742848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1746944 ++read 2048/2048 bytes at offset 1746944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1751040 ++read 2048/2048 bytes at offset 1751040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1755136 ++read 2048/2048 bytes at offset 1755136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1759232 ++read 2048/2048 bytes at offset 1759232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1763328 ++read 2048/2048 bytes at offset 1763328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1767424 ++read 2048/2048 bytes at offset 1767424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1771520 ++read 2048/2048 bytes at offset 1771520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1775616 ++read 2048/2048 bytes at offset 1775616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1779712 ++read 2048/2048 bytes at offset 1779712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1783808 ++read 2048/2048 bytes at offset 1783808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1787904 ++read 2048/2048 bytes at offset 1787904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1792000 ++read 2048/2048 bytes at offset 1792000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1796096 ++read 2048/2048 bytes at offset 1796096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1800192 ++read 2048/2048 bytes at offset 1800192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1804288 ++read 2048/2048 bytes at offset 1804288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1808384 ++read 2048/2048 bytes at offset 1808384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1812480 ++read 2048/2048 bytes at offset 1812480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1816576 ++read 2048/2048 bytes at offset 1816576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1820672 ++read 2048/2048 bytes at offset 1820672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1824768 ++read 2048/2048 bytes at offset 1824768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1828864 ++read 2048/2048 bytes at offset 1828864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1832960 ++read 2048/2048 bytes at offset 1832960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1837056 ++read 2048/2048 bytes at offset 1837056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1841152 ++read 2048/2048 bytes at offset 1841152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1845248 ++read 2048/2048 bytes at offset 1845248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1849344 ++read 2048/2048 bytes at offset 1849344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1853440 ++read 2048/2048 bytes at offset 1853440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1857536 ++read 2048/2048 bytes at offset 1857536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1861632 ++read 2048/2048 bytes at offset 1861632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1865728 ++read 2048/2048 bytes at offset 1865728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1869824 ++read 2048/2048 bytes at offset 1869824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1873920 ++read 2048/2048 bytes at offset 1873920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1878016 ++read 2048/2048 bytes at offset 1878016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1882112 ++read 2048/2048 bytes at offset 1882112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1886208 ++read 2048/2048 bytes at offset 1886208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1890304 ++read 2048/2048 bytes at offset 1890304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1894400 ++read 2048/2048 bytes at offset 1894400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1898496 ++read 2048/2048 bytes at offset 1898496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1902592 ++read 2048/2048 bytes at offset 1902592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1906688 ++read 2048/2048 bytes at offset 1906688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1910784 ++read 2048/2048 bytes at offset 1910784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1914880 ++read 2048/2048 bytes at offset 1914880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1918976 ++read 2048/2048 bytes at offset 1918976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1923072 ++read 2048/2048 bytes at offset 1923072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1927168 ++read 2048/2048 bytes at offset 1927168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1931264 ++read 2048/2048 bytes at offset 1931264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1935360 ++read 2048/2048 bytes at offset 1935360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1939456 ++read 2048/2048 bytes at offset 1939456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1943552 ++read 2048/2048 bytes at offset 1943552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1947648 ++read 2048/2048 bytes at offset 1947648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1951744 ++read 2048/2048 bytes at offset 1951744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1955840 ++read 2048/2048 bytes at offset 1955840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1959936 ++read 2048/2048 bytes at offset 1959936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1964032 ++read 2048/2048 bytes at offset 1964032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1968128 ++read 2048/2048 bytes at offset 1968128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1972224 ++read 2048/2048 bytes at offset 1972224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1976320 ++read 2048/2048 bytes at offset 1976320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1980416 ++read 2048/2048 bytes at offset 1980416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1984512 ++read 2048/2048 bytes at offset 1984512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1988608 ++read 2048/2048 bytes at offset 1988608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1992704 ++read 2048/2048 bytes at offset 1992704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1996800 ++read 2048/2048 bytes at offset 1996800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2000896 ++read 2048/2048 bytes at offset 2000896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2004992 ++read 2048/2048 bytes at offset 2004992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2009088 ++read 2048/2048 bytes at offset 2009088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2013184 ++read 2048/2048 bytes at offset 2013184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2017280 ++read 2048/2048 bytes at offset 2017280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2021376 ++read 2048/2048 bytes at offset 2021376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2025472 ++read 2048/2048 bytes at offset 2025472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2029568 ++read 2048/2048 bytes at offset 2029568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2033664 ++read 2048/2048 bytes at offset 2033664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2037760 ++read 2048/2048 bytes at offset 2037760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2041856 ++read 2048/2048 bytes at offset 2041856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2045952 ++read 2048/2048 bytes at offset 2045952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2050048 ++read 2048/2048 bytes at offset 2050048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2054144 ++read 2048/2048 bytes at offset 2054144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2058240 ++read 2048/2048 bytes at offset 2058240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2062336 ++read 2048/2048 bytes at offset 2062336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2066432 ++read 2048/2048 bytes at offset 2066432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2070528 ++read 2048/2048 bytes at offset 2070528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2074624 ++read 2048/2048 bytes at offset 2074624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2078720 ++read 2048/2048 bytes at offset 2078720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2082816 ++read 2048/2048 bytes at offset 2082816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2086912 ++read 2048/2048 bytes at offset 2086912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2091008 ++read 2048/2048 bytes at offset 2091008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2095104 ++read 2048/2048 bytes at offset 2095104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> read 2048/2048 bytes at offset 2097152 ++=== IO: pattern 0 ++read 2048/2048 bytes at offset 2097152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2101248 ++read 2048/2048 bytes at offset 2101248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2105344 ++read 2048/2048 bytes at offset 2105344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2109440 ++read 2048/2048 bytes at offset 2109440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2113536 ++read 2048/2048 bytes at offset 2113536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2117632 ++read 2048/2048 bytes at offset 2117632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2121728 ++read 2048/2048 bytes at offset 2121728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2125824 ++read 2048/2048 bytes at offset 2125824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2129920 ++read 2048/2048 bytes at offset 2129920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2134016 ++read 2048/2048 bytes at offset 2134016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2138112 ++read 2048/2048 bytes at offset 2138112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2142208 ++read 2048/2048 bytes at offset 2142208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2146304 ++read 2048/2048 bytes at offset 2146304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2150400 ++read 2048/2048 bytes at offset 2150400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2154496 ++read 2048/2048 bytes at offset 2154496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2158592 ++read 2048/2048 bytes at offset 2158592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2162688 ++read 2048/2048 bytes at offset 2162688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2166784 ++read 2048/2048 bytes at offset 2166784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2170880 ++read 2048/2048 bytes at offset 2170880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2174976 ++read 2048/2048 bytes at offset 2174976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2179072 ++read 2048/2048 bytes at offset 2179072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2183168 ++read 2048/2048 bytes at offset 2183168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2187264 ++read 2048/2048 bytes at offset 2187264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2191360 ++read 2048/2048 bytes at offset 2191360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2195456 ++read 2048/2048 bytes at offset 2195456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2199552 ++read 2048/2048 bytes at offset 2199552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2203648 ++read 2048/2048 bytes at offset 2203648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2207744 ++read 2048/2048 bytes at offset 2207744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2211840 ++read 2048/2048 bytes at offset 2211840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2215936 ++read 2048/2048 bytes at offset 2215936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2220032 ++read 2048/2048 bytes at offset 2220032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2224128 ++read 2048/2048 bytes at offset 2224128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2228224 ++read 2048/2048 bytes at offset 2228224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2232320 ++read 2048/2048 bytes at offset 2232320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2236416 ++read 2048/2048 bytes at offset 2236416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2240512 ++read 2048/2048 bytes at offset 2240512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2244608 ++read 2048/2048 bytes at offset 2244608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2248704 ++read 2048/2048 bytes at offset 2248704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2252800 ++read 2048/2048 bytes at offset 2252800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2256896 ++read 2048/2048 bytes at offset 2256896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2260992 ++read 2048/2048 bytes at offset 2260992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2265088 ++read 2048/2048 bytes at offset 2265088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2269184 ++read 2048/2048 bytes at offset 2269184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2273280 ++read 2048/2048 bytes at offset 2273280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2277376 ++read 2048/2048 bytes at offset 2277376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2281472 ++read 2048/2048 bytes at offset 2281472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2285568 ++read 2048/2048 bytes at offset 2285568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2289664 ++read 2048/2048 bytes at offset 2289664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2293760 ++read 2048/2048 bytes at offset 2293760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2297856 ++read 2048/2048 bytes at offset 2297856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2301952 ++read 2048/2048 bytes at offset 2301952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2306048 ++read 2048/2048 bytes at offset 2306048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2310144 ++read 2048/2048 bytes at offset 2310144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2314240 ++read 2048/2048 bytes at offset 2314240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2318336 ++read 2048/2048 bytes at offset 2318336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2322432 ++read 2048/2048 bytes at offset 2322432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2326528 ++read 2048/2048 bytes at offset 2326528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2330624 ++read 2048/2048 bytes at offset 2330624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2334720 ++read 2048/2048 bytes at offset 2334720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2338816 ++read 2048/2048 bytes at offset 2338816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2342912 ++read 2048/2048 bytes at offset 2342912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2347008 ++read 2048/2048 bytes at offset 2347008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2351104 ++read 2048/2048 bytes at offset 2351104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2355200 ++read 2048/2048 bytes at offset 2355200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2359296 ++read 2048/2048 bytes at offset 2359296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2363392 ++read 2048/2048 bytes at offset 2363392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2367488 ++read 2048/2048 bytes at offset 2367488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2371584 ++read 2048/2048 bytes at offset 2371584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2375680 ++read 2048/2048 bytes at offset 2375680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2379776 ++read 2048/2048 bytes at offset 2379776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2383872 ++read 2048/2048 bytes at offset 2383872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2387968 ++read 2048/2048 bytes at offset 2387968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2392064 ++read 2048/2048 bytes at offset 2392064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2396160 ++read 2048/2048 bytes at offset 2396160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2400256 ++read 2048/2048 bytes at offset 2400256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2404352 ++read 2048/2048 bytes at offset 2404352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2408448 ++read 2048/2048 bytes at offset 2408448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2412544 ++read 2048/2048 bytes at offset 2412544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2416640 ++read 2048/2048 bytes at offset 2416640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2420736 ++read 2048/2048 bytes at offset 2420736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2424832 ++read 2048/2048 bytes at offset 2424832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2428928 ++read 2048/2048 bytes at offset 2428928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2433024 ++read 2048/2048 bytes at offset 2433024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2437120 ++read 2048/2048 bytes at offset 2437120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2441216 ++read 2048/2048 bytes at offset 2441216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2445312 ++read 2048/2048 bytes at offset 2445312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2449408 ++read 2048/2048 bytes at offset 2449408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2453504 ++read 2048/2048 bytes at offset 2453504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2457600 ++read 2048/2048 bytes at offset 2457600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2461696 ++read 2048/2048 bytes at offset 2461696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2465792 ++read 2048/2048 bytes at offset 2465792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2469888 ++read 2048/2048 bytes at offset 2469888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2473984 ++read 2048/2048 bytes at offset 2473984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2478080 ++read 2048/2048 bytes at offset 2478080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2482176 ++read 2048/2048 bytes at offset 2482176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2486272 ++read 2048/2048 bytes at offset 2486272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2490368 ++read 2048/2048 bytes at offset 2490368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2494464 ++read 2048/2048 bytes at offset 2494464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2498560 ++read 2048/2048 bytes at offset 2498560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2502656 ++read 2048/2048 bytes at offset 2502656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2506752 ++read 2048/2048 bytes at offset 2506752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2510848 ++read 2048/2048 bytes at offset 2510848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2514944 ++read 2048/2048 bytes at offset 2514944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2519040 ++read 2048/2048 bytes at offset 2519040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2523136 ++read 2048/2048 bytes at offset 2523136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2527232 ++read 2048/2048 bytes at offset 2527232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2531328 ++read 2048/2048 bytes at offset 2531328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2535424 ++read 2048/2048 bytes at offset 2535424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2539520 ++read 2048/2048 bytes at offset 2539520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2543616 ++read 2048/2048 bytes at offset 2543616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2547712 ++read 2048/2048 bytes at offset 2547712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2551808 ++read 2048/2048 bytes at offset 2551808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2555904 ++read 2048/2048 bytes at offset 2555904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2560000 ++read 2048/2048 bytes at offset 2560000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2564096 ++read 2048/2048 bytes at offset 2564096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2568192 ++read 2048/2048 bytes at offset 2568192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2572288 ++read 2048/2048 bytes at offset 2572288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2576384 ++read 2048/2048 bytes at offset 2576384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2580480 ++read 2048/2048 bytes at offset 2580480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2584576 ++read 2048/2048 bytes at offset 2584576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2588672 ++read 2048/2048 bytes at offset 2588672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2592768 ++read 2048/2048 bytes at offset 2592768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2596864 ++read 2048/2048 bytes at offset 2596864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2600960 ++read 2048/2048 bytes at offset 2600960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2605056 ++read 2048/2048 bytes at offset 2605056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2609152 ++read 2048/2048 bytes at offset 2609152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2613248 ++read 2048/2048 bytes at offset 2613248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2617344 ++read 2048/2048 bytes at offset 2617344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2621440 ++read 2048/2048 bytes at offset 2621440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2625536 ++read 2048/2048 bytes at offset 2625536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2629632 ++read 2048/2048 bytes at offset 2629632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2633728 ++read 2048/2048 bytes at offset 2633728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2637824 ++read 2048/2048 bytes at offset 2637824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2641920 ++read 2048/2048 bytes at offset 2641920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2646016 ++read 2048/2048 bytes at offset 2646016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2650112 ++read 2048/2048 bytes at offset 2650112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2654208 ++read 2048/2048 bytes at offset 2654208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2658304 ++read 2048/2048 bytes at offset 2658304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2662400 ++read 2048/2048 bytes at offset 2662400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2666496 ++read 2048/2048 bytes at offset 2666496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2670592 ++read 2048/2048 bytes at offset 2670592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2674688 ++read 2048/2048 bytes at offset 2674688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2678784 ++read 2048/2048 bytes at offset 2678784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2682880 ++read 2048/2048 bytes at offset 2682880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2686976 ++read 2048/2048 bytes at offset 2686976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2691072 ++read 2048/2048 bytes at offset 2691072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2695168 ++read 2048/2048 bytes at offset 2695168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2699264 ++read 2048/2048 bytes at offset 2699264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2703360 ++read 2048/2048 bytes at offset 2703360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2707456 ++read 2048/2048 bytes at offset 2707456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2711552 ++read 2048/2048 bytes at offset 2711552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2715648 ++read 2048/2048 bytes at offset 2715648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2719744 ++read 2048/2048 bytes at offset 2719744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2723840 ++read 2048/2048 bytes at offset 2723840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2727936 ++read 2048/2048 bytes at offset 2727936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2732032 ++read 2048/2048 bytes at offset 2732032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2736128 ++read 2048/2048 bytes at offset 2736128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2740224 ++read 2048/2048 bytes at offset 2740224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2744320 ++read 2048/2048 bytes at offset 2744320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2748416 ++read 2048/2048 bytes at offset 2748416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2752512 ++read 2048/2048 bytes at offset 2752512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2756608 ++read 2048/2048 bytes at offset 2756608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2760704 ++read 2048/2048 bytes at offset 2760704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2764800 ++read 2048/2048 bytes at offset 2764800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2768896 ++read 2048/2048 bytes at offset 2768896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2772992 ++read 2048/2048 bytes at offset 2772992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2777088 ++read 2048/2048 bytes at offset 2777088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2781184 ++read 2048/2048 bytes at offset 2781184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2785280 ++read 2048/2048 bytes at offset 2785280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2789376 ++read 2048/2048 bytes at offset 2789376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2793472 ++read 2048/2048 bytes at offset 2793472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2797568 ++read 2048/2048 bytes at offset 2797568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2801664 ++read 2048/2048 bytes at offset 2801664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2805760 ++read 2048/2048 bytes at offset 2805760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2809856 ++read 2048/2048 bytes at offset 2809856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2813952 ++read 2048/2048 bytes at offset 2813952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2818048 ++read 2048/2048 bytes at offset 2818048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2822144 ++read 2048/2048 bytes at offset 2822144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2826240 ++read 2048/2048 bytes at offset 2826240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2830336 ++read 2048/2048 bytes at offset 2830336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2834432 ++read 2048/2048 bytes at offset 2834432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2838528 ++read 2048/2048 bytes at offset 2838528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2842624 ++read 2048/2048 bytes at offset 2842624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2846720 ++read 2048/2048 bytes at offset 2846720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2850816 ++read 2048/2048 bytes at offset 2850816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2854912 ++read 2048/2048 bytes at offset 2854912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2859008 ++read 2048/2048 bytes at offset 2859008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2863104 ++read 2048/2048 bytes at offset 2863104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2867200 ++read 2048/2048 bytes at offset 2867200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2871296 ++read 2048/2048 bytes at offset 2871296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2875392 ++read 2048/2048 bytes at offset 2875392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2879488 ++read 2048/2048 bytes at offset 2879488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2883584 ++read 2048/2048 bytes at offset 2883584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2887680 ++read 2048/2048 bytes at offset 2887680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2891776 ++read 2048/2048 bytes at offset 2891776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2895872 ++read 2048/2048 bytes at offset 2895872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2899968 ++read 2048/2048 bytes at offset 2899968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2904064 ++read 2048/2048 bytes at offset 2904064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2908160 ++read 2048/2048 bytes at offset 2908160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2912256 ++read 2048/2048 bytes at offset 2912256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2916352 ++read 2048/2048 bytes at offset 2916352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2920448 ++read 2048/2048 bytes at offset 2920448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2924544 ++read 2048/2048 bytes at offset 2924544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2928640 ++read 2048/2048 bytes at offset 2928640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2932736 ++read 2048/2048 bytes at offset 2932736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2936832 ++read 2048/2048 bytes at offset 2936832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2940928 ++read 2048/2048 bytes at offset 2940928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2945024 ++read 2048/2048 bytes at offset 2945024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2949120 ++read 2048/2048 bytes at offset 2949120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2953216 ++read 2048/2048 bytes at offset 2953216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2957312 ++read 2048/2048 bytes at offset 2957312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2961408 ++read 2048/2048 bytes at offset 2961408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2965504 ++read 2048/2048 bytes at offset 2965504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2969600 ++read 2048/2048 bytes at offset 2969600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2973696 ++read 2048/2048 bytes at offset 2973696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2977792 ++read 2048/2048 bytes at offset 2977792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2981888 ++read 2048/2048 bytes at offset 2981888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2985984 ++read 2048/2048 bytes at offset 2985984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2990080 ++read 2048/2048 bytes at offset 2990080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2994176 ++read 2048/2048 bytes at offset 2994176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2998272 ++read 2048/2048 bytes at offset 2998272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3002368 ++read 2048/2048 bytes at offset 3002368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3006464 ++read 2048/2048 bytes at offset 3006464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3010560 ++read 2048/2048 bytes at offset 3010560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3014656 ++read 2048/2048 bytes at offset 3014656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3018752 ++read 2048/2048 bytes at offset 3018752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3022848 ++read 2048/2048 bytes at offset 3022848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3026944 ++read 2048/2048 bytes at offset 3026944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3031040 ++read 2048/2048 bytes at offset 3031040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3035136 ++read 2048/2048 bytes at offset 3035136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3039232 ++read 2048/2048 bytes at offset 3039232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3043328 ++read 2048/2048 bytes at offset 3043328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3047424 ++read 2048/2048 bytes at offset 3047424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3051520 ++read 2048/2048 bytes at offset 3051520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3055616 ++read 2048/2048 bytes at offset 3055616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3059712 ++read 2048/2048 bytes at offset 3059712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3063808 ++read 2048/2048 bytes at offset 3063808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3067904 ++read 2048/2048 bytes at offset 3067904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3072000 ++read 2048/2048 bytes at offset 3072000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3076096 ++read 2048/2048 bytes at offset 3076096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3080192 ++read 2048/2048 bytes at offset 3080192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3084288 ++read 2048/2048 bytes at offset 3084288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3088384 ++read 2048/2048 bytes at offset 3088384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3092480 ++read 2048/2048 bytes at offset 3092480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3096576 ++read 2048/2048 bytes at offset 3096576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3100672 ++read 2048/2048 bytes at offset 3100672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3104768 ++read 2048/2048 bytes at offset 3104768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3108864 ++read 2048/2048 bytes at offset 3108864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3112960 ++read 2048/2048 bytes at offset 3112960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3117056 ++read 2048/2048 bytes at offset 3117056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3121152 ++read 2048/2048 bytes at offset 3121152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3125248 ++read 2048/2048 bytes at offset 3125248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3129344 ++read 2048/2048 bytes at offset 3129344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3133440 ++read 2048/2048 bytes at offset 3133440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3137536 ++read 2048/2048 bytes at offset 3137536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3141632 ++read 2048/2048 bytes at offset 3141632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 2 +-qemu-io> read 2048/2048 bytes at offset 3146752 ++=== IO: pattern 2 ++read 2048/2048 bytes at offset 3146752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3150848 ++read 2048/2048 bytes at offset 3150848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3154944 ++read 2048/2048 bytes at offset 3154944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3159040 ++read 2048/2048 bytes at offset 3159040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3163136 ++read 2048/2048 bytes at offset 3163136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3167232 ++read 2048/2048 bytes at offset 3167232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3171328 ++read 2048/2048 bytes at offset 3171328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3175424 ++read 2048/2048 bytes at offset 3175424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3179520 ++read 2048/2048 bytes at offset 3179520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3183616 ++read 2048/2048 bytes at offset 3183616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3187712 ++read 2048/2048 bytes at offset 3187712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3191808 ++read 2048/2048 bytes at offset 3191808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3195904 ++read 2048/2048 bytes at offset 3195904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3200000 ++read 2048/2048 bytes at offset 3200000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3204096 ++read 2048/2048 bytes at offset 3204096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3208192 ++read 2048/2048 bytes at offset 3208192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3212288 ++read 2048/2048 bytes at offset 3212288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3216384 ++read 2048/2048 bytes at offset 3216384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3220480 ++read 2048/2048 bytes at offset 3220480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3224576 ++read 2048/2048 bytes at offset 3224576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3228672 ++read 2048/2048 bytes at offset 3228672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3232768 ++read 2048/2048 bytes at offset 3232768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3236864 ++read 2048/2048 bytes at offset 3236864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3240960 ++read 2048/2048 bytes at offset 3240960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3245056 ++read 2048/2048 bytes at offset 3245056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3249152 ++read 2048/2048 bytes at offset 3249152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3253248 ++read 2048/2048 bytes at offset 3253248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3257344 ++read 2048/2048 bytes at offset 3257344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3261440 ++read 2048/2048 bytes at offset 3261440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3265536 ++read 2048/2048 bytes at offset 3265536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3269632 ++read 2048/2048 bytes at offset 3269632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3273728 ++read 2048/2048 bytes at offset 3273728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3277824 ++read 2048/2048 bytes at offset 3277824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3281920 ++read 2048/2048 bytes at offset 3281920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3286016 ++read 2048/2048 bytes at offset 3286016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3290112 ++read 2048/2048 bytes at offset 3290112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3294208 ++read 2048/2048 bytes at offset 3294208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3298304 ++read 2048/2048 bytes at offset 3298304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3302400 ++read 2048/2048 bytes at offset 3302400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3306496 ++read 2048/2048 bytes at offset 3306496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3310592 ++read 2048/2048 bytes at offset 3310592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3314688 ++read 2048/2048 bytes at offset 3314688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3318784 ++read 2048/2048 bytes at offset 3318784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3322880 ++read 2048/2048 bytes at offset 3322880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3326976 ++read 2048/2048 bytes at offset 3326976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3331072 ++read 2048/2048 bytes at offset 3331072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3335168 ++read 2048/2048 bytes at offset 3335168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3339264 ++read 2048/2048 bytes at offset 3339264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3343360 ++read 2048/2048 bytes at offset 3343360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3347456 ++read 2048/2048 bytes at offset 3347456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3351552 ++read 2048/2048 bytes at offset 3351552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3355648 ++read 2048/2048 bytes at offset 3355648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3359744 ++read 2048/2048 bytes at offset 3359744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3363840 ++read 2048/2048 bytes at offset 3363840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3367936 ++read 2048/2048 bytes at offset 3367936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3372032 ++read 2048/2048 bytes at offset 3372032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3376128 ++read 2048/2048 bytes at offset 3376128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3380224 ++read 2048/2048 bytes at offset 3380224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3384320 ++read 2048/2048 bytes at offset 3384320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3388416 ++read 2048/2048 bytes at offset 3388416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3392512 ++read 2048/2048 bytes at offset 3392512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3396608 ++read 2048/2048 bytes at offset 3396608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3400704 ++read 2048/2048 bytes at offset 3400704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3404800 ++read 2048/2048 bytes at offset 3404800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3408896 ++read 2048/2048 bytes at offset 3408896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3412992 ++read 2048/2048 bytes at offset 3412992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3417088 ++read 2048/2048 bytes at offset 3417088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3421184 ++read 2048/2048 bytes at offset 3421184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3425280 ++read 2048/2048 bytes at offset 3425280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3429376 ++read 2048/2048 bytes at offset 3429376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3433472 ++read 2048/2048 bytes at offset 3433472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3437568 ++read 2048/2048 bytes at offset 3437568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3441664 ++read 2048/2048 bytes at offset 3441664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3445760 ++read 2048/2048 bytes at offset 3445760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3449856 ++read 2048/2048 bytes at offset 3449856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3453952 ++read 2048/2048 bytes at offset 3453952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3458048 ++read 2048/2048 bytes at offset 3458048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3462144 ++read 2048/2048 bytes at offset 3462144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3466240 ++read 2048/2048 bytes at offset 3466240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3470336 ++read 2048/2048 bytes at offset 3470336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3474432 ++read 2048/2048 bytes at offset 3474432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3478528 ++read 2048/2048 bytes at offset 3478528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3482624 ++read 2048/2048 bytes at offset 3482624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3486720 ++read 2048/2048 bytes at offset 3486720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3490816 ++read 2048/2048 bytes at offset 3490816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3494912 ++read 2048/2048 bytes at offset 3494912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3499008 ++read 2048/2048 bytes at offset 3499008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3503104 ++read 2048/2048 bytes at offset 3503104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3507200 ++read 2048/2048 bytes at offset 3507200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3511296 ++read 2048/2048 bytes at offset 3511296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3515392 ++read 2048/2048 bytes at offset 3515392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3519488 ++read 2048/2048 bytes at offset 3519488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3523584 ++read 2048/2048 bytes at offset 3523584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3527680 ++read 2048/2048 bytes at offset 3527680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3531776 ++read 2048/2048 bytes at offset 3531776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3535872 ++read 2048/2048 bytes at offset 3535872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3539968 ++read 2048/2048 bytes at offset 3539968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3544064 ++read 2048/2048 bytes at offset 3544064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3548160 ++read 2048/2048 bytes at offset 3548160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3552256 ++read 2048/2048 bytes at offset 3552256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3556352 ++read 2048/2048 bytes at offset 3556352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3560448 ++read 2048/2048 bytes at offset 3560448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3564544 ++read 2048/2048 bytes at offset 3564544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3568640 ++read 2048/2048 bytes at offset 3568640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3572736 ++read 2048/2048 bytes at offset 3572736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3576832 ++read 2048/2048 bytes at offset 3576832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3580928 ++read 2048/2048 bytes at offset 3580928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3585024 ++read 2048/2048 bytes at offset 3585024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3589120 ++read 2048/2048 bytes at offset 3589120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3593216 ++read 2048/2048 bytes at offset 3593216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3597312 ++read 2048/2048 bytes at offset 3597312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3601408 ++read 2048/2048 bytes at offset 3601408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3605504 ++read 2048/2048 bytes at offset 3605504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3609600 ++read 2048/2048 bytes at offset 3609600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3613696 ++read 2048/2048 bytes at offset 3613696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3617792 ++read 2048/2048 bytes at offset 3617792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3621888 ++read 2048/2048 bytes at offset 3621888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3625984 ++read 2048/2048 bytes at offset 3625984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3630080 ++read 2048/2048 bytes at offset 3630080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3634176 ++read 2048/2048 bytes at offset 3634176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3638272 ++read 2048/2048 bytes at offset 3638272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3642368 ++read 2048/2048 bytes at offset 3642368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3646464 ++read 2048/2048 bytes at offset 3646464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3650560 ++read 2048/2048 bytes at offset 3650560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3654656 ++read 2048/2048 bytes at offset 3654656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3658752 ++read 2048/2048 bytes at offset 3658752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3662848 ++read 2048/2048 bytes at offset 3662848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3666944 ++read 2048/2048 bytes at offset 3666944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3671040 ++read 2048/2048 bytes at offset 3671040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3675136 ++read 2048/2048 bytes at offset 3675136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3679232 ++read 2048/2048 bytes at offset 3679232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3683328 ++read 2048/2048 bytes at offset 3683328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3687424 ++read 2048/2048 bytes at offset 3687424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3691520 ++read 2048/2048 bytes at offset 3691520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3695616 ++read 2048/2048 bytes at offset 3695616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3699712 ++read 2048/2048 bytes at offset 3699712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3703808 ++read 2048/2048 bytes at offset 3703808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3707904 ++read 2048/2048 bytes at offset 3707904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3712000 ++read 2048/2048 bytes at offset 3712000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3716096 ++read 2048/2048 bytes at offset 3716096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3720192 ++read 2048/2048 bytes at offset 3720192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3724288 ++read 2048/2048 bytes at offset 3724288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3728384 ++read 2048/2048 bytes at offset 3728384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3732480 ++read 2048/2048 bytes at offset 3732480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3736576 ++read 2048/2048 bytes at offset 3736576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3740672 ++read 2048/2048 bytes at offset 3740672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3744768 ++read 2048/2048 bytes at offset 3744768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3748864 ++read 2048/2048 bytes at offset 3748864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3752960 ++read 2048/2048 bytes at offset 3752960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3757056 ++read 2048/2048 bytes at offset 3757056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3761152 ++read 2048/2048 bytes at offset 3761152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3765248 ++read 2048/2048 bytes at offset 3765248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3769344 ++read 2048/2048 bytes at offset 3769344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3773440 ++read 2048/2048 bytes at offset 3773440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3777536 ++read 2048/2048 bytes at offset 3777536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3781632 ++read 2048/2048 bytes at offset 3781632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3785728 ++read 2048/2048 bytes at offset 3785728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3789824 ++read 2048/2048 bytes at offset 3789824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3793920 ++read 2048/2048 bytes at offset 3793920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3798016 ++read 2048/2048 bytes at offset 3798016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3802112 ++read 2048/2048 bytes at offset 3802112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3806208 ++read 2048/2048 bytes at offset 3806208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3810304 ++read 2048/2048 bytes at offset 3810304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3814400 ++read 2048/2048 bytes at offset 3814400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3818496 ++read 2048/2048 bytes at offset 3818496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3822592 ++read 2048/2048 bytes at offset 3822592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3826688 ++read 2048/2048 bytes at offset 3826688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3830784 ++read 2048/2048 bytes at offset 3830784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3834880 ++read 2048/2048 bytes at offset 3834880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3838976 ++read 2048/2048 bytes at offset 3838976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3843072 ++read 2048/2048 bytes at offset 3843072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3847168 ++read 2048/2048 bytes at offset 3847168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3851264 ++read 2048/2048 bytes at offset 3851264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3855360 ++read 2048/2048 bytes at offset 3855360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3859456 ++read 2048/2048 bytes at offset 3859456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3863552 ++read 2048/2048 bytes at offset 3863552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3867648 ++read 2048/2048 bytes at offset 3867648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3871744 ++read 2048/2048 bytes at offset 3871744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3875840 ++read 2048/2048 bytes at offset 3875840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3879936 ++read 2048/2048 bytes at offset 3879936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3884032 ++read 2048/2048 bytes at offset 3884032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3888128 ++read 2048/2048 bytes at offset 3888128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3892224 ++read 2048/2048 bytes at offset 3892224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3896320 ++read 2048/2048 bytes at offset 3896320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3900416 ++read 2048/2048 bytes at offset 3900416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3904512 ++read 2048/2048 bytes at offset 3904512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3908608 ++read 2048/2048 bytes at offset 3908608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3912704 ++read 2048/2048 bytes at offset 3912704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3916800 ++read 2048/2048 bytes at offset 3916800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3920896 ++read 2048/2048 bytes at offset 3920896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3924992 ++read 2048/2048 bytes at offset 3924992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3929088 ++read 2048/2048 bytes at offset 3929088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3933184 ++read 2048/2048 bytes at offset 3933184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3937280 ++read 2048/2048 bytes at offset 3937280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3941376 ++read 2048/2048 bytes at offset 3941376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3945472 ++read 2048/2048 bytes at offset 3945472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3949568 ++read 2048/2048 bytes at offset 3949568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3953664 ++read 2048/2048 bytes at offset 3953664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3957760 ++read 2048/2048 bytes at offset 3957760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3961856 ++read 2048/2048 bytes at offset 3961856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3965952 ++read 2048/2048 bytes at offset 3965952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3970048 ++read 2048/2048 bytes at offset 3970048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3974144 ++read 2048/2048 bytes at offset 3974144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3978240 ++read 2048/2048 bytes at offset 3978240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3982336 ++read 2048/2048 bytes at offset 3982336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3986432 ++read 2048/2048 bytes at offset 3986432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3990528 ++read 2048/2048 bytes at offset 3990528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3994624 ++read 2048/2048 bytes at offset 3994624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3998720 ++read 2048/2048 bytes at offset 3998720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4002816 ++read 2048/2048 bytes at offset 4002816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4006912 ++read 2048/2048 bytes at offset 4006912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4011008 ++read 2048/2048 bytes at offset 4011008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4015104 ++read 2048/2048 bytes at offset 4015104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4019200 ++read 2048/2048 bytes at offset 4019200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4023296 ++read 2048/2048 bytes at offset 4023296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4027392 ++read 2048/2048 bytes at offset 4027392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4031488 ++read 2048/2048 bytes at offset 4031488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4035584 ++read 2048/2048 bytes at offset 4035584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4039680 ++read 2048/2048 bytes at offset 4039680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4043776 ++read 2048/2048 bytes at offset 4043776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4047872 ++read 2048/2048 bytes at offset 4047872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4051968 ++read 2048/2048 bytes at offset 4051968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4056064 ++read 2048/2048 bytes at offset 4056064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4060160 ++read 2048/2048 bytes at offset 4060160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4064256 ++read 2048/2048 bytes at offset 4064256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4068352 ++read 2048/2048 bytes at offset 4068352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4072448 ++read 2048/2048 bytes at offset 4072448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4076544 ++read 2048/2048 bytes at offset 4076544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4080640 ++read 2048/2048 bytes at offset 4080640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4084736 ++read 2048/2048 bytes at offset 4084736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4088832 ++read 2048/2048 bytes at offset 4088832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4092928 ++read 2048/2048 bytes at offset 4092928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4097024 ++read 2048/2048 bytes at offset 4097024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4101120 ++read 2048/2048 bytes at offset 4101120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4105216 ++read 2048/2048 bytes at offset 4105216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4109312 ++read 2048/2048 bytes at offset 4109312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4113408 ++read 2048/2048 bytes at offset 4113408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4117504 ++read 2048/2048 bytes at offset 4117504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4121600 ++read 2048/2048 bytes at offset 4121600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4125696 ++read 2048/2048 bytes at offset 4125696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4129792 ++read 2048/2048 bytes at offset 4129792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4133888 ++read 2048/2048 bytes at offset 4133888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4137984 ++read 2048/2048 bytes at offset 4137984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4142080 ++read 2048/2048 bytes at offset 4142080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4146176 ++read 2048/2048 bytes at offset 4146176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4150272 ++read 2048/2048 bytes at offset 4150272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4154368 ++read 2048/2048 bytes at offset 4154368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4158464 ++read 2048/2048 bytes at offset 4158464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4162560 ++read 2048/2048 bytes at offset 4162560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4166656 ++read 2048/2048 bytes at offset 4166656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4170752 ++read 2048/2048 bytes at offset 4170752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4174848 ++read 2048/2048 bytes at offset 4174848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4178944 ++read 2048/2048 bytes at offset 4178944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4183040 ++read 2048/2048 bytes at offset 4183040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4187136 ++read 2048/2048 bytes at offset 4187136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4191232 ++read 2048/2048 bytes at offset 4191232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 4 +-qemu-io> read 8192/8192 bytes at offset 4196352 ++=== IO: pattern 4 ++read 8192/8192 bytes at offset 4196352 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4208640 ++read 8192/8192 bytes at offset 4208640 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4220928 ++read 8192/8192 bytes at offset 4220928 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4233216 ++read 8192/8192 bytes at offset 4233216 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4245504 ++read 8192/8192 bytes at offset 4245504 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4257792 ++read 8192/8192 bytes at offset 4257792 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4270080 ++read 8192/8192 bytes at offset 4270080 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4282368 ++read 8192/8192 bytes at offset 4282368 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4294656 ++read 8192/8192 bytes at offset 4294656 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4306944 ++read 8192/8192 bytes at offset 4306944 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4319232 ++read 8192/8192 bytes at offset 4319232 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4331520 ++read 8192/8192 bytes at offset 4331520 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4343808 ++read 8192/8192 bytes at offset 4343808 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4356096 ++read 8192/8192 bytes at offset 4356096 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4368384 ++read 8192/8192 bytes at offset 4368384 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4380672 ++read 8192/8192 bytes at offset 4380672 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4392960 ++read 8192/8192 bytes at offset 4392960 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4405248 ++read 8192/8192 bytes at offset 4405248 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4417536 ++read 8192/8192 bytes at offset 4417536 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4429824 ++read 8192/8192 bytes at offset 4429824 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4442112 ++read 8192/8192 bytes at offset 4442112 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4454400 ++read 8192/8192 bytes at offset 4454400 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4466688 ++read 8192/8192 bytes at offset 4466688 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4478976 ++read 8192/8192 bytes at offset 4478976 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4491264 ++read 8192/8192 bytes at offset 4491264 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4503552 ++read 8192/8192 bytes at offset 4503552 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4515840 ++read 8192/8192 bytes at offset 4515840 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4528128 ++read 8192/8192 bytes at offset 4528128 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4540416 ++read 8192/8192 bytes at offset 4540416 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4552704 ++read 8192/8192 bytes at offset 4552704 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4564992 ++read 8192/8192 bytes at offset 4564992 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4577280 ++read 8192/8192 bytes at offset 4577280 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4589568 ++read 8192/8192 bytes at offset 4589568 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4601856 ++read 8192/8192 bytes at offset 4601856 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4614144 ++read 8192/8192 bytes at offset 4614144 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4626432 ++read 8192/8192 bytes at offset 4626432 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4638720 ++read 8192/8192 bytes at offset 4638720 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4651008 ++read 8192/8192 bytes at offset 4651008 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4663296 ++read 8192/8192 bytes at offset 4663296 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4675584 ++read 8192/8192 bytes at offset 4675584 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4687872 ++read 8192/8192 bytes at offset 4687872 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4700160 ++read 8192/8192 bytes at offset 4700160 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4712448 ++read 8192/8192 bytes at offset 4712448 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4724736 ++read 8192/8192 bytes at offset 4724736 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4737024 ++read 8192/8192 bytes at offset 4737024 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4749312 ++read 8192/8192 bytes at offset 4749312 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4761600 ++read 8192/8192 bytes at offset 4761600 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4773888 ++read 8192/8192 bytes at offset 4773888 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4786176 ++read 8192/8192 bytes at offset 4786176 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4798464 ++read 8192/8192 bytes at offset 4798464 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4810752 ++read 8192/8192 bytes at offset 4810752 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4823040 ++read 8192/8192 bytes at offset 4823040 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4835328 ++read 8192/8192 bytes at offset 4835328 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4847616 ++read 8192/8192 bytes at offset 4847616 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4859904 ++read 8192/8192 bytes at offset 4859904 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4872192 ++read 8192/8192 bytes at offset 4872192 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4884480 ++read 8192/8192 bytes at offset 4884480 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4896768 ++read 8192/8192 bytes at offset 4896768 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4909056 ++read 8192/8192 bytes at offset 4909056 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4921344 ++read 8192/8192 bytes at offset 4921344 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4933632 ++read 8192/8192 bytes at offset 4933632 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4945920 ++read 8192/8192 bytes at offset 4945920 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4958208 ++read 8192/8192 bytes at offset 4958208 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4970496 ++read 8192/8192 bytes at offset 4970496 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 244 +-qemu-io> read 12288/12288 bytes at offset 6285312 ++=== IO: pattern 244 ++read 12288/12288 bytes at offset 6285312 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 8384512 ++read 12288/12288 bytes at offset 8384512 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 10483712 ++read 12288/12288 bytes at offset 10483712 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 12582912 ++read 12288/12288 bytes at offset 12582912 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 14682112 ++read 12288/12288 bytes at offset 14682112 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 16781312 ++read 12288/12288 bytes at offset 16781312 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 18880512 ++read 12288/12288 bytes at offset 18880512 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 20979712 ++read 12288/12288 bytes at offset 20979712 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> wrote 4096/4096 bytes at offset 0 ++=== IO: pattern 0 ++wrote 4096/4096 bytes at offset 0 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4096 ++wrote 4096/4096 bytes at offset 4096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8192 ++wrote 4096/4096 bytes at offset 8192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 12288 ++wrote 4096/4096 bytes at offset 12288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 16384 ++wrote 4096/4096 bytes at offset 16384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 20480 ++wrote 4096/4096 bytes at offset 20480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 24576 ++wrote 4096/4096 bytes at offset 24576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 28672 ++wrote 4096/4096 bytes at offset 28672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 32768 ++wrote 4096/4096 bytes at offset 32768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 36864 ++wrote 4096/4096 bytes at offset 36864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 40960 ++wrote 4096/4096 bytes at offset 40960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 45056 ++wrote 4096/4096 bytes at offset 45056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 49152 ++wrote 4096/4096 bytes at offset 49152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 53248 ++wrote 4096/4096 bytes at offset 53248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 57344 ++wrote 4096/4096 bytes at offset 57344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 61440 ++wrote 4096/4096 bytes at offset 61440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 65536 ++wrote 4096/4096 bytes at offset 65536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 69632 ++wrote 4096/4096 bytes at offset 69632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 73728 ++wrote 4096/4096 bytes at offset 73728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 77824 ++wrote 4096/4096 bytes at offset 77824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 81920 ++wrote 4096/4096 bytes at offset 81920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 86016 ++wrote 4096/4096 bytes at offset 86016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 90112 ++wrote 4096/4096 bytes at offset 90112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 94208 ++wrote 4096/4096 bytes at offset 94208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 98304 ++wrote 4096/4096 bytes at offset 98304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 102400 ++wrote 4096/4096 bytes at offset 102400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 106496 ++wrote 4096/4096 bytes at offset 106496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 110592 ++wrote 4096/4096 bytes at offset 110592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 114688 ++wrote 4096/4096 bytes at offset 114688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 118784 ++wrote 4096/4096 bytes at offset 118784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 122880 ++wrote 4096/4096 bytes at offset 122880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 126976 ++wrote 4096/4096 bytes at offset 126976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 131072 ++wrote 4096/4096 bytes at offset 131072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 135168 ++wrote 4096/4096 bytes at offset 135168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 139264 ++wrote 4096/4096 bytes at offset 139264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 143360 ++wrote 4096/4096 bytes at offset 143360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 147456 ++wrote 4096/4096 bytes at offset 147456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 151552 ++wrote 4096/4096 bytes at offset 151552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 155648 ++wrote 4096/4096 bytes at offset 155648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 159744 ++wrote 4096/4096 bytes at offset 159744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 163840 ++wrote 4096/4096 bytes at offset 163840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 167936 ++wrote 4096/4096 bytes at offset 167936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 172032 ++wrote 4096/4096 bytes at offset 172032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 176128 ++wrote 4096/4096 bytes at offset 176128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 180224 ++wrote 4096/4096 bytes at offset 180224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 184320 ++wrote 4096/4096 bytes at offset 184320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 188416 ++wrote 4096/4096 bytes at offset 188416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 192512 ++wrote 4096/4096 bytes at offset 192512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 196608 ++wrote 4096/4096 bytes at offset 196608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 200704 ++wrote 4096/4096 bytes at offset 200704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 204800 ++wrote 4096/4096 bytes at offset 204800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 208896 ++wrote 4096/4096 bytes at offset 208896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 212992 ++wrote 4096/4096 bytes at offset 212992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 217088 ++wrote 4096/4096 bytes at offset 217088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 221184 ++wrote 4096/4096 bytes at offset 221184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 225280 ++wrote 4096/4096 bytes at offset 225280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 229376 ++wrote 4096/4096 bytes at offset 229376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 233472 ++wrote 4096/4096 bytes at offset 233472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 237568 ++wrote 4096/4096 bytes at offset 237568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 241664 ++wrote 4096/4096 bytes at offset 241664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 245760 ++wrote 4096/4096 bytes at offset 245760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 249856 ++wrote 4096/4096 bytes at offset 249856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 253952 ++wrote 4096/4096 bytes at offset 253952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 258048 ++wrote 4096/4096 bytes at offset 258048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 262144 ++wrote 4096/4096 bytes at offset 262144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 266240 ++wrote 4096/4096 bytes at offset 266240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 270336 ++wrote 4096/4096 bytes at offset 270336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 274432 ++wrote 4096/4096 bytes at offset 274432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 278528 ++wrote 4096/4096 bytes at offset 278528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 282624 ++wrote 4096/4096 bytes at offset 282624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 286720 ++wrote 4096/4096 bytes at offset 286720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 290816 ++wrote 4096/4096 bytes at offset 290816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 294912 ++wrote 4096/4096 bytes at offset 294912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 299008 ++wrote 4096/4096 bytes at offset 299008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 303104 ++wrote 4096/4096 bytes at offset 303104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 307200 ++wrote 4096/4096 bytes at offset 307200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 311296 ++wrote 4096/4096 bytes at offset 311296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 315392 ++wrote 4096/4096 bytes at offset 315392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 319488 ++wrote 4096/4096 bytes at offset 319488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 323584 ++wrote 4096/4096 bytes at offset 323584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 327680 ++wrote 4096/4096 bytes at offset 327680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 331776 ++wrote 4096/4096 bytes at offset 331776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 335872 ++wrote 4096/4096 bytes at offset 335872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 339968 ++wrote 4096/4096 bytes at offset 339968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 344064 ++wrote 4096/4096 bytes at offset 344064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 348160 ++wrote 4096/4096 bytes at offset 348160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 352256 ++wrote 4096/4096 bytes at offset 352256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 356352 ++wrote 4096/4096 bytes at offset 356352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 360448 ++wrote 4096/4096 bytes at offset 360448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 364544 ++wrote 4096/4096 bytes at offset 364544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 368640 ++wrote 4096/4096 bytes at offset 368640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 372736 ++wrote 4096/4096 bytes at offset 372736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 376832 ++wrote 4096/4096 bytes at offset 376832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 380928 ++wrote 4096/4096 bytes at offset 380928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 385024 ++wrote 4096/4096 bytes at offset 385024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 389120 ++wrote 4096/4096 bytes at offset 389120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 393216 ++wrote 4096/4096 bytes at offset 393216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 397312 ++wrote 4096/4096 bytes at offset 397312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 401408 ++wrote 4096/4096 bytes at offset 401408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 405504 ++wrote 4096/4096 bytes at offset 405504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 409600 ++wrote 4096/4096 bytes at offset 409600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 413696 ++wrote 4096/4096 bytes at offset 413696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 417792 ++wrote 4096/4096 bytes at offset 417792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 421888 ++wrote 4096/4096 bytes at offset 421888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 425984 ++wrote 4096/4096 bytes at offset 425984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 430080 ++wrote 4096/4096 bytes at offset 430080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 434176 ++wrote 4096/4096 bytes at offset 434176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 438272 ++wrote 4096/4096 bytes at offset 438272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 442368 ++wrote 4096/4096 bytes at offset 442368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 446464 ++wrote 4096/4096 bytes at offset 446464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 450560 ++wrote 4096/4096 bytes at offset 450560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 454656 ++wrote 4096/4096 bytes at offset 454656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 458752 ++wrote 4096/4096 bytes at offset 458752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 462848 ++wrote 4096/4096 bytes at offset 462848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 466944 ++wrote 4096/4096 bytes at offset 466944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 471040 ++wrote 4096/4096 bytes at offset 471040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 475136 ++wrote 4096/4096 bytes at offset 475136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 479232 ++wrote 4096/4096 bytes at offset 479232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 483328 ++wrote 4096/4096 bytes at offset 483328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 487424 ++wrote 4096/4096 bytes at offset 487424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 491520 ++wrote 4096/4096 bytes at offset 491520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 495616 ++wrote 4096/4096 bytes at offset 495616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 499712 ++wrote 4096/4096 bytes at offset 499712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 503808 ++wrote 4096/4096 bytes at offset 503808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 507904 ++wrote 4096/4096 bytes at offset 507904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 512000 ++wrote 4096/4096 bytes at offset 512000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 516096 ++wrote 4096/4096 bytes at offset 516096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 520192 ++wrote 4096/4096 bytes at offset 520192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 524288 ++wrote 4096/4096 bytes at offset 524288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 528384 ++wrote 4096/4096 bytes at offset 528384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 532480 ++wrote 4096/4096 bytes at offset 532480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 536576 ++wrote 4096/4096 bytes at offset 536576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 540672 ++wrote 4096/4096 bytes at offset 540672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 544768 ++wrote 4096/4096 bytes at offset 544768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 548864 ++wrote 4096/4096 bytes at offset 548864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 552960 ++wrote 4096/4096 bytes at offset 552960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 557056 ++wrote 4096/4096 bytes at offset 557056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 561152 ++wrote 4096/4096 bytes at offset 561152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 565248 ++wrote 4096/4096 bytes at offset 565248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 569344 ++wrote 4096/4096 bytes at offset 569344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 573440 ++wrote 4096/4096 bytes at offset 573440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 577536 ++wrote 4096/4096 bytes at offset 577536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 581632 ++wrote 4096/4096 bytes at offset 581632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 585728 ++wrote 4096/4096 bytes at offset 585728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 589824 ++wrote 4096/4096 bytes at offset 589824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 593920 ++wrote 4096/4096 bytes at offset 593920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 598016 ++wrote 4096/4096 bytes at offset 598016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 602112 ++wrote 4096/4096 bytes at offset 602112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 606208 ++wrote 4096/4096 bytes at offset 606208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 610304 ++wrote 4096/4096 bytes at offset 610304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 614400 ++wrote 4096/4096 bytes at offset 614400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 618496 ++wrote 4096/4096 bytes at offset 618496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 622592 ++wrote 4096/4096 bytes at offset 622592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 626688 ++wrote 4096/4096 bytes at offset 626688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 630784 ++wrote 4096/4096 bytes at offset 630784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 634880 ++wrote 4096/4096 bytes at offset 634880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 638976 ++wrote 4096/4096 bytes at offset 638976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 643072 ++wrote 4096/4096 bytes at offset 643072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 647168 ++wrote 4096/4096 bytes at offset 647168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 651264 ++wrote 4096/4096 bytes at offset 651264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 655360 ++wrote 4096/4096 bytes at offset 655360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 659456 ++wrote 4096/4096 bytes at offset 659456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 663552 ++wrote 4096/4096 bytes at offset 663552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 667648 ++wrote 4096/4096 bytes at offset 667648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 671744 ++wrote 4096/4096 bytes at offset 671744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 675840 ++wrote 4096/4096 bytes at offset 675840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 679936 ++wrote 4096/4096 bytes at offset 679936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 684032 ++wrote 4096/4096 bytes at offset 684032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 688128 ++wrote 4096/4096 bytes at offset 688128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 692224 ++wrote 4096/4096 bytes at offset 692224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 696320 ++wrote 4096/4096 bytes at offset 696320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 700416 ++wrote 4096/4096 bytes at offset 700416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 704512 ++wrote 4096/4096 bytes at offset 704512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 708608 ++wrote 4096/4096 bytes at offset 708608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 712704 ++wrote 4096/4096 bytes at offset 712704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 716800 ++wrote 4096/4096 bytes at offset 716800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 720896 ++wrote 4096/4096 bytes at offset 720896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 724992 ++wrote 4096/4096 bytes at offset 724992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 729088 ++wrote 4096/4096 bytes at offset 729088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 733184 ++wrote 4096/4096 bytes at offset 733184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 737280 ++wrote 4096/4096 bytes at offset 737280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 741376 ++wrote 4096/4096 bytes at offset 741376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 745472 ++wrote 4096/4096 bytes at offset 745472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 749568 ++wrote 4096/4096 bytes at offset 749568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 753664 ++wrote 4096/4096 bytes at offset 753664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 757760 ++wrote 4096/4096 bytes at offset 757760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 761856 ++wrote 4096/4096 bytes at offset 761856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 765952 ++wrote 4096/4096 bytes at offset 765952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 770048 ++wrote 4096/4096 bytes at offset 770048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 774144 ++wrote 4096/4096 bytes at offset 774144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 778240 ++wrote 4096/4096 bytes at offset 778240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 782336 ++wrote 4096/4096 bytes at offset 782336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 786432 ++wrote 4096/4096 bytes at offset 786432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 790528 ++wrote 4096/4096 bytes at offset 790528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 794624 ++wrote 4096/4096 bytes at offset 794624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 798720 ++wrote 4096/4096 bytes at offset 798720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 802816 ++wrote 4096/4096 bytes at offset 802816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 806912 ++wrote 4096/4096 bytes at offset 806912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 811008 ++wrote 4096/4096 bytes at offset 811008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 815104 ++wrote 4096/4096 bytes at offset 815104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 819200 ++wrote 4096/4096 bytes at offset 819200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 823296 ++wrote 4096/4096 bytes at offset 823296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 827392 ++wrote 4096/4096 bytes at offset 827392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 831488 ++wrote 4096/4096 bytes at offset 831488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 835584 ++wrote 4096/4096 bytes at offset 835584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 839680 ++wrote 4096/4096 bytes at offset 839680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 843776 ++wrote 4096/4096 bytes at offset 843776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 847872 ++wrote 4096/4096 bytes at offset 847872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 851968 ++wrote 4096/4096 bytes at offset 851968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 856064 ++wrote 4096/4096 bytes at offset 856064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 860160 ++wrote 4096/4096 bytes at offset 860160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 864256 ++wrote 4096/4096 bytes at offset 864256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 868352 ++wrote 4096/4096 bytes at offset 868352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 872448 ++wrote 4096/4096 bytes at offset 872448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 876544 ++wrote 4096/4096 bytes at offset 876544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 880640 ++wrote 4096/4096 bytes at offset 880640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 884736 ++wrote 4096/4096 bytes at offset 884736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 888832 ++wrote 4096/4096 bytes at offset 888832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 892928 ++wrote 4096/4096 bytes at offset 892928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 897024 ++wrote 4096/4096 bytes at offset 897024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 901120 ++wrote 4096/4096 bytes at offset 901120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 905216 ++wrote 4096/4096 bytes at offset 905216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 909312 ++wrote 4096/4096 bytes at offset 909312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 913408 ++wrote 4096/4096 bytes at offset 913408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 917504 ++wrote 4096/4096 bytes at offset 917504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 921600 ++wrote 4096/4096 bytes at offset 921600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 925696 ++wrote 4096/4096 bytes at offset 925696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 929792 ++wrote 4096/4096 bytes at offset 929792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 933888 ++wrote 4096/4096 bytes at offset 933888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 937984 ++wrote 4096/4096 bytes at offset 937984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 942080 ++wrote 4096/4096 bytes at offset 942080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 946176 ++wrote 4096/4096 bytes at offset 946176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 950272 ++wrote 4096/4096 bytes at offset 950272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 954368 ++wrote 4096/4096 bytes at offset 954368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 958464 ++wrote 4096/4096 bytes at offset 958464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 962560 ++wrote 4096/4096 bytes at offset 962560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 966656 ++wrote 4096/4096 bytes at offset 966656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 970752 ++wrote 4096/4096 bytes at offset 970752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 974848 ++wrote 4096/4096 bytes at offset 974848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 978944 ++wrote 4096/4096 bytes at offset 978944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 983040 ++wrote 4096/4096 bytes at offset 983040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 987136 ++wrote 4096/4096 bytes at offset 987136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 991232 ++wrote 4096/4096 bytes at offset 991232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 995328 ++wrote 4096/4096 bytes at offset 995328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 999424 ++wrote 4096/4096 bytes at offset 999424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1003520 ++wrote 4096/4096 bytes at offset 1003520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1007616 ++wrote 4096/4096 bytes at offset 1007616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1011712 ++wrote 4096/4096 bytes at offset 1011712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1015808 ++wrote 4096/4096 bytes at offset 1015808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1019904 ++wrote 4096/4096 bytes at offset 1019904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1024000 ++wrote 4096/4096 bytes at offset 1024000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1028096 ++wrote 4096/4096 bytes at offset 1028096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1032192 ++wrote 4096/4096 bytes at offset 1032192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1036288 ++wrote 4096/4096 bytes at offset 1036288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1040384 ++wrote 4096/4096 bytes at offset 1040384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1044480 ++wrote 4096/4096 bytes at offset 1044480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 4 +-qemu-io> wrote 2048/2048 bytes at offset 1050624 ++=== IO: pattern 4 ++wrote 2048/2048 bytes at offset 1050624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1054720 ++wrote 2048/2048 bytes at offset 1054720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1058816 ++wrote 2048/2048 bytes at offset 1058816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1062912 ++wrote 2048/2048 bytes at offset 1062912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1067008 ++wrote 2048/2048 bytes at offset 1067008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1071104 ++wrote 2048/2048 bytes at offset 1071104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1075200 ++wrote 2048/2048 bytes at offset 1075200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1079296 ++wrote 2048/2048 bytes at offset 1079296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1083392 ++wrote 2048/2048 bytes at offset 1083392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1087488 ++wrote 2048/2048 bytes at offset 1087488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1091584 ++wrote 2048/2048 bytes at offset 1091584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1095680 ++wrote 2048/2048 bytes at offset 1095680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1099776 ++wrote 2048/2048 bytes at offset 1099776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1103872 ++wrote 2048/2048 bytes at offset 1103872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1107968 ++wrote 2048/2048 bytes at offset 1107968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1112064 ++wrote 2048/2048 bytes at offset 1112064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1116160 ++wrote 2048/2048 bytes at offset 1116160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1120256 ++wrote 2048/2048 bytes at offset 1120256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1124352 ++wrote 2048/2048 bytes at offset 1124352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1128448 ++wrote 2048/2048 bytes at offset 1128448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1132544 ++wrote 2048/2048 bytes at offset 1132544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1136640 ++wrote 2048/2048 bytes at offset 1136640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1140736 ++wrote 2048/2048 bytes at offset 1140736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1144832 ++wrote 2048/2048 bytes at offset 1144832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1148928 ++wrote 2048/2048 bytes at offset 1148928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1153024 ++wrote 2048/2048 bytes at offset 1153024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1157120 ++wrote 2048/2048 bytes at offset 1157120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1161216 ++wrote 2048/2048 bytes at offset 1161216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1165312 ++wrote 2048/2048 bytes at offset 1165312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1169408 ++wrote 2048/2048 bytes at offset 1169408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1173504 ++wrote 2048/2048 bytes at offset 1173504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1177600 ++wrote 2048/2048 bytes at offset 1177600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1181696 ++wrote 2048/2048 bytes at offset 1181696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1185792 ++wrote 2048/2048 bytes at offset 1185792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1189888 ++wrote 2048/2048 bytes at offset 1189888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1193984 ++wrote 2048/2048 bytes at offset 1193984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1198080 ++wrote 2048/2048 bytes at offset 1198080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1202176 ++wrote 2048/2048 bytes at offset 1202176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1206272 ++wrote 2048/2048 bytes at offset 1206272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1210368 ++wrote 2048/2048 bytes at offset 1210368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1214464 ++wrote 2048/2048 bytes at offset 1214464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1218560 ++wrote 2048/2048 bytes at offset 1218560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1222656 ++wrote 2048/2048 bytes at offset 1222656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1226752 ++wrote 2048/2048 bytes at offset 1226752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1230848 ++wrote 2048/2048 bytes at offset 1230848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1234944 ++wrote 2048/2048 bytes at offset 1234944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1239040 ++wrote 2048/2048 bytes at offset 1239040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1243136 ++wrote 2048/2048 bytes at offset 1243136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1247232 ++wrote 2048/2048 bytes at offset 1247232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1251328 ++wrote 2048/2048 bytes at offset 1251328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1255424 ++wrote 2048/2048 bytes at offset 1255424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1259520 ++wrote 2048/2048 bytes at offset 1259520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1263616 ++wrote 2048/2048 bytes at offset 1263616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1267712 ++wrote 2048/2048 bytes at offset 1267712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1271808 ++wrote 2048/2048 bytes at offset 1271808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1275904 ++wrote 2048/2048 bytes at offset 1275904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1280000 ++wrote 2048/2048 bytes at offset 1280000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1284096 ++wrote 2048/2048 bytes at offset 1284096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1288192 ++wrote 2048/2048 bytes at offset 1288192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1292288 ++wrote 2048/2048 bytes at offset 1292288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1296384 ++wrote 2048/2048 bytes at offset 1296384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1300480 ++wrote 2048/2048 bytes at offset 1300480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1304576 ++wrote 2048/2048 bytes at offset 1304576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1308672 ++wrote 2048/2048 bytes at offset 1308672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1312768 ++wrote 2048/2048 bytes at offset 1312768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1316864 ++wrote 2048/2048 bytes at offset 1316864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1320960 ++wrote 2048/2048 bytes at offset 1320960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1325056 ++wrote 2048/2048 bytes at offset 1325056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1329152 ++wrote 2048/2048 bytes at offset 1329152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1333248 ++wrote 2048/2048 bytes at offset 1333248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1337344 ++wrote 2048/2048 bytes at offset 1337344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1341440 ++wrote 2048/2048 bytes at offset 1341440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1345536 ++wrote 2048/2048 bytes at offset 1345536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1349632 ++wrote 2048/2048 bytes at offset 1349632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1353728 ++wrote 2048/2048 bytes at offset 1353728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1357824 ++wrote 2048/2048 bytes at offset 1357824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1361920 ++wrote 2048/2048 bytes at offset 1361920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1366016 ++wrote 2048/2048 bytes at offset 1366016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1370112 ++wrote 2048/2048 bytes at offset 1370112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1374208 ++wrote 2048/2048 bytes at offset 1374208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1378304 ++wrote 2048/2048 bytes at offset 1378304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1382400 ++wrote 2048/2048 bytes at offset 1382400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1386496 ++wrote 2048/2048 bytes at offset 1386496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1390592 ++wrote 2048/2048 bytes at offset 1390592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1394688 ++wrote 2048/2048 bytes at offset 1394688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1398784 ++wrote 2048/2048 bytes at offset 1398784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1402880 ++wrote 2048/2048 bytes at offset 1402880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1406976 ++wrote 2048/2048 bytes at offset 1406976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1411072 ++wrote 2048/2048 bytes at offset 1411072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1415168 ++wrote 2048/2048 bytes at offset 1415168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1419264 ++wrote 2048/2048 bytes at offset 1419264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1423360 ++wrote 2048/2048 bytes at offset 1423360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1427456 ++wrote 2048/2048 bytes at offset 1427456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1431552 ++wrote 2048/2048 bytes at offset 1431552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1435648 ++wrote 2048/2048 bytes at offset 1435648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1439744 ++wrote 2048/2048 bytes at offset 1439744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1443840 ++wrote 2048/2048 bytes at offset 1443840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1447936 ++wrote 2048/2048 bytes at offset 1447936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1452032 ++wrote 2048/2048 bytes at offset 1452032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1456128 ++wrote 2048/2048 bytes at offset 1456128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1460224 ++wrote 2048/2048 bytes at offset 1460224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1464320 ++wrote 2048/2048 bytes at offset 1464320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1468416 ++wrote 2048/2048 bytes at offset 1468416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1472512 ++wrote 2048/2048 bytes at offset 1472512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1476608 ++wrote 2048/2048 bytes at offset 1476608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1480704 ++wrote 2048/2048 bytes at offset 1480704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1484800 ++wrote 2048/2048 bytes at offset 1484800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1488896 ++wrote 2048/2048 bytes at offset 1488896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1492992 ++wrote 2048/2048 bytes at offset 1492992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1497088 ++wrote 2048/2048 bytes at offset 1497088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1501184 ++wrote 2048/2048 bytes at offset 1501184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1505280 ++wrote 2048/2048 bytes at offset 1505280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1509376 ++wrote 2048/2048 bytes at offset 1509376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1513472 ++wrote 2048/2048 bytes at offset 1513472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1517568 ++wrote 2048/2048 bytes at offset 1517568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1521664 ++wrote 2048/2048 bytes at offset 1521664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1525760 ++wrote 2048/2048 bytes at offset 1525760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1529856 ++wrote 2048/2048 bytes at offset 1529856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1533952 ++wrote 2048/2048 bytes at offset 1533952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1538048 ++wrote 2048/2048 bytes at offset 1538048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1542144 ++wrote 2048/2048 bytes at offset 1542144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1546240 ++wrote 2048/2048 bytes at offset 1546240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1550336 ++wrote 2048/2048 bytes at offset 1550336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1554432 ++wrote 2048/2048 bytes at offset 1554432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1558528 ++wrote 2048/2048 bytes at offset 1558528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1562624 ++wrote 2048/2048 bytes at offset 1562624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1566720 ++wrote 2048/2048 bytes at offset 1566720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1570816 ++wrote 2048/2048 bytes at offset 1570816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1574912 ++wrote 2048/2048 bytes at offset 1574912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1579008 ++wrote 2048/2048 bytes at offset 1579008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1583104 ++wrote 2048/2048 bytes at offset 1583104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1587200 ++wrote 2048/2048 bytes at offset 1587200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1591296 ++wrote 2048/2048 bytes at offset 1591296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1595392 ++wrote 2048/2048 bytes at offset 1595392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1599488 ++wrote 2048/2048 bytes at offset 1599488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1603584 ++wrote 2048/2048 bytes at offset 1603584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1607680 ++wrote 2048/2048 bytes at offset 1607680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1611776 ++wrote 2048/2048 bytes at offset 1611776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1615872 ++wrote 2048/2048 bytes at offset 1615872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1619968 ++wrote 2048/2048 bytes at offset 1619968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1624064 ++wrote 2048/2048 bytes at offset 1624064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1628160 ++wrote 2048/2048 bytes at offset 1628160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1632256 ++wrote 2048/2048 bytes at offset 1632256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1636352 ++wrote 2048/2048 bytes at offset 1636352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1640448 ++wrote 2048/2048 bytes at offset 1640448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1644544 ++wrote 2048/2048 bytes at offset 1644544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1648640 ++wrote 2048/2048 bytes at offset 1648640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1652736 ++wrote 2048/2048 bytes at offset 1652736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1656832 ++wrote 2048/2048 bytes at offset 1656832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1660928 ++wrote 2048/2048 bytes at offset 1660928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1665024 ++wrote 2048/2048 bytes at offset 1665024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1669120 ++wrote 2048/2048 bytes at offset 1669120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1673216 ++wrote 2048/2048 bytes at offset 1673216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1677312 ++wrote 2048/2048 bytes at offset 1677312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1681408 ++wrote 2048/2048 bytes at offset 1681408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1685504 ++wrote 2048/2048 bytes at offset 1685504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1689600 ++wrote 2048/2048 bytes at offset 1689600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1693696 ++wrote 2048/2048 bytes at offset 1693696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1697792 ++wrote 2048/2048 bytes at offset 1697792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1701888 ++wrote 2048/2048 bytes at offset 1701888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1705984 ++wrote 2048/2048 bytes at offset 1705984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1710080 ++wrote 2048/2048 bytes at offset 1710080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1714176 ++wrote 2048/2048 bytes at offset 1714176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1718272 ++wrote 2048/2048 bytes at offset 1718272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1722368 ++wrote 2048/2048 bytes at offset 1722368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1726464 ++wrote 2048/2048 bytes at offset 1726464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1730560 ++wrote 2048/2048 bytes at offset 1730560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1734656 ++wrote 2048/2048 bytes at offset 1734656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1738752 ++wrote 2048/2048 bytes at offset 1738752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1742848 ++wrote 2048/2048 bytes at offset 1742848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1746944 ++wrote 2048/2048 bytes at offset 1746944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1751040 ++wrote 2048/2048 bytes at offset 1751040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1755136 ++wrote 2048/2048 bytes at offset 1755136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1759232 ++wrote 2048/2048 bytes at offset 1759232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1763328 ++wrote 2048/2048 bytes at offset 1763328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1767424 ++wrote 2048/2048 bytes at offset 1767424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1771520 ++wrote 2048/2048 bytes at offset 1771520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1775616 ++wrote 2048/2048 bytes at offset 1775616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1779712 ++wrote 2048/2048 bytes at offset 1779712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1783808 ++wrote 2048/2048 bytes at offset 1783808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1787904 ++wrote 2048/2048 bytes at offset 1787904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1792000 ++wrote 2048/2048 bytes at offset 1792000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1796096 ++wrote 2048/2048 bytes at offset 1796096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1800192 ++wrote 2048/2048 bytes at offset 1800192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1804288 ++wrote 2048/2048 bytes at offset 1804288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1808384 ++wrote 2048/2048 bytes at offset 1808384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1812480 ++wrote 2048/2048 bytes at offset 1812480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1816576 ++wrote 2048/2048 bytes at offset 1816576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1820672 ++wrote 2048/2048 bytes at offset 1820672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1824768 ++wrote 2048/2048 bytes at offset 1824768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1828864 ++wrote 2048/2048 bytes at offset 1828864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1832960 ++wrote 2048/2048 bytes at offset 1832960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1837056 ++wrote 2048/2048 bytes at offset 1837056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1841152 ++wrote 2048/2048 bytes at offset 1841152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1845248 ++wrote 2048/2048 bytes at offset 1845248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1849344 ++wrote 2048/2048 bytes at offset 1849344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1853440 ++wrote 2048/2048 bytes at offset 1853440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1857536 ++wrote 2048/2048 bytes at offset 1857536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1861632 ++wrote 2048/2048 bytes at offset 1861632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1865728 ++wrote 2048/2048 bytes at offset 1865728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1869824 ++wrote 2048/2048 bytes at offset 1869824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1873920 ++wrote 2048/2048 bytes at offset 1873920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1878016 ++wrote 2048/2048 bytes at offset 1878016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1882112 ++wrote 2048/2048 bytes at offset 1882112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1886208 ++wrote 2048/2048 bytes at offset 1886208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1890304 ++wrote 2048/2048 bytes at offset 1890304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1894400 ++wrote 2048/2048 bytes at offset 1894400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1898496 ++wrote 2048/2048 bytes at offset 1898496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1902592 ++wrote 2048/2048 bytes at offset 1902592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1906688 ++wrote 2048/2048 bytes at offset 1906688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1910784 ++wrote 2048/2048 bytes at offset 1910784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1914880 ++wrote 2048/2048 bytes at offset 1914880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1918976 ++wrote 2048/2048 bytes at offset 1918976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1923072 ++wrote 2048/2048 bytes at offset 1923072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1927168 ++wrote 2048/2048 bytes at offset 1927168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1931264 ++wrote 2048/2048 bytes at offset 1931264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1935360 ++wrote 2048/2048 bytes at offset 1935360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1939456 ++wrote 2048/2048 bytes at offset 1939456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1943552 ++wrote 2048/2048 bytes at offset 1943552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1947648 ++wrote 2048/2048 bytes at offset 1947648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1951744 ++wrote 2048/2048 bytes at offset 1951744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1955840 ++wrote 2048/2048 bytes at offset 1955840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1959936 ++wrote 2048/2048 bytes at offset 1959936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1964032 ++wrote 2048/2048 bytes at offset 1964032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1968128 ++wrote 2048/2048 bytes at offset 1968128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1972224 ++wrote 2048/2048 bytes at offset 1972224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1976320 ++wrote 2048/2048 bytes at offset 1976320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1980416 ++wrote 2048/2048 bytes at offset 1980416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1984512 ++wrote 2048/2048 bytes at offset 1984512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1988608 ++wrote 2048/2048 bytes at offset 1988608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1992704 ++wrote 2048/2048 bytes at offset 1992704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1996800 ++wrote 2048/2048 bytes at offset 1996800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2000896 ++wrote 2048/2048 bytes at offset 2000896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2004992 ++wrote 2048/2048 bytes at offset 2004992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2009088 ++wrote 2048/2048 bytes at offset 2009088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2013184 ++wrote 2048/2048 bytes at offset 2013184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2017280 ++wrote 2048/2048 bytes at offset 2017280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2021376 ++wrote 2048/2048 bytes at offset 2021376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2025472 ++wrote 2048/2048 bytes at offset 2025472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2029568 ++wrote 2048/2048 bytes at offset 2029568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2033664 ++wrote 2048/2048 bytes at offset 2033664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2037760 ++wrote 2048/2048 bytes at offset 2037760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2041856 ++wrote 2048/2048 bytes at offset 2041856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2045952 ++wrote 2048/2048 bytes at offset 2045952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2050048 ++wrote 2048/2048 bytes at offset 2050048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2054144 ++wrote 2048/2048 bytes at offset 2054144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2058240 ++wrote 2048/2048 bytes at offset 2058240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2062336 ++wrote 2048/2048 bytes at offset 2062336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2066432 ++wrote 2048/2048 bytes at offset 2066432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2070528 ++wrote 2048/2048 bytes at offset 2070528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2074624 ++wrote 2048/2048 bytes at offset 2074624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2078720 ++wrote 2048/2048 bytes at offset 2078720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2082816 ++wrote 2048/2048 bytes at offset 2082816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2086912 ++wrote 2048/2048 bytes at offset 2086912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2091008 ++wrote 2048/2048 bytes at offset 2091008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2095104 ++wrote 2048/2048 bytes at offset 2095104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> wrote 2048/2048 bytes at offset 2097152 ++=== IO: pattern 0 ++wrote 2048/2048 bytes at offset 2097152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2101248 ++wrote 2048/2048 bytes at offset 2101248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2105344 ++wrote 2048/2048 bytes at offset 2105344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2109440 ++wrote 2048/2048 bytes at offset 2109440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2113536 ++wrote 2048/2048 bytes at offset 2113536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2117632 ++wrote 2048/2048 bytes at offset 2117632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2121728 ++wrote 2048/2048 bytes at offset 2121728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2125824 ++wrote 2048/2048 bytes at offset 2125824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2129920 ++wrote 2048/2048 bytes at offset 2129920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2134016 ++wrote 2048/2048 bytes at offset 2134016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2138112 ++wrote 2048/2048 bytes at offset 2138112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2142208 ++wrote 2048/2048 bytes at offset 2142208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2146304 ++wrote 2048/2048 bytes at offset 2146304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2150400 ++wrote 2048/2048 bytes at offset 2150400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2154496 ++wrote 2048/2048 bytes at offset 2154496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2158592 ++wrote 2048/2048 bytes at offset 2158592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2162688 ++wrote 2048/2048 bytes at offset 2162688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2166784 ++wrote 2048/2048 bytes at offset 2166784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2170880 ++wrote 2048/2048 bytes at offset 2170880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2174976 ++wrote 2048/2048 bytes at offset 2174976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2179072 ++wrote 2048/2048 bytes at offset 2179072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2183168 ++wrote 2048/2048 bytes at offset 2183168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2187264 ++wrote 2048/2048 bytes at offset 2187264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2191360 ++wrote 2048/2048 bytes at offset 2191360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2195456 ++wrote 2048/2048 bytes at offset 2195456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2199552 ++wrote 2048/2048 bytes at offset 2199552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2203648 ++wrote 2048/2048 bytes at offset 2203648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2207744 ++wrote 2048/2048 bytes at offset 2207744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2211840 ++wrote 2048/2048 bytes at offset 2211840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2215936 ++wrote 2048/2048 bytes at offset 2215936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2220032 ++wrote 2048/2048 bytes at offset 2220032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2224128 ++wrote 2048/2048 bytes at offset 2224128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2228224 ++wrote 2048/2048 bytes at offset 2228224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2232320 ++wrote 2048/2048 bytes at offset 2232320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2236416 ++wrote 2048/2048 bytes at offset 2236416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2240512 ++wrote 2048/2048 bytes at offset 2240512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2244608 ++wrote 2048/2048 bytes at offset 2244608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2248704 ++wrote 2048/2048 bytes at offset 2248704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2252800 ++wrote 2048/2048 bytes at offset 2252800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2256896 ++wrote 2048/2048 bytes at offset 2256896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2260992 ++wrote 2048/2048 bytes at offset 2260992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2265088 ++wrote 2048/2048 bytes at offset 2265088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2269184 ++wrote 2048/2048 bytes at offset 2269184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2273280 ++wrote 2048/2048 bytes at offset 2273280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2277376 ++wrote 2048/2048 bytes at offset 2277376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2281472 ++wrote 2048/2048 bytes at offset 2281472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2285568 ++wrote 2048/2048 bytes at offset 2285568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2289664 ++wrote 2048/2048 bytes at offset 2289664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2293760 ++wrote 2048/2048 bytes at offset 2293760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2297856 ++wrote 2048/2048 bytes at offset 2297856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2301952 ++wrote 2048/2048 bytes at offset 2301952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2306048 ++wrote 2048/2048 bytes at offset 2306048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2310144 ++wrote 2048/2048 bytes at offset 2310144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2314240 ++wrote 2048/2048 bytes at offset 2314240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2318336 ++wrote 2048/2048 bytes at offset 2318336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2322432 ++wrote 2048/2048 bytes at offset 2322432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2326528 ++wrote 2048/2048 bytes at offset 2326528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2330624 ++wrote 2048/2048 bytes at offset 2330624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2334720 ++wrote 2048/2048 bytes at offset 2334720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2338816 ++wrote 2048/2048 bytes at offset 2338816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2342912 ++wrote 2048/2048 bytes at offset 2342912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2347008 ++wrote 2048/2048 bytes at offset 2347008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2351104 ++wrote 2048/2048 bytes at offset 2351104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2355200 ++wrote 2048/2048 bytes at offset 2355200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2359296 ++wrote 2048/2048 bytes at offset 2359296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2363392 ++wrote 2048/2048 bytes at offset 2363392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2367488 ++wrote 2048/2048 bytes at offset 2367488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2371584 ++wrote 2048/2048 bytes at offset 2371584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2375680 ++wrote 2048/2048 bytes at offset 2375680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2379776 ++wrote 2048/2048 bytes at offset 2379776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2383872 ++wrote 2048/2048 bytes at offset 2383872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2387968 ++wrote 2048/2048 bytes at offset 2387968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2392064 ++wrote 2048/2048 bytes at offset 2392064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2396160 ++wrote 2048/2048 bytes at offset 2396160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2400256 ++wrote 2048/2048 bytes at offset 2400256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2404352 ++wrote 2048/2048 bytes at offset 2404352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2408448 ++wrote 2048/2048 bytes at offset 2408448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2412544 ++wrote 2048/2048 bytes at offset 2412544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2416640 ++wrote 2048/2048 bytes at offset 2416640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2420736 ++wrote 2048/2048 bytes at offset 2420736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2424832 ++wrote 2048/2048 bytes at offset 2424832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2428928 ++wrote 2048/2048 bytes at offset 2428928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2433024 ++wrote 2048/2048 bytes at offset 2433024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2437120 ++wrote 2048/2048 bytes at offset 2437120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2441216 ++wrote 2048/2048 bytes at offset 2441216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2445312 ++wrote 2048/2048 bytes at offset 2445312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2449408 ++wrote 2048/2048 bytes at offset 2449408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2453504 ++wrote 2048/2048 bytes at offset 2453504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2457600 ++wrote 2048/2048 bytes at offset 2457600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2461696 ++wrote 2048/2048 bytes at offset 2461696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2465792 ++wrote 2048/2048 bytes at offset 2465792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2469888 ++wrote 2048/2048 bytes at offset 2469888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2473984 ++wrote 2048/2048 bytes at offset 2473984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2478080 ++wrote 2048/2048 bytes at offset 2478080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2482176 ++wrote 2048/2048 bytes at offset 2482176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2486272 ++wrote 2048/2048 bytes at offset 2486272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2490368 ++wrote 2048/2048 bytes at offset 2490368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2494464 ++wrote 2048/2048 bytes at offset 2494464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2498560 ++wrote 2048/2048 bytes at offset 2498560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2502656 ++wrote 2048/2048 bytes at offset 2502656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2506752 ++wrote 2048/2048 bytes at offset 2506752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2510848 ++wrote 2048/2048 bytes at offset 2510848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2514944 ++wrote 2048/2048 bytes at offset 2514944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2519040 ++wrote 2048/2048 bytes at offset 2519040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2523136 ++wrote 2048/2048 bytes at offset 2523136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2527232 ++wrote 2048/2048 bytes at offset 2527232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2531328 ++wrote 2048/2048 bytes at offset 2531328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2535424 ++wrote 2048/2048 bytes at offset 2535424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2539520 ++wrote 2048/2048 bytes at offset 2539520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2543616 ++wrote 2048/2048 bytes at offset 2543616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2547712 ++wrote 2048/2048 bytes at offset 2547712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2551808 ++wrote 2048/2048 bytes at offset 2551808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2555904 ++wrote 2048/2048 bytes at offset 2555904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2560000 ++wrote 2048/2048 bytes at offset 2560000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2564096 ++wrote 2048/2048 bytes at offset 2564096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2568192 ++wrote 2048/2048 bytes at offset 2568192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2572288 ++wrote 2048/2048 bytes at offset 2572288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2576384 ++wrote 2048/2048 bytes at offset 2576384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2580480 ++wrote 2048/2048 bytes at offset 2580480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2584576 ++wrote 2048/2048 bytes at offset 2584576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2588672 ++wrote 2048/2048 bytes at offset 2588672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2592768 ++wrote 2048/2048 bytes at offset 2592768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2596864 ++wrote 2048/2048 bytes at offset 2596864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2600960 ++wrote 2048/2048 bytes at offset 2600960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2605056 ++wrote 2048/2048 bytes at offset 2605056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2609152 ++wrote 2048/2048 bytes at offset 2609152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2613248 ++wrote 2048/2048 bytes at offset 2613248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2617344 ++wrote 2048/2048 bytes at offset 2617344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2621440 ++wrote 2048/2048 bytes at offset 2621440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2625536 ++wrote 2048/2048 bytes at offset 2625536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2629632 ++wrote 2048/2048 bytes at offset 2629632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2633728 ++wrote 2048/2048 bytes at offset 2633728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2637824 ++wrote 2048/2048 bytes at offset 2637824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2641920 ++wrote 2048/2048 bytes at offset 2641920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2646016 ++wrote 2048/2048 bytes at offset 2646016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2650112 ++wrote 2048/2048 bytes at offset 2650112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2654208 ++wrote 2048/2048 bytes at offset 2654208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2658304 ++wrote 2048/2048 bytes at offset 2658304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2662400 ++wrote 2048/2048 bytes at offset 2662400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2666496 ++wrote 2048/2048 bytes at offset 2666496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2670592 ++wrote 2048/2048 bytes at offset 2670592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2674688 ++wrote 2048/2048 bytes at offset 2674688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2678784 ++wrote 2048/2048 bytes at offset 2678784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2682880 ++wrote 2048/2048 bytes at offset 2682880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2686976 ++wrote 2048/2048 bytes at offset 2686976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2691072 ++wrote 2048/2048 bytes at offset 2691072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2695168 ++wrote 2048/2048 bytes at offset 2695168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2699264 ++wrote 2048/2048 bytes at offset 2699264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2703360 ++wrote 2048/2048 bytes at offset 2703360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2707456 ++wrote 2048/2048 bytes at offset 2707456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2711552 ++wrote 2048/2048 bytes at offset 2711552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2715648 ++wrote 2048/2048 bytes at offset 2715648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2719744 ++wrote 2048/2048 bytes at offset 2719744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2723840 ++wrote 2048/2048 bytes at offset 2723840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2727936 ++wrote 2048/2048 bytes at offset 2727936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2732032 ++wrote 2048/2048 bytes at offset 2732032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2736128 ++wrote 2048/2048 bytes at offset 2736128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2740224 ++wrote 2048/2048 bytes at offset 2740224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2744320 ++wrote 2048/2048 bytes at offset 2744320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2748416 ++wrote 2048/2048 bytes at offset 2748416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2752512 ++wrote 2048/2048 bytes at offset 2752512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2756608 ++wrote 2048/2048 bytes at offset 2756608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2760704 ++wrote 2048/2048 bytes at offset 2760704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2764800 ++wrote 2048/2048 bytes at offset 2764800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2768896 ++wrote 2048/2048 bytes at offset 2768896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2772992 ++wrote 2048/2048 bytes at offset 2772992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2777088 ++wrote 2048/2048 bytes at offset 2777088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2781184 ++wrote 2048/2048 bytes at offset 2781184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2785280 ++wrote 2048/2048 bytes at offset 2785280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2789376 ++wrote 2048/2048 bytes at offset 2789376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2793472 ++wrote 2048/2048 bytes at offset 2793472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2797568 ++wrote 2048/2048 bytes at offset 2797568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2801664 ++wrote 2048/2048 bytes at offset 2801664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2805760 ++wrote 2048/2048 bytes at offset 2805760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2809856 ++wrote 2048/2048 bytes at offset 2809856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2813952 ++wrote 2048/2048 bytes at offset 2813952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2818048 ++wrote 2048/2048 bytes at offset 2818048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2822144 ++wrote 2048/2048 bytes at offset 2822144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2826240 ++wrote 2048/2048 bytes at offset 2826240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2830336 ++wrote 2048/2048 bytes at offset 2830336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2834432 ++wrote 2048/2048 bytes at offset 2834432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2838528 ++wrote 2048/2048 bytes at offset 2838528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2842624 ++wrote 2048/2048 bytes at offset 2842624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2846720 ++wrote 2048/2048 bytes at offset 2846720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2850816 ++wrote 2048/2048 bytes at offset 2850816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2854912 ++wrote 2048/2048 bytes at offset 2854912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2859008 ++wrote 2048/2048 bytes at offset 2859008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2863104 ++wrote 2048/2048 bytes at offset 2863104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2867200 ++wrote 2048/2048 bytes at offset 2867200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2871296 ++wrote 2048/2048 bytes at offset 2871296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2875392 ++wrote 2048/2048 bytes at offset 2875392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2879488 ++wrote 2048/2048 bytes at offset 2879488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2883584 ++wrote 2048/2048 bytes at offset 2883584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2887680 ++wrote 2048/2048 bytes at offset 2887680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2891776 ++wrote 2048/2048 bytes at offset 2891776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2895872 ++wrote 2048/2048 bytes at offset 2895872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2899968 ++wrote 2048/2048 bytes at offset 2899968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2904064 ++wrote 2048/2048 bytes at offset 2904064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2908160 ++wrote 2048/2048 bytes at offset 2908160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2912256 ++wrote 2048/2048 bytes at offset 2912256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2916352 ++wrote 2048/2048 bytes at offset 2916352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2920448 ++wrote 2048/2048 bytes at offset 2920448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2924544 ++wrote 2048/2048 bytes at offset 2924544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2928640 ++wrote 2048/2048 bytes at offset 2928640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2932736 ++wrote 2048/2048 bytes at offset 2932736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2936832 ++wrote 2048/2048 bytes at offset 2936832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2940928 ++wrote 2048/2048 bytes at offset 2940928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2945024 ++wrote 2048/2048 bytes at offset 2945024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2949120 ++wrote 2048/2048 bytes at offset 2949120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2953216 ++wrote 2048/2048 bytes at offset 2953216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2957312 ++wrote 2048/2048 bytes at offset 2957312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2961408 ++wrote 2048/2048 bytes at offset 2961408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2965504 ++wrote 2048/2048 bytes at offset 2965504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2969600 ++wrote 2048/2048 bytes at offset 2969600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2973696 ++wrote 2048/2048 bytes at offset 2973696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2977792 ++wrote 2048/2048 bytes at offset 2977792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2981888 ++wrote 2048/2048 bytes at offset 2981888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2985984 ++wrote 2048/2048 bytes at offset 2985984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2990080 ++wrote 2048/2048 bytes at offset 2990080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2994176 ++wrote 2048/2048 bytes at offset 2994176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2998272 ++wrote 2048/2048 bytes at offset 2998272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3002368 ++wrote 2048/2048 bytes at offset 3002368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3006464 ++wrote 2048/2048 bytes at offset 3006464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3010560 ++wrote 2048/2048 bytes at offset 3010560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3014656 ++wrote 2048/2048 bytes at offset 3014656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3018752 ++wrote 2048/2048 bytes at offset 3018752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3022848 ++wrote 2048/2048 bytes at offset 3022848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3026944 ++wrote 2048/2048 bytes at offset 3026944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3031040 ++wrote 2048/2048 bytes at offset 3031040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3035136 ++wrote 2048/2048 bytes at offset 3035136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3039232 ++wrote 2048/2048 bytes at offset 3039232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3043328 ++wrote 2048/2048 bytes at offset 3043328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3047424 ++wrote 2048/2048 bytes at offset 3047424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3051520 ++wrote 2048/2048 bytes at offset 3051520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3055616 ++wrote 2048/2048 bytes at offset 3055616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3059712 ++wrote 2048/2048 bytes at offset 3059712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3063808 ++wrote 2048/2048 bytes at offset 3063808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3067904 ++wrote 2048/2048 bytes at offset 3067904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3072000 ++wrote 2048/2048 bytes at offset 3072000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3076096 ++wrote 2048/2048 bytes at offset 3076096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3080192 ++wrote 2048/2048 bytes at offset 3080192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3084288 ++wrote 2048/2048 bytes at offset 3084288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3088384 ++wrote 2048/2048 bytes at offset 3088384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3092480 ++wrote 2048/2048 bytes at offset 3092480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3096576 ++wrote 2048/2048 bytes at offset 3096576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3100672 ++wrote 2048/2048 bytes at offset 3100672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3104768 ++wrote 2048/2048 bytes at offset 3104768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3108864 ++wrote 2048/2048 bytes at offset 3108864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3112960 ++wrote 2048/2048 bytes at offset 3112960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3117056 ++wrote 2048/2048 bytes at offset 3117056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3121152 ++wrote 2048/2048 bytes at offset 3121152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3125248 ++wrote 2048/2048 bytes at offset 3125248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3129344 ++wrote 2048/2048 bytes at offset 3129344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3133440 ++wrote 2048/2048 bytes at offset 3133440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3137536 ++wrote 2048/2048 bytes at offset 3137536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3141632 ++wrote 2048/2048 bytes at offset 3141632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 2 +-qemu-io> wrote 2048/2048 bytes at offset 3146752 ++=== IO: pattern 2 ++wrote 2048/2048 bytes at offset 3146752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3150848 ++wrote 2048/2048 bytes at offset 3150848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3154944 ++wrote 2048/2048 bytes at offset 3154944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3159040 ++wrote 2048/2048 bytes at offset 3159040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3163136 ++wrote 2048/2048 bytes at offset 3163136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3167232 ++wrote 2048/2048 bytes at offset 3167232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3171328 ++wrote 2048/2048 bytes at offset 3171328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3175424 ++wrote 2048/2048 bytes at offset 3175424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3179520 ++wrote 2048/2048 bytes at offset 3179520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3183616 ++wrote 2048/2048 bytes at offset 3183616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3187712 ++wrote 2048/2048 bytes at offset 3187712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3191808 ++wrote 2048/2048 bytes at offset 3191808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3195904 ++wrote 2048/2048 bytes at offset 3195904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3200000 ++wrote 2048/2048 bytes at offset 3200000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3204096 ++wrote 2048/2048 bytes at offset 3204096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3208192 ++wrote 2048/2048 bytes at offset 3208192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3212288 ++wrote 2048/2048 bytes at offset 3212288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3216384 ++wrote 2048/2048 bytes at offset 3216384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3220480 ++wrote 2048/2048 bytes at offset 3220480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3224576 ++wrote 2048/2048 bytes at offset 3224576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3228672 ++wrote 2048/2048 bytes at offset 3228672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3232768 ++wrote 2048/2048 bytes at offset 3232768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3236864 ++wrote 2048/2048 bytes at offset 3236864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3240960 ++wrote 2048/2048 bytes at offset 3240960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3245056 ++wrote 2048/2048 bytes at offset 3245056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3249152 ++wrote 2048/2048 bytes at offset 3249152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3253248 ++wrote 2048/2048 bytes at offset 3253248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3257344 ++wrote 2048/2048 bytes at offset 3257344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3261440 ++wrote 2048/2048 bytes at offset 3261440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3265536 ++wrote 2048/2048 bytes at offset 3265536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3269632 ++wrote 2048/2048 bytes at offset 3269632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3273728 ++wrote 2048/2048 bytes at offset 3273728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3277824 ++wrote 2048/2048 bytes at offset 3277824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3281920 ++wrote 2048/2048 bytes at offset 3281920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3286016 ++wrote 2048/2048 bytes at offset 3286016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3290112 ++wrote 2048/2048 bytes at offset 3290112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3294208 ++wrote 2048/2048 bytes at offset 3294208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3298304 ++wrote 2048/2048 bytes at offset 3298304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3302400 ++wrote 2048/2048 bytes at offset 3302400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3306496 ++wrote 2048/2048 bytes at offset 3306496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3310592 ++wrote 2048/2048 bytes at offset 3310592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3314688 ++wrote 2048/2048 bytes at offset 3314688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3318784 ++wrote 2048/2048 bytes at offset 3318784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3322880 ++wrote 2048/2048 bytes at offset 3322880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3326976 ++wrote 2048/2048 bytes at offset 3326976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3331072 ++wrote 2048/2048 bytes at offset 3331072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3335168 ++wrote 2048/2048 bytes at offset 3335168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3339264 ++wrote 2048/2048 bytes at offset 3339264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3343360 ++wrote 2048/2048 bytes at offset 3343360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3347456 ++wrote 2048/2048 bytes at offset 3347456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3351552 ++wrote 2048/2048 bytes at offset 3351552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3355648 ++wrote 2048/2048 bytes at offset 3355648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3359744 ++wrote 2048/2048 bytes at offset 3359744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3363840 ++wrote 2048/2048 bytes at offset 3363840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3367936 ++wrote 2048/2048 bytes at offset 3367936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3372032 ++wrote 2048/2048 bytes at offset 3372032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3376128 ++wrote 2048/2048 bytes at offset 3376128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3380224 ++wrote 2048/2048 bytes at offset 3380224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3384320 ++wrote 2048/2048 bytes at offset 3384320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3388416 ++wrote 2048/2048 bytes at offset 3388416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3392512 ++wrote 2048/2048 bytes at offset 3392512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3396608 ++wrote 2048/2048 bytes at offset 3396608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3400704 ++wrote 2048/2048 bytes at offset 3400704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3404800 ++wrote 2048/2048 bytes at offset 3404800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3408896 ++wrote 2048/2048 bytes at offset 3408896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3412992 ++wrote 2048/2048 bytes at offset 3412992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3417088 ++wrote 2048/2048 bytes at offset 3417088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3421184 ++wrote 2048/2048 bytes at offset 3421184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3425280 ++wrote 2048/2048 bytes at offset 3425280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3429376 ++wrote 2048/2048 bytes at offset 3429376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3433472 ++wrote 2048/2048 bytes at offset 3433472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3437568 ++wrote 2048/2048 bytes at offset 3437568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3441664 ++wrote 2048/2048 bytes at offset 3441664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3445760 ++wrote 2048/2048 bytes at offset 3445760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3449856 ++wrote 2048/2048 bytes at offset 3449856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3453952 ++wrote 2048/2048 bytes at offset 3453952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3458048 ++wrote 2048/2048 bytes at offset 3458048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3462144 ++wrote 2048/2048 bytes at offset 3462144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3466240 ++wrote 2048/2048 bytes at offset 3466240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3470336 ++wrote 2048/2048 bytes at offset 3470336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3474432 ++wrote 2048/2048 bytes at offset 3474432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3478528 ++wrote 2048/2048 bytes at offset 3478528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3482624 ++wrote 2048/2048 bytes at offset 3482624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3486720 ++wrote 2048/2048 bytes at offset 3486720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3490816 ++wrote 2048/2048 bytes at offset 3490816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3494912 ++wrote 2048/2048 bytes at offset 3494912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3499008 ++wrote 2048/2048 bytes at offset 3499008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3503104 ++wrote 2048/2048 bytes at offset 3503104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3507200 ++wrote 2048/2048 bytes at offset 3507200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3511296 ++wrote 2048/2048 bytes at offset 3511296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3515392 ++wrote 2048/2048 bytes at offset 3515392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3519488 ++wrote 2048/2048 bytes at offset 3519488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3523584 ++wrote 2048/2048 bytes at offset 3523584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3527680 ++wrote 2048/2048 bytes at offset 3527680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3531776 ++wrote 2048/2048 bytes at offset 3531776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3535872 ++wrote 2048/2048 bytes at offset 3535872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3539968 ++wrote 2048/2048 bytes at offset 3539968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3544064 ++wrote 2048/2048 bytes at offset 3544064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3548160 ++wrote 2048/2048 bytes at offset 3548160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3552256 ++wrote 2048/2048 bytes at offset 3552256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3556352 ++wrote 2048/2048 bytes at offset 3556352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3560448 ++wrote 2048/2048 bytes at offset 3560448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3564544 ++wrote 2048/2048 bytes at offset 3564544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3568640 ++wrote 2048/2048 bytes at offset 3568640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3572736 ++wrote 2048/2048 bytes at offset 3572736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3576832 ++wrote 2048/2048 bytes at offset 3576832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3580928 ++wrote 2048/2048 bytes at offset 3580928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3585024 ++wrote 2048/2048 bytes at offset 3585024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3589120 ++wrote 2048/2048 bytes at offset 3589120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3593216 ++wrote 2048/2048 bytes at offset 3593216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3597312 ++wrote 2048/2048 bytes at offset 3597312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3601408 ++wrote 2048/2048 bytes at offset 3601408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3605504 ++wrote 2048/2048 bytes at offset 3605504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3609600 ++wrote 2048/2048 bytes at offset 3609600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3613696 ++wrote 2048/2048 bytes at offset 3613696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3617792 ++wrote 2048/2048 bytes at offset 3617792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3621888 ++wrote 2048/2048 bytes at offset 3621888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3625984 ++wrote 2048/2048 bytes at offset 3625984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3630080 ++wrote 2048/2048 bytes at offset 3630080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3634176 ++wrote 2048/2048 bytes at offset 3634176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3638272 ++wrote 2048/2048 bytes at offset 3638272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3642368 ++wrote 2048/2048 bytes at offset 3642368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3646464 ++wrote 2048/2048 bytes at offset 3646464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3650560 ++wrote 2048/2048 bytes at offset 3650560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3654656 ++wrote 2048/2048 bytes at offset 3654656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3658752 ++wrote 2048/2048 bytes at offset 3658752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3662848 ++wrote 2048/2048 bytes at offset 3662848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3666944 ++wrote 2048/2048 bytes at offset 3666944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3671040 ++wrote 2048/2048 bytes at offset 3671040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3675136 ++wrote 2048/2048 bytes at offset 3675136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3679232 ++wrote 2048/2048 bytes at offset 3679232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3683328 ++wrote 2048/2048 bytes at offset 3683328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3687424 ++wrote 2048/2048 bytes at offset 3687424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3691520 ++wrote 2048/2048 bytes at offset 3691520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3695616 ++wrote 2048/2048 bytes at offset 3695616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3699712 ++wrote 2048/2048 bytes at offset 3699712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3703808 ++wrote 2048/2048 bytes at offset 3703808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3707904 ++wrote 2048/2048 bytes at offset 3707904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3712000 ++wrote 2048/2048 bytes at offset 3712000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3716096 ++wrote 2048/2048 bytes at offset 3716096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3720192 ++wrote 2048/2048 bytes at offset 3720192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3724288 ++wrote 2048/2048 bytes at offset 3724288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3728384 ++wrote 2048/2048 bytes at offset 3728384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3732480 ++wrote 2048/2048 bytes at offset 3732480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3736576 ++wrote 2048/2048 bytes at offset 3736576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3740672 ++wrote 2048/2048 bytes at offset 3740672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3744768 ++wrote 2048/2048 bytes at offset 3744768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3748864 ++wrote 2048/2048 bytes at offset 3748864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3752960 ++wrote 2048/2048 bytes at offset 3752960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3757056 ++wrote 2048/2048 bytes at offset 3757056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3761152 ++wrote 2048/2048 bytes at offset 3761152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3765248 ++wrote 2048/2048 bytes at offset 3765248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3769344 ++wrote 2048/2048 bytes at offset 3769344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3773440 ++wrote 2048/2048 bytes at offset 3773440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3777536 ++wrote 2048/2048 bytes at offset 3777536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3781632 ++wrote 2048/2048 bytes at offset 3781632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3785728 ++wrote 2048/2048 bytes at offset 3785728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3789824 ++wrote 2048/2048 bytes at offset 3789824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3793920 ++wrote 2048/2048 bytes at offset 3793920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3798016 ++wrote 2048/2048 bytes at offset 3798016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3802112 ++wrote 2048/2048 bytes at offset 3802112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3806208 ++wrote 2048/2048 bytes at offset 3806208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3810304 ++wrote 2048/2048 bytes at offset 3810304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3814400 ++wrote 2048/2048 bytes at offset 3814400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3818496 ++wrote 2048/2048 bytes at offset 3818496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3822592 ++wrote 2048/2048 bytes at offset 3822592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3826688 ++wrote 2048/2048 bytes at offset 3826688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3830784 ++wrote 2048/2048 bytes at offset 3830784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3834880 ++wrote 2048/2048 bytes at offset 3834880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3838976 ++wrote 2048/2048 bytes at offset 3838976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3843072 ++wrote 2048/2048 bytes at offset 3843072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3847168 ++wrote 2048/2048 bytes at offset 3847168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3851264 ++wrote 2048/2048 bytes at offset 3851264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3855360 ++wrote 2048/2048 bytes at offset 3855360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3859456 ++wrote 2048/2048 bytes at offset 3859456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3863552 ++wrote 2048/2048 bytes at offset 3863552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3867648 ++wrote 2048/2048 bytes at offset 3867648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3871744 ++wrote 2048/2048 bytes at offset 3871744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3875840 ++wrote 2048/2048 bytes at offset 3875840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3879936 ++wrote 2048/2048 bytes at offset 3879936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3884032 ++wrote 2048/2048 bytes at offset 3884032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3888128 ++wrote 2048/2048 bytes at offset 3888128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3892224 ++wrote 2048/2048 bytes at offset 3892224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3896320 ++wrote 2048/2048 bytes at offset 3896320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3900416 ++wrote 2048/2048 bytes at offset 3900416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3904512 ++wrote 2048/2048 bytes at offset 3904512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3908608 ++wrote 2048/2048 bytes at offset 3908608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3912704 ++wrote 2048/2048 bytes at offset 3912704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3916800 ++wrote 2048/2048 bytes at offset 3916800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3920896 ++wrote 2048/2048 bytes at offset 3920896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3924992 ++wrote 2048/2048 bytes at offset 3924992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3929088 ++wrote 2048/2048 bytes at offset 3929088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3933184 ++wrote 2048/2048 bytes at offset 3933184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3937280 ++wrote 2048/2048 bytes at offset 3937280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3941376 ++wrote 2048/2048 bytes at offset 3941376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3945472 ++wrote 2048/2048 bytes at offset 3945472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3949568 ++wrote 2048/2048 bytes at offset 3949568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3953664 ++wrote 2048/2048 bytes at offset 3953664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3957760 ++wrote 2048/2048 bytes at offset 3957760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3961856 ++wrote 2048/2048 bytes at offset 3961856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3965952 ++wrote 2048/2048 bytes at offset 3965952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3970048 ++wrote 2048/2048 bytes at offset 3970048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3974144 ++wrote 2048/2048 bytes at offset 3974144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3978240 ++wrote 2048/2048 bytes at offset 3978240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3982336 ++wrote 2048/2048 bytes at offset 3982336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3986432 ++wrote 2048/2048 bytes at offset 3986432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3990528 ++wrote 2048/2048 bytes at offset 3990528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3994624 ++wrote 2048/2048 bytes at offset 3994624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3998720 ++wrote 2048/2048 bytes at offset 3998720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4002816 ++wrote 2048/2048 bytes at offset 4002816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4006912 ++wrote 2048/2048 bytes at offset 4006912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4011008 ++wrote 2048/2048 bytes at offset 4011008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4015104 ++wrote 2048/2048 bytes at offset 4015104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4019200 ++wrote 2048/2048 bytes at offset 4019200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4023296 ++wrote 2048/2048 bytes at offset 4023296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4027392 ++wrote 2048/2048 bytes at offset 4027392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4031488 ++wrote 2048/2048 bytes at offset 4031488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4035584 ++wrote 2048/2048 bytes at offset 4035584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4039680 ++wrote 2048/2048 bytes at offset 4039680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4043776 ++wrote 2048/2048 bytes at offset 4043776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4047872 ++wrote 2048/2048 bytes at offset 4047872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4051968 ++wrote 2048/2048 bytes at offset 4051968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4056064 ++wrote 2048/2048 bytes at offset 4056064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4060160 ++wrote 2048/2048 bytes at offset 4060160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4064256 ++wrote 2048/2048 bytes at offset 4064256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4068352 ++wrote 2048/2048 bytes at offset 4068352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4072448 ++wrote 2048/2048 bytes at offset 4072448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4076544 ++wrote 2048/2048 bytes at offset 4076544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4080640 ++wrote 2048/2048 bytes at offset 4080640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4084736 ++wrote 2048/2048 bytes at offset 4084736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4088832 ++wrote 2048/2048 bytes at offset 4088832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4092928 ++wrote 2048/2048 bytes at offset 4092928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4097024 ++wrote 2048/2048 bytes at offset 4097024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4101120 ++wrote 2048/2048 bytes at offset 4101120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4105216 ++wrote 2048/2048 bytes at offset 4105216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4109312 ++wrote 2048/2048 bytes at offset 4109312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4113408 ++wrote 2048/2048 bytes at offset 4113408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4117504 ++wrote 2048/2048 bytes at offset 4117504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4121600 ++wrote 2048/2048 bytes at offset 4121600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4125696 ++wrote 2048/2048 bytes at offset 4125696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4129792 ++wrote 2048/2048 bytes at offset 4129792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4133888 ++wrote 2048/2048 bytes at offset 4133888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4137984 ++wrote 2048/2048 bytes at offset 4137984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4142080 ++wrote 2048/2048 bytes at offset 4142080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4146176 ++wrote 2048/2048 bytes at offset 4146176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4150272 ++wrote 2048/2048 bytes at offset 4150272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4154368 ++wrote 2048/2048 bytes at offset 4154368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4158464 ++wrote 2048/2048 bytes at offset 4158464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4162560 ++wrote 2048/2048 bytes at offset 4162560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4166656 ++wrote 2048/2048 bytes at offset 4166656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4170752 ++wrote 2048/2048 bytes at offset 4170752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4174848 ++wrote 2048/2048 bytes at offset 4174848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4178944 ++wrote 2048/2048 bytes at offset 4178944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4183040 ++wrote 2048/2048 bytes at offset 4183040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4187136 ++wrote 2048/2048 bytes at offset 4187136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4191232 ++wrote 2048/2048 bytes at offset 4191232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 4 +-qemu-io> wrote 8192/8192 bytes at offset 4196352 ++=== IO: pattern 4 ++wrote 8192/8192 bytes at offset 4196352 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4208640 ++wrote 8192/8192 bytes at offset 4208640 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4220928 ++wrote 8192/8192 bytes at offset 4220928 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4233216 ++wrote 8192/8192 bytes at offset 4233216 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4245504 ++wrote 8192/8192 bytes at offset 4245504 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4257792 ++wrote 8192/8192 bytes at offset 4257792 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4270080 ++wrote 8192/8192 bytes at offset 4270080 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4282368 ++wrote 8192/8192 bytes at offset 4282368 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4294656 ++wrote 8192/8192 bytes at offset 4294656 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4306944 ++wrote 8192/8192 bytes at offset 4306944 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4319232 ++wrote 8192/8192 bytes at offset 4319232 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4331520 ++wrote 8192/8192 bytes at offset 4331520 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4343808 ++wrote 8192/8192 bytes at offset 4343808 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4356096 ++wrote 8192/8192 bytes at offset 4356096 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4368384 ++wrote 8192/8192 bytes at offset 4368384 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4380672 ++wrote 8192/8192 bytes at offset 4380672 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4392960 ++wrote 8192/8192 bytes at offset 4392960 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4405248 ++wrote 8192/8192 bytes at offset 4405248 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4417536 ++wrote 8192/8192 bytes at offset 4417536 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4429824 ++wrote 8192/8192 bytes at offset 4429824 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4442112 ++wrote 8192/8192 bytes at offset 4442112 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4454400 ++wrote 8192/8192 bytes at offset 4454400 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4466688 ++wrote 8192/8192 bytes at offset 4466688 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4478976 ++wrote 8192/8192 bytes at offset 4478976 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4491264 ++wrote 8192/8192 bytes at offset 4491264 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4503552 ++wrote 8192/8192 bytes at offset 4503552 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4515840 ++wrote 8192/8192 bytes at offset 4515840 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4528128 ++wrote 8192/8192 bytes at offset 4528128 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4540416 ++wrote 8192/8192 bytes at offset 4540416 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4552704 ++wrote 8192/8192 bytes at offset 4552704 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4564992 ++wrote 8192/8192 bytes at offset 4564992 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4577280 ++wrote 8192/8192 bytes at offset 4577280 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4589568 ++wrote 8192/8192 bytes at offset 4589568 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4601856 ++wrote 8192/8192 bytes at offset 4601856 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4614144 ++wrote 8192/8192 bytes at offset 4614144 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4626432 ++wrote 8192/8192 bytes at offset 4626432 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4638720 ++wrote 8192/8192 bytes at offset 4638720 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4651008 ++wrote 8192/8192 bytes at offset 4651008 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4663296 ++wrote 8192/8192 bytes at offset 4663296 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4675584 ++wrote 8192/8192 bytes at offset 4675584 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4687872 ++wrote 8192/8192 bytes at offset 4687872 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4700160 ++wrote 8192/8192 bytes at offset 4700160 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4712448 ++wrote 8192/8192 bytes at offset 4712448 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4724736 ++wrote 8192/8192 bytes at offset 4724736 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4737024 ++wrote 8192/8192 bytes at offset 4737024 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4749312 ++wrote 8192/8192 bytes at offset 4749312 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4761600 ++wrote 8192/8192 bytes at offset 4761600 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4773888 ++wrote 8192/8192 bytes at offset 4773888 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4786176 ++wrote 8192/8192 bytes at offset 4786176 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4798464 ++wrote 8192/8192 bytes at offset 4798464 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4810752 ++wrote 8192/8192 bytes at offset 4810752 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4823040 ++wrote 8192/8192 bytes at offset 4823040 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4835328 ++wrote 8192/8192 bytes at offset 4835328 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4847616 ++wrote 8192/8192 bytes at offset 4847616 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4859904 ++wrote 8192/8192 bytes at offset 4859904 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4872192 ++wrote 8192/8192 bytes at offset 4872192 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4884480 ++wrote 8192/8192 bytes at offset 4884480 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4896768 ++wrote 8192/8192 bytes at offset 4896768 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4909056 ++wrote 8192/8192 bytes at offset 4909056 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4921344 ++wrote 8192/8192 bytes at offset 4921344 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4933632 ++wrote 8192/8192 bytes at offset 4933632 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4945920 ++wrote 8192/8192 bytes at offset 4945920 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4958208 ++wrote 8192/8192 bytes at offset 4958208 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4970496 ++wrote 8192/8192 bytes at offset 4970496 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 244 +-qemu-io> wrote 12288/12288 bytes at offset 6285312 ++=== IO: pattern 244 ++wrote 12288/12288 bytes at offset 6285312 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 8384512 ++wrote 12288/12288 bytes at offset 8384512 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 10483712 ++wrote 12288/12288 bytes at offset 10483712 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 12582912 ++wrote 12288/12288 bytes at offset 12582912 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 14682112 ++wrote 12288/12288 bytes at offset 14682112 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 16781312 ++wrote 12288/12288 bytes at offset 16781312 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 18880512 ++wrote 12288/12288 bytes at offset 18880512 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 20979712 ++wrote 12288/12288 bytes at offset 20979712 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> read 4096/4096 bytes at offset 0 ++=== IO: pattern 0 ++read 4096/4096 bytes at offset 0 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4096 ++read 4096/4096 bytes at offset 4096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 8192 ++read 4096/4096 bytes at offset 8192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 12288 ++read 4096/4096 bytes at offset 12288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 16384 ++read 4096/4096 bytes at offset 16384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 20480 ++read 4096/4096 bytes at offset 20480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 24576 ++read 4096/4096 bytes at offset 24576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 28672 ++read 4096/4096 bytes at offset 28672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 32768 ++read 4096/4096 bytes at offset 32768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 36864 ++read 4096/4096 bytes at offset 36864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 40960 ++read 4096/4096 bytes at offset 40960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 45056 ++read 4096/4096 bytes at offset 45056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 49152 ++read 4096/4096 bytes at offset 49152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 53248 ++read 4096/4096 bytes at offset 53248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 57344 ++read 4096/4096 bytes at offset 57344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 61440 ++read 4096/4096 bytes at offset 61440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 65536 ++read 4096/4096 bytes at offset 65536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 69632 ++read 4096/4096 bytes at offset 69632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 73728 ++read 4096/4096 bytes at offset 73728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 77824 ++read 4096/4096 bytes at offset 77824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 81920 ++read 4096/4096 bytes at offset 81920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 86016 ++read 4096/4096 bytes at offset 86016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 90112 ++read 4096/4096 bytes at offset 90112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 94208 ++read 4096/4096 bytes at offset 94208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 98304 ++read 4096/4096 bytes at offset 98304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 102400 ++read 4096/4096 bytes at offset 102400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 106496 ++read 4096/4096 bytes at offset 106496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 110592 ++read 4096/4096 bytes at offset 110592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 114688 ++read 4096/4096 bytes at offset 114688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 118784 ++read 4096/4096 bytes at offset 118784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 122880 ++read 4096/4096 bytes at offset 122880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 126976 ++read 4096/4096 bytes at offset 126976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 131072 ++read 4096/4096 bytes at offset 131072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 135168 ++read 4096/4096 bytes at offset 135168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 139264 ++read 4096/4096 bytes at offset 139264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 143360 ++read 4096/4096 bytes at offset 143360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 147456 ++read 4096/4096 bytes at offset 147456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 151552 ++read 4096/4096 bytes at offset 151552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 155648 ++read 4096/4096 bytes at offset 155648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 159744 ++read 4096/4096 bytes at offset 159744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 163840 ++read 4096/4096 bytes at offset 163840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 167936 ++read 4096/4096 bytes at offset 167936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 172032 ++read 4096/4096 bytes at offset 172032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 176128 ++read 4096/4096 bytes at offset 176128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 180224 ++read 4096/4096 bytes at offset 180224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 184320 ++read 4096/4096 bytes at offset 184320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 188416 ++read 4096/4096 bytes at offset 188416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 192512 ++read 4096/4096 bytes at offset 192512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 196608 ++read 4096/4096 bytes at offset 196608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 200704 ++read 4096/4096 bytes at offset 200704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 204800 ++read 4096/4096 bytes at offset 204800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 208896 ++read 4096/4096 bytes at offset 208896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 212992 ++read 4096/4096 bytes at offset 212992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 217088 ++read 4096/4096 bytes at offset 217088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 221184 ++read 4096/4096 bytes at offset 221184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 225280 ++read 4096/4096 bytes at offset 225280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 229376 ++read 4096/4096 bytes at offset 229376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 233472 ++read 4096/4096 bytes at offset 233472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 237568 ++read 4096/4096 bytes at offset 237568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 241664 ++read 4096/4096 bytes at offset 241664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 245760 ++read 4096/4096 bytes at offset 245760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 249856 ++read 4096/4096 bytes at offset 249856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 253952 ++read 4096/4096 bytes at offset 253952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 258048 ++read 4096/4096 bytes at offset 258048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 262144 ++read 4096/4096 bytes at offset 262144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 266240 ++read 4096/4096 bytes at offset 266240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 270336 ++read 4096/4096 bytes at offset 270336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 274432 ++read 4096/4096 bytes at offset 274432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 278528 ++read 4096/4096 bytes at offset 278528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 282624 ++read 4096/4096 bytes at offset 282624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 286720 ++read 4096/4096 bytes at offset 286720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 290816 ++read 4096/4096 bytes at offset 290816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 294912 ++read 4096/4096 bytes at offset 294912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 299008 ++read 4096/4096 bytes at offset 299008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 303104 ++read 4096/4096 bytes at offset 303104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 307200 ++read 4096/4096 bytes at offset 307200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 311296 ++read 4096/4096 bytes at offset 311296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 315392 ++read 4096/4096 bytes at offset 315392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 319488 ++read 4096/4096 bytes at offset 319488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 323584 ++read 4096/4096 bytes at offset 323584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 327680 ++read 4096/4096 bytes at offset 327680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 331776 ++read 4096/4096 bytes at offset 331776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 335872 ++read 4096/4096 bytes at offset 335872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 339968 ++read 4096/4096 bytes at offset 339968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 344064 ++read 4096/4096 bytes at offset 344064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 348160 ++read 4096/4096 bytes at offset 348160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 352256 ++read 4096/4096 bytes at offset 352256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 356352 ++read 4096/4096 bytes at offset 356352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 360448 ++read 4096/4096 bytes at offset 360448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 364544 ++read 4096/4096 bytes at offset 364544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 368640 ++read 4096/4096 bytes at offset 368640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 372736 ++read 4096/4096 bytes at offset 372736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 376832 ++read 4096/4096 bytes at offset 376832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 380928 ++read 4096/4096 bytes at offset 380928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 385024 ++read 4096/4096 bytes at offset 385024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 389120 ++read 4096/4096 bytes at offset 389120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 393216 ++read 4096/4096 bytes at offset 393216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 397312 ++read 4096/4096 bytes at offset 397312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 401408 ++read 4096/4096 bytes at offset 401408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 405504 ++read 4096/4096 bytes at offset 405504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 409600 ++read 4096/4096 bytes at offset 409600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 413696 ++read 4096/4096 bytes at offset 413696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 417792 ++read 4096/4096 bytes at offset 417792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 421888 ++read 4096/4096 bytes at offset 421888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 425984 ++read 4096/4096 bytes at offset 425984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 430080 ++read 4096/4096 bytes at offset 430080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 434176 ++read 4096/4096 bytes at offset 434176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 438272 ++read 4096/4096 bytes at offset 438272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 442368 ++read 4096/4096 bytes at offset 442368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 446464 ++read 4096/4096 bytes at offset 446464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 450560 ++read 4096/4096 bytes at offset 450560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 454656 ++read 4096/4096 bytes at offset 454656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 458752 ++read 4096/4096 bytes at offset 458752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 462848 ++read 4096/4096 bytes at offset 462848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 466944 ++read 4096/4096 bytes at offset 466944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 471040 ++read 4096/4096 bytes at offset 471040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 475136 ++read 4096/4096 bytes at offset 475136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 479232 ++read 4096/4096 bytes at offset 479232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 483328 ++read 4096/4096 bytes at offset 483328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 487424 ++read 4096/4096 bytes at offset 487424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 491520 ++read 4096/4096 bytes at offset 491520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 495616 ++read 4096/4096 bytes at offset 495616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 499712 ++read 4096/4096 bytes at offset 499712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 503808 ++read 4096/4096 bytes at offset 503808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 507904 ++read 4096/4096 bytes at offset 507904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 512000 ++read 4096/4096 bytes at offset 512000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 516096 ++read 4096/4096 bytes at offset 516096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 520192 ++read 4096/4096 bytes at offset 520192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 524288 ++read 4096/4096 bytes at offset 524288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 528384 ++read 4096/4096 bytes at offset 528384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 532480 ++read 4096/4096 bytes at offset 532480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 536576 ++read 4096/4096 bytes at offset 536576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 540672 ++read 4096/4096 bytes at offset 540672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 544768 ++read 4096/4096 bytes at offset 544768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 548864 ++read 4096/4096 bytes at offset 548864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 552960 ++read 4096/4096 bytes at offset 552960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 557056 ++read 4096/4096 bytes at offset 557056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 561152 ++read 4096/4096 bytes at offset 561152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 565248 ++read 4096/4096 bytes at offset 565248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 569344 ++read 4096/4096 bytes at offset 569344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 573440 ++read 4096/4096 bytes at offset 573440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 577536 ++read 4096/4096 bytes at offset 577536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 581632 ++read 4096/4096 bytes at offset 581632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 585728 ++read 4096/4096 bytes at offset 585728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 589824 ++read 4096/4096 bytes at offset 589824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 593920 ++read 4096/4096 bytes at offset 593920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 598016 ++read 4096/4096 bytes at offset 598016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 602112 ++read 4096/4096 bytes at offset 602112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 606208 ++read 4096/4096 bytes at offset 606208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 610304 ++read 4096/4096 bytes at offset 610304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 614400 ++read 4096/4096 bytes at offset 614400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 618496 ++read 4096/4096 bytes at offset 618496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 622592 ++read 4096/4096 bytes at offset 622592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 626688 ++read 4096/4096 bytes at offset 626688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 630784 ++read 4096/4096 bytes at offset 630784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 634880 ++read 4096/4096 bytes at offset 634880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 638976 ++read 4096/4096 bytes at offset 638976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 643072 ++read 4096/4096 bytes at offset 643072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 647168 ++read 4096/4096 bytes at offset 647168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 651264 ++read 4096/4096 bytes at offset 651264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 655360 ++read 4096/4096 bytes at offset 655360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 659456 ++read 4096/4096 bytes at offset 659456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 663552 ++read 4096/4096 bytes at offset 663552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 667648 ++read 4096/4096 bytes at offset 667648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 671744 ++read 4096/4096 bytes at offset 671744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 675840 ++read 4096/4096 bytes at offset 675840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 679936 ++read 4096/4096 bytes at offset 679936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 684032 ++read 4096/4096 bytes at offset 684032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 688128 ++read 4096/4096 bytes at offset 688128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 692224 ++read 4096/4096 bytes at offset 692224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 696320 ++read 4096/4096 bytes at offset 696320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 700416 ++read 4096/4096 bytes at offset 700416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 704512 ++read 4096/4096 bytes at offset 704512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 708608 ++read 4096/4096 bytes at offset 708608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 712704 ++read 4096/4096 bytes at offset 712704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 716800 ++read 4096/4096 bytes at offset 716800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 720896 ++read 4096/4096 bytes at offset 720896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 724992 ++read 4096/4096 bytes at offset 724992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 729088 ++read 4096/4096 bytes at offset 729088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 733184 ++read 4096/4096 bytes at offset 733184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 737280 ++read 4096/4096 bytes at offset 737280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 741376 ++read 4096/4096 bytes at offset 741376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 745472 ++read 4096/4096 bytes at offset 745472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 749568 ++read 4096/4096 bytes at offset 749568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 753664 ++read 4096/4096 bytes at offset 753664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 757760 ++read 4096/4096 bytes at offset 757760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 761856 ++read 4096/4096 bytes at offset 761856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 765952 ++read 4096/4096 bytes at offset 765952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 770048 ++read 4096/4096 bytes at offset 770048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 774144 ++read 4096/4096 bytes at offset 774144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 778240 ++read 4096/4096 bytes at offset 778240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 782336 ++read 4096/4096 bytes at offset 782336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 786432 ++read 4096/4096 bytes at offset 786432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 790528 ++read 4096/4096 bytes at offset 790528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 794624 ++read 4096/4096 bytes at offset 794624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 798720 ++read 4096/4096 bytes at offset 798720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 802816 ++read 4096/4096 bytes at offset 802816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 806912 ++read 4096/4096 bytes at offset 806912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 811008 ++read 4096/4096 bytes at offset 811008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 815104 ++read 4096/4096 bytes at offset 815104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 819200 ++read 4096/4096 bytes at offset 819200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 823296 ++read 4096/4096 bytes at offset 823296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 827392 ++read 4096/4096 bytes at offset 827392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 831488 ++read 4096/4096 bytes at offset 831488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 835584 ++read 4096/4096 bytes at offset 835584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 839680 ++read 4096/4096 bytes at offset 839680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 843776 ++read 4096/4096 bytes at offset 843776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 847872 ++read 4096/4096 bytes at offset 847872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 851968 ++read 4096/4096 bytes at offset 851968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 856064 ++read 4096/4096 bytes at offset 856064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 860160 ++read 4096/4096 bytes at offset 860160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 864256 ++read 4096/4096 bytes at offset 864256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 868352 ++read 4096/4096 bytes at offset 868352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 872448 ++read 4096/4096 bytes at offset 872448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 876544 ++read 4096/4096 bytes at offset 876544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 880640 ++read 4096/4096 bytes at offset 880640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 884736 ++read 4096/4096 bytes at offset 884736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 888832 ++read 4096/4096 bytes at offset 888832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 892928 ++read 4096/4096 bytes at offset 892928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 897024 ++read 4096/4096 bytes at offset 897024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 901120 ++read 4096/4096 bytes at offset 901120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 905216 ++read 4096/4096 bytes at offset 905216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 909312 ++read 4096/4096 bytes at offset 909312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 913408 ++read 4096/4096 bytes at offset 913408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 917504 ++read 4096/4096 bytes at offset 917504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 921600 ++read 4096/4096 bytes at offset 921600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 925696 ++read 4096/4096 bytes at offset 925696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 929792 ++read 4096/4096 bytes at offset 929792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 933888 ++read 4096/4096 bytes at offset 933888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 937984 ++read 4096/4096 bytes at offset 937984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 942080 ++read 4096/4096 bytes at offset 942080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 946176 ++read 4096/4096 bytes at offset 946176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 950272 ++read 4096/4096 bytes at offset 950272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 954368 ++read 4096/4096 bytes at offset 954368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 958464 ++read 4096/4096 bytes at offset 958464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 962560 ++read 4096/4096 bytes at offset 962560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 966656 ++read 4096/4096 bytes at offset 966656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 970752 ++read 4096/4096 bytes at offset 970752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 974848 ++read 4096/4096 bytes at offset 974848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 978944 ++read 4096/4096 bytes at offset 978944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 983040 ++read 4096/4096 bytes at offset 983040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 987136 ++read 4096/4096 bytes at offset 987136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 991232 ++read 4096/4096 bytes at offset 991232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 995328 ++read 4096/4096 bytes at offset 995328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 999424 ++read 4096/4096 bytes at offset 999424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1003520 ++read 4096/4096 bytes at offset 1003520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1007616 ++read 4096/4096 bytes at offset 1007616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1011712 ++read 4096/4096 bytes at offset 1011712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1015808 ++read 4096/4096 bytes at offset 1015808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1019904 ++read 4096/4096 bytes at offset 1019904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1024000 ++read 4096/4096 bytes at offset 1024000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1028096 ++read 4096/4096 bytes at offset 1028096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1032192 ++read 4096/4096 bytes at offset 1032192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1036288 ++read 4096/4096 bytes at offset 1036288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1040384 ++read 4096/4096 bytes at offset 1040384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1044480 ++read 4096/4096 bytes at offset 1044480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 4 +-qemu-io> read 2048/2048 bytes at offset 1050624 ++=== IO: pattern 4 ++read 2048/2048 bytes at offset 1050624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1054720 ++read 2048/2048 bytes at offset 1054720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1058816 ++read 2048/2048 bytes at offset 1058816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1062912 ++read 2048/2048 bytes at offset 1062912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1067008 ++read 2048/2048 bytes at offset 1067008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1071104 ++read 2048/2048 bytes at offset 1071104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1075200 ++read 2048/2048 bytes at offset 1075200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1079296 ++read 2048/2048 bytes at offset 1079296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1083392 ++read 2048/2048 bytes at offset 1083392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1087488 ++read 2048/2048 bytes at offset 1087488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1091584 ++read 2048/2048 bytes at offset 1091584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1095680 ++read 2048/2048 bytes at offset 1095680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1099776 ++read 2048/2048 bytes at offset 1099776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1103872 ++read 2048/2048 bytes at offset 1103872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1107968 ++read 2048/2048 bytes at offset 1107968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1112064 ++read 2048/2048 bytes at offset 1112064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1116160 ++read 2048/2048 bytes at offset 1116160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1120256 ++read 2048/2048 bytes at offset 1120256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1124352 ++read 2048/2048 bytes at offset 1124352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1128448 ++read 2048/2048 bytes at offset 1128448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1132544 ++read 2048/2048 bytes at offset 1132544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1136640 ++read 2048/2048 bytes at offset 1136640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1140736 ++read 2048/2048 bytes at offset 1140736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1144832 ++read 2048/2048 bytes at offset 1144832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1148928 ++read 2048/2048 bytes at offset 1148928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1153024 ++read 2048/2048 bytes at offset 1153024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1157120 ++read 2048/2048 bytes at offset 1157120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1161216 ++read 2048/2048 bytes at offset 1161216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1165312 ++read 2048/2048 bytes at offset 1165312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1169408 ++read 2048/2048 bytes at offset 1169408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1173504 ++read 2048/2048 bytes at offset 1173504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1177600 ++read 2048/2048 bytes at offset 1177600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1181696 ++read 2048/2048 bytes at offset 1181696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1185792 ++read 2048/2048 bytes at offset 1185792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1189888 ++read 2048/2048 bytes at offset 1189888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1193984 ++read 2048/2048 bytes at offset 1193984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1198080 ++read 2048/2048 bytes at offset 1198080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1202176 ++read 2048/2048 bytes at offset 1202176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1206272 ++read 2048/2048 bytes at offset 1206272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1210368 ++read 2048/2048 bytes at offset 1210368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1214464 ++read 2048/2048 bytes at offset 1214464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1218560 ++read 2048/2048 bytes at offset 1218560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1222656 ++read 2048/2048 bytes at offset 1222656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1226752 ++read 2048/2048 bytes at offset 1226752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1230848 ++read 2048/2048 bytes at offset 1230848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1234944 ++read 2048/2048 bytes at offset 1234944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1239040 ++read 2048/2048 bytes at offset 1239040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1243136 ++read 2048/2048 bytes at offset 1243136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1247232 ++read 2048/2048 bytes at offset 1247232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1251328 ++read 2048/2048 bytes at offset 1251328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1255424 ++read 2048/2048 bytes at offset 1255424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1259520 ++read 2048/2048 bytes at offset 1259520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1263616 ++read 2048/2048 bytes at offset 1263616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1267712 ++read 2048/2048 bytes at offset 1267712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1271808 ++read 2048/2048 bytes at offset 1271808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1275904 ++read 2048/2048 bytes at offset 1275904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1280000 ++read 2048/2048 bytes at offset 1280000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1284096 ++read 2048/2048 bytes at offset 1284096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1288192 ++read 2048/2048 bytes at offset 1288192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1292288 ++read 2048/2048 bytes at offset 1292288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1296384 ++read 2048/2048 bytes at offset 1296384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1300480 ++read 2048/2048 bytes at offset 1300480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1304576 ++read 2048/2048 bytes at offset 1304576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1308672 ++read 2048/2048 bytes at offset 1308672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1312768 ++read 2048/2048 bytes at offset 1312768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1316864 ++read 2048/2048 bytes at offset 1316864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1320960 ++read 2048/2048 bytes at offset 1320960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1325056 ++read 2048/2048 bytes at offset 1325056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1329152 ++read 2048/2048 bytes at offset 1329152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1333248 ++read 2048/2048 bytes at offset 1333248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1337344 ++read 2048/2048 bytes at offset 1337344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1341440 ++read 2048/2048 bytes at offset 1341440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1345536 ++read 2048/2048 bytes at offset 1345536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1349632 ++read 2048/2048 bytes at offset 1349632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1353728 ++read 2048/2048 bytes at offset 1353728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1357824 ++read 2048/2048 bytes at offset 1357824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1361920 ++read 2048/2048 bytes at offset 1361920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1366016 ++read 2048/2048 bytes at offset 1366016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1370112 ++read 2048/2048 bytes at offset 1370112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1374208 ++read 2048/2048 bytes at offset 1374208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1378304 ++read 2048/2048 bytes at offset 1378304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1382400 ++read 2048/2048 bytes at offset 1382400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1386496 ++read 2048/2048 bytes at offset 1386496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1390592 ++read 2048/2048 bytes at offset 1390592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1394688 ++read 2048/2048 bytes at offset 1394688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1398784 ++read 2048/2048 bytes at offset 1398784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1402880 ++read 2048/2048 bytes at offset 1402880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1406976 ++read 2048/2048 bytes at offset 1406976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1411072 ++read 2048/2048 bytes at offset 1411072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1415168 ++read 2048/2048 bytes at offset 1415168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1419264 ++read 2048/2048 bytes at offset 1419264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1423360 ++read 2048/2048 bytes at offset 1423360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1427456 ++read 2048/2048 bytes at offset 1427456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1431552 ++read 2048/2048 bytes at offset 1431552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1435648 ++read 2048/2048 bytes at offset 1435648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1439744 ++read 2048/2048 bytes at offset 1439744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1443840 ++read 2048/2048 bytes at offset 1443840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1447936 ++read 2048/2048 bytes at offset 1447936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1452032 ++read 2048/2048 bytes at offset 1452032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1456128 ++read 2048/2048 bytes at offset 1456128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1460224 ++read 2048/2048 bytes at offset 1460224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1464320 ++read 2048/2048 bytes at offset 1464320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1468416 ++read 2048/2048 bytes at offset 1468416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1472512 ++read 2048/2048 bytes at offset 1472512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1476608 ++read 2048/2048 bytes at offset 1476608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1480704 ++read 2048/2048 bytes at offset 1480704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1484800 ++read 2048/2048 bytes at offset 1484800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1488896 ++read 2048/2048 bytes at offset 1488896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1492992 ++read 2048/2048 bytes at offset 1492992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1497088 ++read 2048/2048 bytes at offset 1497088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1501184 ++read 2048/2048 bytes at offset 1501184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1505280 ++read 2048/2048 bytes at offset 1505280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1509376 ++read 2048/2048 bytes at offset 1509376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1513472 ++read 2048/2048 bytes at offset 1513472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1517568 ++read 2048/2048 bytes at offset 1517568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1521664 ++read 2048/2048 bytes at offset 1521664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1525760 ++read 2048/2048 bytes at offset 1525760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1529856 ++read 2048/2048 bytes at offset 1529856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1533952 ++read 2048/2048 bytes at offset 1533952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1538048 ++read 2048/2048 bytes at offset 1538048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1542144 ++read 2048/2048 bytes at offset 1542144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1546240 ++read 2048/2048 bytes at offset 1546240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1550336 ++read 2048/2048 bytes at offset 1550336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1554432 ++read 2048/2048 bytes at offset 1554432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1558528 ++read 2048/2048 bytes at offset 1558528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1562624 ++read 2048/2048 bytes at offset 1562624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1566720 ++read 2048/2048 bytes at offset 1566720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1570816 ++read 2048/2048 bytes at offset 1570816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1574912 ++read 2048/2048 bytes at offset 1574912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1579008 ++read 2048/2048 bytes at offset 1579008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1583104 ++read 2048/2048 bytes at offset 1583104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1587200 ++read 2048/2048 bytes at offset 1587200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1591296 ++read 2048/2048 bytes at offset 1591296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1595392 ++read 2048/2048 bytes at offset 1595392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1599488 ++read 2048/2048 bytes at offset 1599488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1603584 ++read 2048/2048 bytes at offset 1603584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1607680 ++read 2048/2048 bytes at offset 1607680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1611776 ++read 2048/2048 bytes at offset 1611776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1615872 ++read 2048/2048 bytes at offset 1615872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1619968 ++read 2048/2048 bytes at offset 1619968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1624064 ++read 2048/2048 bytes at offset 1624064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1628160 ++read 2048/2048 bytes at offset 1628160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1632256 ++read 2048/2048 bytes at offset 1632256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1636352 ++read 2048/2048 bytes at offset 1636352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1640448 ++read 2048/2048 bytes at offset 1640448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1644544 ++read 2048/2048 bytes at offset 1644544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1648640 ++read 2048/2048 bytes at offset 1648640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1652736 ++read 2048/2048 bytes at offset 1652736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1656832 ++read 2048/2048 bytes at offset 1656832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1660928 ++read 2048/2048 bytes at offset 1660928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1665024 ++read 2048/2048 bytes at offset 1665024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1669120 ++read 2048/2048 bytes at offset 1669120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1673216 ++read 2048/2048 bytes at offset 1673216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1677312 ++read 2048/2048 bytes at offset 1677312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1681408 ++read 2048/2048 bytes at offset 1681408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1685504 ++read 2048/2048 bytes at offset 1685504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1689600 ++read 2048/2048 bytes at offset 1689600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1693696 ++read 2048/2048 bytes at offset 1693696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1697792 ++read 2048/2048 bytes at offset 1697792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1701888 ++read 2048/2048 bytes at offset 1701888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1705984 ++read 2048/2048 bytes at offset 1705984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1710080 ++read 2048/2048 bytes at offset 1710080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1714176 ++read 2048/2048 bytes at offset 1714176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1718272 ++read 2048/2048 bytes at offset 1718272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1722368 ++read 2048/2048 bytes at offset 1722368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1726464 ++read 2048/2048 bytes at offset 1726464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1730560 ++read 2048/2048 bytes at offset 1730560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1734656 ++read 2048/2048 bytes at offset 1734656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1738752 ++read 2048/2048 bytes at offset 1738752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1742848 ++read 2048/2048 bytes at offset 1742848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1746944 ++read 2048/2048 bytes at offset 1746944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1751040 ++read 2048/2048 bytes at offset 1751040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1755136 ++read 2048/2048 bytes at offset 1755136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1759232 ++read 2048/2048 bytes at offset 1759232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1763328 ++read 2048/2048 bytes at offset 1763328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1767424 ++read 2048/2048 bytes at offset 1767424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1771520 ++read 2048/2048 bytes at offset 1771520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1775616 ++read 2048/2048 bytes at offset 1775616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1779712 ++read 2048/2048 bytes at offset 1779712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1783808 ++read 2048/2048 bytes at offset 1783808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1787904 ++read 2048/2048 bytes at offset 1787904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1792000 ++read 2048/2048 bytes at offset 1792000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1796096 ++read 2048/2048 bytes at offset 1796096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1800192 ++read 2048/2048 bytes at offset 1800192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1804288 ++read 2048/2048 bytes at offset 1804288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1808384 ++read 2048/2048 bytes at offset 1808384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1812480 ++read 2048/2048 bytes at offset 1812480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1816576 ++read 2048/2048 bytes at offset 1816576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1820672 ++read 2048/2048 bytes at offset 1820672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1824768 ++read 2048/2048 bytes at offset 1824768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1828864 ++read 2048/2048 bytes at offset 1828864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1832960 ++read 2048/2048 bytes at offset 1832960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1837056 ++read 2048/2048 bytes at offset 1837056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1841152 ++read 2048/2048 bytes at offset 1841152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1845248 ++read 2048/2048 bytes at offset 1845248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1849344 ++read 2048/2048 bytes at offset 1849344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1853440 ++read 2048/2048 bytes at offset 1853440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1857536 ++read 2048/2048 bytes at offset 1857536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1861632 ++read 2048/2048 bytes at offset 1861632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1865728 ++read 2048/2048 bytes at offset 1865728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1869824 ++read 2048/2048 bytes at offset 1869824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1873920 ++read 2048/2048 bytes at offset 1873920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1878016 ++read 2048/2048 bytes at offset 1878016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1882112 ++read 2048/2048 bytes at offset 1882112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1886208 ++read 2048/2048 bytes at offset 1886208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1890304 ++read 2048/2048 bytes at offset 1890304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1894400 ++read 2048/2048 bytes at offset 1894400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1898496 ++read 2048/2048 bytes at offset 1898496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1902592 ++read 2048/2048 bytes at offset 1902592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1906688 ++read 2048/2048 bytes at offset 1906688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1910784 ++read 2048/2048 bytes at offset 1910784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1914880 ++read 2048/2048 bytes at offset 1914880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1918976 ++read 2048/2048 bytes at offset 1918976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1923072 ++read 2048/2048 bytes at offset 1923072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1927168 ++read 2048/2048 bytes at offset 1927168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1931264 ++read 2048/2048 bytes at offset 1931264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1935360 ++read 2048/2048 bytes at offset 1935360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1939456 ++read 2048/2048 bytes at offset 1939456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1943552 ++read 2048/2048 bytes at offset 1943552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1947648 ++read 2048/2048 bytes at offset 1947648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1951744 ++read 2048/2048 bytes at offset 1951744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1955840 ++read 2048/2048 bytes at offset 1955840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1959936 ++read 2048/2048 bytes at offset 1959936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1964032 ++read 2048/2048 bytes at offset 1964032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1968128 ++read 2048/2048 bytes at offset 1968128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1972224 ++read 2048/2048 bytes at offset 1972224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1976320 ++read 2048/2048 bytes at offset 1976320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1980416 ++read 2048/2048 bytes at offset 1980416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1984512 ++read 2048/2048 bytes at offset 1984512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1988608 ++read 2048/2048 bytes at offset 1988608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1992704 ++read 2048/2048 bytes at offset 1992704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1996800 ++read 2048/2048 bytes at offset 1996800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2000896 ++read 2048/2048 bytes at offset 2000896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2004992 ++read 2048/2048 bytes at offset 2004992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2009088 ++read 2048/2048 bytes at offset 2009088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2013184 ++read 2048/2048 bytes at offset 2013184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2017280 ++read 2048/2048 bytes at offset 2017280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2021376 ++read 2048/2048 bytes at offset 2021376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2025472 ++read 2048/2048 bytes at offset 2025472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2029568 ++read 2048/2048 bytes at offset 2029568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2033664 ++read 2048/2048 bytes at offset 2033664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2037760 ++read 2048/2048 bytes at offset 2037760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2041856 ++read 2048/2048 bytes at offset 2041856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2045952 ++read 2048/2048 bytes at offset 2045952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2050048 ++read 2048/2048 bytes at offset 2050048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2054144 ++read 2048/2048 bytes at offset 2054144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2058240 ++read 2048/2048 bytes at offset 2058240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2062336 ++read 2048/2048 bytes at offset 2062336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2066432 ++read 2048/2048 bytes at offset 2066432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2070528 ++read 2048/2048 bytes at offset 2070528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2074624 ++read 2048/2048 bytes at offset 2074624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2078720 ++read 2048/2048 bytes at offset 2078720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2082816 ++read 2048/2048 bytes at offset 2082816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2086912 ++read 2048/2048 bytes at offset 2086912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2091008 ++read 2048/2048 bytes at offset 2091008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2095104 ++read 2048/2048 bytes at offset 2095104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> read 2048/2048 bytes at offset 2097152 ++=== IO: pattern 0 ++read 2048/2048 bytes at offset 2097152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2101248 ++read 2048/2048 bytes at offset 2101248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2105344 ++read 2048/2048 bytes at offset 2105344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2109440 ++read 2048/2048 bytes at offset 2109440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2113536 ++read 2048/2048 bytes at offset 2113536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2117632 ++read 2048/2048 bytes at offset 2117632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2121728 ++read 2048/2048 bytes at offset 2121728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2125824 ++read 2048/2048 bytes at offset 2125824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2129920 ++read 2048/2048 bytes at offset 2129920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2134016 ++read 2048/2048 bytes at offset 2134016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2138112 ++read 2048/2048 bytes at offset 2138112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2142208 ++read 2048/2048 bytes at offset 2142208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2146304 ++read 2048/2048 bytes at offset 2146304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2150400 ++read 2048/2048 bytes at offset 2150400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2154496 ++read 2048/2048 bytes at offset 2154496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2158592 ++read 2048/2048 bytes at offset 2158592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2162688 ++read 2048/2048 bytes at offset 2162688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2166784 ++read 2048/2048 bytes at offset 2166784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2170880 ++read 2048/2048 bytes at offset 2170880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2174976 ++read 2048/2048 bytes at offset 2174976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2179072 ++read 2048/2048 bytes at offset 2179072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2183168 ++read 2048/2048 bytes at offset 2183168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2187264 ++read 2048/2048 bytes at offset 2187264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2191360 ++read 2048/2048 bytes at offset 2191360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2195456 ++read 2048/2048 bytes at offset 2195456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2199552 ++read 2048/2048 bytes at offset 2199552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2203648 ++read 2048/2048 bytes at offset 2203648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2207744 ++read 2048/2048 bytes at offset 2207744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2211840 ++read 2048/2048 bytes at offset 2211840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2215936 ++read 2048/2048 bytes at offset 2215936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2220032 ++read 2048/2048 bytes at offset 2220032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2224128 ++read 2048/2048 bytes at offset 2224128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2228224 ++read 2048/2048 bytes at offset 2228224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2232320 ++read 2048/2048 bytes at offset 2232320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2236416 ++read 2048/2048 bytes at offset 2236416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2240512 ++read 2048/2048 bytes at offset 2240512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2244608 ++read 2048/2048 bytes at offset 2244608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2248704 ++read 2048/2048 bytes at offset 2248704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2252800 ++read 2048/2048 bytes at offset 2252800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2256896 ++read 2048/2048 bytes at offset 2256896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2260992 ++read 2048/2048 bytes at offset 2260992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2265088 ++read 2048/2048 bytes at offset 2265088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2269184 ++read 2048/2048 bytes at offset 2269184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2273280 ++read 2048/2048 bytes at offset 2273280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2277376 ++read 2048/2048 bytes at offset 2277376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2281472 ++read 2048/2048 bytes at offset 2281472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2285568 ++read 2048/2048 bytes at offset 2285568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2289664 ++read 2048/2048 bytes at offset 2289664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2293760 ++read 2048/2048 bytes at offset 2293760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2297856 ++read 2048/2048 bytes at offset 2297856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2301952 ++read 2048/2048 bytes at offset 2301952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2306048 ++read 2048/2048 bytes at offset 2306048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2310144 ++read 2048/2048 bytes at offset 2310144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2314240 ++read 2048/2048 bytes at offset 2314240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2318336 ++read 2048/2048 bytes at offset 2318336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2322432 ++read 2048/2048 bytes at offset 2322432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2326528 ++read 2048/2048 bytes at offset 2326528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2330624 ++read 2048/2048 bytes at offset 2330624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2334720 ++read 2048/2048 bytes at offset 2334720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2338816 ++read 2048/2048 bytes at offset 2338816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2342912 ++read 2048/2048 bytes at offset 2342912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2347008 ++read 2048/2048 bytes at offset 2347008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2351104 ++read 2048/2048 bytes at offset 2351104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2355200 ++read 2048/2048 bytes at offset 2355200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2359296 ++read 2048/2048 bytes at offset 2359296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2363392 ++read 2048/2048 bytes at offset 2363392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2367488 ++read 2048/2048 bytes at offset 2367488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2371584 ++read 2048/2048 bytes at offset 2371584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2375680 ++read 2048/2048 bytes at offset 2375680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2379776 ++read 2048/2048 bytes at offset 2379776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2383872 ++read 2048/2048 bytes at offset 2383872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2387968 ++read 2048/2048 bytes at offset 2387968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2392064 ++read 2048/2048 bytes at offset 2392064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2396160 ++read 2048/2048 bytes at offset 2396160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2400256 ++read 2048/2048 bytes at offset 2400256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2404352 ++read 2048/2048 bytes at offset 2404352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2408448 ++read 2048/2048 bytes at offset 2408448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2412544 ++read 2048/2048 bytes at offset 2412544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2416640 ++read 2048/2048 bytes at offset 2416640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2420736 ++read 2048/2048 bytes at offset 2420736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2424832 ++read 2048/2048 bytes at offset 2424832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2428928 ++read 2048/2048 bytes at offset 2428928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2433024 ++read 2048/2048 bytes at offset 2433024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2437120 ++read 2048/2048 bytes at offset 2437120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2441216 ++read 2048/2048 bytes at offset 2441216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2445312 ++read 2048/2048 bytes at offset 2445312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2449408 ++read 2048/2048 bytes at offset 2449408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2453504 ++read 2048/2048 bytes at offset 2453504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2457600 ++read 2048/2048 bytes at offset 2457600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2461696 ++read 2048/2048 bytes at offset 2461696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2465792 ++read 2048/2048 bytes at offset 2465792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2469888 ++read 2048/2048 bytes at offset 2469888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2473984 ++read 2048/2048 bytes at offset 2473984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2478080 ++read 2048/2048 bytes at offset 2478080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2482176 ++read 2048/2048 bytes at offset 2482176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2486272 ++read 2048/2048 bytes at offset 2486272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2490368 ++read 2048/2048 bytes at offset 2490368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2494464 ++read 2048/2048 bytes at offset 2494464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2498560 ++read 2048/2048 bytes at offset 2498560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2502656 ++read 2048/2048 bytes at offset 2502656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2506752 ++read 2048/2048 bytes at offset 2506752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2510848 ++read 2048/2048 bytes at offset 2510848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2514944 ++read 2048/2048 bytes at offset 2514944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2519040 ++read 2048/2048 bytes at offset 2519040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2523136 ++read 2048/2048 bytes at offset 2523136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2527232 ++read 2048/2048 bytes at offset 2527232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2531328 ++read 2048/2048 bytes at offset 2531328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2535424 ++read 2048/2048 bytes at offset 2535424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2539520 ++read 2048/2048 bytes at offset 2539520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2543616 ++read 2048/2048 bytes at offset 2543616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2547712 ++read 2048/2048 bytes at offset 2547712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2551808 ++read 2048/2048 bytes at offset 2551808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2555904 ++read 2048/2048 bytes at offset 2555904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2560000 ++read 2048/2048 bytes at offset 2560000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2564096 ++read 2048/2048 bytes at offset 2564096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2568192 ++read 2048/2048 bytes at offset 2568192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2572288 ++read 2048/2048 bytes at offset 2572288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2576384 ++read 2048/2048 bytes at offset 2576384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2580480 ++read 2048/2048 bytes at offset 2580480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2584576 ++read 2048/2048 bytes at offset 2584576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2588672 ++read 2048/2048 bytes at offset 2588672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2592768 ++read 2048/2048 bytes at offset 2592768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2596864 ++read 2048/2048 bytes at offset 2596864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2600960 ++read 2048/2048 bytes at offset 2600960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2605056 ++read 2048/2048 bytes at offset 2605056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2609152 ++read 2048/2048 bytes at offset 2609152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2613248 ++read 2048/2048 bytes at offset 2613248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2617344 ++read 2048/2048 bytes at offset 2617344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2621440 ++read 2048/2048 bytes at offset 2621440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2625536 ++read 2048/2048 bytes at offset 2625536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2629632 ++read 2048/2048 bytes at offset 2629632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2633728 ++read 2048/2048 bytes at offset 2633728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2637824 ++read 2048/2048 bytes at offset 2637824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2641920 ++read 2048/2048 bytes at offset 2641920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2646016 ++read 2048/2048 bytes at offset 2646016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2650112 ++read 2048/2048 bytes at offset 2650112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2654208 ++read 2048/2048 bytes at offset 2654208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2658304 ++read 2048/2048 bytes at offset 2658304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2662400 ++read 2048/2048 bytes at offset 2662400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2666496 ++read 2048/2048 bytes at offset 2666496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2670592 ++read 2048/2048 bytes at offset 2670592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2674688 ++read 2048/2048 bytes at offset 2674688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2678784 ++read 2048/2048 bytes at offset 2678784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2682880 ++read 2048/2048 bytes at offset 2682880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2686976 ++read 2048/2048 bytes at offset 2686976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2691072 ++read 2048/2048 bytes at offset 2691072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2695168 ++read 2048/2048 bytes at offset 2695168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2699264 ++read 2048/2048 bytes at offset 2699264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2703360 ++read 2048/2048 bytes at offset 2703360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2707456 ++read 2048/2048 bytes at offset 2707456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2711552 ++read 2048/2048 bytes at offset 2711552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2715648 ++read 2048/2048 bytes at offset 2715648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2719744 ++read 2048/2048 bytes at offset 2719744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2723840 ++read 2048/2048 bytes at offset 2723840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2727936 ++read 2048/2048 bytes at offset 2727936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2732032 ++read 2048/2048 bytes at offset 2732032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2736128 ++read 2048/2048 bytes at offset 2736128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2740224 ++read 2048/2048 bytes at offset 2740224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2744320 ++read 2048/2048 bytes at offset 2744320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2748416 ++read 2048/2048 bytes at offset 2748416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2752512 ++read 2048/2048 bytes at offset 2752512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2756608 ++read 2048/2048 bytes at offset 2756608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2760704 ++read 2048/2048 bytes at offset 2760704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2764800 ++read 2048/2048 bytes at offset 2764800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2768896 ++read 2048/2048 bytes at offset 2768896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2772992 ++read 2048/2048 bytes at offset 2772992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2777088 ++read 2048/2048 bytes at offset 2777088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2781184 ++read 2048/2048 bytes at offset 2781184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2785280 ++read 2048/2048 bytes at offset 2785280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2789376 ++read 2048/2048 bytes at offset 2789376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2793472 ++read 2048/2048 bytes at offset 2793472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2797568 ++read 2048/2048 bytes at offset 2797568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2801664 ++read 2048/2048 bytes at offset 2801664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2805760 ++read 2048/2048 bytes at offset 2805760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2809856 ++read 2048/2048 bytes at offset 2809856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2813952 ++read 2048/2048 bytes at offset 2813952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2818048 ++read 2048/2048 bytes at offset 2818048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2822144 ++read 2048/2048 bytes at offset 2822144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2826240 ++read 2048/2048 bytes at offset 2826240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2830336 ++read 2048/2048 bytes at offset 2830336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2834432 ++read 2048/2048 bytes at offset 2834432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2838528 ++read 2048/2048 bytes at offset 2838528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2842624 ++read 2048/2048 bytes at offset 2842624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2846720 ++read 2048/2048 bytes at offset 2846720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2850816 ++read 2048/2048 bytes at offset 2850816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2854912 ++read 2048/2048 bytes at offset 2854912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2859008 ++read 2048/2048 bytes at offset 2859008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2863104 ++read 2048/2048 bytes at offset 2863104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2867200 ++read 2048/2048 bytes at offset 2867200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2871296 ++read 2048/2048 bytes at offset 2871296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2875392 ++read 2048/2048 bytes at offset 2875392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2879488 ++read 2048/2048 bytes at offset 2879488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2883584 ++read 2048/2048 bytes at offset 2883584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2887680 ++read 2048/2048 bytes at offset 2887680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2891776 ++read 2048/2048 bytes at offset 2891776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2895872 ++read 2048/2048 bytes at offset 2895872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2899968 ++read 2048/2048 bytes at offset 2899968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2904064 ++read 2048/2048 bytes at offset 2904064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2908160 ++read 2048/2048 bytes at offset 2908160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2912256 ++read 2048/2048 bytes at offset 2912256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2916352 ++read 2048/2048 bytes at offset 2916352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2920448 ++read 2048/2048 bytes at offset 2920448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2924544 ++read 2048/2048 bytes at offset 2924544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2928640 ++read 2048/2048 bytes at offset 2928640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2932736 ++read 2048/2048 bytes at offset 2932736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2936832 ++read 2048/2048 bytes at offset 2936832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2940928 ++read 2048/2048 bytes at offset 2940928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2945024 ++read 2048/2048 bytes at offset 2945024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2949120 ++read 2048/2048 bytes at offset 2949120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2953216 ++read 2048/2048 bytes at offset 2953216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2957312 ++read 2048/2048 bytes at offset 2957312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2961408 ++read 2048/2048 bytes at offset 2961408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2965504 ++read 2048/2048 bytes at offset 2965504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2969600 ++read 2048/2048 bytes at offset 2969600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2973696 ++read 2048/2048 bytes at offset 2973696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2977792 ++read 2048/2048 bytes at offset 2977792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2981888 ++read 2048/2048 bytes at offset 2981888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2985984 ++read 2048/2048 bytes at offset 2985984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2990080 ++read 2048/2048 bytes at offset 2990080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2994176 ++read 2048/2048 bytes at offset 2994176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2998272 ++read 2048/2048 bytes at offset 2998272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3002368 ++read 2048/2048 bytes at offset 3002368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3006464 ++read 2048/2048 bytes at offset 3006464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3010560 ++read 2048/2048 bytes at offset 3010560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3014656 ++read 2048/2048 bytes at offset 3014656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3018752 ++read 2048/2048 bytes at offset 3018752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3022848 ++read 2048/2048 bytes at offset 3022848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3026944 ++read 2048/2048 bytes at offset 3026944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3031040 ++read 2048/2048 bytes at offset 3031040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3035136 ++read 2048/2048 bytes at offset 3035136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3039232 ++read 2048/2048 bytes at offset 3039232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3043328 ++read 2048/2048 bytes at offset 3043328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3047424 ++read 2048/2048 bytes at offset 3047424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3051520 ++read 2048/2048 bytes at offset 3051520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3055616 ++read 2048/2048 bytes at offset 3055616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3059712 ++read 2048/2048 bytes at offset 3059712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3063808 ++read 2048/2048 bytes at offset 3063808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3067904 ++read 2048/2048 bytes at offset 3067904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3072000 ++read 2048/2048 bytes at offset 3072000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3076096 ++read 2048/2048 bytes at offset 3076096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3080192 ++read 2048/2048 bytes at offset 3080192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3084288 ++read 2048/2048 bytes at offset 3084288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3088384 ++read 2048/2048 bytes at offset 3088384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3092480 ++read 2048/2048 bytes at offset 3092480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3096576 ++read 2048/2048 bytes at offset 3096576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3100672 ++read 2048/2048 bytes at offset 3100672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3104768 ++read 2048/2048 bytes at offset 3104768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3108864 ++read 2048/2048 bytes at offset 3108864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3112960 ++read 2048/2048 bytes at offset 3112960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3117056 ++read 2048/2048 bytes at offset 3117056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3121152 ++read 2048/2048 bytes at offset 3121152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3125248 ++read 2048/2048 bytes at offset 3125248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3129344 ++read 2048/2048 bytes at offset 3129344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3133440 ++read 2048/2048 bytes at offset 3133440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3137536 ++read 2048/2048 bytes at offset 3137536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3141632 ++read 2048/2048 bytes at offset 3141632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 2 +-qemu-io> read 2048/2048 bytes at offset 3146752 ++=== IO: pattern 2 ++read 2048/2048 bytes at offset 3146752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3150848 ++read 2048/2048 bytes at offset 3150848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3154944 ++read 2048/2048 bytes at offset 3154944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3159040 ++read 2048/2048 bytes at offset 3159040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3163136 ++read 2048/2048 bytes at offset 3163136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3167232 ++read 2048/2048 bytes at offset 3167232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3171328 ++read 2048/2048 bytes at offset 3171328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3175424 ++read 2048/2048 bytes at offset 3175424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3179520 ++read 2048/2048 bytes at offset 3179520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3183616 ++read 2048/2048 bytes at offset 3183616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3187712 ++read 2048/2048 bytes at offset 3187712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3191808 ++read 2048/2048 bytes at offset 3191808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3195904 ++read 2048/2048 bytes at offset 3195904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3200000 ++read 2048/2048 bytes at offset 3200000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3204096 ++read 2048/2048 bytes at offset 3204096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3208192 ++read 2048/2048 bytes at offset 3208192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3212288 ++read 2048/2048 bytes at offset 3212288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3216384 ++read 2048/2048 bytes at offset 3216384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3220480 ++read 2048/2048 bytes at offset 3220480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3224576 ++read 2048/2048 bytes at offset 3224576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3228672 ++read 2048/2048 bytes at offset 3228672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3232768 ++read 2048/2048 bytes at offset 3232768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3236864 ++read 2048/2048 bytes at offset 3236864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3240960 ++read 2048/2048 bytes at offset 3240960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3245056 ++read 2048/2048 bytes at offset 3245056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3249152 ++read 2048/2048 bytes at offset 3249152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3253248 ++read 2048/2048 bytes at offset 3253248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3257344 ++read 2048/2048 bytes at offset 3257344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3261440 ++read 2048/2048 bytes at offset 3261440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3265536 ++read 2048/2048 bytes at offset 3265536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3269632 ++read 2048/2048 bytes at offset 3269632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3273728 ++read 2048/2048 bytes at offset 3273728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3277824 ++read 2048/2048 bytes at offset 3277824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3281920 ++read 2048/2048 bytes at offset 3281920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3286016 ++read 2048/2048 bytes at offset 3286016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3290112 ++read 2048/2048 bytes at offset 3290112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3294208 ++read 2048/2048 bytes at offset 3294208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3298304 ++read 2048/2048 bytes at offset 3298304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3302400 ++read 2048/2048 bytes at offset 3302400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3306496 ++read 2048/2048 bytes at offset 3306496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3310592 ++read 2048/2048 bytes at offset 3310592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3314688 ++read 2048/2048 bytes at offset 3314688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3318784 ++read 2048/2048 bytes at offset 3318784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3322880 ++read 2048/2048 bytes at offset 3322880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3326976 ++read 2048/2048 bytes at offset 3326976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3331072 ++read 2048/2048 bytes at offset 3331072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3335168 ++read 2048/2048 bytes at offset 3335168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3339264 ++read 2048/2048 bytes at offset 3339264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3343360 ++read 2048/2048 bytes at offset 3343360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3347456 ++read 2048/2048 bytes at offset 3347456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3351552 ++read 2048/2048 bytes at offset 3351552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3355648 ++read 2048/2048 bytes at offset 3355648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3359744 ++read 2048/2048 bytes at offset 3359744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3363840 ++read 2048/2048 bytes at offset 3363840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3367936 ++read 2048/2048 bytes at offset 3367936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3372032 ++read 2048/2048 bytes at offset 3372032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3376128 ++read 2048/2048 bytes at offset 3376128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3380224 ++read 2048/2048 bytes at offset 3380224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3384320 ++read 2048/2048 bytes at offset 3384320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3388416 ++read 2048/2048 bytes at offset 3388416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3392512 ++read 2048/2048 bytes at offset 3392512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3396608 ++read 2048/2048 bytes at offset 3396608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3400704 ++read 2048/2048 bytes at offset 3400704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3404800 ++read 2048/2048 bytes at offset 3404800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3408896 ++read 2048/2048 bytes at offset 3408896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3412992 ++read 2048/2048 bytes at offset 3412992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3417088 ++read 2048/2048 bytes at offset 3417088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3421184 ++read 2048/2048 bytes at offset 3421184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3425280 ++read 2048/2048 bytes at offset 3425280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3429376 ++read 2048/2048 bytes at offset 3429376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3433472 ++read 2048/2048 bytes at offset 3433472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3437568 ++read 2048/2048 bytes at offset 3437568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3441664 ++read 2048/2048 bytes at offset 3441664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3445760 ++read 2048/2048 bytes at offset 3445760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3449856 ++read 2048/2048 bytes at offset 3449856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3453952 ++read 2048/2048 bytes at offset 3453952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3458048 ++read 2048/2048 bytes at offset 3458048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3462144 ++read 2048/2048 bytes at offset 3462144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3466240 ++read 2048/2048 bytes at offset 3466240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3470336 ++read 2048/2048 bytes at offset 3470336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3474432 ++read 2048/2048 bytes at offset 3474432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3478528 ++read 2048/2048 bytes at offset 3478528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3482624 ++read 2048/2048 bytes at offset 3482624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3486720 ++read 2048/2048 bytes at offset 3486720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3490816 ++read 2048/2048 bytes at offset 3490816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3494912 ++read 2048/2048 bytes at offset 3494912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3499008 ++read 2048/2048 bytes at offset 3499008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3503104 ++read 2048/2048 bytes at offset 3503104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3507200 ++read 2048/2048 bytes at offset 3507200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3511296 ++read 2048/2048 bytes at offset 3511296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3515392 ++read 2048/2048 bytes at offset 3515392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3519488 ++read 2048/2048 bytes at offset 3519488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3523584 ++read 2048/2048 bytes at offset 3523584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3527680 ++read 2048/2048 bytes at offset 3527680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3531776 ++read 2048/2048 bytes at offset 3531776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3535872 ++read 2048/2048 bytes at offset 3535872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3539968 ++read 2048/2048 bytes at offset 3539968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3544064 ++read 2048/2048 bytes at offset 3544064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3548160 ++read 2048/2048 bytes at offset 3548160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3552256 ++read 2048/2048 bytes at offset 3552256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3556352 ++read 2048/2048 bytes at offset 3556352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3560448 ++read 2048/2048 bytes at offset 3560448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3564544 ++read 2048/2048 bytes at offset 3564544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3568640 ++read 2048/2048 bytes at offset 3568640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3572736 ++read 2048/2048 bytes at offset 3572736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3576832 ++read 2048/2048 bytes at offset 3576832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3580928 ++read 2048/2048 bytes at offset 3580928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3585024 ++read 2048/2048 bytes at offset 3585024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3589120 ++read 2048/2048 bytes at offset 3589120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3593216 ++read 2048/2048 bytes at offset 3593216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3597312 ++read 2048/2048 bytes at offset 3597312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3601408 ++read 2048/2048 bytes at offset 3601408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3605504 ++read 2048/2048 bytes at offset 3605504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3609600 ++read 2048/2048 bytes at offset 3609600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3613696 ++read 2048/2048 bytes at offset 3613696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3617792 ++read 2048/2048 bytes at offset 3617792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3621888 ++read 2048/2048 bytes at offset 3621888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3625984 ++read 2048/2048 bytes at offset 3625984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3630080 ++read 2048/2048 bytes at offset 3630080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3634176 ++read 2048/2048 bytes at offset 3634176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3638272 ++read 2048/2048 bytes at offset 3638272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3642368 ++read 2048/2048 bytes at offset 3642368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3646464 ++read 2048/2048 bytes at offset 3646464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3650560 ++read 2048/2048 bytes at offset 3650560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3654656 ++read 2048/2048 bytes at offset 3654656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3658752 ++read 2048/2048 bytes at offset 3658752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3662848 ++read 2048/2048 bytes at offset 3662848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3666944 ++read 2048/2048 bytes at offset 3666944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3671040 ++read 2048/2048 bytes at offset 3671040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3675136 ++read 2048/2048 bytes at offset 3675136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3679232 ++read 2048/2048 bytes at offset 3679232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3683328 ++read 2048/2048 bytes at offset 3683328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3687424 ++read 2048/2048 bytes at offset 3687424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3691520 ++read 2048/2048 bytes at offset 3691520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3695616 ++read 2048/2048 bytes at offset 3695616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3699712 ++read 2048/2048 bytes at offset 3699712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3703808 ++read 2048/2048 bytes at offset 3703808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3707904 ++read 2048/2048 bytes at offset 3707904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3712000 ++read 2048/2048 bytes at offset 3712000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3716096 ++read 2048/2048 bytes at offset 3716096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3720192 ++read 2048/2048 bytes at offset 3720192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3724288 ++read 2048/2048 bytes at offset 3724288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3728384 ++read 2048/2048 bytes at offset 3728384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3732480 ++read 2048/2048 bytes at offset 3732480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3736576 ++read 2048/2048 bytes at offset 3736576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3740672 ++read 2048/2048 bytes at offset 3740672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3744768 ++read 2048/2048 bytes at offset 3744768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3748864 ++read 2048/2048 bytes at offset 3748864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3752960 ++read 2048/2048 bytes at offset 3752960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3757056 ++read 2048/2048 bytes at offset 3757056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3761152 ++read 2048/2048 bytes at offset 3761152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3765248 ++read 2048/2048 bytes at offset 3765248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3769344 ++read 2048/2048 bytes at offset 3769344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3773440 ++read 2048/2048 bytes at offset 3773440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3777536 ++read 2048/2048 bytes at offset 3777536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3781632 ++read 2048/2048 bytes at offset 3781632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3785728 ++read 2048/2048 bytes at offset 3785728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3789824 ++read 2048/2048 bytes at offset 3789824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3793920 ++read 2048/2048 bytes at offset 3793920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3798016 ++read 2048/2048 bytes at offset 3798016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3802112 ++read 2048/2048 bytes at offset 3802112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3806208 ++read 2048/2048 bytes at offset 3806208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3810304 ++read 2048/2048 bytes at offset 3810304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3814400 ++read 2048/2048 bytes at offset 3814400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3818496 ++read 2048/2048 bytes at offset 3818496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3822592 ++read 2048/2048 bytes at offset 3822592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3826688 ++read 2048/2048 bytes at offset 3826688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3830784 ++read 2048/2048 bytes at offset 3830784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3834880 ++read 2048/2048 bytes at offset 3834880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3838976 ++read 2048/2048 bytes at offset 3838976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3843072 ++read 2048/2048 bytes at offset 3843072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3847168 ++read 2048/2048 bytes at offset 3847168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3851264 ++read 2048/2048 bytes at offset 3851264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3855360 ++read 2048/2048 bytes at offset 3855360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3859456 ++read 2048/2048 bytes at offset 3859456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3863552 ++read 2048/2048 bytes at offset 3863552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3867648 ++read 2048/2048 bytes at offset 3867648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3871744 ++read 2048/2048 bytes at offset 3871744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3875840 ++read 2048/2048 bytes at offset 3875840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3879936 ++read 2048/2048 bytes at offset 3879936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3884032 ++read 2048/2048 bytes at offset 3884032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3888128 ++read 2048/2048 bytes at offset 3888128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3892224 ++read 2048/2048 bytes at offset 3892224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3896320 ++read 2048/2048 bytes at offset 3896320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3900416 ++read 2048/2048 bytes at offset 3900416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3904512 ++read 2048/2048 bytes at offset 3904512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3908608 ++read 2048/2048 bytes at offset 3908608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3912704 ++read 2048/2048 bytes at offset 3912704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3916800 ++read 2048/2048 bytes at offset 3916800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3920896 ++read 2048/2048 bytes at offset 3920896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3924992 ++read 2048/2048 bytes at offset 3924992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3929088 ++read 2048/2048 bytes at offset 3929088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3933184 ++read 2048/2048 bytes at offset 3933184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3937280 ++read 2048/2048 bytes at offset 3937280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3941376 ++read 2048/2048 bytes at offset 3941376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3945472 ++read 2048/2048 bytes at offset 3945472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3949568 ++read 2048/2048 bytes at offset 3949568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3953664 ++read 2048/2048 bytes at offset 3953664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3957760 ++read 2048/2048 bytes at offset 3957760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3961856 ++read 2048/2048 bytes at offset 3961856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3965952 ++read 2048/2048 bytes at offset 3965952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3970048 ++read 2048/2048 bytes at offset 3970048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3974144 ++read 2048/2048 bytes at offset 3974144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3978240 ++read 2048/2048 bytes at offset 3978240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3982336 ++read 2048/2048 bytes at offset 3982336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3986432 ++read 2048/2048 bytes at offset 3986432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3990528 ++read 2048/2048 bytes at offset 3990528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3994624 ++read 2048/2048 bytes at offset 3994624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3998720 ++read 2048/2048 bytes at offset 3998720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4002816 ++read 2048/2048 bytes at offset 4002816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4006912 ++read 2048/2048 bytes at offset 4006912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4011008 ++read 2048/2048 bytes at offset 4011008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4015104 ++read 2048/2048 bytes at offset 4015104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4019200 ++read 2048/2048 bytes at offset 4019200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4023296 ++read 2048/2048 bytes at offset 4023296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4027392 ++read 2048/2048 bytes at offset 4027392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4031488 ++read 2048/2048 bytes at offset 4031488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4035584 ++read 2048/2048 bytes at offset 4035584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4039680 ++read 2048/2048 bytes at offset 4039680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4043776 ++read 2048/2048 bytes at offset 4043776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4047872 ++read 2048/2048 bytes at offset 4047872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4051968 ++read 2048/2048 bytes at offset 4051968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4056064 ++read 2048/2048 bytes at offset 4056064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4060160 ++read 2048/2048 bytes at offset 4060160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4064256 ++read 2048/2048 bytes at offset 4064256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4068352 ++read 2048/2048 bytes at offset 4068352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4072448 ++read 2048/2048 bytes at offset 4072448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4076544 ++read 2048/2048 bytes at offset 4076544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4080640 ++read 2048/2048 bytes at offset 4080640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4084736 ++read 2048/2048 bytes at offset 4084736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4088832 ++read 2048/2048 bytes at offset 4088832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4092928 ++read 2048/2048 bytes at offset 4092928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4097024 ++read 2048/2048 bytes at offset 4097024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4101120 ++read 2048/2048 bytes at offset 4101120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4105216 ++read 2048/2048 bytes at offset 4105216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4109312 ++read 2048/2048 bytes at offset 4109312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4113408 ++read 2048/2048 bytes at offset 4113408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4117504 ++read 2048/2048 bytes at offset 4117504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4121600 ++read 2048/2048 bytes at offset 4121600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4125696 ++read 2048/2048 bytes at offset 4125696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4129792 ++read 2048/2048 bytes at offset 4129792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4133888 ++read 2048/2048 bytes at offset 4133888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4137984 ++read 2048/2048 bytes at offset 4137984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4142080 ++read 2048/2048 bytes at offset 4142080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4146176 ++read 2048/2048 bytes at offset 4146176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4150272 ++read 2048/2048 bytes at offset 4150272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4154368 ++read 2048/2048 bytes at offset 4154368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4158464 ++read 2048/2048 bytes at offset 4158464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4162560 ++read 2048/2048 bytes at offset 4162560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4166656 ++read 2048/2048 bytes at offset 4166656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4170752 ++read 2048/2048 bytes at offset 4170752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4174848 ++read 2048/2048 bytes at offset 4174848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4178944 ++read 2048/2048 bytes at offset 4178944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4183040 ++read 2048/2048 bytes at offset 4183040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4187136 ++read 2048/2048 bytes at offset 4187136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4191232 ++read 2048/2048 bytes at offset 4191232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 4 +-qemu-io> read 8192/8192 bytes at offset 4196352 ++=== IO: pattern 4 ++read 8192/8192 bytes at offset 4196352 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4208640 ++read 8192/8192 bytes at offset 4208640 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4220928 ++read 8192/8192 bytes at offset 4220928 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4233216 ++read 8192/8192 bytes at offset 4233216 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4245504 ++read 8192/8192 bytes at offset 4245504 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4257792 ++read 8192/8192 bytes at offset 4257792 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4270080 ++read 8192/8192 bytes at offset 4270080 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4282368 ++read 8192/8192 bytes at offset 4282368 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4294656 ++read 8192/8192 bytes at offset 4294656 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4306944 ++read 8192/8192 bytes at offset 4306944 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4319232 ++read 8192/8192 bytes at offset 4319232 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4331520 ++read 8192/8192 bytes at offset 4331520 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4343808 ++read 8192/8192 bytes at offset 4343808 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4356096 ++read 8192/8192 bytes at offset 4356096 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4368384 ++read 8192/8192 bytes at offset 4368384 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4380672 ++read 8192/8192 bytes at offset 4380672 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4392960 ++read 8192/8192 bytes at offset 4392960 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4405248 ++read 8192/8192 bytes at offset 4405248 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4417536 ++read 8192/8192 bytes at offset 4417536 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4429824 ++read 8192/8192 bytes at offset 4429824 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4442112 ++read 8192/8192 bytes at offset 4442112 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4454400 ++read 8192/8192 bytes at offset 4454400 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4466688 ++read 8192/8192 bytes at offset 4466688 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4478976 ++read 8192/8192 bytes at offset 4478976 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4491264 ++read 8192/8192 bytes at offset 4491264 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4503552 ++read 8192/8192 bytes at offset 4503552 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4515840 ++read 8192/8192 bytes at offset 4515840 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4528128 ++read 8192/8192 bytes at offset 4528128 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4540416 ++read 8192/8192 bytes at offset 4540416 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4552704 ++read 8192/8192 bytes at offset 4552704 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4564992 ++read 8192/8192 bytes at offset 4564992 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4577280 ++read 8192/8192 bytes at offset 4577280 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4589568 ++read 8192/8192 bytes at offset 4589568 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4601856 ++read 8192/8192 bytes at offset 4601856 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4614144 ++read 8192/8192 bytes at offset 4614144 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4626432 ++read 8192/8192 bytes at offset 4626432 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4638720 ++read 8192/8192 bytes at offset 4638720 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4651008 ++read 8192/8192 bytes at offset 4651008 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4663296 ++read 8192/8192 bytes at offset 4663296 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4675584 ++read 8192/8192 bytes at offset 4675584 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4687872 ++read 8192/8192 bytes at offset 4687872 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4700160 ++read 8192/8192 bytes at offset 4700160 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4712448 ++read 8192/8192 bytes at offset 4712448 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4724736 ++read 8192/8192 bytes at offset 4724736 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4737024 ++read 8192/8192 bytes at offset 4737024 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4749312 ++read 8192/8192 bytes at offset 4749312 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4761600 ++read 8192/8192 bytes at offset 4761600 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4773888 ++read 8192/8192 bytes at offset 4773888 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4786176 ++read 8192/8192 bytes at offset 4786176 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4798464 ++read 8192/8192 bytes at offset 4798464 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4810752 ++read 8192/8192 bytes at offset 4810752 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4823040 ++read 8192/8192 bytes at offset 4823040 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4835328 ++read 8192/8192 bytes at offset 4835328 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4847616 ++read 8192/8192 bytes at offset 4847616 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4859904 ++read 8192/8192 bytes at offset 4859904 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4872192 ++read 8192/8192 bytes at offset 4872192 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4884480 ++read 8192/8192 bytes at offset 4884480 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4896768 ++read 8192/8192 bytes at offset 4896768 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4909056 ++read 8192/8192 bytes at offset 4909056 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4921344 ++read 8192/8192 bytes at offset 4921344 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4933632 ++read 8192/8192 bytes at offset 4933632 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4945920 ++read 8192/8192 bytes at offset 4945920 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4958208 ++read 8192/8192 bytes at offset 4958208 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4970496 ++read 8192/8192 bytes at offset 4970496 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 244 +-qemu-io> read 12288/12288 bytes at offset 6285312 ++=== IO: pattern 244 ++read 12288/12288 bytes at offset 6285312 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 8384512 ++read 12288/12288 bytes at offset 8384512 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 10483712 ++read 12288/12288 bytes at offset 10483712 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 12582912 ++read 12288/12288 bytes at offset 12582912 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 14682112 ++read 12288/12288 bytes at offset 14682112 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 16781312 ++read 12288/12288 bytes at offset 16781312 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 18880512 ++read 12288/12288 bytes at offset 18880512 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 20979712 ++read 12288/12288 bytes at offset 20979712 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> No errors were found on the image. ++No errors were found on the image. + At offset 4294967296: + === IO: pattern 0 +-qemu-io> wrote 4096/4096 bytes at offset 4294967296 ++wrote 4096/4096 bytes at offset 4294967296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4294971392 ++wrote 4096/4096 bytes at offset 4294971392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4294975488 ++wrote 4096/4096 bytes at offset 4294975488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4294979584 ++wrote 4096/4096 bytes at offset 4294979584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4294983680 ++wrote 4096/4096 bytes at offset 4294983680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4294987776 ++wrote 4096/4096 bytes at offset 4294987776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4294991872 ++wrote 4096/4096 bytes at offset 4294991872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4294995968 ++wrote 4096/4096 bytes at offset 4294995968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295000064 ++wrote 4096/4096 bytes at offset 4295000064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295004160 ++wrote 4096/4096 bytes at offset 4295004160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295008256 ++wrote 4096/4096 bytes at offset 4295008256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295012352 ++wrote 4096/4096 bytes at offset 4295012352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295016448 ++wrote 4096/4096 bytes at offset 4295016448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295020544 ++wrote 4096/4096 bytes at offset 4295020544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295024640 ++wrote 4096/4096 bytes at offset 4295024640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295028736 ++wrote 4096/4096 bytes at offset 4295028736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295032832 ++wrote 4096/4096 bytes at offset 4295032832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295036928 ++wrote 4096/4096 bytes at offset 4295036928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295041024 ++wrote 4096/4096 bytes at offset 4295041024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295045120 ++wrote 4096/4096 bytes at offset 4295045120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295049216 ++wrote 4096/4096 bytes at offset 4295049216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295053312 ++wrote 4096/4096 bytes at offset 4295053312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295057408 ++wrote 4096/4096 bytes at offset 4295057408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295061504 ++wrote 4096/4096 bytes at offset 4295061504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295065600 ++wrote 4096/4096 bytes at offset 4295065600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295069696 ++wrote 4096/4096 bytes at offset 4295069696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295073792 ++wrote 4096/4096 bytes at offset 4295073792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295077888 ++wrote 4096/4096 bytes at offset 4295077888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295081984 ++wrote 4096/4096 bytes at offset 4295081984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295086080 ++wrote 4096/4096 bytes at offset 4295086080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295090176 ++wrote 4096/4096 bytes at offset 4295090176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295094272 ++wrote 4096/4096 bytes at offset 4295094272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295098368 ++wrote 4096/4096 bytes at offset 4295098368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295102464 ++wrote 4096/4096 bytes at offset 4295102464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295106560 ++wrote 4096/4096 bytes at offset 4295106560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295110656 ++wrote 4096/4096 bytes at offset 4295110656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295114752 ++wrote 4096/4096 bytes at offset 4295114752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295118848 ++wrote 4096/4096 bytes at offset 4295118848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295122944 ++wrote 4096/4096 bytes at offset 4295122944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295127040 ++wrote 4096/4096 bytes at offset 4295127040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295131136 ++wrote 4096/4096 bytes at offset 4295131136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295135232 ++wrote 4096/4096 bytes at offset 4295135232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295139328 ++wrote 4096/4096 bytes at offset 4295139328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295143424 ++wrote 4096/4096 bytes at offset 4295143424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295147520 ++wrote 4096/4096 bytes at offset 4295147520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295151616 ++wrote 4096/4096 bytes at offset 4295151616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295155712 ++wrote 4096/4096 bytes at offset 4295155712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295159808 ++wrote 4096/4096 bytes at offset 4295159808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295163904 ++wrote 4096/4096 bytes at offset 4295163904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295168000 ++wrote 4096/4096 bytes at offset 4295168000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295172096 ++wrote 4096/4096 bytes at offset 4295172096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295176192 ++wrote 4096/4096 bytes at offset 4295176192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295180288 ++wrote 4096/4096 bytes at offset 4295180288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295184384 ++wrote 4096/4096 bytes at offset 4295184384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295188480 ++wrote 4096/4096 bytes at offset 4295188480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295192576 ++wrote 4096/4096 bytes at offset 4295192576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295196672 ++wrote 4096/4096 bytes at offset 4295196672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295200768 ++wrote 4096/4096 bytes at offset 4295200768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295204864 ++wrote 4096/4096 bytes at offset 4295204864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295208960 ++wrote 4096/4096 bytes at offset 4295208960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295213056 ++wrote 4096/4096 bytes at offset 4295213056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295217152 ++wrote 4096/4096 bytes at offset 4295217152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295221248 ++wrote 4096/4096 bytes at offset 4295221248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295225344 ++wrote 4096/4096 bytes at offset 4295225344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295229440 ++wrote 4096/4096 bytes at offset 4295229440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295233536 ++wrote 4096/4096 bytes at offset 4295233536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295237632 ++wrote 4096/4096 bytes at offset 4295237632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295241728 ++wrote 4096/4096 bytes at offset 4295241728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295245824 ++wrote 4096/4096 bytes at offset 4295245824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295249920 ++wrote 4096/4096 bytes at offset 4295249920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295254016 ++wrote 4096/4096 bytes at offset 4295254016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295258112 ++wrote 4096/4096 bytes at offset 4295258112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295262208 ++wrote 4096/4096 bytes at offset 4295262208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295266304 ++wrote 4096/4096 bytes at offset 4295266304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295270400 ++wrote 4096/4096 bytes at offset 4295270400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295274496 ++wrote 4096/4096 bytes at offset 4295274496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295278592 ++wrote 4096/4096 bytes at offset 4295278592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295282688 ++wrote 4096/4096 bytes at offset 4295282688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295286784 ++wrote 4096/4096 bytes at offset 4295286784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295290880 ++wrote 4096/4096 bytes at offset 4295290880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295294976 ++wrote 4096/4096 bytes at offset 4295294976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295299072 ++wrote 4096/4096 bytes at offset 4295299072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295303168 ++wrote 4096/4096 bytes at offset 4295303168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295307264 ++wrote 4096/4096 bytes at offset 4295307264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295311360 ++wrote 4096/4096 bytes at offset 4295311360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295315456 ++wrote 4096/4096 bytes at offset 4295315456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295319552 ++wrote 4096/4096 bytes at offset 4295319552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295323648 ++wrote 4096/4096 bytes at offset 4295323648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295327744 ++wrote 4096/4096 bytes at offset 4295327744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295331840 ++wrote 4096/4096 bytes at offset 4295331840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295335936 ++wrote 4096/4096 bytes at offset 4295335936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295340032 ++wrote 4096/4096 bytes at offset 4295340032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295344128 ++wrote 4096/4096 bytes at offset 4295344128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295348224 ++wrote 4096/4096 bytes at offset 4295348224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295352320 ++wrote 4096/4096 bytes at offset 4295352320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295356416 ++wrote 4096/4096 bytes at offset 4295356416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295360512 ++wrote 4096/4096 bytes at offset 4295360512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295364608 ++wrote 4096/4096 bytes at offset 4295364608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295368704 ++wrote 4096/4096 bytes at offset 4295368704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295372800 ++wrote 4096/4096 bytes at offset 4295372800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295376896 ++wrote 4096/4096 bytes at offset 4295376896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295380992 ++wrote 4096/4096 bytes at offset 4295380992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295385088 ++wrote 4096/4096 bytes at offset 4295385088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295389184 ++wrote 4096/4096 bytes at offset 4295389184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295393280 ++wrote 4096/4096 bytes at offset 4295393280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295397376 ++wrote 4096/4096 bytes at offset 4295397376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295401472 ++wrote 4096/4096 bytes at offset 4295401472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295405568 ++wrote 4096/4096 bytes at offset 4295405568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295409664 ++wrote 4096/4096 bytes at offset 4295409664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295413760 ++wrote 4096/4096 bytes at offset 4295413760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295417856 ++wrote 4096/4096 bytes at offset 4295417856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295421952 ++wrote 4096/4096 bytes at offset 4295421952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295426048 ++wrote 4096/4096 bytes at offset 4295426048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295430144 ++wrote 4096/4096 bytes at offset 4295430144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295434240 ++wrote 4096/4096 bytes at offset 4295434240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295438336 ++wrote 4096/4096 bytes at offset 4295438336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295442432 ++wrote 4096/4096 bytes at offset 4295442432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295446528 ++wrote 4096/4096 bytes at offset 4295446528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295450624 ++wrote 4096/4096 bytes at offset 4295450624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295454720 ++wrote 4096/4096 bytes at offset 4295454720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295458816 ++wrote 4096/4096 bytes at offset 4295458816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295462912 ++wrote 4096/4096 bytes at offset 4295462912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295467008 ++wrote 4096/4096 bytes at offset 4295467008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295471104 ++wrote 4096/4096 bytes at offset 4295471104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295475200 ++wrote 4096/4096 bytes at offset 4295475200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295479296 ++wrote 4096/4096 bytes at offset 4295479296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295483392 ++wrote 4096/4096 bytes at offset 4295483392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295487488 ++wrote 4096/4096 bytes at offset 4295487488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295491584 ++wrote 4096/4096 bytes at offset 4295491584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295495680 ++wrote 4096/4096 bytes at offset 4295495680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295499776 ++wrote 4096/4096 bytes at offset 4295499776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295503872 ++wrote 4096/4096 bytes at offset 4295503872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295507968 ++wrote 4096/4096 bytes at offset 4295507968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295512064 ++wrote 4096/4096 bytes at offset 4295512064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295516160 ++wrote 4096/4096 bytes at offset 4295516160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295520256 ++wrote 4096/4096 bytes at offset 4295520256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295524352 ++wrote 4096/4096 bytes at offset 4295524352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295528448 ++wrote 4096/4096 bytes at offset 4295528448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295532544 ++wrote 4096/4096 bytes at offset 4295532544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295536640 ++wrote 4096/4096 bytes at offset 4295536640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295540736 ++wrote 4096/4096 bytes at offset 4295540736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295544832 ++wrote 4096/4096 bytes at offset 4295544832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295548928 ++wrote 4096/4096 bytes at offset 4295548928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295553024 ++wrote 4096/4096 bytes at offset 4295553024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295557120 ++wrote 4096/4096 bytes at offset 4295557120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295561216 ++wrote 4096/4096 bytes at offset 4295561216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295565312 ++wrote 4096/4096 bytes at offset 4295565312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295569408 ++wrote 4096/4096 bytes at offset 4295569408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295573504 ++wrote 4096/4096 bytes at offset 4295573504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295577600 ++wrote 4096/4096 bytes at offset 4295577600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295581696 ++wrote 4096/4096 bytes at offset 4295581696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295585792 ++wrote 4096/4096 bytes at offset 4295585792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295589888 ++wrote 4096/4096 bytes at offset 4295589888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295593984 ++wrote 4096/4096 bytes at offset 4295593984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295598080 ++wrote 4096/4096 bytes at offset 4295598080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295602176 ++wrote 4096/4096 bytes at offset 4295602176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295606272 ++wrote 4096/4096 bytes at offset 4295606272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295610368 ++wrote 4096/4096 bytes at offset 4295610368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295614464 ++wrote 4096/4096 bytes at offset 4295614464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295618560 ++wrote 4096/4096 bytes at offset 4295618560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295622656 ++wrote 4096/4096 bytes at offset 4295622656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295626752 ++wrote 4096/4096 bytes at offset 4295626752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295630848 ++wrote 4096/4096 bytes at offset 4295630848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295634944 ++wrote 4096/4096 bytes at offset 4295634944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295639040 ++wrote 4096/4096 bytes at offset 4295639040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295643136 ++wrote 4096/4096 bytes at offset 4295643136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295647232 ++wrote 4096/4096 bytes at offset 4295647232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295651328 ++wrote 4096/4096 bytes at offset 4295651328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295655424 ++wrote 4096/4096 bytes at offset 4295655424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295659520 ++wrote 4096/4096 bytes at offset 4295659520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295663616 ++wrote 4096/4096 bytes at offset 4295663616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295667712 ++wrote 4096/4096 bytes at offset 4295667712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295671808 ++wrote 4096/4096 bytes at offset 4295671808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295675904 ++wrote 4096/4096 bytes at offset 4295675904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295680000 ++wrote 4096/4096 bytes at offset 4295680000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295684096 ++wrote 4096/4096 bytes at offset 4295684096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295688192 ++wrote 4096/4096 bytes at offset 4295688192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295692288 ++wrote 4096/4096 bytes at offset 4295692288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295696384 ++wrote 4096/4096 bytes at offset 4295696384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295700480 ++wrote 4096/4096 bytes at offset 4295700480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295704576 ++wrote 4096/4096 bytes at offset 4295704576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295708672 ++wrote 4096/4096 bytes at offset 4295708672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295712768 ++wrote 4096/4096 bytes at offset 4295712768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295716864 ++wrote 4096/4096 bytes at offset 4295716864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295720960 ++wrote 4096/4096 bytes at offset 4295720960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295725056 ++wrote 4096/4096 bytes at offset 4295725056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295729152 ++wrote 4096/4096 bytes at offset 4295729152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295733248 ++wrote 4096/4096 bytes at offset 4295733248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295737344 ++wrote 4096/4096 bytes at offset 4295737344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295741440 ++wrote 4096/4096 bytes at offset 4295741440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295745536 ++wrote 4096/4096 bytes at offset 4295745536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295749632 ++wrote 4096/4096 bytes at offset 4295749632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295753728 ++wrote 4096/4096 bytes at offset 4295753728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295757824 ++wrote 4096/4096 bytes at offset 4295757824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295761920 ++wrote 4096/4096 bytes at offset 4295761920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295766016 ++wrote 4096/4096 bytes at offset 4295766016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295770112 ++wrote 4096/4096 bytes at offset 4295770112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295774208 ++wrote 4096/4096 bytes at offset 4295774208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295778304 ++wrote 4096/4096 bytes at offset 4295778304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295782400 ++wrote 4096/4096 bytes at offset 4295782400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295786496 ++wrote 4096/4096 bytes at offset 4295786496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295790592 ++wrote 4096/4096 bytes at offset 4295790592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295794688 ++wrote 4096/4096 bytes at offset 4295794688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295798784 ++wrote 4096/4096 bytes at offset 4295798784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295802880 ++wrote 4096/4096 bytes at offset 4295802880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295806976 ++wrote 4096/4096 bytes at offset 4295806976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295811072 ++wrote 4096/4096 bytes at offset 4295811072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295815168 ++wrote 4096/4096 bytes at offset 4295815168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295819264 ++wrote 4096/4096 bytes at offset 4295819264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295823360 ++wrote 4096/4096 bytes at offset 4295823360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295827456 ++wrote 4096/4096 bytes at offset 4295827456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295831552 ++wrote 4096/4096 bytes at offset 4295831552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295835648 ++wrote 4096/4096 bytes at offset 4295835648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295839744 ++wrote 4096/4096 bytes at offset 4295839744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295843840 ++wrote 4096/4096 bytes at offset 4295843840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295847936 ++wrote 4096/4096 bytes at offset 4295847936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295852032 ++wrote 4096/4096 bytes at offset 4295852032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295856128 ++wrote 4096/4096 bytes at offset 4295856128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295860224 ++wrote 4096/4096 bytes at offset 4295860224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295864320 ++wrote 4096/4096 bytes at offset 4295864320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295868416 ++wrote 4096/4096 bytes at offset 4295868416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295872512 ++wrote 4096/4096 bytes at offset 4295872512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295876608 ++wrote 4096/4096 bytes at offset 4295876608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295880704 ++wrote 4096/4096 bytes at offset 4295880704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295884800 ++wrote 4096/4096 bytes at offset 4295884800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295888896 ++wrote 4096/4096 bytes at offset 4295888896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295892992 ++wrote 4096/4096 bytes at offset 4295892992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295897088 ++wrote 4096/4096 bytes at offset 4295897088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295901184 ++wrote 4096/4096 bytes at offset 4295901184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295905280 ++wrote 4096/4096 bytes at offset 4295905280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295909376 ++wrote 4096/4096 bytes at offset 4295909376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295913472 ++wrote 4096/4096 bytes at offset 4295913472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295917568 ++wrote 4096/4096 bytes at offset 4295917568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295921664 ++wrote 4096/4096 bytes at offset 4295921664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295925760 ++wrote 4096/4096 bytes at offset 4295925760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295929856 ++wrote 4096/4096 bytes at offset 4295929856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295933952 ++wrote 4096/4096 bytes at offset 4295933952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295938048 ++wrote 4096/4096 bytes at offset 4295938048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295942144 ++wrote 4096/4096 bytes at offset 4295942144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295946240 ++wrote 4096/4096 bytes at offset 4295946240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295950336 ++wrote 4096/4096 bytes at offset 4295950336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295954432 ++wrote 4096/4096 bytes at offset 4295954432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295958528 ++wrote 4096/4096 bytes at offset 4295958528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295962624 ++wrote 4096/4096 bytes at offset 4295962624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295966720 ++wrote 4096/4096 bytes at offset 4295966720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295970816 ++wrote 4096/4096 bytes at offset 4295970816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295974912 ++wrote 4096/4096 bytes at offset 4295974912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295979008 ++wrote 4096/4096 bytes at offset 4295979008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295983104 ++wrote 4096/4096 bytes at offset 4295983104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295987200 ++wrote 4096/4096 bytes at offset 4295987200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295991296 ++wrote 4096/4096 bytes at offset 4295991296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295995392 ++wrote 4096/4096 bytes at offset 4295995392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295999488 ++wrote 4096/4096 bytes at offset 4295999488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296003584 ++wrote 4096/4096 bytes at offset 4296003584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296007680 ++wrote 4096/4096 bytes at offset 4296007680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296011776 ++wrote 4096/4096 bytes at offset 4296011776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 4 +-qemu-io> wrote 2048/2048 bytes at offset 4296017920 ++=== IO: pattern 4 ++wrote 2048/2048 bytes at offset 4296017920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296022016 ++wrote 2048/2048 bytes at offset 4296022016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296026112 ++wrote 2048/2048 bytes at offset 4296026112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296030208 ++wrote 2048/2048 bytes at offset 4296030208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296034304 ++wrote 2048/2048 bytes at offset 4296034304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296038400 ++wrote 2048/2048 bytes at offset 4296038400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296042496 ++wrote 2048/2048 bytes at offset 4296042496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296046592 ++wrote 2048/2048 bytes at offset 4296046592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296050688 ++wrote 2048/2048 bytes at offset 4296050688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296054784 ++wrote 2048/2048 bytes at offset 4296054784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296058880 ++wrote 2048/2048 bytes at offset 4296058880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296062976 ++wrote 2048/2048 bytes at offset 4296062976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296067072 ++wrote 2048/2048 bytes at offset 4296067072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296071168 ++wrote 2048/2048 bytes at offset 4296071168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296075264 ++wrote 2048/2048 bytes at offset 4296075264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296079360 ++wrote 2048/2048 bytes at offset 4296079360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296083456 ++wrote 2048/2048 bytes at offset 4296083456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296087552 ++wrote 2048/2048 bytes at offset 4296087552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296091648 ++wrote 2048/2048 bytes at offset 4296091648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296095744 ++wrote 2048/2048 bytes at offset 4296095744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296099840 ++wrote 2048/2048 bytes at offset 4296099840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296103936 ++wrote 2048/2048 bytes at offset 4296103936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296108032 ++wrote 2048/2048 bytes at offset 4296108032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296112128 ++wrote 2048/2048 bytes at offset 4296112128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296116224 ++wrote 2048/2048 bytes at offset 4296116224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296120320 ++wrote 2048/2048 bytes at offset 4296120320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296124416 ++wrote 2048/2048 bytes at offset 4296124416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296128512 ++wrote 2048/2048 bytes at offset 4296128512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296132608 ++wrote 2048/2048 bytes at offset 4296132608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296136704 ++wrote 2048/2048 bytes at offset 4296136704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296140800 ++wrote 2048/2048 bytes at offset 4296140800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296144896 ++wrote 2048/2048 bytes at offset 4296144896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296148992 ++wrote 2048/2048 bytes at offset 4296148992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296153088 ++wrote 2048/2048 bytes at offset 4296153088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296157184 ++wrote 2048/2048 bytes at offset 4296157184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296161280 ++wrote 2048/2048 bytes at offset 4296161280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296165376 ++wrote 2048/2048 bytes at offset 4296165376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296169472 ++wrote 2048/2048 bytes at offset 4296169472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296173568 ++wrote 2048/2048 bytes at offset 4296173568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296177664 ++wrote 2048/2048 bytes at offset 4296177664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296181760 ++wrote 2048/2048 bytes at offset 4296181760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296185856 ++wrote 2048/2048 bytes at offset 4296185856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296189952 ++wrote 2048/2048 bytes at offset 4296189952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296194048 ++wrote 2048/2048 bytes at offset 4296194048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296198144 ++wrote 2048/2048 bytes at offset 4296198144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296202240 ++wrote 2048/2048 bytes at offset 4296202240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296206336 ++wrote 2048/2048 bytes at offset 4296206336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296210432 ++wrote 2048/2048 bytes at offset 4296210432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296214528 ++wrote 2048/2048 bytes at offset 4296214528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296218624 ++wrote 2048/2048 bytes at offset 4296218624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296222720 ++wrote 2048/2048 bytes at offset 4296222720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296226816 ++wrote 2048/2048 bytes at offset 4296226816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296230912 ++wrote 2048/2048 bytes at offset 4296230912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296235008 ++wrote 2048/2048 bytes at offset 4296235008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296239104 ++wrote 2048/2048 bytes at offset 4296239104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296243200 ++wrote 2048/2048 bytes at offset 4296243200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296247296 ++wrote 2048/2048 bytes at offset 4296247296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296251392 ++wrote 2048/2048 bytes at offset 4296251392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296255488 ++wrote 2048/2048 bytes at offset 4296255488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296259584 ++wrote 2048/2048 bytes at offset 4296259584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296263680 ++wrote 2048/2048 bytes at offset 4296263680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296267776 ++wrote 2048/2048 bytes at offset 4296267776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296271872 ++wrote 2048/2048 bytes at offset 4296271872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296275968 ++wrote 2048/2048 bytes at offset 4296275968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296280064 ++wrote 2048/2048 bytes at offset 4296280064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296284160 ++wrote 2048/2048 bytes at offset 4296284160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296288256 ++wrote 2048/2048 bytes at offset 4296288256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296292352 ++wrote 2048/2048 bytes at offset 4296292352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296296448 ++wrote 2048/2048 bytes at offset 4296296448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296300544 ++wrote 2048/2048 bytes at offset 4296300544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296304640 ++wrote 2048/2048 bytes at offset 4296304640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296308736 ++wrote 2048/2048 bytes at offset 4296308736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296312832 ++wrote 2048/2048 bytes at offset 4296312832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296316928 ++wrote 2048/2048 bytes at offset 4296316928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296321024 ++wrote 2048/2048 bytes at offset 4296321024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296325120 ++wrote 2048/2048 bytes at offset 4296325120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296329216 ++wrote 2048/2048 bytes at offset 4296329216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296333312 ++wrote 2048/2048 bytes at offset 4296333312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296337408 ++wrote 2048/2048 bytes at offset 4296337408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296341504 ++wrote 2048/2048 bytes at offset 4296341504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296345600 ++wrote 2048/2048 bytes at offset 4296345600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296349696 ++wrote 2048/2048 bytes at offset 4296349696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296353792 ++wrote 2048/2048 bytes at offset 4296353792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296357888 ++wrote 2048/2048 bytes at offset 4296357888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296361984 ++wrote 2048/2048 bytes at offset 4296361984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296366080 ++wrote 2048/2048 bytes at offset 4296366080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296370176 ++wrote 2048/2048 bytes at offset 4296370176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296374272 ++wrote 2048/2048 bytes at offset 4296374272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296378368 ++wrote 2048/2048 bytes at offset 4296378368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296382464 ++wrote 2048/2048 bytes at offset 4296382464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296386560 ++wrote 2048/2048 bytes at offset 4296386560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296390656 ++wrote 2048/2048 bytes at offset 4296390656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296394752 ++wrote 2048/2048 bytes at offset 4296394752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296398848 ++wrote 2048/2048 bytes at offset 4296398848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296402944 ++wrote 2048/2048 bytes at offset 4296402944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296407040 ++wrote 2048/2048 bytes at offset 4296407040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296411136 ++wrote 2048/2048 bytes at offset 4296411136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296415232 ++wrote 2048/2048 bytes at offset 4296415232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296419328 ++wrote 2048/2048 bytes at offset 4296419328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296423424 ++wrote 2048/2048 bytes at offset 4296423424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296427520 ++wrote 2048/2048 bytes at offset 4296427520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296431616 ++wrote 2048/2048 bytes at offset 4296431616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296435712 ++wrote 2048/2048 bytes at offset 4296435712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296439808 ++wrote 2048/2048 bytes at offset 4296439808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296443904 ++wrote 2048/2048 bytes at offset 4296443904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296448000 ++wrote 2048/2048 bytes at offset 4296448000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296452096 ++wrote 2048/2048 bytes at offset 4296452096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296456192 ++wrote 2048/2048 bytes at offset 4296456192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296460288 ++wrote 2048/2048 bytes at offset 4296460288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296464384 ++wrote 2048/2048 bytes at offset 4296464384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296468480 ++wrote 2048/2048 bytes at offset 4296468480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296472576 ++wrote 2048/2048 bytes at offset 4296472576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296476672 ++wrote 2048/2048 bytes at offset 4296476672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296480768 ++wrote 2048/2048 bytes at offset 4296480768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296484864 ++wrote 2048/2048 bytes at offset 4296484864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296488960 ++wrote 2048/2048 bytes at offset 4296488960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296493056 ++wrote 2048/2048 bytes at offset 4296493056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296497152 ++wrote 2048/2048 bytes at offset 4296497152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296501248 ++wrote 2048/2048 bytes at offset 4296501248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296505344 ++wrote 2048/2048 bytes at offset 4296505344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296509440 ++wrote 2048/2048 bytes at offset 4296509440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296513536 ++wrote 2048/2048 bytes at offset 4296513536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296517632 ++wrote 2048/2048 bytes at offset 4296517632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296521728 ++wrote 2048/2048 bytes at offset 4296521728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296525824 ++wrote 2048/2048 bytes at offset 4296525824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296529920 ++wrote 2048/2048 bytes at offset 4296529920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296534016 ++wrote 2048/2048 bytes at offset 4296534016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296538112 ++wrote 2048/2048 bytes at offset 4296538112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296542208 ++wrote 2048/2048 bytes at offset 4296542208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296546304 ++wrote 2048/2048 bytes at offset 4296546304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296550400 ++wrote 2048/2048 bytes at offset 4296550400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296554496 ++wrote 2048/2048 bytes at offset 4296554496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296558592 ++wrote 2048/2048 bytes at offset 4296558592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296562688 ++wrote 2048/2048 bytes at offset 4296562688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296566784 ++wrote 2048/2048 bytes at offset 4296566784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296570880 ++wrote 2048/2048 bytes at offset 4296570880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296574976 ++wrote 2048/2048 bytes at offset 4296574976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296579072 ++wrote 2048/2048 bytes at offset 4296579072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296583168 ++wrote 2048/2048 bytes at offset 4296583168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296587264 ++wrote 2048/2048 bytes at offset 4296587264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296591360 ++wrote 2048/2048 bytes at offset 4296591360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296595456 ++wrote 2048/2048 bytes at offset 4296595456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296599552 ++wrote 2048/2048 bytes at offset 4296599552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296603648 ++wrote 2048/2048 bytes at offset 4296603648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296607744 ++wrote 2048/2048 bytes at offset 4296607744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296611840 ++wrote 2048/2048 bytes at offset 4296611840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296615936 ++wrote 2048/2048 bytes at offset 4296615936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296620032 ++wrote 2048/2048 bytes at offset 4296620032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296624128 ++wrote 2048/2048 bytes at offset 4296624128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296628224 ++wrote 2048/2048 bytes at offset 4296628224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296632320 ++wrote 2048/2048 bytes at offset 4296632320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296636416 ++wrote 2048/2048 bytes at offset 4296636416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296640512 ++wrote 2048/2048 bytes at offset 4296640512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296644608 ++wrote 2048/2048 bytes at offset 4296644608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296648704 ++wrote 2048/2048 bytes at offset 4296648704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296652800 ++wrote 2048/2048 bytes at offset 4296652800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296656896 ++wrote 2048/2048 bytes at offset 4296656896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296660992 ++wrote 2048/2048 bytes at offset 4296660992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296665088 ++wrote 2048/2048 bytes at offset 4296665088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296669184 ++wrote 2048/2048 bytes at offset 4296669184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296673280 ++wrote 2048/2048 bytes at offset 4296673280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296677376 ++wrote 2048/2048 bytes at offset 4296677376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296681472 ++wrote 2048/2048 bytes at offset 4296681472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296685568 ++wrote 2048/2048 bytes at offset 4296685568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296689664 ++wrote 2048/2048 bytes at offset 4296689664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296693760 ++wrote 2048/2048 bytes at offset 4296693760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296697856 ++wrote 2048/2048 bytes at offset 4296697856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296701952 ++wrote 2048/2048 bytes at offset 4296701952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296706048 ++wrote 2048/2048 bytes at offset 4296706048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296710144 ++wrote 2048/2048 bytes at offset 4296710144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296714240 ++wrote 2048/2048 bytes at offset 4296714240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296718336 ++wrote 2048/2048 bytes at offset 4296718336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296722432 ++wrote 2048/2048 bytes at offset 4296722432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296726528 ++wrote 2048/2048 bytes at offset 4296726528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296730624 ++wrote 2048/2048 bytes at offset 4296730624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296734720 ++wrote 2048/2048 bytes at offset 4296734720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296738816 ++wrote 2048/2048 bytes at offset 4296738816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296742912 ++wrote 2048/2048 bytes at offset 4296742912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296747008 ++wrote 2048/2048 bytes at offset 4296747008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296751104 ++wrote 2048/2048 bytes at offset 4296751104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296755200 ++wrote 2048/2048 bytes at offset 4296755200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296759296 ++wrote 2048/2048 bytes at offset 4296759296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296763392 ++wrote 2048/2048 bytes at offset 4296763392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296767488 ++wrote 2048/2048 bytes at offset 4296767488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296771584 ++wrote 2048/2048 bytes at offset 4296771584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296775680 ++wrote 2048/2048 bytes at offset 4296775680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296779776 ++wrote 2048/2048 bytes at offset 4296779776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296783872 ++wrote 2048/2048 bytes at offset 4296783872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296787968 ++wrote 2048/2048 bytes at offset 4296787968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296792064 ++wrote 2048/2048 bytes at offset 4296792064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296796160 ++wrote 2048/2048 bytes at offset 4296796160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296800256 ++wrote 2048/2048 bytes at offset 4296800256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296804352 ++wrote 2048/2048 bytes at offset 4296804352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296808448 ++wrote 2048/2048 bytes at offset 4296808448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296812544 ++wrote 2048/2048 bytes at offset 4296812544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296816640 ++wrote 2048/2048 bytes at offset 4296816640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296820736 ++wrote 2048/2048 bytes at offset 4296820736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296824832 ++wrote 2048/2048 bytes at offset 4296824832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296828928 ++wrote 2048/2048 bytes at offset 4296828928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296833024 ++wrote 2048/2048 bytes at offset 4296833024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296837120 ++wrote 2048/2048 bytes at offset 4296837120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296841216 ++wrote 2048/2048 bytes at offset 4296841216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296845312 ++wrote 2048/2048 bytes at offset 4296845312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296849408 ++wrote 2048/2048 bytes at offset 4296849408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296853504 ++wrote 2048/2048 bytes at offset 4296853504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296857600 ++wrote 2048/2048 bytes at offset 4296857600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296861696 ++wrote 2048/2048 bytes at offset 4296861696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296865792 ++wrote 2048/2048 bytes at offset 4296865792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296869888 ++wrote 2048/2048 bytes at offset 4296869888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296873984 ++wrote 2048/2048 bytes at offset 4296873984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296878080 ++wrote 2048/2048 bytes at offset 4296878080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296882176 ++wrote 2048/2048 bytes at offset 4296882176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296886272 ++wrote 2048/2048 bytes at offset 4296886272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296890368 ++wrote 2048/2048 bytes at offset 4296890368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296894464 ++wrote 2048/2048 bytes at offset 4296894464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296898560 ++wrote 2048/2048 bytes at offset 4296898560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296902656 ++wrote 2048/2048 bytes at offset 4296902656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296906752 ++wrote 2048/2048 bytes at offset 4296906752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296910848 ++wrote 2048/2048 bytes at offset 4296910848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296914944 ++wrote 2048/2048 bytes at offset 4296914944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296919040 ++wrote 2048/2048 bytes at offset 4296919040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296923136 ++wrote 2048/2048 bytes at offset 4296923136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296927232 ++wrote 2048/2048 bytes at offset 4296927232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296931328 ++wrote 2048/2048 bytes at offset 4296931328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296935424 ++wrote 2048/2048 bytes at offset 4296935424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296939520 ++wrote 2048/2048 bytes at offset 4296939520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296943616 ++wrote 2048/2048 bytes at offset 4296943616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296947712 ++wrote 2048/2048 bytes at offset 4296947712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296951808 ++wrote 2048/2048 bytes at offset 4296951808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296955904 ++wrote 2048/2048 bytes at offset 4296955904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296960000 ++wrote 2048/2048 bytes at offset 4296960000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296964096 ++wrote 2048/2048 bytes at offset 4296964096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296968192 ++wrote 2048/2048 bytes at offset 4296968192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296972288 ++wrote 2048/2048 bytes at offset 4296972288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296976384 ++wrote 2048/2048 bytes at offset 4296976384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296980480 ++wrote 2048/2048 bytes at offset 4296980480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296984576 ++wrote 2048/2048 bytes at offset 4296984576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296988672 ++wrote 2048/2048 bytes at offset 4296988672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296992768 ++wrote 2048/2048 bytes at offset 4296992768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296996864 ++wrote 2048/2048 bytes at offset 4296996864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297000960 ++wrote 2048/2048 bytes at offset 4297000960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297005056 ++wrote 2048/2048 bytes at offset 4297005056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297009152 ++wrote 2048/2048 bytes at offset 4297009152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297013248 ++wrote 2048/2048 bytes at offset 4297013248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297017344 ++wrote 2048/2048 bytes at offset 4297017344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297021440 ++wrote 2048/2048 bytes at offset 4297021440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297025536 ++wrote 2048/2048 bytes at offset 4297025536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297029632 ++wrote 2048/2048 bytes at offset 4297029632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297033728 ++wrote 2048/2048 bytes at offset 4297033728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297037824 ++wrote 2048/2048 bytes at offset 4297037824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297041920 ++wrote 2048/2048 bytes at offset 4297041920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297046016 ++wrote 2048/2048 bytes at offset 4297046016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297050112 ++wrote 2048/2048 bytes at offset 4297050112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297054208 ++wrote 2048/2048 bytes at offset 4297054208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297058304 ++wrote 2048/2048 bytes at offset 4297058304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297062400 ++wrote 2048/2048 bytes at offset 4297062400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> wrote 2048/2048 bytes at offset 4297064448 ++=== IO: pattern 0 ++wrote 2048/2048 bytes at offset 4297064448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297068544 ++wrote 2048/2048 bytes at offset 4297068544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297072640 ++wrote 2048/2048 bytes at offset 4297072640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297076736 ++wrote 2048/2048 bytes at offset 4297076736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297080832 ++wrote 2048/2048 bytes at offset 4297080832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297084928 ++wrote 2048/2048 bytes at offset 4297084928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297089024 ++wrote 2048/2048 bytes at offset 4297089024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297093120 ++wrote 2048/2048 bytes at offset 4297093120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297097216 ++wrote 2048/2048 bytes at offset 4297097216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297101312 ++wrote 2048/2048 bytes at offset 4297101312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297105408 ++wrote 2048/2048 bytes at offset 4297105408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297109504 ++wrote 2048/2048 bytes at offset 4297109504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297113600 ++wrote 2048/2048 bytes at offset 4297113600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297117696 ++wrote 2048/2048 bytes at offset 4297117696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297121792 ++wrote 2048/2048 bytes at offset 4297121792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297125888 ++wrote 2048/2048 bytes at offset 4297125888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297129984 ++wrote 2048/2048 bytes at offset 4297129984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297134080 ++wrote 2048/2048 bytes at offset 4297134080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297138176 ++wrote 2048/2048 bytes at offset 4297138176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297142272 ++wrote 2048/2048 bytes at offset 4297142272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297146368 ++wrote 2048/2048 bytes at offset 4297146368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297150464 ++wrote 2048/2048 bytes at offset 4297150464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297154560 ++wrote 2048/2048 bytes at offset 4297154560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297158656 ++wrote 2048/2048 bytes at offset 4297158656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297162752 ++wrote 2048/2048 bytes at offset 4297162752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297166848 ++wrote 2048/2048 bytes at offset 4297166848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297170944 ++wrote 2048/2048 bytes at offset 4297170944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297175040 ++wrote 2048/2048 bytes at offset 4297175040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297179136 ++wrote 2048/2048 bytes at offset 4297179136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297183232 ++wrote 2048/2048 bytes at offset 4297183232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297187328 ++wrote 2048/2048 bytes at offset 4297187328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297191424 ++wrote 2048/2048 bytes at offset 4297191424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297195520 ++wrote 2048/2048 bytes at offset 4297195520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297199616 ++wrote 2048/2048 bytes at offset 4297199616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297203712 ++wrote 2048/2048 bytes at offset 4297203712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297207808 ++wrote 2048/2048 bytes at offset 4297207808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297211904 ++wrote 2048/2048 bytes at offset 4297211904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297216000 ++wrote 2048/2048 bytes at offset 4297216000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297220096 ++wrote 2048/2048 bytes at offset 4297220096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297224192 ++wrote 2048/2048 bytes at offset 4297224192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297228288 ++wrote 2048/2048 bytes at offset 4297228288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297232384 ++wrote 2048/2048 bytes at offset 4297232384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297236480 ++wrote 2048/2048 bytes at offset 4297236480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297240576 ++wrote 2048/2048 bytes at offset 4297240576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297244672 ++wrote 2048/2048 bytes at offset 4297244672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297248768 ++wrote 2048/2048 bytes at offset 4297248768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297252864 ++wrote 2048/2048 bytes at offset 4297252864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297256960 ++wrote 2048/2048 bytes at offset 4297256960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297261056 ++wrote 2048/2048 bytes at offset 4297261056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297265152 ++wrote 2048/2048 bytes at offset 4297265152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297269248 ++wrote 2048/2048 bytes at offset 4297269248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297273344 ++wrote 2048/2048 bytes at offset 4297273344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297277440 ++wrote 2048/2048 bytes at offset 4297277440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297281536 ++wrote 2048/2048 bytes at offset 4297281536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297285632 ++wrote 2048/2048 bytes at offset 4297285632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297289728 ++wrote 2048/2048 bytes at offset 4297289728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297293824 ++wrote 2048/2048 bytes at offset 4297293824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297297920 ++wrote 2048/2048 bytes at offset 4297297920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297302016 ++wrote 2048/2048 bytes at offset 4297302016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297306112 ++wrote 2048/2048 bytes at offset 4297306112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297310208 ++wrote 2048/2048 bytes at offset 4297310208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297314304 ++wrote 2048/2048 bytes at offset 4297314304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297318400 ++wrote 2048/2048 bytes at offset 4297318400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297322496 ++wrote 2048/2048 bytes at offset 4297322496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297326592 ++wrote 2048/2048 bytes at offset 4297326592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297330688 ++wrote 2048/2048 bytes at offset 4297330688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297334784 ++wrote 2048/2048 bytes at offset 4297334784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297338880 ++wrote 2048/2048 bytes at offset 4297338880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297342976 ++wrote 2048/2048 bytes at offset 4297342976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297347072 ++wrote 2048/2048 bytes at offset 4297347072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297351168 ++wrote 2048/2048 bytes at offset 4297351168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297355264 ++wrote 2048/2048 bytes at offset 4297355264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297359360 ++wrote 2048/2048 bytes at offset 4297359360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297363456 ++wrote 2048/2048 bytes at offset 4297363456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297367552 ++wrote 2048/2048 bytes at offset 4297367552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297371648 ++wrote 2048/2048 bytes at offset 4297371648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297375744 ++wrote 2048/2048 bytes at offset 4297375744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297379840 ++wrote 2048/2048 bytes at offset 4297379840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297383936 ++wrote 2048/2048 bytes at offset 4297383936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297388032 ++wrote 2048/2048 bytes at offset 4297388032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297392128 ++wrote 2048/2048 bytes at offset 4297392128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297396224 ++wrote 2048/2048 bytes at offset 4297396224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297400320 ++wrote 2048/2048 bytes at offset 4297400320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297404416 ++wrote 2048/2048 bytes at offset 4297404416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297408512 ++wrote 2048/2048 bytes at offset 4297408512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297412608 ++wrote 2048/2048 bytes at offset 4297412608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297416704 ++wrote 2048/2048 bytes at offset 4297416704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297420800 ++wrote 2048/2048 bytes at offset 4297420800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297424896 ++wrote 2048/2048 bytes at offset 4297424896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297428992 ++wrote 2048/2048 bytes at offset 4297428992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297433088 ++wrote 2048/2048 bytes at offset 4297433088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297437184 ++wrote 2048/2048 bytes at offset 4297437184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297441280 ++wrote 2048/2048 bytes at offset 4297441280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297445376 ++wrote 2048/2048 bytes at offset 4297445376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297449472 ++wrote 2048/2048 bytes at offset 4297449472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297453568 ++wrote 2048/2048 bytes at offset 4297453568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297457664 ++wrote 2048/2048 bytes at offset 4297457664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297461760 ++wrote 2048/2048 bytes at offset 4297461760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297465856 ++wrote 2048/2048 bytes at offset 4297465856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297469952 ++wrote 2048/2048 bytes at offset 4297469952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297474048 ++wrote 2048/2048 bytes at offset 4297474048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297478144 ++wrote 2048/2048 bytes at offset 4297478144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297482240 ++wrote 2048/2048 bytes at offset 4297482240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297486336 ++wrote 2048/2048 bytes at offset 4297486336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297490432 ++wrote 2048/2048 bytes at offset 4297490432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297494528 ++wrote 2048/2048 bytes at offset 4297494528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297498624 ++wrote 2048/2048 bytes at offset 4297498624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297502720 ++wrote 2048/2048 bytes at offset 4297502720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297506816 ++wrote 2048/2048 bytes at offset 4297506816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297510912 ++wrote 2048/2048 bytes at offset 4297510912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297515008 ++wrote 2048/2048 bytes at offset 4297515008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297519104 ++wrote 2048/2048 bytes at offset 4297519104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297523200 ++wrote 2048/2048 bytes at offset 4297523200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297527296 ++wrote 2048/2048 bytes at offset 4297527296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297531392 ++wrote 2048/2048 bytes at offset 4297531392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297535488 ++wrote 2048/2048 bytes at offset 4297535488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297539584 ++wrote 2048/2048 bytes at offset 4297539584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297543680 ++wrote 2048/2048 bytes at offset 4297543680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297547776 ++wrote 2048/2048 bytes at offset 4297547776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297551872 ++wrote 2048/2048 bytes at offset 4297551872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297555968 ++wrote 2048/2048 bytes at offset 4297555968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297560064 ++wrote 2048/2048 bytes at offset 4297560064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297564160 ++wrote 2048/2048 bytes at offset 4297564160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297568256 ++wrote 2048/2048 bytes at offset 4297568256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297572352 ++wrote 2048/2048 bytes at offset 4297572352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297576448 ++wrote 2048/2048 bytes at offset 4297576448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297580544 ++wrote 2048/2048 bytes at offset 4297580544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297584640 ++wrote 2048/2048 bytes at offset 4297584640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297588736 ++wrote 2048/2048 bytes at offset 4297588736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297592832 ++wrote 2048/2048 bytes at offset 4297592832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297596928 ++wrote 2048/2048 bytes at offset 4297596928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297601024 ++wrote 2048/2048 bytes at offset 4297601024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297605120 ++wrote 2048/2048 bytes at offset 4297605120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297609216 ++wrote 2048/2048 bytes at offset 4297609216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297613312 ++wrote 2048/2048 bytes at offset 4297613312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297617408 ++wrote 2048/2048 bytes at offset 4297617408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297621504 ++wrote 2048/2048 bytes at offset 4297621504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297625600 ++wrote 2048/2048 bytes at offset 4297625600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297629696 ++wrote 2048/2048 bytes at offset 4297629696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297633792 ++wrote 2048/2048 bytes at offset 4297633792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297637888 ++wrote 2048/2048 bytes at offset 4297637888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297641984 ++wrote 2048/2048 bytes at offset 4297641984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297646080 ++wrote 2048/2048 bytes at offset 4297646080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297650176 ++wrote 2048/2048 bytes at offset 4297650176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297654272 ++wrote 2048/2048 bytes at offset 4297654272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297658368 ++wrote 2048/2048 bytes at offset 4297658368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297662464 ++wrote 2048/2048 bytes at offset 4297662464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297666560 ++wrote 2048/2048 bytes at offset 4297666560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297670656 ++wrote 2048/2048 bytes at offset 4297670656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297674752 ++wrote 2048/2048 bytes at offset 4297674752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297678848 ++wrote 2048/2048 bytes at offset 4297678848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297682944 ++wrote 2048/2048 bytes at offset 4297682944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297687040 ++wrote 2048/2048 bytes at offset 4297687040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297691136 ++wrote 2048/2048 bytes at offset 4297691136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297695232 ++wrote 2048/2048 bytes at offset 4297695232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297699328 ++wrote 2048/2048 bytes at offset 4297699328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297703424 ++wrote 2048/2048 bytes at offset 4297703424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297707520 ++wrote 2048/2048 bytes at offset 4297707520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297711616 ++wrote 2048/2048 bytes at offset 4297711616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297715712 ++wrote 2048/2048 bytes at offset 4297715712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297719808 ++wrote 2048/2048 bytes at offset 4297719808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297723904 ++wrote 2048/2048 bytes at offset 4297723904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297728000 ++wrote 2048/2048 bytes at offset 4297728000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297732096 ++wrote 2048/2048 bytes at offset 4297732096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297736192 ++wrote 2048/2048 bytes at offset 4297736192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297740288 ++wrote 2048/2048 bytes at offset 4297740288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297744384 ++wrote 2048/2048 bytes at offset 4297744384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297748480 ++wrote 2048/2048 bytes at offset 4297748480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297752576 ++wrote 2048/2048 bytes at offset 4297752576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297756672 ++wrote 2048/2048 bytes at offset 4297756672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297760768 ++wrote 2048/2048 bytes at offset 4297760768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297764864 ++wrote 2048/2048 bytes at offset 4297764864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297768960 ++wrote 2048/2048 bytes at offset 4297768960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297773056 ++wrote 2048/2048 bytes at offset 4297773056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297777152 ++wrote 2048/2048 bytes at offset 4297777152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297781248 ++wrote 2048/2048 bytes at offset 4297781248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297785344 ++wrote 2048/2048 bytes at offset 4297785344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297789440 ++wrote 2048/2048 bytes at offset 4297789440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297793536 ++wrote 2048/2048 bytes at offset 4297793536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297797632 ++wrote 2048/2048 bytes at offset 4297797632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297801728 ++wrote 2048/2048 bytes at offset 4297801728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297805824 ++wrote 2048/2048 bytes at offset 4297805824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297809920 ++wrote 2048/2048 bytes at offset 4297809920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297814016 ++wrote 2048/2048 bytes at offset 4297814016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297818112 ++wrote 2048/2048 bytes at offset 4297818112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297822208 ++wrote 2048/2048 bytes at offset 4297822208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297826304 ++wrote 2048/2048 bytes at offset 4297826304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297830400 ++wrote 2048/2048 bytes at offset 4297830400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297834496 ++wrote 2048/2048 bytes at offset 4297834496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297838592 ++wrote 2048/2048 bytes at offset 4297838592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297842688 ++wrote 2048/2048 bytes at offset 4297842688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297846784 ++wrote 2048/2048 bytes at offset 4297846784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297850880 ++wrote 2048/2048 bytes at offset 4297850880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297854976 ++wrote 2048/2048 bytes at offset 4297854976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297859072 ++wrote 2048/2048 bytes at offset 4297859072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297863168 ++wrote 2048/2048 bytes at offset 4297863168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297867264 ++wrote 2048/2048 bytes at offset 4297867264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297871360 ++wrote 2048/2048 bytes at offset 4297871360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297875456 ++wrote 2048/2048 bytes at offset 4297875456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297879552 ++wrote 2048/2048 bytes at offset 4297879552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297883648 ++wrote 2048/2048 bytes at offset 4297883648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297887744 ++wrote 2048/2048 bytes at offset 4297887744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297891840 ++wrote 2048/2048 bytes at offset 4297891840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297895936 ++wrote 2048/2048 bytes at offset 4297895936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297900032 ++wrote 2048/2048 bytes at offset 4297900032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297904128 ++wrote 2048/2048 bytes at offset 4297904128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297908224 ++wrote 2048/2048 bytes at offset 4297908224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297912320 ++wrote 2048/2048 bytes at offset 4297912320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297916416 ++wrote 2048/2048 bytes at offset 4297916416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297920512 ++wrote 2048/2048 bytes at offset 4297920512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297924608 ++wrote 2048/2048 bytes at offset 4297924608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297928704 ++wrote 2048/2048 bytes at offset 4297928704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297932800 ++wrote 2048/2048 bytes at offset 4297932800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297936896 ++wrote 2048/2048 bytes at offset 4297936896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297940992 ++wrote 2048/2048 bytes at offset 4297940992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297945088 ++wrote 2048/2048 bytes at offset 4297945088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297949184 ++wrote 2048/2048 bytes at offset 4297949184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297953280 ++wrote 2048/2048 bytes at offset 4297953280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297957376 ++wrote 2048/2048 bytes at offset 4297957376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297961472 ++wrote 2048/2048 bytes at offset 4297961472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297965568 ++wrote 2048/2048 bytes at offset 4297965568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297969664 ++wrote 2048/2048 bytes at offset 4297969664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297973760 ++wrote 2048/2048 bytes at offset 4297973760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297977856 ++wrote 2048/2048 bytes at offset 4297977856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297981952 ++wrote 2048/2048 bytes at offset 4297981952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297986048 ++wrote 2048/2048 bytes at offset 4297986048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297990144 ++wrote 2048/2048 bytes at offset 4297990144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297994240 ++wrote 2048/2048 bytes at offset 4297994240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297998336 ++wrote 2048/2048 bytes at offset 4297998336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298002432 ++wrote 2048/2048 bytes at offset 4298002432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298006528 ++wrote 2048/2048 bytes at offset 4298006528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298010624 ++wrote 2048/2048 bytes at offset 4298010624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298014720 ++wrote 2048/2048 bytes at offset 4298014720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298018816 ++wrote 2048/2048 bytes at offset 4298018816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298022912 ++wrote 2048/2048 bytes at offset 4298022912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298027008 ++wrote 2048/2048 bytes at offset 4298027008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298031104 ++wrote 2048/2048 bytes at offset 4298031104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298035200 ++wrote 2048/2048 bytes at offset 4298035200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298039296 ++wrote 2048/2048 bytes at offset 4298039296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298043392 ++wrote 2048/2048 bytes at offset 4298043392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298047488 ++wrote 2048/2048 bytes at offset 4298047488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298051584 ++wrote 2048/2048 bytes at offset 4298051584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298055680 ++wrote 2048/2048 bytes at offset 4298055680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298059776 ++wrote 2048/2048 bytes at offset 4298059776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298063872 ++wrote 2048/2048 bytes at offset 4298063872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298067968 ++wrote 2048/2048 bytes at offset 4298067968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298072064 ++wrote 2048/2048 bytes at offset 4298072064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298076160 ++wrote 2048/2048 bytes at offset 4298076160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298080256 ++wrote 2048/2048 bytes at offset 4298080256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298084352 ++wrote 2048/2048 bytes at offset 4298084352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298088448 ++wrote 2048/2048 bytes at offset 4298088448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298092544 ++wrote 2048/2048 bytes at offset 4298092544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298096640 ++wrote 2048/2048 bytes at offset 4298096640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298100736 ++wrote 2048/2048 bytes at offset 4298100736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298104832 ++wrote 2048/2048 bytes at offset 4298104832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298108928 ++wrote 2048/2048 bytes at offset 4298108928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 2 +-qemu-io> wrote 2048/2048 bytes at offset 4298114048 ++=== IO: pattern 2 ++wrote 2048/2048 bytes at offset 4298114048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298118144 ++wrote 2048/2048 bytes at offset 4298118144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298122240 ++wrote 2048/2048 bytes at offset 4298122240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298126336 ++wrote 2048/2048 bytes at offset 4298126336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298130432 ++wrote 2048/2048 bytes at offset 4298130432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298134528 ++wrote 2048/2048 bytes at offset 4298134528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298138624 ++wrote 2048/2048 bytes at offset 4298138624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298142720 ++wrote 2048/2048 bytes at offset 4298142720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298146816 ++wrote 2048/2048 bytes at offset 4298146816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298150912 ++wrote 2048/2048 bytes at offset 4298150912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298155008 ++wrote 2048/2048 bytes at offset 4298155008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298159104 ++wrote 2048/2048 bytes at offset 4298159104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298163200 ++wrote 2048/2048 bytes at offset 4298163200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298167296 ++wrote 2048/2048 bytes at offset 4298167296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298171392 ++wrote 2048/2048 bytes at offset 4298171392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298175488 ++wrote 2048/2048 bytes at offset 4298175488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298179584 ++wrote 2048/2048 bytes at offset 4298179584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298183680 ++wrote 2048/2048 bytes at offset 4298183680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298187776 ++wrote 2048/2048 bytes at offset 4298187776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298191872 ++wrote 2048/2048 bytes at offset 4298191872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298195968 ++wrote 2048/2048 bytes at offset 4298195968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298200064 ++wrote 2048/2048 bytes at offset 4298200064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298204160 ++wrote 2048/2048 bytes at offset 4298204160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298208256 ++wrote 2048/2048 bytes at offset 4298208256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298212352 ++wrote 2048/2048 bytes at offset 4298212352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298216448 ++wrote 2048/2048 bytes at offset 4298216448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298220544 ++wrote 2048/2048 bytes at offset 4298220544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298224640 ++wrote 2048/2048 bytes at offset 4298224640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298228736 ++wrote 2048/2048 bytes at offset 4298228736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298232832 ++wrote 2048/2048 bytes at offset 4298232832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298236928 ++wrote 2048/2048 bytes at offset 4298236928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298241024 ++wrote 2048/2048 bytes at offset 4298241024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298245120 ++wrote 2048/2048 bytes at offset 4298245120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298249216 ++wrote 2048/2048 bytes at offset 4298249216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298253312 ++wrote 2048/2048 bytes at offset 4298253312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298257408 ++wrote 2048/2048 bytes at offset 4298257408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298261504 ++wrote 2048/2048 bytes at offset 4298261504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298265600 ++wrote 2048/2048 bytes at offset 4298265600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298269696 ++wrote 2048/2048 bytes at offset 4298269696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298273792 ++wrote 2048/2048 bytes at offset 4298273792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298277888 ++wrote 2048/2048 bytes at offset 4298277888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298281984 ++wrote 2048/2048 bytes at offset 4298281984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298286080 ++wrote 2048/2048 bytes at offset 4298286080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298290176 ++wrote 2048/2048 bytes at offset 4298290176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298294272 ++wrote 2048/2048 bytes at offset 4298294272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298298368 ++wrote 2048/2048 bytes at offset 4298298368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298302464 ++wrote 2048/2048 bytes at offset 4298302464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298306560 ++wrote 2048/2048 bytes at offset 4298306560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298310656 ++wrote 2048/2048 bytes at offset 4298310656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298314752 ++wrote 2048/2048 bytes at offset 4298314752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298318848 ++wrote 2048/2048 bytes at offset 4298318848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298322944 ++wrote 2048/2048 bytes at offset 4298322944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298327040 ++wrote 2048/2048 bytes at offset 4298327040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298331136 ++wrote 2048/2048 bytes at offset 4298331136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298335232 ++wrote 2048/2048 bytes at offset 4298335232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298339328 ++wrote 2048/2048 bytes at offset 4298339328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298343424 ++wrote 2048/2048 bytes at offset 4298343424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298347520 ++wrote 2048/2048 bytes at offset 4298347520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298351616 ++wrote 2048/2048 bytes at offset 4298351616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298355712 ++wrote 2048/2048 bytes at offset 4298355712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298359808 ++wrote 2048/2048 bytes at offset 4298359808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298363904 ++wrote 2048/2048 bytes at offset 4298363904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298368000 ++wrote 2048/2048 bytes at offset 4298368000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298372096 ++wrote 2048/2048 bytes at offset 4298372096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298376192 ++wrote 2048/2048 bytes at offset 4298376192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298380288 ++wrote 2048/2048 bytes at offset 4298380288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298384384 ++wrote 2048/2048 bytes at offset 4298384384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298388480 ++wrote 2048/2048 bytes at offset 4298388480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298392576 ++wrote 2048/2048 bytes at offset 4298392576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298396672 ++wrote 2048/2048 bytes at offset 4298396672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298400768 ++wrote 2048/2048 bytes at offset 4298400768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298404864 ++wrote 2048/2048 bytes at offset 4298404864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298408960 ++wrote 2048/2048 bytes at offset 4298408960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298413056 ++wrote 2048/2048 bytes at offset 4298413056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298417152 ++wrote 2048/2048 bytes at offset 4298417152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298421248 ++wrote 2048/2048 bytes at offset 4298421248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298425344 ++wrote 2048/2048 bytes at offset 4298425344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298429440 ++wrote 2048/2048 bytes at offset 4298429440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298433536 ++wrote 2048/2048 bytes at offset 4298433536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298437632 ++wrote 2048/2048 bytes at offset 4298437632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298441728 ++wrote 2048/2048 bytes at offset 4298441728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298445824 ++wrote 2048/2048 bytes at offset 4298445824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298449920 ++wrote 2048/2048 bytes at offset 4298449920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298454016 ++wrote 2048/2048 bytes at offset 4298454016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298458112 ++wrote 2048/2048 bytes at offset 4298458112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298462208 ++wrote 2048/2048 bytes at offset 4298462208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298466304 ++wrote 2048/2048 bytes at offset 4298466304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298470400 ++wrote 2048/2048 bytes at offset 4298470400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298474496 ++wrote 2048/2048 bytes at offset 4298474496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298478592 ++wrote 2048/2048 bytes at offset 4298478592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298482688 ++wrote 2048/2048 bytes at offset 4298482688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298486784 ++wrote 2048/2048 bytes at offset 4298486784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298490880 ++wrote 2048/2048 bytes at offset 4298490880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298494976 ++wrote 2048/2048 bytes at offset 4298494976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298499072 ++wrote 2048/2048 bytes at offset 4298499072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298503168 ++wrote 2048/2048 bytes at offset 4298503168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298507264 ++wrote 2048/2048 bytes at offset 4298507264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298511360 ++wrote 2048/2048 bytes at offset 4298511360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298515456 ++wrote 2048/2048 bytes at offset 4298515456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298519552 ++wrote 2048/2048 bytes at offset 4298519552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298523648 ++wrote 2048/2048 bytes at offset 4298523648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298527744 ++wrote 2048/2048 bytes at offset 4298527744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298531840 ++wrote 2048/2048 bytes at offset 4298531840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298535936 ++wrote 2048/2048 bytes at offset 4298535936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298540032 ++wrote 2048/2048 bytes at offset 4298540032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298544128 ++wrote 2048/2048 bytes at offset 4298544128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298548224 ++wrote 2048/2048 bytes at offset 4298548224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298552320 ++wrote 2048/2048 bytes at offset 4298552320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298556416 ++wrote 2048/2048 bytes at offset 4298556416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298560512 ++wrote 2048/2048 bytes at offset 4298560512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298564608 ++wrote 2048/2048 bytes at offset 4298564608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298568704 ++wrote 2048/2048 bytes at offset 4298568704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298572800 ++wrote 2048/2048 bytes at offset 4298572800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298576896 ++wrote 2048/2048 bytes at offset 4298576896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298580992 ++wrote 2048/2048 bytes at offset 4298580992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298585088 ++wrote 2048/2048 bytes at offset 4298585088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298589184 ++wrote 2048/2048 bytes at offset 4298589184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298593280 ++wrote 2048/2048 bytes at offset 4298593280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298597376 ++wrote 2048/2048 bytes at offset 4298597376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298601472 ++wrote 2048/2048 bytes at offset 4298601472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298605568 ++wrote 2048/2048 bytes at offset 4298605568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298609664 ++wrote 2048/2048 bytes at offset 4298609664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298613760 ++wrote 2048/2048 bytes at offset 4298613760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298617856 ++wrote 2048/2048 bytes at offset 4298617856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298621952 ++wrote 2048/2048 bytes at offset 4298621952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298626048 ++wrote 2048/2048 bytes at offset 4298626048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298630144 ++wrote 2048/2048 bytes at offset 4298630144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298634240 ++wrote 2048/2048 bytes at offset 4298634240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298638336 ++wrote 2048/2048 bytes at offset 4298638336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298642432 ++wrote 2048/2048 bytes at offset 4298642432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298646528 ++wrote 2048/2048 bytes at offset 4298646528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298650624 ++wrote 2048/2048 bytes at offset 4298650624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298654720 ++wrote 2048/2048 bytes at offset 4298654720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298658816 ++wrote 2048/2048 bytes at offset 4298658816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298662912 ++wrote 2048/2048 bytes at offset 4298662912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298667008 ++wrote 2048/2048 bytes at offset 4298667008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298671104 ++wrote 2048/2048 bytes at offset 4298671104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298675200 ++wrote 2048/2048 bytes at offset 4298675200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298679296 ++wrote 2048/2048 bytes at offset 4298679296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298683392 ++wrote 2048/2048 bytes at offset 4298683392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298687488 ++wrote 2048/2048 bytes at offset 4298687488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298691584 ++wrote 2048/2048 bytes at offset 4298691584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298695680 ++wrote 2048/2048 bytes at offset 4298695680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298699776 ++wrote 2048/2048 bytes at offset 4298699776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298703872 ++wrote 2048/2048 bytes at offset 4298703872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298707968 ++wrote 2048/2048 bytes at offset 4298707968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298712064 ++wrote 2048/2048 bytes at offset 4298712064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298716160 ++wrote 2048/2048 bytes at offset 4298716160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298720256 ++wrote 2048/2048 bytes at offset 4298720256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298724352 ++wrote 2048/2048 bytes at offset 4298724352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298728448 ++wrote 2048/2048 bytes at offset 4298728448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298732544 ++wrote 2048/2048 bytes at offset 4298732544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298736640 ++wrote 2048/2048 bytes at offset 4298736640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298740736 ++wrote 2048/2048 bytes at offset 4298740736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298744832 ++wrote 2048/2048 bytes at offset 4298744832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298748928 ++wrote 2048/2048 bytes at offset 4298748928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298753024 ++wrote 2048/2048 bytes at offset 4298753024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298757120 ++wrote 2048/2048 bytes at offset 4298757120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298761216 ++wrote 2048/2048 bytes at offset 4298761216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298765312 ++wrote 2048/2048 bytes at offset 4298765312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298769408 ++wrote 2048/2048 bytes at offset 4298769408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298773504 ++wrote 2048/2048 bytes at offset 4298773504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298777600 ++wrote 2048/2048 bytes at offset 4298777600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298781696 ++wrote 2048/2048 bytes at offset 4298781696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298785792 ++wrote 2048/2048 bytes at offset 4298785792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298789888 ++wrote 2048/2048 bytes at offset 4298789888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298793984 ++wrote 2048/2048 bytes at offset 4298793984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298798080 ++wrote 2048/2048 bytes at offset 4298798080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298802176 ++wrote 2048/2048 bytes at offset 4298802176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298806272 ++wrote 2048/2048 bytes at offset 4298806272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298810368 ++wrote 2048/2048 bytes at offset 4298810368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298814464 ++wrote 2048/2048 bytes at offset 4298814464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298818560 ++wrote 2048/2048 bytes at offset 4298818560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298822656 ++wrote 2048/2048 bytes at offset 4298822656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298826752 ++wrote 2048/2048 bytes at offset 4298826752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298830848 ++wrote 2048/2048 bytes at offset 4298830848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298834944 ++wrote 2048/2048 bytes at offset 4298834944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298839040 ++wrote 2048/2048 bytes at offset 4298839040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298843136 ++wrote 2048/2048 bytes at offset 4298843136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298847232 ++wrote 2048/2048 bytes at offset 4298847232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298851328 ++wrote 2048/2048 bytes at offset 4298851328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298855424 ++wrote 2048/2048 bytes at offset 4298855424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298859520 ++wrote 2048/2048 bytes at offset 4298859520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298863616 ++wrote 2048/2048 bytes at offset 4298863616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298867712 ++wrote 2048/2048 bytes at offset 4298867712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298871808 ++wrote 2048/2048 bytes at offset 4298871808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298875904 ++wrote 2048/2048 bytes at offset 4298875904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298880000 ++wrote 2048/2048 bytes at offset 4298880000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298884096 ++wrote 2048/2048 bytes at offset 4298884096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298888192 ++wrote 2048/2048 bytes at offset 4298888192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298892288 ++wrote 2048/2048 bytes at offset 4298892288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298896384 ++wrote 2048/2048 bytes at offset 4298896384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298900480 ++wrote 2048/2048 bytes at offset 4298900480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298904576 ++wrote 2048/2048 bytes at offset 4298904576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298908672 ++wrote 2048/2048 bytes at offset 4298908672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298912768 ++wrote 2048/2048 bytes at offset 4298912768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298916864 ++wrote 2048/2048 bytes at offset 4298916864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298920960 ++wrote 2048/2048 bytes at offset 4298920960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298925056 ++wrote 2048/2048 bytes at offset 4298925056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298929152 ++wrote 2048/2048 bytes at offset 4298929152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298933248 ++wrote 2048/2048 bytes at offset 4298933248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298937344 ++wrote 2048/2048 bytes at offset 4298937344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298941440 ++wrote 2048/2048 bytes at offset 4298941440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298945536 ++wrote 2048/2048 bytes at offset 4298945536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298949632 ++wrote 2048/2048 bytes at offset 4298949632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298953728 ++wrote 2048/2048 bytes at offset 4298953728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298957824 ++wrote 2048/2048 bytes at offset 4298957824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298961920 ++wrote 2048/2048 bytes at offset 4298961920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298966016 ++wrote 2048/2048 bytes at offset 4298966016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298970112 ++wrote 2048/2048 bytes at offset 4298970112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298974208 ++wrote 2048/2048 bytes at offset 4298974208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298978304 ++wrote 2048/2048 bytes at offset 4298978304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298982400 ++wrote 2048/2048 bytes at offset 4298982400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298986496 ++wrote 2048/2048 bytes at offset 4298986496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298990592 ++wrote 2048/2048 bytes at offset 4298990592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298994688 ++wrote 2048/2048 bytes at offset 4298994688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298998784 ++wrote 2048/2048 bytes at offset 4298998784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299002880 ++wrote 2048/2048 bytes at offset 4299002880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299006976 ++wrote 2048/2048 bytes at offset 4299006976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299011072 ++wrote 2048/2048 bytes at offset 4299011072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299015168 ++wrote 2048/2048 bytes at offset 4299015168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299019264 ++wrote 2048/2048 bytes at offset 4299019264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299023360 ++wrote 2048/2048 bytes at offset 4299023360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299027456 ++wrote 2048/2048 bytes at offset 4299027456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299031552 ++wrote 2048/2048 bytes at offset 4299031552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299035648 ++wrote 2048/2048 bytes at offset 4299035648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299039744 ++wrote 2048/2048 bytes at offset 4299039744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299043840 ++wrote 2048/2048 bytes at offset 4299043840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299047936 ++wrote 2048/2048 bytes at offset 4299047936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299052032 ++wrote 2048/2048 bytes at offset 4299052032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299056128 ++wrote 2048/2048 bytes at offset 4299056128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299060224 ++wrote 2048/2048 bytes at offset 4299060224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299064320 ++wrote 2048/2048 bytes at offset 4299064320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299068416 ++wrote 2048/2048 bytes at offset 4299068416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299072512 ++wrote 2048/2048 bytes at offset 4299072512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299076608 ++wrote 2048/2048 bytes at offset 4299076608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299080704 ++wrote 2048/2048 bytes at offset 4299080704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299084800 ++wrote 2048/2048 bytes at offset 4299084800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299088896 ++wrote 2048/2048 bytes at offset 4299088896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299092992 ++wrote 2048/2048 bytes at offset 4299092992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299097088 ++wrote 2048/2048 bytes at offset 4299097088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299101184 ++wrote 2048/2048 bytes at offset 4299101184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299105280 ++wrote 2048/2048 bytes at offset 4299105280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299109376 ++wrote 2048/2048 bytes at offset 4299109376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299113472 ++wrote 2048/2048 bytes at offset 4299113472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299117568 ++wrote 2048/2048 bytes at offset 4299117568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299121664 ++wrote 2048/2048 bytes at offset 4299121664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299125760 ++wrote 2048/2048 bytes at offset 4299125760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299129856 ++wrote 2048/2048 bytes at offset 4299129856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299133952 ++wrote 2048/2048 bytes at offset 4299133952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299138048 ++wrote 2048/2048 bytes at offset 4299138048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299142144 ++wrote 2048/2048 bytes at offset 4299142144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299146240 ++wrote 2048/2048 bytes at offset 4299146240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299150336 ++wrote 2048/2048 bytes at offset 4299150336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299154432 ++wrote 2048/2048 bytes at offset 4299154432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299158528 ++wrote 2048/2048 bytes at offset 4299158528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 4 +-qemu-io> wrote 8192/8192 bytes at offset 4299163648 ++=== IO: pattern 4 ++wrote 8192/8192 bytes at offset 4299163648 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299175936 ++wrote 8192/8192 bytes at offset 4299175936 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299188224 ++wrote 8192/8192 bytes at offset 4299188224 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299200512 ++wrote 8192/8192 bytes at offset 4299200512 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299212800 ++wrote 8192/8192 bytes at offset 4299212800 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299225088 ++wrote 8192/8192 bytes at offset 4299225088 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299237376 ++wrote 8192/8192 bytes at offset 4299237376 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299249664 ++wrote 8192/8192 bytes at offset 4299249664 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299261952 ++wrote 8192/8192 bytes at offset 4299261952 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299274240 ++wrote 8192/8192 bytes at offset 4299274240 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299286528 ++wrote 8192/8192 bytes at offset 4299286528 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299298816 ++wrote 8192/8192 bytes at offset 4299298816 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299311104 ++wrote 8192/8192 bytes at offset 4299311104 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299323392 ++wrote 8192/8192 bytes at offset 4299323392 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299335680 ++wrote 8192/8192 bytes at offset 4299335680 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299347968 ++wrote 8192/8192 bytes at offset 4299347968 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299360256 ++wrote 8192/8192 bytes at offset 4299360256 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299372544 ++wrote 8192/8192 bytes at offset 4299372544 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299384832 ++wrote 8192/8192 bytes at offset 4299384832 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299397120 ++wrote 8192/8192 bytes at offset 4299397120 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299409408 ++wrote 8192/8192 bytes at offset 4299409408 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299421696 ++wrote 8192/8192 bytes at offset 4299421696 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299433984 ++wrote 8192/8192 bytes at offset 4299433984 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299446272 ++wrote 8192/8192 bytes at offset 4299446272 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299458560 ++wrote 8192/8192 bytes at offset 4299458560 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299470848 ++wrote 8192/8192 bytes at offset 4299470848 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299483136 ++wrote 8192/8192 bytes at offset 4299483136 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299495424 ++wrote 8192/8192 bytes at offset 4299495424 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299507712 ++wrote 8192/8192 bytes at offset 4299507712 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299520000 ++wrote 8192/8192 bytes at offset 4299520000 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299532288 ++wrote 8192/8192 bytes at offset 4299532288 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299544576 ++wrote 8192/8192 bytes at offset 4299544576 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299556864 ++wrote 8192/8192 bytes at offset 4299556864 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299569152 ++wrote 8192/8192 bytes at offset 4299569152 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299581440 ++wrote 8192/8192 bytes at offset 4299581440 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299593728 ++wrote 8192/8192 bytes at offset 4299593728 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299606016 ++wrote 8192/8192 bytes at offset 4299606016 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299618304 ++wrote 8192/8192 bytes at offset 4299618304 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299630592 ++wrote 8192/8192 bytes at offset 4299630592 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299642880 ++wrote 8192/8192 bytes at offset 4299642880 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299655168 ++wrote 8192/8192 bytes at offset 4299655168 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299667456 ++wrote 8192/8192 bytes at offset 4299667456 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299679744 ++wrote 8192/8192 bytes at offset 4299679744 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299692032 ++wrote 8192/8192 bytes at offset 4299692032 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299704320 ++wrote 8192/8192 bytes at offset 4299704320 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299716608 ++wrote 8192/8192 bytes at offset 4299716608 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299728896 ++wrote 8192/8192 bytes at offset 4299728896 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299741184 ++wrote 8192/8192 bytes at offset 4299741184 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299753472 ++wrote 8192/8192 bytes at offset 4299753472 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299765760 ++wrote 8192/8192 bytes at offset 4299765760 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299778048 ++wrote 8192/8192 bytes at offset 4299778048 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299790336 ++wrote 8192/8192 bytes at offset 4299790336 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299802624 ++wrote 8192/8192 bytes at offset 4299802624 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299814912 ++wrote 8192/8192 bytes at offset 4299814912 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299827200 ++wrote 8192/8192 bytes at offset 4299827200 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299839488 ++wrote 8192/8192 bytes at offset 4299839488 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299851776 ++wrote 8192/8192 bytes at offset 4299851776 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299864064 ++wrote 8192/8192 bytes at offset 4299864064 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299876352 ++wrote 8192/8192 bytes at offset 4299876352 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299888640 ++wrote 8192/8192 bytes at offset 4299888640 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299900928 ++wrote 8192/8192 bytes at offset 4299900928 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299913216 ++wrote 8192/8192 bytes at offset 4299913216 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299925504 ++wrote 8192/8192 bytes at offset 4299925504 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299937792 ++wrote 8192/8192 bytes at offset 4299937792 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 244 +-qemu-io> wrote 12288/12288 bytes at offset 4301252608 ++=== IO: pattern 244 ++wrote 12288/12288 bytes at offset 4301252608 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 4303351808 ++wrote 12288/12288 bytes at offset 4303351808 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 4305451008 ++wrote 12288/12288 bytes at offset 4305451008 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 4307550208 ++wrote 12288/12288 bytes at offset 4307550208 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 4309649408 ++wrote 12288/12288 bytes at offset 4309649408 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 4311748608 ++wrote 12288/12288 bytes at offset 4311748608 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 4313847808 ++wrote 12288/12288 bytes at offset 4313847808 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 4315947008 ++wrote 12288/12288 bytes at offset 4315947008 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> read 4096/4096 bytes at offset 4294967296 ++=== IO: pattern 0 ++read 4096/4096 bytes at offset 4294967296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294971392 ++read 4096/4096 bytes at offset 4294971392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294975488 ++read 4096/4096 bytes at offset 4294975488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294979584 ++read 4096/4096 bytes at offset 4294979584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294983680 ++read 4096/4096 bytes at offset 4294983680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294987776 ++read 4096/4096 bytes at offset 4294987776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294991872 ++read 4096/4096 bytes at offset 4294991872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294995968 ++read 4096/4096 bytes at offset 4294995968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295000064 ++read 4096/4096 bytes at offset 4295000064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295004160 ++read 4096/4096 bytes at offset 4295004160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295008256 ++read 4096/4096 bytes at offset 4295008256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295012352 ++read 4096/4096 bytes at offset 4295012352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295016448 ++read 4096/4096 bytes at offset 4295016448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295020544 ++read 4096/4096 bytes at offset 4295020544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295024640 ++read 4096/4096 bytes at offset 4295024640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295028736 ++read 4096/4096 bytes at offset 4295028736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295032832 ++read 4096/4096 bytes at offset 4295032832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295036928 ++read 4096/4096 bytes at offset 4295036928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295041024 ++read 4096/4096 bytes at offset 4295041024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295045120 ++read 4096/4096 bytes at offset 4295045120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295049216 ++read 4096/4096 bytes at offset 4295049216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295053312 ++read 4096/4096 bytes at offset 4295053312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295057408 ++read 4096/4096 bytes at offset 4295057408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295061504 ++read 4096/4096 bytes at offset 4295061504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295065600 ++read 4096/4096 bytes at offset 4295065600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295069696 ++read 4096/4096 bytes at offset 4295069696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295073792 ++read 4096/4096 bytes at offset 4295073792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295077888 ++read 4096/4096 bytes at offset 4295077888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295081984 ++read 4096/4096 bytes at offset 4295081984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295086080 ++read 4096/4096 bytes at offset 4295086080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295090176 ++read 4096/4096 bytes at offset 4295090176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295094272 ++read 4096/4096 bytes at offset 4295094272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295098368 ++read 4096/4096 bytes at offset 4295098368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295102464 ++read 4096/4096 bytes at offset 4295102464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295106560 ++read 4096/4096 bytes at offset 4295106560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295110656 ++read 4096/4096 bytes at offset 4295110656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295114752 ++read 4096/4096 bytes at offset 4295114752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295118848 ++read 4096/4096 bytes at offset 4295118848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295122944 ++read 4096/4096 bytes at offset 4295122944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295127040 ++read 4096/4096 bytes at offset 4295127040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295131136 ++read 4096/4096 bytes at offset 4295131136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295135232 ++read 4096/4096 bytes at offset 4295135232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295139328 ++read 4096/4096 bytes at offset 4295139328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295143424 ++read 4096/4096 bytes at offset 4295143424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295147520 ++read 4096/4096 bytes at offset 4295147520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295151616 ++read 4096/4096 bytes at offset 4295151616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295155712 ++read 4096/4096 bytes at offset 4295155712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295159808 ++read 4096/4096 bytes at offset 4295159808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295163904 ++read 4096/4096 bytes at offset 4295163904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295168000 ++read 4096/4096 bytes at offset 4295168000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295172096 ++read 4096/4096 bytes at offset 4295172096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295176192 ++read 4096/4096 bytes at offset 4295176192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295180288 ++read 4096/4096 bytes at offset 4295180288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295184384 ++read 4096/4096 bytes at offset 4295184384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295188480 ++read 4096/4096 bytes at offset 4295188480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295192576 ++read 4096/4096 bytes at offset 4295192576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295196672 ++read 4096/4096 bytes at offset 4295196672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295200768 ++read 4096/4096 bytes at offset 4295200768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295204864 ++read 4096/4096 bytes at offset 4295204864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295208960 ++read 4096/4096 bytes at offset 4295208960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295213056 ++read 4096/4096 bytes at offset 4295213056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295217152 ++read 4096/4096 bytes at offset 4295217152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295221248 ++read 4096/4096 bytes at offset 4295221248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295225344 ++read 4096/4096 bytes at offset 4295225344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295229440 ++read 4096/4096 bytes at offset 4295229440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295233536 ++read 4096/4096 bytes at offset 4295233536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295237632 ++read 4096/4096 bytes at offset 4295237632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295241728 ++read 4096/4096 bytes at offset 4295241728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295245824 ++read 4096/4096 bytes at offset 4295245824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295249920 ++read 4096/4096 bytes at offset 4295249920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295254016 ++read 4096/4096 bytes at offset 4295254016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295258112 ++read 4096/4096 bytes at offset 4295258112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295262208 ++read 4096/4096 bytes at offset 4295262208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295266304 ++read 4096/4096 bytes at offset 4295266304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295270400 ++read 4096/4096 bytes at offset 4295270400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295274496 ++read 4096/4096 bytes at offset 4295274496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295278592 ++read 4096/4096 bytes at offset 4295278592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295282688 ++read 4096/4096 bytes at offset 4295282688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295286784 ++read 4096/4096 bytes at offset 4295286784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295290880 ++read 4096/4096 bytes at offset 4295290880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295294976 ++read 4096/4096 bytes at offset 4295294976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295299072 ++read 4096/4096 bytes at offset 4295299072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295303168 ++read 4096/4096 bytes at offset 4295303168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295307264 ++read 4096/4096 bytes at offset 4295307264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295311360 ++read 4096/4096 bytes at offset 4295311360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295315456 ++read 4096/4096 bytes at offset 4295315456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295319552 ++read 4096/4096 bytes at offset 4295319552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295323648 ++read 4096/4096 bytes at offset 4295323648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295327744 ++read 4096/4096 bytes at offset 4295327744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295331840 ++read 4096/4096 bytes at offset 4295331840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295335936 ++read 4096/4096 bytes at offset 4295335936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295340032 ++read 4096/4096 bytes at offset 4295340032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295344128 ++read 4096/4096 bytes at offset 4295344128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295348224 ++read 4096/4096 bytes at offset 4295348224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295352320 ++read 4096/4096 bytes at offset 4295352320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295356416 ++read 4096/4096 bytes at offset 4295356416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295360512 ++read 4096/4096 bytes at offset 4295360512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295364608 ++read 4096/4096 bytes at offset 4295364608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295368704 ++read 4096/4096 bytes at offset 4295368704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295372800 ++read 4096/4096 bytes at offset 4295372800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295376896 ++read 4096/4096 bytes at offset 4295376896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295380992 ++read 4096/4096 bytes at offset 4295380992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295385088 ++read 4096/4096 bytes at offset 4295385088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295389184 ++read 4096/4096 bytes at offset 4295389184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295393280 ++read 4096/4096 bytes at offset 4295393280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295397376 ++read 4096/4096 bytes at offset 4295397376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295401472 ++read 4096/4096 bytes at offset 4295401472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295405568 ++read 4096/4096 bytes at offset 4295405568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295409664 ++read 4096/4096 bytes at offset 4295409664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295413760 ++read 4096/4096 bytes at offset 4295413760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295417856 ++read 4096/4096 bytes at offset 4295417856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295421952 ++read 4096/4096 bytes at offset 4295421952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295426048 ++read 4096/4096 bytes at offset 4295426048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295430144 ++read 4096/4096 bytes at offset 4295430144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295434240 ++read 4096/4096 bytes at offset 4295434240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295438336 ++read 4096/4096 bytes at offset 4295438336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295442432 ++read 4096/4096 bytes at offset 4295442432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295446528 ++read 4096/4096 bytes at offset 4295446528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295450624 ++read 4096/4096 bytes at offset 4295450624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295454720 ++read 4096/4096 bytes at offset 4295454720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295458816 ++read 4096/4096 bytes at offset 4295458816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295462912 ++read 4096/4096 bytes at offset 4295462912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295467008 ++read 4096/4096 bytes at offset 4295467008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295471104 ++read 4096/4096 bytes at offset 4295471104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295475200 ++read 4096/4096 bytes at offset 4295475200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295479296 ++read 4096/4096 bytes at offset 4295479296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295483392 ++read 4096/4096 bytes at offset 4295483392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295487488 ++read 4096/4096 bytes at offset 4295487488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295491584 ++read 4096/4096 bytes at offset 4295491584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295495680 ++read 4096/4096 bytes at offset 4295495680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295499776 ++read 4096/4096 bytes at offset 4295499776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295503872 ++read 4096/4096 bytes at offset 4295503872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295507968 ++read 4096/4096 bytes at offset 4295507968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295512064 ++read 4096/4096 bytes at offset 4295512064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295516160 ++read 4096/4096 bytes at offset 4295516160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295520256 ++read 4096/4096 bytes at offset 4295520256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295524352 ++read 4096/4096 bytes at offset 4295524352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295528448 ++read 4096/4096 bytes at offset 4295528448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295532544 ++read 4096/4096 bytes at offset 4295532544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295536640 ++read 4096/4096 bytes at offset 4295536640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295540736 ++read 4096/4096 bytes at offset 4295540736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295544832 ++read 4096/4096 bytes at offset 4295544832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295548928 ++read 4096/4096 bytes at offset 4295548928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295553024 ++read 4096/4096 bytes at offset 4295553024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295557120 ++read 4096/4096 bytes at offset 4295557120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295561216 ++read 4096/4096 bytes at offset 4295561216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295565312 ++read 4096/4096 bytes at offset 4295565312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295569408 ++read 4096/4096 bytes at offset 4295569408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295573504 ++read 4096/4096 bytes at offset 4295573504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295577600 ++read 4096/4096 bytes at offset 4295577600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295581696 ++read 4096/4096 bytes at offset 4295581696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295585792 ++read 4096/4096 bytes at offset 4295585792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295589888 ++read 4096/4096 bytes at offset 4295589888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295593984 ++read 4096/4096 bytes at offset 4295593984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295598080 ++read 4096/4096 bytes at offset 4295598080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295602176 ++read 4096/4096 bytes at offset 4295602176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295606272 ++read 4096/4096 bytes at offset 4295606272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295610368 ++read 4096/4096 bytes at offset 4295610368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295614464 ++read 4096/4096 bytes at offset 4295614464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295618560 ++read 4096/4096 bytes at offset 4295618560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295622656 ++read 4096/4096 bytes at offset 4295622656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295626752 ++read 4096/4096 bytes at offset 4295626752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295630848 ++read 4096/4096 bytes at offset 4295630848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295634944 ++read 4096/4096 bytes at offset 4295634944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295639040 ++read 4096/4096 bytes at offset 4295639040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295643136 ++read 4096/4096 bytes at offset 4295643136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295647232 ++read 4096/4096 bytes at offset 4295647232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295651328 ++read 4096/4096 bytes at offset 4295651328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295655424 ++read 4096/4096 bytes at offset 4295655424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295659520 ++read 4096/4096 bytes at offset 4295659520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295663616 ++read 4096/4096 bytes at offset 4295663616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295667712 ++read 4096/4096 bytes at offset 4295667712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295671808 ++read 4096/4096 bytes at offset 4295671808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295675904 ++read 4096/4096 bytes at offset 4295675904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295680000 ++read 4096/4096 bytes at offset 4295680000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295684096 ++read 4096/4096 bytes at offset 4295684096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295688192 ++read 4096/4096 bytes at offset 4295688192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295692288 ++read 4096/4096 bytes at offset 4295692288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295696384 ++read 4096/4096 bytes at offset 4295696384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295700480 ++read 4096/4096 bytes at offset 4295700480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295704576 ++read 4096/4096 bytes at offset 4295704576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295708672 ++read 4096/4096 bytes at offset 4295708672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295712768 ++read 4096/4096 bytes at offset 4295712768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295716864 ++read 4096/4096 bytes at offset 4295716864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295720960 ++read 4096/4096 bytes at offset 4295720960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295725056 ++read 4096/4096 bytes at offset 4295725056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295729152 ++read 4096/4096 bytes at offset 4295729152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295733248 ++read 4096/4096 bytes at offset 4295733248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295737344 ++read 4096/4096 bytes at offset 4295737344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295741440 ++read 4096/4096 bytes at offset 4295741440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295745536 ++read 4096/4096 bytes at offset 4295745536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295749632 ++read 4096/4096 bytes at offset 4295749632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295753728 ++read 4096/4096 bytes at offset 4295753728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295757824 ++read 4096/4096 bytes at offset 4295757824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295761920 ++read 4096/4096 bytes at offset 4295761920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295766016 ++read 4096/4096 bytes at offset 4295766016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295770112 ++read 4096/4096 bytes at offset 4295770112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295774208 ++read 4096/4096 bytes at offset 4295774208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295778304 ++read 4096/4096 bytes at offset 4295778304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295782400 ++read 4096/4096 bytes at offset 4295782400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295786496 ++read 4096/4096 bytes at offset 4295786496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295790592 ++read 4096/4096 bytes at offset 4295790592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295794688 ++read 4096/4096 bytes at offset 4295794688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295798784 ++read 4096/4096 bytes at offset 4295798784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295802880 ++read 4096/4096 bytes at offset 4295802880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295806976 ++read 4096/4096 bytes at offset 4295806976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295811072 ++read 4096/4096 bytes at offset 4295811072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295815168 ++read 4096/4096 bytes at offset 4295815168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295819264 ++read 4096/4096 bytes at offset 4295819264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295823360 ++read 4096/4096 bytes at offset 4295823360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295827456 ++read 4096/4096 bytes at offset 4295827456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295831552 ++read 4096/4096 bytes at offset 4295831552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295835648 ++read 4096/4096 bytes at offset 4295835648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295839744 ++read 4096/4096 bytes at offset 4295839744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295843840 ++read 4096/4096 bytes at offset 4295843840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295847936 ++read 4096/4096 bytes at offset 4295847936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295852032 ++read 4096/4096 bytes at offset 4295852032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295856128 ++read 4096/4096 bytes at offset 4295856128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295860224 ++read 4096/4096 bytes at offset 4295860224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295864320 ++read 4096/4096 bytes at offset 4295864320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295868416 ++read 4096/4096 bytes at offset 4295868416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295872512 ++read 4096/4096 bytes at offset 4295872512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295876608 ++read 4096/4096 bytes at offset 4295876608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295880704 ++read 4096/4096 bytes at offset 4295880704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295884800 ++read 4096/4096 bytes at offset 4295884800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295888896 ++read 4096/4096 bytes at offset 4295888896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295892992 ++read 4096/4096 bytes at offset 4295892992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295897088 ++read 4096/4096 bytes at offset 4295897088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295901184 ++read 4096/4096 bytes at offset 4295901184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295905280 ++read 4096/4096 bytes at offset 4295905280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295909376 ++read 4096/4096 bytes at offset 4295909376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295913472 ++read 4096/4096 bytes at offset 4295913472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295917568 ++read 4096/4096 bytes at offset 4295917568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295921664 ++read 4096/4096 bytes at offset 4295921664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295925760 ++read 4096/4096 bytes at offset 4295925760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295929856 ++read 4096/4096 bytes at offset 4295929856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295933952 ++read 4096/4096 bytes at offset 4295933952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295938048 ++read 4096/4096 bytes at offset 4295938048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295942144 ++read 4096/4096 bytes at offset 4295942144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295946240 ++read 4096/4096 bytes at offset 4295946240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295950336 ++read 4096/4096 bytes at offset 4295950336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295954432 ++read 4096/4096 bytes at offset 4295954432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295958528 ++read 4096/4096 bytes at offset 4295958528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295962624 ++read 4096/4096 bytes at offset 4295962624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295966720 ++read 4096/4096 bytes at offset 4295966720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295970816 ++read 4096/4096 bytes at offset 4295970816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295974912 ++read 4096/4096 bytes at offset 4295974912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295979008 ++read 4096/4096 bytes at offset 4295979008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295983104 ++read 4096/4096 bytes at offset 4295983104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295987200 ++read 4096/4096 bytes at offset 4295987200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295991296 ++read 4096/4096 bytes at offset 4295991296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295995392 ++read 4096/4096 bytes at offset 4295995392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295999488 ++read 4096/4096 bytes at offset 4295999488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4296003584 ++read 4096/4096 bytes at offset 4296003584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4296007680 ++read 4096/4096 bytes at offset 4296007680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4296011776 ++read 4096/4096 bytes at offset 4296011776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 4 +-qemu-io> read 2048/2048 bytes at offset 4296017920 ++=== IO: pattern 4 ++read 2048/2048 bytes at offset 4296017920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296022016 ++read 2048/2048 bytes at offset 4296022016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296026112 ++read 2048/2048 bytes at offset 4296026112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296030208 ++read 2048/2048 bytes at offset 4296030208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296034304 ++read 2048/2048 bytes at offset 4296034304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296038400 ++read 2048/2048 bytes at offset 4296038400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296042496 ++read 2048/2048 bytes at offset 4296042496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296046592 ++read 2048/2048 bytes at offset 4296046592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296050688 ++read 2048/2048 bytes at offset 4296050688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296054784 ++read 2048/2048 bytes at offset 4296054784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296058880 ++read 2048/2048 bytes at offset 4296058880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296062976 ++read 2048/2048 bytes at offset 4296062976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296067072 ++read 2048/2048 bytes at offset 4296067072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296071168 ++read 2048/2048 bytes at offset 4296071168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296075264 ++read 2048/2048 bytes at offset 4296075264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296079360 ++read 2048/2048 bytes at offset 4296079360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296083456 ++read 2048/2048 bytes at offset 4296083456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296087552 ++read 2048/2048 bytes at offset 4296087552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296091648 ++read 2048/2048 bytes at offset 4296091648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296095744 ++read 2048/2048 bytes at offset 4296095744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296099840 ++read 2048/2048 bytes at offset 4296099840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296103936 ++read 2048/2048 bytes at offset 4296103936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296108032 ++read 2048/2048 bytes at offset 4296108032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296112128 ++read 2048/2048 bytes at offset 4296112128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296116224 ++read 2048/2048 bytes at offset 4296116224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296120320 ++read 2048/2048 bytes at offset 4296120320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296124416 ++read 2048/2048 bytes at offset 4296124416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296128512 ++read 2048/2048 bytes at offset 4296128512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296132608 ++read 2048/2048 bytes at offset 4296132608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296136704 ++read 2048/2048 bytes at offset 4296136704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296140800 ++read 2048/2048 bytes at offset 4296140800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296144896 ++read 2048/2048 bytes at offset 4296144896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296148992 ++read 2048/2048 bytes at offset 4296148992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296153088 ++read 2048/2048 bytes at offset 4296153088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296157184 ++read 2048/2048 bytes at offset 4296157184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296161280 ++read 2048/2048 bytes at offset 4296161280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296165376 ++read 2048/2048 bytes at offset 4296165376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296169472 ++read 2048/2048 bytes at offset 4296169472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296173568 ++read 2048/2048 bytes at offset 4296173568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296177664 ++read 2048/2048 bytes at offset 4296177664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296181760 ++read 2048/2048 bytes at offset 4296181760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296185856 ++read 2048/2048 bytes at offset 4296185856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296189952 ++read 2048/2048 bytes at offset 4296189952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296194048 ++read 2048/2048 bytes at offset 4296194048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296198144 ++read 2048/2048 bytes at offset 4296198144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296202240 ++read 2048/2048 bytes at offset 4296202240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296206336 ++read 2048/2048 bytes at offset 4296206336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296210432 ++read 2048/2048 bytes at offset 4296210432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296214528 ++read 2048/2048 bytes at offset 4296214528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296218624 ++read 2048/2048 bytes at offset 4296218624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296222720 ++read 2048/2048 bytes at offset 4296222720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296226816 ++read 2048/2048 bytes at offset 4296226816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296230912 ++read 2048/2048 bytes at offset 4296230912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296235008 ++read 2048/2048 bytes at offset 4296235008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296239104 ++read 2048/2048 bytes at offset 4296239104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296243200 ++read 2048/2048 bytes at offset 4296243200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296247296 ++read 2048/2048 bytes at offset 4296247296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296251392 ++read 2048/2048 bytes at offset 4296251392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296255488 ++read 2048/2048 bytes at offset 4296255488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296259584 ++read 2048/2048 bytes at offset 4296259584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296263680 ++read 2048/2048 bytes at offset 4296263680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296267776 ++read 2048/2048 bytes at offset 4296267776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296271872 ++read 2048/2048 bytes at offset 4296271872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296275968 ++read 2048/2048 bytes at offset 4296275968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296280064 ++read 2048/2048 bytes at offset 4296280064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296284160 ++read 2048/2048 bytes at offset 4296284160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296288256 ++read 2048/2048 bytes at offset 4296288256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296292352 ++read 2048/2048 bytes at offset 4296292352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296296448 ++read 2048/2048 bytes at offset 4296296448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296300544 ++read 2048/2048 bytes at offset 4296300544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296304640 ++read 2048/2048 bytes at offset 4296304640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296308736 ++read 2048/2048 bytes at offset 4296308736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296312832 ++read 2048/2048 bytes at offset 4296312832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296316928 ++read 2048/2048 bytes at offset 4296316928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296321024 ++read 2048/2048 bytes at offset 4296321024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296325120 ++read 2048/2048 bytes at offset 4296325120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296329216 ++read 2048/2048 bytes at offset 4296329216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296333312 ++read 2048/2048 bytes at offset 4296333312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296337408 ++read 2048/2048 bytes at offset 4296337408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296341504 ++read 2048/2048 bytes at offset 4296341504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296345600 ++read 2048/2048 bytes at offset 4296345600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296349696 ++read 2048/2048 bytes at offset 4296349696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296353792 ++read 2048/2048 bytes at offset 4296353792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296357888 ++read 2048/2048 bytes at offset 4296357888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296361984 ++read 2048/2048 bytes at offset 4296361984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296366080 ++read 2048/2048 bytes at offset 4296366080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296370176 ++read 2048/2048 bytes at offset 4296370176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296374272 ++read 2048/2048 bytes at offset 4296374272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296378368 ++read 2048/2048 bytes at offset 4296378368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296382464 ++read 2048/2048 bytes at offset 4296382464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296386560 ++read 2048/2048 bytes at offset 4296386560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296390656 ++read 2048/2048 bytes at offset 4296390656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296394752 ++read 2048/2048 bytes at offset 4296394752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296398848 ++read 2048/2048 bytes at offset 4296398848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296402944 ++read 2048/2048 bytes at offset 4296402944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296407040 ++read 2048/2048 bytes at offset 4296407040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296411136 ++read 2048/2048 bytes at offset 4296411136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296415232 ++read 2048/2048 bytes at offset 4296415232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296419328 ++read 2048/2048 bytes at offset 4296419328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296423424 ++read 2048/2048 bytes at offset 4296423424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296427520 ++read 2048/2048 bytes at offset 4296427520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296431616 ++read 2048/2048 bytes at offset 4296431616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296435712 ++read 2048/2048 bytes at offset 4296435712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296439808 ++read 2048/2048 bytes at offset 4296439808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296443904 ++read 2048/2048 bytes at offset 4296443904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296448000 ++read 2048/2048 bytes at offset 4296448000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296452096 ++read 2048/2048 bytes at offset 4296452096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296456192 ++read 2048/2048 bytes at offset 4296456192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296460288 ++read 2048/2048 bytes at offset 4296460288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296464384 ++read 2048/2048 bytes at offset 4296464384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296468480 ++read 2048/2048 bytes at offset 4296468480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296472576 ++read 2048/2048 bytes at offset 4296472576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296476672 ++read 2048/2048 bytes at offset 4296476672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296480768 ++read 2048/2048 bytes at offset 4296480768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296484864 ++read 2048/2048 bytes at offset 4296484864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296488960 ++read 2048/2048 bytes at offset 4296488960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296493056 ++read 2048/2048 bytes at offset 4296493056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296497152 ++read 2048/2048 bytes at offset 4296497152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296501248 ++read 2048/2048 bytes at offset 4296501248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296505344 ++read 2048/2048 bytes at offset 4296505344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296509440 ++read 2048/2048 bytes at offset 4296509440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296513536 ++read 2048/2048 bytes at offset 4296513536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296517632 ++read 2048/2048 bytes at offset 4296517632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296521728 ++read 2048/2048 bytes at offset 4296521728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296525824 ++read 2048/2048 bytes at offset 4296525824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296529920 ++read 2048/2048 bytes at offset 4296529920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296534016 ++read 2048/2048 bytes at offset 4296534016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296538112 ++read 2048/2048 bytes at offset 4296538112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296542208 ++read 2048/2048 bytes at offset 4296542208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296546304 ++read 2048/2048 bytes at offset 4296546304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296550400 ++read 2048/2048 bytes at offset 4296550400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296554496 ++read 2048/2048 bytes at offset 4296554496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296558592 ++read 2048/2048 bytes at offset 4296558592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296562688 ++read 2048/2048 bytes at offset 4296562688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296566784 ++read 2048/2048 bytes at offset 4296566784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296570880 ++read 2048/2048 bytes at offset 4296570880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296574976 ++read 2048/2048 bytes at offset 4296574976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296579072 ++read 2048/2048 bytes at offset 4296579072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296583168 ++read 2048/2048 bytes at offset 4296583168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296587264 ++read 2048/2048 bytes at offset 4296587264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296591360 ++read 2048/2048 bytes at offset 4296591360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296595456 ++read 2048/2048 bytes at offset 4296595456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296599552 ++read 2048/2048 bytes at offset 4296599552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296603648 ++read 2048/2048 bytes at offset 4296603648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296607744 ++read 2048/2048 bytes at offset 4296607744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296611840 ++read 2048/2048 bytes at offset 4296611840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296615936 ++read 2048/2048 bytes at offset 4296615936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296620032 ++read 2048/2048 bytes at offset 4296620032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296624128 ++read 2048/2048 bytes at offset 4296624128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296628224 ++read 2048/2048 bytes at offset 4296628224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296632320 ++read 2048/2048 bytes at offset 4296632320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296636416 ++read 2048/2048 bytes at offset 4296636416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296640512 ++read 2048/2048 bytes at offset 4296640512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296644608 ++read 2048/2048 bytes at offset 4296644608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296648704 ++read 2048/2048 bytes at offset 4296648704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296652800 ++read 2048/2048 bytes at offset 4296652800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296656896 ++read 2048/2048 bytes at offset 4296656896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296660992 ++read 2048/2048 bytes at offset 4296660992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296665088 ++read 2048/2048 bytes at offset 4296665088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296669184 ++read 2048/2048 bytes at offset 4296669184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296673280 ++read 2048/2048 bytes at offset 4296673280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296677376 ++read 2048/2048 bytes at offset 4296677376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296681472 ++read 2048/2048 bytes at offset 4296681472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296685568 ++read 2048/2048 bytes at offset 4296685568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296689664 ++read 2048/2048 bytes at offset 4296689664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296693760 ++read 2048/2048 bytes at offset 4296693760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296697856 ++read 2048/2048 bytes at offset 4296697856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296701952 ++read 2048/2048 bytes at offset 4296701952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296706048 ++read 2048/2048 bytes at offset 4296706048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296710144 ++read 2048/2048 bytes at offset 4296710144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296714240 ++read 2048/2048 bytes at offset 4296714240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296718336 ++read 2048/2048 bytes at offset 4296718336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296722432 ++read 2048/2048 bytes at offset 4296722432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296726528 ++read 2048/2048 bytes at offset 4296726528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296730624 ++read 2048/2048 bytes at offset 4296730624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296734720 ++read 2048/2048 bytes at offset 4296734720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296738816 ++read 2048/2048 bytes at offset 4296738816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296742912 ++read 2048/2048 bytes at offset 4296742912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296747008 ++read 2048/2048 bytes at offset 4296747008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296751104 ++read 2048/2048 bytes at offset 4296751104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296755200 ++read 2048/2048 bytes at offset 4296755200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296759296 ++read 2048/2048 bytes at offset 4296759296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296763392 ++read 2048/2048 bytes at offset 4296763392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296767488 ++read 2048/2048 bytes at offset 4296767488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296771584 ++read 2048/2048 bytes at offset 4296771584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296775680 ++read 2048/2048 bytes at offset 4296775680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296779776 ++read 2048/2048 bytes at offset 4296779776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296783872 ++read 2048/2048 bytes at offset 4296783872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296787968 ++read 2048/2048 bytes at offset 4296787968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296792064 ++read 2048/2048 bytes at offset 4296792064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296796160 ++read 2048/2048 bytes at offset 4296796160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296800256 ++read 2048/2048 bytes at offset 4296800256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296804352 ++read 2048/2048 bytes at offset 4296804352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296808448 ++read 2048/2048 bytes at offset 4296808448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296812544 ++read 2048/2048 bytes at offset 4296812544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296816640 ++read 2048/2048 bytes at offset 4296816640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296820736 ++read 2048/2048 bytes at offset 4296820736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296824832 ++read 2048/2048 bytes at offset 4296824832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296828928 ++read 2048/2048 bytes at offset 4296828928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296833024 ++read 2048/2048 bytes at offset 4296833024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296837120 ++read 2048/2048 bytes at offset 4296837120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296841216 ++read 2048/2048 bytes at offset 4296841216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296845312 ++read 2048/2048 bytes at offset 4296845312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296849408 ++read 2048/2048 bytes at offset 4296849408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296853504 ++read 2048/2048 bytes at offset 4296853504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296857600 ++read 2048/2048 bytes at offset 4296857600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296861696 ++read 2048/2048 bytes at offset 4296861696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296865792 ++read 2048/2048 bytes at offset 4296865792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296869888 ++read 2048/2048 bytes at offset 4296869888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296873984 ++read 2048/2048 bytes at offset 4296873984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296878080 ++read 2048/2048 bytes at offset 4296878080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296882176 ++read 2048/2048 bytes at offset 4296882176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296886272 ++read 2048/2048 bytes at offset 4296886272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296890368 ++read 2048/2048 bytes at offset 4296890368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296894464 ++read 2048/2048 bytes at offset 4296894464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296898560 ++read 2048/2048 bytes at offset 4296898560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296902656 ++read 2048/2048 bytes at offset 4296902656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296906752 ++read 2048/2048 bytes at offset 4296906752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296910848 ++read 2048/2048 bytes at offset 4296910848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296914944 ++read 2048/2048 bytes at offset 4296914944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296919040 ++read 2048/2048 bytes at offset 4296919040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296923136 ++read 2048/2048 bytes at offset 4296923136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296927232 ++read 2048/2048 bytes at offset 4296927232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296931328 ++read 2048/2048 bytes at offset 4296931328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296935424 ++read 2048/2048 bytes at offset 4296935424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296939520 ++read 2048/2048 bytes at offset 4296939520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296943616 ++read 2048/2048 bytes at offset 4296943616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296947712 ++read 2048/2048 bytes at offset 4296947712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296951808 ++read 2048/2048 bytes at offset 4296951808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296955904 ++read 2048/2048 bytes at offset 4296955904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296960000 ++read 2048/2048 bytes at offset 4296960000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296964096 ++read 2048/2048 bytes at offset 4296964096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296968192 ++read 2048/2048 bytes at offset 4296968192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296972288 ++read 2048/2048 bytes at offset 4296972288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296976384 ++read 2048/2048 bytes at offset 4296976384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296980480 ++read 2048/2048 bytes at offset 4296980480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296984576 ++read 2048/2048 bytes at offset 4296984576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296988672 ++read 2048/2048 bytes at offset 4296988672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296992768 ++read 2048/2048 bytes at offset 4296992768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296996864 ++read 2048/2048 bytes at offset 4296996864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297000960 ++read 2048/2048 bytes at offset 4297000960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297005056 ++read 2048/2048 bytes at offset 4297005056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297009152 ++read 2048/2048 bytes at offset 4297009152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297013248 ++read 2048/2048 bytes at offset 4297013248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297017344 ++read 2048/2048 bytes at offset 4297017344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297021440 ++read 2048/2048 bytes at offset 4297021440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297025536 ++read 2048/2048 bytes at offset 4297025536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297029632 ++read 2048/2048 bytes at offset 4297029632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297033728 ++read 2048/2048 bytes at offset 4297033728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297037824 ++read 2048/2048 bytes at offset 4297037824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297041920 ++read 2048/2048 bytes at offset 4297041920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297046016 ++read 2048/2048 bytes at offset 4297046016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297050112 ++read 2048/2048 bytes at offset 4297050112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297054208 ++read 2048/2048 bytes at offset 4297054208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297058304 ++read 2048/2048 bytes at offset 4297058304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297062400 ++read 2048/2048 bytes at offset 4297062400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> read 2048/2048 bytes at offset 4297064448 ++=== IO: pattern 0 ++read 2048/2048 bytes at offset 4297064448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297068544 ++read 2048/2048 bytes at offset 4297068544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297072640 ++read 2048/2048 bytes at offset 4297072640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297076736 ++read 2048/2048 bytes at offset 4297076736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297080832 ++read 2048/2048 bytes at offset 4297080832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297084928 ++read 2048/2048 bytes at offset 4297084928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297089024 ++read 2048/2048 bytes at offset 4297089024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297093120 ++read 2048/2048 bytes at offset 4297093120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297097216 ++read 2048/2048 bytes at offset 4297097216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297101312 ++read 2048/2048 bytes at offset 4297101312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297105408 ++read 2048/2048 bytes at offset 4297105408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297109504 ++read 2048/2048 bytes at offset 4297109504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297113600 ++read 2048/2048 bytes at offset 4297113600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297117696 ++read 2048/2048 bytes at offset 4297117696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297121792 ++read 2048/2048 bytes at offset 4297121792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297125888 ++read 2048/2048 bytes at offset 4297125888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297129984 ++read 2048/2048 bytes at offset 4297129984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297134080 ++read 2048/2048 bytes at offset 4297134080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297138176 ++read 2048/2048 bytes at offset 4297138176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297142272 ++read 2048/2048 bytes at offset 4297142272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297146368 ++read 2048/2048 bytes at offset 4297146368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297150464 ++read 2048/2048 bytes at offset 4297150464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297154560 ++read 2048/2048 bytes at offset 4297154560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297158656 ++read 2048/2048 bytes at offset 4297158656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297162752 ++read 2048/2048 bytes at offset 4297162752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297166848 ++read 2048/2048 bytes at offset 4297166848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297170944 ++read 2048/2048 bytes at offset 4297170944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297175040 ++read 2048/2048 bytes at offset 4297175040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297179136 ++read 2048/2048 bytes at offset 4297179136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297183232 ++read 2048/2048 bytes at offset 4297183232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297187328 ++read 2048/2048 bytes at offset 4297187328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297191424 ++read 2048/2048 bytes at offset 4297191424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297195520 ++read 2048/2048 bytes at offset 4297195520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297199616 ++read 2048/2048 bytes at offset 4297199616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297203712 ++read 2048/2048 bytes at offset 4297203712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297207808 ++read 2048/2048 bytes at offset 4297207808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297211904 ++read 2048/2048 bytes at offset 4297211904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297216000 ++read 2048/2048 bytes at offset 4297216000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297220096 ++read 2048/2048 bytes at offset 4297220096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297224192 ++read 2048/2048 bytes at offset 4297224192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297228288 ++read 2048/2048 bytes at offset 4297228288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297232384 ++read 2048/2048 bytes at offset 4297232384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297236480 ++read 2048/2048 bytes at offset 4297236480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297240576 ++read 2048/2048 bytes at offset 4297240576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297244672 ++read 2048/2048 bytes at offset 4297244672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297248768 ++read 2048/2048 bytes at offset 4297248768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297252864 ++read 2048/2048 bytes at offset 4297252864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297256960 ++read 2048/2048 bytes at offset 4297256960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297261056 ++read 2048/2048 bytes at offset 4297261056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297265152 ++read 2048/2048 bytes at offset 4297265152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297269248 ++read 2048/2048 bytes at offset 4297269248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297273344 ++read 2048/2048 bytes at offset 4297273344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297277440 ++read 2048/2048 bytes at offset 4297277440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297281536 ++read 2048/2048 bytes at offset 4297281536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297285632 ++read 2048/2048 bytes at offset 4297285632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297289728 ++read 2048/2048 bytes at offset 4297289728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297293824 ++read 2048/2048 bytes at offset 4297293824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297297920 ++read 2048/2048 bytes at offset 4297297920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297302016 ++read 2048/2048 bytes at offset 4297302016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297306112 ++read 2048/2048 bytes at offset 4297306112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297310208 ++read 2048/2048 bytes at offset 4297310208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297314304 ++read 2048/2048 bytes at offset 4297314304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297318400 ++read 2048/2048 bytes at offset 4297318400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297322496 ++read 2048/2048 bytes at offset 4297322496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297326592 ++read 2048/2048 bytes at offset 4297326592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297330688 ++read 2048/2048 bytes at offset 4297330688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297334784 ++read 2048/2048 bytes at offset 4297334784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297338880 ++read 2048/2048 bytes at offset 4297338880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297342976 ++read 2048/2048 bytes at offset 4297342976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297347072 ++read 2048/2048 bytes at offset 4297347072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297351168 ++read 2048/2048 bytes at offset 4297351168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297355264 ++read 2048/2048 bytes at offset 4297355264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297359360 ++read 2048/2048 bytes at offset 4297359360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297363456 ++read 2048/2048 bytes at offset 4297363456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297367552 ++read 2048/2048 bytes at offset 4297367552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297371648 ++read 2048/2048 bytes at offset 4297371648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297375744 ++read 2048/2048 bytes at offset 4297375744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297379840 ++read 2048/2048 bytes at offset 4297379840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297383936 ++read 2048/2048 bytes at offset 4297383936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297388032 ++read 2048/2048 bytes at offset 4297388032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297392128 ++read 2048/2048 bytes at offset 4297392128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297396224 ++read 2048/2048 bytes at offset 4297396224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297400320 ++read 2048/2048 bytes at offset 4297400320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297404416 ++read 2048/2048 bytes at offset 4297404416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297408512 ++read 2048/2048 bytes at offset 4297408512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297412608 ++read 2048/2048 bytes at offset 4297412608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297416704 ++read 2048/2048 bytes at offset 4297416704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297420800 ++read 2048/2048 bytes at offset 4297420800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297424896 ++read 2048/2048 bytes at offset 4297424896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297428992 ++read 2048/2048 bytes at offset 4297428992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297433088 ++read 2048/2048 bytes at offset 4297433088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297437184 ++read 2048/2048 bytes at offset 4297437184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297441280 ++read 2048/2048 bytes at offset 4297441280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297445376 ++read 2048/2048 bytes at offset 4297445376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297449472 ++read 2048/2048 bytes at offset 4297449472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297453568 ++read 2048/2048 bytes at offset 4297453568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297457664 ++read 2048/2048 bytes at offset 4297457664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297461760 ++read 2048/2048 bytes at offset 4297461760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297465856 ++read 2048/2048 bytes at offset 4297465856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297469952 ++read 2048/2048 bytes at offset 4297469952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297474048 ++read 2048/2048 bytes at offset 4297474048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297478144 ++read 2048/2048 bytes at offset 4297478144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297482240 ++read 2048/2048 bytes at offset 4297482240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297486336 ++read 2048/2048 bytes at offset 4297486336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297490432 ++read 2048/2048 bytes at offset 4297490432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297494528 ++read 2048/2048 bytes at offset 4297494528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297498624 ++read 2048/2048 bytes at offset 4297498624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297502720 ++read 2048/2048 bytes at offset 4297502720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297506816 ++read 2048/2048 bytes at offset 4297506816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297510912 ++read 2048/2048 bytes at offset 4297510912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297515008 ++read 2048/2048 bytes at offset 4297515008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297519104 ++read 2048/2048 bytes at offset 4297519104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297523200 ++read 2048/2048 bytes at offset 4297523200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297527296 ++read 2048/2048 bytes at offset 4297527296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297531392 ++read 2048/2048 bytes at offset 4297531392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297535488 ++read 2048/2048 bytes at offset 4297535488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297539584 ++read 2048/2048 bytes at offset 4297539584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297543680 ++read 2048/2048 bytes at offset 4297543680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297547776 ++read 2048/2048 bytes at offset 4297547776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297551872 ++read 2048/2048 bytes at offset 4297551872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297555968 ++read 2048/2048 bytes at offset 4297555968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297560064 ++read 2048/2048 bytes at offset 4297560064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297564160 ++read 2048/2048 bytes at offset 4297564160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297568256 ++read 2048/2048 bytes at offset 4297568256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297572352 ++read 2048/2048 bytes at offset 4297572352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297576448 ++read 2048/2048 bytes at offset 4297576448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297580544 ++read 2048/2048 bytes at offset 4297580544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297584640 ++read 2048/2048 bytes at offset 4297584640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297588736 ++read 2048/2048 bytes at offset 4297588736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297592832 ++read 2048/2048 bytes at offset 4297592832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297596928 ++read 2048/2048 bytes at offset 4297596928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297601024 ++read 2048/2048 bytes at offset 4297601024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297605120 ++read 2048/2048 bytes at offset 4297605120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297609216 ++read 2048/2048 bytes at offset 4297609216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297613312 ++read 2048/2048 bytes at offset 4297613312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297617408 ++read 2048/2048 bytes at offset 4297617408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297621504 ++read 2048/2048 bytes at offset 4297621504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297625600 ++read 2048/2048 bytes at offset 4297625600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297629696 ++read 2048/2048 bytes at offset 4297629696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297633792 ++read 2048/2048 bytes at offset 4297633792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297637888 ++read 2048/2048 bytes at offset 4297637888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297641984 ++read 2048/2048 bytes at offset 4297641984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297646080 ++read 2048/2048 bytes at offset 4297646080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297650176 ++read 2048/2048 bytes at offset 4297650176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297654272 ++read 2048/2048 bytes at offset 4297654272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297658368 ++read 2048/2048 bytes at offset 4297658368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297662464 ++read 2048/2048 bytes at offset 4297662464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297666560 ++read 2048/2048 bytes at offset 4297666560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297670656 ++read 2048/2048 bytes at offset 4297670656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297674752 ++read 2048/2048 bytes at offset 4297674752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297678848 ++read 2048/2048 bytes at offset 4297678848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297682944 ++read 2048/2048 bytes at offset 4297682944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297687040 ++read 2048/2048 bytes at offset 4297687040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297691136 ++read 2048/2048 bytes at offset 4297691136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297695232 ++read 2048/2048 bytes at offset 4297695232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297699328 ++read 2048/2048 bytes at offset 4297699328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297703424 ++read 2048/2048 bytes at offset 4297703424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297707520 ++read 2048/2048 bytes at offset 4297707520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297711616 ++read 2048/2048 bytes at offset 4297711616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297715712 ++read 2048/2048 bytes at offset 4297715712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297719808 ++read 2048/2048 bytes at offset 4297719808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297723904 ++read 2048/2048 bytes at offset 4297723904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297728000 ++read 2048/2048 bytes at offset 4297728000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297732096 ++read 2048/2048 bytes at offset 4297732096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297736192 ++read 2048/2048 bytes at offset 4297736192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297740288 ++read 2048/2048 bytes at offset 4297740288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297744384 ++read 2048/2048 bytes at offset 4297744384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297748480 ++read 2048/2048 bytes at offset 4297748480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297752576 ++read 2048/2048 bytes at offset 4297752576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297756672 ++read 2048/2048 bytes at offset 4297756672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297760768 ++read 2048/2048 bytes at offset 4297760768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297764864 ++read 2048/2048 bytes at offset 4297764864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297768960 ++read 2048/2048 bytes at offset 4297768960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297773056 ++read 2048/2048 bytes at offset 4297773056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297777152 ++read 2048/2048 bytes at offset 4297777152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297781248 ++read 2048/2048 bytes at offset 4297781248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297785344 ++read 2048/2048 bytes at offset 4297785344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297789440 ++read 2048/2048 bytes at offset 4297789440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297793536 ++read 2048/2048 bytes at offset 4297793536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297797632 ++read 2048/2048 bytes at offset 4297797632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297801728 ++read 2048/2048 bytes at offset 4297801728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297805824 ++read 2048/2048 bytes at offset 4297805824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297809920 ++read 2048/2048 bytes at offset 4297809920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297814016 ++read 2048/2048 bytes at offset 4297814016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297818112 ++read 2048/2048 bytes at offset 4297818112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297822208 ++read 2048/2048 bytes at offset 4297822208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297826304 ++read 2048/2048 bytes at offset 4297826304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297830400 ++read 2048/2048 bytes at offset 4297830400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297834496 ++read 2048/2048 bytes at offset 4297834496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297838592 ++read 2048/2048 bytes at offset 4297838592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297842688 ++read 2048/2048 bytes at offset 4297842688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297846784 ++read 2048/2048 bytes at offset 4297846784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297850880 ++read 2048/2048 bytes at offset 4297850880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297854976 ++read 2048/2048 bytes at offset 4297854976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297859072 ++read 2048/2048 bytes at offset 4297859072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297863168 ++read 2048/2048 bytes at offset 4297863168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297867264 ++read 2048/2048 bytes at offset 4297867264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297871360 ++read 2048/2048 bytes at offset 4297871360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297875456 ++read 2048/2048 bytes at offset 4297875456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297879552 ++read 2048/2048 bytes at offset 4297879552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297883648 ++read 2048/2048 bytes at offset 4297883648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297887744 ++read 2048/2048 bytes at offset 4297887744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297891840 ++read 2048/2048 bytes at offset 4297891840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297895936 ++read 2048/2048 bytes at offset 4297895936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297900032 ++read 2048/2048 bytes at offset 4297900032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297904128 ++read 2048/2048 bytes at offset 4297904128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297908224 ++read 2048/2048 bytes at offset 4297908224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297912320 ++read 2048/2048 bytes at offset 4297912320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297916416 ++read 2048/2048 bytes at offset 4297916416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297920512 ++read 2048/2048 bytes at offset 4297920512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297924608 ++read 2048/2048 bytes at offset 4297924608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297928704 ++read 2048/2048 bytes at offset 4297928704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297932800 ++read 2048/2048 bytes at offset 4297932800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297936896 ++read 2048/2048 bytes at offset 4297936896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297940992 ++read 2048/2048 bytes at offset 4297940992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297945088 ++read 2048/2048 bytes at offset 4297945088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297949184 ++read 2048/2048 bytes at offset 4297949184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297953280 ++read 2048/2048 bytes at offset 4297953280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297957376 ++read 2048/2048 bytes at offset 4297957376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297961472 ++read 2048/2048 bytes at offset 4297961472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297965568 ++read 2048/2048 bytes at offset 4297965568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297969664 ++read 2048/2048 bytes at offset 4297969664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297973760 ++read 2048/2048 bytes at offset 4297973760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297977856 ++read 2048/2048 bytes at offset 4297977856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297981952 ++read 2048/2048 bytes at offset 4297981952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297986048 ++read 2048/2048 bytes at offset 4297986048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297990144 ++read 2048/2048 bytes at offset 4297990144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297994240 ++read 2048/2048 bytes at offset 4297994240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297998336 ++read 2048/2048 bytes at offset 4297998336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298002432 ++read 2048/2048 bytes at offset 4298002432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298006528 ++read 2048/2048 bytes at offset 4298006528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298010624 ++read 2048/2048 bytes at offset 4298010624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298014720 ++read 2048/2048 bytes at offset 4298014720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298018816 ++read 2048/2048 bytes at offset 4298018816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298022912 ++read 2048/2048 bytes at offset 4298022912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298027008 ++read 2048/2048 bytes at offset 4298027008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298031104 ++read 2048/2048 bytes at offset 4298031104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298035200 ++read 2048/2048 bytes at offset 4298035200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298039296 ++read 2048/2048 bytes at offset 4298039296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298043392 ++read 2048/2048 bytes at offset 4298043392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298047488 ++read 2048/2048 bytes at offset 4298047488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298051584 ++read 2048/2048 bytes at offset 4298051584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298055680 ++read 2048/2048 bytes at offset 4298055680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298059776 ++read 2048/2048 bytes at offset 4298059776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298063872 ++read 2048/2048 bytes at offset 4298063872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298067968 ++read 2048/2048 bytes at offset 4298067968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298072064 ++read 2048/2048 bytes at offset 4298072064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298076160 ++read 2048/2048 bytes at offset 4298076160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298080256 ++read 2048/2048 bytes at offset 4298080256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298084352 ++read 2048/2048 bytes at offset 4298084352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298088448 ++read 2048/2048 bytes at offset 4298088448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298092544 ++read 2048/2048 bytes at offset 4298092544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298096640 ++read 2048/2048 bytes at offset 4298096640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298100736 ++read 2048/2048 bytes at offset 4298100736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298104832 ++read 2048/2048 bytes at offset 4298104832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298108928 ++read 2048/2048 bytes at offset 4298108928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 2 +-qemu-io> read 2048/2048 bytes at offset 4298114048 ++=== IO: pattern 2 ++read 2048/2048 bytes at offset 4298114048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298118144 ++read 2048/2048 bytes at offset 4298118144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298122240 ++read 2048/2048 bytes at offset 4298122240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298126336 ++read 2048/2048 bytes at offset 4298126336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298130432 ++read 2048/2048 bytes at offset 4298130432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298134528 ++read 2048/2048 bytes at offset 4298134528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298138624 ++read 2048/2048 bytes at offset 4298138624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298142720 ++read 2048/2048 bytes at offset 4298142720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298146816 ++read 2048/2048 bytes at offset 4298146816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298150912 ++read 2048/2048 bytes at offset 4298150912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298155008 ++read 2048/2048 bytes at offset 4298155008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298159104 ++read 2048/2048 bytes at offset 4298159104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298163200 ++read 2048/2048 bytes at offset 4298163200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298167296 ++read 2048/2048 bytes at offset 4298167296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298171392 ++read 2048/2048 bytes at offset 4298171392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298175488 ++read 2048/2048 bytes at offset 4298175488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298179584 ++read 2048/2048 bytes at offset 4298179584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298183680 ++read 2048/2048 bytes at offset 4298183680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298187776 ++read 2048/2048 bytes at offset 4298187776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298191872 ++read 2048/2048 bytes at offset 4298191872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298195968 ++read 2048/2048 bytes at offset 4298195968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298200064 ++read 2048/2048 bytes at offset 4298200064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298204160 ++read 2048/2048 bytes at offset 4298204160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298208256 ++read 2048/2048 bytes at offset 4298208256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298212352 ++read 2048/2048 bytes at offset 4298212352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298216448 ++read 2048/2048 bytes at offset 4298216448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298220544 ++read 2048/2048 bytes at offset 4298220544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298224640 ++read 2048/2048 bytes at offset 4298224640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298228736 ++read 2048/2048 bytes at offset 4298228736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298232832 ++read 2048/2048 bytes at offset 4298232832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298236928 ++read 2048/2048 bytes at offset 4298236928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298241024 ++read 2048/2048 bytes at offset 4298241024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298245120 ++read 2048/2048 bytes at offset 4298245120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298249216 ++read 2048/2048 bytes at offset 4298249216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298253312 ++read 2048/2048 bytes at offset 4298253312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298257408 ++read 2048/2048 bytes at offset 4298257408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298261504 ++read 2048/2048 bytes at offset 4298261504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298265600 ++read 2048/2048 bytes at offset 4298265600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298269696 ++read 2048/2048 bytes at offset 4298269696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298273792 ++read 2048/2048 bytes at offset 4298273792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298277888 ++read 2048/2048 bytes at offset 4298277888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298281984 ++read 2048/2048 bytes at offset 4298281984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298286080 ++read 2048/2048 bytes at offset 4298286080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298290176 ++read 2048/2048 bytes at offset 4298290176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298294272 ++read 2048/2048 bytes at offset 4298294272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298298368 ++read 2048/2048 bytes at offset 4298298368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298302464 ++read 2048/2048 bytes at offset 4298302464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298306560 ++read 2048/2048 bytes at offset 4298306560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298310656 ++read 2048/2048 bytes at offset 4298310656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298314752 ++read 2048/2048 bytes at offset 4298314752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298318848 ++read 2048/2048 bytes at offset 4298318848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298322944 ++read 2048/2048 bytes at offset 4298322944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298327040 ++read 2048/2048 bytes at offset 4298327040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298331136 ++read 2048/2048 bytes at offset 4298331136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298335232 ++read 2048/2048 bytes at offset 4298335232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298339328 ++read 2048/2048 bytes at offset 4298339328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298343424 ++read 2048/2048 bytes at offset 4298343424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298347520 ++read 2048/2048 bytes at offset 4298347520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298351616 ++read 2048/2048 bytes at offset 4298351616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298355712 ++read 2048/2048 bytes at offset 4298355712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298359808 ++read 2048/2048 bytes at offset 4298359808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298363904 ++read 2048/2048 bytes at offset 4298363904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298368000 ++read 2048/2048 bytes at offset 4298368000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298372096 ++read 2048/2048 bytes at offset 4298372096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298376192 ++read 2048/2048 bytes at offset 4298376192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298380288 ++read 2048/2048 bytes at offset 4298380288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298384384 ++read 2048/2048 bytes at offset 4298384384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298388480 ++read 2048/2048 bytes at offset 4298388480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298392576 ++read 2048/2048 bytes at offset 4298392576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298396672 ++read 2048/2048 bytes at offset 4298396672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298400768 ++read 2048/2048 bytes at offset 4298400768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298404864 ++read 2048/2048 bytes at offset 4298404864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298408960 ++read 2048/2048 bytes at offset 4298408960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298413056 ++read 2048/2048 bytes at offset 4298413056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298417152 ++read 2048/2048 bytes at offset 4298417152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298421248 ++read 2048/2048 bytes at offset 4298421248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298425344 ++read 2048/2048 bytes at offset 4298425344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298429440 ++read 2048/2048 bytes at offset 4298429440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298433536 ++read 2048/2048 bytes at offset 4298433536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298437632 ++read 2048/2048 bytes at offset 4298437632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298441728 ++read 2048/2048 bytes at offset 4298441728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298445824 ++read 2048/2048 bytes at offset 4298445824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298449920 ++read 2048/2048 bytes at offset 4298449920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298454016 ++read 2048/2048 bytes at offset 4298454016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298458112 ++read 2048/2048 bytes at offset 4298458112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298462208 ++read 2048/2048 bytes at offset 4298462208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298466304 ++read 2048/2048 bytes at offset 4298466304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298470400 ++read 2048/2048 bytes at offset 4298470400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298474496 ++read 2048/2048 bytes at offset 4298474496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298478592 ++read 2048/2048 bytes at offset 4298478592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298482688 ++read 2048/2048 bytes at offset 4298482688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298486784 ++read 2048/2048 bytes at offset 4298486784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298490880 ++read 2048/2048 bytes at offset 4298490880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298494976 ++read 2048/2048 bytes at offset 4298494976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298499072 ++read 2048/2048 bytes at offset 4298499072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298503168 ++read 2048/2048 bytes at offset 4298503168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298507264 ++read 2048/2048 bytes at offset 4298507264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298511360 ++read 2048/2048 bytes at offset 4298511360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298515456 ++read 2048/2048 bytes at offset 4298515456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298519552 ++read 2048/2048 bytes at offset 4298519552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298523648 ++read 2048/2048 bytes at offset 4298523648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298527744 ++read 2048/2048 bytes at offset 4298527744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298531840 ++read 2048/2048 bytes at offset 4298531840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298535936 ++read 2048/2048 bytes at offset 4298535936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298540032 ++read 2048/2048 bytes at offset 4298540032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298544128 ++read 2048/2048 bytes at offset 4298544128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298548224 ++read 2048/2048 bytes at offset 4298548224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298552320 ++read 2048/2048 bytes at offset 4298552320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298556416 ++read 2048/2048 bytes at offset 4298556416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298560512 ++read 2048/2048 bytes at offset 4298560512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298564608 ++read 2048/2048 bytes at offset 4298564608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298568704 ++read 2048/2048 bytes at offset 4298568704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298572800 ++read 2048/2048 bytes at offset 4298572800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298576896 ++read 2048/2048 bytes at offset 4298576896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298580992 ++read 2048/2048 bytes at offset 4298580992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298585088 ++read 2048/2048 bytes at offset 4298585088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298589184 ++read 2048/2048 bytes at offset 4298589184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298593280 ++read 2048/2048 bytes at offset 4298593280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298597376 ++read 2048/2048 bytes at offset 4298597376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298601472 ++read 2048/2048 bytes at offset 4298601472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298605568 ++read 2048/2048 bytes at offset 4298605568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298609664 ++read 2048/2048 bytes at offset 4298609664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298613760 ++read 2048/2048 bytes at offset 4298613760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298617856 ++read 2048/2048 bytes at offset 4298617856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298621952 ++read 2048/2048 bytes at offset 4298621952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298626048 ++read 2048/2048 bytes at offset 4298626048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298630144 ++read 2048/2048 bytes at offset 4298630144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298634240 ++read 2048/2048 bytes at offset 4298634240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298638336 ++read 2048/2048 bytes at offset 4298638336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298642432 ++read 2048/2048 bytes at offset 4298642432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298646528 ++read 2048/2048 bytes at offset 4298646528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298650624 ++read 2048/2048 bytes at offset 4298650624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298654720 ++read 2048/2048 bytes at offset 4298654720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298658816 ++read 2048/2048 bytes at offset 4298658816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298662912 ++read 2048/2048 bytes at offset 4298662912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298667008 ++read 2048/2048 bytes at offset 4298667008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298671104 ++read 2048/2048 bytes at offset 4298671104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298675200 ++read 2048/2048 bytes at offset 4298675200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298679296 ++read 2048/2048 bytes at offset 4298679296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298683392 ++read 2048/2048 bytes at offset 4298683392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298687488 ++read 2048/2048 bytes at offset 4298687488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298691584 ++read 2048/2048 bytes at offset 4298691584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298695680 ++read 2048/2048 bytes at offset 4298695680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298699776 ++read 2048/2048 bytes at offset 4298699776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298703872 ++read 2048/2048 bytes at offset 4298703872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298707968 ++read 2048/2048 bytes at offset 4298707968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298712064 ++read 2048/2048 bytes at offset 4298712064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298716160 ++read 2048/2048 bytes at offset 4298716160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298720256 ++read 2048/2048 bytes at offset 4298720256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298724352 ++read 2048/2048 bytes at offset 4298724352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298728448 ++read 2048/2048 bytes at offset 4298728448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298732544 ++read 2048/2048 bytes at offset 4298732544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298736640 ++read 2048/2048 bytes at offset 4298736640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298740736 ++read 2048/2048 bytes at offset 4298740736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298744832 ++read 2048/2048 bytes at offset 4298744832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298748928 ++read 2048/2048 bytes at offset 4298748928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298753024 ++read 2048/2048 bytes at offset 4298753024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298757120 ++read 2048/2048 bytes at offset 4298757120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298761216 ++read 2048/2048 bytes at offset 4298761216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298765312 ++read 2048/2048 bytes at offset 4298765312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298769408 ++read 2048/2048 bytes at offset 4298769408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298773504 ++read 2048/2048 bytes at offset 4298773504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298777600 ++read 2048/2048 bytes at offset 4298777600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298781696 ++read 2048/2048 bytes at offset 4298781696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298785792 ++read 2048/2048 bytes at offset 4298785792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298789888 ++read 2048/2048 bytes at offset 4298789888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298793984 ++read 2048/2048 bytes at offset 4298793984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298798080 ++read 2048/2048 bytes at offset 4298798080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298802176 ++read 2048/2048 bytes at offset 4298802176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298806272 ++read 2048/2048 bytes at offset 4298806272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298810368 ++read 2048/2048 bytes at offset 4298810368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298814464 ++read 2048/2048 bytes at offset 4298814464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298818560 ++read 2048/2048 bytes at offset 4298818560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298822656 ++read 2048/2048 bytes at offset 4298822656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298826752 ++read 2048/2048 bytes at offset 4298826752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298830848 ++read 2048/2048 bytes at offset 4298830848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298834944 ++read 2048/2048 bytes at offset 4298834944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298839040 ++read 2048/2048 bytes at offset 4298839040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298843136 ++read 2048/2048 bytes at offset 4298843136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298847232 ++read 2048/2048 bytes at offset 4298847232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298851328 ++read 2048/2048 bytes at offset 4298851328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298855424 ++read 2048/2048 bytes at offset 4298855424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298859520 ++read 2048/2048 bytes at offset 4298859520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298863616 ++read 2048/2048 bytes at offset 4298863616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298867712 ++read 2048/2048 bytes at offset 4298867712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298871808 ++read 2048/2048 bytes at offset 4298871808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298875904 ++read 2048/2048 bytes at offset 4298875904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298880000 ++read 2048/2048 bytes at offset 4298880000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298884096 ++read 2048/2048 bytes at offset 4298884096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298888192 ++read 2048/2048 bytes at offset 4298888192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298892288 ++read 2048/2048 bytes at offset 4298892288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298896384 ++read 2048/2048 bytes at offset 4298896384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298900480 ++read 2048/2048 bytes at offset 4298900480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298904576 ++read 2048/2048 bytes at offset 4298904576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298908672 ++read 2048/2048 bytes at offset 4298908672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298912768 ++read 2048/2048 bytes at offset 4298912768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298916864 ++read 2048/2048 bytes at offset 4298916864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298920960 ++read 2048/2048 bytes at offset 4298920960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298925056 ++read 2048/2048 bytes at offset 4298925056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298929152 ++read 2048/2048 bytes at offset 4298929152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298933248 ++read 2048/2048 bytes at offset 4298933248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298937344 ++read 2048/2048 bytes at offset 4298937344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298941440 ++read 2048/2048 bytes at offset 4298941440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298945536 ++read 2048/2048 bytes at offset 4298945536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298949632 ++read 2048/2048 bytes at offset 4298949632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298953728 ++read 2048/2048 bytes at offset 4298953728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298957824 ++read 2048/2048 bytes at offset 4298957824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298961920 ++read 2048/2048 bytes at offset 4298961920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298966016 ++read 2048/2048 bytes at offset 4298966016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298970112 ++read 2048/2048 bytes at offset 4298970112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298974208 ++read 2048/2048 bytes at offset 4298974208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298978304 ++read 2048/2048 bytes at offset 4298978304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298982400 ++read 2048/2048 bytes at offset 4298982400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298986496 ++read 2048/2048 bytes at offset 4298986496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298990592 ++read 2048/2048 bytes at offset 4298990592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298994688 ++read 2048/2048 bytes at offset 4298994688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298998784 ++read 2048/2048 bytes at offset 4298998784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299002880 ++read 2048/2048 bytes at offset 4299002880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299006976 ++read 2048/2048 bytes at offset 4299006976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299011072 ++read 2048/2048 bytes at offset 4299011072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299015168 ++read 2048/2048 bytes at offset 4299015168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299019264 ++read 2048/2048 bytes at offset 4299019264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299023360 ++read 2048/2048 bytes at offset 4299023360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299027456 ++read 2048/2048 bytes at offset 4299027456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299031552 ++read 2048/2048 bytes at offset 4299031552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299035648 ++read 2048/2048 bytes at offset 4299035648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299039744 ++read 2048/2048 bytes at offset 4299039744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299043840 ++read 2048/2048 bytes at offset 4299043840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299047936 ++read 2048/2048 bytes at offset 4299047936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299052032 ++read 2048/2048 bytes at offset 4299052032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299056128 ++read 2048/2048 bytes at offset 4299056128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299060224 ++read 2048/2048 bytes at offset 4299060224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299064320 ++read 2048/2048 bytes at offset 4299064320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299068416 ++read 2048/2048 bytes at offset 4299068416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299072512 ++read 2048/2048 bytes at offset 4299072512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299076608 ++read 2048/2048 bytes at offset 4299076608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299080704 ++read 2048/2048 bytes at offset 4299080704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299084800 ++read 2048/2048 bytes at offset 4299084800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299088896 ++read 2048/2048 bytes at offset 4299088896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299092992 ++read 2048/2048 bytes at offset 4299092992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299097088 ++read 2048/2048 bytes at offset 4299097088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299101184 ++read 2048/2048 bytes at offset 4299101184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299105280 ++read 2048/2048 bytes at offset 4299105280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299109376 ++read 2048/2048 bytes at offset 4299109376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299113472 ++read 2048/2048 bytes at offset 4299113472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299117568 ++read 2048/2048 bytes at offset 4299117568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299121664 ++read 2048/2048 bytes at offset 4299121664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299125760 ++read 2048/2048 bytes at offset 4299125760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299129856 ++read 2048/2048 bytes at offset 4299129856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299133952 ++read 2048/2048 bytes at offset 4299133952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299138048 ++read 2048/2048 bytes at offset 4299138048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299142144 ++read 2048/2048 bytes at offset 4299142144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299146240 ++read 2048/2048 bytes at offset 4299146240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299150336 ++read 2048/2048 bytes at offset 4299150336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299154432 ++read 2048/2048 bytes at offset 4299154432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299158528 ++read 2048/2048 bytes at offset 4299158528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 4 +-qemu-io> read 8192/8192 bytes at offset 4299163648 ++=== IO: pattern 4 ++read 8192/8192 bytes at offset 4299163648 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299175936 ++read 8192/8192 bytes at offset 4299175936 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299188224 ++read 8192/8192 bytes at offset 4299188224 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299200512 ++read 8192/8192 bytes at offset 4299200512 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299212800 ++read 8192/8192 bytes at offset 4299212800 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299225088 ++read 8192/8192 bytes at offset 4299225088 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299237376 ++read 8192/8192 bytes at offset 4299237376 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299249664 ++read 8192/8192 bytes at offset 4299249664 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299261952 ++read 8192/8192 bytes at offset 4299261952 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299274240 ++read 8192/8192 bytes at offset 4299274240 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299286528 ++read 8192/8192 bytes at offset 4299286528 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299298816 ++read 8192/8192 bytes at offset 4299298816 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299311104 ++read 8192/8192 bytes at offset 4299311104 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299323392 ++read 8192/8192 bytes at offset 4299323392 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299335680 ++read 8192/8192 bytes at offset 4299335680 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299347968 ++read 8192/8192 bytes at offset 4299347968 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299360256 ++read 8192/8192 bytes at offset 4299360256 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299372544 ++read 8192/8192 bytes at offset 4299372544 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299384832 ++read 8192/8192 bytes at offset 4299384832 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299397120 ++read 8192/8192 bytes at offset 4299397120 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299409408 ++read 8192/8192 bytes at offset 4299409408 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299421696 ++read 8192/8192 bytes at offset 4299421696 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299433984 ++read 8192/8192 bytes at offset 4299433984 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299446272 ++read 8192/8192 bytes at offset 4299446272 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299458560 ++read 8192/8192 bytes at offset 4299458560 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299470848 ++read 8192/8192 bytes at offset 4299470848 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299483136 ++read 8192/8192 bytes at offset 4299483136 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299495424 ++read 8192/8192 bytes at offset 4299495424 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299507712 ++read 8192/8192 bytes at offset 4299507712 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299520000 ++read 8192/8192 bytes at offset 4299520000 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299532288 ++read 8192/8192 bytes at offset 4299532288 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299544576 ++read 8192/8192 bytes at offset 4299544576 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299556864 ++read 8192/8192 bytes at offset 4299556864 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299569152 ++read 8192/8192 bytes at offset 4299569152 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299581440 ++read 8192/8192 bytes at offset 4299581440 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299593728 ++read 8192/8192 bytes at offset 4299593728 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299606016 ++read 8192/8192 bytes at offset 4299606016 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299618304 ++read 8192/8192 bytes at offset 4299618304 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299630592 ++read 8192/8192 bytes at offset 4299630592 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299642880 ++read 8192/8192 bytes at offset 4299642880 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299655168 ++read 8192/8192 bytes at offset 4299655168 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299667456 ++read 8192/8192 bytes at offset 4299667456 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299679744 ++read 8192/8192 bytes at offset 4299679744 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299692032 ++read 8192/8192 bytes at offset 4299692032 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299704320 ++read 8192/8192 bytes at offset 4299704320 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299716608 ++read 8192/8192 bytes at offset 4299716608 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299728896 ++read 8192/8192 bytes at offset 4299728896 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299741184 ++read 8192/8192 bytes at offset 4299741184 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299753472 ++read 8192/8192 bytes at offset 4299753472 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299765760 ++read 8192/8192 bytes at offset 4299765760 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299778048 ++read 8192/8192 bytes at offset 4299778048 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299790336 ++read 8192/8192 bytes at offset 4299790336 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299802624 ++read 8192/8192 bytes at offset 4299802624 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299814912 ++read 8192/8192 bytes at offset 4299814912 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299827200 ++read 8192/8192 bytes at offset 4299827200 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299839488 ++read 8192/8192 bytes at offset 4299839488 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299851776 ++read 8192/8192 bytes at offset 4299851776 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299864064 ++read 8192/8192 bytes at offset 4299864064 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299876352 ++read 8192/8192 bytes at offset 4299876352 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299888640 ++read 8192/8192 bytes at offset 4299888640 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299900928 ++read 8192/8192 bytes at offset 4299900928 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299913216 ++read 8192/8192 bytes at offset 4299913216 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299925504 ++read 8192/8192 bytes at offset 4299925504 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299937792 ++read 8192/8192 bytes at offset 4299937792 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 244 +-qemu-io> read 12288/12288 bytes at offset 4301252608 ++=== IO: pattern 244 ++read 12288/12288 bytes at offset 4301252608 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4303351808 ++read 12288/12288 bytes at offset 4303351808 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4305451008 ++read 12288/12288 bytes at offset 4305451008 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4307550208 ++read 12288/12288 bytes at offset 4307550208 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4309649408 ++read 12288/12288 bytes at offset 4309649408 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4311748608 ++read 12288/12288 bytes at offset 4311748608 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4313847808 ++read 12288/12288 bytes at offset 4313847808 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4315947008 ++read 12288/12288 bytes at offset 4315947008 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> wrote 4096/4096 bytes at offset 4294967296 ++=== IO: pattern 0 ++wrote 4096/4096 bytes at offset 4294967296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4294971392 ++wrote 4096/4096 bytes at offset 4294971392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4294975488 ++wrote 4096/4096 bytes at offset 4294975488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4294979584 ++wrote 4096/4096 bytes at offset 4294979584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4294983680 ++wrote 4096/4096 bytes at offset 4294983680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4294987776 ++wrote 4096/4096 bytes at offset 4294987776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4294991872 ++wrote 4096/4096 bytes at offset 4294991872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4294995968 ++wrote 4096/4096 bytes at offset 4294995968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295000064 ++wrote 4096/4096 bytes at offset 4295000064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295004160 ++wrote 4096/4096 bytes at offset 4295004160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295008256 ++wrote 4096/4096 bytes at offset 4295008256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295012352 ++wrote 4096/4096 bytes at offset 4295012352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295016448 ++wrote 4096/4096 bytes at offset 4295016448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295020544 ++wrote 4096/4096 bytes at offset 4295020544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295024640 ++wrote 4096/4096 bytes at offset 4295024640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295028736 ++wrote 4096/4096 bytes at offset 4295028736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295032832 ++wrote 4096/4096 bytes at offset 4295032832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295036928 ++wrote 4096/4096 bytes at offset 4295036928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295041024 ++wrote 4096/4096 bytes at offset 4295041024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295045120 ++wrote 4096/4096 bytes at offset 4295045120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295049216 ++wrote 4096/4096 bytes at offset 4295049216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295053312 ++wrote 4096/4096 bytes at offset 4295053312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295057408 ++wrote 4096/4096 bytes at offset 4295057408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295061504 ++wrote 4096/4096 bytes at offset 4295061504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295065600 ++wrote 4096/4096 bytes at offset 4295065600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295069696 ++wrote 4096/4096 bytes at offset 4295069696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295073792 ++wrote 4096/4096 bytes at offset 4295073792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295077888 ++wrote 4096/4096 bytes at offset 4295077888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295081984 ++wrote 4096/4096 bytes at offset 4295081984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295086080 ++wrote 4096/4096 bytes at offset 4295086080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295090176 ++wrote 4096/4096 bytes at offset 4295090176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295094272 ++wrote 4096/4096 bytes at offset 4295094272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295098368 ++wrote 4096/4096 bytes at offset 4295098368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295102464 ++wrote 4096/4096 bytes at offset 4295102464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295106560 ++wrote 4096/4096 bytes at offset 4295106560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295110656 ++wrote 4096/4096 bytes at offset 4295110656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295114752 ++wrote 4096/4096 bytes at offset 4295114752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295118848 ++wrote 4096/4096 bytes at offset 4295118848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295122944 ++wrote 4096/4096 bytes at offset 4295122944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295127040 ++wrote 4096/4096 bytes at offset 4295127040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295131136 ++wrote 4096/4096 bytes at offset 4295131136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295135232 ++wrote 4096/4096 bytes at offset 4295135232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295139328 ++wrote 4096/4096 bytes at offset 4295139328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295143424 ++wrote 4096/4096 bytes at offset 4295143424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295147520 ++wrote 4096/4096 bytes at offset 4295147520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295151616 ++wrote 4096/4096 bytes at offset 4295151616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295155712 ++wrote 4096/4096 bytes at offset 4295155712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295159808 ++wrote 4096/4096 bytes at offset 4295159808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295163904 ++wrote 4096/4096 bytes at offset 4295163904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295168000 ++wrote 4096/4096 bytes at offset 4295168000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295172096 ++wrote 4096/4096 bytes at offset 4295172096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295176192 ++wrote 4096/4096 bytes at offset 4295176192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295180288 ++wrote 4096/4096 bytes at offset 4295180288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295184384 ++wrote 4096/4096 bytes at offset 4295184384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295188480 ++wrote 4096/4096 bytes at offset 4295188480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295192576 ++wrote 4096/4096 bytes at offset 4295192576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295196672 ++wrote 4096/4096 bytes at offset 4295196672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295200768 ++wrote 4096/4096 bytes at offset 4295200768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295204864 ++wrote 4096/4096 bytes at offset 4295204864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295208960 ++wrote 4096/4096 bytes at offset 4295208960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295213056 ++wrote 4096/4096 bytes at offset 4295213056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295217152 ++wrote 4096/4096 bytes at offset 4295217152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295221248 ++wrote 4096/4096 bytes at offset 4295221248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295225344 ++wrote 4096/4096 bytes at offset 4295225344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295229440 ++wrote 4096/4096 bytes at offset 4295229440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295233536 ++wrote 4096/4096 bytes at offset 4295233536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295237632 ++wrote 4096/4096 bytes at offset 4295237632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295241728 ++wrote 4096/4096 bytes at offset 4295241728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295245824 ++wrote 4096/4096 bytes at offset 4295245824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295249920 ++wrote 4096/4096 bytes at offset 4295249920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295254016 ++wrote 4096/4096 bytes at offset 4295254016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295258112 ++wrote 4096/4096 bytes at offset 4295258112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295262208 ++wrote 4096/4096 bytes at offset 4295262208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295266304 ++wrote 4096/4096 bytes at offset 4295266304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295270400 ++wrote 4096/4096 bytes at offset 4295270400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295274496 ++wrote 4096/4096 bytes at offset 4295274496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295278592 ++wrote 4096/4096 bytes at offset 4295278592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295282688 ++wrote 4096/4096 bytes at offset 4295282688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295286784 ++wrote 4096/4096 bytes at offset 4295286784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295290880 ++wrote 4096/4096 bytes at offset 4295290880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295294976 ++wrote 4096/4096 bytes at offset 4295294976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295299072 ++wrote 4096/4096 bytes at offset 4295299072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295303168 ++wrote 4096/4096 bytes at offset 4295303168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295307264 ++wrote 4096/4096 bytes at offset 4295307264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295311360 ++wrote 4096/4096 bytes at offset 4295311360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295315456 ++wrote 4096/4096 bytes at offset 4295315456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295319552 ++wrote 4096/4096 bytes at offset 4295319552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295323648 ++wrote 4096/4096 bytes at offset 4295323648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295327744 ++wrote 4096/4096 bytes at offset 4295327744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295331840 ++wrote 4096/4096 bytes at offset 4295331840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295335936 ++wrote 4096/4096 bytes at offset 4295335936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295340032 ++wrote 4096/4096 bytes at offset 4295340032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295344128 ++wrote 4096/4096 bytes at offset 4295344128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295348224 ++wrote 4096/4096 bytes at offset 4295348224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295352320 ++wrote 4096/4096 bytes at offset 4295352320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295356416 ++wrote 4096/4096 bytes at offset 4295356416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295360512 ++wrote 4096/4096 bytes at offset 4295360512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295364608 ++wrote 4096/4096 bytes at offset 4295364608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295368704 ++wrote 4096/4096 bytes at offset 4295368704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295372800 ++wrote 4096/4096 bytes at offset 4295372800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295376896 ++wrote 4096/4096 bytes at offset 4295376896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295380992 ++wrote 4096/4096 bytes at offset 4295380992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295385088 ++wrote 4096/4096 bytes at offset 4295385088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295389184 ++wrote 4096/4096 bytes at offset 4295389184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295393280 ++wrote 4096/4096 bytes at offset 4295393280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295397376 ++wrote 4096/4096 bytes at offset 4295397376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295401472 ++wrote 4096/4096 bytes at offset 4295401472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295405568 ++wrote 4096/4096 bytes at offset 4295405568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295409664 ++wrote 4096/4096 bytes at offset 4295409664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295413760 ++wrote 4096/4096 bytes at offset 4295413760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295417856 ++wrote 4096/4096 bytes at offset 4295417856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295421952 ++wrote 4096/4096 bytes at offset 4295421952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295426048 ++wrote 4096/4096 bytes at offset 4295426048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295430144 ++wrote 4096/4096 bytes at offset 4295430144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295434240 ++wrote 4096/4096 bytes at offset 4295434240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295438336 ++wrote 4096/4096 bytes at offset 4295438336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295442432 ++wrote 4096/4096 bytes at offset 4295442432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295446528 ++wrote 4096/4096 bytes at offset 4295446528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295450624 ++wrote 4096/4096 bytes at offset 4295450624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295454720 ++wrote 4096/4096 bytes at offset 4295454720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295458816 ++wrote 4096/4096 bytes at offset 4295458816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295462912 ++wrote 4096/4096 bytes at offset 4295462912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295467008 ++wrote 4096/4096 bytes at offset 4295467008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295471104 ++wrote 4096/4096 bytes at offset 4295471104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295475200 ++wrote 4096/4096 bytes at offset 4295475200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295479296 ++wrote 4096/4096 bytes at offset 4295479296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295483392 ++wrote 4096/4096 bytes at offset 4295483392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295487488 ++wrote 4096/4096 bytes at offset 4295487488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295491584 ++wrote 4096/4096 bytes at offset 4295491584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295495680 ++wrote 4096/4096 bytes at offset 4295495680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295499776 ++wrote 4096/4096 bytes at offset 4295499776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295503872 ++wrote 4096/4096 bytes at offset 4295503872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295507968 ++wrote 4096/4096 bytes at offset 4295507968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295512064 ++wrote 4096/4096 bytes at offset 4295512064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295516160 ++wrote 4096/4096 bytes at offset 4295516160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295520256 ++wrote 4096/4096 bytes at offset 4295520256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295524352 ++wrote 4096/4096 bytes at offset 4295524352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295528448 ++wrote 4096/4096 bytes at offset 4295528448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295532544 ++wrote 4096/4096 bytes at offset 4295532544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295536640 ++wrote 4096/4096 bytes at offset 4295536640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295540736 ++wrote 4096/4096 bytes at offset 4295540736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295544832 ++wrote 4096/4096 bytes at offset 4295544832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295548928 ++wrote 4096/4096 bytes at offset 4295548928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295553024 ++wrote 4096/4096 bytes at offset 4295553024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295557120 ++wrote 4096/4096 bytes at offset 4295557120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295561216 ++wrote 4096/4096 bytes at offset 4295561216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295565312 ++wrote 4096/4096 bytes at offset 4295565312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295569408 ++wrote 4096/4096 bytes at offset 4295569408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295573504 ++wrote 4096/4096 bytes at offset 4295573504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295577600 ++wrote 4096/4096 bytes at offset 4295577600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295581696 ++wrote 4096/4096 bytes at offset 4295581696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295585792 ++wrote 4096/4096 bytes at offset 4295585792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295589888 ++wrote 4096/4096 bytes at offset 4295589888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295593984 ++wrote 4096/4096 bytes at offset 4295593984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295598080 ++wrote 4096/4096 bytes at offset 4295598080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295602176 ++wrote 4096/4096 bytes at offset 4295602176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295606272 ++wrote 4096/4096 bytes at offset 4295606272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295610368 ++wrote 4096/4096 bytes at offset 4295610368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295614464 ++wrote 4096/4096 bytes at offset 4295614464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295618560 ++wrote 4096/4096 bytes at offset 4295618560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295622656 ++wrote 4096/4096 bytes at offset 4295622656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295626752 ++wrote 4096/4096 bytes at offset 4295626752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295630848 ++wrote 4096/4096 bytes at offset 4295630848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295634944 ++wrote 4096/4096 bytes at offset 4295634944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295639040 ++wrote 4096/4096 bytes at offset 4295639040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295643136 ++wrote 4096/4096 bytes at offset 4295643136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295647232 ++wrote 4096/4096 bytes at offset 4295647232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295651328 ++wrote 4096/4096 bytes at offset 4295651328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295655424 ++wrote 4096/4096 bytes at offset 4295655424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295659520 ++wrote 4096/4096 bytes at offset 4295659520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295663616 ++wrote 4096/4096 bytes at offset 4295663616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295667712 ++wrote 4096/4096 bytes at offset 4295667712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295671808 ++wrote 4096/4096 bytes at offset 4295671808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295675904 ++wrote 4096/4096 bytes at offset 4295675904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295680000 ++wrote 4096/4096 bytes at offset 4295680000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295684096 ++wrote 4096/4096 bytes at offset 4295684096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295688192 ++wrote 4096/4096 bytes at offset 4295688192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295692288 ++wrote 4096/4096 bytes at offset 4295692288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295696384 ++wrote 4096/4096 bytes at offset 4295696384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295700480 ++wrote 4096/4096 bytes at offset 4295700480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295704576 ++wrote 4096/4096 bytes at offset 4295704576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295708672 ++wrote 4096/4096 bytes at offset 4295708672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295712768 ++wrote 4096/4096 bytes at offset 4295712768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295716864 ++wrote 4096/4096 bytes at offset 4295716864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295720960 ++wrote 4096/4096 bytes at offset 4295720960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295725056 ++wrote 4096/4096 bytes at offset 4295725056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295729152 ++wrote 4096/4096 bytes at offset 4295729152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295733248 ++wrote 4096/4096 bytes at offset 4295733248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295737344 ++wrote 4096/4096 bytes at offset 4295737344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295741440 ++wrote 4096/4096 bytes at offset 4295741440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295745536 ++wrote 4096/4096 bytes at offset 4295745536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295749632 ++wrote 4096/4096 bytes at offset 4295749632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295753728 ++wrote 4096/4096 bytes at offset 4295753728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295757824 ++wrote 4096/4096 bytes at offset 4295757824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295761920 ++wrote 4096/4096 bytes at offset 4295761920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295766016 ++wrote 4096/4096 bytes at offset 4295766016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295770112 ++wrote 4096/4096 bytes at offset 4295770112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295774208 ++wrote 4096/4096 bytes at offset 4295774208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295778304 ++wrote 4096/4096 bytes at offset 4295778304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295782400 ++wrote 4096/4096 bytes at offset 4295782400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295786496 ++wrote 4096/4096 bytes at offset 4295786496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295790592 ++wrote 4096/4096 bytes at offset 4295790592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295794688 ++wrote 4096/4096 bytes at offset 4295794688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295798784 ++wrote 4096/4096 bytes at offset 4295798784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295802880 ++wrote 4096/4096 bytes at offset 4295802880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295806976 ++wrote 4096/4096 bytes at offset 4295806976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295811072 ++wrote 4096/4096 bytes at offset 4295811072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295815168 ++wrote 4096/4096 bytes at offset 4295815168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295819264 ++wrote 4096/4096 bytes at offset 4295819264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295823360 ++wrote 4096/4096 bytes at offset 4295823360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295827456 ++wrote 4096/4096 bytes at offset 4295827456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295831552 ++wrote 4096/4096 bytes at offset 4295831552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295835648 ++wrote 4096/4096 bytes at offset 4295835648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295839744 ++wrote 4096/4096 bytes at offset 4295839744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295843840 ++wrote 4096/4096 bytes at offset 4295843840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295847936 ++wrote 4096/4096 bytes at offset 4295847936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295852032 ++wrote 4096/4096 bytes at offset 4295852032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295856128 ++wrote 4096/4096 bytes at offset 4295856128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295860224 ++wrote 4096/4096 bytes at offset 4295860224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295864320 ++wrote 4096/4096 bytes at offset 4295864320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295868416 ++wrote 4096/4096 bytes at offset 4295868416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295872512 ++wrote 4096/4096 bytes at offset 4295872512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295876608 ++wrote 4096/4096 bytes at offset 4295876608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295880704 ++wrote 4096/4096 bytes at offset 4295880704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295884800 ++wrote 4096/4096 bytes at offset 4295884800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295888896 ++wrote 4096/4096 bytes at offset 4295888896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295892992 ++wrote 4096/4096 bytes at offset 4295892992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295897088 ++wrote 4096/4096 bytes at offset 4295897088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295901184 ++wrote 4096/4096 bytes at offset 4295901184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295905280 ++wrote 4096/4096 bytes at offset 4295905280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295909376 ++wrote 4096/4096 bytes at offset 4295909376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295913472 ++wrote 4096/4096 bytes at offset 4295913472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295917568 ++wrote 4096/4096 bytes at offset 4295917568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295921664 ++wrote 4096/4096 bytes at offset 4295921664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295925760 ++wrote 4096/4096 bytes at offset 4295925760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295929856 ++wrote 4096/4096 bytes at offset 4295929856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295933952 ++wrote 4096/4096 bytes at offset 4295933952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295938048 ++wrote 4096/4096 bytes at offset 4295938048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295942144 ++wrote 4096/4096 bytes at offset 4295942144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295946240 ++wrote 4096/4096 bytes at offset 4295946240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295950336 ++wrote 4096/4096 bytes at offset 4295950336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295954432 ++wrote 4096/4096 bytes at offset 4295954432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295958528 ++wrote 4096/4096 bytes at offset 4295958528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295962624 ++wrote 4096/4096 bytes at offset 4295962624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295966720 ++wrote 4096/4096 bytes at offset 4295966720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295970816 ++wrote 4096/4096 bytes at offset 4295970816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295974912 ++wrote 4096/4096 bytes at offset 4295974912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295979008 ++wrote 4096/4096 bytes at offset 4295979008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295983104 ++wrote 4096/4096 bytes at offset 4295983104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295987200 ++wrote 4096/4096 bytes at offset 4295987200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295991296 ++wrote 4096/4096 bytes at offset 4295991296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295995392 ++wrote 4096/4096 bytes at offset 4295995392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295999488 ++wrote 4096/4096 bytes at offset 4295999488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296003584 ++wrote 4096/4096 bytes at offset 4296003584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296007680 ++wrote 4096/4096 bytes at offset 4296007680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296011776 ++wrote 4096/4096 bytes at offset 4296011776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 4 +-qemu-io> wrote 2048/2048 bytes at offset 4296017920 ++=== IO: pattern 4 ++wrote 2048/2048 bytes at offset 4296017920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296022016 ++wrote 2048/2048 bytes at offset 4296022016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296026112 ++wrote 2048/2048 bytes at offset 4296026112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296030208 ++wrote 2048/2048 bytes at offset 4296030208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296034304 ++wrote 2048/2048 bytes at offset 4296034304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296038400 ++wrote 2048/2048 bytes at offset 4296038400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296042496 ++wrote 2048/2048 bytes at offset 4296042496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296046592 ++wrote 2048/2048 bytes at offset 4296046592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296050688 ++wrote 2048/2048 bytes at offset 4296050688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296054784 ++wrote 2048/2048 bytes at offset 4296054784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296058880 ++wrote 2048/2048 bytes at offset 4296058880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296062976 ++wrote 2048/2048 bytes at offset 4296062976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296067072 ++wrote 2048/2048 bytes at offset 4296067072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296071168 ++wrote 2048/2048 bytes at offset 4296071168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296075264 ++wrote 2048/2048 bytes at offset 4296075264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296079360 ++wrote 2048/2048 bytes at offset 4296079360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296083456 ++wrote 2048/2048 bytes at offset 4296083456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296087552 ++wrote 2048/2048 bytes at offset 4296087552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296091648 ++wrote 2048/2048 bytes at offset 4296091648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296095744 ++wrote 2048/2048 bytes at offset 4296095744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296099840 ++wrote 2048/2048 bytes at offset 4296099840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296103936 ++wrote 2048/2048 bytes at offset 4296103936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296108032 ++wrote 2048/2048 bytes at offset 4296108032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296112128 ++wrote 2048/2048 bytes at offset 4296112128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296116224 ++wrote 2048/2048 bytes at offset 4296116224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296120320 ++wrote 2048/2048 bytes at offset 4296120320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296124416 ++wrote 2048/2048 bytes at offset 4296124416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296128512 ++wrote 2048/2048 bytes at offset 4296128512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296132608 ++wrote 2048/2048 bytes at offset 4296132608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296136704 ++wrote 2048/2048 bytes at offset 4296136704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296140800 ++wrote 2048/2048 bytes at offset 4296140800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296144896 ++wrote 2048/2048 bytes at offset 4296144896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296148992 ++wrote 2048/2048 bytes at offset 4296148992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296153088 ++wrote 2048/2048 bytes at offset 4296153088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296157184 ++wrote 2048/2048 bytes at offset 4296157184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296161280 ++wrote 2048/2048 bytes at offset 4296161280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296165376 ++wrote 2048/2048 bytes at offset 4296165376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296169472 ++wrote 2048/2048 bytes at offset 4296169472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296173568 ++wrote 2048/2048 bytes at offset 4296173568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296177664 ++wrote 2048/2048 bytes at offset 4296177664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296181760 ++wrote 2048/2048 bytes at offset 4296181760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296185856 ++wrote 2048/2048 bytes at offset 4296185856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296189952 ++wrote 2048/2048 bytes at offset 4296189952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296194048 ++wrote 2048/2048 bytes at offset 4296194048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296198144 ++wrote 2048/2048 bytes at offset 4296198144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296202240 ++wrote 2048/2048 bytes at offset 4296202240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296206336 ++wrote 2048/2048 bytes at offset 4296206336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296210432 ++wrote 2048/2048 bytes at offset 4296210432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296214528 ++wrote 2048/2048 bytes at offset 4296214528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296218624 ++wrote 2048/2048 bytes at offset 4296218624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296222720 ++wrote 2048/2048 bytes at offset 4296222720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296226816 ++wrote 2048/2048 bytes at offset 4296226816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296230912 ++wrote 2048/2048 bytes at offset 4296230912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296235008 ++wrote 2048/2048 bytes at offset 4296235008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296239104 ++wrote 2048/2048 bytes at offset 4296239104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296243200 ++wrote 2048/2048 bytes at offset 4296243200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296247296 ++wrote 2048/2048 bytes at offset 4296247296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296251392 ++wrote 2048/2048 bytes at offset 4296251392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296255488 ++wrote 2048/2048 bytes at offset 4296255488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296259584 ++wrote 2048/2048 bytes at offset 4296259584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296263680 ++wrote 2048/2048 bytes at offset 4296263680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296267776 ++wrote 2048/2048 bytes at offset 4296267776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296271872 ++wrote 2048/2048 bytes at offset 4296271872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296275968 ++wrote 2048/2048 bytes at offset 4296275968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296280064 ++wrote 2048/2048 bytes at offset 4296280064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296284160 ++wrote 2048/2048 bytes at offset 4296284160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296288256 ++wrote 2048/2048 bytes at offset 4296288256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296292352 ++wrote 2048/2048 bytes at offset 4296292352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296296448 ++wrote 2048/2048 bytes at offset 4296296448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296300544 ++wrote 2048/2048 bytes at offset 4296300544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296304640 ++wrote 2048/2048 bytes at offset 4296304640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296308736 ++wrote 2048/2048 bytes at offset 4296308736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296312832 ++wrote 2048/2048 bytes at offset 4296312832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296316928 ++wrote 2048/2048 bytes at offset 4296316928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296321024 ++wrote 2048/2048 bytes at offset 4296321024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296325120 ++wrote 2048/2048 bytes at offset 4296325120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296329216 ++wrote 2048/2048 bytes at offset 4296329216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296333312 ++wrote 2048/2048 bytes at offset 4296333312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296337408 ++wrote 2048/2048 bytes at offset 4296337408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296341504 ++wrote 2048/2048 bytes at offset 4296341504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296345600 ++wrote 2048/2048 bytes at offset 4296345600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296349696 ++wrote 2048/2048 bytes at offset 4296349696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296353792 ++wrote 2048/2048 bytes at offset 4296353792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296357888 ++wrote 2048/2048 bytes at offset 4296357888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296361984 ++wrote 2048/2048 bytes at offset 4296361984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296366080 ++wrote 2048/2048 bytes at offset 4296366080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296370176 ++wrote 2048/2048 bytes at offset 4296370176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296374272 ++wrote 2048/2048 bytes at offset 4296374272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296378368 ++wrote 2048/2048 bytes at offset 4296378368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296382464 ++wrote 2048/2048 bytes at offset 4296382464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296386560 ++wrote 2048/2048 bytes at offset 4296386560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296390656 ++wrote 2048/2048 bytes at offset 4296390656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296394752 ++wrote 2048/2048 bytes at offset 4296394752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296398848 ++wrote 2048/2048 bytes at offset 4296398848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296402944 ++wrote 2048/2048 bytes at offset 4296402944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296407040 ++wrote 2048/2048 bytes at offset 4296407040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296411136 ++wrote 2048/2048 bytes at offset 4296411136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296415232 ++wrote 2048/2048 bytes at offset 4296415232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296419328 ++wrote 2048/2048 bytes at offset 4296419328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296423424 ++wrote 2048/2048 bytes at offset 4296423424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296427520 ++wrote 2048/2048 bytes at offset 4296427520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296431616 ++wrote 2048/2048 bytes at offset 4296431616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296435712 ++wrote 2048/2048 bytes at offset 4296435712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296439808 ++wrote 2048/2048 bytes at offset 4296439808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296443904 ++wrote 2048/2048 bytes at offset 4296443904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296448000 ++wrote 2048/2048 bytes at offset 4296448000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296452096 ++wrote 2048/2048 bytes at offset 4296452096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296456192 ++wrote 2048/2048 bytes at offset 4296456192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296460288 ++wrote 2048/2048 bytes at offset 4296460288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296464384 ++wrote 2048/2048 bytes at offset 4296464384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296468480 ++wrote 2048/2048 bytes at offset 4296468480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296472576 ++wrote 2048/2048 bytes at offset 4296472576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296476672 ++wrote 2048/2048 bytes at offset 4296476672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296480768 ++wrote 2048/2048 bytes at offset 4296480768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296484864 ++wrote 2048/2048 bytes at offset 4296484864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296488960 ++wrote 2048/2048 bytes at offset 4296488960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296493056 ++wrote 2048/2048 bytes at offset 4296493056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296497152 ++wrote 2048/2048 bytes at offset 4296497152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296501248 ++wrote 2048/2048 bytes at offset 4296501248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296505344 ++wrote 2048/2048 bytes at offset 4296505344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296509440 ++wrote 2048/2048 bytes at offset 4296509440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296513536 ++wrote 2048/2048 bytes at offset 4296513536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296517632 ++wrote 2048/2048 bytes at offset 4296517632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296521728 ++wrote 2048/2048 bytes at offset 4296521728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296525824 ++wrote 2048/2048 bytes at offset 4296525824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296529920 ++wrote 2048/2048 bytes at offset 4296529920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296534016 ++wrote 2048/2048 bytes at offset 4296534016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296538112 ++wrote 2048/2048 bytes at offset 4296538112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296542208 ++wrote 2048/2048 bytes at offset 4296542208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296546304 ++wrote 2048/2048 bytes at offset 4296546304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296550400 ++wrote 2048/2048 bytes at offset 4296550400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296554496 ++wrote 2048/2048 bytes at offset 4296554496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296558592 ++wrote 2048/2048 bytes at offset 4296558592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296562688 ++wrote 2048/2048 bytes at offset 4296562688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296566784 ++wrote 2048/2048 bytes at offset 4296566784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296570880 ++wrote 2048/2048 bytes at offset 4296570880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296574976 ++wrote 2048/2048 bytes at offset 4296574976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296579072 ++wrote 2048/2048 bytes at offset 4296579072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296583168 ++wrote 2048/2048 bytes at offset 4296583168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296587264 ++wrote 2048/2048 bytes at offset 4296587264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296591360 ++wrote 2048/2048 bytes at offset 4296591360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296595456 ++wrote 2048/2048 bytes at offset 4296595456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296599552 ++wrote 2048/2048 bytes at offset 4296599552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296603648 ++wrote 2048/2048 bytes at offset 4296603648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296607744 ++wrote 2048/2048 bytes at offset 4296607744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296611840 ++wrote 2048/2048 bytes at offset 4296611840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296615936 ++wrote 2048/2048 bytes at offset 4296615936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296620032 ++wrote 2048/2048 bytes at offset 4296620032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296624128 ++wrote 2048/2048 bytes at offset 4296624128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296628224 ++wrote 2048/2048 bytes at offset 4296628224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296632320 ++wrote 2048/2048 bytes at offset 4296632320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296636416 ++wrote 2048/2048 bytes at offset 4296636416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296640512 ++wrote 2048/2048 bytes at offset 4296640512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296644608 ++wrote 2048/2048 bytes at offset 4296644608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296648704 ++wrote 2048/2048 bytes at offset 4296648704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296652800 ++wrote 2048/2048 bytes at offset 4296652800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296656896 ++wrote 2048/2048 bytes at offset 4296656896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296660992 ++wrote 2048/2048 bytes at offset 4296660992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296665088 ++wrote 2048/2048 bytes at offset 4296665088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296669184 ++wrote 2048/2048 bytes at offset 4296669184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296673280 ++wrote 2048/2048 bytes at offset 4296673280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296677376 ++wrote 2048/2048 bytes at offset 4296677376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296681472 ++wrote 2048/2048 bytes at offset 4296681472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296685568 ++wrote 2048/2048 bytes at offset 4296685568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296689664 ++wrote 2048/2048 bytes at offset 4296689664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296693760 ++wrote 2048/2048 bytes at offset 4296693760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296697856 ++wrote 2048/2048 bytes at offset 4296697856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296701952 ++wrote 2048/2048 bytes at offset 4296701952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296706048 ++wrote 2048/2048 bytes at offset 4296706048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296710144 ++wrote 2048/2048 bytes at offset 4296710144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296714240 ++wrote 2048/2048 bytes at offset 4296714240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296718336 ++wrote 2048/2048 bytes at offset 4296718336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296722432 ++wrote 2048/2048 bytes at offset 4296722432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296726528 ++wrote 2048/2048 bytes at offset 4296726528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296730624 ++wrote 2048/2048 bytes at offset 4296730624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296734720 ++wrote 2048/2048 bytes at offset 4296734720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296738816 ++wrote 2048/2048 bytes at offset 4296738816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296742912 ++wrote 2048/2048 bytes at offset 4296742912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296747008 ++wrote 2048/2048 bytes at offset 4296747008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296751104 ++wrote 2048/2048 bytes at offset 4296751104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296755200 ++wrote 2048/2048 bytes at offset 4296755200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296759296 ++wrote 2048/2048 bytes at offset 4296759296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296763392 ++wrote 2048/2048 bytes at offset 4296763392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296767488 ++wrote 2048/2048 bytes at offset 4296767488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296771584 ++wrote 2048/2048 bytes at offset 4296771584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296775680 ++wrote 2048/2048 bytes at offset 4296775680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296779776 ++wrote 2048/2048 bytes at offset 4296779776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296783872 ++wrote 2048/2048 bytes at offset 4296783872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296787968 ++wrote 2048/2048 bytes at offset 4296787968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296792064 ++wrote 2048/2048 bytes at offset 4296792064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296796160 ++wrote 2048/2048 bytes at offset 4296796160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296800256 ++wrote 2048/2048 bytes at offset 4296800256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296804352 ++wrote 2048/2048 bytes at offset 4296804352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296808448 ++wrote 2048/2048 bytes at offset 4296808448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296812544 ++wrote 2048/2048 bytes at offset 4296812544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296816640 ++wrote 2048/2048 bytes at offset 4296816640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296820736 ++wrote 2048/2048 bytes at offset 4296820736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296824832 ++wrote 2048/2048 bytes at offset 4296824832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296828928 ++wrote 2048/2048 bytes at offset 4296828928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296833024 ++wrote 2048/2048 bytes at offset 4296833024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296837120 ++wrote 2048/2048 bytes at offset 4296837120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296841216 ++wrote 2048/2048 bytes at offset 4296841216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296845312 ++wrote 2048/2048 bytes at offset 4296845312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296849408 ++wrote 2048/2048 bytes at offset 4296849408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296853504 ++wrote 2048/2048 bytes at offset 4296853504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296857600 ++wrote 2048/2048 bytes at offset 4296857600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296861696 ++wrote 2048/2048 bytes at offset 4296861696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296865792 ++wrote 2048/2048 bytes at offset 4296865792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296869888 ++wrote 2048/2048 bytes at offset 4296869888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296873984 ++wrote 2048/2048 bytes at offset 4296873984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296878080 ++wrote 2048/2048 bytes at offset 4296878080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296882176 ++wrote 2048/2048 bytes at offset 4296882176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296886272 ++wrote 2048/2048 bytes at offset 4296886272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296890368 ++wrote 2048/2048 bytes at offset 4296890368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296894464 ++wrote 2048/2048 bytes at offset 4296894464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296898560 ++wrote 2048/2048 bytes at offset 4296898560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296902656 ++wrote 2048/2048 bytes at offset 4296902656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296906752 ++wrote 2048/2048 bytes at offset 4296906752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296910848 ++wrote 2048/2048 bytes at offset 4296910848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296914944 ++wrote 2048/2048 bytes at offset 4296914944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296919040 ++wrote 2048/2048 bytes at offset 4296919040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296923136 ++wrote 2048/2048 bytes at offset 4296923136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296927232 ++wrote 2048/2048 bytes at offset 4296927232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296931328 ++wrote 2048/2048 bytes at offset 4296931328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296935424 ++wrote 2048/2048 bytes at offset 4296935424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296939520 ++wrote 2048/2048 bytes at offset 4296939520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296943616 ++wrote 2048/2048 bytes at offset 4296943616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296947712 ++wrote 2048/2048 bytes at offset 4296947712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296951808 ++wrote 2048/2048 bytes at offset 4296951808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296955904 ++wrote 2048/2048 bytes at offset 4296955904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296960000 ++wrote 2048/2048 bytes at offset 4296960000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296964096 ++wrote 2048/2048 bytes at offset 4296964096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296968192 ++wrote 2048/2048 bytes at offset 4296968192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296972288 ++wrote 2048/2048 bytes at offset 4296972288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296976384 ++wrote 2048/2048 bytes at offset 4296976384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296980480 ++wrote 2048/2048 bytes at offset 4296980480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296984576 ++wrote 2048/2048 bytes at offset 4296984576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296988672 ++wrote 2048/2048 bytes at offset 4296988672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296992768 ++wrote 2048/2048 bytes at offset 4296992768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296996864 ++wrote 2048/2048 bytes at offset 4296996864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297000960 ++wrote 2048/2048 bytes at offset 4297000960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297005056 ++wrote 2048/2048 bytes at offset 4297005056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297009152 ++wrote 2048/2048 bytes at offset 4297009152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297013248 ++wrote 2048/2048 bytes at offset 4297013248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297017344 ++wrote 2048/2048 bytes at offset 4297017344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297021440 ++wrote 2048/2048 bytes at offset 4297021440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297025536 ++wrote 2048/2048 bytes at offset 4297025536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297029632 ++wrote 2048/2048 bytes at offset 4297029632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297033728 ++wrote 2048/2048 bytes at offset 4297033728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297037824 ++wrote 2048/2048 bytes at offset 4297037824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297041920 ++wrote 2048/2048 bytes at offset 4297041920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297046016 ++wrote 2048/2048 bytes at offset 4297046016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297050112 ++wrote 2048/2048 bytes at offset 4297050112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297054208 ++wrote 2048/2048 bytes at offset 4297054208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297058304 ++wrote 2048/2048 bytes at offset 4297058304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297062400 ++wrote 2048/2048 bytes at offset 4297062400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> wrote 2048/2048 bytes at offset 4297064448 ++=== IO: pattern 0 ++wrote 2048/2048 bytes at offset 4297064448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297068544 ++wrote 2048/2048 bytes at offset 4297068544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297072640 ++wrote 2048/2048 bytes at offset 4297072640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297076736 ++wrote 2048/2048 bytes at offset 4297076736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297080832 ++wrote 2048/2048 bytes at offset 4297080832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297084928 ++wrote 2048/2048 bytes at offset 4297084928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297089024 ++wrote 2048/2048 bytes at offset 4297089024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297093120 ++wrote 2048/2048 bytes at offset 4297093120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297097216 ++wrote 2048/2048 bytes at offset 4297097216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297101312 ++wrote 2048/2048 bytes at offset 4297101312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297105408 ++wrote 2048/2048 bytes at offset 4297105408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297109504 ++wrote 2048/2048 bytes at offset 4297109504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297113600 ++wrote 2048/2048 bytes at offset 4297113600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297117696 ++wrote 2048/2048 bytes at offset 4297117696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297121792 ++wrote 2048/2048 bytes at offset 4297121792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297125888 ++wrote 2048/2048 bytes at offset 4297125888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297129984 ++wrote 2048/2048 bytes at offset 4297129984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297134080 ++wrote 2048/2048 bytes at offset 4297134080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297138176 ++wrote 2048/2048 bytes at offset 4297138176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297142272 ++wrote 2048/2048 bytes at offset 4297142272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297146368 ++wrote 2048/2048 bytes at offset 4297146368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297150464 ++wrote 2048/2048 bytes at offset 4297150464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297154560 ++wrote 2048/2048 bytes at offset 4297154560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297158656 ++wrote 2048/2048 bytes at offset 4297158656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297162752 ++wrote 2048/2048 bytes at offset 4297162752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297166848 ++wrote 2048/2048 bytes at offset 4297166848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297170944 ++wrote 2048/2048 bytes at offset 4297170944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297175040 ++wrote 2048/2048 bytes at offset 4297175040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297179136 ++wrote 2048/2048 bytes at offset 4297179136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297183232 ++wrote 2048/2048 bytes at offset 4297183232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297187328 ++wrote 2048/2048 bytes at offset 4297187328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297191424 ++wrote 2048/2048 bytes at offset 4297191424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297195520 ++wrote 2048/2048 bytes at offset 4297195520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297199616 ++wrote 2048/2048 bytes at offset 4297199616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297203712 ++wrote 2048/2048 bytes at offset 4297203712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297207808 ++wrote 2048/2048 bytes at offset 4297207808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297211904 ++wrote 2048/2048 bytes at offset 4297211904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297216000 ++wrote 2048/2048 bytes at offset 4297216000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297220096 ++wrote 2048/2048 bytes at offset 4297220096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297224192 ++wrote 2048/2048 bytes at offset 4297224192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297228288 ++wrote 2048/2048 bytes at offset 4297228288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297232384 ++wrote 2048/2048 bytes at offset 4297232384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297236480 ++wrote 2048/2048 bytes at offset 4297236480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297240576 ++wrote 2048/2048 bytes at offset 4297240576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297244672 ++wrote 2048/2048 bytes at offset 4297244672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297248768 ++wrote 2048/2048 bytes at offset 4297248768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297252864 ++wrote 2048/2048 bytes at offset 4297252864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297256960 ++wrote 2048/2048 bytes at offset 4297256960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297261056 ++wrote 2048/2048 bytes at offset 4297261056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297265152 ++wrote 2048/2048 bytes at offset 4297265152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297269248 ++wrote 2048/2048 bytes at offset 4297269248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297273344 ++wrote 2048/2048 bytes at offset 4297273344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297277440 ++wrote 2048/2048 bytes at offset 4297277440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297281536 ++wrote 2048/2048 bytes at offset 4297281536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297285632 ++wrote 2048/2048 bytes at offset 4297285632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297289728 ++wrote 2048/2048 bytes at offset 4297289728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297293824 ++wrote 2048/2048 bytes at offset 4297293824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297297920 ++wrote 2048/2048 bytes at offset 4297297920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297302016 ++wrote 2048/2048 bytes at offset 4297302016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297306112 ++wrote 2048/2048 bytes at offset 4297306112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297310208 ++wrote 2048/2048 bytes at offset 4297310208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297314304 ++wrote 2048/2048 bytes at offset 4297314304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297318400 ++wrote 2048/2048 bytes at offset 4297318400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297322496 ++wrote 2048/2048 bytes at offset 4297322496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297326592 ++wrote 2048/2048 bytes at offset 4297326592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297330688 ++wrote 2048/2048 bytes at offset 4297330688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297334784 ++wrote 2048/2048 bytes at offset 4297334784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297338880 ++wrote 2048/2048 bytes at offset 4297338880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297342976 ++wrote 2048/2048 bytes at offset 4297342976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297347072 ++wrote 2048/2048 bytes at offset 4297347072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297351168 ++wrote 2048/2048 bytes at offset 4297351168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297355264 ++wrote 2048/2048 bytes at offset 4297355264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297359360 ++wrote 2048/2048 bytes at offset 4297359360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297363456 ++wrote 2048/2048 bytes at offset 4297363456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297367552 ++wrote 2048/2048 bytes at offset 4297367552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297371648 ++wrote 2048/2048 bytes at offset 4297371648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297375744 ++wrote 2048/2048 bytes at offset 4297375744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297379840 ++wrote 2048/2048 bytes at offset 4297379840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297383936 ++wrote 2048/2048 bytes at offset 4297383936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297388032 ++wrote 2048/2048 bytes at offset 4297388032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297392128 ++wrote 2048/2048 bytes at offset 4297392128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297396224 ++wrote 2048/2048 bytes at offset 4297396224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297400320 ++wrote 2048/2048 bytes at offset 4297400320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297404416 ++wrote 2048/2048 bytes at offset 4297404416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297408512 ++wrote 2048/2048 bytes at offset 4297408512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297412608 ++wrote 2048/2048 bytes at offset 4297412608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297416704 ++wrote 2048/2048 bytes at offset 4297416704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297420800 ++wrote 2048/2048 bytes at offset 4297420800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297424896 ++wrote 2048/2048 bytes at offset 4297424896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297428992 ++wrote 2048/2048 bytes at offset 4297428992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297433088 ++wrote 2048/2048 bytes at offset 4297433088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297437184 ++wrote 2048/2048 bytes at offset 4297437184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297441280 ++wrote 2048/2048 bytes at offset 4297441280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297445376 ++wrote 2048/2048 bytes at offset 4297445376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297449472 ++wrote 2048/2048 bytes at offset 4297449472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297453568 ++wrote 2048/2048 bytes at offset 4297453568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297457664 ++wrote 2048/2048 bytes at offset 4297457664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297461760 ++wrote 2048/2048 bytes at offset 4297461760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297465856 ++wrote 2048/2048 bytes at offset 4297465856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297469952 ++wrote 2048/2048 bytes at offset 4297469952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297474048 ++wrote 2048/2048 bytes at offset 4297474048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297478144 ++wrote 2048/2048 bytes at offset 4297478144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297482240 ++wrote 2048/2048 bytes at offset 4297482240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297486336 ++wrote 2048/2048 bytes at offset 4297486336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297490432 ++wrote 2048/2048 bytes at offset 4297490432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297494528 ++wrote 2048/2048 bytes at offset 4297494528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297498624 ++wrote 2048/2048 bytes at offset 4297498624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297502720 ++wrote 2048/2048 bytes at offset 4297502720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297506816 ++wrote 2048/2048 bytes at offset 4297506816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297510912 ++wrote 2048/2048 bytes at offset 4297510912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297515008 ++wrote 2048/2048 bytes at offset 4297515008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297519104 ++wrote 2048/2048 bytes at offset 4297519104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297523200 ++wrote 2048/2048 bytes at offset 4297523200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297527296 ++wrote 2048/2048 bytes at offset 4297527296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297531392 ++wrote 2048/2048 bytes at offset 4297531392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297535488 ++wrote 2048/2048 bytes at offset 4297535488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297539584 ++wrote 2048/2048 bytes at offset 4297539584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297543680 ++wrote 2048/2048 bytes at offset 4297543680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297547776 ++wrote 2048/2048 bytes at offset 4297547776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297551872 ++wrote 2048/2048 bytes at offset 4297551872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297555968 ++wrote 2048/2048 bytes at offset 4297555968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297560064 ++wrote 2048/2048 bytes at offset 4297560064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297564160 ++wrote 2048/2048 bytes at offset 4297564160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297568256 ++wrote 2048/2048 bytes at offset 4297568256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297572352 ++wrote 2048/2048 bytes at offset 4297572352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297576448 ++wrote 2048/2048 bytes at offset 4297576448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297580544 ++wrote 2048/2048 bytes at offset 4297580544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297584640 ++wrote 2048/2048 bytes at offset 4297584640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297588736 ++wrote 2048/2048 bytes at offset 4297588736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297592832 ++wrote 2048/2048 bytes at offset 4297592832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297596928 ++wrote 2048/2048 bytes at offset 4297596928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297601024 ++wrote 2048/2048 bytes at offset 4297601024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297605120 ++wrote 2048/2048 bytes at offset 4297605120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297609216 ++wrote 2048/2048 bytes at offset 4297609216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297613312 ++wrote 2048/2048 bytes at offset 4297613312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297617408 ++wrote 2048/2048 bytes at offset 4297617408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297621504 ++wrote 2048/2048 bytes at offset 4297621504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297625600 ++wrote 2048/2048 bytes at offset 4297625600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297629696 ++wrote 2048/2048 bytes at offset 4297629696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297633792 ++wrote 2048/2048 bytes at offset 4297633792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297637888 ++wrote 2048/2048 bytes at offset 4297637888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297641984 ++wrote 2048/2048 bytes at offset 4297641984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297646080 ++wrote 2048/2048 bytes at offset 4297646080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297650176 ++wrote 2048/2048 bytes at offset 4297650176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297654272 ++wrote 2048/2048 bytes at offset 4297654272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297658368 ++wrote 2048/2048 bytes at offset 4297658368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297662464 ++wrote 2048/2048 bytes at offset 4297662464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297666560 ++wrote 2048/2048 bytes at offset 4297666560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297670656 ++wrote 2048/2048 bytes at offset 4297670656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297674752 ++wrote 2048/2048 bytes at offset 4297674752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297678848 ++wrote 2048/2048 bytes at offset 4297678848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297682944 ++wrote 2048/2048 bytes at offset 4297682944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297687040 ++wrote 2048/2048 bytes at offset 4297687040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297691136 ++wrote 2048/2048 bytes at offset 4297691136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297695232 ++wrote 2048/2048 bytes at offset 4297695232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297699328 ++wrote 2048/2048 bytes at offset 4297699328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297703424 ++wrote 2048/2048 bytes at offset 4297703424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297707520 ++wrote 2048/2048 bytes at offset 4297707520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297711616 ++wrote 2048/2048 bytes at offset 4297711616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297715712 ++wrote 2048/2048 bytes at offset 4297715712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297719808 ++wrote 2048/2048 bytes at offset 4297719808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297723904 ++wrote 2048/2048 bytes at offset 4297723904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297728000 ++wrote 2048/2048 bytes at offset 4297728000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297732096 ++wrote 2048/2048 bytes at offset 4297732096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297736192 ++wrote 2048/2048 bytes at offset 4297736192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297740288 ++wrote 2048/2048 bytes at offset 4297740288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297744384 ++wrote 2048/2048 bytes at offset 4297744384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297748480 ++wrote 2048/2048 bytes at offset 4297748480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297752576 ++wrote 2048/2048 bytes at offset 4297752576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297756672 ++wrote 2048/2048 bytes at offset 4297756672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297760768 ++wrote 2048/2048 bytes at offset 4297760768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297764864 ++wrote 2048/2048 bytes at offset 4297764864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297768960 ++wrote 2048/2048 bytes at offset 4297768960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297773056 ++wrote 2048/2048 bytes at offset 4297773056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297777152 ++wrote 2048/2048 bytes at offset 4297777152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297781248 ++wrote 2048/2048 bytes at offset 4297781248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297785344 ++wrote 2048/2048 bytes at offset 4297785344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297789440 ++wrote 2048/2048 bytes at offset 4297789440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297793536 ++wrote 2048/2048 bytes at offset 4297793536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297797632 ++wrote 2048/2048 bytes at offset 4297797632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297801728 ++wrote 2048/2048 bytes at offset 4297801728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297805824 ++wrote 2048/2048 bytes at offset 4297805824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297809920 ++wrote 2048/2048 bytes at offset 4297809920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297814016 ++wrote 2048/2048 bytes at offset 4297814016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297818112 ++wrote 2048/2048 bytes at offset 4297818112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297822208 ++wrote 2048/2048 bytes at offset 4297822208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297826304 ++wrote 2048/2048 bytes at offset 4297826304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297830400 ++wrote 2048/2048 bytes at offset 4297830400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297834496 ++wrote 2048/2048 bytes at offset 4297834496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297838592 ++wrote 2048/2048 bytes at offset 4297838592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297842688 ++wrote 2048/2048 bytes at offset 4297842688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297846784 ++wrote 2048/2048 bytes at offset 4297846784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297850880 ++wrote 2048/2048 bytes at offset 4297850880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297854976 ++wrote 2048/2048 bytes at offset 4297854976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297859072 ++wrote 2048/2048 bytes at offset 4297859072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297863168 ++wrote 2048/2048 bytes at offset 4297863168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297867264 ++wrote 2048/2048 bytes at offset 4297867264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297871360 ++wrote 2048/2048 bytes at offset 4297871360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297875456 ++wrote 2048/2048 bytes at offset 4297875456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297879552 ++wrote 2048/2048 bytes at offset 4297879552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297883648 ++wrote 2048/2048 bytes at offset 4297883648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297887744 ++wrote 2048/2048 bytes at offset 4297887744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297891840 ++wrote 2048/2048 bytes at offset 4297891840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297895936 ++wrote 2048/2048 bytes at offset 4297895936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297900032 ++wrote 2048/2048 bytes at offset 4297900032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297904128 ++wrote 2048/2048 bytes at offset 4297904128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297908224 ++wrote 2048/2048 bytes at offset 4297908224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297912320 ++wrote 2048/2048 bytes at offset 4297912320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297916416 ++wrote 2048/2048 bytes at offset 4297916416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297920512 ++wrote 2048/2048 bytes at offset 4297920512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297924608 ++wrote 2048/2048 bytes at offset 4297924608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297928704 ++wrote 2048/2048 bytes at offset 4297928704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297932800 ++wrote 2048/2048 bytes at offset 4297932800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297936896 ++wrote 2048/2048 bytes at offset 4297936896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297940992 ++wrote 2048/2048 bytes at offset 4297940992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297945088 ++wrote 2048/2048 bytes at offset 4297945088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297949184 ++wrote 2048/2048 bytes at offset 4297949184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297953280 ++wrote 2048/2048 bytes at offset 4297953280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297957376 ++wrote 2048/2048 bytes at offset 4297957376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297961472 ++wrote 2048/2048 bytes at offset 4297961472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297965568 ++wrote 2048/2048 bytes at offset 4297965568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297969664 ++wrote 2048/2048 bytes at offset 4297969664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297973760 ++wrote 2048/2048 bytes at offset 4297973760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297977856 ++wrote 2048/2048 bytes at offset 4297977856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297981952 ++wrote 2048/2048 bytes at offset 4297981952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297986048 ++wrote 2048/2048 bytes at offset 4297986048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297990144 ++wrote 2048/2048 bytes at offset 4297990144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297994240 ++wrote 2048/2048 bytes at offset 4297994240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297998336 ++wrote 2048/2048 bytes at offset 4297998336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298002432 ++wrote 2048/2048 bytes at offset 4298002432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298006528 ++wrote 2048/2048 bytes at offset 4298006528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298010624 ++wrote 2048/2048 bytes at offset 4298010624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298014720 ++wrote 2048/2048 bytes at offset 4298014720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298018816 ++wrote 2048/2048 bytes at offset 4298018816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298022912 ++wrote 2048/2048 bytes at offset 4298022912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298027008 ++wrote 2048/2048 bytes at offset 4298027008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298031104 ++wrote 2048/2048 bytes at offset 4298031104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298035200 ++wrote 2048/2048 bytes at offset 4298035200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298039296 ++wrote 2048/2048 bytes at offset 4298039296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298043392 ++wrote 2048/2048 bytes at offset 4298043392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298047488 ++wrote 2048/2048 bytes at offset 4298047488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298051584 ++wrote 2048/2048 bytes at offset 4298051584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298055680 ++wrote 2048/2048 bytes at offset 4298055680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298059776 ++wrote 2048/2048 bytes at offset 4298059776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298063872 ++wrote 2048/2048 bytes at offset 4298063872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298067968 ++wrote 2048/2048 bytes at offset 4298067968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298072064 ++wrote 2048/2048 bytes at offset 4298072064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298076160 ++wrote 2048/2048 bytes at offset 4298076160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298080256 ++wrote 2048/2048 bytes at offset 4298080256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298084352 ++wrote 2048/2048 bytes at offset 4298084352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298088448 ++wrote 2048/2048 bytes at offset 4298088448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298092544 ++wrote 2048/2048 bytes at offset 4298092544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298096640 ++wrote 2048/2048 bytes at offset 4298096640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298100736 ++wrote 2048/2048 bytes at offset 4298100736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298104832 ++wrote 2048/2048 bytes at offset 4298104832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298108928 ++wrote 2048/2048 bytes at offset 4298108928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 2 +-qemu-io> wrote 2048/2048 bytes at offset 4298114048 ++=== IO: pattern 2 ++wrote 2048/2048 bytes at offset 4298114048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298118144 ++wrote 2048/2048 bytes at offset 4298118144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298122240 ++wrote 2048/2048 bytes at offset 4298122240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298126336 ++wrote 2048/2048 bytes at offset 4298126336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298130432 ++wrote 2048/2048 bytes at offset 4298130432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298134528 ++wrote 2048/2048 bytes at offset 4298134528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298138624 ++wrote 2048/2048 bytes at offset 4298138624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298142720 ++wrote 2048/2048 bytes at offset 4298142720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298146816 ++wrote 2048/2048 bytes at offset 4298146816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298150912 ++wrote 2048/2048 bytes at offset 4298150912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298155008 ++wrote 2048/2048 bytes at offset 4298155008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298159104 ++wrote 2048/2048 bytes at offset 4298159104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298163200 ++wrote 2048/2048 bytes at offset 4298163200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298167296 ++wrote 2048/2048 bytes at offset 4298167296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298171392 ++wrote 2048/2048 bytes at offset 4298171392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298175488 ++wrote 2048/2048 bytes at offset 4298175488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298179584 ++wrote 2048/2048 bytes at offset 4298179584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298183680 ++wrote 2048/2048 bytes at offset 4298183680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298187776 ++wrote 2048/2048 bytes at offset 4298187776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298191872 ++wrote 2048/2048 bytes at offset 4298191872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298195968 ++wrote 2048/2048 bytes at offset 4298195968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298200064 ++wrote 2048/2048 bytes at offset 4298200064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298204160 ++wrote 2048/2048 bytes at offset 4298204160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298208256 ++wrote 2048/2048 bytes at offset 4298208256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298212352 ++wrote 2048/2048 bytes at offset 4298212352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298216448 ++wrote 2048/2048 bytes at offset 4298216448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298220544 ++wrote 2048/2048 bytes at offset 4298220544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298224640 ++wrote 2048/2048 bytes at offset 4298224640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298228736 ++wrote 2048/2048 bytes at offset 4298228736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298232832 ++wrote 2048/2048 bytes at offset 4298232832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298236928 ++wrote 2048/2048 bytes at offset 4298236928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298241024 ++wrote 2048/2048 bytes at offset 4298241024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298245120 ++wrote 2048/2048 bytes at offset 4298245120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298249216 ++wrote 2048/2048 bytes at offset 4298249216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298253312 ++wrote 2048/2048 bytes at offset 4298253312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298257408 ++wrote 2048/2048 bytes at offset 4298257408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298261504 ++wrote 2048/2048 bytes at offset 4298261504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298265600 ++wrote 2048/2048 bytes at offset 4298265600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298269696 ++wrote 2048/2048 bytes at offset 4298269696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298273792 ++wrote 2048/2048 bytes at offset 4298273792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298277888 ++wrote 2048/2048 bytes at offset 4298277888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298281984 ++wrote 2048/2048 bytes at offset 4298281984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298286080 ++wrote 2048/2048 bytes at offset 4298286080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298290176 ++wrote 2048/2048 bytes at offset 4298290176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298294272 ++wrote 2048/2048 bytes at offset 4298294272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298298368 ++wrote 2048/2048 bytes at offset 4298298368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298302464 ++wrote 2048/2048 bytes at offset 4298302464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298306560 ++wrote 2048/2048 bytes at offset 4298306560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298310656 ++wrote 2048/2048 bytes at offset 4298310656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298314752 ++wrote 2048/2048 bytes at offset 4298314752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298318848 ++wrote 2048/2048 bytes at offset 4298318848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298322944 ++wrote 2048/2048 bytes at offset 4298322944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298327040 ++wrote 2048/2048 bytes at offset 4298327040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298331136 ++wrote 2048/2048 bytes at offset 4298331136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298335232 ++wrote 2048/2048 bytes at offset 4298335232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298339328 ++wrote 2048/2048 bytes at offset 4298339328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298343424 ++wrote 2048/2048 bytes at offset 4298343424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298347520 ++wrote 2048/2048 bytes at offset 4298347520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298351616 ++wrote 2048/2048 bytes at offset 4298351616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298355712 ++wrote 2048/2048 bytes at offset 4298355712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298359808 ++wrote 2048/2048 bytes at offset 4298359808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298363904 ++wrote 2048/2048 bytes at offset 4298363904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298368000 ++wrote 2048/2048 bytes at offset 4298368000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298372096 ++wrote 2048/2048 bytes at offset 4298372096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298376192 ++wrote 2048/2048 bytes at offset 4298376192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298380288 ++wrote 2048/2048 bytes at offset 4298380288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298384384 ++wrote 2048/2048 bytes at offset 4298384384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298388480 ++wrote 2048/2048 bytes at offset 4298388480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298392576 ++wrote 2048/2048 bytes at offset 4298392576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298396672 ++wrote 2048/2048 bytes at offset 4298396672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298400768 ++wrote 2048/2048 bytes at offset 4298400768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298404864 ++wrote 2048/2048 bytes at offset 4298404864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298408960 ++wrote 2048/2048 bytes at offset 4298408960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298413056 ++wrote 2048/2048 bytes at offset 4298413056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298417152 ++wrote 2048/2048 bytes at offset 4298417152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298421248 ++wrote 2048/2048 bytes at offset 4298421248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298425344 ++wrote 2048/2048 bytes at offset 4298425344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298429440 ++wrote 2048/2048 bytes at offset 4298429440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298433536 ++wrote 2048/2048 bytes at offset 4298433536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298437632 ++wrote 2048/2048 bytes at offset 4298437632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298441728 ++wrote 2048/2048 bytes at offset 4298441728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298445824 ++wrote 2048/2048 bytes at offset 4298445824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298449920 ++wrote 2048/2048 bytes at offset 4298449920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298454016 ++wrote 2048/2048 bytes at offset 4298454016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298458112 ++wrote 2048/2048 bytes at offset 4298458112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298462208 ++wrote 2048/2048 bytes at offset 4298462208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298466304 ++wrote 2048/2048 bytes at offset 4298466304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298470400 ++wrote 2048/2048 bytes at offset 4298470400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298474496 ++wrote 2048/2048 bytes at offset 4298474496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298478592 ++wrote 2048/2048 bytes at offset 4298478592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298482688 ++wrote 2048/2048 bytes at offset 4298482688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298486784 ++wrote 2048/2048 bytes at offset 4298486784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298490880 ++wrote 2048/2048 bytes at offset 4298490880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298494976 ++wrote 2048/2048 bytes at offset 4298494976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298499072 ++wrote 2048/2048 bytes at offset 4298499072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298503168 ++wrote 2048/2048 bytes at offset 4298503168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298507264 ++wrote 2048/2048 bytes at offset 4298507264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298511360 ++wrote 2048/2048 bytes at offset 4298511360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298515456 ++wrote 2048/2048 bytes at offset 4298515456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298519552 ++wrote 2048/2048 bytes at offset 4298519552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298523648 ++wrote 2048/2048 bytes at offset 4298523648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298527744 ++wrote 2048/2048 bytes at offset 4298527744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298531840 ++wrote 2048/2048 bytes at offset 4298531840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298535936 ++wrote 2048/2048 bytes at offset 4298535936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298540032 ++wrote 2048/2048 bytes at offset 4298540032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298544128 ++wrote 2048/2048 bytes at offset 4298544128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298548224 ++wrote 2048/2048 bytes at offset 4298548224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298552320 ++wrote 2048/2048 bytes at offset 4298552320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298556416 ++wrote 2048/2048 bytes at offset 4298556416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298560512 ++wrote 2048/2048 bytes at offset 4298560512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298564608 ++wrote 2048/2048 bytes at offset 4298564608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298568704 ++wrote 2048/2048 bytes at offset 4298568704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298572800 ++wrote 2048/2048 bytes at offset 4298572800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298576896 ++wrote 2048/2048 bytes at offset 4298576896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298580992 ++wrote 2048/2048 bytes at offset 4298580992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298585088 ++wrote 2048/2048 bytes at offset 4298585088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298589184 ++wrote 2048/2048 bytes at offset 4298589184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298593280 ++wrote 2048/2048 bytes at offset 4298593280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298597376 ++wrote 2048/2048 bytes at offset 4298597376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298601472 ++wrote 2048/2048 bytes at offset 4298601472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298605568 ++wrote 2048/2048 bytes at offset 4298605568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298609664 ++wrote 2048/2048 bytes at offset 4298609664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298613760 ++wrote 2048/2048 bytes at offset 4298613760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298617856 ++wrote 2048/2048 bytes at offset 4298617856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298621952 ++wrote 2048/2048 bytes at offset 4298621952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298626048 ++wrote 2048/2048 bytes at offset 4298626048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298630144 ++wrote 2048/2048 bytes at offset 4298630144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298634240 ++wrote 2048/2048 bytes at offset 4298634240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298638336 ++wrote 2048/2048 bytes at offset 4298638336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298642432 ++wrote 2048/2048 bytes at offset 4298642432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298646528 ++wrote 2048/2048 bytes at offset 4298646528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298650624 ++wrote 2048/2048 bytes at offset 4298650624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298654720 ++wrote 2048/2048 bytes at offset 4298654720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298658816 ++wrote 2048/2048 bytes at offset 4298658816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298662912 ++wrote 2048/2048 bytes at offset 4298662912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298667008 ++wrote 2048/2048 bytes at offset 4298667008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298671104 ++wrote 2048/2048 bytes at offset 4298671104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298675200 ++wrote 2048/2048 bytes at offset 4298675200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298679296 ++wrote 2048/2048 bytes at offset 4298679296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298683392 ++wrote 2048/2048 bytes at offset 4298683392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298687488 ++wrote 2048/2048 bytes at offset 4298687488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298691584 ++wrote 2048/2048 bytes at offset 4298691584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298695680 ++wrote 2048/2048 bytes at offset 4298695680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298699776 ++wrote 2048/2048 bytes at offset 4298699776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298703872 ++wrote 2048/2048 bytes at offset 4298703872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298707968 ++wrote 2048/2048 bytes at offset 4298707968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298712064 ++wrote 2048/2048 bytes at offset 4298712064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298716160 ++wrote 2048/2048 bytes at offset 4298716160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298720256 ++wrote 2048/2048 bytes at offset 4298720256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298724352 ++wrote 2048/2048 bytes at offset 4298724352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298728448 ++wrote 2048/2048 bytes at offset 4298728448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298732544 ++wrote 2048/2048 bytes at offset 4298732544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298736640 ++wrote 2048/2048 bytes at offset 4298736640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298740736 ++wrote 2048/2048 bytes at offset 4298740736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298744832 ++wrote 2048/2048 bytes at offset 4298744832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298748928 ++wrote 2048/2048 bytes at offset 4298748928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298753024 ++wrote 2048/2048 bytes at offset 4298753024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298757120 ++wrote 2048/2048 bytes at offset 4298757120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298761216 ++wrote 2048/2048 bytes at offset 4298761216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298765312 ++wrote 2048/2048 bytes at offset 4298765312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298769408 ++wrote 2048/2048 bytes at offset 4298769408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298773504 ++wrote 2048/2048 bytes at offset 4298773504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298777600 ++wrote 2048/2048 bytes at offset 4298777600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298781696 ++wrote 2048/2048 bytes at offset 4298781696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298785792 ++wrote 2048/2048 bytes at offset 4298785792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298789888 ++wrote 2048/2048 bytes at offset 4298789888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298793984 ++wrote 2048/2048 bytes at offset 4298793984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298798080 ++wrote 2048/2048 bytes at offset 4298798080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298802176 ++wrote 2048/2048 bytes at offset 4298802176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298806272 ++wrote 2048/2048 bytes at offset 4298806272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298810368 ++wrote 2048/2048 bytes at offset 4298810368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298814464 ++wrote 2048/2048 bytes at offset 4298814464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298818560 ++wrote 2048/2048 bytes at offset 4298818560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298822656 ++wrote 2048/2048 bytes at offset 4298822656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298826752 ++wrote 2048/2048 bytes at offset 4298826752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298830848 ++wrote 2048/2048 bytes at offset 4298830848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298834944 ++wrote 2048/2048 bytes at offset 4298834944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298839040 ++wrote 2048/2048 bytes at offset 4298839040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298843136 ++wrote 2048/2048 bytes at offset 4298843136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298847232 ++wrote 2048/2048 bytes at offset 4298847232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298851328 ++wrote 2048/2048 bytes at offset 4298851328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298855424 ++wrote 2048/2048 bytes at offset 4298855424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298859520 ++wrote 2048/2048 bytes at offset 4298859520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298863616 ++wrote 2048/2048 bytes at offset 4298863616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298867712 ++wrote 2048/2048 bytes at offset 4298867712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298871808 ++wrote 2048/2048 bytes at offset 4298871808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298875904 ++wrote 2048/2048 bytes at offset 4298875904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298880000 ++wrote 2048/2048 bytes at offset 4298880000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298884096 ++wrote 2048/2048 bytes at offset 4298884096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298888192 ++wrote 2048/2048 bytes at offset 4298888192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298892288 ++wrote 2048/2048 bytes at offset 4298892288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298896384 ++wrote 2048/2048 bytes at offset 4298896384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298900480 ++wrote 2048/2048 bytes at offset 4298900480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298904576 ++wrote 2048/2048 bytes at offset 4298904576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298908672 ++wrote 2048/2048 bytes at offset 4298908672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298912768 ++wrote 2048/2048 bytes at offset 4298912768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298916864 ++wrote 2048/2048 bytes at offset 4298916864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298920960 ++wrote 2048/2048 bytes at offset 4298920960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298925056 ++wrote 2048/2048 bytes at offset 4298925056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298929152 ++wrote 2048/2048 bytes at offset 4298929152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298933248 ++wrote 2048/2048 bytes at offset 4298933248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298937344 ++wrote 2048/2048 bytes at offset 4298937344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298941440 ++wrote 2048/2048 bytes at offset 4298941440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298945536 ++wrote 2048/2048 bytes at offset 4298945536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298949632 ++wrote 2048/2048 bytes at offset 4298949632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298953728 ++wrote 2048/2048 bytes at offset 4298953728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298957824 ++wrote 2048/2048 bytes at offset 4298957824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298961920 ++wrote 2048/2048 bytes at offset 4298961920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298966016 ++wrote 2048/2048 bytes at offset 4298966016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298970112 ++wrote 2048/2048 bytes at offset 4298970112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298974208 ++wrote 2048/2048 bytes at offset 4298974208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298978304 ++wrote 2048/2048 bytes at offset 4298978304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298982400 ++wrote 2048/2048 bytes at offset 4298982400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298986496 ++wrote 2048/2048 bytes at offset 4298986496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298990592 ++wrote 2048/2048 bytes at offset 4298990592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298994688 ++wrote 2048/2048 bytes at offset 4298994688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298998784 ++wrote 2048/2048 bytes at offset 4298998784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299002880 ++wrote 2048/2048 bytes at offset 4299002880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299006976 ++wrote 2048/2048 bytes at offset 4299006976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299011072 ++wrote 2048/2048 bytes at offset 4299011072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299015168 ++wrote 2048/2048 bytes at offset 4299015168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299019264 ++wrote 2048/2048 bytes at offset 4299019264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299023360 ++wrote 2048/2048 bytes at offset 4299023360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299027456 ++wrote 2048/2048 bytes at offset 4299027456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299031552 ++wrote 2048/2048 bytes at offset 4299031552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299035648 ++wrote 2048/2048 bytes at offset 4299035648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299039744 ++wrote 2048/2048 bytes at offset 4299039744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299043840 ++wrote 2048/2048 bytes at offset 4299043840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299047936 ++wrote 2048/2048 bytes at offset 4299047936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299052032 ++wrote 2048/2048 bytes at offset 4299052032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299056128 ++wrote 2048/2048 bytes at offset 4299056128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299060224 ++wrote 2048/2048 bytes at offset 4299060224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299064320 ++wrote 2048/2048 bytes at offset 4299064320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299068416 ++wrote 2048/2048 bytes at offset 4299068416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299072512 ++wrote 2048/2048 bytes at offset 4299072512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299076608 ++wrote 2048/2048 bytes at offset 4299076608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299080704 ++wrote 2048/2048 bytes at offset 4299080704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299084800 ++wrote 2048/2048 bytes at offset 4299084800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299088896 ++wrote 2048/2048 bytes at offset 4299088896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299092992 ++wrote 2048/2048 bytes at offset 4299092992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299097088 ++wrote 2048/2048 bytes at offset 4299097088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299101184 ++wrote 2048/2048 bytes at offset 4299101184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299105280 ++wrote 2048/2048 bytes at offset 4299105280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299109376 ++wrote 2048/2048 bytes at offset 4299109376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299113472 ++wrote 2048/2048 bytes at offset 4299113472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299117568 ++wrote 2048/2048 bytes at offset 4299117568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299121664 ++wrote 2048/2048 bytes at offset 4299121664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299125760 ++wrote 2048/2048 bytes at offset 4299125760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299129856 ++wrote 2048/2048 bytes at offset 4299129856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299133952 ++wrote 2048/2048 bytes at offset 4299133952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299138048 ++wrote 2048/2048 bytes at offset 4299138048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299142144 ++wrote 2048/2048 bytes at offset 4299142144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299146240 ++wrote 2048/2048 bytes at offset 4299146240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299150336 ++wrote 2048/2048 bytes at offset 4299150336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299154432 ++wrote 2048/2048 bytes at offset 4299154432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299158528 ++wrote 2048/2048 bytes at offset 4299158528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 4 +-qemu-io> wrote 8192/8192 bytes at offset 4299163648 ++=== IO: pattern 4 ++wrote 8192/8192 bytes at offset 4299163648 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299175936 ++wrote 8192/8192 bytes at offset 4299175936 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299188224 ++wrote 8192/8192 bytes at offset 4299188224 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299200512 ++wrote 8192/8192 bytes at offset 4299200512 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299212800 ++wrote 8192/8192 bytes at offset 4299212800 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299225088 ++wrote 8192/8192 bytes at offset 4299225088 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299237376 ++wrote 8192/8192 bytes at offset 4299237376 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299249664 ++wrote 8192/8192 bytes at offset 4299249664 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299261952 ++wrote 8192/8192 bytes at offset 4299261952 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299274240 ++wrote 8192/8192 bytes at offset 4299274240 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299286528 ++wrote 8192/8192 bytes at offset 4299286528 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299298816 ++wrote 8192/8192 bytes at offset 4299298816 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299311104 ++wrote 8192/8192 bytes at offset 4299311104 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299323392 ++wrote 8192/8192 bytes at offset 4299323392 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299335680 ++wrote 8192/8192 bytes at offset 4299335680 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299347968 ++wrote 8192/8192 bytes at offset 4299347968 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299360256 ++wrote 8192/8192 bytes at offset 4299360256 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299372544 ++wrote 8192/8192 bytes at offset 4299372544 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299384832 ++wrote 8192/8192 bytes at offset 4299384832 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299397120 ++wrote 8192/8192 bytes at offset 4299397120 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299409408 ++wrote 8192/8192 bytes at offset 4299409408 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299421696 ++wrote 8192/8192 bytes at offset 4299421696 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299433984 ++wrote 8192/8192 bytes at offset 4299433984 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299446272 ++wrote 8192/8192 bytes at offset 4299446272 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299458560 ++wrote 8192/8192 bytes at offset 4299458560 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299470848 ++wrote 8192/8192 bytes at offset 4299470848 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299483136 ++wrote 8192/8192 bytes at offset 4299483136 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299495424 ++wrote 8192/8192 bytes at offset 4299495424 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299507712 ++wrote 8192/8192 bytes at offset 4299507712 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299520000 ++wrote 8192/8192 bytes at offset 4299520000 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299532288 ++wrote 8192/8192 bytes at offset 4299532288 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299544576 ++wrote 8192/8192 bytes at offset 4299544576 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299556864 ++wrote 8192/8192 bytes at offset 4299556864 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299569152 ++wrote 8192/8192 bytes at offset 4299569152 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299581440 ++wrote 8192/8192 bytes at offset 4299581440 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299593728 ++wrote 8192/8192 bytes at offset 4299593728 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299606016 ++wrote 8192/8192 bytes at offset 4299606016 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299618304 ++wrote 8192/8192 bytes at offset 4299618304 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299630592 ++wrote 8192/8192 bytes at offset 4299630592 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299642880 ++wrote 8192/8192 bytes at offset 4299642880 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299655168 ++wrote 8192/8192 bytes at offset 4299655168 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299667456 ++wrote 8192/8192 bytes at offset 4299667456 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299679744 ++wrote 8192/8192 bytes at offset 4299679744 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299692032 ++wrote 8192/8192 bytes at offset 4299692032 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299704320 ++wrote 8192/8192 bytes at offset 4299704320 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299716608 ++wrote 8192/8192 bytes at offset 4299716608 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299728896 ++wrote 8192/8192 bytes at offset 4299728896 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299741184 ++wrote 8192/8192 bytes at offset 4299741184 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299753472 ++wrote 8192/8192 bytes at offset 4299753472 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299765760 ++wrote 8192/8192 bytes at offset 4299765760 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299778048 ++wrote 8192/8192 bytes at offset 4299778048 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299790336 ++wrote 8192/8192 bytes at offset 4299790336 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299802624 ++wrote 8192/8192 bytes at offset 4299802624 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299814912 ++wrote 8192/8192 bytes at offset 4299814912 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299827200 ++wrote 8192/8192 bytes at offset 4299827200 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299839488 ++wrote 8192/8192 bytes at offset 4299839488 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299851776 ++wrote 8192/8192 bytes at offset 4299851776 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299864064 ++wrote 8192/8192 bytes at offset 4299864064 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299876352 ++wrote 8192/8192 bytes at offset 4299876352 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299888640 ++wrote 8192/8192 bytes at offset 4299888640 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299900928 ++wrote 8192/8192 bytes at offset 4299900928 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299913216 ++wrote 8192/8192 bytes at offset 4299913216 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299925504 ++wrote 8192/8192 bytes at offset 4299925504 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299937792 ++wrote 8192/8192 bytes at offset 4299937792 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 244 +-qemu-io> wrote 12288/12288 bytes at offset 4301252608 ++=== IO: pattern 244 ++wrote 12288/12288 bytes at offset 4301252608 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 4303351808 ++wrote 12288/12288 bytes at offset 4303351808 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 4305451008 ++wrote 12288/12288 bytes at offset 4305451008 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 4307550208 ++wrote 12288/12288 bytes at offset 4307550208 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 4309649408 ++wrote 12288/12288 bytes at offset 4309649408 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 4311748608 ++wrote 12288/12288 bytes at offset 4311748608 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 4313847808 ++wrote 12288/12288 bytes at offset 4313847808 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 4315947008 ++wrote 12288/12288 bytes at offset 4315947008 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> read 4096/4096 bytes at offset 4294967296 ++=== IO: pattern 0 ++read 4096/4096 bytes at offset 4294967296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294971392 ++read 4096/4096 bytes at offset 4294971392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294975488 ++read 4096/4096 bytes at offset 4294975488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294979584 ++read 4096/4096 bytes at offset 4294979584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294983680 ++read 4096/4096 bytes at offset 4294983680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294987776 ++read 4096/4096 bytes at offset 4294987776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294991872 ++read 4096/4096 bytes at offset 4294991872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294995968 ++read 4096/4096 bytes at offset 4294995968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295000064 ++read 4096/4096 bytes at offset 4295000064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295004160 ++read 4096/4096 bytes at offset 4295004160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295008256 ++read 4096/4096 bytes at offset 4295008256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295012352 ++read 4096/4096 bytes at offset 4295012352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295016448 ++read 4096/4096 bytes at offset 4295016448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295020544 ++read 4096/4096 bytes at offset 4295020544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295024640 ++read 4096/4096 bytes at offset 4295024640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295028736 ++read 4096/4096 bytes at offset 4295028736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295032832 ++read 4096/4096 bytes at offset 4295032832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295036928 ++read 4096/4096 bytes at offset 4295036928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295041024 ++read 4096/4096 bytes at offset 4295041024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295045120 ++read 4096/4096 bytes at offset 4295045120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295049216 ++read 4096/4096 bytes at offset 4295049216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295053312 ++read 4096/4096 bytes at offset 4295053312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295057408 ++read 4096/4096 bytes at offset 4295057408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295061504 ++read 4096/4096 bytes at offset 4295061504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295065600 ++read 4096/4096 bytes at offset 4295065600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295069696 ++read 4096/4096 bytes at offset 4295069696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295073792 ++read 4096/4096 bytes at offset 4295073792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295077888 ++read 4096/4096 bytes at offset 4295077888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295081984 ++read 4096/4096 bytes at offset 4295081984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295086080 ++read 4096/4096 bytes at offset 4295086080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295090176 ++read 4096/4096 bytes at offset 4295090176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295094272 ++read 4096/4096 bytes at offset 4295094272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295098368 ++read 4096/4096 bytes at offset 4295098368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295102464 ++read 4096/4096 bytes at offset 4295102464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295106560 ++read 4096/4096 bytes at offset 4295106560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295110656 ++read 4096/4096 bytes at offset 4295110656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295114752 ++read 4096/4096 bytes at offset 4295114752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295118848 ++read 4096/4096 bytes at offset 4295118848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295122944 ++read 4096/4096 bytes at offset 4295122944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295127040 ++read 4096/4096 bytes at offset 4295127040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295131136 ++read 4096/4096 bytes at offset 4295131136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295135232 ++read 4096/4096 bytes at offset 4295135232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295139328 ++read 4096/4096 bytes at offset 4295139328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295143424 ++read 4096/4096 bytes at offset 4295143424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295147520 ++read 4096/4096 bytes at offset 4295147520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295151616 ++read 4096/4096 bytes at offset 4295151616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295155712 ++read 4096/4096 bytes at offset 4295155712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295159808 ++read 4096/4096 bytes at offset 4295159808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295163904 ++read 4096/4096 bytes at offset 4295163904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295168000 ++read 4096/4096 bytes at offset 4295168000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295172096 ++read 4096/4096 bytes at offset 4295172096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295176192 ++read 4096/4096 bytes at offset 4295176192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295180288 ++read 4096/4096 bytes at offset 4295180288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295184384 ++read 4096/4096 bytes at offset 4295184384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295188480 ++read 4096/4096 bytes at offset 4295188480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295192576 ++read 4096/4096 bytes at offset 4295192576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295196672 ++read 4096/4096 bytes at offset 4295196672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295200768 ++read 4096/4096 bytes at offset 4295200768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295204864 ++read 4096/4096 bytes at offset 4295204864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295208960 ++read 4096/4096 bytes at offset 4295208960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295213056 ++read 4096/4096 bytes at offset 4295213056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295217152 ++read 4096/4096 bytes at offset 4295217152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295221248 ++read 4096/4096 bytes at offset 4295221248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295225344 ++read 4096/4096 bytes at offset 4295225344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295229440 ++read 4096/4096 bytes at offset 4295229440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295233536 ++read 4096/4096 bytes at offset 4295233536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295237632 ++read 4096/4096 bytes at offset 4295237632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295241728 ++read 4096/4096 bytes at offset 4295241728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295245824 ++read 4096/4096 bytes at offset 4295245824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295249920 ++read 4096/4096 bytes at offset 4295249920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295254016 ++read 4096/4096 bytes at offset 4295254016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295258112 ++read 4096/4096 bytes at offset 4295258112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295262208 ++read 4096/4096 bytes at offset 4295262208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295266304 ++read 4096/4096 bytes at offset 4295266304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295270400 ++read 4096/4096 bytes at offset 4295270400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295274496 ++read 4096/4096 bytes at offset 4295274496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295278592 ++read 4096/4096 bytes at offset 4295278592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295282688 ++read 4096/4096 bytes at offset 4295282688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295286784 ++read 4096/4096 bytes at offset 4295286784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295290880 ++read 4096/4096 bytes at offset 4295290880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295294976 ++read 4096/4096 bytes at offset 4295294976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295299072 ++read 4096/4096 bytes at offset 4295299072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295303168 ++read 4096/4096 bytes at offset 4295303168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295307264 ++read 4096/4096 bytes at offset 4295307264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295311360 ++read 4096/4096 bytes at offset 4295311360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295315456 ++read 4096/4096 bytes at offset 4295315456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295319552 ++read 4096/4096 bytes at offset 4295319552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295323648 ++read 4096/4096 bytes at offset 4295323648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295327744 ++read 4096/4096 bytes at offset 4295327744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295331840 ++read 4096/4096 bytes at offset 4295331840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295335936 ++read 4096/4096 bytes at offset 4295335936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295340032 ++read 4096/4096 bytes at offset 4295340032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295344128 ++read 4096/4096 bytes at offset 4295344128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295348224 ++read 4096/4096 bytes at offset 4295348224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295352320 ++read 4096/4096 bytes at offset 4295352320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295356416 ++read 4096/4096 bytes at offset 4295356416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295360512 ++read 4096/4096 bytes at offset 4295360512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295364608 ++read 4096/4096 bytes at offset 4295364608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295368704 ++read 4096/4096 bytes at offset 4295368704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295372800 ++read 4096/4096 bytes at offset 4295372800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295376896 ++read 4096/4096 bytes at offset 4295376896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295380992 ++read 4096/4096 bytes at offset 4295380992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295385088 ++read 4096/4096 bytes at offset 4295385088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295389184 ++read 4096/4096 bytes at offset 4295389184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295393280 ++read 4096/4096 bytes at offset 4295393280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295397376 ++read 4096/4096 bytes at offset 4295397376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295401472 ++read 4096/4096 bytes at offset 4295401472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295405568 ++read 4096/4096 bytes at offset 4295405568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295409664 ++read 4096/4096 bytes at offset 4295409664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295413760 ++read 4096/4096 bytes at offset 4295413760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295417856 ++read 4096/4096 bytes at offset 4295417856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295421952 ++read 4096/4096 bytes at offset 4295421952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295426048 ++read 4096/4096 bytes at offset 4295426048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295430144 ++read 4096/4096 bytes at offset 4295430144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295434240 ++read 4096/4096 bytes at offset 4295434240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295438336 ++read 4096/4096 bytes at offset 4295438336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295442432 ++read 4096/4096 bytes at offset 4295442432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295446528 ++read 4096/4096 bytes at offset 4295446528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295450624 ++read 4096/4096 bytes at offset 4295450624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295454720 ++read 4096/4096 bytes at offset 4295454720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295458816 ++read 4096/4096 bytes at offset 4295458816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295462912 ++read 4096/4096 bytes at offset 4295462912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295467008 ++read 4096/4096 bytes at offset 4295467008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295471104 ++read 4096/4096 bytes at offset 4295471104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295475200 ++read 4096/4096 bytes at offset 4295475200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295479296 ++read 4096/4096 bytes at offset 4295479296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295483392 ++read 4096/4096 bytes at offset 4295483392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295487488 ++read 4096/4096 bytes at offset 4295487488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295491584 ++read 4096/4096 bytes at offset 4295491584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295495680 ++read 4096/4096 bytes at offset 4295495680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295499776 ++read 4096/4096 bytes at offset 4295499776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295503872 ++read 4096/4096 bytes at offset 4295503872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295507968 ++read 4096/4096 bytes at offset 4295507968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295512064 ++read 4096/4096 bytes at offset 4295512064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295516160 ++read 4096/4096 bytes at offset 4295516160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295520256 ++read 4096/4096 bytes at offset 4295520256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295524352 ++read 4096/4096 bytes at offset 4295524352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295528448 ++read 4096/4096 bytes at offset 4295528448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295532544 ++read 4096/4096 bytes at offset 4295532544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295536640 ++read 4096/4096 bytes at offset 4295536640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295540736 ++read 4096/4096 bytes at offset 4295540736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295544832 ++read 4096/4096 bytes at offset 4295544832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295548928 ++read 4096/4096 bytes at offset 4295548928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295553024 ++read 4096/4096 bytes at offset 4295553024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295557120 ++read 4096/4096 bytes at offset 4295557120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295561216 ++read 4096/4096 bytes at offset 4295561216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295565312 ++read 4096/4096 bytes at offset 4295565312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295569408 ++read 4096/4096 bytes at offset 4295569408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295573504 ++read 4096/4096 bytes at offset 4295573504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295577600 ++read 4096/4096 bytes at offset 4295577600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295581696 ++read 4096/4096 bytes at offset 4295581696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295585792 ++read 4096/4096 bytes at offset 4295585792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295589888 ++read 4096/4096 bytes at offset 4295589888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295593984 ++read 4096/4096 bytes at offset 4295593984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295598080 ++read 4096/4096 bytes at offset 4295598080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295602176 ++read 4096/4096 bytes at offset 4295602176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295606272 ++read 4096/4096 bytes at offset 4295606272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295610368 ++read 4096/4096 bytes at offset 4295610368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295614464 ++read 4096/4096 bytes at offset 4295614464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295618560 ++read 4096/4096 bytes at offset 4295618560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295622656 ++read 4096/4096 bytes at offset 4295622656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295626752 ++read 4096/4096 bytes at offset 4295626752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295630848 ++read 4096/4096 bytes at offset 4295630848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295634944 ++read 4096/4096 bytes at offset 4295634944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295639040 ++read 4096/4096 bytes at offset 4295639040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295643136 ++read 4096/4096 bytes at offset 4295643136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295647232 ++read 4096/4096 bytes at offset 4295647232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295651328 ++read 4096/4096 bytes at offset 4295651328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295655424 ++read 4096/4096 bytes at offset 4295655424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295659520 ++read 4096/4096 bytes at offset 4295659520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295663616 ++read 4096/4096 bytes at offset 4295663616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295667712 ++read 4096/4096 bytes at offset 4295667712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295671808 ++read 4096/4096 bytes at offset 4295671808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295675904 ++read 4096/4096 bytes at offset 4295675904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295680000 ++read 4096/4096 bytes at offset 4295680000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295684096 ++read 4096/4096 bytes at offset 4295684096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295688192 ++read 4096/4096 bytes at offset 4295688192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295692288 ++read 4096/4096 bytes at offset 4295692288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295696384 ++read 4096/4096 bytes at offset 4295696384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295700480 ++read 4096/4096 bytes at offset 4295700480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295704576 ++read 4096/4096 bytes at offset 4295704576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295708672 ++read 4096/4096 bytes at offset 4295708672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295712768 ++read 4096/4096 bytes at offset 4295712768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295716864 ++read 4096/4096 bytes at offset 4295716864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295720960 ++read 4096/4096 bytes at offset 4295720960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295725056 ++read 4096/4096 bytes at offset 4295725056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295729152 ++read 4096/4096 bytes at offset 4295729152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295733248 ++read 4096/4096 bytes at offset 4295733248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295737344 ++read 4096/4096 bytes at offset 4295737344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295741440 ++read 4096/4096 bytes at offset 4295741440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295745536 ++read 4096/4096 bytes at offset 4295745536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295749632 ++read 4096/4096 bytes at offset 4295749632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295753728 ++read 4096/4096 bytes at offset 4295753728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295757824 ++read 4096/4096 bytes at offset 4295757824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295761920 ++read 4096/4096 bytes at offset 4295761920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295766016 ++read 4096/4096 bytes at offset 4295766016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295770112 ++read 4096/4096 bytes at offset 4295770112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295774208 ++read 4096/4096 bytes at offset 4295774208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295778304 ++read 4096/4096 bytes at offset 4295778304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295782400 ++read 4096/4096 bytes at offset 4295782400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295786496 ++read 4096/4096 bytes at offset 4295786496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295790592 ++read 4096/4096 bytes at offset 4295790592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295794688 ++read 4096/4096 bytes at offset 4295794688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295798784 ++read 4096/4096 bytes at offset 4295798784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295802880 ++read 4096/4096 bytes at offset 4295802880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295806976 ++read 4096/4096 bytes at offset 4295806976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295811072 ++read 4096/4096 bytes at offset 4295811072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295815168 ++read 4096/4096 bytes at offset 4295815168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295819264 ++read 4096/4096 bytes at offset 4295819264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295823360 ++read 4096/4096 bytes at offset 4295823360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295827456 ++read 4096/4096 bytes at offset 4295827456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295831552 ++read 4096/4096 bytes at offset 4295831552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295835648 ++read 4096/4096 bytes at offset 4295835648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295839744 ++read 4096/4096 bytes at offset 4295839744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295843840 ++read 4096/4096 bytes at offset 4295843840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295847936 ++read 4096/4096 bytes at offset 4295847936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295852032 ++read 4096/4096 bytes at offset 4295852032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295856128 ++read 4096/4096 bytes at offset 4295856128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295860224 ++read 4096/4096 bytes at offset 4295860224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295864320 ++read 4096/4096 bytes at offset 4295864320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295868416 ++read 4096/4096 bytes at offset 4295868416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295872512 ++read 4096/4096 bytes at offset 4295872512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295876608 ++read 4096/4096 bytes at offset 4295876608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295880704 ++read 4096/4096 bytes at offset 4295880704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295884800 ++read 4096/4096 bytes at offset 4295884800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295888896 ++read 4096/4096 bytes at offset 4295888896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295892992 ++read 4096/4096 bytes at offset 4295892992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295897088 ++read 4096/4096 bytes at offset 4295897088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295901184 ++read 4096/4096 bytes at offset 4295901184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295905280 ++read 4096/4096 bytes at offset 4295905280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295909376 ++read 4096/4096 bytes at offset 4295909376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295913472 ++read 4096/4096 bytes at offset 4295913472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295917568 ++read 4096/4096 bytes at offset 4295917568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295921664 ++read 4096/4096 bytes at offset 4295921664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295925760 ++read 4096/4096 bytes at offset 4295925760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295929856 ++read 4096/4096 bytes at offset 4295929856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295933952 ++read 4096/4096 bytes at offset 4295933952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295938048 ++read 4096/4096 bytes at offset 4295938048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295942144 ++read 4096/4096 bytes at offset 4295942144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295946240 ++read 4096/4096 bytes at offset 4295946240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295950336 ++read 4096/4096 bytes at offset 4295950336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295954432 ++read 4096/4096 bytes at offset 4295954432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295958528 ++read 4096/4096 bytes at offset 4295958528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295962624 ++read 4096/4096 bytes at offset 4295962624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295966720 ++read 4096/4096 bytes at offset 4295966720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295970816 ++read 4096/4096 bytes at offset 4295970816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295974912 ++read 4096/4096 bytes at offset 4295974912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295979008 ++read 4096/4096 bytes at offset 4295979008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295983104 ++read 4096/4096 bytes at offset 4295983104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295987200 ++read 4096/4096 bytes at offset 4295987200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295991296 ++read 4096/4096 bytes at offset 4295991296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295995392 ++read 4096/4096 bytes at offset 4295995392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295999488 ++read 4096/4096 bytes at offset 4295999488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4296003584 ++read 4096/4096 bytes at offset 4296003584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4296007680 ++read 4096/4096 bytes at offset 4296007680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4296011776 ++read 4096/4096 bytes at offset 4296011776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 4 +-qemu-io> read 2048/2048 bytes at offset 4296017920 ++=== IO: pattern 4 ++read 2048/2048 bytes at offset 4296017920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296022016 ++read 2048/2048 bytes at offset 4296022016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296026112 ++read 2048/2048 bytes at offset 4296026112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296030208 ++read 2048/2048 bytes at offset 4296030208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296034304 ++read 2048/2048 bytes at offset 4296034304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296038400 ++read 2048/2048 bytes at offset 4296038400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296042496 ++read 2048/2048 bytes at offset 4296042496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296046592 ++read 2048/2048 bytes at offset 4296046592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296050688 ++read 2048/2048 bytes at offset 4296050688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296054784 ++read 2048/2048 bytes at offset 4296054784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296058880 ++read 2048/2048 bytes at offset 4296058880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296062976 ++read 2048/2048 bytes at offset 4296062976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296067072 ++read 2048/2048 bytes at offset 4296067072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296071168 ++read 2048/2048 bytes at offset 4296071168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296075264 ++read 2048/2048 bytes at offset 4296075264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296079360 ++read 2048/2048 bytes at offset 4296079360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296083456 ++read 2048/2048 bytes at offset 4296083456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296087552 ++read 2048/2048 bytes at offset 4296087552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296091648 ++read 2048/2048 bytes at offset 4296091648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296095744 ++read 2048/2048 bytes at offset 4296095744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296099840 ++read 2048/2048 bytes at offset 4296099840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296103936 ++read 2048/2048 bytes at offset 4296103936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296108032 ++read 2048/2048 bytes at offset 4296108032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296112128 ++read 2048/2048 bytes at offset 4296112128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296116224 ++read 2048/2048 bytes at offset 4296116224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296120320 ++read 2048/2048 bytes at offset 4296120320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296124416 ++read 2048/2048 bytes at offset 4296124416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296128512 ++read 2048/2048 bytes at offset 4296128512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296132608 ++read 2048/2048 bytes at offset 4296132608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296136704 ++read 2048/2048 bytes at offset 4296136704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296140800 ++read 2048/2048 bytes at offset 4296140800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296144896 ++read 2048/2048 bytes at offset 4296144896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296148992 ++read 2048/2048 bytes at offset 4296148992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296153088 ++read 2048/2048 bytes at offset 4296153088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296157184 ++read 2048/2048 bytes at offset 4296157184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296161280 ++read 2048/2048 bytes at offset 4296161280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296165376 ++read 2048/2048 bytes at offset 4296165376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296169472 ++read 2048/2048 bytes at offset 4296169472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296173568 ++read 2048/2048 bytes at offset 4296173568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296177664 ++read 2048/2048 bytes at offset 4296177664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296181760 ++read 2048/2048 bytes at offset 4296181760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296185856 ++read 2048/2048 bytes at offset 4296185856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296189952 ++read 2048/2048 bytes at offset 4296189952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296194048 ++read 2048/2048 bytes at offset 4296194048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296198144 ++read 2048/2048 bytes at offset 4296198144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296202240 ++read 2048/2048 bytes at offset 4296202240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296206336 ++read 2048/2048 bytes at offset 4296206336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296210432 ++read 2048/2048 bytes at offset 4296210432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296214528 ++read 2048/2048 bytes at offset 4296214528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296218624 ++read 2048/2048 bytes at offset 4296218624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296222720 ++read 2048/2048 bytes at offset 4296222720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296226816 ++read 2048/2048 bytes at offset 4296226816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296230912 ++read 2048/2048 bytes at offset 4296230912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296235008 ++read 2048/2048 bytes at offset 4296235008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296239104 ++read 2048/2048 bytes at offset 4296239104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296243200 ++read 2048/2048 bytes at offset 4296243200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296247296 ++read 2048/2048 bytes at offset 4296247296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296251392 ++read 2048/2048 bytes at offset 4296251392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296255488 ++read 2048/2048 bytes at offset 4296255488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296259584 ++read 2048/2048 bytes at offset 4296259584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296263680 ++read 2048/2048 bytes at offset 4296263680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296267776 ++read 2048/2048 bytes at offset 4296267776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296271872 ++read 2048/2048 bytes at offset 4296271872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296275968 ++read 2048/2048 bytes at offset 4296275968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296280064 ++read 2048/2048 bytes at offset 4296280064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296284160 ++read 2048/2048 bytes at offset 4296284160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296288256 ++read 2048/2048 bytes at offset 4296288256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296292352 ++read 2048/2048 bytes at offset 4296292352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296296448 ++read 2048/2048 bytes at offset 4296296448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296300544 ++read 2048/2048 bytes at offset 4296300544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296304640 ++read 2048/2048 bytes at offset 4296304640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296308736 ++read 2048/2048 bytes at offset 4296308736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296312832 ++read 2048/2048 bytes at offset 4296312832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296316928 ++read 2048/2048 bytes at offset 4296316928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296321024 ++read 2048/2048 bytes at offset 4296321024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296325120 ++read 2048/2048 bytes at offset 4296325120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296329216 ++read 2048/2048 bytes at offset 4296329216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296333312 ++read 2048/2048 bytes at offset 4296333312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296337408 ++read 2048/2048 bytes at offset 4296337408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296341504 ++read 2048/2048 bytes at offset 4296341504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296345600 ++read 2048/2048 bytes at offset 4296345600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296349696 ++read 2048/2048 bytes at offset 4296349696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296353792 ++read 2048/2048 bytes at offset 4296353792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296357888 ++read 2048/2048 bytes at offset 4296357888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296361984 ++read 2048/2048 bytes at offset 4296361984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296366080 ++read 2048/2048 bytes at offset 4296366080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296370176 ++read 2048/2048 bytes at offset 4296370176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296374272 ++read 2048/2048 bytes at offset 4296374272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296378368 ++read 2048/2048 bytes at offset 4296378368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296382464 ++read 2048/2048 bytes at offset 4296382464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296386560 ++read 2048/2048 bytes at offset 4296386560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296390656 ++read 2048/2048 bytes at offset 4296390656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296394752 ++read 2048/2048 bytes at offset 4296394752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296398848 ++read 2048/2048 bytes at offset 4296398848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296402944 ++read 2048/2048 bytes at offset 4296402944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296407040 ++read 2048/2048 bytes at offset 4296407040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296411136 ++read 2048/2048 bytes at offset 4296411136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296415232 ++read 2048/2048 bytes at offset 4296415232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296419328 ++read 2048/2048 bytes at offset 4296419328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296423424 ++read 2048/2048 bytes at offset 4296423424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296427520 ++read 2048/2048 bytes at offset 4296427520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296431616 ++read 2048/2048 bytes at offset 4296431616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296435712 ++read 2048/2048 bytes at offset 4296435712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296439808 ++read 2048/2048 bytes at offset 4296439808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296443904 ++read 2048/2048 bytes at offset 4296443904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296448000 ++read 2048/2048 bytes at offset 4296448000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296452096 ++read 2048/2048 bytes at offset 4296452096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296456192 ++read 2048/2048 bytes at offset 4296456192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296460288 ++read 2048/2048 bytes at offset 4296460288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296464384 ++read 2048/2048 bytes at offset 4296464384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296468480 ++read 2048/2048 bytes at offset 4296468480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296472576 ++read 2048/2048 bytes at offset 4296472576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296476672 ++read 2048/2048 bytes at offset 4296476672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296480768 ++read 2048/2048 bytes at offset 4296480768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296484864 ++read 2048/2048 bytes at offset 4296484864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296488960 ++read 2048/2048 bytes at offset 4296488960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296493056 ++read 2048/2048 bytes at offset 4296493056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296497152 ++read 2048/2048 bytes at offset 4296497152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296501248 ++read 2048/2048 bytes at offset 4296501248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296505344 ++read 2048/2048 bytes at offset 4296505344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296509440 ++read 2048/2048 bytes at offset 4296509440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296513536 ++read 2048/2048 bytes at offset 4296513536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296517632 ++read 2048/2048 bytes at offset 4296517632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296521728 ++read 2048/2048 bytes at offset 4296521728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296525824 ++read 2048/2048 bytes at offset 4296525824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296529920 ++read 2048/2048 bytes at offset 4296529920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296534016 ++read 2048/2048 bytes at offset 4296534016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296538112 ++read 2048/2048 bytes at offset 4296538112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296542208 ++read 2048/2048 bytes at offset 4296542208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296546304 ++read 2048/2048 bytes at offset 4296546304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296550400 ++read 2048/2048 bytes at offset 4296550400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296554496 ++read 2048/2048 bytes at offset 4296554496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296558592 ++read 2048/2048 bytes at offset 4296558592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296562688 ++read 2048/2048 bytes at offset 4296562688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296566784 ++read 2048/2048 bytes at offset 4296566784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296570880 ++read 2048/2048 bytes at offset 4296570880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296574976 ++read 2048/2048 bytes at offset 4296574976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296579072 ++read 2048/2048 bytes at offset 4296579072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296583168 ++read 2048/2048 bytes at offset 4296583168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296587264 ++read 2048/2048 bytes at offset 4296587264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296591360 ++read 2048/2048 bytes at offset 4296591360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296595456 ++read 2048/2048 bytes at offset 4296595456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296599552 ++read 2048/2048 bytes at offset 4296599552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296603648 ++read 2048/2048 bytes at offset 4296603648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296607744 ++read 2048/2048 bytes at offset 4296607744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296611840 ++read 2048/2048 bytes at offset 4296611840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296615936 ++read 2048/2048 bytes at offset 4296615936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296620032 ++read 2048/2048 bytes at offset 4296620032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296624128 ++read 2048/2048 bytes at offset 4296624128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296628224 ++read 2048/2048 bytes at offset 4296628224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296632320 ++read 2048/2048 bytes at offset 4296632320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296636416 ++read 2048/2048 bytes at offset 4296636416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296640512 ++read 2048/2048 bytes at offset 4296640512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296644608 ++read 2048/2048 bytes at offset 4296644608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296648704 ++read 2048/2048 bytes at offset 4296648704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296652800 ++read 2048/2048 bytes at offset 4296652800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296656896 ++read 2048/2048 bytes at offset 4296656896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296660992 ++read 2048/2048 bytes at offset 4296660992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296665088 ++read 2048/2048 bytes at offset 4296665088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296669184 ++read 2048/2048 bytes at offset 4296669184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296673280 ++read 2048/2048 bytes at offset 4296673280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296677376 ++read 2048/2048 bytes at offset 4296677376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296681472 ++read 2048/2048 bytes at offset 4296681472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296685568 ++read 2048/2048 bytes at offset 4296685568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296689664 ++read 2048/2048 bytes at offset 4296689664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296693760 ++read 2048/2048 bytes at offset 4296693760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296697856 ++read 2048/2048 bytes at offset 4296697856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296701952 ++read 2048/2048 bytes at offset 4296701952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296706048 ++read 2048/2048 bytes at offset 4296706048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296710144 ++read 2048/2048 bytes at offset 4296710144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296714240 ++read 2048/2048 bytes at offset 4296714240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296718336 ++read 2048/2048 bytes at offset 4296718336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296722432 ++read 2048/2048 bytes at offset 4296722432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296726528 ++read 2048/2048 bytes at offset 4296726528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296730624 ++read 2048/2048 bytes at offset 4296730624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296734720 ++read 2048/2048 bytes at offset 4296734720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296738816 ++read 2048/2048 bytes at offset 4296738816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296742912 ++read 2048/2048 bytes at offset 4296742912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296747008 ++read 2048/2048 bytes at offset 4296747008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296751104 ++read 2048/2048 bytes at offset 4296751104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296755200 ++read 2048/2048 bytes at offset 4296755200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296759296 ++read 2048/2048 bytes at offset 4296759296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296763392 ++read 2048/2048 bytes at offset 4296763392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296767488 ++read 2048/2048 bytes at offset 4296767488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296771584 ++read 2048/2048 bytes at offset 4296771584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296775680 ++read 2048/2048 bytes at offset 4296775680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296779776 ++read 2048/2048 bytes at offset 4296779776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296783872 ++read 2048/2048 bytes at offset 4296783872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296787968 ++read 2048/2048 bytes at offset 4296787968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296792064 ++read 2048/2048 bytes at offset 4296792064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296796160 ++read 2048/2048 bytes at offset 4296796160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296800256 ++read 2048/2048 bytes at offset 4296800256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296804352 ++read 2048/2048 bytes at offset 4296804352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296808448 ++read 2048/2048 bytes at offset 4296808448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296812544 ++read 2048/2048 bytes at offset 4296812544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296816640 ++read 2048/2048 bytes at offset 4296816640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296820736 ++read 2048/2048 bytes at offset 4296820736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296824832 ++read 2048/2048 bytes at offset 4296824832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296828928 ++read 2048/2048 bytes at offset 4296828928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296833024 ++read 2048/2048 bytes at offset 4296833024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296837120 ++read 2048/2048 bytes at offset 4296837120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296841216 ++read 2048/2048 bytes at offset 4296841216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296845312 ++read 2048/2048 bytes at offset 4296845312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296849408 ++read 2048/2048 bytes at offset 4296849408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296853504 ++read 2048/2048 bytes at offset 4296853504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296857600 ++read 2048/2048 bytes at offset 4296857600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296861696 ++read 2048/2048 bytes at offset 4296861696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296865792 ++read 2048/2048 bytes at offset 4296865792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296869888 ++read 2048/2048 bytes at offset 4296869888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296873984 ++read 2048/2048 bytes at offset 4296873984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296878080 ++read 2048/2048 bytes at offset 4296878080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296882176 ++read 2048/2048 bytes at offset 4296882176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296886272 ++read 2048/2048 bytes at offset 4296886272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296890368 ++read 2048/2048 bytes at offset 4296890368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296894464 ++read 2048/2048 bytes at offset 4296894464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296898560 ++read 2048/2048 bytes at offset 4296898560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296902656 ++read 2048/2048 bytes at offset 4296902656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296906752 ++read 2048/2048 bytes at offset 4296906752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296910848 ++read 2048/2048 bytes at offset 4296910848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296914944 ++read 2048/2048 bytes at offset 4296914944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296919040 ++read 2048/2048 bytes at offset 4296919040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296923136 ++read 2048/2048 bytes at offset 4296923136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296927232 ++read 2048/2048 bytes at offset 4296927232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296931328 ++read 2048/2048 bytes at offset 4296931328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296935424 ++read 2048/2048 bytes at offset 4296935424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296939520 ++read 2048/2048 bytes at offset 4296939520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296943616 ++read 2048/2048 bytes at offset 4296943616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296947712 ++read 2048/2048 bytes at offset 4296947712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296951808 ++read 2048/2048 bytes at offset 4296951808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296955904 ++read 2048/2048 bytes at offset 4296955904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296960000 ++read 2048/2048 bytes at offset 4296960000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296964096 ++read 2048/2048 bytes at offset 4296964096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296968192 ++read 2048/2048 bytes at offset 4296968192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296972288 ++read 2048/2048 bytes at offset 4296972288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296976384 ++read 2048/2048 bytes at offset 4296976384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296980480 ++read 2048/2048 bytes at offset 4296980480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296984576 ++read 2048/2048 bytes at offset 4296984576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296988672 ++read 2048/2048 bytes at offset 4296988672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296992768 ++read 2048/2048 bytes at offset 4296992768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296996864 ++read 2048/2048 bytes at offset 4296996864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297000960 ++read 2048/2048 bytes at offset 4297000960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297005056 ++read 2048/2048 bytes at offset 4297005056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297009152 ++read 2048/2048 bytes at offset 4297009152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297013248 ++read 2048/2048 bytes at offset 4297013248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297017344 ++read 2048/2048 bytes at offset 4297017344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297021440 ++read 2048/2048 bytes at offset 4297021440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297025536 ++read 2048/2048 bytes at offset 4297025536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297029632 ++read 2048/2048 bytes at offset 4297029632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297033728 ++read 2048/2048 bytes at offset 4297033728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297037824 ++read 2048/2048 bytes at offset 4297037824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297041920 ++read 2048/2048 bytes at offset 4297041920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297046016 ++read 2048/2048 bytes at offset 4297046016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297050112 ++read 2048/2048 bytes at offset 4297050112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297054208 ++read 2048/2048 bytes at offset 4297054208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297058304 ++read 2048/2048 bytes at offset 4297058304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297062400 ++read 2048/2048 bytes at offset 4297062400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> read 2048/2048 bytes at offset 4297064448 ++=== IO: pattern 0 ++read 2048/2048 bytes at offset 4297064448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297068544 ++read 2048/2048 bytes at offset 4297068544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297072640 ++read 2048/2048 bytes at offset 4297072640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297076736 ++read 2048/2048 bytes at offset 4297076736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297080832 ++read 2048/2048 bytes at offset 4297080832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297084928 ++read 2048/2048 bytes at offset 4297084928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297089024 ++read 2048/2048 bytes at offset 4297089024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297093120 ++read 2048/2048 bytes at offset 4297093120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297097216 ++read 2048/2048 bytes at offset 4297097216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297101312 ++read 2048/2048 bytes at offset 4297101312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297105408 ++read 2048/2048 bytes at offset 4297105408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297109504 ++read 2048/2048 bytes at offset 4297109504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297113600 ++read 2048/2048 bytes at offset 4297113600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297117696 ++read 2048/2048 bytes at offset 4297117696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297121792 ++read 2048/2048 bytes at offset 4297121792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297125888 ++read 2048/2048 bytes at offset 4297125888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297129984 ++read 2048/2048 bytes at offset 4297129984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297134080 ++read 2048/2048 bytes at offset 4297134080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297138176 ++read 2048/2048 bytes at offset 4297138176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297142272 ++read 2048/2048 bytes at offset 4297142272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297146368 ++read 2048/2048 bytes at offset 4297146368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297150464 ++read 2048/2048 bytes at offset 4297150464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297154560 ++read 2048/2048 bytes at offset 4297154560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297158656 ++read 2048/2048 bytes at offset 4297158656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297162752 ++read 2048/2048 bytes at offset 4297162752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297166848 ++read 2048/2048 bytes at offset 4297166848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297170944 ++read 2048/2048 bytes at offset 4297170944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297175040 ++read 2048/2048 bytes at offset 4297175040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297179136 ++read 2048/2048 bytes at offset 4297179136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297183232 ++read 2048/2048 bytes at offset 4297183232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297187328 ++read 2048/2048 bytes at offset 4297187328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297191424 ++read 2048/2048 bytes at offset 4297191424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297195520 ++read 2048/2048 bytes at offset 4297195520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297199616 ++read 2048/2048 bytes at offset 4297199616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297203712 ++read 2048/2048 bytes at offset 4297203712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297207808 ++read 2048/2048 bytes at offset 4297207808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297211904 ++read 2048/2048 bytes at offset 4297211904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297216000 ++read 2048/2048 bytes at offset 4297216000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297220096 ++read 2048/2048 bytes at offset 4297220096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297224192 ++read 2048/2048 bytes at offset 4297224192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297228288 ++read 2048/2048 bytes at offset 4297228288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297232384 ++read 2048/2048 bytes at offset 4297232384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297236480 ++read 2048/2048 bytes at offset 4297236480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297240576 ++read 2048/2048 bytes at offset 4297240576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297244672 ++read 2048/2048 bytes at offset 4297244672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297248768 ++read 2048/2048 bytes at offset 4297248768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297252864 ++read 2048/2048 bytes at offset 4297252864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297256960 ++read 2048/2048 bytes at offset 4297256960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297261056 ++read 2048/2048 bytes at offset 4297261056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297265152 ++read 2048/2048 bytes at offset 4297265152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297269248 ++read 2048/2048 bytes at offset 4297269248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297273344 ++read 2048/2048 bytes at offset 4297273344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297277440 ++read 2048/2048 bytes at offset 4297277440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297281536 ++read 2048/2048 bytes at offset 4297281536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297285632 ++read 2048/2048 bytes at offset 4297285632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297289728 ++read 2048/2048 bytes at offset 4297289728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297293824 ++read 2048/2048 bytes at offset 4297293824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297297920 ++read 2048/2048 bytes at offset 4297297920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297302016 ++read 2048/2048 bytes at offset 4297302016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297306112 ++read 2048/2048 bytes at offset 4297306112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297310208 ++read 2048/2048 bytes at offset 4297310208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297314304 ++read 2048/2048 bytes at offset 4297314304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297318400 ++read 2048/2048 bytes at offset 4297318400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297322496 ++read 2048/2048 bytes at offset 4297322496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297326592 ++read 2048/2048 bytes at offset 4297326592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297330688 ++read 2048/2048 bytes at offset 4297330688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297334784 ++read 2048/2048 bytes at offset 4297334784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297338880 ++read 2048/2048 bytes at offset 4297338880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297342976 ++read 2048/2048 bytes at offset 4297342976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297347072 ++read 2048/2048 bytes at offset 4297347072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297351168 ++read 2048/2048 bytes at offset 4297351168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297355264 ++read 2048/2048 bytes at offset 4297355264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297359360 ++read 2048/2048 bytes at offset 4297359360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297363456 ++read 2048/2048 bytes at offset 4297363456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297367552 ++read 2048/2048 bytes at offset 4297367552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297371648 ++read 2048/2048 bytes at offset 4297371648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297375744 ++read 2048/2048 bytes at offset 4297375744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297379840 ++read 2048/2048 bytes at offset 4297379840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297383936 ++read 2048/2048 bytes at offset 4297383936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297388032 ++read 2048/2048 bytes at offset 4297388032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297392128 ++read 2048/2048 bytes at offset 4297392128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297396224 ++read 2048/2048 bytes at offset 4297396224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297400320 ++read 2048/2048 bytes at offset 4297400320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297404416 ++read 2048/2048 bytes at offset 4297404416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297408512 ++read 2048/2048 bytes at offset 4297408512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297412608 ++read 2048/2048 bytes at offset 4297412608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297416704 ++read 2048/2048 bytes at offset 4297416704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297420800 ++read 2048/2048 bytes at offset 4297420800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297424896 ++read 2048/2048 bytes at offset 4297424896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297428992 ++read 2048/2048 bytes at offset 4297428992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297433088 ++read 2048/2048 bytes at offset 4297433088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297437184 ++read 2048/2048 bytes at offset 4297437184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297441280 ++read 2048/2048 bytes at offset 4297441280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297445376 ++read 2048/2048 bytes at offset 4297445376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297449472 ++read 2048/2048 bytes at offset 4297449472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297453568 ++read 2048/2048 bytes at offset 4297453568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297457664 ++read 2048/2048 bytes at offset 4297457664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297461760 ++read 2048/2048 bytes at offset 4297461760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297465856 ++read 2048/2048 bytes at offset 4297465856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297469952 ++read 2048/2048 bytes at offset 4297469952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297474048 ++read 2048/2048 bytes at offset 4297474048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297478144 ++read 2048/2048 bytes at offset 4297478144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297482240 ++read 2048/2048 bytes at offset 4297482240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297486336 ++read 2048/2048 bytes at offset 4297486336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297490432 ++read 2048/2048 bytes at offset 4297490432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297494528 ++read 2048/2048 bytes at offset 4297494528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297498624 ++read 2048/2048 bytes at offset 4297498624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297502720 ++read 2048/2048 bytes at offset 4297502720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297506816 ++read 2048/2048 bytes at offset 4297506816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297510912 ++read 2048/2048 bytes at offset 4297510912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297515008 ++read 2048/2048 bytes at offset 4297515008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297519104 ++read 2048/2048 bytes at offset 4297519104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297523200 ++read 2048/2048 bytes at offset 4297523200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297527296 ++read 2048/2048 bytes at offset 4297527296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297531392 ++read 2048/2048 bytes at offset 4297531392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297535488 ++read 2048/2048 bytes at offset 4297535488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297539584 ++read 2048/2048 bytes at offset 4297539584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297543680 ++read 2048/2048 bytes at offset 4297543680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297547776 ++read 2048/2048 bytes at offset 4297547776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297551872 ++read 2048/2048 bytes at offset 4297551872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297555968 ++read 2048/2048 bytes at offset 4297555968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297560064 ++read 2048/2048 bytes at offset 4297560064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297564160 ++read 2048/2048 bytes at offset 4297564160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297568256 ++read 2048/2048 bytes at offset 4297568256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297572352 ++read 2048/2048 bytes at offset 4297572352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297576448 ++read 2048/2048 bytes at offset 4297576448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297580544 ++read 2048/2048 bytes at offset 4297580544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297584640 ++read 2048/2048 bytes at offset 4297584640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297588736 ++read 2048/2048 bytes at offset 4297588736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297592832 ++read 2048/2048 bytes at offset 4297592832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297596928 ++read 2048/2048 bytes at offset 4297596928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297601024 ++read 2048/2048 bytes at offset 4297601024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297605120 ++read 2048/2048 bytes at offset 4297605120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297609216 ++read 2048/2048 bytes at offset 4297609216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297613312 ++read 2048/2048 bytes at offset 4297613312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297617408 ++read 2048/2048 bytes at offset 4297617408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297621504 ++read 2048/2048 bytes at offset 4297621504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297625600 ++read 2048/2048 bytes at offset 4297625600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297629696 ++read 2048/2048 bytes at offset 4297629696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297633792 ++read 2048/2048 bytes at offset 4297633792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297637888 ++read 2048/2048 bytes at offset 4297637888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297641984 ++read 2048/2048 bytes at offset 4297641984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297646080 ++read 2048/2048 bytes at offset 4297646080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297650176 ++read 2048/2048 bytes at offset 4297650176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297654272 ++read 2048/2048 bytes at offset 4297654272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297658368 ++read 2048/2048 bytes at offset 4297658368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297662464 ++read 2048/2048 bytes at offset 4297662464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297666560 ++read 2048/2048 bytes at offset 4297666560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297670656 ++read 2048/2048 bytes at offset 4297670656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297674752 ++read 2048/2048 bytes at offset 4297674752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297678848 ++read 2048/2048 bytes at offset 4297678848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297682944 ++read 2048/2048 bytes at offset 4297682944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297687040 ++read 2048/2048 bytes at offset 4297687040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297691136 ++read 2048/2048 bytes at offset 4297691136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297695232 ++read 2048/2048 bytes at offset 4297695232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297699328 ++read 2048/2048 bytes at offset 4297699328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297703424 ++read 2048/2048 bytes at offset 4297703424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297707520 ++read 2048/2048 bytes at offset 4297707520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297711616 ++read 2048/2048 bytes at offset 4297711616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297715712 ++read 2048/2048 bytes at offset 4297715712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297719808 ++read 2048/2048 bytes at offset 4297719808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297723904 ++read 2048/2048 bytes at offset 4297723904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297728000 ++read 2048/2048 bytes at offset 4297728000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297732096 ++read 2048/2048 bytes at offset 4297732096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297736192 ++read 2048/2048 bytes at offset 4297736192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297740288 ++read 2048/2048 bytes at offset 4297740288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297744384 ++read 2048/2048 bytes at offset 4297744384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297748480 ++read 2048/2048 bytes at offset 4297748480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297752576 ++read 2048/2048 bytes at offset 4297752576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297756672 ++read 2048/2048 bytes at offset 4297756672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297760768 ++read 2048/2048 bytes at offset 4297760768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297764864 ++read 2048/2048 bytes at offset 4297764864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297768960 ++read 2048/2048 bytes at offset 4297768960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297773056 ++read 2048/2048 bytes at offset 4297773056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297777152 ++read 2048/2048 bytes at offset 4297777152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297781248 ++read 2048/2048 bytes at offset 4297781248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297785344 ++read 2048/2048 bytes at offset 4297785344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297789440 ++read 2048/2048 bytes at offset 4297789440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297793536 ++read 2048/2048 bytes at offset 4297793536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297797632 ++read 2048/2048 bytes at offset 4297797632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297801728 ++read 2048/2048 bytes at offset 4297801728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297805824 ++read 2048/2048 bytes at offset 4297805824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297809920 ++read 2048/2048 bytes at offset 4297809920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297814016 ++read 2048/2048 bytes at offset 4297814016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297818112 ++read 2048/2048 bytes at offset 4297818112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297822208 ++read 2048/2048 bytes at offset 4297822208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297826304 ++read 2048/2048 bytes at offset 4297826304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297830400 ++read 2048/2048 bytes at offset 4297830400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297834496 ++read 2048/2048 bytes at offset 4297834496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297838592 ++read 2048/2048 bytes at offset 4297838592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297842688 ++read 2048/2048 bytes at offset 4297842688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297846784 ++read 2048/2048 bytes at offset 4297846784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297850880 ++read 2048/2048 bytes at offset 4297850880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297854976 ++read 2048/2048 bytes at offset 4297854976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297859072 ++read 2048/2048 bytes at offset 4297859072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297863168 ++read 2048/2048 bytes at offset 4297863168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297867264 ++read 2048/2048 bytes at offset 4297867264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297871360 ++read 2048/2048 bytes at offset 4297871360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297875456 ++read 2048/2048 bytes at offset 4297875456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297879552 ++read 2048/2048 bytes at offset 4297879552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297883648 ++read 2048/2048 bytes at offset 4297883648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297887744 ++read 2048/2048 bytes at offset 4297887744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297891840 ++read 2048/2048 bytes at offset 4297891840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297895936 ++read 2048/2048 bytes at offset 4297895936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297900032 ++read 2048/2048 bytes at offset 4297900032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297904128 ++read 2048/2048 bytes at offset 4297904128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297908224 ++read 2048/2048 bytes at offset 4297908224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297912320 ++read 2048/2048 bytes at offset 4297912320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297916416 ++read 2048/2048 bytes at offset 4297916416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297920512 ++read 2048/2048 bytes at offset 4297920512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297924608 ++read 2048/2048 bytes at offset 4297924608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297928704 ++read 2048/2048 bytes at offset 4297928704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297932800 ++read 2048/2048 bytes at offset 4297932800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297936896 ++read 2048/2048 bytes at offset 4297936896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297940992 ++read 2048/2048 bytes at offset 4297940992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297945088 ++read 2048/2048 bytes at offset 4297945088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297949184 ++read 2048/2048 bytes at offset 4297949184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297953280 ++read 2048/2048 bytes at offset 4297953280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297957376 ++read 2048/2048 bytes at offset 4297957376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297961472 ++read 2048/2048 bytes at offset 4297961472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297965568 ++read 2048/2048 bytes at offset 4297965568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297969664 ++read 2048/2048 bytes at offset 4297969664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297973760 ++read 2048/2048 bytes at offset 4297973760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297977856 ++read 2048/2048 bytes at offset 4297977856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297981952 ++read 2048/2048 bytes at offset 4297981952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297986048 ++read 2048/2048 bytes at offset 4297986048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297990144 ++read 2048/2048 bytes at offset 4297990144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297994240 ++read 2048/2048 bytes at offset 4297994240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297998336 ++read 2048/2048 bytes at offset 4297998336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298002432 ++read 2048/2048 bytes at offset 4298002432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298006528 ++read 2048/2048 bytes at offset 4298006528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298010624 ++read 2048/2048 bytes at offset 4298010624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298014720 ++read 2048/2048 bytes at offset 4298014720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298018816 ++read 2048/2048 bytes at offset 4298018816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298022912 ++read 2048/2048 bytes at offset 4298022912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298027008 ++read 2048/2048 bytes at offset 4298027008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298031104 ++read 2048/2048 bytes at offset 4298031104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298035200 ++read 2048/2048 bytes at offset 4298035200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298039296 ++read 2048/2048 bytes at offset 4298039296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298043392 ++read 2048/2048 bytes at offset 4298043392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298047488 ++read 2048/2048 bytes at offset 4298047488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298051584 ++read 2048/2048 bytes at offset 4298051584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298055680 ++read 2048/2048 bytes at offset 4298055680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298059776 ++read 2048/2048 bytes at offset 4298059776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298063872 ++read 2048/2048 bytes at offset 4298063872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298067968 ++read 2048/2048 bytes at offset 4298067968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298072064 ++read 2048/2048 bytes at offset 4298072064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298076160 ++read 2048/2048 bytes at offset 4298076160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298080256 ++read 2048/2048 bytes at offset 4298080256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298084352 ++read 2048/2048 bytes at offset 4298084352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298088448 ++read 2048/2048 bytes at offset 4298088448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298092544 ++read 2048/2048 bytes at offset 4298092544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298096640 ++read 2048/2048 bytes at offset 4298096640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298100736 ++read 2048/2048 bytes at offset 4298100736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298104832 ++read 2048/2048 bytes at offset 4298104832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298108928 ++read 2048/2048 bytes at offset 4298108928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 2 +-qemu-io> read 2048/2048 bytes at offset 4298114048 ++=== IO: pattern 2 ++read 2048/2048 bytes at offset 4298114048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298118144 ++read 2048/2048 bytes at offset 4298118144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298122240 ++read 2048/2048 bytes at offset 4298122240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298126336 ++read 2048/2048 bytes at offset 4298126336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298130432 ++read 2048/2048 bytes at offset 4298130432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298134528 ++read 2048/2048 bytes at offset 4298134528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298138624 ++read 2048/2048 bytes at offset 4298138624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298142720 ++read 2048/2048 bytes at offset 4298142720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298146816 ++read 2048/2048 bytes at offset 4298146816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298150912 ++read 2048/2048 bytes at offset 4298150912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298155008 ++read 2048/2048 bytes at offset 4298155008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298159104 ++read 2048/2048 bytes at offset 4298159104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298163200 ++read 2048/2048 bytes at offset 4298163200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298167296 ++read 2048/2048 bytes at offset 4298167296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298171392 ++read 2048/2048 bytes at offset 4298171392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298175488 ++read 2048/2048 bytes at offset 4298175488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298179584 ++read 2048/2048 bytes at offset 4298179584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298183680 ++read 2048/2048 bytes at offset 4298183680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298187776 ++read 2048/2048 bytes at offset 4298187776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298191872 ++read 2048/2048 bytes at offset 4298191872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298195968 ++read 2048/2048 bytes at offset 4298195968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298200064 ++read 2048/2048 bytes at offset 4298200064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298204160 ++read 2048/2048 bytes at offset 4298204160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298208256 ++read 2048/2048 bytes at offset 4298208256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298212352 ++read 2048/2048 bytes at offset 4298212352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298216448 ++read 2048/2048 bytes at offset 4298216448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298220544 ++read 2048/2048 bytes at offset 4298220544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298224640 ++read 2048/2048 bytes at offset 4298224640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298228736 ++read 2048/2048 bytes at offset 4298228736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298232832 ++read 2048/2048 bytes at offset 4298232832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298236928 ++read 2048/2048 bytes at offset 4298236928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298241024 ++read 2048/2048 bytes at offset 4298241024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298245120 ++read 2048/2048 bytes at offset 4298245120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298249216 ++read 2048/2048 bytes at offset 4298249216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298253312 ++read 2048/2048 bytes at offset 4298253312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298257408 ++read 2048/2048 bytes at offset 4298257408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298261504 ++read 2048/2048 bytes at offset 4298261504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298265600 ++read 2048/2048 bytes at offset 4298265600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298269696 ++read 2048/2048 bytes at offset 4298269696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298273792 ++read 2048/2048 bytes at offset 4298273792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298277888 ++read 2048/2048 bytes at offset 4298277888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298281984 ++read 2048/2048 bytes at offset 4298281984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298286080 ++read 2048/2048 bytes at offset 4298286080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298290176 ++read 2048/2048 bytes at offset 4298290176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298294272 ++read 2048/2048 bytes at offset 4298294272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298298368 ++read 2048/2048 bytes at offset 4298298368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298302464 ++read 2048/2048 bytes at offset 4298302464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298306560 ++read 2048/2048 bytes at offset 4298306560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298310656 ++read 2048/2048 bytes at offset 4298310656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298314752 ++read 2048/2048 bytes at offset 4298314752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298318848 ++read 2048/2048 bytes at offset 4298318848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298322944 ++read 2048/2048 bytes at offset 4298322944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298327040 ++read 2048/2048 bytes at offset 4298327040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298331136 ++read 2048/2048 bytes at offset 4298331136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298335232 ++read 2048/2048 bytes at offset 4298335232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298339328 ++read 2048/2048 bytes at offset 4298339328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298343424 ++read 2048/2048 bytes at offset 4298343424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298347520 ++read 2048/2048 bytes at offset 4298347520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298351616 ++read 2048/2048 bytes at offset 4298351616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298355712 ++read 2048/2048 bytes at offset 4298355712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298359808 ++read 2048/2048 bytes at offset 4298359808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298363904 ++read 2048/2048 bytes at offset 4298363904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298368000 ++read 2048/2048 bytes at offset 4298368000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298372096 ++read 2048/2048 bytes at offset 4298372096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298376192 ++read 2048/2048 bytes at offset 4298376192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298380288 ++read 2048/2048 bytes at offset 4298380288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298384384 ++read 2048/2048 bytes at offset 4298384384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298388480 ++read 2048/2048 bytes at offset 4298388480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298392576 ++read 2048/2048 bytes at offset 4298392576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298396672 ++read 2048/2048 bytes at offset 4298396672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298400768 ++read 2048/2048 bytes at offset 4298400768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298404864 ++read 2048/2048 bytes at offset 4298404864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298408960 ++read 2048/2048 bytes at offset 4298408960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298413056 ++read 2048/2048 bytes at offset 4298413056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298417152 ++read 2048/2048 bytes at offset 4298417152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298421248 ++read 2048/2048 bytes at offset 4298421248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298425344 ++read 2048/2048 bytes at offset 4298425344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298429440 ++read 2048/2048 bytes at offset 4298429440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298433536 ++read 2048/2048 bytes at offset 4298433536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298437632 ++read 2048/2048 bytes at offset 4298437632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298441728 ++read 2048/2048 bytes at offset 4298441728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298445824 ++read 2048/2048 bytes at offset 4298445824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298449920 ++read 2048/2048 bytes at offset 4298449920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298454016 ++read 2048/2048 bytes at offset 4298454016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298458112 ++read 2048/2048 bytes at offset 4298458112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298462208 ++read 2048/2048 bytes at offset 4298462208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298466304 ++read 2048/2048 bytes at offset 4298466304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298470400 ++read 2048/2048 bytes at offset 4298470400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298474496 ++read 2048/2048 bytes at offset 4298474496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298478592 ++read 2048/2048 bytes at offset 4298478592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298482688 ++read 2048/2048 bytes at offset 4298482688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298486784 ++read 2048/2048 bytes at offset 4298486784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298490880 ++read 2048/2048 bytes at offset 4298490880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298494976 ++read 2048/2048 bytes at offset 4298494976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298499072 ++read 2048/2048 bytes at offset 4298499072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298503168 ++read 2048/2048 bytes at offset 4298503168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298507264 ++read 2048/2048 bytes at offset 4298507264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298511360 ++read 2048/2048 bytes at offset 4298511360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298515456 ++read 2048/2048 bytes at offset 4298515456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298519552 ++read 2048/2048 bytes at offset 4298519552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298523648 ++read 2048/2048 bytes at offset 4298523648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298527744 ++read 2048/2048 bytes at offset 4298527744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298531840 ++read 2048/2048 bytes at offset 4298531840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298535936 ++read 2048/2048 bytes at offset 4298535936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298540032 ++read 2048/2048 bytes at offset 4298540032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298544128 ++read 2048/2048 bytes at offset 4298544128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298548224 ++read 2048/2048 bytes at offset 4298548224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298552320 ++read 2048/2048 bytes at offset 4298552320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298556416 ++read 2048/2048 bytes at offset 4298556416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298560512 ++read 2048/2048 bytes at offset 4298560512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298564608 ++read 2048/2048 bytes at offset 4298564608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298568704 ++read 2048/2048 bytes at offset 4298568704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298572800 ++read 2048/2048 bytes at offset 4298572800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298576896 ++read 2048/2048 bytes at offset 4298576896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298580992 ++read 2048/2048 bytes at offset 4298580992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298585088 ++read 2048/2048 bytes at offset 4298585088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298589184 ++read 2048/2048 bytes at offset 4298589184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298593280 ++read 2048/2048 bytes at offset 4298593280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298597376 ++read 2048/2048 bytes at offset 4298597376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298601472 ++read 2048/2048 bytes at offset 4298601472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298605568 ++read 2048/2048 bytes at offset 4298605568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298609664 ++read 2048/2048 bytes at offset 4298609664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298613760 ++read 2048/2048 bytes at offset 4298613760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298617856 ++read 2048/2048 bytes at offset 4298617856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298621952 ++read 2048/2048 bytes at offset 4298621952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298626048 ++read 2048/2048 bytes at offset 4298626048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298630144 ++read 2048/2048 bytes at offset 4298630144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298634240 ++read 2048/2048 bytes at offset 4298634240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298638336 ++read 2048/2048 bytes at offset 4298638336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298642432 ++read 2048/2048 bytes at offset 4298642432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298646528 ++read 2048/2048 bytes at offset 4298646528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298650624 ++read 2048/2048 bytes at offset 4298650624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298654720 ++read 2048/2048 bytes at offset 4298654720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298658816 ++read 2048/2048 bytes at offset 4298658816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298662912 ++read 2048/2048 bytes at offset 4298662912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298667008 ++read 2048/2048 bytes at offset 4298667008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298671104 ++read 2048/2048 bytes at offset 4298671104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298675200 ++read 2048/2048 bytes at offset 4298675200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298679296 ++read 2048/2048 bytes at offset 4298679296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298683392 ++read 2048/2048 bytes at offset 4298683392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298687488 ++read 2048/2048 bytes at offset 4298687488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298691584 ++read 2048/2048 bytes at offset 4298691584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298695680 ++read 2048/2048 bytes at offset 4298695680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298699776 ++read 2048/2048 bytes at offset 4298699776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298703872 ++read 2048/2048 bytes at offset 4298703872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298707968 ++read 2048/2048 bytes at offset 4298707968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298712064 ++read 2048/2048 bytes at offset 4298712064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298716160 ++read 2048/2048 bytes at offset 4298716160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298720256 ++read 2048/2048 bytes at offset 4298720256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298724352 ++read 2048/2048 bytes at offset 4298724352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298728448 ++read 2048/2048 bytes at offset 4298728448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298732544 ++read 2048/2048 bytes at offset 4298732544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298736640 ++read 2048/2048 bytes at offset 4298736640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298740736 ++read 2048/2048 bytes at offset 4298740736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298744832 ++read 2048/2048 bytes at offset 4298744832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298748928 ++read 2048/2048 bytes at offset 4298748928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298753024 ++read 2048/2048 bytes at offset 4298753024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298757120 ++read 2048/2048 bytes at offset 4298757120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298761216 ++read 2048/2048 bytes at offset 4298761216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298765312 ++read 2048/2048 bytes at offset 4298765312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298769408 ++read 2048/2048 bytes at offset 4298769408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298773504 ++read 2048/2048 bytes at offset 4298773504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298777600 ++read 2048/2048 bytes at offset 4298777600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298781696 ++read 2048/2048 bytes at offset 4298781696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298785792 ++read 2048/2048 bytes at offset 4298785792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298789888 ++read 2048/2048 bytes at offset 4298789888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298793984 ++read 2048/2048 bytes at offset 4298793984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298798080 ++read 2048/2048 bytes at offset 4298798080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298802176 ++read 2048/2048 bytes at offset 4298802176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298806272 ++read 2048/2048 bytes at offset 4298806272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298810368 ++read 2048/2048 bytes at offset 4298810368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298814464 ++read 2048/2048 bytes at offset 4298814464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298818560 ++read 2048/2048 bytes at offset 4298818560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298822656 ++read 2048/2048 bytes at offset 4298822656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298826752 ++read 2048/2048 bytes at offset 4298826752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298830848 ++read 2048/2048 bytes at offset 4298830848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298834944 ++read 2048/2048 bytes at offset 4298834944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298839040 ++read 2048/2048 bytes at offset 4298839040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298843136 ++read 2048/2048 bytes at offset 4298843136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298847232 ++read 2048/2048 bytes at offset 4298847232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298851328 ++read 2048/2048 bytes at offset 4298851328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298855424 ++read 2048/2048 bytes at offset 4298855424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298859520 ++read 2048/2048 bytes at offset 4298859520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298863616 ++read 2048/2048 bytes at offset 4298863616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298867712 ++read 2048/2048 bytes at offset 4298867712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298871808 ++read 2048/2048 bytes at offset 4298871808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298875904 ++read 2048/2048 bytes at offset 4298875904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298880000 ++read 2048/2048 bytes at offset 4298880000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298884096 ++read 2048/2048 bytes at offset 4298884096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298888192 ++read 2048/2048 bytes at offset 4298888192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298892288 ++read 2048/2048 bytes at offset 4298892288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298896384 ++read 2048/2048 bytes at offset 4298896384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298900480 ++read 2048/2048 bytes at offset 4298900480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298904576 ++read 2048/2048 bytes at offset 4298904576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298908672 ++read 2048/2048 bytes at offset 4298908672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298912768 ++read 2048/2048 bytes at offset 4298912768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298916864 ++read 2048/2048 bytes at offset 4298916864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298920960 ++read 2048/2048 bytes at offset 4298920960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298925056 ++read 2048/2048 bytes at offset 4298925056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298929152 ++read 2048/2048 bytes at offset 4298929152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298933248 ++read 2048/2048 bytes at offset 4298933248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298937344 ++read 2048/2048 bytes at offset 4298937344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298941440 ++read 2048/2048 bytes at offset 4298941440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298945536 ++read 2048/2048 bytes at offset 4298945536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298949632 ++read 2048/2048 bytes at offset 4298949632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298953728 ++read 2048/2048 bytes at offset 4298953728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298957824 ++read 2048/2048 bytes at offset 4298957824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298961920 ++read 2048/2048 bytes at offset 4298961920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298966016 ++read 2048/2048 bytes at offset 4298966016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298970112 ++read 2048/2048 bytes at offset 4298970112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298974208 ++read 2048/2048 bytes at offset 4298974208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298978304 ++read 2048/2048 bytes at offset 4298978304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298982400 ++read 2048/2048 bytes at offset 4298982400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298986496 ++read 2048/2048 bytes at offset 4298986496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298990592 ++read 2048/2048 bytes at offset 4298990592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298994688 ++read 2048/2048 bytes at offset 4298994688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298998784 ++read 2048/2048 bytes at offset 4298998784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299002880 ++read 2048/2048 bytes at offset 4299002880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299006976 ++read 2048/2048 bytes at offset 4299006976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299011072 ++read 2048/2048 bytes at offset 4299011072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299015168 ++read 2048/2048 bytes at offset 4299015168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299019264 ++read 2048/2048 bytes at offset 4299019264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299023360 ++read 2048/2048 bytes at offset 4299023360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299027456 ++read 2048/2048 bytes at offset 4299027456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299031552 ++read 2048/2048 bytes at offset 4299031552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299035648 ++read 2048/2048 bytes at offset 4299035648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299039744 ++read 2048/2048 bytes at offset 4299039744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299043840 ++read 2048/2048 bytes at offset 4299043840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299047936 ++read 2048/2048 bytes at offset 4299047936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299052032 ++read 2048/2048 bytes at offset 4299052032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299056128 ++read 2048/2048 bytes at offset 4299056128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299060224 ++read 2048/2048 bytes at offset 4299060224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299064320 ++read 2048/2048 bytes at offset 4299064320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299068416 ++read 2048/2048 bytes at offset 4299068416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299072512 ++read 2048/2048 bytes at offset 4299072512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299076608 ++read 2048/2048 bytes at offset 4299076608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299080704 ++read 2048/2048 bytes at offset 4299080704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299084800 ++read 2048/2048 bytes at offset 4299084800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299088896 ++read 2048/2048 bytes at offset 4299088896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299092992 ++read 2048/2048 bytes at offset 4299092992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299097088 ++read 2048/2048 bytes at offset 4299097088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299101184 ++read 2048/2048 bytes at offset 4299101184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299105280 ++read 2048/2048 bytes at offset 4299105280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299109376 ++read 2048/2048 bytes at offset 4299109376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299113472 ++read 2048/2048 bytes at offset 4299113472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299117568 ++read 2048/2048 bytes at offset 4299117568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299121664 ++read 2048/2048 bytes at offset 4299121664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299125760 ++read 2048/2048 bytes at offset 4299125760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299129856 ++read 2048/2048 bytes at offset 4299129856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299133952 ++read 2048/2048 bytes at offset 4299133952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299138048 ++read 2048/2048 bytes at offset 4299138048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299142144 ++read 2048/2048 bytes at offset 4299142144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299146240 ++read 2048/2048 bytes at offset 4299146240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299150336 ++read 2048/2048 bytes at offset 4299150336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299154432 ++read 2048/2048 bytes at offset 4299154432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299158528 ++read 2048/2048 bytes at offset 4299158528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 4 +-qemu-io> read 8192/8192 bytes at offset 4299163648 ++=== IO: pattern 4 ++read 8192/8192 bytes at offset 4299163648 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299175936 ++read 8192/8192 bytes at offset 4299175936 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299188224 ++read 8192/8192 bytes at offset 4299188224 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299200512 ++read 8192/8192 bytes at offset 4299200512 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299212800 ++read 8192/8192 bytes at offset 4299212800 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299225088 ++read 8192/8192 bytes at offset 4299225088 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299237376 ++read 8192/8192 bytes at offset 4299237376 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299249664 ++read 8192/8192 bytes at offset 4299249664 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299261952 ++read 8192/8192 bytes at offset 4299261952 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299274240 ++read 8192/8192 bytes at offset 4299274240 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299286528 ++read 8192/8192 bytes at offset 4299286528 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299298816 ++read 8192/8192 bytes at offset 4299298816 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299311104 ++read 8192/8192 bytes at offset 4299311104 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299323392 ++read 8192/8192 bytes at offset 4299323392 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299335680 ++read 8192/8192 bytes at offset 4299335680 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299347968 ++read 8192/8192 bytes at offset 4299347968 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299360256 ++read 8192/8192 bytes at offset 4299360256 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299372544 ++read 8192/8192 bytes at offset 4299372544 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299384832 ++read 8192/8192 bytes at offset 4299384832 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299397120 ++read 8192/8192 bytes at offset 4299397120 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299409408 ++read 8192/8192 bytes at offset 4299409408 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299421696 ++read 8192/8192 bytes at offset 4299421696 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299433984 ++read 8192/8192 bytes at offset 4299433984 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299446272 ++read 8192/8192 bytes at offset 4299446272 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299458560 ++read 8192/8192 bytes at offset 4299458560 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299470848 ++read 8192/8192 bytes at offset 4299470848 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299483136 ++read 8192/8192 bytes at offset 4299483136 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299495424 ++read 8192/8192 bytes at offset 4299495424 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299507712 ++read 8192/8192 bytes at offset 4299507712 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299520000 ++read 8192/8192 bytes at offset 4299520000 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299532288 ++read 8192/8192 bytes at offset 4299532288 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299544576 ++read 8192/8192 bytes at offset 4299544576 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299556864 ++read 8192/8192 bytes at offset 4299556864 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299569152 ++read 8192/8192 bytes at offset 4299569152 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299581440 ++read 8192/8192 bytes at offset 4299581440 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299593728 ++read 8192/8192 bytes at offset 4299593728 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299606016 ++read 8192/8192 bytes at offset 4299606016 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299618304 ++read 8192/8192 bytes at offset 4299618304 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299630592 ++read 8192/8192 bytes at offset 4299630592 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299642880 ++read 8192/8192 bytes at offset 4299642880 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299655168 ++read 8192/8192 bytes at offset 4299655168 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299667456 ++read 8192/8192 bytes at offset 4299667456 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299679744 ++read 8192/8192 bytes at offset 4299679744 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299692032 ++read 8192/8192 bytes at offset 4299692032 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299704320 ++read 8192/8192 bytes at offset 4299704320 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299716608 ++read 8192/8192 bytes at offset 4299716608 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299728896 ++read 8192/8192 bytes at offset 4299728896 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299741184 ++read 8192/8192 bytes at offset 4299741184 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299753472 ++read 8192/8192 bytes at offset 4299753472 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299765760 ++read 8192/8192 bytes at offset 4299765760 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299778048 ++read 8192/8192 bytes at offset 4299778048 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299790336 ++read 8192/8192 bytes at offset 4299790336 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299802624 ++read 8192/8192 bytes at offset 4299802624 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299814912 ++read 8192/8192 bytes at offset 4299814912 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299827200 ++read 8192/8192 bytes at offset 4299827200 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299839488 ++read 8192/8192 bytes at offset 4299839488 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299851776 ++read 8192/8192 bytes at offset 4299851776 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299864064 ++read 8192/8192 bytes at offset 4299864064 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299876352 ++read 8192/8192 bytes at offset 4299876352 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299888640 ++read 8192/8192 bytes at offset 4299888640 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299900928 ++read 8192/8192 bytes at offset 4299900928 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299913216 ++read 8192/8192 bytes at offset 4299913216 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299925504 ++read 8192/8192 bytes at offset 4299925504 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299937792 ++read 8192/8192 bytes at offset 4299937792 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 244 +-qemu-io> read 12288/12288 bytes at offset 4301252608 ++=== IO: pattern 244 ++read 12288/12288 bytes at offset 4301252608 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4303351808 ++read 12288/12288 bytes at offset 4303351808 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4305451008 ++read 12288/12288 bytes at offset 4305451008 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4307550208 ++read 12288/12288 bytes at offset 4307550208 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4309649408 ++read 12288/12288 bytes at offset 4309649408 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4311748608 ++read 12288/12288 bytes at offset 4311748608 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4313847808 ++read 12288/12288 bytes at offset 4313847808 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4315947008 ++read 12288/12288 bytes at offset 4315947008 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> No errors were found on the image. ++No errors were found on the image. + Compressing image + + Testing compressed image + + With offset 0: + === IO: pattern 0 +-qemu-io> read 4096/4096 bytes at offset 0 ++read 4096/4096 bytes at offset 0 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4096 ++read 4096/4096 bytes at offset 4096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 8192 ++read 4096/4096 bytes at offset 8192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 12288 ++read 4096/4096 bytes at offset 12288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 16384 ++read 4096/4096 bytes at offset 16384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 20480 ++read 4096/4096 bytes at offset 20480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 24576 ++read 4096/4096 bytes at offset 24576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 28672 ++read 4096/4096 bytes at offset 28672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 32768 ++read 4096/4096 bytes at offset 32768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 36864 ++read 4096/4096 bytes at offset 36864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 40960 ++read 4096/4096 bytes at offset 40960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 45056 ++read 4096/4096 bytes at offset 45056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 49152 ++read 4096/4096 bytes at offset 49152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 53248 ++read 4096/4096 bytes at offset 53248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 57344 ++read 4096/4096 bytes at offset 57344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 61440 ++read 4096/4096 bytes at offset 61440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 65536 ++read 4096/4096 bytes at offset 65536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 69632 ++read 4096/4096 bytes at offset 69632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 73728 ++read 4096/4096 bytes at offset 73728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 77824 ++read 4096/4096 bytes at offset 77824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 81920 ++read 4096/4096 bytes at offset 81920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 86016 ++read 4096/4096 bytes at offset 86016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 90112 ++read 4096/4096 bytes at offset 90112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 94208 ++read 4096/4096 bytes at offset 94208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 98304 ++read 4096/4096 bytes at offset 98304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 102400 ++read 4096/4096 bytes at offset 102400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 106496 ++read 4096/4096 bytes at offset 106496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 110592 ++read 4096/4096 bytes at offset 110592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 114688 ++read 4096/4096 bytes at offset 114688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 118784 ++read 4096/4096 bytes at offset 118784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 122880 ++read 4096/4096 bytes at offset 122880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 126976 ++read 4096/4096 bytes at offset 126976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 131072 ++read 4096/4096 bytes at offset 131072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 135168 ++read 4096/4096 bytes at offset 135168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 139264 ++read 4096/4096 bytes at offset 139264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 143360 ++read 4096/4096 bytes at offset 143360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 147456 ++read 4096/4096 bytes at offset 147456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 151552 ++read 4096/4096 bytes at offset 151552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 155648 ++read 4096/4096 bytes at offset 155648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 159744 ++read 4096/4096 bytes at offset 159744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 163840 ++read 4096/4096 bytes at offset 163840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 167936 ++read 4096/4096 bytes at offset 167936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 172032 ++read 4096/4096 bytes at offset 172032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 176128 ++read 4096/4096 bytes at offset 176128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 180224 ++read 4096/4096 bytes at offset 180224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 184320 ++read 4096/4096 bytes at offset 184320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 188416 ++read 4096/4096 bytes at offset 188416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 192512 ++read 4096/4096 bytes at offset 192512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 196608 ++read 4096/4096 bytes at offset 196608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 200704 ++read 4096/4096 bytes at offset 200704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 204800 ++read 4096/4096 bytes at offset 204800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 208896 ++read 4096/4096 bytes at offset 208896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 212992 ++read 4096/4096 bytes at offset 212992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 217088 ++read 4096/4096 bytes at offset 217088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 221184 ++read 4096/4096 bytes at offset 221184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 225280 ++read 4096/4096 bytes at offset 225280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 229376 ++read 4096/4096 bytes at offset 229376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 233472 ++read 4096/4096 bytes at offset 233472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 237568 ++read 4096/4096 bytes at offset 237568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 241664 ++read 4096/4096 bytes at offset 241664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 245760 ++read 4096/4096 bytes at offset 245760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 249856 ++read 4096/4096 bytes at offset 249856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 253952 ++read 4096/4096 bytes at offset 253952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 258048 ++read 4096/4096 bytes at offset 258048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 262144 ++read 4096/4096 bytes at offset 262144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 266240 ++read 4096/4096 bytes at offset 266240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 270336 ++read 4096/4096 bytes at offset 270336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 274432 ++read 4096/4096 bytes at offset 274432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 278528 ++read 4096/4096 bytes at offset 278528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 282624 ++read 4096/4096 bytes at offset 282624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 286720 ++read 4096/4096 bytes at offset 286720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 290816 ++read 4096/4096 bytes at offset 290816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 294912 ++read 4096/4096 bytes at offset 294912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 299008 ++read 4096/4096 bytes at offset 299008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 303104 ++read 4096/4096 bytes at offset 303104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 307200 ++read 4096/4096 bytes at offset 307200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 311296 ++read 4096/4096 bytes at offset 311296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 315392 ++read 4096/4096 bytes at offset 315392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 319488 ++read 4096/4096 bytes at offset 319488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 323584 ++read 4096/4096 bytes at offset 323584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 327680 ++read 4096/4096 bytes at offset 327680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 331776 ++read 4096/4096 bytes at offset 331776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 335872 ++read 4096/4096 bytes at offset 335872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 339968 ++read 4096/4096 bytes at offset 339968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 344064 ++read 4096/4096 bytes at offset 344064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 348160 ++read 4096/4096 bytes at offset 348160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 352256 ++read 4096/4096 bytes at offset 352256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 356352 ++read 4096/4096 bytes at offset 356352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 360448 ++read 4096/4096 bytes at offset 360448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 364544 ++read 4096/4096 bytes at offset 364544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 368640 ++read 4096/4096 bytes at offset 368640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 372736 ++read 4096/4096 bytes at offset 372736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 376832 ++read 4096/4096 bytes at offset 376832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 380928 ++read 4096/4096 bytes at offset 380928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 385024 ++read 4096/4096 bytes at offset 385024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 389120 ++read 4096/4096 bytes at offset 389120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 393216 ++read 4096/4096 bytes at offset 393216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 397312 ++read 4096/4096 bytes at offset 397312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 401408 ++read 4096/4096 bytes at offset 401408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 405504 ++read 4096/4096 bytes at offset 405504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 409600 ++read 4096/4096 bytes at offset 409600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 413696 ++read 4096/4096 bytes at offset 413696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 417792 ++read 4096/4096 bytes at offset 417792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 421888 ++read 4096/4096 bytes at offset 421888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 425984 ++read 4096/4096 bytes at offset 425984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 430080 ++read 4096/4096 bytes at offset 430080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 434176 ++read 4096/4096 bytes at offset 434176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 438272 ++read 4096/4096 bytes at offset 438272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 442368 ++read 4096/4096 bytes at offset 442368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 446464 ++read 4096/4096 bytes at offset 446464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 450560 ++read 4096/4096 bytes at offset 450560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 454656 ++read 4096/4096 bytes at offset 454656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 458752 ++read 4096/4096 bytes at offset 458752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 462848 ++read 4096/4096 bytes at offset 462848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 466944 ++read 4096/4096 bytes at offset 466944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 471040 ++read 4096/4096 bytes at offset 471040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 475136 ++read 4096/4096 bytes at offset 475136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 479232 ++read 4096/4096 bytes at offset 479232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 483328 ++read 4096/4096 bytes at offset 483328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 487424 ++read 4096/4096 bytes at offset 487424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 491520 ++read 4096/4096 bytes at offset 491520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 495616 ++read 4096/4096 bytes at offset 495616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 499712 ++read 4096/4096 bytes at offset 499712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 503808 ++read 4096/4096 bytes at offset 503808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 507904 ++read 4096/4096 bytes at offset 507904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 512000 ++read 4096/4096 bytes at offset 512000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 516096 ++read 4096/4096 bytes at offset 516096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 520192 ++read 4096/4096 bytes at offset 520192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 524288 ++read 4096/4096 bytes at offset 524288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 528384 ++read 4096/4096 bytes at offset 528384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 532480 ++read 4096/4096 bytes at offset 532480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 536576 ++read 4096/4096 bytes at offset 536576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 540672 ++read 4096/4096 bytes at offset 540672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 544768 ++read 4096/4096 bytes at offset 544768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 548864 ++read 4096/4096 bytes at offset 548864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 552960 ++read 4096/4096 bytes at offset 552960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 557056 ++read 4096/4096 bytes at offset 557056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 561152 ++read 4096/4096 bytes at offset 561152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 565248 ++read 4096/4096 bytes at offset 565248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 569344 ++read 4096/4096 bytes at offset 569344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 573440 ++read 4096/4096 bytes at offset 573440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 577536 ++read 4096/4096 bytes at offset 577536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 581632 ++read 4096/4096 bytes at offset 581632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 585728 ++read 4096/4096 bytes at offset 585728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 589824 ++read 4096/4096 bytes at offset 589824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 593920 ++read 4096/4096 bytes at offset 593920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 598016 ++read 4096/4096 bytes at offset 598016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 602112 ++read 4096/4096 bytes at offset 602112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 606208 ++read 4096/4096 bytes at offset 606208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 610304 ++read 4096/4096 bytes at offset 610304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 614400 ++read 4096/4096 bytes at offset 614400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 618496 ++read 4096/4096 bytes at offset 618496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 622592 ++read 4096/4096 bytes at offset 622592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 626688 ++read 4096/4096 bytes at offset 626688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 630784 ++read 4096/4096 bytes at offset 630784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 634880 ++read 4096/4096 bytes at offset 634880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 638976 ++read 4096/4096 bytes at offset 638976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 643072 ++read 4096/4096 bytes at offset 643072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 647168 ++read 4096/4096 bytes at offset 647168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 651264 ++read 4096/4096 bytes at offset 651264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 655360 ++read 4096/4096 bytes at offset 655360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 659456 ++read 4096/4096 bytes at offset 659456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 663552 ++read 4096/4096 bytes at offset 663552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 667648 ++read 4096/4096 bytes at offset 667648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 671744 ++read 4096/4096 bytes at offset 671744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 675840 ++read 4096/4096 bytes at offset 675840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 679936 ++read 4096/4096 bytes at offset 679936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 684032 ++read 4096/4096 bytes at offset 684032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 688128 ++read 4096/4096 bytes at offset 688128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 692224 ++read 4096/4096 bytes at offset 692224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 696320 ++read 4096/4096 bytes at offset 696320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 700416 ++read 4096/4096 bytes at offset 700416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 704512 ++read 4096/4096 bytes at offset 704512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 708608 ++read 4096/4096 bytes at offset 708608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 712704 ++read 4096/4096 bytes at offset 712704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 716800 ++read 4096/4096 bytes at offset 716800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 720896 ++read 4096/4096 bytes at offset 720896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 724992 ++read 4096/4096 bytes at offset 724992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 729088 ++read 4096/4096 bytes at offset 729088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 733184 ++read 4096/4096 bytes at offset 733184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 737280 ++read 4096/4096 bytes at offset 737280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 741376 ++read 4096/4096 bytes at offset 741376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 745472 ++read 4096/4096 bytes at offset 745472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 749568 ++read 4096/4096 bytes at offset 749568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 753664 ++read 4096/4096 bytes at offset 753664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 757760 ++read 4096/4096 bytes at offset 757760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 761856 ++read 4096/4096 bytes at offset 761856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 765952 ++read 4096/4096 bytes at offset 765952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 770048 ++read 4096/4096 bytes at offset 770048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 774144 ++read 4096/4096 bytes at offset 774144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 778240 ++read 4096/4096 bytes at offset 778240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 782336 ++read 4096/4096 bytes at offset 782336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 786432 ++read 4096/4096 bytes at offset 786432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 790528 ++read 4096/4096 bytes at offset 790528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 794624 ++read 4096/4096 bytes at offset 794624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 798720 ++read 4096/4096 bytes at offset 798720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 802816 ++read 4096/4096 bytes at offset 802816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 806912 ++read 4096/4096 bytes at offset 806912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 811008 ++read 4096/4096 bytes at offset 811008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 815104 ++read 4096/4096 bytes at offset 815104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 819200 ++read 4096/4096 bytes at offset 819200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 823296 ++read 4096/4096 bytes at offset 823296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 827392 ++read 4096/4096 bytes at offset 827392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 831488 ++read 4096/4096 bytes at offset 831488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 835584 ++read 4096/4096 bytes at offset 835584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 839680 ++read 4096/4096 bytes at offset 839680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 843776 ++read 4096/4096 bytes at offset 843776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 847872 ++read 4096/4096 bytes at offset 847872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 851968 ++read 4096/4096 bytes at offset 851968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 856064 ++read 4096/4096 bytes at offset 856064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 860160 ++read 4096/4096 bytes at offset 860160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 864256 ++read 4096/4096 bytes at offset 864256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 868352 ++read 4096/4096 bytes at offset 868352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 872448 ++read 4096/4096 bytes at offset 872448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 876544 ++read 4096/4096 bytes at offset 876544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 880640 ++read 4096/4096 bytes at offset 880640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 884736 ++read 4096/4096 bytes at offset 884736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 888832 ++read 4096/4096 bytes at offset 888832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 892928 ++read 4096/4096 bytes at offset 892928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 897024 ++read 4096/4096 bytes at offset 897024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 901120 ++read 4096/4096 bytes at offset 901120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 905216 ++read 4096/4096 bytes at offset 905216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 909312 ++read 4096/4096 bytes at offset 909312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 913408 ++read 4096/4096 bytes at offset 913408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 917504 ++read 4096/4096 bytes at offset 917504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 921600 ++read 4096/4096 bytes at offset 921600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 925696 ++read 4096/4096 bytes at offset 925696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 929792 ++read 4096/4096 bytes at offset 929792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 933888 ++read 4096/4096 bytes at offset 933888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 937984 ++read 4096/4096 bytes at offset 937984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 942080 ++read 4096/4096 bytes at offset 942080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 946176 ++read 4096/4096 bytes at offset 946176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 950272 ++read 4096/4096 bytes at offset 950272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 954368 ++read 4096/4096 bytes at offset 954368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 958464 ++read 4096/4096 bytes at offset 958464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 962560 ++read 4096/4096 bytes at offset 962560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 966656 ++read 4096/4096 bytes at offset 966656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 970752 ++read 4096/4096 bytes at offset 970752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 974848 ++read 4096/4096 bytes at offset 974848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 978944 ++read 4096/4096 bytes at offset 978944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 983040 ++read 4096/4096 bytes at offset 983040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 987136 ++read 4096/4096 bytes at offset 987136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 991232 ++read 4096/4096 bytes at offset 991232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 995328 ++read 4096/4096 bytes at offset 995328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 999424 ++read 4096/4096 bytes at offset 999424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1003520 ++read 4096/4096 bytes at offset 1003520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1007616 ++read 4096/4096 bytes at offset 1007616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1011712 ++read 4096/4096 bytes at offset 1011712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1015808 ++read 4096/4096 bytes at offset 1015808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1019904 ++read 4096/4096 bytes at offset 1019904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1024000 ++read 4096/4096 bytes at offset 1024000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1028096 ++read 4096/4096 bytes at offset 1028096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1032192 ++read 4096/4096 bytes at offset 1032192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1036288 ++read 4096/4096 bytes at offset 1036288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1040384 ++read 4096/4096 bytes at offset 1040384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1044480 ++read 4096/4096 bytes at offset 1044480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 4 +-qemu-io> read 2048/2048 bytes at offset 1050624 ++=== IO: pattern 4 ++read 2048/2048 bytes at offset 1050624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1054720 ++read 2048/2048 bytes at offset 1054720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1058816 ++read 2048/2048 bytes at offset 1058816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1062912 ++read 2048/2048 bytes at offset 1062912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1067008 ++read 2048/2048 bytes at offset 1067008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1071104 ++read 2048/2048 bytes at offset 1071104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1075200 ++read 2048/2048 bytes at offset 1075200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1079296 ++read 2048/2048 bytes at offset 1079296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1083392 ++read 2048/2048 bytes at offset 1083392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1087488 ++read 2048/2048 bytes at offset 1087488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1091584 ++read 2048/2048 bytes at offset 1091584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1095680 ++read 2048/2048 bytes at offset 1095680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1099776 ++read 2048/2048 bytes at offset 1099776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1103872 ++read 2048/2048 bytes at offset 1103872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1107968 ++read 2048/2048 bytes at offset 1107968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1112064 ++read 2048/2048 bytes at offset 1112064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1116160 ++read 2048/2048 bytes at offset 1116160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1120256 ++read 2048/2048 bytes at offset 1120256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1124352 ++read 2048/2048 bytes at offset 1124352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1128448 ++read 2048/2048 bytes at offset 1128448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1132544 ++read 2048/2048 bytes at offset 1132544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1136640 ++read 2048/2048 bytes at offset 1136640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1140736 ++read 2048/2048 bytes at offset 1140736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1144832 ++read 2048/2048 bytes at offset 1144832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1148928 ++read 2048/2048 bytes at offset 1148928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1153024 ++read 2048/2048 bytes at offset 1153024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1157120 ++read 2048/2048 bytes at offset 1157120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1161216 ++read 2048/2048 bytes at offset 1161216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1165312 ++read 2048/2048 bytes at offset 1165312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1169408 ++read 2048/2048 bytes at offset 1169408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1173504 ++read 2048/2048 bytes at offset 1173504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1177600 ++read 2048/2048 bytes at offset 1177600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1181696 ++read 2048/2048 bytes at offset 1181696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1185792 ++read 2048/2048 bytes at offset 1185792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1189888 ++read 2048/2048 bytes at offset 1189888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1193984 ++read 2048/2048 bytes at offset 1193984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1198080 ++read 2048/2048 bytes at offset 1198080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1202176 ++read 2048/2048 bytes at offset 1202176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1206272 ++read 2048/2048 bytes at offset 1206272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1210368 ++read 2048/2048 bytes at offset 1210368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1214464 ++read 2048/2048 bytes at offset 1214464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1218560 ++read 2048/2048 bytes at offset 1218560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1222656 ++read 2048/2048 bytes at offset 1222656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1226752 ++read 2048/2048 bytes at offset 1226752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1230848 ++read 2048/2048 bytes at offset 1230848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1234944 ++read 2048/2048 bytes at offset 1234944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1239040 ++read 2048/2048 bytes at offset 1239040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1243136 ++read 2048/2048 bytes at offset 1243136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1247232 ++read 2048/2048 bytes at offset 1247232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1251328 ++read 2048/2048 bytes at offset 1251328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1255424 ++read 2048/2048 bytes at offset 1255424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1259520 ++read 2048/2048 bytes at offset 1259520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1263616 ++read 2048/2048 bytes at offset 1263616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1267712 ++read 2048/2048 bytes at offset 1267712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1271808 ++read 2048/2048 bytes at offset 1271808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1275904 ++read 2048/2048 bytes at offset 1275904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1280000 ++read 2048/2048 bytes at offset 1280000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1284096 ++read 2048/2048 bytes at offset 1284096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1288192 ++read 2048/2048 bytes at offset 1288192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1292288 ++read 2048/2048 bytes at offset 1292288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1296384 ++read 2048/2048 bytes at offset 1296384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1300480 ++read 2048/2048 bytes at offset 1300480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1304576 ++read 2048/2048 bytes at offset 1304576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1308672 ++read 2048/2048 bytes at offset 1308672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1312768 ++read 2048/2048 bytes at offset 1312768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1316864 ++read 2048/2048 bytes at offset 1316864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1320960 ++read 2048/2048 bytes at offset 1320960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1325056 ++read 2048/2048 bytes at offset 1325056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1329152 ++read 2048/2048 bytes at offset 1329152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1333248 ++read 2048/2048 bytes at offset 1333248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1337344 ++read 2048/2048 bytes at offset 1337344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1341440 ++read 2048/2048 bytes at offset 1341440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1345536 ++read 2048/2048 bytes at offset 1345536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1349632 ++read 2048/2048 bytes at offset 1349632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1353728 ++read 2048/2048 bytes at offset 1353728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1357824 ++read 2048/2048 bytes at offset 1357824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1361920 ++read 2048/2048 bytes at offset 1361920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1366016 ++read 2048/2048 bytes at offset 1366016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1370112 ++read 2048/2048 bytes at offset 1370112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1374208 ++read 2048/2048 bytes at offset 1374208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1378304 ++read 2048/2048 bytes at offset 1378304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1382400 ++read 2048/2048 bytes at offset 1382400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1386496 ++read 2048/2048 bytes at offset 1386496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1390592 ++read 2048/2048 bytes at offset 1390592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1394688 ++read 2048/2048 bytes at offset 1394688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1398784 ++read 2048/2048 bytes at offset 1398784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1402880 ++read 2048/2048 bytes at offset 1402880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1406976 ++read 2048/2048 bytes at offset 1406976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1411072 ++read 2048/2048 bytes at offset 1411072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1415168 ++read 2048/2048 bytes at offset 1415168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1419264 ++read 2048/2048 bytes at offset 1419264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1423360 ++read 2048/2048 bytes at offset 1423360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1427456 ++read 2048/2048 bytes at offset 1427456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1431552 ++read 2048/2048 bytes at offset 1431552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1435648 ++read 2048/2048 bytes at offset 1435648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1439744 ++read 2048/2048 bytes at offset 1439744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1443840 ++read 2048/2048 bytes at offset 1443840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1447936 ++read 2048/2048 bytes at offset 1447936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1452032 ++read 2048/2048 bytes at offset 1452032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1456128 ++read 2048/2048 bytes at offset 1456128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1460224 ++read 2048/2048 bytes at offset 1460224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1464320 ++read 2048/2048 bytes at offset 1464320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1468416 ++read 2048/2048 bytes at offset 1468416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1472512 ++read 2048/2048 bytes at offset 1472512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1476608 ++read 2048/2048 bytes at offset 1476608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1480704 ++read 2048/2048 bytes at offset 1480704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1484800 ++read 2048/2048 bytes at offset 1484800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1488896 ++read 2048/2048 bytes at offset 1488896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1492992 ++read 2048/2048 bytes at offset 1492992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1497088 ++read 2048/2048 bytes at offset 1497088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1501184 ++read 2048/2048 bytes at offset 1501184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1505280 ++read 2048/2048 bytes at offset 1505280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1509376 ++read 2048/2048 bytes at offset 1509376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1513472 ++read 2048/2048 bytes at offset 1513472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1517568 ++read 2048/2048 bytes at offset 1517568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1521664 ++read 2048/2048 bytes at offset 1521664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1525760 ++read 2048/2048 bytes at offset 1525760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1529856 ++read 2048/2048 bytes at offset 1529856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1533952 ++read 2048/2048 bytes at offset 1533952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1538048 ++read 2048/2048 bytes at offset 1538048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1542144 ++read 2048/2048 bytes at offset 1542144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1546240 ++read 2048/2048 bytes at offset 1546240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1550336 ++read 2048/2048 bytes at offset 1550336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1554432 ++read 2048/2048 bytes at offset 1554432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1558528 ++read 2048/2048 bytes at offset 1558528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1562624 ++read 2048/2048 bytes at offset 1562624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1566720 ++read 2048/2048 bytes at offset 1566720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1570816 ++read 2048/2048 bytes at offset 1570816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1574912 ++read 2048/2048 bytes at offset 1574912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1579008 ++read 2048/2048 bytes at offset 1579008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1583104 ++read 2048/2048 bytes at offset 1583104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1587200 ++read 2048/2048 bytes at offset 1587200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1591296 ++read 2048/2048 bytes at offset 1591296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1595392 ++read 2048/2048 bytes at offset 1595392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1599488 ++read 2048/2048 bytes at offset 1599488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1603584 ++read 2048/2048 bytes at offset 1603584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1607680 ++read 2048/2048 bytes at offset 1607680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1611776 ++read 2048/2048 bytes at offset 1611776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1615872 ++read 2048/2048 bytes at offset 1615872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1619968 ++read 2048/2048 bytes at offset 1619968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1624064 ++read 2048/2048 bytes at offset 1624064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1628160 ++read 2048/2048 bytes at offset 1628160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1632256 ++read 2048/2048 bytes at offset 1632256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1636352 ++read 2048/2048 bytes at offset 1636352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1640448 ++read 2048/2048 bytes at offset 1640448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1644544 ++read 2048/2048 bytes at offset 1644544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1648640 ++read 2048/2048 bytes at offset 1648640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1652736 ++read 2048/2048 bytes at offset 1652736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1656832 ++read 2048/2048 bytes at offset 1656832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1660928 ++read 2048/2048 bytes at offset 1660928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1665024 ++read 2048/2048 bytes at offset 1665024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1669120 ++read 2048/2048 bytes at offset 1669120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1673216 ++read 2048/2048 bytes at offset 1673216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1677312 ++read 2048/2048 bytes at offset 1677312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1681408 ++read 2048/2048 bytes at offset 1681408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1685504 ++read 2048/2048 bytes at offset 1685504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1689600 ++read 2048/2048 bytes at offset 1689600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1693696 ++read 2048/2048 bytes at offset 1693696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1697792 ++read 2048/2048 bytes at offset 1697792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1701888 ++read 2048/2048 bytes at offset 1701888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1705984 ++read 2048/2048 bytes at offset 1705984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1710080 ++read 2048/2048 bytes at offset 1710080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1714176 ++read 2048/2048 bytes at offset 1714176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1718272 ++read 2048/2048 bytes at offset 1718272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1722368 ++read 2048/2048 bytes at offset 1722368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1726464 ++read 2048/2048 bytes at offset 1726464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1730560 ++read 2048/2048 bytes at offset 1730560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1734656 ++read 2048/2048 bytes at offset 1734656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1738752 ++read 2048/2048 bytes at offset 1738752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1742848 ++read 2048/2048 bytes at offset 1742848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1746944 ++read 2048/2048 bytes at offset 1746944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1751040 ++read 2048/2048 bytes at offset 1751040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1755136 ++read 2048/2048 bytes at offset 1755136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1759232 ++read 2048/2048 bytes at offset 1759232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1763328 ++read 2048/2048 bytes at offset 1763328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1767424 ++read 2048/2048 bytes at offset 1767424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1771520 ++read 2048/2048 bytes at offset 1771520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1775616 ++read 2048/2048 bytes at offset 1775616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1779712 ++read 2048/2048 bytes at offset 1779712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1783808 ++read 2048/2048 bytes at offset 1783808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1787904 ++read 2048/2048 bytes at offset 1787904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1792000 ++read 2048/2048 bytes at offset 1792000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1796096 ++read 2048/2048 bytes at offset 1796096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1800192 ++read 2048/2048 bytes at offset 1800192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1804288 ++read 2048/2048 bytes at offset 1804288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1808384 ++read 2048/2048 bytes at offset 1808384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1812480 ++read 2048/2048 bytes at offset 1812480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1816576 ++read 2048/2048 bytes at offset 1816576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1820672 ++read 2048/2048 bytes at offset 1820672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1824768 ++read 2048/2048 bytes at offset 1824768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1828864 ++read 2048/2048 bytes at offset 1828864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1832960 ++read 2048/2048 bytes at offset 1832960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1837056 ++read 2048/2048 bytes at offset 1837056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1841152 ++read 2048/2048 bytes at offset 1841152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1845248 ++read 2048/2048 bytes at offset 1845248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1849344 ++read 2048/2048 bytes at offset 1849344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1853440 ++read 2048/2048 bytes at offset 1853440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1857536 ++read 2048/2048 bytes at offset 1857536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1861632 ++read 2048/2048 bytes at offset 1861632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1865728 ++read 2048/2048 bytes at offset 1865728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1869824 ++read 2048/2048 bytes at offset 1869824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1873920 ++read 2048/2048 bytes at offset 1873920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1878016 ++read 2048/2048 bytes at offset 1878016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1882112 ++read 2048/2048 bytes at offset 1882112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1886208 ++read 2048/2048 bytes at offset 1886208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1890304 ++read 2048/2048 bytes at offset 1890304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1894400 ++read 2048/2048 bytes at offset 1894400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1898496 ++read 2048/2048 bytes at offset 1898496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1902592 ++read 2048/2048 bytes at offset 1902592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1906688 ++read 2048/2048 bytes at offset 1906688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1910784 ++read 2048/2048 bytes at offset 1910784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1914880 ++read 2048/2048 bytes at offset 1914880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1918976 ++read 2048/2048 bytes at offset 1918976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1923072 ++read 2048/2048 bytes at offset 1923072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1927168 ++read 2048/2048 bytes at offset 1927168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1931264 ++read 2048/2048 bytes at offset 1931264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1935360 ++read 2048/2048 bytes at offset 1935360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1939456 ++read 2048/2048 bytes at offset 1939456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1943552 ++read 2048/2048 bytes at offset 1943552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1947648 ++read 2048/2048 bytes at offset 1947648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1951744 ++read 2048/2048 bytes at offset 1951744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1955840 ++read 2048/2048 bytes at offset 1955840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1959936 ++read 2048/2048 bytes at offset 1959936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1964032 ++read 2048/2048 bytes at offset 1964032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1968128 ++read 2048/2048 bytes at offset 1968128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1972224 ++read 2048/2048 bytes at offset 1972224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1976320 ++read 2048/2048 bytes at offset 1976320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1980416 ++read 2048/2048 bytes at offset 1980416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1984512 ++read 2048/2048 bytes at offset 1984512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1988608 ++read 2048/2048 bytes at offset 1988608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1992704 ++read 2048/2048 bytes at offset 1992704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1996800 ++read 2048/2048 bytes at offset 1996800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2000896 ++read 2048/2048 bytes at offset 2000896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2004992 ++read 2048/2048 bytes at offset 2004992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2009088 ++read 2048/2048 bytes at offset 2009088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2013184 ++read 2048/2048 bytes at offset 2013184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2017280 ++read 2048/2048 bytes at offset 2017280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2021376 ++read 2048/2048 bytes at offset 2021376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2025472 ++read 2048/2048 bytes at offset 2025472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2029568 ++read 2048/2048 bytes at offset 2029568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2033664 ++read 2048/2048 bytes at offset 2033664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2037760 ++read 2048/2048 bytes at offset 2037760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2041856 ++read 2048/2048 bytes at offset 2041856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2045952 ++read 2048/2048 bytes at offset 2045952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2050048 ++read 2048/2048 bytes at offset 2050048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2054144 ++read 2048/2048 bytes at offset 2054144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2058240 ++read 2048/2048 bytes at offset 2058240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2062336 ++read 2048/2048 bytes at offset 2062336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2066432 ++read 2048/2048 bytes at offset 2066432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2070528 ++read 2048/2048 bytes at offset 2070528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2074624 ++read 2048/2048 bytes at offset 2074624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2078720 ++read 2048/2048 bytes at offset 2078720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2082816 ++read 2048/2048 bytes at offset 2082816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2086912 ++read 2048/2048 bytes at offset 2086912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2091008 ++read 2048/2048 bytes at offset 2091008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2095104 ++read 2048/2048 bytes at offset 2095104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> read 2048/2048 bytes at offset 2097152 ++=== IO: pattern 0 ++read 2048/2048 bytes at offset 2097152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2101248 ++read 2048/2048 bytes at offset 2101248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2105344 ++read 2048/2048 bytes at offset 2105344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2109440 ++read 2048/2048 bytes at offset 2109440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2113536 ++read 2048/2048 bytes at offset 2113536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2117632 ++read 2048/2048 bytes at offset 2117632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2121728 ++read 2048/2048 bytes at offset 2121728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2125824 ++read 2048/2048 bytes at offset 2125824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2129920 ++read 2048/2048 bytes at offset 2129920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2134016 ++read 2048/2048 bytes at offset 2134016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2138112 ++read 2048/2048 bytes at offset 2138112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2142208 ++read 2048/2048 bytes at offset 2142208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2146304 ++read 2048/2048 bytes at offset 2146304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2150400 ++read 2048/2048 bytes at offset 2150400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2154496 ++read 2048/2048 bytes at offset 2154496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2158592 ++read 2048/2048 bytes at offset 2158592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2162688 ++read 2048/2048 bytes at offset 2162688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2166784 ++read 2048/2048 bytes at offset 2166784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2170880 ++read 2048/2048 bytes at offset 2170880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2174976 ++read 2048/2048 bytes at offset 2174976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2179072 ++read 2048/2048 bytes at offset 2179072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2183168 ++read 2048/2048 bytes at offset 2183168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2187264 ++read 2048/2048 bytes at offset 2187264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2191360 ++read 2048/2048 bytes at offset 2191360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2195456 ++read 2048/2048 bytes at offset 2195456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2199552 ++read 2048/2048 bytes at offset 2199552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2203648 ++read 2048/2048 bytes at offset 2203648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2207744 ++read 2048/2048 bytes at offset 2207744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2211840 ++read 2048/2048 bytes at offset 2211840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2215936 ++read 2048/2048 bytes at offset 2215936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2220032 ++read 2048/2048 bytes at offset 2220032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2224128 ++read 2048/2048 bytes at offset 2224128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2228224 ++read 2048/2048 bytes at offset 2228224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2232320 ++read 2048/2048 bytes at offset 2232320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2236416 ++read 2048/2048 bytes at offset 2236416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2240512 ++read 2048/2048 bytes at offset 2240512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2244608 ++read 2048/2048 bytes at offset 2244608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2248704 ++read 2048/2048 bytes at offset 2248704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2252800 ++read 2048/2048 bytes at offset 2252800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2256896 ++read 2048/2048 bytes at offset 2256896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2260992 ++read 2048/2048 bytes at offset 2260992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2265088 ++read 2048/2048 bytes at offset 2265088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2269184 ++read 2048/2048 bytes at offset 2269184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2273280 ++read 2048/2048 bytes at offset 2273280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2277376 ++read 2048/2048 bytes at offset 2277376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2281472 ++read 2048/2048 bytes at offset 2281472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2285568 ++read 2048/2048 bytes at offset 2285568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2289664 ++read 2048/2048 bytes at offset 2289664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2293760 ++read 2048/2048 bytes at offset 2293760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2297856 ++read 2048/2048 bytes at offset 2297856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2301952 ++read 2048/2048 bytes at offset 2301952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2306048 ++read 2048/2048 bytes at offset 2306048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2310144 ++read 2048/2048 bytes at offset 2310144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2314240 ++read 2048/2048 bytes at offset 2314240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2318336 ++read 2048/2048 bytes at offset 2318336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2322432 ++read 2048/2048 bytes at offset 2322432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2326528 ++read 2048/2048 bytes at offset 2326528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2330624 ++read 2048/2048 bytes at offset 2330624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2334720 ++read 2048/2048 bytes at offset 2334720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2338816 ++read 2048/2048 bytes at offset 2338816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2342912 ++read 2048/2048 bytes at offset 2342912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2347008 ++read 2048/2048 bytes at offset 2347008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2351104 ++read 2048/2048 bytes at offset 2351104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2355200 ++read 2048/2048 bytes at offset 2355200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2359296 ++read 2048/2048 bytes at offset 2359296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2363392 ++read 2048/2048 bytes at offset 2363392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2367488 ++read 2048/2048 bytes at offset 2367488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2371584 ++read 2048/2048 bytes at offset 2371584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2375680 ++read 2048/2048 bytes at offset 2375680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2379776 ++read 2048/2048 bytes at offset 2379776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2383872 ++read 2048/2048 bytes at offset 2383872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2387968 ++read 2048/2048 bytes at offset 2387968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2392064 ++read 2048/2048 bytes at offset 2392064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2396160 ++read 2048/2048 bytes at offset 2396160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2400256 ++read 2048/2048 bytes at offset 2400256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2404352 ++read 2048/2048 bytes at offset 2404352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2408448 ++read 2048/2048 bytes at offset 2408448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2412544 ++read 2048/2048 bytes at offset 2412544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2416640 ++read 2048/2048 bytes at offset 2416640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2420736 ++read 2048/2048 bytes at offset 2420736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2424832 ++read 2048/2048 bytes at offset 2424832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2428928 ++read 2048/2048 bytes at offset 2428928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2433024 ++read 2048/2048 bytes at offset 2433024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2437120 ++read 2048/2048 bytes at offset 2437120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2441216 ++read 2048/2048 bytes at offset 2441216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2445312 ++read 2048/2048 bytes at offset 2445312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2449408 ++read 2048/2048 bytes at offset 2449408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2453504 ++read 2048/2048 bytes at offset 2453504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2457600 ++read 2048/2048 bytes at offset 2457600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2461696 ++read 2048/2048 bytes at offset 2461696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2465792 ++read 2048/2048 bytes at offset 2465792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2469888 ++read 2048/2048 bytes at offset 2469888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2473984 ++read 2048/2048 bytes at offset 2473984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2478080 ++read 2048/2048 bytes at offset 2478080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2482176 ++read 2048/2048 bytes at offset 2482176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2486272 ++read 2048/2048 bytes at offset 2486272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2490368 ++read 2048/2048 bytes at offset 2490368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2494464 ++read 2048/2048 bytes at offset 2494464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2498560 ++read 2048/2048 bytes at offset 2498560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2502656 ++read 2048/2048 bytes at offset 2502656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2506752 ++read 2048/2048 bytes at offset 2506752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2510848 ++read 2048/2048 bytes at offset 2510848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2514944 ++read 2048/2048 bytes at offset 2514944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2519040 ++read 2048/2048 bytes at offset 2519040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2523136 ++read 2048/2048 bytes at offset 2523136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2527232 ++read 2048/2048 bytes at offset 2527232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2531328 ++read 2048/2048 bytes at offset 2531328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2535424 ++read 2048/2048 bytes at offset 2535424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2539520 ++read 2048/2048 bytes at offset 2539520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2543616 ++read 2048/2048 bytes at offset 2543616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2547712 ++read 2048/2048 bytes at offset 2547712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2551808 ++read 2048/2048 bytes at offset 2551808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2555904 ++read 2048/2048 bytes at offset 2555904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2560000 ++read 2048/2048 bytes at offset 2560000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2564096 ++read 2048/2048 bytes at offset 2564096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2568192 ++read 2048/2048 bytes at offset 2568192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2572288 ++read 2048/2048 bytes at offset 2572288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2576384 ++read 2048/2048 bytes at offset 2576384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2580480 ++read 2048/2048 bytes at offset 2580480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2584576 ++read 2048/2048 bytes at offset 2584576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2588672 ++read 2048/2048 bytes at offset 2588672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2592768 ++read 2048/2048 bytes at offset 2592768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2596864 ++read 2048/2048 bytes at offset 2596864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2600960 ++read 2048/2048 bytes at offset 2600960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2605056 ++read 2048/2048 bytes at offset 2605056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2609152 ++read 2048/2048 bytes at offset 2609152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2613248 ++read 2048/2048 bytes at offset 2613248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2617344 ++read 2048/2048 bytes at offset 2617344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2621440 ++read 2048/2048 bytes at offset 2621440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2625536 ++read 2048/2048 bytes at offset 2625536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2629632 ++read 2048/2048 bytes at offset 2629632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2633728 ++read 2048/2048 bytes at offset 2633728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2637824 ++read 2048/2048 bytes at offset 2637824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2641920 ++read 2048/2048 bytes at offset 2641920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2646016 ++read 2048/2048 bytes at offset 2646016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2650112 ++read 2048/2048 bytes at offset 2650112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2654208 ++read 2048/2048 bytes at offset 2654208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2658304 ++read 2048/2048 bytes at offset 2658304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2662400 ++read 2048/2048 bytes at offset 2662400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2666496 ++read 2048/2048 bytes at offset 2666496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2670592 ++read 2048/2048 bytes at offset 2670592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2674688 ++read 2048/2048 bytes at offset 2674688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2678784 ++read 2048/2048 bytes at offset 2678784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2682880 ++read 2048/2048 bytes at offset 2682880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2686976 ++read 2048/2048 bytes at offset 2686976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2691072 ++read 2048/2048 bytes at offset 2691072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2695168 ++read 2048/2048 bytes at offset 2695168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2699264 ++read 2048/2048 bytes at offset 2699264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2703360 ++read 2048/2048 bytes at offset 2703360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2707456 ++read 2048/2048 bytes at offset 2707456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2711552 ++read 2048/2048 bytes at offset 2711552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2715648 ++read 2048/2048 bytes at offset 2715648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2719744 ++read 2048/2048 bytes at offset 2719744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2723840 ++read 2048/2048 bytes at offset 2723840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2727936 ++read 2048/2048 bytes at offset 2727936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2732032 ++read 2048/2048 bytes at offset 2732032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2736128 ++read 2048/2048 bytes at offset 2736128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2740224 ++read 2048/2048 bytes at offset 2740224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2744320 ++read 2048/2048 bytes at offset 2744320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2748416 ++read 2048/2048 bytes at offset 2748416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2752512 ++read 2048/2048 bytes at offset 2752512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2756608 ++read 2048/2048 bytes at offset 2756608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2760704 ++read 2048/2048 bytes at offset 2760704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2764800 ++read 2048/2048 bytes at offset 2764800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2768896 ++read 2048/2048 bytes at offset 2768896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2772992 ++read 2048/2048 bytes at offset 2772992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2777088 ++read 2048/2048 bytes at offset 2777088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2781184 ++read 2048/2048 bytes at offset 2781184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2785280 ++read 2048/2048 bytes at offset 2785280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2789376 ++read 2048/2048 bytes at offset 2789376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2793472 ++read 2048/2048 bytes at offset 2793472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2797568 ++read 2048/2048 bytes at offset 2797568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2801664 ++read 2048/2048 bytes at offset 2801664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2805760 ++read 2048/2048 bytes at offset 2805760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2809856 ++read 2048/2048 bytes at offset 2809856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2813952 ++read 2048/2048 bytes at offset 2813952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2818048 ++read 2048/2048 bytes at offset 2818048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2822144 ++read 2048/2048 bytes at offset 2822144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2826240 ++read 2048/2048 bytes at offset 2826240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2830336 ++read 2048/2048 bytes at offset 2830336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2834432 ++read 2048/2048 bytes at offset 2834432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2838528 ++read 2048/2048 bytes at offset 2838528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2842624 ++read 2048/2048 bytes at offset 2842624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2846720 ++read 2048/2048 bytes at offset 2846720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2850816 ++read 2048/2048 bytes at offset 2850816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2854912 ++read 2048/2048 bytes at offset 2854912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2859008 ++read 2048/2048 bytes at offset 2859008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2863104 ++read 2048/2048 bytes at offset 2863104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2867200 ++read 2048/2048 bytes at offset 2867200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2871296 ++read 2048/2048 bytes at offset 2871296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2875392 ++read 2048/2048 bytes at offset 2875392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2879488 ++read 2048/2048 bytes at offset 2879488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2883584 ++read 2048/2048 bytes at offset 2883584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2887680 ++read 2048/2048 bytes at offset 2887680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2891776 ++read 2048/2048 bytes at offset 2891776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2895872 ++read 2048/2048 bytes at offset 2895872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2899968 ++read 2048/2048 bytes at offset 2899968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2904064 ++read 2048/2048 bytes at offset 2904064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2908160 ++read 2048/2048 bytes at offset 2908160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2912256 ++read 2048/2048 bytes at offset 2912256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2916352 ++read 2048/2048 bytes at offset 2916352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2920448 ++read 2048/2048 bytes at offset 2920448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2924544 ++read 2048/2048 bytes at offset 2924544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2928640 ++read 2048/2048 bytes at offset 2928640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2932736 ++read 2048/2048 bytes at offset 2932736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2936832 ++read 2048/2048 bytes at offset 2936832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2940928 ++read 2048/2048 bytes at offset 2940928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2945024 ++read 2048/2048 bytes at offset 2945024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2949120 ++read 2048/2048 bytes at offset 2949120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2953216 ++read 2048/2048 bytes at offset 2953216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2957312 ++read 2048/2048 bytes at offset 2957312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2961408 ++read 2048/2048 bytes at offset 2961408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2965504 ++read 2048/2048 bytes at offset 2965504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2969600 ++read 2048/2048 bytes at offset 2969600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2973696 ++read 2048/2048 bytes at offset 2973696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2977792 ++read 2048/2048 bytes at offset 2977792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2981888 ++read 2048/2048 bytes at offset 2981888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2985984 ++read 2048/2048 bytes at offset 2985984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2990080 ++read 2048/2048 bytes at offset 2990080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2994176 ++read 2048/2048 bytes at offset 2994176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2998272 ++read 2048/2048 bytes at offset 2998272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3002368 ++read 2048/2048 bytes at offset 3002368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3006464 ++read 2048/2048 bytes at offset 3006464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3010560 ++read 2048/2048 bytes at offset 3010560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3014656 ++read 2048/2048 bytes at offset 3014656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3018752 ++read 2048/2048 bytes at offset 3018752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3022848 ++read 2048/2048 bytes at offset 3022848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3026944 ++read 2048/2048 bytes at offset 3026944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3031040 ++read 2048/2048 bytes at offset 3031040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3035136 ++read 2048/2048 bytes at offset 3035136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3039232 ++read 2048/2048 bytes at offset 3039232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3043328 ++read 2048/2048 bytes at offset 3043328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3047424 ++read 2048/2048 bytes at offset 3047424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3051520 ++read 2048/2048 bytes at offset 3051520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3055616 ++read 2048/2048 bytes at offset 3055616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3059712 ++read 2048/2048 bytes at offset 3059712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3063808 ++read 2048/2048 bytes at offset 3063808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3067904 ++read 2048/2048 bytes at offset 3067904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3072000 ++read 2048/2048 bytes at offset 3072000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3076096 ++read 2048/2048 bytes at offset 3076096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3080192 ++read 2048/2048 bytes at offset 3080192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3084288 ++read 2048/2048 bytes at offset 3084288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3088384 ++read 2048/2048 bytes at offset 3088384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3092480 ++read 2048/2048 bytes at offset 3092480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3096576 ++read 2048/2048 bytes at offset 3096576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3100672 ++read 2048/2048 bytes at offset 3100672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3104768 ++read 2048/2048 bytes at offset 3104768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3108864 ++read 2048/2048 bytes at offset 3108864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3112960 ++read 2048/2048 bytes at offset 3112960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3117056 ++read 2048/2048 bytes at offset 3117056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3121152 ++read 2048/2048 bytes at offset 3121152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3125248 ++read 2048/2048 bytes at offset 3125248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3129344 ++read 2048/2048 bytes at offset 3129344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3133440 ++read 2048/2048 bytes at offset 3133440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3137536 ++read 2048/2048 bytes at offset 3137536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3141632 ++read 2048/2048 bytes at offset 3141632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 2 +-qemu-io> read 2048/2048 bytes at offset 3146752 ++=== IO: pattern 2 ++read 2048/2048 bytes at offset 3146752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3150848 ++read 2048/2048 bytes at offset 3150848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3154944 ++read 2048/2048 bytes at offset 3154944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3159040 ++read 2048/2048 bytes at offset 3159040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3163136 ++read 2048/2048 bytes at offset 3163136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3167232 ++read 2048/2048 bytes at offset 3167232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3171328 ++read 2048/2048 bytes at offset 3171328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3175424 ++read 2048/2048 bytes at offset 3175424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3179520 ++read 2048/2048 bytes at offset 3179520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3183616 ++read 2048/2048 bytes at offset 3183616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3187712 ++read 2048/2048 bytes at offset 3187712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3191808 ++read 2048/2048 bytes at offset 3191808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3195904 ++read 2048/2048 bytes at offset 3195904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3200000 ++read 2048/2048 bytes at offset 3200000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3204096 ++read 2048/2048 bytes at offset 3204096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3208192 ++read 2048/2048 bytes at offset 3208192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3212288 ++read 2048/2048 bytes at offset 3212288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3216384 ++read 2048/2048 bytes at offset 3216384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3220480 ++read 2048/2048 bytes at offset 3220480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3224576 ++read 2048/2048 bytes at offset 3224576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3228672 ++read 2048/2048 bytes at offset 3228672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3232768 ++read 2048/2048 bytes at offset 3232768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3236864 ++read 2048/2048 bytes at offset 3236864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3240960 ++read 2048/2048 bytes at offset 3240960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3245056 ++read 2048/2048 bytes at offset 3245056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3249152 ++read 2048/2048 bytes at offset 3249152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3253248 ++read 2048/2048 bytes at offset 3253248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3257344 ++read 2048/2048 bytes at offset 3257344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3261440 ++read 2048/2048 bytes at offset 3261440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3265536 ++read 2048/2048 bytes at offset 3265536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3269632 ++read 2048/2048 bytes at offset 3269632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3273728 ++read 2048/2048 bytes at offset 3273728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3277824 ++read 2048/2048 bytes at offset 3277824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3281920 ++read 2048/2048 bytes at offset 3281920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3286016 ++read 2048/2048 bytes at offset 3286016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3290112 ++read 2048/2048 bytes at offset 3290112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3294208 ++read 2048/2048 bytes at offset 3294208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3298304 ++read 2048/2048 bytes at offset 3298304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3302400 ++read 2048/2048 bytes at offset 3302400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3306496 ++read 2048/2048 bytes at offset 3306496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3310592 ++read 2048/2048 bytes at offset 3310592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3314688 ++read 2048/2048 bytes at offset 3314688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3318784 ++read 2048/2048 bytes at offset 3318784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3322880 ++read 2048/2048 bytes at offset 3322880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3326976 ++read 2048/2048 bytes at offset 3326976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3331072 ++read 2048/2048 bytes at offset 3331072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3335168 ++read 2048/2048 bytes at offset 3335168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3339264 ++read 2048/2048 bytes at offset 3339264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3343360 ++read 2048/2048 bytes at offset 3343360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3347456 ++read 2048/2048 bytes at offset 3347456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3351552 ++read 2048/2048 bytes at offset 3351552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3355648 ++read 2048/2048 bytes at offset 3355648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3359744 ++read 2048/2048 bytes at offset 3359744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3363840 ++read 2048/2048 bytes at offset 3363840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3367936 ++read 2048/2048 bytes at offset 3367936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3372032 ++read 2048/2048 bytes at offset 3372032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3376128 ++read 2048/2048 bytes at offset 3376128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3380224 ++read 2048/2048 bytes at offset 3380224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3384320 ++read 2048/2048 bytes at offset 3384320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3388416 ++read 2048/2048 bytes at offset 3388416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3392512 ++read 2048/2048 bytes at offset 3392512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3396608 ++read 2048/2048 bytes at offset 3396608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3400704 ++read 2048/2048 bytes at offset 3400704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3404800 ++read 2048/2048 bytes at offset 3404800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3408896 ++read 2048/2048 bytes at offset 3408896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3412992 ++read 2048/2048 bytes at offset 3412992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3417088 ++read 2048/2048 bytes at offset 3417088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3421184 ++read 2048/2048 bytes at offset 3421184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3425280 ++read 2048/2048 bytes at offset 3425280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3429376 ++read 2048/2048 bytes at offset 3429376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3433472 ++read 2048/2048 bytes at offset 3433472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3437568 ++read 2048/2048 bytes at offset 3437568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3441664 ++read 2048/2048 bytes at offset 3441664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3445760 ++read 2048/2048 bytes at offset 3445760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3449856 ++read 2048/2048 bytes at offset 3449856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3453952 ++read 2048/2048 bytes at offset 3453952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3458048 ++read 2048/2048 bytes at offset 3458048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3462144 ++read 2048/2048 bytes at offset 3462144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3466240 ++read 2048/2048 bytes at offset 3466240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3470336 ++read 2048/2048 bytes at offset 3470336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3474432 ++read 2048/2048 bytes at offset 3474432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3478528 ++read 2048/2048 bytes at offset 3478528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3482624 ++read 2048/2048 bytes at offset 3482624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3486720 ++read 2048/2048 bytes at offset 3486720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3490816 ++read 2048/2048 bytes at offset 3490816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3494912 ++read 2048/2048 bytes at offset 3494912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3499008 ++read 2048/2048 bytes at offset 3499008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3503104 ++read 2048/2048 bytes at offset 3503104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3507200 ++read 2048/2048 bytes at offset 3507200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3511296 ++read 2048/2048 bytes at offset 3511296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3515392 ++read 2048/2048 bytes at offset 3515392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3519488 ++read 2048/2048 bytes at offset 3519488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3523584 ++read 2048/2048 bytes at offset 3523584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3527680 ++read 2048/2048 bytes at offset 3527680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3531776 ++read 2048/2048 bytes at offset 3531776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3535872 ++read 2048/2048 bytes at offset 3535872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3539968 ++read 2048/2048 bytes at offset 3539968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3544064 ++read 2048/2048 bytes at offset 3544064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3548160 ++read 2048/2048 bytes at offset 3548160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3552256 ++read 2048/2048 bytes at offset 3552256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3556352 ++read 2048/2048 bytes at offset 3556352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3560448 ++read 2048/2048 bytes at offset 3560448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3564544 ++read 2048/2048 bytes at offset 3564544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3568640 ++read 2048/2048 bytes at offset 3568640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3572736 ++read 2048/2048 bytes at offset 3572736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3576832 ++read 2048/2048 bytes at offset 3576832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3580928 ++read 2048/2048 bytes at offset 3580928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3585024 ++read 2048/2048 bytes at offset 3585024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3589120 ++read 2048/2048 bytes at offset 3589120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3593216 ++read 2048/2048 bytes at offset 3593216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3597312 ++read 2048/2048 bytes at offset 3597312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3601408 ++read 2048/2048 bytes at offset 3601408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3605504 ++read 2048/2048 bytes at offset 3605504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3609600 ++read 2048/2048 bytes at offset 3609600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3613696 ++read 2048/2048 bytes at offset 3613696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3617792 ++read 2048/2048 bytes at offset 3617792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3621888 ++read 2048/2048 bytes at offset 3621888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3625984 ++read 2048/2048 bytes at offset 3625984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3630080 ++read 2048/2048 bytes at offset 3630080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3634176 ++read 2048/2048 bytes at offset 3634176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3638272 ++read 2048/2048 bytes at offset 3638272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3642368 ++read 2048/2048 bytes at offset 3642368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3646464 ++read 2048/2048 bytes at offset 3646464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3650560 ++read 2048/2048 bytes at offset 3650560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3654656 ++read 2048/2048 bytes at offset 3654656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3658752 ++read 2048/2048 bytes at offset 3658752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3662848 ++read 2048/2048 bytes at offset 3662848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3666944 ++read 2048/2048 bytes at offset 3666944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3671040 ++read 2048/2048 bytes at offset 3671040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3675136 ++read 2048/2048 bytes at offset 3675136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3679232 ++read 2048/2048 bytes at offset 3679232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3683328 ++read 2048/2048 bytes at offset 3683328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3687424 ++read 2048/2048 bytes at offset 3687424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3691520 ++read 2048/2048 bytes at offset 3691520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3695616 ++read 2048/2048 bytes at offset 3695616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3699712 ++read 2048/2048 bytes at offset 3699712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3703808 ++read 2048/2048 bytes at offset 3703808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3707904 ++read 2048/2048 bytes at offset 3707904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3712000 ++read 2048/2048 bytes at offset 3712000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3716096 ++read 2048/2048 bytes at offset 3716096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3720192 ++read 2048/2048 bytes at offset 3720192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3724288 ++read 2048/2048 bytes at offset 3724288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3728384 ++read 2048/2048 bytes at offset 3728384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3732480 ++read 2048/2048 bytes at offset 3732480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3736576 ++read 2048/2048 bytes at offset 3736576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3740672 ++read 2048/2048 bytes at offset 3740672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3744768 ++read 2048/2048 bytes at offset 3744768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3748864 ++read 2048/2048 bytes at offset 3748864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3752960 ++read 2048/2048 bytes at offset 3752960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3757056 ++read 2048/2048 bytes at offset 3757056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3761152 ++read 2048/2048 bytes at offset 3761152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3765248 ++read 2048/2048 bytes at offset 3765248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3769344 ++read 2048/2048 bytes at offset 3769344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3773440 ++read 2048/2048 bytes at offset 3773440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3777536 ++read 2048/2048 bytes at offset 3777536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3781632 ++read 2048/2048 bytes at offset 3781632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3785728 ++read 2048/2048 bytes at offset 3785728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3789824 ++read 2048/2048 bytes at offset 3789824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3793920 ++read 2048/2048 bytes at offset 3793920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3798016 ++read 2048/2048 bytes at offset 3798016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3802112 ++read 2048/2048 bytes at offset 3802112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3806208 ++read 2048/2048 bytes at offset 3806208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3810304 ++read 2048/2048 bytes at offset 3810304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3814400 ++read 2048/2048 bytes at offset 3814400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3818496 ++read 2048/2048 bytes at offset 3818496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3822592 ++read 2048/2048 bytes at offset 3822592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3826688 ++read 2048/2048 bytes at offset 3826688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3830784 ++read 2048/2048 bytes at offset 3830784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3834880 ++read 2048/2048 bytes at offset 3834880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3838976 ++read 2048/2048 bytes at offset 3838976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3843072 ++read 2048/2048 bytes at offset 3843072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3847168 ++read 2048/2048 bytes at offset 3847168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3851264 ++read 2048/2048 bytes at offset 3851264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3855360 ++read 2048/2048 bytes at offset 3855360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3859456 ++read 2048/2048 bytes at offset 3859456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3863552 ++read 2048/2048 bytes at offset 3863552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3867648 ++read 2048/2048 bytes at offset 3867648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3871744 ++read 2048/2048 bytes at offset 3871744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3875840 ++read 2048/2048 bytes at offset 3875840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3879936 ++read 2048/2048 bytes at offset 3879936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3884032 ++read 2048/2048 bytes at offset 3884032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3888128 ++read 2048/2048 bytes at offset 3888128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3892224 ++read 2048/2048 bytes at offset 3892224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3896320 ++read 2048/2048 bytes at offset 3896320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3900416 ++read 2048/2048 bytes at offset 3900416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3904512 ++read 2048/2048 bytes at offset 3904512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3908608 ++read 2048/2048 bytes at offset 3908608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3912704 ++read 2048/2048 bytes at offset 3912704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3916800 ++read 2048/2048 bytes at offset 3916800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3920896 ++read 2048/2048 bytes at offset 3920896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3924992 ++read 2048/2048 bytes at offset 3924992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3929088 ++read 2048/2048 bytes at offset 3929088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3933184 ++read 2048/2048 bytes at offset 3933184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3937280 ++read 2048/2048 bytes at offset 3937280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3941376 ++read 2048/2048 bytes at offset 3941376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3945472 ++read 2048/2048 bytes at offset 3945472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3949568 ++read 2048/2048 bytes at offset 3949568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3953664 ++read 2048/2048 bytes at offset 3953664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3957760 ++read 2048/2048 bytes at offset 3957760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3961856 ++read 2048/2048 bytes at offset 3961856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3965952 ++read 2048/2048 bytes at offset 3965952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3970048 ++read 2048/2048 bytes at offset 3970048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3974144 ++read 2048/2048 bytes at offset 3974144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3978240 ++read 2048/2048 bytes at offset 3978240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3982336 ++read 2048/2048 bytes at offset 3982336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3986432 ++read 2048/2048 bytes at offset 3986432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3990528 ++read 2048/2048 bytes at offset 3990528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3994624 ++read 2048/2048 bytes at offset 3994624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3998720 ++read 2048/2048 bytes at offset 3998720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4002816 ++read 2048/2048 bytes at offset 4002816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4006912 ++read 2048/2048 bytes at offset 4006912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4011008 ++read 2048/2048 bytes at offset 4011008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4015104 ++read 2048/2048 bytes at offset 4015104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4019200 ++read 2048/2048 bytes at offset 4019200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4023296 ++read 2048/2048 bytes at offset 4023296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4027392 ++read 2048/2048 bytes at offset 4027392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4031488 ++read 2048/2048 bytes at offset 4031488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4035584 ++read 2048/2048 bytes at offset 4035584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4039680 ++read 2048/2048 bytes at offset 4039680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4043776 ++read 2048/2048 bytes at offset 4043776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4047872 ++read 2048/2048 bytes at offset 4047872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4051968 ++read 2048/2048 bytes at offset 4051968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4056064 ++read 2048/2048 bytes at offset 4056064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4060160 ++read 2048/2048 bytes at offset 4060160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4064256 ++read 2048/2048 bytes at offset 4064256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4068352 ++read 2048/2048 bytes at offset 4068352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4072448 ++read 2048/2048 bytes at offset 4072448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4076544 ++read 2048/2048 bytes at offset 4076544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4080640 ++read 2048/2048 bytes at offset 4080640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4084736 ++read 2048/2048 bytes at offset 4084736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4088832 ++read 2048/2048 bytes at offset 4088832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4092928 ++read 2048/2048 bytes at offset 4092928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4097024 ++read 2048/2048 bytes at offset 4097024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4101120 ++read 2048/2048 bytes at offset 4101120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4105216 ++read 2048/2048 bytes at offset 4105216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4109312 ++read 2048/2048 bytes at offset 4109312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4113408 ++read 2048/2048 bytes at offset 4113408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4117504 ++read 2048/2048 bytes at offset 4117504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4121600 ++read 2048/2048 bytes at offset 4121600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4125696 ++read 2048/2048 bytes at offset 4125696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4129792 ++read 2048/2048 bytes at offset 4129792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4133888 ++read 2048/2048 bytes at offset 4133888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4137984 ++read 2048/2048 bytes at offset 4137984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4142080 ++read 2048/2048 bytes at offset 4142080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4146176 ++read 2048/2048 bytes at offset 4146176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4150272 ++read 2048/2048 bytes at offset 4150272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4154368 ++read 2048/2048 bytes at offset 4154368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4158464 ++read 2048/2048 bytes at offset 4158464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4162560 ++read 2048/2048 bytes at offset 4162560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4166656 ++read 2048/2048 bytes at offset 4166656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4170752 ++read 2048/2048 bytes at offset 4170752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4174848 ++read 2048/2048 bytes at offset 4174848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4178944 ++read 2048/2048 bytes at offset 4178944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4183040 ++read 2048/2048 bytes at offset 4183040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4187136 ++read 2048/2048 bytes at offset 4187136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4191232 ++read 2048/2048 bytes at offset 4191232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 4 +-qemu-io> read 8192/8192 bytes at offset 4196352 ++=== IO: pattern 4 ++read 8192/8192 bytes at offset 4196352 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4208640 ++read 8192/8192 bytes at offset 4208640 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4220928 ++read 8192/8192 bytes at offset 4220928 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4233216 ++read 8192/8192 bytes at offset 4233216 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4245504 ++read 8192/8192 bytes at offset 4245504 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4257792 ++read 8192/8192 bytes at offset 4257792 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4270080 ++read 8192/8192 bytes at offset 4270080 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4282368 ++read 8192/8192 bytes at offset 4282368 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4294656 ++read 8192/8192 bytes at offset 4294656 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4306944 ++read 8192/8192 bytes at offset 4306944 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4319232 ++read 8192/8192 bytes at offset 4319232 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4331520 ++read 8192/8192 bytes at offset 4331520 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4343808 ++read 8192/8192 bytes at offset 4343808 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4356096 ++read 8192/8192 bytes at offset 4356096 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4368384 ++read 8192/8192 bytes at offset 4368384 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4380672 ++read 8192/8192 bytes at offset 4380672 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4392960 ++read 8192/8192 bytes at offset 4392960 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4405248 ++read 8192/8192 bytes at offset 4405248 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4417536 ++read 8192/8192 bytes at offset 4417536 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4429824 ++read 8192/8192 bytes at offset 4429824 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4442112 ++read 8192/8192 bytes at offset 4442112 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4454400 ++read 8192/8192 bytes at offset 4454400 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4466688 ++read 8192/8192 bytes at offset 4466688 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4478976 ++read 8192/8192 bytes at offset 4478976 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4491264 ++read 8192/8192 bytes at offset 4491264 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4503552 ++read 8192/8192 bytes at offset 4503552 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4515840 ++read 8192/8192 bytes at offset 4515840 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4528128 ++read 8192/8192 bytes at offset 4528128 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4540416 ++read 8192/8192 bytes at offset 4540416 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4552704 ++read 8192/8192 bytes at offset 4552704 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4564992 ++read 8192/8192 bytes at offset 4564992 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4577280 ++read 8192/8192 bytes at offset 4577280 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4589568 ++read 8192/8192 bytes at offset 4589568 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4601856 ++read 8192/8192 bytes at offset 4601856 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4614144 ++read 8192/8192 bytes at offset 4614144 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4626432 ++read 8192/8192 bytes at offset 4626432 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4638720 ++read 8192/8192 bytes at offset 4638720 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4651008 ++read 8192/8192 bytes at offset 4651008 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4663296 ++read 8192/8192 bytes at offset 4663296 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4675584 ++read 8192/8192 bytes at offset 4675584 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4687872 ++read 8192/8192 bytes at offset 4687872 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4700160 ++read 8192/8192 bytes at offset 4700160 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4712448 ++read 8192/8192 bytes at offset 4712448 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4724736 ++read 8192/8192 bytes at offset 4724736 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4737024 ++read 8192/8192 bytes at offset 4737024 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4749312 ++read 8192/8192 bytes at offset 4749312 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4761600 ++read 8192/8192 bytes at offset 4761600 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4773888 ++read 8192/8192 bytes at offset 4773888 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4786176 ++read 8192/8192 bytes at offset 4786176 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4798464 ++read 8192/8192 bytes at offset 4798464 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4810752 ++read 8192/8192 bytes at offset 4810752 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4823040 ++read 8192/8192 bytes at offset 4823040 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4835328 ++read 8192/8192 bytes at offset 4835328 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4847616 ++read 8192/8192 bytes at offset 4847616 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4859904 ++read 8192/8192 bytes at offset 4859904 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4872192 ++read 8192/8192 bytes at offset 4872192 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4884480 ++read 8192/8192 bytes at offset 4884480 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4896768 ++read 8192/8192 bytes at offset 4896768 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4909056 ++read 8192/8192 bytes at offset 4909056 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4921344 ++read 8192/8192 bytes at offset 4921344 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4933632 ++read 8192/8192 bytes at offset 4933632 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4945920 ++read 8192/8192 bytes at offset 4945920 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4958208 ++read 8192/8192 bytes at offset 4958208 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4970496 ++read 8192/8192 bytes at offset 4970496 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 244 +-qemu-io> read 12288/12288 bytes at offset 6285312 ++=== IO: pattern 244 ++read 12288/12288 bytes at offset 6285312 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 8384512 ++read 12288/12288 bytes at offset 8384512 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 10483712 ++read 12288/12288 bytes at offset 10483712 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 12582912 ++read 12288/12288 bytes at offset 12582912 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 14682112 ++read 12288/12288 bytes at offset 14682112 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 16781312 ++read 12288/12288 bytes at offset 16781312 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 18880512 ++read 12288/12288 bytes at offset 18880512 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 20979712 ++read 12288/12288 bytes at offset 20979712 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> read 4096/4096 bytes at offset 0 ++=== IO: pattern 0 ++read 4096/4096 bytes at offset 0 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4096 ++read 4096/4096 bytes at offset 4096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 8192 ++read 4096/4096 bytes at offset 8192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 12288 ++read 4096/4096 bytes at offset 12288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 16384 ++read 4096/4096 bytes at offset 16384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 20480 ++read 4096/4096 bytes at offset 20480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 24576 ++read 4096/4096 bytes at offset 24576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 28672 ++read 4096/4096 bytes at offset 28672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 32768 ++read 4096/4096 bytes at offset 32768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 36864 ++read 4096/4096 bytes at offset 36864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 40960 ++read 4096/4096 bytes at offset 40960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 45056 ++read 4096/4096 bytes at offset 45056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 49152 ++read 4096/4096 bytes at offset 49152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 53248 ++read 4096/4096 bytes at offset 53248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 57344 ++read 4096/4096 bytes at offset 57344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 61440 ++read 4096/4096 bytes at offset 61440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 65536 ++read 4096/4096 bytes at offset 65536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 69632 ++read 4096/4096 bytes at offset 69632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 73728 ++read 4096/4096 bytes at offset 73728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 77824 ++read 4096/4096 bytes at offset 77824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 81920 ++read 4096/4096 bytes at offset 81920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 86016 ++read 4096/4096 bytes at offset 86016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 90112 ++read 4096/4096 bytes at offset 90112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 94208 ++read 4096/4096 bytes at offset 94208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 98304 ++read 4096/4096 bytes at offset 98304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 102400 ++read 4096/4096 bytes at offset 102400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 106496 ++read 4096/4096 bytes at offset 106496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 110592 ++read 4096/4096 bytes at offset 110592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 114688 ++read 4096/4096 bytes at offset 114688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 118784 ++read 4096/4096 bytes at offset 118784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 122880 ++read 4096/4096 bytes at offset 122880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 126976 ++read 4096/4096 bytes at offset 126976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 131072 ++read 4096/4096 bytes at offset 131072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 135168 ++read 4096/4096 bytes at offset 135168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 139264 ++read 4096/4096 bytes at offset 139264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 143360 ++read 4096/4096 bytes at offset 143360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 147456 ++read 4096/4096 bytes at offset 147456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 151552 ++read 4096/4096 bytes at offset 151552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 155648 ++read 4096/4096 bytes at offset 155648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 159744 ++read 4096/4096 bytes at offset 159744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 163840 ++read 4096/4096 bytes at offset 163840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 167936 ++read 4096/4096 bytes at offset 167936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 172032 ++read 4096/4096 bytes at offset 172032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 176128 ++read 4096/4096 bytes at offset 176128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 180224 ++read 4096/4096 bytes at offset 180224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 184320 ++read 4096/4096 bytes at offset 184320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 188416 ++read 4096/4096 bytes at offset 188416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 192512 ++read 4096/4096 bytes at offset 192512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 196608 ++read 4096/4096 bytes at offset 196608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 200704 ++read 4096/4096 bytes at offset 200704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 204800 ++read 4096/4096 bytes at offset 204800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 208896 ++read 4096/4096 bytes at offset 208896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 212992 ++read 4096/4096 bytes at offset 212992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 217088 ++read 4096/4096 bytes at offset 217088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 221184 ++read 4096/4096 bytes at offset 221184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 225280 ++read 4096/4096 bytes at offset 225280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 229376 ++read 4096/4096 bytes at offset 229376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 233472 ++read 4096/4096 bytes at offset 233472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 237568 ++read 4096/4096 bytes at offset 237568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 241664 ++read 4096/4096 bytes at offset 241664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 245760 ++read 4096/4096 bytes at offset 245760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 249856 ++read 4096/4096 bytes at offset 249856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 253952 ++read 4096/4096 bytes at offset 253952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 258048 ++read 4096/4096 bytes at offset 258048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 262144 ++read 4096/4096 bytes at offset 262144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 266240 ++read 4096/4096 bytes at offset 266240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 270336 ++read 4096/4096 bytes at offset 270336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 274432 ++read 4096/4096 bytes at offset 274432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 278528 ++read 4096/4096 bytes at offset 278528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 282624 ++read 4096/4096 bytes at offset 282624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 286720 ++read 4096/4096 bytes at offset 286720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 290816 ++read 4096/4096 bytes at offset 290816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 294912 ++read 4096/4096 bytes at offset 294912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 299008 ++read 4096/4096 bytes at offset 299008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 303104 ++read 4096/4096 bytes at offset 303104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 307200 ++read 4096/4096 bytes at offset 307200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 311296 ++read 4096/4096 bytes at offset 311296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 315392 ++read 4096/4096 bytes at offset 315392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 319488 ++read 4096/4096 bytes at offset 319488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 323584 ++read 4096/4096 bytes at offset 323584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 327680 ++read 4096/4096 bytes at offset 327680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 331776 ++read 4096/4096 bytes at offset 331776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 335872 ++read 4096/4096 bytes at offset 335872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 339968 ++read 4096/4096 bytes at offset 339968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 344064 ++read 4096/4096 bytes at offset 344064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 348160 ++read 4096/4096 bytes at offset 348160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 352256 ++read 4096/4096 bytes at offset 352256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 356352 ++read 4096/4096 bytes at offset 356352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 360448 ++read 4096/4096 bytes at offset 360448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 364544 ++read 4096/4096 bytes at offset 364544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 368640 ++read 4096/4096 bytes at offset 368640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 372736 ++read 4096/4096 bytes at offset 372736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 376832 ++read 4096/4096 bytes at offset 376832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 380928 ++read 4096/4096 bytes at offset 380928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 385024 ++read 4096/4096 bytes at offset 385024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 389120 ++read 4096/4096 bytes at offset 389120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 393216 ++read 4096/4096 bytes at offset 393216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 397312 ++read 4096/4096 bytes at offset 397312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 401408 ++read 4096/4096 bytes at offset 401408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 405504 ++read 4096/4096 bytes at offset 405504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 409600 ++read 4096/4096 bytes at offset 409600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 413696 ++read 4096/4096 bytes at offset 413696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 417792 ++read 4096/4096 bytes at offset 417792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 421888 ++read 4096/4096 bytes at offset 421888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 425984 ++read 4096/4096 bytes at offset 425984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 430080 ++read 4096/4096 bytes at offset 430080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 434176 ++read 4096/4096 bytes at offset 434176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 438272 ++read 4096/4096 bytes at offset 438272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 442368 ++read 4096/4096 bytes at offset 442368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 446464 ++read 4096/4096 bytes at offset 446464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 450560 ++read 4096/4096 bytes at offset 450560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 454656 ++read 4096/4096 bytes at offset 454656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 458752 ++read 4096/4096 bytes at offset 458752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 462848 ++read 4096/4096 bytes at offset 462848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 466944 ++read 4096/4096 bytes at offset 466944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 471040 ++read 4096/4096 bytes at offset 471040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 475136 ++read 4096/4096 bytes at offset 475136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 479232 ++read 4096/4096 bytes at offset 479232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 483328 ++read 4096/4096 bytes at offset 483328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 487424 ++read 4096/4096 bytes at offset 487424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 491520 ++read 4096/4096 bytes at offset 491520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 495616 ++read 4096/4096 bytes at offset 495616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 499712 ++read 4096/4096 bytes at offset 499712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 503808 ++read 4096/4096 bytes at offset 503808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 507904 ++read 4096/4096 bytes at offset 507904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 512000 ++read 4096/4096 bytes at offset 512000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 516096 ++read 4096/4096 bytes at offset 516096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 520192 ++read 4096/4096 bytes at offset 520192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 524288 ++read 4096/4096 bytes at offset 524288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 528384 ++read 4096/4096 bytes at offset 528384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 532480 ++read 4096/4096 bytes at offset 532480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 536576 ++read 4096/4096 bytes at offset 536576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 540672 ++read 4096/4096 bytes at offset 540672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 544768 ++read 4096/4096 bytes at offset 544768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 548864 ++read 4096/4096 bytes at offset 548864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 552960 ++read 4096/4096 bytes at offset 552960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 557056 ++read 4096/4096 bytes at offset 557056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 561152 ++read 4096/4096 bytes at offset 561152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 565248 ++read 4096/4096 bytes at offset 565248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 569344 ++read 4096/4096 bytes at offset 569344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 573440 ++read 4096/4096 bytes at offset 573440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 577536 ++read 4096/4096 bytes at offset 577536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 581632 ++read 4096/4096 bytes at offset 581632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 585728 ++read 4096/4096 bytes at offset 585728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 589824 ++read 4096/4096 bytes at offset 589824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 593920 ++read 4096/4096 bytes at offset 593920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 598016 ++read 4096/4096 bytes at offset 598016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 602112 ++read 4096/4096 bytes at offset 602112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 606208 ++read 4096/4096 bytes at offset 606208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 610304 ++read 4096/4096 bytes at offset 610304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 614400 ++read 4096/4096 bytes at offset 614400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 618496 ++read 4096/4096 bytes at offset 618496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 622592 ++read 4096/4096 bytes at offset 622592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 626688 ++read 4096/4096 bytes at offset 626688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 630784 ++read 4096/4096 bytes at offset 630784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 634880 ++read 4096/4096 bytes at offset 634880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 638976 ++read 4096/4096 bytes at offset 638976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 643072 ++read 4096/4096 bytes at offset 643072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 647168 ++read 4096/4096 bytes at offset 647168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 651264 ++read 4096/4096 bytes at offset 651264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 655360 ++read 4096/4096 bytes at offset 655360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 659456 ++read 4096/4096 bytes at offset 659456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 663552 ++read 4096/4096 bytes at offset 663552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 667648 ++read 4096/4096 bytes at offset 667648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 671744 ++read 4096/4096 bytes at offset 671744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 675840 ++read 4096/4096 bytes at offset 675840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 679936 ++read 4096/4096 bytes at offset 679936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 684032 ++read 4096/4096 bytes at offset 684032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 688128 ++read 4096/4096 bytes at offset 688128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 692224 ++read 4096/4096 bytes at offset 692224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 696320 ++read 4096/4096 bytes at offset 696320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 700416 ++read 4096/4096 bytes at offset 700416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 704512 ++read 4096/4096 bytes at offset 704512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 708608 ++read 4096/4096 bytes at offset 708608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 712704 ++read 4096/4096 bytes at offset 712704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 716800 ++read 4096/4096 bytes at offset 716800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 720896 ++read 4096/4096 bytes at offset 720896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 724992 ++read 4096/4096 bytes at offset 724992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 729088 ++read 4096/4096 bytes at offset 729088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 733184 ++read 4096/4096 bytes at offset 733184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 737280 ++read 4096/4096 bytes at offset 737280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 741376 ++read 4096/4096 bytes at offset 741376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 745472 ++read 4096/4096 bytes at offset 745472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 749568 ++read 4096/4096 bytes at offset 749568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 753664 ++read 4096/4096 bytes at offset 753664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 757760 ++read 4096/4096 bytes at offset 757760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 761856 ++read 4096/4096 bytes at offset 761856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 765952 ++read 4096/4096 bytes at offset 765952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 770048 ++read 4096/4096 bytes at offset 770048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 774144 ++read 4096/4096 bytes at offset 774144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 778240 ++read 4096/4096 bytes at offset 778240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 782336 ++read 4096/4096 bytes at offset 782336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 786432 ++read 4096/4096 bytes at offset 786432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 790528 ++read 4096/4096 bytes at offset 790528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 794624 ++read 4096/4096 bytes at offset 794624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 798720 ++read 4096/4096 bytes at offset 798720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 802816 ++read 4096/4096 bytes at offset 802816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 806912 ++read 4096/4096 bytes at offset 806912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 811008 ++read 4096/4096 bytes at offset 811008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 815104 ++read 4096/4096 bytes at offset 815104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 819200 ++read 4096/4096 bytes at offset 819200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 823296 ++read 4096/4096 bytes at offset 823296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 827392 ++read 4096/4096 bytes at offset 827392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 831488 ++read 4096/4096 bytes at offset 831488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 835584 ++read 4096/4096 bytes at offset 835584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 839680 ++read 4096/4096 bytes at offset 839680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 843776 ++read 4096/4096 bytes at offset 843776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 847872 ++read 4096/4096 bytes at offset 847872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 851968 ++read 4096/4096 bytes at offset 851968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 856064 ++read 4096/4096 bytes at offset 856064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 860160 ++read 4096/4096 bytes at offset 860160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 864256 ++read 4096/4096 bytes at offset 864256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 868352 ++read 4096/4096 bytes at offset 868352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 872448 ++read 4096/4096 bytes at offset 872448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 876544 ++read 4096/4096 bytes at offset 876544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 880640 ++read 4096/4096 bytes at offset 880640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 884736 ++read 4096/4096 bytes at offset 884736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 888832 ++read 4096/4096 bytes at offset 888832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 892928 ++read 4096/4096 bytes at offset 892928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 897024 ++read 4096/4096 bytes at offset 897024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 901120 ++read 4096/4096 bytes at offset 901120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 905216 ++read 4096/4096 bytes at offset 905216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 909312 ++read 4096/4096 bytes at offset 909312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 913408 ++read 4096/4096 bytes at offset 913408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 917504 ++read 4096/4096 bytes at offset 917504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 921600 ++read 4096/4096 bytes at offset 921600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 925696 ++read 4096/4096 bytes at offset 925696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 929792 ++read 4096/4096 bytes at offset 929792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 933888 ++read 4096/4096 bytes at offset 933888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 937984 ++read 4096/4096 bytes at offset 937984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 942080 ++read 4096/4096 bytes at offset 942080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 946176 ++read 4096/4096 bytes at offset 946176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 950272 ++read 4096/4096 bytes at offset 950272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 954368 ++read 4096/4096 bytes at offset 954368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 958464 ++read 4096/4096 bytes at offset 958464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 962560 ++read 4096/4096 bytes at offset 962560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 966656 ++read 4096/4096 bytes at offset 966656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 970752 ++read 4096/4096 bytes at offset 970752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 974848 ++read 4096/4096 bytes at offset 974848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 978944 ++read 4096/4096 bytes at offset 978944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 983040 ++read 4096/4096 bytes at offset 983040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 987136 ++read 4096/4096 bytes at offset 987136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 991232 ++read 4096/4096 bytes at offset 991232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 995328 ++read 4096/4096 bytes at offset 995328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 999424 ++read 4096/4096 bytes at offset 999424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1003520 ++read 4096/4096 bytes at offset 1003520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1007616 ++read 4096/4096 bytes at offset 1007616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1011712 ++read 4096/4096 bytes at offset 1011712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1015808 ++read 4096/4096 bytes at offset 1015808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1019904 ++read 4096/4096 bytes at offset 1019904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1024000 ++read 4096/4096 bytes at offset 1024000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1028096 ++read 4096/4096 bytes at offset 1028096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1032192 ++read 4096/4096 bytes at offset 1032192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1036288 ++read 4096/4096 bytes at offset 1036288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1040384 ++read 4096/4096 bytes at offset 1040384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1044480 ++read 4096/4096 bytes at offset 1044480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 4 +-qemu-io> read 2048/2048 bytes at offset 1050624 ++=== IO: pattern 4 ++read 2048/2048 bytes at offset 1050624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1054720 ++read 2048/2048 bytes at offset 1054720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1058816 ++read 2048/2048 bytes at offset 1058816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1062912 ++read 2048/2048 bytes at offset 1062912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1067008 ++read 2048/2048 bytes at offset 1067008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1071104 ++read 2048/2048 bytes at offset 1071104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1075200 ++read 2048/2048 bytes at offset 1075200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1079296 ++read 2048/2048 bytes at offset 1079296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1083392 ++read 2048/2048 bytes at offset 1083392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1087488 ++read 2048/2048 bytes at offset 1087488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1091584 ++read 2048/2048 bytes at offset 1091584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1095680 ++read 2048/2048 bytes at offset 1095680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1099776 ++read 2048/2048 bytes at offset 1099776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1103872 ++read 2048/2048 bytes at offset 1103872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1107968 ++read 2048/2048 bytes at offset 1107968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1112064 ++read 2048/2048 bytes at offset 1112064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1116160 ++read 2048/2048 bytes at offset 1116160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1120256 ++read 2048/2048 bytes at offset 1120256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1124352 ++read 2048/2048 bytes at offset 1124352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1128448 ++read 2048/2048 bytes at offset 1128448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1132544 ++read 2048/2048 bytes at offset 1132544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1136640 ++read 2048/2048 bytes at offset 1136640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1140736 ++read 2048/2048 bytes at offset 1140736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1144832 ++read 2048/2048 bytes at offset 1144832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1148928 ++read 2048/2048 bytes at offset 1148928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1153024 ++read 2048/2048 bytes at offset 1153024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1157120 ++read 2048/2048 bytes at offset 1157120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1161216 ++read 2048/2048 bytes at offset 1161216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1165312 ++read 2048/2048 bytes at offset 1165312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1169408 ++read 2048/2048 bytes at offset 1169408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1173504 ++read 2048/2048 bytes at offset 1173504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1177600 ++read 2048/2048 bytes at offset 1177600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1181696 ++read 2048/2048 bytes at offset 1181696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1185792 ++read 2048/2048 bytes at offset 1185792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1189888 ++read 2048/2048 bytes at offset 1189888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1193984 ++read 2048/2048 bytes at offset 1193984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1198080 ++read 2048/2048 bytes at offset 1198080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1202176 ++read 2048/2048 bytes at offset 1202176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1206272 ++read 2048/2048 bytes at offset 1206272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1210368 ++read 2048/2048 bytes at offset 1210368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1214464 ++read 2048/2048 bytes at offset 1214464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1218560 ++read 2048/2048 bytes at offset 1218560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1222656 ++read 2048/2048 bytes at offset 1222656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1226752 ++read 2048/2048 bytes at offset 1226752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1230848 ++read 2048/2048 bytes at offset 1230848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1234944 ++read 2048/2048 bytes at offset 1234944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1239040 ++read 2048/2048 bytes at offset 1239040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1243136 ++read 2048/2048 bytes at offset 1243136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1247232 ++read 2048/2048 bytes at offset 1247232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1251328 ++read 2048/2048 bytes at offset 1251328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1255424 ++read 2048/2048 bytes at offset 1255424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1259520 ++read 2048/2048 bytes at offset 1259520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1263616 ++read 2048/2048 bytes at offset 1263616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1267712 ++read 2048/2048 bytes at offset 1267712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1271808 ++read 2048/2048 bytes at offset 1271808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1275904 ++read 2048/2048 bytes at offset 1275904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1280000 ++read 2048/2048 bytes at offset 1280000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1284096 ++read 2048/2048 bytes at offset 1284096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1288192 ++read 2048/2048 bytes at offset 1288192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1292288 ++read 2048/2048 bytes at offset 1292288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1296384 ++read 2048/2048 bytes at offset 1296384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1300480 ++read 2048/2048 bytes at offset 1300480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1304576 ++read 2048/2048 bytes at offset 1304576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1308672 ++read 2048/2048 bytes at offset 1308672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1312768 ++read 2048/2048 bytes at offset 1312768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1316864 ++read 2048/2048 bytes at offset 1316864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1320960 ++read 2048/2048 bytes at offset 1320960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1325056 ++read 2048/2048 bytes at offset 1325056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1329152 ++read 2048/2048 bytes at offset 1329152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1333248 ++read 2048/2048 bytes at offset 1333248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1337344 ++read 2048/2048 bytes at offset 1337344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1341440 ++read 2048/2048 bytes at offset 1341440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1345536 ++read 2048/2048 bytes at offset 1345536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1349632 ++read 2048/2048 bytes at offset 1349632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1353728 ++read 2048/2048 bytes at offset 1353728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1357824 ++read 2048/2048 bytes at offset 1357824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1361920 ++read 2048/2048 bytes at offset 1361920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1366016 ++read 2048/2048 bytes at offset 1366016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1370112 ++read 2048/2048 bytes at offset 1370112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1374208 ++read 2048/2048 bytes at offset 1374208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1378304 ++read 2048/2048 bytes at offset 1378304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1382400 ++read 2048/2048 bytes at offset 1382400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1386496 ++read 2048/2048 bytes at offset 1386496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1390592 ++read 2048/2048 bytes at offset 1390592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1394688 ++read 2048/2048 bytes at offset 1394688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1398784 ++read 2048/2048 bytes at offset 1398784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1402880 ++read 2048/2048 bytes at offset 1402880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1406976 ++read 2048/2048 bytes at offset 1406976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1411072 ++read 2048/2048 bytes at offset 1411072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1415168 ++read 2048/2048 bytes at offset 1415168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1419264 ++read 2048/2048 bytes at offset 1419264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1423360 ++read 2048/2048 bytes at offset 1423360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1427456 ++read 2048/2048 bytes at offset 1427456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1431552 ++read 2048/2048 bytes at offset 1431552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1435648 ++read 2048/2048 bytes at offset 1435648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1439744 ++read 2048/2048 bytes at offset 1439744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1443840 ++read 2048/2048 bytes at offset 1443840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1447936 ++read 2048/2048 bytes at offset 1447936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1452032 ++read 2048/2048 bytes at offset 1452032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1456128 ++read 2048/2048 bytes at offset 1456128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1460224 ++read 2048/2048 bytes at offset 1460224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1464320 ++read 2048/2048 bytes at offset 1464320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1468416 ++read 2048/2048 bytes at offset 1468416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1472512 ++read 2048/2048 bytes at offset 1472512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1476608 ++read 2048/2048 bytes at offset 1476608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1480704 ++read 2048/2048 bytes at offset 1480704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1484800 ++read 2048/2048 bytes at offset 1484800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1488896 ++read 2048/2048 bytes at offset 1488896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1492992 ++read 2048/2048 bytes at offset 1492992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1497088 ++read 2048/2048 bytes at offset 1497088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1501184 ++read 2048/2048 bytes at offset 1501184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1505280 ++read 2048/2048 bytes at offset 1505280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1509376 ++read 2048/2048 bytes at offset 1509376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1513472 ++read 2048/2048 bytes at offset 1513472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1517568 ++read 2048/2048 bytes at offset 1517568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1521664 ++read 2048/2048 bytes at offset 1521664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1525760 ++read 2048/2048 bytes at offset 1525760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1529856 ++read 2048/2048 bytes at offset 1529856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1533952 ++read 2048/2048 bytes at offset 1533952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1538048 ++read 2048/2048 bytes at offset 1538048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1542144 ++read 2048/2048 bytes at offset 1542144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1546240 ++read 2048/2048 bytes at offset 1546240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1550336 ++read 2048/2048 bytes at offset 1550336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1554432 ++read 2048/2048 bytes at offset 1554432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1558528 ++read 2048/2048 bytes at offset 1558528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1562624 ++read 2048/2048 bytes at offset 1562624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1566720 ++read 2048/2048 bytes at offset 1566720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1570816 ++read 2048/2048 bytes at offset 1570816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1574912 ++read 2048/2048 bytes at offset 1574912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1579008 ++read 2048/2048 bytes at offset 1579008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1583104 ++read 2048/2048 bytes at offset 1583104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1587200 ++read 2048/2048 bytes at offset 1587200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1591296 ++read 2048/2048 bytes at offset 1591296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1595392 ++read 2048/2048 bytes at offset 1595392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1599488 ++read 2048/2048 bytes at offset 1599488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1603584 ++read 2048/2048 bytes at offset 1603584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1607680 ++read 2048/2048 bytes at offset 1607680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1611776 ++read 2048/2048 bytes at offset 1611776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1615872 ++read 2048/2048 bytes at offset 1615872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1619968 ++read 2048/2048 bytes at offset 1619968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1624064 ++read 2048/2048 bytes at offset 1624064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1628160 ++read 2048/2048 bytes at offset 1628160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1632256 ++read 2048/2048 bytes at offset 1632256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1636352 ++read 2048/2048 bytes at offset 1636352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1640448 ++read 2048/2048 bytes at offset 1640448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1644544 ++read 2048/2048 bytes at offset 1644544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1648640 ++read 2048/2048 bytes at offset 1648640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1652736 ++read 2048/2048 bytes at offset 1652736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1656832 ++read 2048/2048 bytes at offset 1656832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1660928 ++read 2048/2048 bytes at offset 1660928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1665024 ++read 2048/2048 bytes at offset 1665024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1669120 ++read 2048/2048 bytes at offset 1669120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1673216 ++read 2048/2048 bytes at offset 1673216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1677312 ++read 2048/2048 bytes at offset 1677312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1681408 ++read 2048/2048 bytes at offset 1681408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1685504 ++read 2048/2048 bytes at offset 1685504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1689600 ++read 2048/2048 bytes at offset 1689600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1693696 ++read 2048/2048 bytes at offset 1693696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1697792 ++read 2048/2048 bytes at offset 1697792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1701888 ++read 2048/2048 bytes at offset 1701888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1705984 ++read 2048/2048 bytes at offset 1705984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1710080 ++read 2048/2048 bytes at offset 1710080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1714176 ++read 2048/2048 bytes at offset 1714176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1718272 ++read 2048/2048 bytes at offset 1718272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1722368 ++read 2048/2048 bytes at offset 1722368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1726464 ++read 2048/2048 bytes at offset 1726464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1730560 ++read 2048/2048 bytes at offset 1730560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1734656 ++read 2048/2048 bytes at offset 1734656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1738752 ++read 2048/2048 bytes at offset 1738752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1742848 ++read 2048/2048 bytes at offset 1742848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1746944 ++read 2048/2048 bytes at offset 1746944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1751040 ++read 2048/2048 bytes at offset 1751040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1755136 ++read 2048/2048 bytes at offset 1755136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1759232 ++read 2048/2048 bytes at offset 1759232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1763328 ++read 2048/2048 bytes at offset 1763328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1767424 ++read 2048/2048 bytes at offset 1767424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1771520 ++read 2048/2048 bytes at offset 1771520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1775616 ++read 2048/2048 bytes at offset 1775616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1779712 ++read 2048/2048 bytes at offset 1779712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1783808 ++read 2048/2048 bytes at offset 1783808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1787904 ++read 2048/2048 bytes at offset 1787904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1792000 ++read 2048/2048 bytes at offset 1792000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1796096 ++read 2048/2048 bytes at offset 1796096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1800192 ++read 2048/2048 bytes at offset 1800192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1804288 ++read 2048/2048 bytes at offset 1804288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1808384 ++read 2048/2048 bytes at offset 1808384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1812480 ++read 2048/2048 bytes at offset 1812480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1816576 ++read 2048/2048 bytes at offset 1816576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1820672 ++read 2048/2048 bytes at offset 1820672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1824768 ++read 2048/2048 bytes at offset 1824768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1828864 ++read 2048/2048 bytes at offset 1828864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1832960 ++read 2048/2048 bytes at offset 1832960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1837056 ++read 2048/2048 bytes at offset 1837056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1841152 ++read 2048/2048 bytes at offset 1841152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1845248 ++read 2048/2048 bytes at offset 1845248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1849344 ++read 2048/2048 bytes at offset 1849344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1853440 ++read 2048/2048 bytes at offset 1853440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1857536 ++read 2048/2048 bytes at offset 1857536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1861632 ++read 2048/2048 bytes at offset 1861632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1865728 ++read 2048/2048 bytes at offset 1865728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1869824 ++read 2048/2048 bytes at offset 1869824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1873920 ++read 2048/2048 bytes at offset 1873920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1878016 ++read 2048/2048 bytes at offset 1878016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1882112 ++read 2048/2048 bytes at offset 1882112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1886208 ++read 2048/2048 bytes at offset 1886208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1890304 ++read 2048/2048 bytes at offset 1890304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1894400 ++read 2048/2048 bytes at offset 1894400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1898496 ++read 2048/2048 bytes at offset 1898496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1902592 ++read 2048/2048 bytes at offset 1902592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1906688 ++read 2048/2048 bytes at offset 1906688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1910784 ++read 2048/2048 bytes at offset 1910784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1914880 ++read 2048/2048 bytes at offset 1914880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1918976 ++read 2048/2048 bytes at offset 1918976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1923072 ++read 2048/2048 bytes at offset 1923072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1927168 ++read 2048/2048 bytes at offset 1927168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1931264 ++read 2048/2048 bytes at offset 1931264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1935360 ++read 2048/2048 bytes at offset 1935360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1939456 ++read 2048/2048 bytes at offset 1939456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1943552 ++read 2048/2048 bytes at offset 1943552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1947648 ++read 2048/2048 bytes at offset 1947648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1951744 ++read 2048/2048 bytes at offset 1951744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1955840 ++read 2048/2048 bytes at offset 1955840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1959936 ++read 2048/2048 bytes at offset 1959936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1964032 ++read 2048/2048 bytes at offset 1964032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1968128 ++read 2048/2048 bytes at offset 1968128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1972224 ++read 2048/2048 bytes at offset 1972224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1976320 ++read 2048/2048 bytes at offset 1976320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1980416 ++read 2048/2048 bytes at offset 1980416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1984512 ++read 2048/2048 bytes at offset 1984512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1988608 ++read 2048/2048 bytes at offset 1988608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1992704 ++read 2048/2048 bytes at offset 1992704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1996800 ++read 2048/2048 bytes at offset 1996800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2000896 ++read 2048/2048 bytes at offset 2000896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2004992 ++read 2048/2048 bytes at offset 2004992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2009088 ++read 2048/2048 bytes at offset 2009088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2013184 ++read 2048/2048 bytes at offset 2013184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2017280 ++read 2048/2048 bytes at offset 2017280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2021376 ++read 2048/2048 bytes at offset 2021376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2025472 ++read 2048/2048 bytes at offset 2025472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2029568 ++read 2048/2048 bytes at offset 2029568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2033664 ++read 2048/2048 bytes at offset 2033664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2037760 ++read 2048/2048 bytes at offset 2037760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2041856 ++read 2048/2048 bytes at offset 2041856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2045952 ++read 2048/2048 bytes at offset 2045952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2050048 ++read 2048/2048 bytes at offset 2050048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2054144 ++read 2048/2048 bytes at offset 2054144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2058240 ++read 2048/2048 bytes at offset 2058240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2062336 ++read 2048/2048 bytes at offset 2062336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2066432 ++read 2048/2048 bytes at offset 2066432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2070528 ++read 2048/2048 bytes at offset 2070528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2074624 ++read 2048/2048 bytes at offset 2074624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2078720 ++read 2048/2048 bytes at offset 2078720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2082816 ++read 2048/2048 bytes at offset 2082816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2086912 ++read 2048/2048 bytes at offset 2086912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2091008 ++read 2048/2048 bytes at offset 2091008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2095104 ++read 2048/2048 bytes at offset 2095104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> read 2048/2048 bytes at offset 2097152 ++=== IO: pattern 0 ++read 2048/2048 bytes at offset 2097152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2101248 ++read 2048/2048 bytes at offset 2101248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2105344 ++read 2048/2048 bytes at offset 2105344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2109440 ++read 2048/2048 bytes at offset 2109440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2113536 ++read 2048/2048 bytes at offset 2113536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2117632 ++read 2048/2048 bytes at offset 2117632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2121728 ++read 2048/2048 bytes at offset 2121728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2125824 ++read 2048/2048 bytes at offset 2125824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2129920 ++read 2048/2048 bytes at offset 2129920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2134016 ++read 2048/2048 bytes at offset 2134016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2138112 ++read 2048/2048 bytes at offset 2138112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2142208 ++read 2048/2048 bytes at offset 2142208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2146304 ++read 2048/2048 bytes at offset 2146304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2150400 ++read 2048/2048 bytes at offset 2150400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2154496 ++read 2048/2048 bytes at offset 2154496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2158592 ++read 2048/2048 bytes at offset 2158592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2162688 ++read 2048/2048 bytes at offset 2162688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2166784 ++read 2048/2048 bytes at offset 2166784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2170880 ++read 2048/2048 bytes at offset 2170880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2174976 ++read 2048/2048 bytes at offset 2174976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2179072 ++read 2048/2048 bytes at offset 2179072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2183168 ++read 2048/2048 bytes at offset 2183168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2187264 ++read 2048/2048 bytes at offset 2187264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2191360 ++read 2048/2048 bytes at offset 2191360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2195456 ++read 2048/2048 bytes at offset 2195456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2199552 ++read 2048/2048 bytes at offset 2199552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2203648 ++read 2048/2048 bytes at offset 2203648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2207744 ++read 2048/2048 bytes at offset 2207744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2211840 ++read 2048/2048 bytes at offset 2211840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2215936 ++read 2048/2048 bytes at offset 2215936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2220032 ++read 2048/2048 bytes at offset 2220032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2224128 ++read 2048/2048 bytes at offset 2224128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2228224 ++read 2048/2048 bytes at offset 2228224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2232320 ++read 2048/2048 bytes at offset 2232320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2236416 ++read 2048/2048 bytes at offset 2236416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2240512 ++read 2048/2048 bytes at offset 2240512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2244608 ++read 2048/2048 bytes at offset 2244608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2248704 ++read 2048/2048 bytes at offset 2248704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2252800 ++read 2048/2048 bytes at offset 2252800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2256896 ++read 2048/2048 bytes at offset 2256896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2260992 ++read 2048/2048 bytes at offset 2260992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2265088 ++read 2048/2048 bytes at offset 2265088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2269184 ++read 2048/2048 bytes at offset 2269184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2273280 ++read 2048/2048 bytes at offset 2273280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2277376 ++read 2048/2048 bytes at offset 2277376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2281472 ++read 2048/2048 bytes at offset 2281472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2285568 ++read 2048/2048 bytes at offset 2285568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2289664 ++read 2048/2048 bytes at offset 2289664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2293760 ++read 2048/2048 bytes at offset 2293760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2297856 ++read 2048/2048 bytes at offset 2297856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2301952 ++read 2048/2048 bytes at offset 2301952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2306048 ++read 2048/2048 bytes at offset 2306048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2310144 ++read 2048/2048 bytes at offset 2310144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2314240 ++read 2048/2048 bytes at offset 2314240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2318336 ++read 2048/2048 bytes at offset 2318336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2322432 ++read 2048/2048 bytes at offset 2322432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2326528 ++read 2048/2048 bytes at offset 2326528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2330624 ++read 2048/2048 bytes at offset 2330624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2334720 ++read 2048/2048 bytes at offset 2334720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2338816 ++read 2048/2048 bytes at offset 2338816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2342912 ++read 2048/2048 bytes at offset 2342912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2347008 ++read 2048/2048 bytes at offset 2347008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2351104 ++read 2048/2048 bytes at offset 2351104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2355200 ++read 2048/2048 bytes at offset 2355200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2359296 ++read 2048/2048 bytes at offset 2359296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2363392 ++read 2048/2048 bytes at offset 2363392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2367488 ++read 2048/2048 bytes at offset 2367488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2371584 ++read 2048/2048 bytes at offset 2371584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2375680 ++read 2048/2048 bytes at offset 2375680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2379776 ++read 2048/2048 bytes at offset 2379776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2383872 ++read 2048/2048 bytes at offset 2383872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2387968 ++read 2048/2048 bytes at offset 2387968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2392064 ++read 2048/2048 bytes at offset 2392064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2396160 ++read 2048/2048 bytes at offset 2396160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2400256 ++read 2048/2048 bytes at offset 2400256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2404352 ++read 2048/2048 bytes at offset 2404352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2408448 ++read 2048/2048 bytes at offset 2408448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2412544 ++read 2048/2048 bytes at offset 2412544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2416640 ++read 2048/2048 bytes at offset 2416640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2420736 ++read 2048/2048 bytes at offset 2420736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2424832 ++read 2048/2048 bytes at offset 2424832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2428928 ++read 2048/2048 bytes at offset 2428928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2433024 ++read 2048/2048 bytes at offset 2433024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2437120 ++read 2048/2048 bytes at offset 2437120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2441216 ++read 2048/2048 bytes at offset 2441216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2445312 ++read 2048/2048 bytes at offset 2445312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2449408 ++read 2048/2048 bytes at offset 2449408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2453504 ++read 2048/2048 bytes at offset 2453504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2457600 ++read 2048/2048 bytes at offset 2457600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2461696 ++read 2048/2048 bytes at offset 2461696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2465792 ++read 2048/2048 bytes at offset 2465792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2469888 ++read 2048/2048 bytes at offset 2469888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2473984 ++read 2048/2048 bytes at offset 2473984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2478080 ++read 2048/2048 bytes at offset 2478080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2482176 ++read 2048/2048 bytes at offset 2482176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2486272 ++read 2048/2048 bytes at offset 2486272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2490368 ++read 2048/2048 bytes at offset 2490368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2494464 ++read 2048/2048 bytes at offset 2494464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2498560 ++read 2048/2048 bytes at offset 2498560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2502656 ++read 2048/2048 bytes at offset 2502656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2506752 ++read 2048/2048 bytes at offset 2506752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2510848 ++read 2048/2048 bytes at offset 2510848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2514944 ++read 2048/2048 bytes at offset 2514944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2519040 ++read 2048/2048 bytes at offset 2519040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2523136 ++read 2048/2048 bytes at offset 2523136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2527232 ++read 2048/2048 bytes at offset 2527232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2531328 ++read 2048/2048 bytes at offset 2531328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2535424 ++read 2048/2048 bytes at offset 2535424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2539520 ++read 2048/2048 bytes at offset 2539520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2543616 ++read 2048/2048 bytes at offset 2543616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2547712 ++read 2048/2048 bytes at offset 2547712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2551808 ++read 2048/2048 bytes at offset 2551808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2555904 ++read 2048/2048 bytes at offset 2555904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2560000 ++read 2048/2048 bytes at offset 2560000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2564096 ++read 2048/2048 bytes at offset 2564096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2568192 ++read 2048/2048 bytes at offset 2568192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2572288 ++read 2048/2048 bytes at offset 2572288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2576384 ++read 2048/2048 bytes at offset 2576384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2580480 ++read 2048/2048 bytes at offset 2580480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2584576 ++read 2048/2048 bytes at offset 2584576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2588672 ++read 2048/2048 bytes at offset 2588672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2592768 ++read 2048/2048 bytes at offset 2592768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2596864 ++read 2048/2048 bytes at offset 2596864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2600960 ++read 2048/2048 bytes at offset 2600960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2605056 ++read 2048/2048 bytes at offset 2605056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2609152 ++read 2048/2048 bytes at offset 2609152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2613248 ++read 2048/2048 bytes at offset 2613248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2617344 ++read 2048/2048 bytes at offset 2617344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2621440 ++read 2048/2048 bytes at offset 2621440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2625536 ++read 2048/2048 bytes at offset 2625536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2629632 ++read 2048/2048 bytes at offset 2629632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2633728 ++read 2048/2048 bytes at offset 2633728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2637824 ++read 2048/2048 bytes at offset 2637824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2641920 ++read 2048/2048 bytes at offset 2641920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2646016 ++read 2048/2048 bytes at offset 2646016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2650112 ++read 2048/2048 bytes at offset 2650112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2654208 ++read 2048/2048 bytes at offset 2654208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2658304 ++read 2048/2048 bytes at offset 2658304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2662400 ++read 2048/2048 bytes at offset 2662400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2666496 ++read 2048/2048 bytes at offset 2666496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2670592 ++read 2048/2048 bytes at offset 2670592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2674688 ++read 2048/2048 bytes at offset 2674688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2678784 ++read 2048/2048 bytes at offset 2678784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2682880 ++read 2048/2048 bytes at offset 2682880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2686976 ++read 2048/2048 bytes at offset 2686976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2691072 ++read 2048/2048 bytes at offset 2691072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2695168 ++read 2048/2048 bytes at offset 2695168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2699264 ++read 2048/2048 bytes at offset 2699264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2703360 ++read 2048/2048 bytes at offset 2703360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2707456 ++read 2048/2048 bytes at offset 2707456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2711552 ++read 2048/2048 bytes at offset 2711552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2715648 ++read 2048/2048 bytes at offset 2715648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2719744 ++read 2048/2048 bytes at offset 2719744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2723840 ++read 2048/2048 bytes at offset 2723840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2727936 ++read 2048/2048 bytes at offset 2727936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2732032 ++read 2048/2048 bytes at offset 2732032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2736128 ++read 2048/2048 bytes at offset 2736128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2740224 ++read 2048/2048 bytes at offset 2740224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2744320 ++read 2048/2048 bytes at offset 2744320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2748416 ++read 2048/2048 bytes at offset 2748416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2752512 ++read 2048/2048 bytes at offset 2752512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2756608 ++read 2048/2048 bytes at offset 2756608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2760704 ++read 2048/2048 bytes at offset 2760704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2764800 ++read 2048/2048 bytes at offset 2764800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2768896 ++read 2048/2048 bytes at offset 2768896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2772992 ++read 2048/2048 bytes at offset 2772992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2777088 ++read 2048/2048 bytes at offset 2777088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2781184 ++read 2048/2048 bytes at offset 2781184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2785280 ++read 2048/2048 bytes at offset 2785280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2789376 ++read 2048/2048 bytes at offset 2789376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2793472 ++read 2048/2048 bytes at offset 2793472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2797568 ++read 2048/2048 bytes at offset 2797568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2801664 ++read 2048/2048 bytes at offset 2801664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2805760 ++read 2048/2048 bytes at offset 2805760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2809856 ++read 2048/2048 bytes at offset 2809856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2813952 ++read 2048/2048 bytes at offset 2813952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2818048 ++read 2048/2048 bytes at offset 2818048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2822144 ++read 2048/2048 bytes at offset 2822144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2826240 ++read 2048/2048 bytes at offset 2826240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2830336 ++read 2048/2048 bytes at offset 2830336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2834432 ++read 2048/2048 bytes at offset 2834432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2838528 ++read 2048/2048 bytes at offset 2838528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2842624 ++read 2048/2048 bytes at offset 2842624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2846720 ++read 2048/2048 bytes at offset 2846720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2850816 ++read 2048/2048 bytes at offset 2850816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2854912 ++read 2048/2048 bytes at offset 2854912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2859008 ++read 2048/2048 bytes at offset 2859008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2863104 ++read 2048/2048 bytes at offset 2863104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2867200 ++read 2048/2048 bytes at offset 2867200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2871296 ++read 2048/2048 bytes at offset 2871296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2875392 ++read 2048/2048 bytes at offset 2875392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2879488 ++read 2048/2048 bytes at offset 2879488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2883584 ++read 2048/2048 bytes at offset 2883584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2887680 ++read 2048/2048 bytes at offset 2887680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2891776 ++read 2048/2048 bytes at offset 2891776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2895872 ++read 2048/2048 bytes at offset 2895872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2899968 ++read 2048/2048 bytes at offset 2899968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2904064 ++read 2048/2048 bytes at offset 2904064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2908160 ++read 2048/2048 bytes at offset 2908160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2912256 ++read 2048/2048 bytes at offset 2912256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2916352 ++read 2048/2048 bytes at offset 2916352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2920448 ++read 2048/2048 bytes at offset 2920448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2924544 ++read 2048/2048 bytes at offset 2924544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2928640 ++read 2048/2048 bytes at offset 2928640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2932736 ++read 2048/2048 bytes at offset 2932736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2936832 ++read 2048/2048 bytes at offset 2936832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2940928 ++read 2048/2048 bytes at offset 2940928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2945024 ++read 2048/2048 bytes at offset 2945024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2949120 ++read 2048/2048 bytes at offset 2949120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2953216 ++read 2048/2048 bytes at offset 2953216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2957312 ++read 2048/2048 bytes at offset 2957312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2961408 ++read 2048/2048 bytes at offset 2961408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2965504 ++read 2048/2048 bytes at offset 2965504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2969600 ++read 2048/2048 bytes at offset 2969600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2973696 ++read 2048/2048 bytes at offset 2973696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2977792 ++read 2048/2048 bytes at offset 2977792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2981888 ++read 2048/2048 bytes at offset 2981888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2985984 ++read 2048/2048 bytes at offset 2985984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2990080 ++read 2048/2048 bytes at offset 2990080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2994176 ++read 2048/2048 bytes at offset 2994176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2998272 ++read 2048/2048 bytes at offset 2998272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3002368 ++read 2048/2048 bytes at offset 3002368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3006464 ++read 2048/2048 bytes at offset 3006464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3010560 ++read 2048/2048 bytes at offset 3010560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3014656 ++read 2048/2048 bytes at offset 3014656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3018752 ++read 2048/2048 bytes at offset 3018752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3022848 ++read 2048/2048 bytes at offset 3022848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3026944 ++read 2048/2048 bytes at offset 3026944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3031040 ++read 2048/2048 bytes at offset 3031040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3035136 ++read 2048/2048 bytes at offset 3035136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3039232 ++read 2048/2048 bytes at offset 3039232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3043328 ++read 2048/2048 bytes at offset 3043328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3047424 ++read 2048/2048 bytes at offset 3047424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3051520 ++read 2048/2048 bytes at offset 3051520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3055616 ++read 2048/2048 bytes at offset 3055616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3059712 ++read 2048/2048 bytes at offset 3059712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3063808 ++read 2048/2048 bytes at offset 3063808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3067904 ++read 2048/2048 bytes at offset 3067904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3072000 ++read 2048/2048 bytes at offset 3072000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3076096 ++read 2048/2048 bytes at offset 3076096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3080192 ++read 2048/2048 bytes at offset 3080192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3084288 ++read 2048/2048 bytes at offset 3084288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3088384 ++read 2048/2048 bytes at offset 3088384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3092480 ++read 2048/2048 bytes at offset 3092480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3096576 ++read 2048/2048 bytes at offset 3096576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3100672 ++read 2048/2048 bytes at offset 3100672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3104768 ++read 2048/2048 bytes at offset 3104768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3108864 ++read 2048/2048 bytes at offset 3108864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3112960 ++read 2048/2048 bytes at offset 3112960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3117056 ++read 2048/2048 bytes at offset 3117056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3121152 ++read 2048/2048 bytes at offset 3121152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3125248 ++read 2048/2048 bytes at offset 3125248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3129344 ++read 2048/2048 bytes at offset 3129344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3133440 ++read 2048/2048 bytes at offset 3133440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3137536 ++read 2048/2048 bytes at offset 3137536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3141632 ++read 2048/2048 bytes at offset 3141632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 2 +-qemu-io> read 2048/2048 bytes at offset 3146752 ++=== IO: pattern 2 ++read 2048/2048 bytes at offset 3146752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3150848 ++read 2048/2048 bytes at offset 3150848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3154944 ++read 2048/2048 bytes at offset 3154944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3159040 ++read 2048/2048 bytes at offset 3159040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3163136 ++read 2048/2048 bytes at offset 3163136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3167232 ++read 2048/2048 bytes at offset 3167232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3171328 ++read 2048/2048 bytes at offset 3171328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3175424 ++read 2048/2048 bytes at offset 3175424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3179520 ++read 2048/2048 bytes at offset 3179520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3183616 ++read 2048/2048 bytes at offset 3183616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3187712 ++read 2048/2048 bytes at offset 3187712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3191808 ++read 2048/2048 bytes at offset 3191808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3195904 ++read 2048/2048 bytes at offset 3195904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3200000 ++read 2048/2048 bytes at offset 3200000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3204096 ++read 2048/2048 bytes at offset 3204096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3208192 ++read 2048/2048 bytes at offset 3208192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3212288 ++read 2048/2048 bytes at offset 3212288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3216384 ++read 2048/2048 bytes at offset 3216384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3220480 ++read 2048/2048 bytes at offset 3220480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3224576 ++read 2048/2048 bytes at offset 3224576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3228672 ++read 2048/2048 bytes at offset 3228672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3232768 ++read 2048/2048 bytes at offset 3232768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3236864 ++read 2048/2048 bytes at offset 3236864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3240960 ++read 2048/2048 bytes at offset 3240960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3245056 ++read 2048/2048 bytes at offset 3245056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3249152 ++read 2048/2048 bytes at offset 3249152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3253248 ++read 2048/2048 bytes at offset 3253248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3257344 ++read 2048/2048 bytes at offset 3257344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3261440 ++read 2048/2048 bytes at offset 3261440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3265536 ++read 2048/2048 bytes at offset 3265536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3269632 ++read 2048/2048 bytes at offset 3269632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3273728 ++read 2048/2048 bytes at offset 3273728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3277824 ++read 2048/2048 bytes at offset 3277824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3281920 ++read 2048/2048 bytes at offset 3281920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3286016 ++read 2048/2048 bytes at offset 3286016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3290112 ++read 2048/2048 bytes at offset 3290112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3294208 ++read 2048/2048 bytes at offset 3294208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3298304 ++read 2048/2048 bytes at offset 3298304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3302400 ++read 2048/2048 bytes at offset 3302400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3306496 ++read 2048/2048 bytes at offset 3306496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3310592 ++read 2048/2048 bytes at offset 3310592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3314688 ++read 2048/2048 bytes at offset 3314688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3318784 ++read 2048/2048 bytes at offset 3318784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3322880 ++read 2048/2048 bytes at offset 3322880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3326976 ++read 2048/2048 bytes at offset 3326976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3331072 ++read 2048/2048 bytes at offset 3331072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3335168 ++read 2048/2048 bytes at offset 3335168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3339264 ++read 2048/2048 bytes at offset 3339264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3343360 ++read 2048/2048 bytes at offset 3343360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3347456 ++read 2048/2048 bytes at offset 3347456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3351552 ++read 2048/2048 bytes at offset 3351552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3355648 ++read 2048/2048 bytes at offset 3355648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3359744 ++read 2048/2048 bytes at offset 3359744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3363840 ++read 2048/2048 bytes at offset 3363840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3367936 ++read 2048/2048 bytes at offset 3367936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3372032 ++read 2048/2048 bytes at offset 3372032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3376128 ++read 2048/2048 bytes at offset 3376128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3380224 ++read 2048/2048 bytes at offset 3380224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3384320 ++read 2048/2048 bytes at offset 3384320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3388416 ++read 2048/2048 bytes at offset 3388416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3392512 ++read 2048/2048 bytes at offset 3392512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3396608 ++read 2048/2048 bytes at offset 3396608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3400704 ++read 2048/2048 bytes at offset 3400704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3404800 ++read 2048/2048 bytes at offset 3404800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3408896 ++read 2048/2048 bytes at offset 3408896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3412992 ++read 2048/2048 bytes at offset 3412992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3417088 ++read 2048/2048 bytes at offset 3417088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3421184 ++read 2048/2048 bytes at offset 3421184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3425280 ++read 2048/2048 bytes at offset 3425280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3429376 ++read 2048/2048 bytes at offset 3429376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3433472 ++read 2048/2048 bytes at offset 3433472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3437568 ++read 2048/2048 bytes at offset 3437568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3441664 ++read 2048/2048 bytes at offset 3441664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3445760 ++read 2048/2048 bytes at offset 3445760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3449856 ++read 2048/2048 bytes at offset 3449856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3453952 ++read 2048/2048 bytes at offset 3453952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3458048 ++read 2048/2048 bytes at offset 3458048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3462144 ++read 2048/2048 bytes at offset 3462144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3466240 ++read 2048/2048 bytes at offset 3466240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3470336 ++read 2048/2048 bytes at offset 3470336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3474432 ++read 2048/2048 bytes at offset 3474432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3478528 ++read 2048/2048 bytes at offset 3478528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3482624 ++read 2048/2048 bytes at offset 3482624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3486720 ++read 2048/2048 bytes at offset 3486720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3490816 ++read 2048/2048 bytes at offset 3490816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3494912 ++read 2048/2048 bytes at offset 3494912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3499008 ++read 2048/2048 bytes at offset 3499008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3503104 ++read 2048/2048 bytes at offset 3503104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3507200 ++read 2048/2048 bytes at offset 3507200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3511296 ++read 2048/2048 bytes at offset 3511296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3515392 ++read 2048/2048 bytes at offset 3515392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3519488 ++read 2048/2048 bytes at offset 3519488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3523584 ++read 2048/2048 bytes at offset 3523584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3527680 ++read 2048/2048 bytes at offset 3527680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3531776 ++read 2048/2048 bytes at offset 3531776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3535872 ++read 2048/2048 bytes at offset 3535872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3539968 ++read 2048/2048 bytes at offset 3539968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3544064 ++read 2048/2048 bytes at offset 3544064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3548160 ++read 2048/2048 bytes at offset 3548160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3552256 ++read 2048/2048 bytes at offset 3552256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3556352 ++read 2048/2048 bytes at offset 3556352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3560448 ++read 2048/2048 bytes at offset 3560448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3564544 ++read 2048/2048 bytes at offset 3564544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3568640 ++read 2048/2048 bytes at offset 3568640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3572736 ++read 2048/2048 bytes at offset 3572736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3576832 ++read 2048/2048 bytes at offset 3576832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3580928 ++read 2048/2048 bytes at offset 3580928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3585024 ++read 2048/2048 bytes at offset 3585024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3589120 ++read 2048/2048 bytes at offset 3589120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3593216 ++read 2048/2048 bytes at offset 3593216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3597312 ++read 2048/2048 bytes at offset 3597312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3601408 ++read 2048/2048 bytes at offset 3601408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3605504 ++read 2048/2048 bytes at offset 3605504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3609600 ++read 2048/2048 bytes at offset 3609600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3613696 ++read 2048/2048 bytes at offset 3613696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3617792 ++read 2048/2048 bytes at offset 3617792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3621888 ++read 2048/2048 bytes at offset 3621888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3625984 ++read 2048/2048 bytes at offset 3625984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3630080 ++read 2048/2048 bytes at offset 3630080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3634176 ++read 2048/2048 bytes at offset 3634176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3638272 ++read 2048/2048 bytes at offset 3638272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3642368 ++read 2048/2048 bytes at offset 3642368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3646464 ++read 2048/2048 bytes at offset 3646464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3650560 ++read 2048/2048 bytes at offset 3650560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3654656 ++read 2048/2048 bytes at offset 3654656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3658752 ++read 2048/2048 bytes at offset 3658752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3662848 ++read 2048/2048 bytes at offset 3662848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3666944 ++read 2048/2048 bytes at offset 3666944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3671040 ++read 2048/2048 bytes at offset 3671040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3675136 ++read 2048/2048 bytes at offset 3675136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3679232 ++read 2048/2048 bytes at offset 3679232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3683328 ++read 2048/2048 bytes at offset 3683328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3687424 ++read 2048/2048 bytes at offset 3687424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3691520 ++read 2048/2048 bytes at offset 3691520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3695616 ++read 2048/2048 bytes at offset 3695616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3699712 ++read 2048/2048 bytes at offset 3699712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3703808 ++read 2048/2048 bytes at offset 3703808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3707904 ++read 2048/2048 bytes at offset 3707904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3712000 ++read 2048/2048 bytes at offset 3712000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3716096 ++read 2048/2048 bytes at offset 3716096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3720192 ++read 2048/2048 bytes at offset 3720192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3724288 ++read 2048/2048 bytes at offset 3724288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3728384 ++read 2048/2048 bytes at offset 3728384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3732480 ++read 2048/2048 bytes at offset 3732480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3736576 ++read 2048/2048 bytes at offset 3736576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3740672 ++read 2048/2048 bytes at offset 3740672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3744768 ++read 2048/2048 bytes at offset 3744768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3748864 ++read 2048/2048 bytes at offset 3748864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3752960 ++read 2048/2048 bytes at offset 3752960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3757056 ++read 2048/2048 bytes at offset 3757056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3761152 ++read 2048/2048 bytes at offset 3761152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3765248 ++read 2048/2048 bytes at offset 3765248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3769344 ++read 2048/2048 bytes at offset 3769344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3773440 ++read 2048/2048 bytes at offset 3773440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3777536 ++read 2048/2048 bytes at offset 3777536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3781632 ++read 2048/2048 bytes at offset 3781632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3785728 ++read 2048/2048 bytes at offset 3785728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3789824 ++read 2048/2048 bytes at offset 3789824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3793920 ++read 2048/2048 bytes at offset 3793920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3798016 ++read 2048/2048 bytes at offset 3798016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3802112 ++read 2048/2048 bytes at offset 3802112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3806208 ++read 2048/2048 bytes at offset 3806208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3810304 ++read 2048/2048 bytes at offset 3810304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3814400 ++read 2048/2048 bytes at offset 3814400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3818496 ++read 2048/2048 bytes at offset 3818496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3822592 ++read 2048/2048 bytes at offset 3822592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3826688 ++read 2048/2048 bytes at offset 3826688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3830784 ++read 2048/2048 bytes at offset 3830784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3834880 ++read 2048/2048 bytes at offset 3834880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3838976 ++read 2048/2048 bytes at offset 3838976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3843072 ++read 2048/2048 bytes at offset 3843072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3847168 ++read 2048/2048 bytes at offset 3847168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3851264 ++read 2048/2048 bytes at offset 3851264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3855360 ++read 2048/2048 bytes at offset 3855360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3859456 ++read 2048/2048 bytes at offset 3859456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3863552 ++read 2048/2048 bytes at offset 3863552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3867648 ++read 2048/2048 bytes at offset 3867648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3871744 ++read 2048/2048 bytes at offset 3871744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3875840 ++read 2048/2048 bytes at offset 3875840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3879936 ++read 2048/2048 bytes at offset 3879936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3884032 ++read 2048/2048 bytes at offset 3884032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3888128 ++read 2048/2048 bytes at offset 3888128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3892224 ++read 2048/2048 bytes at offset 3892224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3896320 ++read 2048/2048 bytes at offset 3896320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3900416 ++read 2048/2048 bytes at offset 3900416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3904512 ++read 2048/2048 bytes at offset 3904512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3908608 ++read 2048/2048 bytes at offset 3908608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3912704 ++read 2048/2048 bytes at offset 3912704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3916800 ++read 2048/2048 bytes at offset 3916800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3920896 ++read 2048/2048 bytes at offset 3920896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3924992 ++read 2048/2048 bytes at offset 3924992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3929088 ++read 2048/2048 bytes at offset 3929088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3933184 ++read 2048/2048 bytes at offset 3933184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3937280 ++read 2048/2048 bytes at offset 3937280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3941376 ++read 2048/2048 bytes at offset 3941376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3945472 ++read 2048/2048 bytes at offset 3945472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3949568 ++read 2048/2048 bytes at offset 3949568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3953664 ++read 2048/2048 bytes at offset 3953664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3957760 ++read 2048/2048 bytes at offset 3957760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3961856 ++read 2048/2048 bytes at offset 3961856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3965952 ++read 2048/2048 bytes at offset 3965952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3970048 ++read 2048/2048 bytes at offset 3970048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3974144 ++read 2048/2048 bytes at offset 3974144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3978240 ++read 2048/2048 bytes at offset 3978240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3982336 ++read 2048/2048 bytes at offset 3982336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3986432 ++read 2048/2048 bytes at offset 3986432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3990528 ++read 2048/2048 bytes at offset 3990528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3994624 ++read 2048/2048 bytes at offset 3994624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3998720 ++read 2048/2048 bytes at offset 3998720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4002816 ++read 2048/2048 bytes at offset 4002816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4006912 ++read 2048/2048 bytes at offset 4006912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4011008 ++read 2048/2048 bytes at offset 4011008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4015104 ++read 2048/2048 bytes at offset 4015104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4019200 ++read 2048/2048 bytes at offset 4019200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4023296 ++read 2048/2048 bytes at offset 4023296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4027392 ++read 2048/2048 bytes at offset 4027392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4031488 ++read 2048/2048 bytes at offset 4031488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4035584 ++read 2048/2048 bytes at offset 4035584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4039680 ++read 2048/2048 bytes at offset 4039680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4043776 ++read 2048/2048 bytes at offset 4043776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4047872 ++read 2048/2048 bytes at offset 4047872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4051968 ++read 2048/2048 bytes at offset 4051968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4056064 ++read 2048/2048 bytes at offset 4056064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4060160 ++read 2048/2048 bytes at offset 4060160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4064256 ++read 2048/2048 bytes at offset 4064256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4068352 ++read 2048/2048 bytes at offset 4068352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4072448 ++read 2048/2048 bytes at offset 4072448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4076544 ++read 2048/2048 bytes at offset 4076544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4080640 ++read 2048/2048 bytes at offset 4080640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4084736 ++read 2048/2048 bytes at offset 4084736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4088832 ++read 2048/2048 bytes at offset 4088832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4092928 ++read 2048/2048 bytes at offset 4092928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4097024 ++read 2048/2048 bytes at offset 4097024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4101120 ++read 2048/2048 bytes at offset 4101120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4105216 ++read 2048/2048 bytes at offset 4105216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4109312 ++read 2048/2048 bytes at offset 4109312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4113408 ++read 2048/2048 bytes at offset 4113408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4117504 ++read 2048/2048 bytes at offset 4117504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4121600 ++read 2048/2048 bytes at offset 4121600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4125696 ++read 2048/2048 bytes at offset 4125696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4129792 ++read 2048/2048 bytes at offset 4129792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4133888 ++read 2048/2048 bytes at offset 4133888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4137984 ++read 2048/2048 bytes at offset 4137984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4142080 ++read 2048/2048 bytes at offset 4142080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4146176 ++read 2048/2048 bytes at offset 4146176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4150272 ++read 2048/2048 bytes at offset 4150272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4154368 ++read 2048/2048 bytes at offset 4154368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4158464 ++read 2048/2048 bytes at offset 4158464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4162560 ++read 2048/2048 bytes at offset 4162560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4166656 ++read 2048/2048 bytes at offset 4166656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4170752 ++read 2048/2048 bytes at offset 4170752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4174848 ++read 2048/2048 bytes at offset 4174848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4178944 ++read 2048/2048 bytes at offset 4178944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4183040 ++read 2048/2048 bytes at offset 4183040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4187136 ++read 2048/2048 bytes at offset 4187136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4191232 ++read 2048/2048 bytes at offset 4191232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 4 +-qemu-io> read 8192/8192 bytes at offset 4196352 ++=== IO: pattern 4 ++read 8192/8192 bytes at offset 4196352 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4208640 ++read 8192/8192 bytes at offset 4208640 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4220928 ++read 8192/8192 bytes at offset 4220928 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4233216 ++read 8192/8192 bytes at offset 4233216 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4245504 ++read 8192/8192 bytes at offset 4245504 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4257792 ++read 8192/8192 bytes at offset 4257792 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4270080 ++read 8192/8192 bytes at offset 4270080 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4282368 ++read 8192/8192 bytes at offset 4282368 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4294656 ++read 8192/8192 bytes at offset 4294656 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4306944 ++read 8192/8192 bytes at offset 4306944 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4319232 ++read 8192/8192 bytes at offset 4319232 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4331520 ++read 8192/8192 bytes at offset 4331520 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4343808 ++read 8192/8192 bytes at offset 4343808 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4356096 ++read 8192/8192 bytes at offset 4356096 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4368384 ++read 8192/8192 bytes at offset 4368384 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4380672 ++read 8192/8192 bytes at offset 4380672 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4392960 ++read 8192/8192 bytes at offset 4392960 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4405248 ++read 8192/8192 bytes at offset 4405248 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4417536 ++read 8192/8192 bytes at offset 4417536 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4429824 ++read 8192/8192 bytes at offset 4429824 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4442112 ++read 8192/8192 bytes at offset 4442112 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4454400 ++read 8192/8192 bytes at offset 4454400 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4466688 ++read 8192/8192 bytes at offset 4466688 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4478976 ++read 8192/8192 bytes at offset 4478976 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4491264 ++read 8192/8192 bytes at offset 4491264 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4503552 ++read 8192/8192 bytes at offset 4503552 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4515840 ++read 8192/8192 bytes at offset 4515840 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4528128 ++read 8192/8192 bytes at offset 4528128 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4540416 ++read 8192/8192 bytes at offset 4540416 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4552704 ++read 8192/8192 bytes at offset 4552704 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4564992 ++read 8192/8192 bytes at offset 4564992 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4577280 ++read 8192/8192 bytes at offset 4577280 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4589568 ++read 8192/8192 bytes at offset 4589568 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4601856 ++read 8192/8192 bytes at offset 4601856 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4614144 ++read 8192/8192 bytes at offset 4614144 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4626432 ++read 8192/8192 bytes at offset 4626432 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4638720 ++read 8192/8192 bytes at offset 4638720 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4651008 ++read 8192/8192 bytes at offset 4651008 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4663296 ++read 8192/8192 bytes at offset 4663296 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4675584 ++read 8192/8192 bytes at offset 4675584 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4687872 ++read 8192/8192 bytes at offset 4687872 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4700160 ++read 8192/8192 bytes at offset 4700160 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4712448 ++read 8192/8192 bytes at offset 4712448 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4724736 ++read 8192/8192 bytes at offset 4724736 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4737024 ++read 8192/8192 bytes at offset 4737024 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4749312 ++read 8192/8192 bytes at offset 4749312 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4761600 ++read 8192/8192 bytes at offset 4761600 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4773888 ++read 8192/8192 bytes at offset 4773888 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4786176 ++read 8192/8192 bytes at offset 4786176 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4798464 ++read 8192/8192 bytes at offset 4798464 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4810752 ++read 8192/8192 bytes at offset 4810752 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4823040 ++read 8192/8192 bytes at offset 4823040 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4835328 ++read 8192/8192 bytes at offset 4835328 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4847616 ++read 8192/8192 bytes at offset 4847616 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4859904 ++read 8192/8192 bytes at offset 4859904 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4872192 ++read 8192/8192 bytes at offset 4872192 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4884480 ++read 8192/8192 bytes at offset 4884480 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4896768 ++read 8192/8192 bytes at offset 4896768 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4909056 ++read 8192/8192 bytes at offset 4909056 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4921344 ++read 8192/8192 bytes at offset 4921344 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4933632 ++read 8192/8192 bytes at offset 4933632 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4945920 ++read 8192/8192 bytes at offset 4945920 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4958208 ++read 8192/8192 bytes at offset 4958208 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4970496 ++read 8192/8192 bytes at offset 4970496 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 244 +-qemu-io> read 12288/12288 bytes at offset 6285312 ++=== IO: pattern 244 ++read 12288/12288 bytes at offset 6285312 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 8384512 ++read 12288/12288 bytes at offset 8384512 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 10483712 ++read 12288/12288 bytes at offset 10483712 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 12582912 ++read 12288/12288 bytes at offset 12582912 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 14682112 ++read 12288/12288 bytes at offset 14682112 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 16781312 ++read 12288/12288 bytes at offset 16781312 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 18880512 ++read 12288/12288 bytes at offset 18880512 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 20979712 ++read 12288/12288 bytes at offset 20979712 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> No errors were found on the image. ++No errors were found on the image. + With offset 4294967296: + === IO: pattern 0 +-qemu-io> read 4096/4096 bytes at offset 4294967296 ++read 4096/4096 bytes at offset 4294967296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294971392 ++read 4096/4096 bytes at offset 4294971392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294975488 ++read 4096/4096 bytes at offset 4294975488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294979584 ++read 4096/4096 bytes at offset 4294979584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294983680 ++read 4096/4096 bytes at offset 4294983680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294987776 ++read 4096/4096 bytes at offset 4294987776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294991872 ++read 4096/4096 bytes at offset 4294991872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294995968 ++read 4096/4096 bytes at offset 4294995968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295000064 ++read 4096/4096 bytes at offset 4295000064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295004160 ++read 4096/4096 bytes at offset 4295004160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295008256 ++read 4096/4096 bytes at offset 4295008256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295012352 ++read 4096/4096 bytes at offset 4295012352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295016448 ++read 4096/4096 bytes at offset 4295016448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295020544 ++read 4096/4096 bytes at offset 4295020544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295024640 ++read 4096/4096 bytes at offset 4295024640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295028736 ++read 4096/4096 bytes at offset 4295028736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295032832 ++read 4096/4096 bytes at offset 4295032832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295036928 ++read 4096/4096 bytes at offset 4295036928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295041024 ++read 4096/4096 bytes at offset 4295041024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295045120 ++read 4096/4096 bytes at offset 4295045120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295049216 ++read 4096/4096 bytes at offset 4295049216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295053312 ++read 4096/4096 bytes at offset 4295053312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295057408 ++read 4096/4096 bytes at offset 4295057408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295061504 ++read 4096/4096 bytes at offset 4295061504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295065600 ++read 4096/4096 bytes at offset 4295065600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295069696 ++read 4096/4096 bytes at offset 4295069696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295073792 ++read 4096/4096 bytes at offset 4295073792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295077888 ++read 4096/4096 bytes at offset 4295077888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295081984 ++read 4096/4096 bytes at offset 4295081984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295086080 ++read 4096/4096 bytes at offset 4295086080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295090176 ++read 4096/4096 bytes at offset 4295090176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295094272 ++read 4096/4096 bytes at offset 4295094272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295098368 ++read 4096/4096 bytes at offset 4295098368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295102464 ++read 4096/4096 bytes at offset 4295102464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295106560 ++read 4096/4096 bytes at offset 4295106560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295110656 ++read 4096/4096 bytes at offset 4295110656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295114752 ++read 4096/4096 bytes at offset 4295114752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295118848 ++read 4096/4096 bytes at offset 4295118848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295122944 ++read 4096/4096 bytes at offset 4295122944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295127040 ++read 4096/4096 bytes at offset 4295127040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295131136 ++read 4096/4096 bytes at offset 4295131136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295135232 ++read 4096/4096 bytes at offset 4295135232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295139328 ++read 4096/4096 bytes at offset 4295139328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295143424 ++read 4096/4096 bytes at offset 4295143424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295147520 ++read 4096/4096 bytes at offset 4295147520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295151616 ++read 4096/4096 bytes at offset 4295151616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295155712 ++read 4096/4096 bytes at offset 4295155712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295159808 ++read 4096/4096 bytes at offset 4295159808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295163904 ++read 4096/4096 bytes at offset 4295163904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295168000 ++read 4096/4096 bytes at offset 4295168000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295172096 ++read 4096/4096 bytes at offset 4295172096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295176192 ++read 4096/4096 bytes at offset 4295176192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295180288 ++read 4096/4096 bytes at offset 4295180288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295184384 ++read 4096/4096 bytes at offset 4295184384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295188480 ++read 4096/4096 bytes at offset 4295188480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295192576 ++read 4096/4096 bytes at offset 4295192576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295196672 ++read 4096/4096 bytes at offset 4295196672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295200768 ++read 4096/4096 bytes at offset 4295200768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295204864 ++read 4096/4096 bytes at offset 4295204864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295208960 ++read 4096/4096 bytes at offset 4295208960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295213056 ++read 4096/4096 bytes at offset 4295213056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295217152 ++read 4096/4096 bytes at offset 4295217152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295221248 ++read 4096/4096 bytes at offset 4295221248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295225344 ++read 4096/4096 bytes at offset 4295225344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295229440 ++read 4096/4096 bytes at offset 4295229440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295233536 ++read 4096/4096 bytes at offset 4295233536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295237632 ++read 4096/4096 bytes at offset 4295237632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295241728 ++read 4096/4096 bytes at offset 4295241728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295245824 ++read 4096/4096 bytes at offset 4295245824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295249920 ++read 4096/4096 bytes at offset 4295249920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295254016 ++read 4096/4096 bytes at offset 4295254016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295258112 ++read 4096/4096 bytes at offset 4295258112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295262208 ++read 4096/4096 bytes at offset 4295262208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295266304 ++read 4096/4096 bytes at offset 4295266304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295270400 ++read 4096/4096 bytes at offset 4295270400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295274496 ++read 4096/4096 bytes at offset 4295274496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295278592 ++read 4096/4096 bytes at offset 4295278592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295282688 ++read 4096/4096 bytes at offset 4295282688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295286784 ++read 4096/4096 bytes at offset 4295286784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295290880 ++read 4096/4096 bytes at offset 4295290880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295294976 ++read 4096/4096 bytes at offset 4295294976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295299072 ++read 4096/4096 bytes at offset 4295299072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295303168 ++read 4096/4096 bytes at offset 4295303168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295307264 ++read 4096/4096 bytes at offset 4295307264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295311360 ++read 4096/4096 bytes at offset 4295311360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295315456 ++read 4096/4096 bytes at offset 4295315456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295319552 ++read 4096/4096 bytes at offset 4295319552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295323648 ++read 4096/4096 bytes at offset 4295323648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295327744 ++read 4096/4096 bytes at offset 4295327744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295331840 ++read 4096/4096 bytes at offset 4295331840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295335936 ++read 4096/4096 bytes at offset 4295335936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295340032 ++read 4096/4096 bytes at offset 4295340032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295344128 ++read 4096/4096 bytes at offset 4295344128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295348224 ++read 4096/4096 bytes at offset 4295348224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295352320 ++read 4096/4096 bytes at offset 4295352320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295356416 ++read 4096/4096 bytes at offset 4295356416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295360512 ++read 4096/4096 bytes at offset 4295360512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295364608 ++read 4096/4096 bytes at offset 4295364608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295368704 ++read 4096/4096 bytes at offset 4295368704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295372800 ++read 4096/4096 bytes at offset 4295372800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295376896 ++read 4096/4096 bytes at offset 4295376896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295380992 ++read 4096/4096 bytes at offset 4295380992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295385088 ++read 4096/4096 bytes at offset 4295385088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295389184 ++read 4096/4096 bytes at offset 4295389184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295393280 ++read 4096/4096 bytes at offset 4295393280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295397376 ++read 4096/4096 bytes at offset 4295397376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295401472 ++read 4096/4096 bytes at offset 4295401472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295405568 ++read 4096/4096 bytes at offset 4295405568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295409664 ++read 4096/4096 bytes at offset 4295409664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295413760 ++read 4096/4096 bytes at offset 4295413760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295417856 ++read 4096/4096 bytes at offset 4295417856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295421952 ++read 4096/4096 bytes at offset 4295421952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295426048 ++read 4096/4096 bytes at offset 4295426048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295430144 ++read 4096/4096 bytes at offset 4295430144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295434240 ++read 4096/4096 bytes at offset 4295434240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295438336 ++read 4096/4096 bytes at offset 4295438336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295442432 ++read 4096/4096 bytes at offset 4295442432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295446528 ++read 4096/4096 bytes at offset 4295446528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295450624 ++read 4096/4096 bytes at offset 4295450624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295454720 ++read 4096/4096 bytes at offset 4295454720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295458816 ++read 4096/4096 bytes at offset 4295458816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295462912 ++read 4096/4096 bytes at offset 4295462912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295467008 ++read 4096/4096 bytes at offset 4295467008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295471104 ++read 4096/4096 bytes at offset 4295471104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295475200 ++read 4096/4096 bytes at offset 4295475200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295479296 ++read 4096/4096 bytes at offset 4295479296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295483392 ++read 4096/4096 bytes at offset 4295483392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295487488 ++read 4096/4096 bytes at offset 4295487488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295491584 ++read 4096/4096 bytes at offset 4295491584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295495680 ++read 4096/4096 bytes at offset 4295495680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295499776 ++read 4096/4096 bytes at offset 4295499776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295503872 ++read 4096/4096 bytes at offset 4295503872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295507968 ++read 4096/4096 bytes at offset 4295507968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295512064 ++read 4096/4096 bytes at offset 4295512064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295516160 ++read 4096/4096 bytes at offset 4295516160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295520256 ++read 4096/4096 bytes at offset 4295520256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295524352 ++read 4096/4096 bytes at offset 4295524352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295528448 ++read 4096/4096 bytes at offset 4295528448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295532544 ++read 4096/4096 bytes at offset 4295532544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295536640 ++read 4096/4096 bytes at offset 4295536640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295540736 ++read 4096/4096 bytes at offset 4295540736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295544832 ++read 4096/4096 bytes at offset 4295544832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295548928 ++read 4096/4096 bytes at offset 4295548928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295553024 ++read 4096/4096 bytes at offset 4295553024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295557120 ++read 4096/4096 bytes at offset 4295557120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295561216 ++read 4096/4096 bytes at offset 4295561216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295565312 ++read 4096/4096 bytes at offset 4295565312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295569408 ++read 4096/4096 bytes at offset 4295569408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295573504 ++read 4096/4096 bytes at offset 4295573504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295577600 ++read 4096/4096 bytes at offset 4295577600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295581696 ++read 4096/4096 bytes at offset 4295581696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295585792 ++read 4096/4096 bytes at offset 4295585792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295589888 ++read 4096/4096 bytes at offset 4295589888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295593984 ++read 4096/4096 bytes at offset 4295593984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295598080 ++read 4096/4096 bytes at offset 4295598080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295602176 ++read 4096/4096 bytes at offset 4295602176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295606272 ++read 4096/4096 bytes at offset 4295606272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295610368 ++read 4096/4096 bytes at offset 4295610368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295614464 ++read 4096/4096 bytes at offset 4295614464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295618560 ++read 4096/4096 bytes at offset 4295618560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295622656 ++read 4096/4096 bytes at offset 4295622656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295626752 ++read 4096/4096 bytes at offset 4295626752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295630848 ++read 4096/4096 bytes at offset 4295630848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295634944 ++read 4096/4096 bytes at offset 4295634944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295639040 ++read 4096/4096 bytes at offset 4295639040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295643136 ++read 4096/4096 bytes at offset 4295643136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295647232 ++read 4096/4096 bytes at offset 4295647232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295651328 ++read 4096/4096 bytes at offset 4295651328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295655424 ++read 4096/4096 bytes at offset 4295655424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295659520 ++read 4096/4096 bytes at offset 4295659520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295663616 ++read 4096/4096 bytes at offset 4295663616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295667712 ++read 4096/4096 bytes at offset 4295667712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295671808 ++read 4096/4096 bytes at offset 4295671808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295675904 ++read 4096/4096 bytes at offset 4295675904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295680000 ++read 4096/4096 bytes at offset 4295680000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295684096 ++read 4096/4096 bytes at offset 4295684096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295688192 ++read 4096/4096 bytes at offset 4295688192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295692288 ++read 4096/4096 bytes at offset 4295692288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295696384 ++read 4096/4096 bytes at offset 4295696384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295700480 ++read 4096/4096 bytes at offset 4295700480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295704576 ++read 4096/4096 bytes at offset 4295704576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295708672 ++read 4096/4096 bytes at offset 4295708672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295712768 ++read 4096/4096 bytes at offset 4295712768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295716864 ++read 4096/4096 bytes at offset 4295716864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295720960 ++read 4096/4096 bytes at offset 4295720960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295725056 ++read 4096/4096 bytes at offset 4295725056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295729152 ++read 4096/4096 bytes at offset 4295729152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295733248 ++read 4096/4096 bytes at offset 4295733248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295737344 ++read 4096/4096 bytes at offset 4295737344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295741440 ++read 4096/4096 bytes at offset 4295741440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295745536 ++read 4096/4096 bytes at offset 4295745536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295749632 ++read 4096/4096 bytes at offset 4295749632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295753728 ++read 4096/4096 bytes at offset 4295753728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295757824 ++read 4096/4096 bytes at offset 4295757824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295761920 ++read 4096/4096 bytes at offset 4295761920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295766016 ++read 4096/4096 bytes at offset 4295766016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295770112 ++read 4096/4096 bytes at offset 4295770112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295774208 ++read 4096/4096 bytes at offset 4295774208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295778304 ++read 4096/4096 bytes at offset 4295778304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295782400 ++read 4096/4096 bytes at offset 4295782400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295786496 ++read 4096/4096 bytes at offset 4295786496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295790592 ++read 4096/4096 bytes at offset 4295790592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295794688 ++read 4096/4096 bytes at offset 4295794688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295798784 ++read 4096/4096 bytes at offset 4295798784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295802880 ++read 4096/4096 bytes at offset 4295802880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295806976 ++read 4096/4096 bytes at offset 4295806976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295811072 ++read 4096/4096 bytes at offset 4295811072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295815168 ++read 4096/4096 bytes at offset 4295815168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295819264 ++read 4096/4096 bytes at offset 4295819264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295823360 ++read 4096/4096 bytes at offset 4295823360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295827456 ++read 4096/4096 bytes at offset 4295827456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295831552 ++read 4096/4096 bytes at offset 4295831552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295835648 ++read 4096/4096 bytes at offset 4295835648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295839744 ++read 4096/4096 bytes at offset 4295839744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295843840 ++read 4096/4096 bytes at offset 4295843840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295847936 ++read 4096/4096 bytes at offset 4295847936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295852032 ++read 4096/4096 bytes at offset 4295852032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295856128 ++read 4096/4096 bytes at offset 4295856128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295860224 ++read 4096/4096 bytes at offset 4295860224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295864320 ++read 4096/4096 bytes at offset 4295864320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295868416 ++read 4096/4096 bytes at offset 4295868416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295872512 ++read 4096/4096 bytes at offset 4295872512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295876608 ++read 4096/4096 bytes at offset 4295876608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295880704 ++read 4096/4096 bytes at offset 4295880704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295884800 ++read 4096/4096 bytes at offset 4295884800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295888896 ++read 4096/4096 bytes at offset 4295888896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295892992 ++read 4096/4096 bytes at offset 4295892992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295897088 ++read 4096/4096 bytes at offset 4295897088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295901184 ++read 4096/4096 bytes at offset 4295901184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295905280 ++read 4096/4096 bytes at offset 4295905280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295909376 ++read 4096/4096 bytes at offset 4295909376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295913472 ++read 4096/4096 bytes at offset 4295913472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295917568 ++read 4096/4096 bytes at offset 4295917568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295921664 ++read 4096/4096 bytes at offset 4295921664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295925760 ++read 4096/4096 bytes at offset 4295925760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295929856 ++read 4096/4096 bytes at offset 4295929856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295933952 ++read 4096/4096 bytes at offset 4295933952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295938048 ++read 4096/4096 bytes at offset 4295938048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295942144 ++read 4096/4096 bytes at offset 4295942144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295946240 ++read 4096/4096 bytes at offset 4295946240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295950336 ++read 4096/4096 bytes at offset 4295950336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295954432 ++read 4096/4096 bytes at offset 4295954432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295958528 ++read 4096/4096 bytes at offset 4295958528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295962624 ++read 4096/4096 bytes at offset 4295962624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295966720 ++read 4096/4096 bytes at offset 4295966720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295970816 ++read 4096/4096 bytes at offset 4295970816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295974912 ++read 4096/4096 bytes at offset 4295974912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295979008 ++read 4096/4096 bytes at offset 4295979008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295983104 ++read 4096/4096 bytes at offset 4295983104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295987200 ++read 4096/4096 bytes at offset 4295987200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295991296 ++read 4096/4096 bytes at offset 4295991296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295995392 ++read 4096/4096 bytes at offset 4295995392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295999488 ++read 4096/4096 bytes at offset 4295999488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4296003584 ++read 4096/4096 bytes at offset 4296003584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4296007680 ++read 4096/4096 bytes at offset 4296007680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4296011776 ++read 4096/4096 bytes at offset 4296011776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 4 +-qemu-io> read 2048/2048 bytes at offset 4296017920 ++=== IO: pattern 4 ++read 2048/2048 bytes at offset 4296017920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296022016 ++read 2048/2048 bytes at offset 4296022016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296026112 ++read 2048/2048 bytes at offset 4296026112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296030208 ++read 2048/2048 bytes at offset 4296030208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296034304 ++read 2048/2048 bytes at offset 4296034304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296038400 ++read 2048/2048 bytes at offset 4296038400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296042496 ++read 2048/2048 bytes at offset 4296042496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296046592 ++read 2048/2048 bytes at offset 4296046592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296050688 ++read 2048/2048 bytes at offset 4296050688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296054784 ++read 2048/2048 bytes at offset 4296054784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296058880 ++read 2048/2048 bytes at offset 4296058880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296062976 ++read 2048/2048 bytes at offset 4296062976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296067072 ++read 2048/2048 bytes at offset 4296067072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296071168 ++read 2048/2048 bytes at offset 4296071168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296075264 ++read 2048/2048 bytes at offset 4296075264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296079360 ++read 2048/2048 bytes at offset 4296079360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296083456 ++read 2048/2048 bytes at offset 4296083456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296087552 ++read 2048/2048 bytes at offset 4296087552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296091648 ++read 2048/2048 bytes at offset 4296091648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296095744 ++read 2048/2048 bytes at offset 4296095744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296099840 ++read 2048/2048 bytes at offset 4296099840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296103936 ++read 2048/2048 bytes at offset 4296103936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296108032 ++read 2048/2048 bytes at offset 4296108032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296112128 ++read 2048/2048 bytes at offset 4296112128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296116224 ++read 2048/2048 bytes at offset 4296116224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296120320 ++read 2048/2048 bytes at offset 4296120320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296124416 ++read 2048/2048 bytes at offset 4296124416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296128512 ++read 2048/2048 bytes at offset 4296128512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296132608 ++read 2048/2048 bytes at offset 4296132608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296136704 ++read 2048/2048 bytes at offset 4296136704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296140800 ++read 2048/2048 bytes at offset 4296140800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296144896 ++read 2048/2048 bytes at offset 4296144896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296148992 ++read 2048/2048 bytes at offset 4296148992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296153088 ++read 2048/2048 bytes at offset 4296153088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296157184 ++read 2048/2048 bytes at offset 4296157184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296161280 ++read 2048/2048 bytes at offset 4296161280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296165376 ++read 2048/2048 bytes at offset 4296165376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296169472 ++read 2048/2048 bytes at offset 4296169472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296173568 ++read 2048/2048 bytes at offset 4296173568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296177664 ++read 2048/2048 bytes at offset 4296177664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296181760 ++read 2048/2048 bytes at offset 4296181760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296185856 ++read 2048/2048 bytes at offset 4296185856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296189952 ++read 2048/2048 bytes at offset 4296189952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296194048 ++read 2048/2048 bytes at offset 4296194048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296198144 ++read 2048/2048 bytes at offset 4296198144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296202240 ++read 2048/2048 bytes at offset 4296202240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296206336 ++read 2048/2048 bytes at offset 4296206336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296210432 ++read 2048/2048 bytes at offset 4296210432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296214528 ++read 2048/2048 bytes at offset 4296214528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296218624 ++read 2048/2048 bytes at offset 4296218624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296222720 ++read 2048/2048 bytes at offset 4296222720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296226816 ++read 2048/2048 bytes at offset 4296226816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296230912 ++read 2048/2048 bytes at offset 4296230912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296235008 ++read 2048/2048 bytes at offset 4296235008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296239104 ++read 2048/2048 bytes at offset 4296239104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296243200 ++read 2048/2048 bytes at offset 4296243200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296247296 ++read 2048/2048 bytes at offset 4296247296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296251392 ++read 2048/2048 bytes at offset 4296251392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296255488 ++read 2048/2048 bytes at offset 4296255488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296259584 ++read 2048/2048 bytes at offset 4296259584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296263680 ++read 2048/2048 bytes at offset 4296263680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296267776 ++read 2048/2048 bytes at offset 4296267776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296271872 ++read 2048/2048 bytes at offset 4296271872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296275968 ++read 2048/2048 bytes at offset 4296275968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296280064 ++read 2048/2048 bytes at offset 4296280064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296284160 ++read 2048/2048 bytes at offset 4296284160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296288256 ++read 2048/2048 bytes at offset 4296288256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296292352 ++read 2048/2048 bytes at offset 4296292352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296296448 ++read 2048/2048 bytes at offset 4296296448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296300544 ++read 2048/2048 bytes at offset 4296300544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296304640 ++read 2048/2048 bytes at offset 4296304640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296308736 ++read 2048/2048 bytes at offset 4296308736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296312832 ++read 2048/2048 bytes at offset 4296312832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296316928 ++read 2048/2048 bytes at offset 4296316928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296321024 ++read 2048/2048 bytes at offset 4296321024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296325120 ++read 2048/2048 bytes at offset 4296325120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296329216 ++read 2048/2048 bytes at offset 4296329216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296333312 ++read 2048/2048 bytes at offset 4296333312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296337408 ++read 2048/2048 bytes at offset 4296337408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296341504 ++read 2048/2048 bytes at offset 4296341504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296345600 ++read 2048/2048 bytes at offset 4296345600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296349696 ++read 2048/2048 bytes at offset 4296349696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296353792 ++read 2048/2048 bytes at offset 4296353792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296357888 ++read 2048/2048 bytes at offset 4296357888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296361984 ++read 2048/2048 bytes at offset 4296361984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296366080 ++read 2048/2048 bytes at offset 4296366080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296370176 ++read 2048/2048 bytes at offset 4296370176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296374272 ++read 2048/2048 bytes at offset 4296374272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296378368 ++read 2048/2048 bytes at offset 4296378368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296382464 ++read 2048/2048 bytes at offset 4296382464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296386560 ++read 2048/2048 bytes at offset 4296386560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296390656 ++read 2048/2048 bytes at offset 4296390656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296394752 ++read 2048/2048 bytes at offset 4296394752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296398848 ++read 2048/2048 bytes at offset 4296398848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296402944 ++read 2048/2048 bytes at offset 4296402944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296407040 ++read 2048/2048 bytes at offset 4296407040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296411136 ++read 2048/2048 bytes at offset 4296411136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296415232 ++read 2048/2048 bytes at offset 4296415232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296419328 ++read 2048/2048 bytes at offset 4296419328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296423424 ++read 2048/2048 bytes at offset 4296423424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296427520 ++read 2048/2048 bytes at offset 4296427520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296431616 ++read 2048/2048 bytes at offset 4296431616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296435712 ++read 2048/2048 bytes at offset 4296435712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296439808 ++read 2048/2048 bytes at offset 4296439808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296443904 ++read 2048/2048 bytes at offset 4296443904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296448000 ++read 2048/2048 bytes at offset 4296448000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296452096 ++read 2048/2048 bytes at offset 4296452096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296456192 ++read 2048/2048 bytes at offset 4296456192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296460288 ++read 2048/2048 bytes at offset 4296460288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296464384 ++read 2048/2048 bytes at offset 4296464384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296468480 ++read 2048/2048 bytes at offset 4296468480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296472576 ++read 2048/2048 bytes at offset 4296472576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296476672 ++read 2048/2048 bytes at offset 4296476672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296480768 ++read 2048/2048 bytes at offset 4296480768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296484864 ++read 2048/2048 bytes at offset 4296484864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296488960 ++read 2048/2048 bytes at offset 4296488960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296493056 ++read 2048/2048 bytes at offset 4296493056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296497152 ++read 2048/2048 bytes at offset 4296497152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296501248 ++read 2048/2048 bytes at offset 4296501248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296505344 ++read 2048/2048 bytes at offset 4296505344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296509440 ++read 2048/2048 bytes at offset 4296509440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296513536 ++read 2048/2048 bytes at offset 4296513536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296517632 ++read 2048/2048 bytes at offset 4296517632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296521728 ++read 2048/2048 bytes at offset 4296521728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296525824 ++read 2048/2048 bytes at offset 4296525824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296529920 ++read 2048/2048 bytes at offset 4296529920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296534016 ++read 2048/2048 bytes at offset 4296534016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296538112 ++read 2048/2048 bytes at offset 4296538112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296542208 ++read 2048/2048 bytes at offset 4296542208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296546304 ++read 2048/2048 bytes at offset 4296546304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296550400 ++read 2048/2048 bytes at offset 4296550400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296554496 ++read 2048/2048 bytes at offset 4296554496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296558592 ++read 2048/2048 bytes at offset 4296558592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296562688 ++read 2048/2048 bytes at offset 4296562688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296566784 ++read 2048/2048 bytes at offset 4296566784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296570880 ++read 2048/2048 bytes at offset 4296570880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296574976 ++read 2048/2048 bytes at offset 4296574976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296579072 ++read 2048/2048 bytes at offset 4296579072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296583168 ++read 2048/2048 bytes at offset 4296583168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296587264 ++read 2048/2048 bytes at offset 4296587264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296591360 ++read 2048/2048 bytes at offset 4296591360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296595456 ++read 2048/2048 bytes at offset 4296595456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296599552 ++read 2048/2048 bytes at offset 4296599552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296603648 ++read 2048/2048 bytes at offset 4296603648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296607744 ++read 2048/2048 bytes at offset 4296607744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296611840 ++read 2048/2048 bytes at offset 4296611840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296615936 ++read 2048/2048 bytes at offset 4296615936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296620032 ++read 2048/2048 bytes at offset 4296620032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296624128 ++read 2048/2048 bytes at offset 4296624128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296628224 ++read 2048/2048 bytes at offset 4296628224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296632320 ++read 2048/2048 bytes at offset 4296632320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296636416 ++read 2048/2048 bytes at offset 4296636416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296640512 ++read 2048/2048 bytes at offset 4296640512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296644608 ++read 2048/2048 bytes at offset 4296644608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296648704 ++read 2048/2048 bytes at offset 4296648704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296652800 ++read 2048/2048 bytes at offset 4296652800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296656896 ++read 2048/2048 bytes at offset 4296656896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296660992 ++read 2048/2048 bytes at offset 4296660992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296665088 ++read 2048/2048 bytes at offset 4296665088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296669184 ++read 2048/2048 bytes at offset 4296669184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296673280 ++read 2048/2048 bytes at offset 4296673280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296677376 ++read 2048/2048 bytes at offset 4296677376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296681472 ++read 2048/2048 bytes at offset 4296681472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296685568 ++read 2048/2048 bytes at offset 4296685568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296689664 ++read 2048/2048 bytes at offset 4296689664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296693760 ++read 2048/2048 bytes at offset 4296693760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296697856 ++read 2048/2048 bytes at offset 4296697856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296701952 ++read 2048/2048 bytes at offset 4296701952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296706048 ++read 2048/2048 bytes at offset 4296706048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296710144 ++read 2048/2048 bytes at offset 4296710144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296714240 ++read 2048/2048 bytes at offset 4296714240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296718336 ++read 2048/2048 bytes at offset 4296718336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296722432 ++read 2048/2048 bytes at offset 4296722432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296726528 ++read 2048/2048 bytes at offset 4296726528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296730624 ++read 2048/2048 bytes at offset 4296730624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296734720 ++read 2048/2048 bytes at offset 4296734720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296738816 ++read 2048/2048 bytes at offset 4296738816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296742912 ++read 2048/2048 bytes at offset 4296742912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296747008 ++read 2048/2048 bytes at offset 4296747008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296751104 ++read 2048/2048 bytes at offset 4296751104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296755200 ++read 2048/2048 bytes at offset 4296755200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296759296 ++read 2048/2048 bytes at offset 4296759296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296763392 ++read 2048/2048 bytes at offset 4296763392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296767488 ++read 2048/2048 bytes at offset 4296767488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296771584 ++read 2048/2048 bytes at offset 4296771584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296775680 ++read 2048/2048 bytes at offset 4296775680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296779776 ++read 2048/2048 bytes at offset 4296779776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296783872 ++read 2048/2048 bytes at offset 4296783872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296787968 ++read 2048/2048 bytes at offset 4296787968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296792064 ++read 2048/2048 bytes at offset 4296792064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296796160 ++read 2048/2048 bytes at offset 4296796160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296800256 ++read 2048/2048 bytes at offset 4296800256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296804352 ++read 2048/2048 bytes at offset 4296804352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296808448 ++read 2048/2048 bytes at offset 4296808448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296812544 ++read 2048/2048 bytes at offset 4296812544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296816640 ++read 2048/2048 bytes at offset 4296816640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296820736 ++read 2048/2048 bytes at offset 4296820736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296824832 ++read 2048/2048 bytes at offset 4296824832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296828928 ++read 2048/2048 bytes at offset 4296828928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296833024 ++read 2048/2048 bytes at offset 4296833024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296837120 ++read 2048/2048 bytes at offset 4296837120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296841216 ++read 2048/2048 bytes at offset 4296841216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296845312 ++read 2048/2048 bytes at offset 4296845312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296849408 ++read 2048/2048 bytes at offset 4296849408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296853504 ++read 2048/2048 bytes at offset 4296853504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296857600 ++read 2048/2048 bytes at offset 4296857600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296861696 ++read 2048/2048 bytes at offset 4296861696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296865792 ++read 2048/2048 bytes at offset 4296865792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296869888 ++read 2048/2048 bytes at offset 4296869888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296873984 ++read 2048/2048 bytes at offset 4296873984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296878080 ++read 2048/2048 bytes at offset 4296878080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296882176 ++read 2048/2048 bytes at offset 4296882176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296886272 ++read 2048/2048 bytes at offset 4296886272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296890368 ++read 2048/2048 bytes at offset 4296890368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296894464 ++read 2048/2048 bytes at offset 4296894464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296898560 ++read 2048/2048 bytes at offset 4296898560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296902656 ++read 2048/2048 bytes at offset 4296902656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296906752 ++read 2048/2048 bytes at offset 4296906752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296910848 ++read 2048/2048 bytes at offset 4296910848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296914944 ++read 2048/2048 bytes at offset 4296914944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296919040 ++read 2048/2048 bytes at offset 4296919040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296923136 ++read 2048/2048 bytes at offset 4296923136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296927232 ++read 2048/2048 bytes at offset 4296927232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296931328 ++read 2048/2048 bytes at offset 4296931328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296935424 ++read 2048/2048 bytes at offset 4296935424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296939520 ++read 2048/2048 bytes at offset 4296939520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296943616 ++read 2048/2048 bytes at offset 4296943616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296947712 ++read 2048/2048 bytes at offset 4296947712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296951808 ++read 2048/2048 bytes at offset 4296951808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296955904 ++read 2048/2048 bytes at offset 4296955904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296960000 ++read 2048/2048 bytes at offset 4296960000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296964096 ++read 2048/2048 bytes at offset 4296964096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296968192 ++read 2048/2048 bytes at offset 4296968192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296972288 ++read 2048/2048 bytes at offset 4296972288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296976384 ++read 2048/2048 bytes at offset 4296976384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296980480 ++read 2048/2048 bytes at offset 4296980480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296984576 ++read 2048/2048 bytes at offset 4296984576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296988672 ++read 2048/2048 bytes at offset 4296988672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296992768 ++read 2048/2048 bytes at offset 4296992768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296996864 ++read 2048/2048 bytes at offset 4296996864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297000960 ++read 2048/2048 bytes at offset 4297000960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297005056 ++read 2048/2048 bytes at offset 4297005056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297009152 ++read 2048/2048 bytes at offset 4297009152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297013248 ++read 2048/2048 bytes at offset 4297013248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297017344 ++read 2048/2048 bytes at offset 4297017344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297021440 ++read 2048/2048 bytes at offset 4297021440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297025536 ++read 2048/2048 bytes at offset 4297025536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297029632 ++read 2048/2048 bytes at offset 4297029632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297033728 ++read 2048/2048 bytes at offset 4297033728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297037824 ++read 2048/2048 bytes at offset 4297037824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297041920 ++read 2048/2048 bytes at offset 4297041920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297046016 ++read 2048/2048 bytes at offset 4297046016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297050112 ++read 2048/2048 bytes at offset 4297050112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297054208 ++read 2048/2048 bytes at offset 4297054208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297058304 ++read 2048/2048 bytes at offset 4297058304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297062400 ++read 2048/2048 bytes at offset 4297062400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> read 2048/2048 bytes at offset 4297064448 ++=== IO: pattern 0 ++read 2048/2048 bytes at offset 4297064448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297068544 ++read 2048/2048 bytes at offset 4297068544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297072640 ++read 2048/2048 bytes at offset 4297072640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297076736 ++read 2048/2048 bytes at offset 4297076736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297080832 ++read 2048/2048 bytes at offset 4297080832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297084928 ++read 2048/2048 bytes at offset 4297084928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297089024 ++read 2048/2048 bytes at offset 4297089024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297093120 ++read 2048/2048 bytes at offset 4297093120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297097216 ++read 2048/2048 bytes at offset 4297097216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297101312 ++read 2048/2048 bytes at offset 4297101312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297105408 ++read 2048/2048 bytes at offset 4297105408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297109504 ++read 2048/2048 bytes at offset 4297109504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297113600 ++read 2048/2048 bytes at offset 4297113600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297117696 ++read 2048/2048 bytes at offset 4297117696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297121792 ++read 2048/2048 bytes at offset 4297121792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297125888 ++read 2048/2048 bytes at offset 4297125888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297129984 ++read 2048/2048 bytes at offset 4297129984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297134080 ++read 2048/2048 bytes at offset 4297134080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297138176 ++read 2048/2048 bytes at offset 4297138176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297142272 ++read 2048/2048 bytes at offset 4297142272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297146368 ++read 2048/2048 bytes at offset 4297146368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297150464 ++read 2048/2048 bytes at offset 4297150464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297154560 ++read 2048/2048 bytes at offset 4297154560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297158656 ++read 2048/2048 bytes at offset 4297158656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297162752 ++read 2048/2048 bytes at offset 4297162752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297166848 ++read 2048/2048 bytes at offset 4297166848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297170944 ++read 2048/2048 bytes at offset 4297170944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297175040 ++read 2048/2048 bytes at offset 4297175040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297179136 ++read 2048/2048 bytes at offset 4297179136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297183232 ++read 2048/2048 bytes at offset 4297183232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297187328 ++read 2048/2048 bytes at offset 4297187328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297191424 ++read 2048/2048 bytes at offset 4297191424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297195520 ++read 2048/2048 bytes at offset 4297195520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297199616 ++read 2048/2048 bytes at offset 4297199616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297203712 ++read 2048/2048 bytes at offset 4297203712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297207808 ++read 2048/2048 bytes at offset 4297207808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297211904 ++read 2048/2048 bytes at offset 4297211904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297216000 ++read 2048/2048 bytes at offset 4297216000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297220096 ++read 2048/2048 bytes at offset 4297220096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297224192 ++read 2048/2048 bytes at offset 4297224192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297228288 ++read 2048/2048 bytes at offset 4297228288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297232384 ++read 2048/2048 bytes at offset 4297232384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297236480 ++read 2048/2048 bytes at offset 4297236480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297240576 ++read 2048/2048 bytes at offset 4297240576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297244672 ++read 2048/2048 bytes at offset 4297244672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297248768 ++read 2048/2048 bytes at offset 4297248768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297252864 ++read 2048/2048 bytes at offset 4297252864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297256960 ++read 2048/2048 bytes at offset 4297256960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297261056 ++read 2048/2048 bytes at offset 4297261056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297265152 ++read 2048/2048 bytes at offset 4297265152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297269248 ++read 2048/2048 bytes at offset 4297269248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297273344 ++read 2048/2048 bytes at offset 4297273344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297277440 ++read 2048/2048 bytes at offset 4297277440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297281536 ++read 2048/2048 bytes at offset 4297281536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297285632 ++read 2048/2048 bytes at offset 4297285632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297289728 ++read 2048/2048 bytes at offset 4297289728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297293824 ++read 2048/2048 bytes at offset 4297293824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297297920 ++read 2048/2048 bytes at offset 4297297920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297302016 ++read 2048/2048 bytes at offset 4297302016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297306112 ++read 2048/2048 bytes at offset 4297306112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297310208 ++read 2048/2048 bytes at offset 4297310208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297314304 ++read 2048/2048 bytes at offset 4297314304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297318400 ++read 2048/2048 bytes at offset 4297318400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297322496 ++read 2048/2048 bytes at offset 4297322496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297326592 ++read 2048/2048 bytes at offset 4297326592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297330688 ++read 2048/2048 bytes at offset 4297330688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297334784 ++read 2048/2048 bytes at offset 4297334784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297338880 ++read 2048/2048 bytes at offset 4297338880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297342976 ++read 2048/2048 bytes at offset 4297342976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297347072 ++read 2048/2048 bytes at offset 4297347072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297351168 ++read 2048/2048 bytes at offset 4297351168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297355264 ++read 2048/2048 bytes at offset 4297355264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297359360 ++read 2048/2048 bytes at offset 4297359360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297363456 ++read 2048/2048 bytes at offset 4297363456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297367552 ++read 2048/2048 bytes at offset 4297367552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297371648 ++read 2048/2048 bytes at offset 4297371648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297375744 ++read 2048/2048 bytes at offset 4297375744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297379840 ++read 2048/2048 bytes at offset 4297379840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297383936 ++read 2048/2048 bytes at offset 4297383936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297388032 ++read 2048/2048 bytes at offset 4297388032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297392128 ++read 2048/2048 bytes at offset 4297392128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297396224 ++read 2048/2048 bytes at offset 4297396224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297400320 ++read 2048/2048 bytes at offset 4297400320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297404416 ++read 2048/2048 bytes at offset 4297404416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297408512 ++read 2048/2048 bytes at offset 4297408512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297412608 ++read 2048/2048 bytes at offset 4297412608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297416704 ++read 2048/2048 bytes at offset 4297416704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297420800 ++read 2048/2048 bytes at offset 4297420800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297424896 ++read 2048/2048 bytes at offset 4297424896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297428992 ++read 2048/2048 bytes at offset 4297428992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297433088 ++read 2048/2048 bytes at offset 4297433088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297437184 ++read 2048/2048 bytes at offset 4297437184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297441280 ++read 2048/2048 bytes at offset 4297441280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297445376 ++read 2048/2048 bytes at offset 4297445376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297449472 ++read 2048/2048 bytes at offset 4297449472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297453568 ++read 2048/2048 bytes at offset 4297453568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297457664 ++read 2048/2048 bytes at offset 4297457664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297461760 ++read 2048/2048 bytes at offset 4297461760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297465856 ++read 2048/2048 bytes at offset 4297465856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297469952 ++read 2048/2048 bytes at offset 4297469952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297474048 ++read 2048/2048 bytes at offset 4297474048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297478144 ++read 2048/2048 bytes at offset 4297478144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297482240 ++read 2048/2048 bytes at offset 4297482240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297486336 ++read 2048/2048 bytes at offset 4297486336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297490432 ++read 2048/2048 bytes at offset 4297490432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297494528 ++read 2048/2048 bytes at offset 4297494528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297498624 ++read 2048/2048 bytes at offset 4297498624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297502720 ++read 2048/2048 bytes at offset 4297502720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297506816 ++read 2048/2048 bytes at offset 4297506816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297510912 ++read 2048/2048 bytes at offset 4297510912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297515008 ++read 2048/2048 bytes at offset 4297515008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297519104 ++read 2048/2048 bytes at offset 4297519104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297523200 ++read 2048/2048 bytes at offset 4297523200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297527296 ++read 2048/2048 bytes at offset 4297527296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297531392 ++read 2048/2048 bytes at offset 4297531392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297535488 ++read 2048/2048 bytes at offset 4297535488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297539584 ++read 2048/2048 bytes at offset 4297539584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297543680 ++read 2048/2048 bytes at offset 4297543680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297547776 ++read 2048/2048 bytes at offset 4297547776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297551872 ++read 2048/2048 bytes at offset 4297551872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297555968 ++read 2048/2048 bytes at offset 4297555968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297560064 ++read 2048/2048 bytes at offset 4297560064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297564160 ++read 2048/2048 bytes at offset 4297564160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297568256 ++read 2048/2048 bytes at offset 4297568256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297572352 ++read 2048/2048 bytes at offset 4297572352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297576448 ++read 2048/2048 bytes at offset 4297576448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297580544 ++read 2048/2048 bytes at offset 4297580544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297584640 ++read 2048/2048 bytes at offset 4297584640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297588736 ++read 2048/2048 bytes at offset 4297588736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297592832 ++read 2048/2048 bytes at offset 4297592832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297596928 ++read 2048/2048 bytes at offset 4297596928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297601024 ++read 2048/2048 bytes at offset 4297601024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297605120 ++read 2048/2048 bytes at offset 4297605120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297609216 ++read 2048/2048 bytes at offset 4297609216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297613312 ++read 2048/2048 bytes at offset 4297613312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297617408 ++read 2048/2048 bytes at offset 4297617408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297621504 ++read 2048/2048 bytes at offset 4297621504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297625600 ++read 2048/2048 bytes at offset 4297625600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297629696 ++read 2048/2048 bytes at offset 4297629696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297633792 ++read 2048/2048 bytes at offset 4297633792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297637888 ++read 2048/2048 bytes at offset 4297637888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297641984 ++read 2048/2048 bytes at offset 4297641984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297646080 ++read 2048/2048 bytes at offset 4297646080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297650176 ++read 2048/2048 bytes at offset 4297650176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297654272 ++read 2048/2048 bytes at offset 4297654272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297658368 ++read 2048/2048 bytes at offset 4297658368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297662464 ++read 2048/2048 bytes at offset 4297662464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297666560 ++read 2048/2048 bytes at offset 4297666560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297670656 ++read 2048/2048 bytes at offset 4297670656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297674752 ++read 2048/2048 bytes at offset 4297674752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297678848 ++read 2048/2048 bytes at offset 4297678848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297682944 ++read 2048/2048 bytes at offset 4297682944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297687040 ++read 2048/2048 bytes at offset 4297687040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297691136 ++read 2048/2048 bytes at offset 4297691136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297695232 ++read 2048/2048 bytes at offset 4297695232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297699328 ++read 2048/2048 bytes at offset 4297699328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297703424 ++read 2048/2048 bytes at offset 4297703424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297707520 ++read 2048/2048 bytes at offset 4297707520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297711616 ++read 2048/2048 bytes at offset 4297711616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297715712 ++read 2048/2048 bytes at offset 4297715712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297719808 ++read 2048/2048 bytes at offset 4297719808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297723904 ++read 2048/2048 bytes at offset 4297723904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297728000 ++read 2048/2048 bytes at offset 4297728000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297732096 ++read 2048/2048 bytes at offset 4297732096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297736192 ++read 2048/2048 bytes at offset 4297736192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297740288 ++read 2048/2048 bytes at offset 4297740288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297744384 ++read 2048/2048 bytes at offset 4297744384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297748480 ++read 2048/2048 bytes at offset 4297748480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297752576 ++read 2048/2048 bytes at offset 4297752576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297756672 ++read 2048/2048 bytes at offset 4297756672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297760768 ++read 2048/2048 bytes at offset 4297760768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297764864 ++read 2048/2048 bytes at offset 4297764864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297768960 ++read 2048/2048 bytes at offset 4297768960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297773056 ++read 2048/2048 bytes at offset 4297773056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297777152 ++read 2048/2048 bytes at offset 4297777152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297781248 ++read 2048/2048 bytes at offset 4297781248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297785344 ++read 2048/2048 bytes at offset 4297785344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297789440 ++read 2048/2048 bytes at offset 4297789440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297793536 ++read 2048/2048 bytes at offset 4297793536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297797632 ++read 2048/2048 bytes at offset 4297797632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297801728 ++read 2048/2048 bytes at offset 4297801728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297805824 ++read 2048/2048 bytes at offset 4297805824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297809920 ++read 2048/2048 bytes at offset 4297809920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297814016 ++read 2048/2048 bytes at offset 4297814016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297818112 ++read 2048/2048 bytes at offset 4297818112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297822208 ++read 2048/2048 bytes at offset 4297822208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297826304 ++read 2048/2048 bytes at offset 4297826304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297830400 ++read 2048/2048 bytes at offset 4297830400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297834496 ++read 2048/2048 bytes at offset 4297834496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297838592 ++read 2048/2048 bytes at offset 4297838592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297842688 ++read 2048/2048 bytes at offset 4297842688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297846784 ++read 2048/2048 bytes at offset 4297846784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297850880 ++read 2048/2048 bytes at offset 4297850880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297854976 ++read 2048/2048 bytes at offset 4297854976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297859072 ++read 2048/2048 bytes at offset 4297859072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297863168 ++read 2048/2048 bytes at offset 4297863168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297867264 ++read 2048/2048 bytes at offset 4297867264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297871360 ++read 2048/2048 bytes at offset 4297871360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297875456 ++read 2048/2048 bytes at offset 4297875456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297879552 ++read 2048/2048 bytes at offset 4297879552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297883648 ++read 2048/2048 bytes at offset 4297883648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297887744 ++read 2048/2048 bytes at offset 4297887744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297891840 ++read 2048/2048 bytes at offset 4297891840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297895936 ++read 2048/2048 bytes at offset 4297895936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297900032 ++read 2048/2048 bytes at offset 4297900032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297904128 ++read 2048/2048 bytes at offset 4297904128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297908224 ++read 2048/2048 bytes at offset 4297908224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297912320 ++read 2048/2048 bytes at offset 4297912320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297916416 ++read 2048/2048 bytes at offset 4297916416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297920512 ++read 2048/2048 bytes at offset 4297920512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297924608 ++read 2048/2048 bytes at offset 4297924608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297928704 ++read 2048/2048 bytes at offset 4297928704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297932800 ++read 2048/2048 bytes at offset 4297932800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297936896 ++read 2048/2048 bytes at offset 4297936896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297940992 ++read 2048/2048 bytes at offset 4297940992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297945088 ++read 2048/2048 bytes at offset 4297945088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297949184 ++read 2048/2048 bytes at offset 4297949184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297953280 ++read 2048/2048 bytes at offset 4297953280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297957376 ++read 2048/2048 bytes at offset 4297957376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297961472 ++read 2048/2048 bytes at offset 4297961472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297965568 ++read 2048/2048 bytes at offset 4297965568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297969664 ++read 2048/2048 bytes at offset 4297969664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297973760 ++read 2048/2048 bytes at offset 4297973760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297977856 ++read 2048/2048 bytes at offset 4297977856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297981952 ++read 2048/2048 bytes at offset 4297981952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297986048 ++read 2048/2048 bytes at offset 4297986048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297990144 ++read 2048/2048 bytes at offset 4297990144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297994240 ++read 2048/2048 bytes at offset 4297994240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297998336 ++read 2048/2048 bytes at offset 4297998336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298002432 ++read 2048/2048 bytes at offset 4298002432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298006528 ++read 2048/2048 bytes at offset 4298006528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298010624 ++read 2048/2048 bytes at offset 4298010624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298014720 ++read 2048/2048 bytes at offset 4298014720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298018816 ++read 2048/2048 bytes at offset 4298018816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298022912 ++read 2048/2048 bytes at offset 4298022912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298027008 ++read 2048/2048 bytes at offset 4298027008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298031104 ++read 2048/2048 bytes at offset 4298031104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298035200 ++read 2048/2048 bytes at offset 4298035200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298039296 ++read 2048/2048 bytes at offset 4298039296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298043392 ++read 2048/2048 bytes at offset 4298043392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298047488 ++read 2048/2048 bytes at offset 4298047488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298051584 ++read 2048/2048 bytes at offset 4298051584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298055680 ++read 2048/2048 bytes at offset 4298055680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298059776 ++read 2048/2048 bytes at offset 4298059776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298063872 ++read 2048/2048 bytes at offset 4298063872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298067968 ++read 2048/2048 bytes at offset 4298067968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298072064 ++read 2048/2048 bytes at offset 4298072064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298076160 ++read 2048/2048 bytes at offset 4298076160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298080256 ++read 2048/2048 bytes at offset 4298080256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298084352 ++read 2048/2048 bytes at offset 4298084352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298088448 ++read 2048/2048 bytes at offset 4298088448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298092544 ++read 2048/2048 bytes at offset 4298092544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298096640 ++read 2048/2048 bytes at offset 4298096640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298100736 ++read 2048/2048 bytes at offset 4298100736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298104832 ++read 2048/2048 bytes at offset 4298104832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298108928 ++read 2048/2048 bytes at offset 4298108928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 2 +-qemu-io> read 2048/2048 bytes at offset 4298114048 ++=== IO: pattern 2 ++read 2048/2048 bytes at offset 4298114048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298118144 ++read 2048/2048 bytes at offset 4298118144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298122240 ++read 2048/2048 bytes at offset 4298122240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298126336 ++read 2048/2048 bytes at offset 4298126336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298130432 ++read 2048/2048 bytes at offset 4298130432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298134528 ++read 2048/2048 bytes at offset 4298134528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298138624 ++read 2048/2048 bytes at offset 4298138624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298142720 ++read 2048/2048 bytes at offset 4298142720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298146816 ++read 2048/2048 bytes at offset 4298146816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298150912 ++read 2048/2048 bytes at offset 4298150912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298155008 ++read 2048/2048 bytes at offset 4298155008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298159104 ++read 2048/2048 bytes at offset 4298159104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298163200 ++read 2048/2048 bytes at offset 4298163200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298167296 ++read 2048/2048 bytes at offset 4298167296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298171392 ++read 2048/2048 bytes at offset 4298171392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298175488 ++read 2048/2048 bytes at offset 4298175488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298179584 ++read 2048/2048 bytes at offset 4298179584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298183680 ++read 2048/2048 bytes at offset 4298183680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298187776 ++read 2048/2048 bytes at offset 4298187776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298191872 ++read 2048/2048 bytes at offset 4298191872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298195968 ++read 2048/2048 bytes at offset 4298195968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298200064 ++read 2048/2048 bytes at offset 4298200064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298204160 ++read 2048/2048 bytes at offset 4298204160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298208256 ++read 2048/2048 bytes at offset 4298208256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298212352 ++read 2048/2048 bytes at offset 4298212352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298216448 ++read 2048/2048 bytes at offset 4298216448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298220544 ++read 2048/2048 bytes at offset 4298220544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298224640 ++read 2048/2048 bytes at offset 4298224640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298228736 ++read 2048/2048 bytes at offset 4298228736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298232832 ++read 2048/2048 bytes at offset 4298232832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298236928 ++read 2048/2048 bytes at offset 4298236928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298241024 ++read 2048/2048 bytes at offset 4298241024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298245120 ++read 2048/2048 bytes at offset 4298245120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298249216 ++read 2048/2048 bytes at offset 4298249216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298253312 ++read 2048/2048 bytes at offset 4298253312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298257408 ++read 2048/2048 bytes at offset 4298257408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298261504 ++read 2048/2048 bytes at offset 4298261504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298265600 ++read 2048/2048 bytes at offset 4298265600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298269696 ++read 2048/2048 bytes at offset 4298269696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298273792 ++read 2048/2048 bytes at offset 4298273792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298277888 ++read 2048/2048 bytes at offset 4298277888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298281984 ++read 2048/2048 bytes at offset 4298281984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298286080 ++read 2048/2048 bytes at offset 4298286080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298290176 ++read 2048/2048 bytes at offset 4298290176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298294272 ++read 2048/2048 bytes at offset 4298294272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298298368 ++read 2048/2048 bytes at offset 4298298368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298302464 ++read 2048/2048 bytes at offset 4298302464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298306560 ++read 2048/2048 bytes at offset 4298306560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298310656 ++read 2048/2048 bytes at offset 4298310656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298314752 ++read 2048/2048 bytes at offset 4298314752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298318848 ++read 2048/2048 bytes at offset 4298318848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298322944 ++read 2048/2048 bytes at offset 4298322944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298327040 ++read 2048/2048 bytes at offset 4298327040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298331136 ++read 2048/2048 bytes at offset 4298331136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298335232 ++read 2048/2048 bytes at offset 4298335232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298339328 ++read 2048/2048 bytes at offset 4298339328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298343424 ++read 2048/2048 bytes at offset 4298343424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298347520 ++read 2048/2048 bytes at offset 4298347520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298351616 ++read 2048/2048 bytes at offset 4298351616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298355712 ++read 2048/2048 bytes at offset 4298355712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298359808 ++read 2048/2048 bytes at offset 4298359808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298363904 ++read 2048/2048 bytes at offset 4298363904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298368000 ++read 2048/2048 bytes at offset 4298368000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298372096 ++read 2048/2048 bytes at offset 4298372096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298376192 ++read 2048/2048 bytes at offset 4298376192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298380288 ++read 2048/2048 bytes at offset 4298380288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298384384 ++read 2048/2048 bytes at offset 4298384384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298388480 ++read 2048/2048 bytes at offset 4298388480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298392576 ++read 2048/2048 bytes at offset 4298392576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298396672 ++read 2048/2048 bytes at offset 4298396672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298400768 ++read 2048/2048 bytes at offset 4298400768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298404864 ++read 2048/2048 bytes at offset 4298404864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298408960 ++read 2048/2048 bytes at offset 4298408960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298413056 ++read 2048/2048 bytes at offset 4298413056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298417152 ++read 2048/2048 bytes at offset 4298417152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298421248 ++read 2048/2048 bytes at offset 4298421248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298425344 ++read 2048/2048 bytes at offset 4298425344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298429440 ++read 2048/2048 bytes at offset 4298429440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298433536 ++read 2048/2048 bytes at offset 4298433536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298437632 ++read 2048/2048 bytes at offset 4298437632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298441728 ++read 2048/2048 bytes at offset 4298441728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298445824 ++read 2048/2048 bytes at offset 4298445824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298449920 ++read 2048/2048 bytes at offset 4298449920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298454016 ++read 2048/2048 bytes at offset 4298454016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298458112 ++read 2048/2048 bytes at offset 4298458112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298462208 ++read 2048/2048 bytes at offset 4298462208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298466304 ++read 2048/2048 bytes at offset 4298466304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298470400 ++read 2048/2048 bytes at offset 4298470400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298474496 ++read 2048/2048 bytes at offset 4298474496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298478592 ++read 2048/2048 bytes at offset 4298478592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298482688 ++read 2048/2048 bytes at offset 4298482688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298486784 ++read 2048/2048 bytes at offset 4298486784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298490880 ++read 2048/2048 bytes at offset 4298490880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298494976 ++read 2048/2048 bytes at offset 4298494976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298499072 ++read 2048/2048 bytes at offset 4298499072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298503168 ++read 2048/2048 bytes at offset 4298503168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298507264 ++read 2048/2048 bytes at offset 4298507264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298511360 ++read 2048/2048 bytes at offset 4298511360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298515456 ++read 2048/2048 bytes at offset 4298515456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298519552 ++read 2048/2048 bytes at offset 4298519552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298523648 ++read 2048/2048 bytes at offset 4298523648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298527744 ++read 2048/2048 bytes at offset 4298527744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298531840 ++read 2048/2048 bytes at offset 4298531840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298535936 ++read 2048/2048 bytes at offset 4298535936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298540032 ++read 2048/2048 bytes at offset 4298540032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298544128 ++read 2048/2048 bytes at offset 4298544128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298548224 ++read 2048/2048 bytes at offset 4298548224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298552320 ++read 2048/2048 bytes at offset 4298552320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298556416 ++read 2048/2048 bytes at offset 4298556416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298560512 ++read 2048/2048 bytes at offset 4298560512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298564608 ++read 2048/2048 bytes at offset 4298564608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298568704 ++read 2048/2048 bytes at offset 4298568704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298572800 ++read 2048/2048 bytes at offset 4298572800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298576896 ++read 2048/2048 bytes at offset 4298576896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298580992 ++read 2048/2048 bytes at offset 4298580992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298585088 ++read 2048/2048 bytes at offset 4298585088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298589184 ++read 2048/2048 bytes at offset 4298589184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298593280 ++read 2048/2048 bytes at offset 4298593280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298597376 ++read 2048/2048 bytes at offset 4298597376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298601472 ++read 2048/2048 bytes at offset 4298601472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298605568 ++read 2048/2048 bytes at offset 4298605568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298609664 ++read 2048/2048 bytes at offset 4298609664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298613760 ++read 2048/2048 bytes at offset 4298613760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298617856 ++read 2048/2048 bytes at offset 4298617856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298621952 ++read 2048/2048 bytes at offset 4298621952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298626048 ++read 2048/2048 bytes at offset 4298626048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298630144 ++read 2048/2048 bytes at offset 4298630144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298634240 ++read 2048/2048 bytes at offset 4298634240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298638336 ++read 2048/2048 bytes at offset 4298638336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298642432 ++read 2048/2048 bytes at offset 4298642432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298646528 ++read 2048/2048 bytes at offset 4298646528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298650624 ++read 2048/2048 bytes at offset 4298650624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298654720 ++read 2048/2048 bytes at offset 4298654720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298658816 ++read 2048/2048 bytes at offset 4298658816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298662912 ++read 2048/2048 bytes at offset 4298662912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298667008 ++read 2048/2048 bytes at offset 4298667008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298671104 ++read 2048/2048 bytes at offset 4298671104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298675200 ++read 2048/2048 bytes at offset 4298675200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298679296 ++read 2048/2048 bytes at offset 4298679296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298683392 ++read 2048/2048 bytes at offset 4298683392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298687488 ++read 2048/2048 bytes at offset 4298687488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298691584 ++read 2048/2048 bytes at offset 4298691584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298695680 ++read 2048/2048 bytes at offset 4298695680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298699776 ++read 2048/2048 bytes at offset 4298699776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298703872 ++read 2048/2048 bytes at offset 4298703872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298707968 ++read 2048/2048 bytes at offset 4298707968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298712064 ++read 2048/2048 bytes at offset 4298712064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298716160 ++read 2048/2048 bytes at offset 4298716160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298720256 ++read 2048/2048 bytes at offset 4298720256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298724352 ++read 2048/2048 bytes at offset 4298724352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298728448 ++read 2048/2048 bytes at offset 4298728448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298732544 ++read 2048/2048 bytes at offset 4298732544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298736640 ++read 2048/2048 bytes at offset 4298736640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298740736 ++read 2048/2048 bytes at offset 4298740736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298744832 ++read 2048/2048 bytes at offset 4298744832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298748928 ++read 2048/2048 bytes at offset 4298748928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298753024 ++read 2048/2048 bytes at offset 4298753024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298757120 ++read 2048/2048 bytes at offset 4298757120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298761216 ++read 2048/2048 bytes at offset 4298761216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298765312 ++read 2048/2048 bytes at offset 4298765312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298769408 ++read 2048/2048 bytes at offset 4298769408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298773504 ++read 2048/2048 bytes at offset 4298773504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298777600 ++read 2048/2048 bytes at offset 4298777600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298781696 ++read 2048/2048 bytes at offset 4298781696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298785792 ++read 2048/2048 bytes at offset 4298785792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298789888 ++read 2048/2048 bytes at offset 4298789888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298793984 ++read 2048/2048 bytes at offset 4298793984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298798080 ++read 2048/2048 bytes at offset 4298798080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298802176 ++read 2048/2048 bytes at offset 4298802176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298806272 ++read 2048/2048 bytes at offset 4298806272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298810368 ++read 2048/2048 bytes at offset 4298810368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298814464 ++read 2048/2048 bytes at offset 4298814464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298818560 ++read 2048/2048 bytes at offset 4298818560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298822656 ++read 2048/2048 bytes at offset 4298822656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298826752 ++read 2048/2048 bytes at offset 4298826752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298830848 ++read 2048/2048 bytes at offset 4298830848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298834944 ++read 2048/2048 bytes at offset 4298834944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298839040 ++read 2048/2048 bytes at offset 4298839040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298843136 ++read 2048/2048 bytes at offset 4298843136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298847232 ++read 2048/2048 bytes at offset 4298847232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298851328 ++read 2048/2048 bytes at offset 4298851328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298855424 ++read 2048/2048 bytes at offset 4298855424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298859520 ++read 2048/2048 bytes at offset 4298859520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298863616 ++read 2048/2048 bytes at offset 4298863616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298867712 ++read 2048/2048 bytes at offset 4298867712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298871808 ++read 2048/2048 bytes at offset 4298871808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298875904 ++read 2048/2048 bytes at offset 4298875904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298880000 ++read 2048/2048 bytes at offset 4298880000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298884096 ++read 2048/2048 bytes at offset 4298884096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298888192 ++read 2048/2048 bytes at offset 4298888192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298892288 ++read 2048/2048 bytes at offset 4298892288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298896384 ++read 2048/2048 bytes at offset 4298896384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298900480 ++read 2048/2048 bytes at offset 4298900480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298904576 ++read 2048/2048 bytes at offset 4298904576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298908672 ++read 2048/2048 bytes at offset 4298908672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298912768 ++read 2048/2048 bytes at offset 4298912768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298916864 ++read 2048/2048 bytes at offset 4298916864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298920960 ++read 2048/2048 bytes at offset 4298920960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298925056 ++read 2048/2048 bytes at offset 4298925056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298929152 ++read 2048/2048 bytes at offset 4298929152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298933248 ++read 2048/2048 bytes at offset 4298933248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298937344 ++read 2048/2048 bytes at offset 4298937344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298941440 ++read 2048/2048 bytes at offset 4298941440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298945536 ++read 2048/2048 bytes at offset 4298945536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298949632 ++read 2048/2048 bytes at offset 4298949632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298953728 ++read 2048/2048 bytes at offset 4298953728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298957824 ++read 2048/2048 bytes at offset 4298957824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298961920 ++read 2048/2048 bytes at offset 4298961920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298966016 ++read 2048/2048 bytes at offset 4298966016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298970112 ++read 2048/2048 bytes at offset 4298970112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298974208 ++read 2048/2048 bytes at offset 4298974208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298978304 ++read 2048/2048 bytes at offset 4298978304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298982400 ++read 2048/2048 bytes at offset 4298982400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298986496 ++read 2048/2048 bytes at offset 4298986496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298990592 ++read 2048/2048 bytes at offset 4298990592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298994688 ++read 2048/2048 bytes at offset 4298994688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298998784 ++read 2048/2048 bytes at offset 4298998784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299002880 ++read 2048/2048 bytes at offset 4299002880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299006976 ++read 2048/2048 bytes at offset 4299006976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299011072 ++read 2048/2048 bytes at offset 4299011072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299015168 ++read 2048/2048 bytes at offset 4299015168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299019264 ++read 2048/2048 bytes at offset 4299019264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299023360 ++read 2048/2048 bytes at offset 4299023360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299027456 ++read 2048/2048 bytes at offset 4299027456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299031552 ++read 2048/2048 bytes at offset 4299031552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299035648 ++read 2048/2048 bytes at offset 4299035648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299039744 ++read 2048/2048 bytes at offset 4299039744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299043840 ++read 2048/2048 bytes at offset 4299043840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299047936 ++read 2048/2048 bytes at offset 4299047936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299052032 ++read 2048/2048 bytes at offset 4299052032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299056128 ++read 2048/2048 bytes at offset 4299056128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299060224 ++read 2048/2048 bytes at offset 4299060224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299064320 ++read 2048/2048 bytes at offset 4299064320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299068416 ++read 2048/2048 bytes at offset 4299068416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299072512 ++read 2048/2048 bytes at offset 4299072512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299076608 ++read 2048/2048 bytes at offset 4299076608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299080704 ++read 2048/2048 bytes at offset 4299080704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299084800 ++read 2048/2048 bytes at offset 4299084800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299088896 ++read 2048/2048 bytes at offset 4299088896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299092992 ++read 2048/2048 bytes at offset 4299092992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299097088 ++read 2048/2048 bytes at offset 4299097088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299101184 ++read 2048/2048 bytes at offset 4299101184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299105280 ++read 2048/2048 bytes at offset 4299105280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299109376 ++read 2048/2048 bytes at offset 4299109376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299113472 ++read 2048/2048 bytes at offset 4299113472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299117568 ++read 2048/2048 bytes at offset 4299117568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299121664 ++read 2048/2048 bytes at offset 4299121664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299125760 ++read 2048/2048 bytes at offset 4299125760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299129856 ++read 2048/2048 bytes at offset 4299129856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299133952 ++read 2048/2048 bytes at offset 4299133952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299138048 ++read 2048/2048 bytes at offset 4299138048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299142144 ++read 2048/2048 bytes at offset 4299142144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299146240 ++read 2048/2048 bytes at offset 4299146240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299150336 ++read 2048/2048 bytes at offset 4299150336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299154432 ++read 2048/2048 bytes at offset 4299154432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299158528 ++read 2048/2048 bytes at offset 4299158528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 4 +-qemu-io> read 8192/8192 bytes at offset 4299163648 ++=== IO: pattern 4 ++read 8192/8192 bytes at offset 4299163648 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299175936 ++read 8192/8192 bytes at offset 4299175936 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299188224 ++read 8192/8192 bytes at offset 4299188224 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299200512 ++read 8192/8192 bytes at offset 4299200512 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299212800 ++read 8192/8192 bytes at offset 4299212800 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299225088 ++read 8192/8192 bytes at offset 4299225088 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299237376 ++read 8192/8192 bytes at offset 4299237376 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299249664 ++read 8192/8192 bytes at offset 4299249664 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299261952 ++read 8192/8192 bytes at offset 4299261952 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299274240 ++read 8192/8192 bytes at offset 4299274240 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299286528 ++read 8192/8192 bytes at offset 4299286528 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299298816 ++read 8192/8192 bytes at offset 4299298816 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299311104 ++read 8192/8192 bytes at offset 4299311104 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299323392 ++read 8192/8192 bytes at offset 4299323392 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299335680 ++read 8192/8192 bytes at offset 4299335680 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299347968 ++read 8192/8192 bytes at offset 4299347968 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299360256 ++read 8192/8192 bytes at offset 4299360256 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299372544 ++read 8192/8192 bytes at offset 4299372544 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299384832 ++read 8192/8192 bytes at offset 4299384832 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299397120 ++read 8192/8192 bytes at offset 4299397120 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299409408 ++read 8192/8192 bytes at offset 4299409408 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299421696 ++read 8192/8192 bytes at offset 4299421696 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299433984 ++read 8192/8192 bytes at offset 4299433984 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299446272 ++read 8192/8192 bytes at offset 4299446272 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299458560 ++read 8192/8192 bytes at offset 4299458560 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299470848 ++read 8192/8192 bytes at offset 4299470848 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299483136 ++read 8192/8192 bytes at offset 4299483136 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299495424 ++read 8192/8192 bytes at offset 4299495424 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299507712 ++read 8192/8192 bytes at offset 4299507712 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299520000 ++read 8192/8192 bytes at offset 4299520000 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299532288 ++read 8192/8192 bytes at offset 4299532288 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299544576 ++read 8192/8192 bytes at offset 4299544576 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299556864 ++read 8192/8192 bytes at offset 4299556864 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299569152 ++read 8192/8192 bytes at offset 4299569152 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299581440 ++read 8192/8192 bytes at offset 4299581440 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299593728 ++read 8192/8192 bytes at offset 4299593728 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299606016 ++read 8192/8192 bytes at offset 4299606016 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299618304 ++read 8192/8192 bytes at offset 4299618304 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299630592 ++read 8192/8192 bytes at offset 4299630592 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299642880 ++read 8192/8192 bytes at offset 4299642880 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299655168 ++read 8192/8192 bytes at offset 4299655168 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299667456 ++read 8192/8192 bytes at offset 4299667456 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299679744 ++read 8192/8192 bytes at offset 4299679744 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299692032 ++read 8192/8192 bytes at offset 4299692032 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299704320 ++read 8192/8192 bytes at offset 4299704320 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299716608 ++read 8192/8192 bytes at offset 4299716608 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299728896 ++read 8192/8192 bytes at offset 4299728896 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299741184 ++read 8192/8192 bytes at offset 4299741184 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299753472 ++read 8192/8192 bytes at offset 4299753472 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299765760 ++read 8192/8192 bytes at offset 4299765760 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299778048 ++read 8192/8192 bytes at offset 4299778048 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299790336 ++read 8192/8192 bytes at offset 4299790336 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299802624 ++read 8192/8192 bytes at offset 4299802624 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299814912 ++read 8192/8192 bytes at offset 4299814912 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299827200 ++read 8192/8192 bytes at offset 4299827200 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299839488 ++read 8192/8192 bytes at offset 4299839488 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299851776 ++read 8192/8192 bytes at offset 4299851776 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299864064 ++read 8192/8192 bytes at offset 4299864064 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299876352 ++read 8192/8192 bytes at offset 4299876352 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299888640 ++read 8192/8192 bytes at offset 4299888640 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299900928 ++read 8192/8192 bytes at offset 4299900928 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299913216 ++read 8192/8192 bytes at offset 4299913216 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299925504 ++read 8192/8192 bytes at offset 4299925504 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299937792 ++read 8192/8192 bytes at offset 4299937792 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 244 +-qemu-io> read 12288/12288 bytes at offset 4301252608 ++=== IO: pattern 244 ++read 12288/12288 bytes at offset 4301252608 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4303351808 ++read 12288/12288 bytes at offset 4303351808 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4305451008 ++read 12288/12288 bytes at offset 4305451008 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4307550208 ++read 12288/12288 bytes at offset 4307550208 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4309649408 ++read 12288/12288 bytes at offset 4309649408 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4311748608 ++read 12288/12288 bytes at offset 4311748608 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4313847808 ++read 12288/12288 bytes at offset 4313847808 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4315947008 ++read 12288/12288 bytes at offset 4315947008 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> read 4096/4096 bytes at offset 4294967296 ++=== IO: pattern 0 ++read 4096/4096 bytes at offset 4294967296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294971392 ++read 4096/4096 bytes at offset 4294971392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294975488 ++read 4096/4096 bytes at offset 4294975488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294979584 ++read 4096/4096 bytes at offset 4294979584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294983680 ++read 4096/4096 bytes at offset 4294983680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294987776 ++read 4096/4096 bytes at offset 4294987776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294991872 ++read 4096/4096 bytes at offset 4294991872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294995968 ++read 4096/4096 bytes at offset 4294995968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295000064 ++read 4096/4096 bytes at offset 4295000064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295004160 ++read 4096/4096 bytes at offset 4295004160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295008256 ++read 4096/4096 bytes at offset 4295008256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295012352 ++read 4096/4096 bytes at offset 4295012352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295016448 ++read 4096/4096 bytes at offset 4295016448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295020544 ++read 4096/4096 bytes at offset 4295020544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295024640 ++read 4096/4096 bytes at offset 4295024640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295028736 ++read 4096/4096 bytes at offset 4295028736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295032832 ++read 4096/4096 bytes at offset 4295032832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295036928 ++read 4096/4096 bytes at offset 4295036928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295041024 ++read 4096/4096 bytes at offset 4295041024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295045120 ++read 4096/4096 bytes at offset 4295045120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295049216 ++read 4096/4096 bytes at offset 4295049216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295053312 ++read 4096/4096 bytes at offset 4295053312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295057408 ++read 4096/4096 bytes at offset 4295057408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295061504 ++read 4096/4096 bytes at offset 4295061504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295065600 ++read 4096/4096 bytes at offset 4295065600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295069696 ++read 4096/4096 bytes at offset 4295069696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295073792 ++read 4096/4096 bytes at offset 4295073792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295077888 ++read 4096/4096 bytes at offset 4295077888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295081984 ++read 4096/4096 bytes at offset 4295081984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295086080 ++read 4096/4096 bytes at offset 4295086080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295090176 ++read 4096/4096 bytes at offset 4295090176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295094272 ++read 4096/4096 bytes at offset 4295094272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295098368 ++read 4096/4096 bytes at offset 4295098368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295102464 ++read 4096/4096 bytes at offset 4295102464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295106560 ++read 4096/4096 bytes at offset 4295106560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295110656 ++read 4096/4096 bytes at offset 4295110656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295114752 ++read 4096/4096 bytes at offset 4295114752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295118848 ++read 4096/4096 bytes at offset 4295118848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295122944 ++read 4096/4096 bytes at offset 4295122944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295127040 ++read 4096/4096 bytes at offset 4295127040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295131136 ++read 4096/4096 bytes at offset 4295131136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295135232 ++read 4096/4096 bytes at offset 4295135232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295139328 ++read 4096/4096 bytes at offset 4295139328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295143424 ++read 4096/4096 bytes at offset 4295143424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295147520 ++read 4096/4096 bytes at offset 4295147520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295151616 ++read 4096/4096 bytes at offset 4295151616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295155712 ++read 4096/4096 bytes at offset 4295155712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295159808 ++read 4096/4096 bytes at offset 4295159808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295163904 ++read 4096/4096 bytes at offset 4295163904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295168000 ++read 4096/4096 bytes at offset 4295168000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295172096 ++read 4096/4096 bytes at offset 4295172096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295176192 ++read 4096/4096 bytes at offset 4295176192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295180288 ++read 4096/4096 bytes at offset 4295180288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295184384 ++read 4096/4096 bytes at offset 4295184384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295188480 ++read 4096/4096 bytes at offset 4295188480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295192576 ++read 4096/4096 bytes at offset 4295192576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295196672 ++read 4096/4096 bytes at offset 4295196672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295200768 ++read 4096/4096 bytes at offset 4295200768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295204864 ++read 4096/4096 bytes at offset 4295204864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295208960 ++read 4096/4096 bytes at offset 4295208960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295213056 ++read 4096/4096 bytes at offset 4295213056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295217152 ++read 4096/4096 bytes at offset 4295217152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295221248 ++read 4096/4096 bytes at offset 4295221248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295225344 ++read 4096/4096 bytes at offset 4295225344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295229440 ++read 4096/4096 bytes at offset 4295229440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295233536 ++read 4096/4096 bytes at offset 4295233536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295237632 ++read 4096/4096 bytes at offset 4295237632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295241728 ++read 4096/4096 bytes at offset 4295241728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295245824 ++read 4096/4096 bytes at offset 4295245824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295249920 ++read 4096/4096 bytes at offset 4295249920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295254016 ++read 4096/4096 bytes at offset 4295254016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295258112 ++read 4096/4096 bytes at offset 4295258112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295262208 ++read 4096/4096 bytes at offset 4295262208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295266304 ++read 4096/4096 bytes at offset 4295266304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295270400 ++read 4096/4096 bytes at offset 4295270400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295274496 ++read 4096/4096 bytes at offset 4295274496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295278592 ++read 4096/4096 bytes at offset 4295278592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295282688 ++read 4096/4096 bytes at offset 4295282688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295286784 ++read 4096/4096 bytes at offset 4295286784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295290880 ++read 4096/4096 bytes at offset 4295290880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295294976 ++read 4096/4096 bytes at offset 4295294976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295299072 ++read 4096/4096 bytes at offset 4295299072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295303168 ++read 4096/4096 bytes at offset 4295303168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295307264 ++read 4096/4096 bytes at offset 4295307264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295311360 ++read 4096/4096 bytes at offset 4295311360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295315456 ++read 4096/4096 bytes at offset 4295315456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295319552 ++read 4096/4096 bytes at offset 4295319552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295323648 ++read 4096/4096 bytes at offset 4295323648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295327744 ++read 4096/4096 bytes at offset 4295327744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295331840 ++read 4096/4096 bytes at offset 4295331840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295335936 ++read 4096/4096 bytes at offset 4295335936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295340032 ++read 4096/4096 bytes at offset 4295340032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295344128 ++read 4096/4096 bytes at offset 4295344128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295348224 ++read 4096/4096 bytes at offset 4295348224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295352320 ++read 4096/4096 bytes at offset 4295352320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295356416 ++read 4096/4096 bytes at offset 4295356416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295360512 ++read 4096/4096 bytes at offset 4295360512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295364608 ++read 4096/4096 bytes at offset 4295364608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295368704 ++read 4096/4096 bytes at offset 4295368704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295372800 ++read 4096/4096 bytes at offset 4295372800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295376896 ++read 4096/4096 bytes at offset 4295376896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295380992 ++read 4096/4096 bytes at offset 4295380992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295385088 ++read 4096/4096 bytes at offset 4295385088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295389184 ++read 4096/4096 bytes at offset 4295389184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295393280 ++read 4096/4096 bytes at offset 4295393280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295397376 ++read 4096/4096 bytes at offset 4295397376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295401472 ++read 4096/4096 bytes at offset 4295401472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295405568 ++read 4096/4096 bytes at offset 4295405568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295409664 ++read 4096/4096 bytes at offset 4295409664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295413760 ++read 4096/4096 bytes at offset 4295413760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295417856 ++read 4096/4096 bytes at offset 4295417856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295421952 ++read 4096/4096 bytes at offset 4295421952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295426048 ++read 4096/4096 bytes at offset 4295426048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295430144 ++read 4096/4096 bytes at offset 4295430144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295434240 ++read 4096/4096 bytes at offset 4295434240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295438336 ++read 4096/4096 bytes at offset 4295438336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295442432 ++read 4096/4096 bytes at offset 4295442432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295446528 ++read 4096/4096 bytes at offset 4295446528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295450624 ++read 4096/4096 bytes at offset 4295450624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295454720 ++read 4096/4096 bytes at offset 4295454720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295458816 ++read 4096/4096 bytes at offset 4295458816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295462912 ++read 4096/4096 bytes at offset 4295462912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295467008 ++read 4096/4096 bytes at offset 4295467008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295471104 ++read 4096/4096 bytes at offset 4295471104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295475200 ++read 4096/4096 bytes at offset 4295475200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295479296 ++read 4096/4096 bytes at offset 4295479296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295483392 ++read 4096/4096 bytes at offset 4295483392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295487488 ++read 4096/4096 bytes at offset 4295487488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295491584 ++read 4096/4096 bytes at offset 4295491584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295495680 ++read 4096/4096 bytes at offset 4295495680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295499776 ++read 4096/4096 bytes at offset 4295499776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295503872 ++read 4096/4096 bytes at offset 4295503872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295507968 ++read 4096/4096 bytes at offset 4295507968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295512064 ++read 4096/4096 bytes at offset 4295512064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295516160 ++read 4096/4096 bytes at offset 4295516160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295520256 ++read 4096/4096 bytes at offset 4295520256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295524352 ++read 4096/4096 bytes at offset 4295524352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295528448 ++read 4096/4096 bytes at offset 4295528448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295532544 ++read 4096/4096 bytes at offset 4295532544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295536640 ++read 4096/4096 bytes at offset 4295536640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295540736 ++read 4096/4096 bytes at offset 4295540736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295544832 ++read 4096/4096 bytes at offset 4295544832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295548928 ++read 4096/4096 bytes at offset 4295548928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295553024 ++read 4096/4096 bytes at offset 4295553024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295557120 ++read 4096/4096 bytes at offset 4295557120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295561216 ++read 4096/4096 bytes at offset 4295561216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295565312 ++read 4096/4096 bytes at offset 4295565312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295569408 ++read 4096/4096 bytes at offset 4295569408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295573504 ++read 4096/4096 bytes at offset 4295573504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295577600 ++read 4096/4096 bytes at offset 4295577600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295581696 ++read 4096/4096 bytes at offset 4295581696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295585792 ++read 4096/4096 bytes at offset 4295585792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295589888 ++read 4096/4096 bytes at offset 4295589888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295593984 ++read 4096/4096 bytes at offset 4295593984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295598080 ++read 4096/4096 bytes at offset 4295598080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295602176 ++read 4096/4096 bytes at offset 4295602176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295606272 ++read 4096/4096 bytes at offset 4295606272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295610368 ++read 4096/4096 bytes at offset 4295610368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295614464 ++read 4096/4096 bytes at offset 4295614464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295618560 ++read 4096/4096 bytes at offset 4295618560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295622656 ++read 4096/4096 bytes at offset 4295622656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295626752 ++read 4096/4096 bytes at offset 4295626752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295630848 ++read 4096/4096 bytes at offset 4295630848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295634944 ++read 4096/4096 bytes at offset 4295634944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295639040 ++read 4096/4096 bytes at offset 4295639040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295643136 ++read 4096/4096 bytes at offset 4295643136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295647232 ++read 4096/4096 bytes at offset 4295647232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295651328 ++read 4096/4096 bytes at offset 4295651328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295655424 ++read 4096/4096 bytes at offset 4295655424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295659520 ++read 4096/4096 bytes at offset 4295659520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295663616 ++read 4096/4096 bytes at offset 4295663616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295667712 ++read 4096/4096 bytes at offset 4295667712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295671808 ++read 4096/4096 bytes at offset 4295671808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295675904 ++read 4096/4096 bytes at offset 4295675904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295680000 ++read 4096/4096 bytes at offset 4295680000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295684096 ++read 4096/4096 bytes at offset 4295684096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295688192 ++read 4096/4096 bytes at offset 4295688192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295692288 ++read 4096/4096 bytes at offset 4295692288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295696384 ++read 4096/4096 bytes at offset 4295696384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295700480 ++read 4096/4096 bytes at offset 4295700480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295704576 ++read 4096/4096 bytes at offset 4295704576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295708672 ++read 4096/4096 bytes at offset 4295708672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295712768 ++read 4096/4096 bytes at offset 4295712768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295716864 ++read 4096/4096 bytes at offset 4295716864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295720960 ++read 4096/4096 bytes at offset 4295720960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295725056 ++read 4096/4096 bytes at offset 4295725056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295729152 ++read 4096/4096 bytes at offset 4295729152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295733248 ++read 4096/4096 bytes at offset 4295733248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295737344 ++read 4096/4096 bytes at offset 4295737344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295741440 ++read 4096/4096 bytes at offset 4295741440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295745536 ++read 4096/4096 bytes at offset 4295745536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295749632 ++read 4096/4096 bytes at offset 4295749632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295753728 ++read 4096/4096 bytes at offset 4295753728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295757824 ++read 4096/4096 bytes at offset 4295757824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295761920 ++read 4096/4096 bytes at offset 4295761920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295766016 ++read 4096/4096 bytes at offset 4295766016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295770112 ++read 4096/4096 bytes at offset 4295770112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295774208 ++read 4096/4096 bytes at offset 4295774208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295778304 ++read 4096/4096 bytes at offset 4295778304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295782400 ++read 4096/4096 bytes at offset 4295782400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295786496 ++read 4096/4096 bytes at offset 4295786496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295790592 ++read 4096/4096 bytes at offset 4295790592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295794688 ++read 4096/4096 bytes at offset 4295794688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295798784 ++read 4096/4096 bytes at offset 4295798784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295802880 ++read 4096/4096 bytes at offset 4295802880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295806976 ++read 4096/4096 bytes at offset 4295806976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295811072 ++read 4096/4096 bytes at offset 4295811072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295815168 ++read 4096/4096 bytes at offset 4295815168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295819264 ++read 4096/4096 bytes at offset 4295819264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295823360 ++read 4096/4096 bytes at offset 4295823360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295827456 ++read 4096/4096 bytes at offset 4295827456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295831552 ++read 4096/4096 bytes at offset 4295831552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295835648 ++read 4096/4096 bytes at offset 4295835648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295839744 ++read 4096/4096 bytes at offset 4295839744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295843840 ++read 4096/4096 bytes at offset 4295843840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295847936 ++read 4096/4096 bytes at offset 4295847936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295852032 ++read 4096/4096 bytes at offset 4295852032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295856128 ++read 4096/4096 bytes at offset 4295856128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295860224 ++read 4096/4096 bytes at offset 4295860224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295864320 ++read 4096/4096 bytes at offset 4295864320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295868416 ++read 4096/4096 bytes at offset 4295868416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295872512 ++read 4096/4096 bytes at offset 4295872512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295876608 ++read 4096/4096 bytes at offset 4295876608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295880704 ++read 4096/4096 bytes at offset 4295880704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295884800 ++read 4096/4096 bytes at offset 4295884800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295888896 ++read 4096/4096 bytes at offset 4295888896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295892992 ++read 4096/4096 bytes at offset 4295892992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295897088 ++read 4096/4096 bytes at offset 4295897088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295901184 ++read 4096/4096 bytes at offset 4295901184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295905280 ++read 4096/4096 bytes at offset 4295905280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295909376 ++read 4096/4096 bytes at offset 4295909376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295913472 ++read 4096/4096 bytes at offset 4295913472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295917568 ++read 4096/4096 bytes at offset 4295917568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295921664 ++read 4096/4096 bytes at offset 4295921664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295925760 ++read 4096/4096 bytes at offset 4295925760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295929856 ++read 4096/4096 bytes at offset 4295929856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295933952 ++read 4096/4096 bytes at offset 4295933952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295938048 ++read 4096/4096 bytes at offset 4295938048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295942144 ++read 4096/4096 bytes at offset 4295942144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295946240 ++read 4096/4096 bytes at offset 4295946240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295950336 ++read 4096/4096 bytes at offset 4295950336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295954432 ++read 4096/4096 bytes at offset 4295954432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295958528 ++read 4096/4096 bytes at offset 4295958528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295962624 ++read 4096/4096 bytes at offset 4295962624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295966720 ++read 4096/4096 bytes at offset 4295966720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295970816 ++read 4096/4096 bytes at offset 4295970816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295974912 ++read 4096/4096 bytes at offset 4295974912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295979008 ++read 4096/4096 bytes at offset 4295979008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295983104 ++read 4096/4096 bytes at offset 4295983104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295987200 ++read 4096/4096 bytes at offset 4295987200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295991296 ++read 4096/4096 bytes at offset 4295991296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295995392 ++read 4096/4096 bytes at offset 4295995392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295999488 ++read 4096/4096 bytes at offset 4295999488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4296003584 ++read 4096/4096 bytes at offset 4296003584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4296007680 ++read 4096/4096 bytes at offset 4296007680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4296011776 ++read 4096/4096 bytes at offset 4296011776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 4 +-qemu-io> read 2048/2048 bytes at offset 4296017920 ++=== IO: pattern 4 ++read 2048/2048 bytes at offset 4296017920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296022016 ++read 2048/2048 bytes at offset 4296022016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296026112 ++read 2048/2048 bytes at offset 4296026112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296030208 ++read 2048/2048 bytes at offset 4296030208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296034304 ++read 2048/2048 bytes at offset 4296034304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296038400 ++read 2048/2048 bytes at offset 4296038400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296042496 ++read 2048/2048 bytes at offset 4296042496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296046592 ++read 2048/2048 bytes at offset 4296046592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296050688 ++read 2048/2048 bytes at offset 4296050688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296054784 ++read 2048/2048 bytes at offset 4296054784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296058880 ++read 2048/2048 bytes at offset 4296058880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296062976 ++read 2048/2048 bytes at offset 4296062976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296067072 ++read 2048/2048 bytes at offset 4296067072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296071168 ++read 2048/2048 bytes at offset 4296071168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296075264 ++read 2048/2048 bytes at offset 4296075264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296079360 ++read 2048/2048 bytes at offset 4296079360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296083456 ++read 2048/2048 bytes at offset 4296083456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296087552 ++read 2048/2048 bytes at offset 4296087552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296091648 ++read 2048/2048 bytes at offset 4296091648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296095744 ++read 2048/2048 bytes at offset 4296095744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296099840 ++read 2048/2048 bytes at offset 4296099840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296103936 ++read 2048/2048 bytes at offset 4296103936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296108032 ++read 2048/2048 bytes at offset 4296108032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296112128 ++read 2048/2048 bytes at offset 4296112128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296116224 ++read 2048/2048 bytes at offset 4296116224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296120320 ++read 2048/2048 bytes at offset 4296120320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296124416 ++read 2048/2048 bytes at offset 4296124416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296128512 ++read 2048/2048 bytes at offset 4296128512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296132608 ++read 2048/2048 bytes at offset 4296132608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296136704 ++read 2048/2048 bytes at offset 4296136704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296140800 ++read 2048/2048 bytes at offset 4296140800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296144896 ++read 2048/2048 bytes at offset 4296144896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296148992 ++read 2048/2048 bytes at offset 4296148992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296153088 ++read 2048/2048 bytes at offset 4296153088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296157184 ++read 2048/2048 bytes at offset 4296157184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296161280 ++read 2048/2048 bytes at offset 4296161280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296165376 ++read 2048/2048 bytes at offset 4296165376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296169472 ++read 2048/2048 bytes at offset 4296169472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296173568 ++read 2048/2048 bytes at offset 4296173568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296177664 ++read 2048/2048 bytes at offset 4296177664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296181760 ++read 2048/2048 bytes at offset 4296181760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296185856 ++read 2048/2048 bytes at offset 4296185856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296189952 ++read 2048/2048 bytes at offset 4296189952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296194048 ++read 2048/2048 bytes at offset 4296194048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296198144 ++read 2048/2048 bytes at offset 4296198144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296202240 ++read 2048/2048 bytes at offset 4296202240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296206336 ++read 2048/2048 bytes at offset 4296206336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296210432 ++read 2048/2048 bytes at offset 4296210432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296214528 ++read 2048/2048 bytes at offset 4296214528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296218624 ++read 2048/2048 bytes at offset 4296218624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296222720 ++read 2048/2048 bytes at offset 4296222720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296226816 ++read 2048/2048 bytes at offset 4296226816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296230912 ++read 2048/2048 bytes at offset 4296230912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296235008 ++read 2048/2048 bytes at offset 4296235008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296239104 ++read 2048/2048 bytes at offset 4296239104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296243200 ++read 2048/2048 bytes at offset 4296243200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296247296 ++read 2048/2048 bytes at offset 4296247296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296251392 ++read 2048/2048 bytes at offset 4296251392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296255488 ++read 2048/2048 bytes at offset 4296255488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296259584 ++read 2048/2048 bytes at offset 4296259584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296263680 ++read 2048/2048 bytes at offset 4296263680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296267776 ++read 2048/2048 bytes at offset 4296267776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296271872 ++read 2048/2048 bytes at offset 4296271872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296275968 ++read 2048/2048 bytes at offset 4296275968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296280064 ++read 2048/2048 bytes at offset 4296280064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296284160 ++read 2048/2048 bytes at offset 4296284160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296288256 ++read 2048/2048 bytes at offset 4296288256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296292352 ++read 2048/2048 bytes at offset 4296292352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296296448 ++read 2048/2048 bytes at offset 4296296448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296300544 ++read 2048/2048 bytes at offset 4296300544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296304640 ++read 2048/2048 bytes at offset 4296304640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296308736 ++read 2048/2048 bytes at offset 4296308736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296312832 ++read 2048/2048 bytes at offset 4296312832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296316928 ++read 2048/2048 bytes at offset 4296316928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296321024 ++read 2048/2048 bytes at offset 4296321024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296325120 ++read 2048/2048 bytes at offset 4296325120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296329216 ++read 2048/2048 bytes at offset 4296329216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296333312 ++read 2048/2048 bytes at offset 4296333312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296337408 ++read 2048/2048 bytes at offset 4296337408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296341504 ++read 2048/2048 bytes at offset 4296341504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296345600 ++read 2048/2048 bytes at offset 4296345600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296349696 ++read 2048/2048 bytes at offset 4296349696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296353792 ++read 2048/2048 bytes at offset 4296353792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296357888 ++read 2048/2048 bytes at offset 4296357888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296361984 ++read 2048/2048 bytes at offset 4296361984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296366080 ++read 2048/2048 bytes at offset 4296366080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296370176 ++read 2048/2048 bytes at offset 4296370176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296374272 ++read 2048/2048 bytes at offset 4296374272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296378368 ++read 2048/2048 bytes at offset 4296378368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296382464 ++read 2048/2048 bytes at offset 4296382464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296386560 ++read 2048/2048 bytes at offset 4296386560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296390656 ++read 2048/2048 bytes at offset 4296390656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296394752 ++read 2048/2048 bytes at offset 4296394752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296398848 ++read 2048/2048 bytes at offset 4296398848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296402944 ++read 2048/2048 bytes at offset 4296402944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296407040 ++read 2048/2048 bytes at offset 4296407040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296411136 ++read 2048/2048 bytes at offset 4296411136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296415232 ++read 2048/2048 bytes at offset 4296415232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296419328 ++read 2048/2048 bytes at offset 4296419328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296423424 ++read 2048/2048 bytes at offset 4296423424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296427520 ++read 2048/2048 bytes at offset 4296427520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296431616 ++read 2048/2048 bytes at offset 4296431616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296435712 ++read 2048/2048 bytes at offset 4296435712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296439808 ++read 2048/2048 bytes at offset 4296439808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296443904 ++read 2048/2048 bytes at offset 4296443904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296448000 ++read 2048/2048 bytes at offset 4296448000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296452096 ++read 2048/2048 bytes at offset 4296452096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296456192 ++read 2048/2048 bytes at offset 4296456192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296460288 ++read 2048/2048 bytes at offset 4296460288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296464384 ++read 2048/2048 bytes at offset 4296464384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296468480 ++read 2048/2048 bytes at offset 4296468480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296472576 ++read 2048/2048 bytes at offset 4296472576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296476672 ++read 2048/2048 bytes at offset 4296476672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296480768 ++read 2048/2048 bytes at offset 4296480768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296484864 ++read 2048/2048 bytes at offset 4296484864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296488960 ++read 2048/2048 bytes at offset 4296488960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296493056 ++read 2048/2048 bytes at offset 4296493056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296497152 ++read 2048/2048 bytes at offset 4296497152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296501248 ++read 2048/2048 bytes at offset 4296501248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296505344 ++read 2048/2048 bytes at offset 4296505344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296509440 ++read 2048/2048 bytes at offset 4296509440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296513536 ++read 2048/2048 bytes at offset 4296513536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296517632 ++read 2048/2048 bytes at offset 4296517632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296521728 ++read 2048/2048 bytes at offset 4296521728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296525824 ++read 2048/2048 bytes at offset 4296525824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296529920 ++read 2048/2048 bytes at offset 4296529920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296534016 ++read 2048/2048 bytes at offset 4296534016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296538112 ++read 2048/2048 bytes at offset 4296538112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296542208 ++read 2048/2048 bytes at offset 4296542208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296546304 ++read 2048/2048 bytes at offset 4296546304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296550400 ++read 2048/2048 bytes at offset 4296550400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296554496 ++read 2048/2048 bytes at offset 4296554496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296558592 ++read 2048/2048 bytes at offset 4296558592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296562688 ++read 2048/2048 bytes at offset 4296562688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296566784 ++read 2048/2048 bytes at offset 4296566784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296570880 ++read 2048/2048 bytes at offset 4296570880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296574976 ++read 2048/2048 bytes at offset 4296574976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296579072 ++read 2048/2048 bytes at offset 4296579072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296583168 ++read 2048/2048 bytes at offset 4296583168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296587264 ++read 2048/2048 bytes at offset 4296587264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296591360 ++read 2048/2048 bytes at offset 4296591360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296595456 ++read 2048/2048 bytes at offset 4296595456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296599552 ++read 2048/2048 bytes at offset 4296599552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296603648 ++read 2048/2048 bytes at offset 4296603648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296607744 ++read 2048/2048 bytes at offset 4296607744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296611840 ++read 2048/2048 bytes at offset 4296611840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296615936 ++read 2048/2048 bytes at offset 4296615936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296620032 ++read 2048/2048 bytes at offset 4296620032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296624128 ++read 2048/2048 bytes at offset 4296624128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296628224 ++read 2048/2048 bytes at offset 4296628224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296632320 ++read 2048/2048 bytes at offset 4296632320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296636416 ++read 2048/2048 bytes at offset 4296636416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296640512 ++read 2048/2048 bytes at offset 4296640512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296644608 ++read 2048/2048 bytes at offset 4296644608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296648704 ++read 2048/2048 bytes at offset 4296648704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296652800 ++read 2048/2048 bytes at offset 4296652800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296656896 ++read 2048/2048 bytes at offset 4296656896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296660992 ++read 2048/2048 bytes at offset 4296660992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296665088 ++read 2048/2048 bytes at offset 4296665088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296669184 ++read 2048/2048 bytes at offset 4296669184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296673280 ++read 2048/2048 bytes at offset 4296673280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296677376 ++read 2048/2048 bytes at offset 4296677376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296681472 ++read 2048/2048 bytes at offset 4296681472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296685568 ++read 2048/2048 bytes at offset 4296685568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296689664 ++read 2048/2048 bytes at offset 4296689664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296693760 ++read 2048/2048 bytes at offset 4296693760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296697856 ++read 2048/2048 bytes at offset 4296697856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296701952 ++read 2048/2048 bytes at offset 4296701952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296706048 ++read 2048/2048 bytes at offset 4296706048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296710144 ++read 2048/2048 bytes at offset 4296710144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296714240 ++read 2048/2048 bytes at offset 4296714240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296718336 ++read 2048/2048 bytes at offset 4296718336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296722432 ++read 2048/2048 bytes at offset 4296722432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296726528 ++read 2048/2048 bytes at offset 4296726528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296730624 ++read 2048/2048 bytes at offset 4296730624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296734720 ++read 2048/2048 bytes at offset 4296734720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296738816 ++read 2048/2048 bytes at offset 4296738816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296742912 ++read 2048/2048 bytes at offset 4296742912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296747008 ++read 2048/2048 bytes at offset 4296747008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296751104 ++read 2048/2048 bytes at offset 4296751104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296755200 ++read 2048/2048 bytes at offset 4296755200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296759296 ++read 2048/2048 bytes at offset 4296759296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296763392 ++read 2048/2048 bytes at offset 4296763392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296767488 ++read 2048/2048 bytes at offset 4296767488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296771584 ++read 2048/2048 bytes at offset 4296771584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296775680 ++read 2048/2048 bytes at offset 4296775680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296779776 ++read 2048/2048 bytes at offset 4296779776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296783872 ++read 2048/2048 bytes at offset 4296783872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296787968 ++read 2048/2048 bytes at offset 4296787968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296792064 ++read 2048/2048 bytes at offset 4296792064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296796160 ++read 2048/2048 bytes at offset 4296796160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296800256 ++read 2048/2048 bytes at offset 4296800256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296804352 ++read 2048/2048 bytes at offset 4296804352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296808448 ++read 2048/2048 bytes at offset 4296808448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296812544 ++read 2048/2048 bytes at offset 4296812544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296816640 ++read 2048/2048 bytes at offset 4296816640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296820736 ++read 2048/2048 bytes at offset 4296820736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296824832 ++read 2048/2048 bytes at offset 4296824832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296828928 ++read 2048/2048 bytes at offset 4296828928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296833024 ++read 2048/2048 bytes at offset 4296833024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296837120 ++read 2048/2048 bytes at offset 4296837120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296841216 ++read 2048/2048 bytes at offset 4296841216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296845312 ++read 2048/2048 bytes at offset 4296845312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296849408 ++read 2048/2048 bytes at offset 4296849408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296853504 ++read 2048/2048 bytes at offset 4296853504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296857600 ++read 2048/2048 bytes at offset 4296857600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296861696 ++read 2048/2048 bytes at offset 4296861696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296865792 ++read 2048/2048 bytes at offset 4296865792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296869888 ++read 2048/2048 bytes at offset 4296869888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296873984 ++read 2048/2048 bytes at offset 4296873984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296878080 ++read 2048/2048 bytes at offset 4296878080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296882176 ++read 2048/2048 bytes at offset 4296882176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296886272 ++read 2048/2048 bytes at offset 4296886272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296890368 ++read 2048/2048 bytes at offset 4296890368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296894464 ++read 2048/2048 bytes at offset 4296894464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296898560 ++read 2048/2048 bytes at offset 4296898560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296902656 ++read 2048/2048 bytes at offset 4296902656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296906752 ++read 2048/2048 bytes at offset 4296906752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296910848 ++read 2048/2048 bytes at offset 4296910848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296914944 ++read 2048/2048 bytes at offset 4296914944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296919040 ++read 2048/2048 bytes at offset 4296919040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296923136 ++read 2048/2048 bytes at offset 4296923136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296927232 ++read 2048/2048 bytes at offset 4296927232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296931328 ++read 2048/2048 bytes at offset 4296931328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296935424 ++read 2048/2048 bytes at offset 4296935424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296939520 ++read 2048/2048 bytes at offset 4296939520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296943616 ++read 2048/2048 bytes at offset 4296943616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296947712 ++read 2048/2048 bytes at offset 4296947712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296951808 ++read 2048/2048 bytes at offset 4296951808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296955904 ++read 2048/2048 bytes at offset 4296955904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296960000 ++read 2048/2048 bytes at offset 4296960000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296964096 ++read 2048/2048 bytes at offset 4296964096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296968192 ++read 2048/2048 bytes at offset 4296968192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296972288 ++read 2048/2048 bytes at offset 4296972288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296976384 ++read 2048/2048 bytes at offset 4296976384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296980480 ++read 2048/2048 bytes at offset 4296980480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296984576 ++read 2048/2048 bytes at offset 4296984576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296988672 ++read 2048/2048 bytes at offset 4296988672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296992768 ++read 2048/2048 bytes at offset 4296992768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296996864 ++read 2048/2048 bytes at offset 4296996864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297000960 ++read 2048/2048 bytes at offset 4297000960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297005056 ++read 2048/2048 bytes at offset 4297005056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297009152 ++read 2048/2048 bytes at offset 4297009152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297013248 ++read 2048/2048 bytes at offset 4297013248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297017344 ++read 2048/2048 bytes at offset 4297017344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297021440 ++read 2048/2048 bytes at offset 4297021440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297025536 ++read 2048/2048 bytes at offset 4297025536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297029632 ++read 2048/2048 bytes at offset 4297029632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297033728 ++read 2048/2048 bytes at offset 4297033728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297037824 ++read 2048/2048 bytes at offset 4297037824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297041920 ++read 2048/2048 bytes at offset 4297041920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297046016 ++read 2048/2048 bytes at offset 4297046016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297050112 ++read 2048/2048 bytes at offset 4297050112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297054208 ++read 2048/2048 bytes at offset 4297054208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297058304 ++read 2048/2048 bytes at offset 4297058304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297062400 ++read 2048/2048 bytes at offset 4297062400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> read 2048/2048 bytes at offset 4297064448 ++=== IO: pattern 0 ++read 2048/2048 bytes at offset 4297064448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297068544 ++read 2048/2048 bytes at offset 4297068544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297072640 ++read 2048/2048 bytes at offset 4297072640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297076736 ++read 2048/2048 bytes at offset 4297076736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297080832 ++read 2048/2048 bytes at offset 4297080832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297084928 ++read 2048/2048 bytes at offset 4297084928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297089024 ++read 2048/2048 bytes at offset 4297089024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297093120 ++read 2048/2048 bytes at offset 4297093120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297097216 ++read 2048/2048 bytes at offset 4297097216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297101312 ++read 2048/2048 bytes at offset 4297101312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297105408 ++read 2048/2048 bytes at offset 4297105408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297109504 ++read 2048/2048 bytes at offset 4297109504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297113600 ++read 2048/2048 bytes at offset 4297113600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297117696 ++read 2048/2048 bytes at offset 4297117696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297121792 ++read 2048/2048 bytes at offset 4297121792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297125888 ++read 2048/2048 bytes at offset 4297125888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297129984 ++read 2048/2048 bytes at offset 4297129984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297134080 ++read 2048/2048 bytes at offset 4297134080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297138176 ++read 2048/2048 bytes at offset 4297138176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297142272 ++read 2048/2048 bytes at offset 4297142272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297146368 ++read 2048/2048 bytes at offset 4297146368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297150464 ++read 2048/2048 bytes at offset 4297150464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297154560 ++read 2048/2048 bytes at offset 4297154560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297158656 ++read 2048/2048 bytes at offset 4297158656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297162752 ++read 2048/2048 bytes at offset 4297162752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297166848 ++read 2048/2048 bytes at offset 4297166848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297170944 ++read 2048/2048 bytes at offset 4297170944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297175040 ++read 2048/2048 bytes at offset 4297175040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297179136 ++read 2048/2048 bytes at offset 4297179136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297183232 ++read 2048/2048 bytes at offset 4297183232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297187328 ++read 2048/2048 bytes at offset 4297187328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297191424 ++read 2048/2048 bytes at offset 4297191424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297195520 ++read 2048/2048 bytes at offset 4297195520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297199616 ++read 2048/2048 bytes at offset 4297199616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297203712 ++read 2048/2048 bytes at offset 4297203712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297207808 ++read 2048/2048 bytes at offset 4297207808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297211904 ++read 2048/2048 bytes at offset 4297211904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297216000 ++read 2048/2048 bytes at offset 4297216000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297220096 ++read 2048/2048 bytes at offset 4297220096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297224192 ++read 2048/2048 bytes at offset 4297224192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297228288 ++read 2048/2048 bytes at offset 4297228288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297232384 ++read 2048/2048 bytes at offset 4297232384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297236480 ++read 2048/2048 bytes at offset 4297236480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297240576 ++read 2048/2048 bytes at offset 4297240576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297244672 ++read 2048/2048 bytes at offset 4297244672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297248768 ++read 2048/2048 bytes at offset 4297248768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297252864 ++read 2048/2048 bytes at offset 4297252864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297256960 ++read 2048/2048 bytes at offset 4297256960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297261056 ++read 2048/2048 bytes at offset 4297261056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297265152 ++read 2048/2048 bytes at offset 4297265152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297269248 ++read 2048/2048 bytes at offset 4297269248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297273344 ++read 2048/2048 bytes at offset 4297273344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297277440 ++read 2048/2048 bytes at offset 4297277440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297281536 ++read 2048/2048 bytes at offset 4297281536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297285632 ++read 2048/2048 bytes at offset 4297285632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297289728 ++read 2048/2048 bytes at offset 4297289728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297293824 ++read 2048/2048 bytes at offset 4297293824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297297920 ++read 2048/2048 bytes at offset 4297297920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297302016 ++read 2048/2048 bytes at offset 4297302016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297306112 ++read 2048/2048 bytes at offset 4297306112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297310208 ++read 2048/2048 bytes at offset 4297310208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297314304 ++read 2048/2048 bytes at offset 4297314304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297318400 ++read 2048/2048 bytes at offset 4297318400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297322496 ++read 2048/2048 bytes at offset 4297322496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297326592 ++read 2048/2048 bytes at offset 4297326592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297330688 ++read 2048/2048 bytes at offset 4297330688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297334784 ++read 2048/2048 bytes at offset 4297334784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297338880 ++read 2048/2048 bytes at offset 4297338880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297342976 ++read 2048/2048 bytes at offset 4297342976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297347072 ++read 2048/2048 bytes at offset 4297347072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297351168 ++read 2048/2048 bytes at offset 4297351168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297355264 ++read 2048/2048 bytes at offset 4297355264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297359360 ++read 2048/2048 bytes at offset 4297359360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297363456 ++read 2048/2048 bytes at offset 4297363456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297367552 ++read 2048/2048 bytes at offset 4297367552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297371648 ++read 2048/2048 bytes at offset 4297371648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297375744 ++read 2048/2048 bytes at offset 4297375744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297379840 ++read 2048/2048 bytes at offset 4297379840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297383936 ++read 2048/2048 bytes at offset 4297383936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297388032 ++read 2048/2048 bytes at offset 4297388032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297392128 ++read 2048/2048 bytes at offset 4297392128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297396224 ++read 2048/2048 bytes at offset 4297396224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297400320 ++read 2048/2048 bytes at offset 4297400320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297404416 ++read 2048/2048 bytes at offset 4297404416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297408512 ++read 2048/2048 bytes at offset 4297408512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297412608 ++read 2048/2048 bytes at offset 4297412608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297416704 ++read 2048/2048 bytes at offset 4297416704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297420800 ++read 2048/2048 bytes at offset 4297420800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297424896 ++read 2048/2048 bytes at offset 4297424896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297428992 ++read 2048/2048 bytes at offset 4297428992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297433088 ++read 2048/2048 bytes at offset 4297433088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297437184 ++read 2048/2048 bytes at offset 4297437184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297441280 ++read 2048/2048 bytes at offset 4297441280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297445376 ++read 2048/2048 bytes at offset 4297445376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297449472 ++read 2048/2048 bytes at offset 4297449472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297453568 ++read 2048/2048 bytes at offset 4297453568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297457664 ++read 2048/2048 bytes at offset 4297457664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297461760 ++read 2048/2048 bytes at offset 4297461760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297465856 ++read 2048/2048 bytes at offset 4297465856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297469952 ++read 2048/2048 bytes at offset 4297469952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297474048 ++read 2048/2048 bytes at offset 4297474048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297478144 ++read 2048/2048 bytes at offset 4297478144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297482240 ++read 2048/2048 bytes at offset 4297482240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297486336 ++read 2048/2048 bytes at offset 4297486336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297490432 ++read 2048/2048 bytes at offset 4297490432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297494528 ++read 2048/2048 bytes at offset 4297494528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297498624 ++read 2048/2048 bytes at offset 4297498624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297502720 ++read 2048/2048 bytes at offset 4297502720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297506816 ++read 2048/2048 bytes at offset 4297506816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297510912 ++read 2048/2048 bytes at offset 4297510912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297515008 ++read 2048/2048 bytes at offset 4297515008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297519104 ++read 2048/2048 bytes at offset 4297519104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297523200 ++read 2048/2048 bytes at offset 4297523200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297527296 ++read 2048/2048 bytes at offset 4297527296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297531392 ++read 2048/2048 bytes at offset 4297531392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297535488 ++read 2048/2048 bytes at offset 4297535488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297539584 ++read 2048/2048 bytes at offset 4297539584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297543680 ++read 2048/2048 bytes at offset 4297543680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297547776 ++read 2048/2048 bytes at offset 4297547776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297551872 ++read 2048/2048 bytes at offset 4297551872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297555968 ++read 2048/2048 bytes at offset 4297555968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297560064 ++read 2048/2048 bytes at offset 4297560064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297564160 ++read 2048/2048 bytes at offset 4297564160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297568256 ++read 2048/2048 bytes at offset 4297568256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297572352 ++read 2048/2048 bytes at offset 4297572352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297576448 ++read 2048/2048 bytes at offset 4297576448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297580544 ++read 2048/2048 bytes at offset 4297580544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297584640 ++read 2048/2048 bytes at offset 4297584640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297588736 ++read 2048/2048 bytes at offset 4297588736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297592832 ++read 2048/2048 bytes at offset 4297592832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297596928 ++read 2048/2048 bytes at offset 4297596928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297601024 ++read 2048/2048 bytes at offset 4297601024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297605120 ++read 2048/2048 bytes at offset 4297605120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297609216 ++read 2048/2048 bytes at offset 4297609216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297613312 ++read 2048/2048 bytes at offset 4297613312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297617408 ++read 2048/2048 bytes at offset 4297617408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297621504 ++read 2048/2048 bytes at offset 4297621504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297625600 ++read 2048/2048 bytes at offset 4297625600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297629696 ++read 2048/2048 bytes at offset 4297629696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297633792 ++read 2048/2048 bytes at offset 4297633792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297637888 ++read 2048/2048 bytes at offset 4297637888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297641984 ++read 2048/2048 bytes at offset 4297641984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297646080 ++read 2048/2048 bytes at offset 4297646080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297650176 ++read 2048/2048 bytes at offset 4297650176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297654272 ++read 2048/2048 bytes at offset 4297654272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297658368 ++read 2048/2048 bytes at offset 4297658368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297662464 ++read 2048/2048 bytes at offset 4297662464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297666560 ++read 2048/2048 bytes at offset 4297666560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297670656 ++read 2048/2048 bytes at offset 4297670656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297674752 ++read 2048/2048 bytes at offset 4297674752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297678848 ++read 2048/2048 bytes at offset 4297678848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297682944 ++read 2048/2048 bytes at offset 4297682944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297687040 ++read 2048/2048 bytes at offset 4297687040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297691136 ++read 2048/2048 bytes at offset 4297691136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297695232 ++read 2048/2048 bytes at offset 4297695232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297699328 ++read 2048/2048 bytes at offset 4297699328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297703424 ++read 2048/2048 bytes at offset 4297703424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297707520 ++read 2048/2048 bytes at offset 4297707520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297711616 ++read 2048/2048 bytes at offset 4297711616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297715712 ++read 2048/2048 bytes at offset 4297715712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297719808 ++read 2048/2048 bytes at offset 4297719808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297723904 ++read 2048/2048 bytes at offset 4297723904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297728000 ++read 2048/2048 bytes at offset 4297728000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297732096 ++read 2048/2048 bytes at offset 4297732096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297736192 ++read 2048/2048 bytes at offset 4297736192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297740288 ++read 2048/2048 bytes at offset 4297740288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297744384 ++read 2048/2048 bytes at offset 4297744384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297748480 ++read 2048/2048 bytes at offset 4297748480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297752576 ++read 2048/2048 bytes at offset 4297752576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297756672 ++read 2048/2048 bytes at offset 4297756672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297760768 ++read 2048/2048 bytes at offset 4297760768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297764864 ++read 2048/2048 bytes at offset 4297764864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297768960 ++read 2048/2048 bytes at offset 4297768960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297773056 ++read 2048/2048 bytes at offset 4297773056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297777152 ++read 2048/2048 bytes at offset 4297777152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297781248 ++read 2048/2048 bytes at offset 4297781248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297785344 ++read 2048/2048 bytes at offset 4297785344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297789440 ++read 2048/2048 bytes at offset 4297789440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297793536 ++read 2048/2048 bytes at offset 4297793536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297797632 ++read 2048/2048 bytes at offset 4297797632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297801728 ++read 2048/2048 bytes at offset 4297801728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297805824 ++read 2048/2048 bytes at offset 4297805824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297809920 ++read 2048/2048 bytes at offset 4297809920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297814016 ++read 2048/2048 bytes at offset 4297814016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297818112 ++read 2048/2048 bytes at offset 4297818112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297822208 ++read 2048/2048 bytes at offset 4297822208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297826304 ++read 2048/2048 bytes at offset 4297826304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297830400 ++read 2048/2048 bytes at offset 4297830400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297834496 ++read 2048/2048 bytes at offset 4297834496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297838592 ++read 2048/2048 bytes at offset 4297838592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297842688 ++read 2048/2048 bytes at offset 4297842688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297846784 ++read 2048/2048 bytes at offset 4297846784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297850880 ++read 2048/2048 bytes at offset 4297850880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297854976 ++read 2048/2048 bytes at offset 4297854976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297859072 ++read 2048/2048 bytes at offset 4297859072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297863168 ++read 2048/2048 bytes at offset 4297863168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297867264 ++read 2048/2048 bytes at offset 4297867264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297871360 ++read 2048/2048 bytes at offset 4297871360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297875456 ++read 2048/2048 bytes at offset 4297875456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297879552 ++read 2048/2048 bytes at offset 4297879552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297883648 ++read 2048/2048 bytes at offset 4297883648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297887744 ++read 2048/2048 bytes at offset 4297887744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297891840 ++read 2048/2048 bytes at offset 4297891840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297895936 ++read 2048/2048 bytes at offset 4297895936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297900032 ++read 2048/2048 bytes at offset 4297900032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297904128 ++read 2048/2048 bytes at offset 4297904128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297908224 ++read 2048/2048 bytes at offset 4297908224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297912320 ++read 2048/2048 bytes at offset 4297912320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297916416 ++read 2048/2048 bytes at offset 4297916416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297920512 ++read 2048/2048 bytes at offset 4297920512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297924608 ++read 2048/2048 bytes at offset 4297924608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297928704 ++read 2048/2048 bytes at offset 4297928704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297932800 ++read 2048/2048 bytes at offset 4297932800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297936896 ++read 2048/2048 bytes at offset 4297936896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297940992 ++read 2048/2048 bytes at offset 4297940992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297945088 ++read 2048/2048 bytes at offset 4297945088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297949184 ++read 2048/2048 bytes at offset 4297949184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297953280 ++read 2048/2048 bytes at offset 4297953280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297957376 ++read 2048/2048 bytes at offset 4297957376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297961472 ++read 2048/2048 bytes at offset 4297961472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297965568 ++read 2048/2048 bytes at offset 4297965568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297969664 ++read 2048/2048 bytes at offset 4297969664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297973760 ++read 2048/2048 bytes at offset 4297973760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297977856 ++read 2048/2048 bytes at offset 4297977856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297981952 ++read 2048/2048 bytes at offset 4297981952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297986048 ++read 2048/2048 bytes at offset 4297986048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297990144 ++read 2048/2048 bytes at offset 4297990144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297994240 ++read 2048/2048 bytes at offset 4297994240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297998336 ++read 2048/2048 bytes at offset 4297998336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298002432 ++read 2048/2048 bytes at offset 4298002432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298006528 ++read 2048/2048 bytes at offset 4298006528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298010624 ++read 2048/2048 bytes at offset 4298010624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298014720 ++read 2048/2048 bytes at offset 4298014720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298018816 ++read 2048/2048 bytes at offset 4298018816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298022912 ++read 2048/2048 bytes at offset 4298022912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298027008 ++read 2048/2048 bytes at offset 4298027008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298031104 ++read 2048/2048 bytes at offset 4298031104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298035200 ++read 2048/2048 bytes at offset 4298035200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298039296 ++read 2048/2048 bytes at offset 4298039296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298043392 ++read 2048/2048 bytes at offset 4298043392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298047488 ++read 2048/2048 bytes at offset 4298047488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298051584 ++read 2048/2048 bytes at offset 4298051584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298055680 ++read 2048/2048 bytes at offset 4298055680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298059776 ++read 2048/2048 bytes at offset 4298059776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298063872 ++read 2048/2048 bytes at offset 4298063872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298067968 ++read 2048/2048 bytes at offset 4298067968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298072064 ++read 2048/2048 bytes at offset 4298072064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298076160 ++read 2048/2048 bytes at offset 4298076160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298080256 ++read 2048/2048 bytes at offset 4298080256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298084352 ++read 2048/2048 bytes at offset 4298084352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298088448 ++read 2048/2048 bytes at offset 4298088448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298092544 ++read 2048/2048 bytes at offset 4298092544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298096640 ++read 2048/2048 bytes at offset 4298096640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298100736 ++read 2048/2048 bytes at offset 4298100736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298104832 ++read 2048/2048 bytes at offset 4298104832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298108928 ++read 2048/2048 bytes at offset 4298108928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 2 +-qemu-io> read 2048/2048 bytes at offset 4298114048 ++=== IO: pattern 2 ++read 2048/2048 bytes at offset 4298114048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298118144 ++read 2048/2048 bytes at offset 4298118144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298122240 ++read 2048/2048 bytes at offset 4298122240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298126336 ++read 2048/2048 bytes at offset 4298126336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298130432 ++read 2048/2048 bytes at offset 4298130432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298134528 ++read 2048/2048 bytes at offset 4298134528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298138624 ++read 2048/2048 bytes at offset 4298138624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298142720 ++read 2048/2048 bytes at offset 4298142720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298146816 ++read 2048/2048 bytes at offset 4298146816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298150912 ++read 2048/2048 bytes at offset 4298150912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298155008 ++read 2048/2048 bytes at offset 4298155008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298159104 ++read 2048/2048 bytes at offset 4298159104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298163200 ++read 2048/2048 bytes at offset 4298163200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298167296 ++read 2048/2048 bytes at offset 4298167296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298171392 ++read 2048/2048 bytes at offset 4298171392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298175488 ++read 2048/2048 bytes at offset 4298175488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298179584 ++read 2048/2048 bytes at offset 4298179584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298183680 ++read 2048/2048 bytes at offset 4298183680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298187776 ++read 2048/2048 bytes at offset 4298187776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298191872 ++read 2048/2048 bytes at offset 4298191872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298195968 ++read 2048/2048 bytes at offset 4298195968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298200064 ++read 2048/2048 bytes at offset 4298200064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298204160 ++read 2048/2048 bytes at offset 4298204160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298208256 ++read 2048/2048 bytes at offset 4298208256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298212352 ++read 2048/2048 bytes at offset 4298212352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298216448 ++read 2048/2048 bytes at offset 4298216448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298220544 ++read 2048/2048 bytes at offset 4298220544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298224640 ++read 2048/2048 bytes at offset 4298224640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298228736 ++read 2048/2048 bytes at offset 4298228736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298232832 ++read 2048/2048 bytes at offset 4298232832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298236928 ++read 2048/2048 bytes at offset 4298236928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298241024 ++read 2048/2048 bytes at offset 4298241024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298245120 ++read 2048/2048 bytes at offset 4298245120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298249216 ++read 2048/2048 bytes at offset 4298249216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298253312 ++read 2048/2048 bytes at offset 4298253312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298257408 ++read 2048/2048 bytes at offset 4298257408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298261504 ++read 2048/2048 bytes at offset 4298261504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298265600 ++read 2048/2048 bytes at offset 4298265600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298269696 ++read 2048/2048 bytes at offset 4298269696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298273792 ++read 2048/2048 bytes at offset 4298273792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298277888 ++read 2048/2048 bytes at offset 4298277888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298281984 ++read 2048/2048 bytes at offset 4298281984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298286080 ++read 2048/2048 bytes at offset 4298286080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298290176 ++read 2048/2048 bytes at offset 4298290176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298294272 ++read 2048/2048 bytes at offset 4298294272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298298368 ++read 2048/2048 bytes at offset 4298298368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298302464 ++read 2048/2048 bytes at offset 4298302464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298306560 ++read 2048/2048 bytes at offset 4298306560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298310656 ++read 2048/2048 bytes at offset 4298310656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298314752 ++read 2048/2048 bytes at offset 4298314752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298318848 ++read 2048/2048 bytes at offset 4298318848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298322944 ++read 2048/2048 bytes at offset 4298322944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298327040 ++read 2048/2048 bytes at offset 4298327040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298331136 ++read 2048/2048 bytes at offset 4298331136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298335232 ++read 2048/2048 bytes at offset 4298335232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298339328 ++read 2048/2048 bytes at offset 4298339328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298343424 ++read 2048/2048 bytes at offset 4298343424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298347520 ++read 2048/2048 bytes at offset 4298347520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298351616 ++read 2048/2048 bytes at offset 4298351616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298355712 ++read 2048/2048 bytes at offset 4298355712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298359808 ++read 2048/2048 bytes at offset 4298359808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298363904 ++read 2048/2048 bytes at offset 4298363904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298368000 ++read 2048/2048 bytes at offset 4298368000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298372096 ++read 2048/2048 bytes at offset 4298372096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298376192 ++read 2048/2048 bytes at offset 4298376192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298380288 ++read 2048/2048 bytes at offset 4298380288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298384384 ++read 2048/2048 bytes at offset 4298384384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298388480 ++read 2048/2048 bytes at offset 4298388480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298392576 ++read 2048/2048 bytes at offset 4298392576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298396672 ++read 2048/2048 bytes at offset 4298396672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298400768 ++read 2048/2048 bytes at offset 4298400768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298404864 ++read 2048/2048 bytes at offset 4298404864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298408960 ++read 2048/2048 bytes at offset 4298408960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298413056 ++read 2048/2048 bytes at offset 4298413056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298417152 ++read 2048/2048 bytes at offset 4298417152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298421248 ++read 2048/2048 bytes at offset 4298421248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298425344 ++read 2048/2048 bytes at offset 4298425344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298429440 ++read 2048/2048 bytes at offset 4298429440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298433536 ++read 2048/2048 bytes at offset 4298433536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298437632 ++read 2048/2048 bytes at offset 4298437632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298441728 ++read 2048/2048 bytes at offset 4298441728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298445824 ++read 2048/2048 bytes at offset 4298445824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298449920 ++read 2048/2048 bytes at offset 4298449920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298454016 ++read 2048/2048 bytes at offset 4298454016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298458112 ++read 2048/2048 bytes at offset 4298458112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298462208 ++read 2048/2048 bytes at offset 4298462208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298466304 ++read 2048/2048 bytes at offset 4298466304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298470400 ++read 2048/2048 bytes at offset 4298470400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298474496 ++read 2048/2048 bytes at offset 4298474496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298478592 ++read 2048/2048 bytes at offset 4298478592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298482688 ++read 2048/2048 bytes at offset 4298482688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298486784 ++read 2048/2048 bytes at offset 4298486784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298490880 ++read 2048/2048 bytes at offset 4298490880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298494976 ++read 2048/2048 bytes at offset 4298494976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298499072 ++read 2048/2048 bytes at offset 4298499072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298503168 ++read 2048/2048 bytes at offset 4298503168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298507264 ++read 2048/2048 bytes at offset 4298507264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298511360 ++read 2048/2048 bytes at offset 4298511360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298515456 ++read 2048/2048 bytes at offset 4298515456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298519552 ++read 2048/2048 bytes at offset 4298519552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298523648 ++read 2048/2048 bytes at offset 4298523648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298527744 ++read 2048/2048 bytes at offset 4298527744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298531840 ++read 2048/2048 bytes at offset 4298531840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298535936 ++read 2048/2048 bytes at offset 4298535936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298540032 ++read 2048/2048 bytes at offset 4298540032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298544128 ++read 2048/2048 bytes at offset 4298544128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298548224 ++read 2048/2048 bytes at offset 4298548224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298552320 ++read 2048/2048 bytes at offset 4298552320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298556416 ++read 2048/2048 bytes at offset 4298556416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298560512 ++read 2048/2048 bytes at offset 4298560512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298564608 ++read 2048/2048 bytes at offset 4298564608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298568704 ++read 2048/2048 bytes at offset 4298568704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298572800 ++read 2048/2048 bytes at offset 4298572800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298576896 ++read 2048/2048 bytes at offset 4298576896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298580992 ++read 2048/2048 bytes at offset 4298580992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298585088 ++read 2048/2048 bytes at offset 4298585088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298589184 ++read 2048/2048 bytes at offset 4298589184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298593280 ++read 2048/2048 bytes at offset 4298593280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298597376 ++read 2048/2048 bytes at offset 4298597376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298601472 ++read 2048/2048 bytes at offset 4298601472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298605568 ++read 2048/2048 bytes at offset 4298605568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298609664 ++read 2048/2048 bytes at offset 4298609664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298613760 ++read 2048/2048 bytes at offset 4298613760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298617856 ++read 2048/2048 bytes at offset 4298617856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298621952 ++read 2048/2048 bytes at offset 4298621952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298626048 ++read 2048/2048 bytes at offset 4298626048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298630144 ++read 2048/2048 bytes at offset 4298630144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298634240 ++read 2048/2048 bytes at offset 4298634240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298638336 ++read 2048/2048 bytes at offset 4298638336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298642432 ++read 2048/2048 bytes at offset 4298642432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298646528 ++read 2048/2048 bytes at offset 4298646528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298650624 ++read 2048/2048 bytes at offset 4298650624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298654720 ++read 2048/2048 bytes at offset 4298654720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298658816 ++read 2048/2048 bytes at offset 4298658816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298662912 ++read 2048/2048 bytes at offset 4298662912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298667008 ++read 2048/2048 bytes at offset 4298667008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298671104 ++read 2048/2048 bytes at offset 4298671104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298675200 ++read 2048/2048 bytes at offset 4298675200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298679296 ++read 2048/2048 bytes at offset 4298679296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298683392 ++read 2048/2048 bytes at offset 4298683392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298687488 ++read 2048/2048 bytes at offset 4298687488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298691584 ++read 2048/2048 bytes at offset 4298691584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298695680 ++read 2048/2048 bytes at offset 4298695680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298699776 ++read 2048/2048 bytes at offset 4298699776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298703872 ++read 2048/2048 bytes at offset 4298703872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298707968 ++read 2048/2048 bytes at offset 4298707968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298712064 ++read 2048/2048 bytes at offset 4298712064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298716160 ++read 2048/2048 bytes at offset 4298716160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298720256 ++read 2048/2048 bytes at offset 4298720256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298724352 ++read 2048/2048 bytes at offset 4298724352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298728448 ++read 2048/2048 bytes at offset 4298728448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298732544 ++read 2048/2048 bytes at offset 4298732544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298736640 ++read 2048/2048 bytes at offset 4298736640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298740736 ++read 2048/2048 bytes at offset 4298740736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298744832 ++read 2048/2048 bytes at offset 4298744832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298748928 ++read 2048/2048 bytes at offset 4298748928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298753024 ++read 2048/2048 bytes at offset 4298753024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298757120 ++read 2048/2048 bytes at offset 4298757120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298761216 ++read 2048/2048 bytes at offset 4298761216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298765312 ++read 2048/2048 bytes at offset 4298765312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298769408 ++read 2048/2048 bytes at offset 4298769408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298773504 ++read 2048/2048 bytes at offset 4298773504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298777600 ++read 2048/2048 bytes at offset 4298777600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298781696 ++read 2048/2048 bytes at offset 4298781696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298785792 ++read 2048/2048 bytes at offset 4298785792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298789888 ++read 2048/2048 bytes at offset 4298789888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298793984 ++read 2048/2048 bytes at offset 4298793984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298798080 ++read 2048/2048 bytes at offset 4298798080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298802176 ++read 2048/2048 bytes at offset 4298802176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298806272 ++read 2048/2048 bytes at offset 4298806272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298810368 ++read 2048/2048 bytes at offset 4298810368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298814464 ++read 2048/2048 bytes at offset 4298814464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298818560 ++read 2048/2048 bytes at offset 4298818560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298822656 ++read 2048/2048 bytes at offset 4298822656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298826752 ++read 2048/2048 bytes at offset 4298826752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298830848 ++read 2048/2048 bytes at offset 4298830848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298834944 ++read 2048/2048 bytes at offset 4298834944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298839040 ++read 2048/2048 bytes at offset 4298839040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298843136 ++read 2048/2048 bytes at offset 4298843136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298847232 ++read 2048/2048 bytes at offset 4298847232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298851328 ++read 2048/2048 bytes at offset 4298851328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298855424 ++read 2048/2048 bytes at offset 4298855424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298859520 ++read 2048/2048 bytes at offset 4298859520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298863616 ++read 2048/2048 bytes at offset 4298863616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298867712 ++read 2048/2048 bytes at offset 4298867712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298871808 ++read 2048/2048 bytes at offset 4298871808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298875904 ++read 2048/2048 bytes at offset 4298875904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298880000 ++read 2048/2048 bytes at offset 4298880000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298884096 ++read 2048/2048 bytes at offset 4298884096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298888192 ++read 2048/2048 bytes at offset 4298888192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298892288 ++read 2048/2048 bytes at offset 4298892288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298896384 ++read 2048/2048 bytes at offset 4298896384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298900480 ++read 2048/2048 bytes at offset 4298900480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298904576 ++read 2048/2048 bytes at offset 4298904576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298908672 ++read 2048/2048 bytes at offset 4298908672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298912768 ++read 2048/2048 bytes at offset 4298912768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298916864 ++read 2048/2048 bytes at offset 4298916864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298920960 ++read 2048/2048 bytes at offset 4298920960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298925056 ++read 2048/2048 bytes at offset 4298925056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298929152 ++read 2048/2048 bytes at offset 4298929152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298933248 ++read 2048/2048 bytes at offset 4298933248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298937344 ++read 2048/2048 bytes at offset 4298937344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298941440 ++read 2048/2048 bytes at offset 4298941440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298945536 ++read 2048/2048 bytes at offset 4298945536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298949632 ++read 2048/2048 bytes at offset 4298949632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298953728 ++read 2048/2048 bytes at offset 4298953728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298957824 ++read 2048/2048 bytes at offset 4298957824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298961920 ++read 2048/2048 bytes at offset 4298961920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298966016 ++read 2048/2048 bytes at offset 4298966016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298970112 ++read 2048/2048 bytes at offset 4298970112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298974208 ++read 2048/2048 bytes at offset 4298974208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298978304 ++read 2048/2048 bytes at offset 4298978304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298982400 ++read 2048/2048 bytes at offset 4298982400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298986496 ++read 2048/2048 bytes at offset 4298986496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298990592 ++read 2048/2048 bytes at offset 4298990592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298994688 ++read 2048/2048 bytes at offset 4298994688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298998784 ++read 2048/2048 bytes at offset 4298998784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299002880 ++read 2048/2048 bytes at offset 4299002880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299006976 ++read 2048/2048 bytes at offset 4299006976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299011072 ++read 2048/2048 bytes at offset 4299011072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299015168 ++read 2048/2048 bytes at offset 4299015168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299019264 ++read 2048/2048 bytes at offset 4299019264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299023360 ++read 2048/2048 bytes at offset 4299023360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299027456 ++read 2048/2048 bytes at offset 4299027456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299031552 ++read 2048/2048 bytes at offset 4299031552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299035648 ++read 2048/2048 bytes at offset 4299035648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299039744 ++read 2048/2048 bytes at offset 4299039744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299043840 ++read 2048/2048 bytes at offset 4299043840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299047936 ++read 2048/2048 bytes at offset 4299047936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299052032 ++read 2048/2048 bytes at offset 4299052032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299056128 ++read 2048/2048 bytes at offset 4299056128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299060224 ++read 2048/2048 bytes at offset 4299060224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299064320 ++read 2048/2048 bytes at offset 4299064320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299068416 ++read 2048/2048 bytes at offset 4299068416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299072512 ++read 2048/2048 bytes at offset 4299072512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299076608 ++read 2048/2048 bytes at offset 4299076608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299080704 ++read 2048/2048 bytes at offset 4299080704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299084800 ++read 2048/2048 bytes at offset 4299084800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299088896 ++read 2048/2048 bytes at offset 4299088896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299092992 ++read 2048/2048 bytes at offset 4299092992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299097088 ++read 2048/2048 bytes at offset 4299097088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299101184 ++read 2048/2048 bytes at offset 4299101184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299105280 ++read 2048/2048 bytes at offset 4299105280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299109376 ++read 2048/2048 bytes at offset 4299109376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299113472 ++read 2048/2048 bytes at offset 4299113472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299117568 ++read 2048/2048 bytes at offset 4299117568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299121664 ++read 2048/2048 bytes at offset 4299121664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299125760 ++read 2048/2048 bytes at offset 4299125760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299129856 ++read 2048/2048 bytes at offset 4299129856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299133952 ++read 2048/2048 bytes at offset 4299133952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299138048 ++read 2048/2048 bytes at offset 4299138048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299142144 ++read 2048/2048 bytes at offset 4299142144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299146240 ++read 2048/2048 bytes at offset 4299146240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299150336 ++read 2048/2048 bytes at offset 4299150336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299154432 ++read 2048/2048 bytes at offset 4299154432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299158528 ++read 2048/2048 bytes at offset 4299158528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 4 +-qemu-io> read 8192/8192 bytes at offset 4299163648 ++=== IO: pattern 4 ++read 8192/8192 bytes at offset 4299163648 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299175936 ++read 8192/8192 bytes at offset 4299175936 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299188224 ++read 8192/8192 bytes at offset 4299188224 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299200512 ++read 8192/8192 bytes at offset 4299200512 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299212800 ++read 8192/8192 bytes at offset 4299212800 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299225088 ++read 8192/8192 bytes at offset 4299225088 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299237376 ++read 8192/8192 bytes at offset 4299237376 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299249664 ++read 8192/8192 bytes at offset 4299249664 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299261952 ++read 8192/8192 bytes at offset 4299261952 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299274240 ++read 8192/8192 bytes at offset 4299274240 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299286528 ++read 8192/8192 bytes at offset 4299286528 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299298816 ++read 8192/8192 bytes at offset 4299298816 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299311104 ++read 8192/8192 bytes at offset 4299311104 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299323392 ++read 8192/8192 bytes at offset 4299323392 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299335680 ++read 8192/8192 bytes at offset 4299335680 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299347968 ++read 8192/8192 bytes at offset 4299347968 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299360256 ++read 8192/8192 bytes at offset 4299360256 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299372544 ++read 8192/8192 bytes at offset 4299372544 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299384832 ++read 8192/8192 bytes at offset 4299384832 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299397120 ++read 8192/8192 bytes at offset 4299397120 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299409408 ++read 8192/8192 bytes at offset 4299409408 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299421696 ++read 8192/8192 bytes at offset 4299421696 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299433984 ++read 8192/8192 bytes at offset 4299433984 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299446272 ++read 8192/8192 bytes at offset 4299446272 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299458560 ++read 8192/8192 bytes at offset 4299458560 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299470848 ++read 8192/8192 bytes at offset 4299470848 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299483136 ++read 8192/8192 bytes at offset 4299483136 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299495424 ++read 8192/8192 bytes at offset 4299495424 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299507712 ++read 8192/8192 bytes at offset 4299507712 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299520000 ++read 8192/8192 bytes at offset 4299520000 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299532288 ++read 8192/8192 bytes at offset 4299532288 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299544576 ++read 8192/8192 bytes at offset 4299544576 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299556864 ++read 8192/8192 bytes at offset 4299556864 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299569152 ++read 8192/8192 bytes at offset 4299569152 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299581440 ++read 8192/8192 bytes at offset 4299581440 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299593728 ++read 8192/8192 bytes at offset 4299593728 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299606016 ++read 8192/8192 bytes at offset 4299606016 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299618304 ++read 8192/8192 bytes at offset 4299618304 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299630592 ++read 8192/8192 bytes at offset 4299630592 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299642880 ++read 8192/8192 bytes at offset 4299642880 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299655168 ++read 8192/8192 bytes at offset 4299655168 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299667456 ++read 8192/8192 bytes at offset 4299667456 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299679744 ++read 8192/8192 bytes at offset 4299679744 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299692032 ++read 8192/8192 bytes at offset 4299692032 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299704320 ++read 8192/8192 bytes at offset 4299704320 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299716608 ++read 8192/8192 bytes at offset 4299716608 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299728896 ++read 8192/8192 bytes at offset 4299728896 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299741184 ++read 8192/8192 bytes at offset 4299741184 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299753472 ++read 8192/8192 bytes at offset 4299753472 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299765760 ++read 8192/8192 bytes at offset 4299765760 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299778048 ++read 8192/8192 bytes at offset 4299778048 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299790336 ++read 8192/8192 bytes at offset 4299790336 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299802624 ++read 8192/8192 bytes at offset 4299802624 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299814912 ++read 8192/8192 bytes at offset 4299814912 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299827200 ++read 8192/8192 bytes at offset 4299827200 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299839488 ++read 8192/8192 bytes at offset 4299839488 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299851776 ++read 8192/8192 bytes at offset 4299851776 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299864064 ++read 8192/8192 bytes at offset 4299864064 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299876352 ++read 8192/8192 bytes at offset 4299876352 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299888640 ++read 8192/8192 bytes at offset 4299888640 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299900928 ++read 8192/8192 bytes at offset 4299900928 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299913216 ++read 8192/8192 bytes at offset 4299913216 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299925504 ++read 8192/8192 bytes at offset 4299925504 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299937792 ++read 8192/8192 bytes at offset 4299937792 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 244 +-qemu-io> read 12288/12288 bytes at offset 4301252608 ++=== IO: pattern 244 ++read 12288/12288 bytes at offset 4301252608 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4303351808 ++read 12288/12288 bytes at offset 4303351808 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4305451008 ++read 12288/12288 bytes at offset 4305451008 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4307550208 ++read 12288/12288 bytes at offset 4307550208 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4309649408 ++read 12288/12288 bytes at offset 4309649408 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4311748608 ++read 12288/12288 bytes at offset 4311748608 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4313847808 ++read 12288/12288 bytes at offset 4313847808 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4315947008 ++read 12288/12288 bytes at offset 4315947008 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> No errors were found on the image. ++No errors were found on the image. + Testing compressed image with odd offsets + + With offset 512: + === IO: pattern 1 +-qemu-io> wrote 4096/4096 bytes at offset 512 ++wrote 4096/4096 bytes at offset 512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4608 ++wrote 4096/4096 bytes at offset 4608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8704 ++wrote 4096/4096 bytes at offset 8704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 12800 ++wrote 4096/4096 bytes at offset 12800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 16896 ++wrote 4096/4096 bytes at offset 16896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 20992 ++wrote 4096/4096 bytes at offset 20992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 25088 ++wrote 4096/4096 bytes at offset 25088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 29184 ++wrote 4096/4096 bytes at offset 29184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 33280 ++wrote 4096/4096 bytes at offset 33280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 37376 ++wrote 4096/4096 bytes at offset 37376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 41472 ++wrote 4096/4096 bytes at offset 41472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 45568 ++wrote 4096/4096 bytes at offset 45568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 49664 ++wrote 4096/4096 bytes at offset 49664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 53760 ++wrote 4096/4096 bytes at offset 53760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 57856 ++wrote 4096/4096 bytes at offset 57856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 61952 ++wrote 4096/4096 bytes at offset 61952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 66048 ++wrote 4096/4096 bytes at offset 66048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 70144 ++wrote 4096/4096 bytes at offset 70144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 74240 ++wrote 4096/4096 bytes at offset 74240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 78336 ++wrote 4096/4096 bytes at offset 78336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 82432 ++wrote 4096/4096 bytes at offset 82432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 86528 ++wrote 4096/4096 bytes at offset 86528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 90624 ++wrote 4096/4096 bytes at offset 90624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 94720 ++wrote 4096/4096 bytes at offset 94720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 98816 ++wrote 4096/4096 bytes at offset 98816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 102912 ++wrote 4096/4096 bytes at offset 102912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 107008 ++wrote 4096/4096 bytes at offset 107008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 111104 ++wrote 4096/4096 bytes at offset 111104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 115200 ++wrote 4096/4096 bytes at offset 115200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 119296 ++wrote 4096/4096 bytes at offset 119296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 123392 ++wrote 4096/4096 bytes at offset 123392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 127488 ++wrote 4096/4096 bytes at offset 127488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 131584 ++wrote 4096/4096 bytes at offset 131584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 135680 ++wrote 4096/4096 bytes at offset 135680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 139776 ++wrote 4096/4096 bytes at offset 139776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 143872 ++wrote 4096/4096 bytes at offset 143872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 147968 ++wrote 4096/4096 bytes at offset 147968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 152064 ++wrote 4096/4096 bytes at offset 152064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 156160 ++wrote 4096/4096 bytes at offset 156160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 160256 ++wrote 4096/4096 bytes at offset 160256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 164352 ++wrote 4096/4096 bytes at offset 164352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 168448 ++wrote 4096/4096 bytes at offset 168448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 172544 ++wrote 4096/4096 bytes at offset 172544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 176640 ++wrote 4096/4096 bytes at offset 176640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 180736 ++wrote 4096/4096 bytes at offset 180736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 184832 ++wrote 4096/4096 bytes at offset 184832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 188928 ++wrote 4096/4096 bytes at offset 188928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 193024 ++wrote 4096/4096 bytes at offset 193024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 197120 ++wrote 4096/4096 bytes at offset 197120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 201216 ++wrote 4096/4096 bytes at offset 201216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 205312 ++wrote 4096/4096 bytes at offset 205312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 209408 ++wrote 4096/4096 bytes at offset 209408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 213504 ++wrote 4096/4096 bytes at offset 213504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 217600 ++wrote 4096/4096 bytes at offset 217600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 221696 ++wrote 4096/4096 bytes at offset 221696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 225792 ++wrote 4096/4096 bytes at offset 225792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 229888 ++wrote 4096/4096 bytes at offset 229888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 233984 ++wrote 4096/4096 bytes at offset 233984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 238080 ++wrote 4096/4096 bytes at offset 238080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 242176 ++wrote 4096/4096 bytes at offset 242176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 246272 ++wrote 4096/4096 bytes at offset 246272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 250368 ++wrote 4096/4096 bytes at offset 250368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 254464 ++wrote 4096/4096 bytes at offset 254464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 258560 ++wrote 4096/4096 bytes at offset 258560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 262656 ++wrote 4096/4096 bytes at offset 262656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 266752 ++wrote 4096/4096 bytes at offset 266752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 270848 ++wrote 4096/4096 bytes at offset 270848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 274944 ++wrote 4096/4096 bytes at offset 274944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 279040 ++wrote 4096/4096 bytes at offset 279040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 283136 ++wrote 4096/4096 bytes at offset 283136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 287232 ++wrote 4096/4096 bytes at offset 287232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 291328 ++wrote 4096/4096 bytes at offset 291328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 295424 ++wrote 4096/4096 bytes at offset 295424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 299520 ++wrote 4096/4096 bytes at offset 299520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 303616 ++wrote 4096/4096 bytes at offset 303616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 307712 ++wrote 4096/4096 bytes at offset 307712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 311808 ++wrote 4096/4096 bytes at offset 311808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 315904 ++wrote 4096/4096 bytes at offset 315904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 320000 ++wrote 4096/4096 bytes at offset 320000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 324096 ++wrote 4096/4096 bytes at offset 324096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 328192 ++wrote 4096/4096 bytes at offset 328192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 332288 ++wrote 4096/4096 bytes at offset 332288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 336384 ++wrote 4096/4096 bytes at offset 336384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 340480 ++wrote 4096/4096 bytes at offset 340480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 344576 ++wrote 4096/4096 bytes at offset 344576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 348672 ++wrote 4096/4096 bytes at offset 348672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 352768 ++wrote 4096/4096 bytes at offset 352768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 356864 ++wrote 4096/4096 bytes at offset 356864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 360960 ++wrote 4096/4096 bytes at offset 360960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 365056 ++wrote 4096/4096 bytes at offset 365056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 369152 ++wrote 4096/4096 bytes at offset 369152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 373248 ++wrote 4096/4096 bytes at offset 373248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 377344 ++wrote 4096/4096 bytes at offset 377344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 381440 ++wrote 4096/4096 bytes at offset 381440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 385536 ++wrote 4096/4096 bytes at offset 385536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 389632 ++wrote 4096/4096 bytes at offset 389632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 393728 ++wrote 4096/4096 bytes at offset 393728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 397824 ++wrote 4096/4096 bytes at offset 397824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 401920 ++wrote 4096/4096 bytes at offset 401920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 406016 ++wrote 4096/4096 bytes at offset 406016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 410112 ++wrote 4096/4096 bytes at offset 410112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 414208 ++wrote 4096/4096 bytes at offset 414208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 418304 ++wrote 4096/4096 bytes at offset 418304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 422400 ++wrote 4096/4096 bytes at offset 422400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 426496 ++wrote 4096/4096 bytes at offset 426496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 430592 ++wrote 4096/4096 bytes at offset 430592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 434688 ++wrote 4096/4096 bytes at offset 434688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 438784 ++wrote 4096/4096 bytes at offset 438784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 442880 ++wrote 4096/4096 bytes at offset 442880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 446976 ++wrote 4096/4096 bytes at offset 446976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 451072 ++wrote 4096/4096 bytes at offset 451072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 455168 ++wrote 4096/4096 bytes at offset 455168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 459264 ++wrote 4096/4096 bytes at offset 459264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 463360 ++wrote 4096/4096 bytes at offset 463360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 467456 ++wrote 4096/4096 bytes at offset 467456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 471552 ++wrote 4096/4096 bytes at offset 471552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 475648 ++wrote 4096/4096 bytes at offset 475648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 479744 ++wrote 4096/4096 bytes at offset 479744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 483840 ++wrote 4096/4096 bytes at offset 483840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 487936 ++wrote 4096/4096 bytes at offset 487936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 492032 ++wrote 4096/4096 bytes at offset 492032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 496128 ++wrote 4096/4096 bytes at offset 496128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 500224 ++wrote 4096/4096 bytes at offset 500224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 504320 ++wrote 4096/4096 bytes at offset 504320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 508416 ++wrote 4096/4096 bytes at offset 508416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 512512 ++wrote 4096/4096 bytes at offset 512512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 516608 ++wrote 4096/4096 bytes at offset 516608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 520704 ++wrote 4096/4096 bytes at offset 520704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 524800 ++wrote 4096/4096 bytes at offset 524800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 528896 ++wrote 4096/4096 bytes at offset 528896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 532992 ++wrote 4096/4096 bytes at offset 532992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 537088 ++wrote 4096/4096 bytes at offset 537088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 541184 ++wrote 4096/4096 bytes at offset 541184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 545280 ++wrote 4096/4096 bytes at offset 545280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 549376 ++wrote 4096/4096 bytes at offset 549376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 553472 ++wrote 4096/4096 bytes at offset 553472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 557568 ++wrote 4096/4096 bytes at offset 557568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 561664 ++wrote 4096/4096 bytes at offset 561664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 565760 ++wrote 4096/4096 bytes at offset 565760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 569856 ++wrote 4096/4096 bytes at offset 569856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 573952 ++wrote 4096/4096 bytes at offset 573952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 578048 ++wrote 4096/4096 bytes at offset 578048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 582144 ++wrote 4096/4096 bytes at offset 582144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 586240 ++wrote 4096/4096 bytes at offset 586240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 590336 ++wrote 4096/4096 bytes at offset 590336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 594432 ++wrote 4096/4096 bytes at offset 594432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 598528 ++wrote 4096/4096 bytes at offset 598528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 602624 ++wrote 4096/4096 bytes at offset 602624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 606720 ++wrote 4096/4096 bytes at offset 606720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 610816 ++wrote 4096/4096 bytes at offset 610816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 614912 ++wrote 4096/4096 bytes at offset 614912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 619008 ++wrote 4096/4096 bytes at offset 619008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 623104 ++wrote 4096/4096 bytes at offset 623104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 627200 ++wrote 4096/4096 bytes at offset 627200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 631296 ++wrote 4096/4096 bytes at offset 631296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 635392 ++wrote 4096/4096 bytes at offset 635392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 639488 ++wrote 4096/4096 bytes at offset 639488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 643584 ++wrote 4096/4096 bytes at offset 643584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 647680 ++wrote 4096/4096 bytes at offset 647680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 651776 ++wrote 4096/4096 bytes at offset 651776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 655872 ++wrote 4096/4096 bytes at offset 655872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 659968 ++wrote 4096/4096 bytes at offset 659968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 664064 ++wrote 4096/4096 bytes at offset 664064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 668160 ++wrote 4096/4096 bytes at offset 668160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 672256 ++wrote 4096/4096 bytes at offset 672256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 676352 ++wrote 4096/4096 bytes at offset 676352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 680448 ++wrote 4096/4096 bytes at offset 680448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 684544 ++wrote 4096/4096 bytes at offset 684544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 688640 ++wrote 4096/4096 bytes at offset 688640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 692736 ++wrote 4096/4096 bytes at offset 692736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 696832 ++wrote 4096/4096 bytes at offset 696832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 700928 ++wrote 4096/4096 bytes at offset 700928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 705024 ++wrote 4096/4096 bytes at offset 705024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 709120 ++wrote 4096/4096 bytes at offset 709120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 713216 ++wrote 4096/4096 bytes at offset 713216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 717312 ++wrote 4096/4096 bytes at offset 717312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 721408 ++wrote 4096/4096 bytes at offset 721408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 725504 ++wrote 4096/4096 bytes at offset 725504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 729600 ++wrote 4096/4096 bytes at offset 729600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 733696 ++wrote 4096/4096 bytes at offset 733696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 737792 ++wrote 4096/4096 bytes at offset 737792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 741888 ++wrote 4096/4096 bytes at offset 741888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 745984 ++wrote 4096/4096 bytes at offset 745984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 750080 ++wrote 4096/4096 bytes at offset 750080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 754176 ++wrote 4096/4096 bytes at offset 754176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 758272 ++wrote 4096/4096 bytes at offset 758272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 762368 ++wrote 4096/4096 bytes at offset 762368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 766464 ++wrote 4096/4096 bytes at offset 766464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 770560 ++wrote 4096/4096 bytes at offset 770560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 774656 ++wrote 4096/4096 bytes at offset 774656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 778752 ++wrote 4096/4096 bytes at offset 778752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 782848 ++wrote 4096/4096 bytes at offset 782848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 786944 ++wrote 4096/4096 bytes at offset 786944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 791040 ++wrote 4096/4096 bytes at offset 791040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 795136 ++wrote 4096/4096 bytes at offset 795136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 799232 ++wrote 4096/4096 bytes at offset 799232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 803328 ++wrote 4096/4096 bytes at offset 803328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 807424 ++wrote 4096/4096 bytes at offset 807424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 811520 ++wrote 4096/4096 bytes at offset 811520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 815616 ++wrote 4096/4096 bytes at offset 815616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 819712 ++wrote 4096/4096 bytes at offset 819712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 823808 ++wrote 4096/4096 bytes at offset 823808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 827904 ++wrote 4096/4096 bytes at offset 827904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 832000 ++wrote 4096/4096 bytes at offset 832000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 836096 ++wrote 4096/4096 bytes at offset 836096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 840192 ++wrote 4096/4096 bytes at offset 840192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 844288 ++wrote 4096/4096 bytes at offset 844288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 848384 ++wrote 4096/4096 bytes at offset 848384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 852480 ++wrote 4096/4096 bytes at offset 852480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 856576 ++wrote 4096/4096 bytes at offset 856576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 860672 ++wrote 4096/4096 bytes at offset 860672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 864768 ++wrote 4096/4096 bytes at offset 864768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 868864 ++wrote 4096/4096 bytes at offset 868864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 872960 ++wrote 4096/4096 bytes at offset 872960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 877056 ++wrote 4096/4096 bytes at offset 877056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 881152 ++wrote 4096/4096 bytes at offset 881152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 885248 ++wrote 4096/4096 bytes at offset 885248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 889344 ++wrote 4096/4096 bytes at offset 889344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 893440 ++wrote 4096/4096 bytes at offset 893440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 897536 ++wrote 4096/4096 bytes at offset 897536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 901632 ++wrote 4096/4096 bytes at offset 901632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 905728 ++wrote 4096/4096 bytes at offset 905728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 909824 ++wrote 4096/4096 bytes at offset 909824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 913920 ++wrote 4096/4096 bytes at offset 913920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 918016 ++wrote 4096/4096 bytes at offset 918016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 922112 ++wrote 4096/4096 bytes at offset 922112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 926208 ++wrote 4096/4096 bytes at offset 926208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 930304 ++wrote 4096/4096 bytes at offset 930304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 934400 ++wrote 4096/4096 bytes at offset 934400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 938496 ++wrote 4096/4096 bytes at offset 938496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 942592 ++wrote 4096/4096 bytes at offset 942592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 946688 ++wrote 4096/4096 bytes at offset 946688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 950784 ++wrote 4096/4096 bytes at offset 950784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 954880 ++wrote 4096/4096 bytes at offset 954880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 958976 ++wrote 4096/4096 bytes at offset 958976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 963072 ++wrote 4096/4096 bytes at offset 963072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 967168 ++wrote 4096/4096 bytes at offset 967168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 971264 ++wrote 4096/4096 bytes at offset 971264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 975360 ++wrote 4096/4096 bytes at offset 975360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 979456 ++wrote 4096/4096 bytes at offset 979456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 983552 ++wrote 4096/4096 bytes at offset 983552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 987648 ++wrote 4096/4096 bytes at offset 987648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 991744 ++wrote 4096/4096 bytes at offset 991744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 995840 ++wrote 4096/4096 bytes at offset 995840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 999936 ++wrote 4096/4096 bytes at offset 999936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1004032 ++wrote 4096/4096 bytes at offset 1004032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1008128 ++wrote 4096/4096 bytes at offset 1008128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1012224 ++wrote 4096/4096 bytes at offset 1012224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1016320 ++wrote 4096/4096 bytes at offset 1016320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1020416 ++wrote 4096/4096 bytes at offset 1020416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1024512 ++wrote 4096/4096 bytes at offset 1024512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1028608 ++wrote 4096/4096 bytes at offset 1028608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1032704 ++wrote 4096/4096 bytes at offset 1032704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1036800 ++wrote 4096/4096 bytes at offset 1036800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1040896 ++wrote 4096/4096 bytes at offset 1040896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1044992 ++wrote 4096/4096 bytes at offset 1044992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 5 +-qemu-io> wrote 2048/2048 bytes at offset 1051136 ++=== IO: pattern 5 ++wrote 2048/2048 bytes at offset 1051136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1055232 ++wrote 2048/2048 bytes at offset 1055232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1059328 ++wrote 2048/2048 bytes at offset 1059328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1063424 ++wrote 2048/2048 bytes at offset 1063424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1067520 ++wrote 2048/2048 bytes at offset 1067520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1071616 ++wrote 2048/2048 bytes at offset 1071616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1075712 ++wrote 2048/2048 bytes at offset 1075712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1079808 ++wrote 2048/2048 bytes at offset 1079808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1083904 ++wrote 2048/2048 bytes at offset 1083904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1088000 ++wrote 2048/2048 bytes at offset 1088000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1092096 ++wrote 2048/2048 bytes at offset 1092096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1096192 ++wrote 2048/2048 bytes at offset 1096192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1100288 ++wrote 2048/2048 bytes at offset 1100288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1104384 ++wrote 2048/2048 bytes at offset 1104384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1108480 ++wrote 2048/2048 bytes at offset 1108480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1112576 ++wrote 2048/2048 bytes at offset 1112576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1116672 ++wrote 2048/2048 bytes at offset 1116672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1120768 ++wrote 2048/2048 bytes at offset 1120768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1124864 ++wrote 2048/2048 bytes at offset 1124864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1128960 ++wrote 2048/2048 bytes at offset 1128960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1133056 ++wrote 2048/2048 bytes at offset 1133056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1137152 ++wrote 2048/2048 bytes at offset 1137152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1141248 ++wrote 2048/2048 bytes at offset 1141248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1145344 ++wrote 2048/2048 bytes at offset 1145344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1149440 ++wrote 2048/2048 bytes at offset 1149440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1153536 ++wrote 2048/2048 bytes at offset 1153536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1157632 ++wrote 2048/2048 bytes at offset 1157632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1161728 ++wrote 2048/2048 bytes at offset 1161728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1165824 ++wrote 2048/2048 bytes at offset 1165824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1169920 ++wrote 2048/2048 bytes at offset 1169920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1174016 ++wrote 2048/2048 bytes at offset 1174016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1178112 ++wrote 2048/2048 bytes at offset 1178112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1182208 ++wrote 2048/2048 bytes at offset 1182208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1186304 ++wrote 2048/2048 bytes at offset 1186304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1190400 ++wrote 2048/2048 bytes at offset 1190400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1194496 ++wrote 2048/2048 bytes at offset 1194496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1198592 ++wrote 2048/2048 bytes at offset 1198592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1202688 ++wrote 2048/2048 bytes at offset 1202688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1206784 ++wrote 2048/2048 bytes at offset 1206784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1210880 ++wrote 2048/2048 bytes at offset 1210880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1214976 ++wrote 2048/2048 bytes at offset 1214976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1219072 ++wrote 2048/2048 bytes at offset 1219072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1223168 ++wrote 2048/2048 bytes at offset 1223168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1227264 ++wrote 2048/2048 bytes at offset 1227264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1231360 ++wrote 2048/2048 bytes at offset 1231360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1235456 ++wrote 2048/2048 bytes at offset 1235456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1239552 ++wrote 2048/2048 bytes at offset 1239552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1243648 ++wrote 2048/2048 bytes at offset 1243648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1247744 ++wrote 2048/2048 bytes at offset 1247744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1251840 ++wrote 2048/2048 bytes at offset 1251840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1255936 ++wrote 2048/2048 bytes at offset 1255936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1260032 ++wrote 2048/2048 bytes at offset 1260032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1264128 ++wrote 2048/2048 bytes at offset 1264128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1268224 ++wrote 2048/2048 bytes at offset 1268224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1272320 ++wrote 2048/2048 bytes at offset 1272320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1276416 ++wrote 2048/2048 bytes at offset 1276416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1280512 ++wrote 2048/2048 bytes at offset 1280512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1284608 ++wrote 2048/2048 bytes at offset 1284608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1288704 ++wrote 2048/2048 bytes at offset 1288704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1292800 ++wrote 2048/2048 bytes at offset 1292800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1296896 ++wrote 2048/2048 bytes at offset 1296896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1300992 ++wrote 2048/2048 bytes at offset 1300992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1305088 ++wrote 2048/2048 bytes at offset 1305088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1309184 ++wrote 2048/2048 bytes at offset 1309184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1313280 ++wrote 2048/2048 bytes at offset 1313280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1317376 ++wrote 2048/2048 bytes at offset 1317376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1321472 ++wrote 2048/2048 bytes at offset 1321472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1325568 ++wrote 2048/2048 bytes at offset 1325568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1329664 ++wrote 2048/2048 bytes at offset 1329664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1333760 ++wrote 2048/2048 bytes at offset 1333760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1337856 ++wrote 2048/2048 bytes at offset 1337856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1341952 ++wrote 2048/2048 bytes at offset 1341952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1346048 ++wrote 2048/2048 bytes at offset 1346048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1350144 ++wrote 2048/2048 bytes at offset 1350144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1354240 ++wrote 2048/2048 bytes at offset 1354240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1358336 ++wrote 2048/2048 bytes at offset 1358336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1362432 ++wrote 2048/2048 bytes at offset 1362432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1366528 ++wrote 2048/2048 bytes at offset 1366528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1370624 ++wrote 2048/2048 bytes at offset 1370624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1374720 ++wrote 2048/2048 bytes at offset 1374720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1378816 ++wrote 2048/2048 bytes at offset 1378816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1382912 ++wrote 2048/2048 bytes at offset 1382912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1387008 ++wrote 2048/2048 bytes at offset 1387008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1391104 ++wrote 2048/2048 bytes at offset 1391104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1395200 ++wrote 2048/2048 bytes at offset 1395200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1399296 ++wrote 2048/2048 bytes at offset 1399296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1403392 ++wrote 2048/2048 bytes at offset 1403392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1407488 ++wrote 2048/2048 bytes at offset 1407488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1411584 ++wrote 2048/2048 bytes at offset 1411584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1415680 ++wrote 2048/2048 bytes at offset 1415680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1419776 ++wrote 2048/2048 bytes at offset 1419776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1423872 ++wrote 2048/2048 bytes at offset 1423872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1427968 ++wrote 2048/2048 bytes at offset 1427968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1432064 ++wrote 2048/2048 bytes at offset 1432064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1436160 ++wrote 2048/2048 bytes at offset 1436160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1440256 ++wrote 2048/2048 bytes at offset 1440256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1444352 ++wrote 2048/2048 bytes at offset 1444352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1448448 ++wrote 2048/2048 bytes at offset 1448448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1452544 ++wrote 2048/2048 bytes at offset 1452544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1456640 ++wrote 2048/2048 bytes at offset 1456640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1460736 ++wrote 2048/2048 bytes at offset 1460736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1464832 ++wrote 2048/2048 bytes at offset 1464832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1468928 ++wrote 2048/2048 bytes at offset 1468928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1473024 ++wrote 2048/2048 bytes at offset 1473024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1477120 ++wrote 2048/2048 bytes at offset 1477120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1481216 ++wrote 2048/2048 bytes at offset 1481216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1485312 ++wrote 2048/2048 bytes at offset 1485312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1489408 ++wrote 2048/2048 bytes at offset 1489408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1493504 ++wrote 2048/2048 bytes at offset 1493504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1497600 ++wrote 2048/2048 bytes at offset 1497600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1501696 ++wrote 2048/2048 bytes at offset 1501696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1505792 ++wrote 2048/2048 bytes at offset 1505792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1509888 ++wrote 2048/2048 bytes at offset 1509888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1513984 ++wrote 2048/2048 bytes at offset 1513984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1518080 ++wrote 2048/2048 bytes at offset 1518080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1522176 ++wrote 2048/2048 bytes at offset 1522176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1526272 ++wrote 2048/2048 bytes at offset 1526272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1530368 ++wrote 2048/2048 bytes at offset 1530368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1534464 ++wrote 2048/2048 bytes at offset 1534464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1538560 ++wrote 2048/2048 bytes at offset 1538560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1542656 ++wrote 2048/2048 bytes at offset 1542656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1546752 ++wrote 2048/2048 bytes at offset 1546752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1550848 ++wrote 2048/2048 bytes at offset 1550848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1554944 ++wrote 2048/2048 bytes at offset 1554944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1559040 ++wrote 2048/2048 bytes at offset 1559040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1563136 ++wrote 2048/2048 bytes at offset 1563136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1567232 ++wrote 2048/2048 bytes at offset 1567232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1571328 ++wrote 2048/2048 bytes at offset 1571328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1575424 ++wrote 2048/2048 bytes at offset 1575424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1579520 ++wrote 2048/2048 bytes at offset 1579520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1583616 ++wrote 2048/2048 bytes at offset 1583616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1587712 ++wrote 2048/2048 bytes at offset 1587712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1591808 ++wrote 2048/2048 bytes at offset 1591808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1595904 ++wrote 2048/2048 bytes at offset 1595904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1600000 ++wrote 2048/2048 bytes at offset 1600000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1604096 ++wrote 2048/2048 bytes at offset 1604096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1608192 ++wrote 2048/2048 bytes at offset 1608192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1612288 ++wrote 2048/2048 bytes at offset 1612288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1616384 ++wrote 2048/2048 bytes at offset 1616384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1620480 ++wrote 2048/2048 bytes at offset 1620480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1624576 ++wrote 2048/2048 bytes at offset 1624576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1628672 ++wrote 2048/2048 bytes at offset 1628672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1632768 ++wrote 2048/2048 bytes at offset 1632768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1636864 ++wrote 2048/2048 bytes at offset 1636864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1640960 ++wrote 2048/2048 bytes at offset 1640960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1645056 ++wrote 2048/2048 bytes at offset 1645056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1649152 ++wrote 2048/2048 bytes at offset 1649152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1653248 ++wrote 2048/2048 bytes at offset 1653248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1657344 ++wrote 2048/2048 bytes at offset 1657344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1661440 ++wrote 2048/2048 bytes at offset 1661440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1665536 ++wrote 2048/2048 bytes at offset 1665536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1669632 ++wrote 2048/2048 bytes at offset 1669632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1673728 ++wrote 2048/2048 bytes at offset 1673728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1677824 ++wrote 2048/2048 bytes at offset 1677824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1681920 ++wrote 2048/2048 bytes at offset 1681920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1686016 ++wrote 2048/2048 bytes at offset 1686016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1690112 ++wrote 2048/2048 bytes at offset 1690112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1694208 ++wrote 2048/2048 bytes at offset 1694208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1698304 ++wrote 2048/2048 bytes at offset 1698304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1702400 ++wrote 2048/2048 bytes at offset 1702400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1706496 ++wrote 2048/2048 bytes at offset 1706496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1710592 ++wrote 2048/2048 bytes at offset 1710592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1714688 ++wrote 2048/2048 bytes at offset 1714688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1718784 ++wrote 2048/2048 bytes at offset 1718784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1722880 ++wrote 2048/2048 bytes at offset 1722880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1726976 ++wrote 2048/2048 bytes at offset 1726976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1731072 ++wrote 2048/2048 bytes at offset 1731072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1735168 ++wrote 2048/2048 bytes at offset 1735168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1739264 ++wrote 2048/2048 bytes at offset 1739264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1743360 ++wrote 2048/2048 bytes at offset 1743360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1747456 ++wrote 2048/2048 bytes at offset 1747456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1751552 ++wrote 2048/2048 bytes at offset 1751552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1755648 ++wrote 2048/2048 bytes at offset 1755648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1759744 ++wrote 2048/2048 bytes at offset 1759744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1763840 ++wrote 2048/2048 bytes at offset 1763840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1767936 ++wrote 2048/2048 bytes at offset 1767936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1772032 ++wrote 2048/2048 bytes at offset 1772032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1776128 ++wrote 2048/2048 bytes at offset 1776128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1780224 ++wrote 2048/2048 bytes at offset 1780224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1784320 ++wrote 2048/2048 bytes at offset 1784320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1788416 ++wrote 2048/2048 bytes at offset 1788416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1792512 ++wrote 2048/2048 bytes at offset 1792512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1796608 ++wrote 2048/2048 bytes at offset 1796608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1800704 ++wrote 2048/2048 bytes at offset 1800704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1804800 ++wrote 2048/2048 bytes at offset 1804800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1808896 ++wrote 2048/2048 bytes at offset 1808896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1812992 ++wrote 2048/2048 bytes at offset 1812992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1817088 ++wrote 2048/2048 bytes at offset 1817088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1821184 ++wrote 2048/2048 bytes at offset 1821184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1825280 ++wrote 2048/2048 bytes at offset 1825280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1829376 ++wrote 2048/2048 bytes at offset 1829376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1833472 ++wrote 2048/2048 bytes at offset 1833472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1837568 ++wrote 2048/2048 bytes at offset 1837568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1841664 ++wrote 2048/2048 bytes at offset 1841664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1845760 ++wrote 2048/2048 bytes at offset 1845760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1849856 ++wrote 2048/2048 bytes at offset 1849856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1853952 ++wrote 2048/2048 bytes at offset 1853952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1858048 ++wrote 2048/2048 bytes at offset 1858048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1862144 ++wrote 2048/2048 bytes at offset 1862144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1866240 ++wrote 2048/2048 bytes at offset 1866240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1870336 ++wrote 2048/2048 bytes at offset 1870336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1874432 ++wrote 2048/2048 bytes at offset 1874432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1878528 ++wrote 2048/2048 bytes at offset 1878528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1882624 ++wrote 2048/2048 bytes at offset 1882624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1886720 ++wrote 2048/2048 bytes at offset 1886720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1890816 ++wrote 2048/2048 bytes at offset 1890816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1894912 ++wrote 2048/2048 bytes at offset 1894912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1899008 ++wrote 2048/2048 bytes at offset 1899008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1903104 ++wrote 2048/2048 bytes at offset 1903104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1907200 ++wrote 2048/2048 bytes at offset 1907200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1911296 ++wrote 2048/2048 bytes at offset 1911296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1915392 ++wrote 2048/2048 bytes at offset 1915392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1919488 ++wrote 2048/2048 bytes at offset 1919488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1923584 ++wrote 2048/2048 bytes at offset 1923584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1927680 ++wrote 2048/2048 bytes at offset 1927680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1931776 ++wrote 2048/2048 bytes at offset 1931776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1935872 ++wrote 2048/2048 bytes at offset 1935872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1939968 ++wrote 2048/2048 bytes at offset 1939968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1944064 ++wrote 2048/2048 bytes at offset 1944064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1948160 ++wrote 2048/2048 bytes at offset 1948160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1952256 ++wrote 2048/2048 bytes at offset 1952256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1956352 ++wrote 2048/2048 bytes at offset 1956352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1960448 ++wrote 2048/2048 bytes at offset 1960448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1964544 ++wrote 2048/2048 bytes at offset 1964544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1968640 ++wrote 2048/2048 bytes at offset 1968640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1972736 ++wrote 2048/2048 bytes at offset 1972736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1976832 ++wrote 2048/2048 bytes at offset 1976832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1980928 ++wrote 2048/2048 bytes at offset 1980928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1985024 ++wrote 2048/2048 bytes at offset 1985024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1989120 ++wrote 2048/2048 bytes at offset 1989120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1993216 ++wrote 2048/2048 bytes at offset 1993216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1997312 ++wrote 2048/2048 bytes at offset 1997312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2001408 ++wrote 2048/2048 bytes at offset 2001408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2005504 ++wrote 2048/2048 bytes at offset 2005504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2009600 ++wrote 2048/2048 bytes at offset 2009600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2013696 ++wrote 2048/2048 bytes at offset 2013696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2017792 ++wrote 2048/2048 bytes at offset 2017792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2021888 ++wrote 2048/2048 bytes at offset 2021888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2025984 ++wrote 2048/2048 bytes at offset 2025984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2030080 ++wrote 2048/2048 bytes at offset 2030080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2034176 ++wrote 2048/2048 bytes at offset 2034176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2038272 ++wrote 2048/2048 bytes at offset 2038272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2042368 ++wrote 2048/2048 bytes at offset 2042368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2046464 ++wrote 2048/2048 bytes at offset 2046464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2050560 ++wrote 2048/2048 bytes at offset 2050560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2054656 ++wrote 2048/2048 bytes at offset 2054656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2058752 ++wrote 2048/2048 bytes at offset 2058752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2062848 ++wrote 2048/2048 bytes at offset 2062848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2066944 ++wrote 2048/2048 bytes at offset 2066944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2071040 ++wrote 2048/2048 bytes at offset 2071040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2075136 ++wrote 2048/2048 bytes at offset 2075136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2079232 ++wrote 2048/2048 bytes at offset 2079232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2083328 ++wrote 2048/2048 bytes at offset 2083328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2087424 ++wrote 2048/2048 bytes at offset 2087424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2091520 ++wrote 2048/2048 bytes at offset 2091520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2095616 ++wrote 2048/2048 bytes at offset 2095616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 1 +-qemu-io> wrote 2048/2048 bytes at offset 2097664 ++=== IO: pattern 1 ++wrote 2048/2048 bytes at offset 2097664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2101760 ++wrote 2048/2048 bytes at offset 2101760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2105856 ++wrote 2048/2048 bytes at offset 2105856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2109952 ++wrote 2048/2048 bytes at offset 2109952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2114048 ++wrote 2048/2048 bytes at offset 2114048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2118144 ++wrote 2048/2048 bytes at offset 2118144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2122240 ++wrote 2048/2048 bytes at offset 2122240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2126336 ++wrote 2048/2048 bytes at offset 2126336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2130432 ++wrote 2048/2048 bytes at offset 2130432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2134528 ++wrote 2048/2048 bytes at offset 2134528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2138624 ++wrote 2048/2048 bytes at offset 2138624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2142720 ++wrote 2048/2048 bytes at offset 2142720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2146816 ++wrote 2048/2048 bytes at offset 2146816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2150912 ++wrote 2048/2048 bytes at offset 2150912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2155008 ++wrote 2048/2048 bytes at offset 2155008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2159104 ++wrote 2048/2048 bytes at offset 2159104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2163200 ++wrote 2048/2048 bytes at offset 2163200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2167296 ++wrote 2048/2048 bytes at offset 2167296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2171392 ++wrote 2048/2048 bytes at offset 2171392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2175488 ++wrote 2048/2048 bytes at offset 2175488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2179584 ++wrote 2048/2048 bytes at offset 2179584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2183680 ++wrote 2048/2048 bytes at offset 2183680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2187776 ++wrote 2048/2048 bytes at offset 2187776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2191872 ++wrote 2048/2048 bytes at offset 2191872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2195968 ++wrote 2048/2048 bytes at offset 2195968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2200064 ++wrote 2048/2048 bytes at offset 2200064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2204160 ++wrote 2048/2048 bytes at offset 2204160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2208256 ++wrote 2048/2048 bytes at offset 2208256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2212352 ++wrote 2048/2048 bytes at offset 2212352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2216448 ++wrote 2048/2048 bytes at offset 2216448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2220544 ++wrote 2048/2048 bytes at offset 2220544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2224640 ++wrote 2048/2048 bytes at offset 2224640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2228736 ++wrote 2048/2048 bytes at offset 2228736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2232832 ++wrote 2048/2048 bytes at offset 2232832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2236928 ++wrote 2048/2048 bytes at offset 2236928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2241024 ++wrote 2048/2048 bytes at offset 2241024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2245120 ++wrote 2048/2048 bytes at offset 2245120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2249216 ++wrote 2048/2048 bytes at offset 2249216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2253312 ++wrote 2048/2048 bytes at offset 2253312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2257408 ++wrote 2048/2048 bytes at offset 2257408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2261504 ++wrote 2048/2048 bytes at offset 2261504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2265600 ++wrote 2048/2048 bytes at offset 2265600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2269696 ++wrote 2048/2048 bytes at offset 2269696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2273792 ++wrote 2048/2048 bytes at offset 2273792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2277888 ++wrote 2048/2048 bytes at offset 2277888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2281984 ++wrote 2048/2048 bytes at offset 2281984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2286080 ++wrote 2048/2048 bytes at offset 2286080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2290176 ++wrote 2048/2048 bytes at offset 2290176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2294272 ++wrote 2048/2048 bytes at offset 2294272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2298368 ++wrote 2048/2048 bytes at offset 2298368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2302464 ++wrote 2048/2048 bytes at offset 2302464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2306560 ++wrote 2048/2048 bytes at offset 2306560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2310656 ++wrote 2048/2048 bytes at offset 2310656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2314752 ++wrote 2048/2048 bytes at offset 2314752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2318848 ++wrote 2048/2048 bytes at offset 2318848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2322944 ++wrote 2048/2048 bytes at offset 2322944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2327040 ++wrote 2048/2048 bytes at offset 2327040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2331136 ++wrote 2048/2048 bytes at offset 2331136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2335232 ++wrote 2048/2048 bytes at offset 2335232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2339328 ++wrote 2048/2048 bytes at offset 2339328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2343424 ++wrote 2048/2048 bytes at offset 2343424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2347520 ++wrote 2048/2048 bytes at offset 2347520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2351616 ++wrote 2048/2048 bytes at offset 2351616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2355712 ++wrote 2048/2048 bytes at offset 2355712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2359808 ++wrote 2048/2048 bytes at offset 2359808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2363904 ++wrote 2048/2048 bytes at offset 2363904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2368000 ++wrote 2048/2048 bytes at offset 2368000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2372096 ++wrote 2048/2048 bytes at offset 2372096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2376192 ++wrote 2048/2048 bytes at offset 2376192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2380288 ++wrote 2048/2048 bytes at offset 2380288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2384384 ++wrote 2048/2048 bytes at offset 2384384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2388480 ++wrote 2048/2048 bytes at offset 2388480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2392576 ++wrote 2048/2048 bytes at offset 2392576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2396672 ++wrote 2048/2048 bytes at offset 2396672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2400768 ++wrote 2048/2048 bytes at offset 2400768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2404864 ++wrote 2048/2048 bytes at offset 2404864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2408960 ++wrote 2048/2048 bytes at offset 2408960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2413056 ++wrote 2048/2048 bytes at offset 2413056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2417152 ++wrote 2048/2048 bytes at offset 2417152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2421248 ++wrote 2048/2048 bytes at offset 2421248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2425344 ++wrote 2048/2048 bytes at offset 2425344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2429440 ++wrote 2048/2048 bytes at offset 2429440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2433536 ++wrote 2048/2048 bytes at offset 2433536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2437632 ++wrote 2048/2048 bytes at offset 2437632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2441728 ++wrote 2048/2048 bytes at offset 2441728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2445824 ++wrote 2048/2048 bytes at offset 2445824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2449920 ++wrote 2048/2048 bytes at offset 2449920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2454016 ++wrote 2048/2048 bytes at offset 2454016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2458112 ++wrote 2048/2048 bytes at offset 2458112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2462208 ++wrote 2048/2048 bytes at offset 2462208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2466304 ++wrote 2048/2048 bytes at offset 2466304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2470400 ++wrote 2048/2048 bytes at offset 2470400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2474496 ++wrote 2048/2048 bytes at offset 2474496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2478592 ++wrote 2048/2048 bytes at offset 2478592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2482688 ++wrote 2048/2048 bytes at offset 2482688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2486784 ++wrote 2048/2048 bytes at offset 2486784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2490880 ++wrote 2048/2048 bytes at offset 2490880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2494976 ++wrote 2048/2048 bytes at offset 2494976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2499072 ++wrote 2048/2048 bytes at offset 2499072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2503168 ++wrote 2048/2048 bytes at offset 2503168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2507264 ++wrote 2048/2048 bytes at offset 2507264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2511360 ++wrote 2048/2048 bytes at offset 2511360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2515456 ++wrote 2048/2048 bytes at offset 2515456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2519552 ++wrote 2048/2048 bytes at offset 2519552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2523648 ++wrote 2048/2048 bytes at offset 2523648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2527744 ++wrote 2048/2048 bytes at offset 2527744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2531840 ++wrote 2048/2048 bytes at offset 2531840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2535936 ++wrote 2048/2048 bytes at offset 2535936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2540032 ++wrote 2048/2048 bytes at offset 2540032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2544128 ++wrote 2048/2048 bytes at offset 2544128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2548224 ++wrote 2048/2048 bytes at offset 2548224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2552320 ++wrote 2048/2048 bytes at offset 2552320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2556416 ++wrote 2048/2048 bytes at offset 2556416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2560512 ++wrote 2048/2048 bytes at offset 2560512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2564608 ++wrote 2048/2048 bytes at offset 2564608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2568704 ++wrote 2048/2048 bytes at offset 2568704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2572800 ++wrote 2048/2048 bytes at offset 2572800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2576896 ++wrote 2048/2048 bytes at offset 2576896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2580992 ++wrote 2048/2048 bytes at offset 2580992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2585088 ++wrote 2048/2048 bytes at offset 2585088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2589184 ++wrote 2048/2048 bytes at offset 2589184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2593280 ++wrote 2048/2048 bytes at offset 2593280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2597376 ++wrote 2048/2048 bytes at offset 2597376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2601472 ++wrote 2048/2048 bytes at offset 2601472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2605568 ++wrote 2048/2048 bytes at offset 2605568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2609664 ++wrote 2048/2048 bytes at offset 2609664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2613760 ++wrote 2048/2048 bytes at offset 2613760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2617856 ++wrote 2048/2048 bytes at offset 2617856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2621952 ++wrote 2048/2048 bytes at offset 2621952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2626048 ++wrote 2048/2048 bytes at offset 2626048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2630144 ++wrote 2048/2048 bytes at offset 2630144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2634240 ++wrote 2048/2048 bytes at offset 2634240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2638336 ++wrote 2048/2048 bytes at offset 2638336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2642432 ++wrote 2048/2048 bytes at offset 2642432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2646528 ++wrote 2048/2048 bytes at offset 2646528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2650624 ++wrote 2048/2048 bytes at offset 2650624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2654720 ++wrote 2048/2048 bytes at offset 2654720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2658816 ++wrote 2048/2048 bytes at offset 2658816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2662912 ++wrote 2048/2048 bytes at offset 2662912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2667008 ++wrote 2048/2048 bytes at offset 2667008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2671104 ++wrote 2048/2048 bytes at offset 2671104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2675200 ++wrote 2048/2048 bytes at offset 2675200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2679296 ++wrote 2048/2048 bytes at offset 2679296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2683392 ++wrote 2048/2048 bytes at offset 2683392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2687488 ++wrote 2048/2048 bytes at offset 2687488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2691584 ++wrote 2048/2048 bytes at offset 2691584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2695680 ++wrote 2048/2048 bytes at offset 2695680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2699776 ++wrote 2048/2048 bytes at offset 2699776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2703872 ++wrote 2048/2048 bytes at offset 2703872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2707968 ++wrote 2048/2048 bytes at offset 2707968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2712064 ++wrote 2048/2048 bytes at offset 2712064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2716160 ++wrote 2048/2048 bytes at offset 2716160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2720256 ++wrote 2048/2048 bytes at offset 2720256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2724352 ++wrote 2048/2048 bytes at offset 2724352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2728448 ++wrote 2048/2048 bytes at offset 2728448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2732544 ++wrote 2048/2048 bytes at offset 2732544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2736640 ++wrote 2048/2048 bytes at offset 2736640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2740736 ++wrote 2048/2048 bytes at offset 2740736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2744832 ++wrote 2048/2048 bytes at offset 2744832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2748928 ++wrote 2048/2048 bytes at offset 2748928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2753024 ++wrote 2048/2048 bytes at offset 2753024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2757120 ++wrote 2048/2048 bytes at offset 2757120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2761216 ++wrote 2048/2048 bytes at offset 2761216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2765312 ++wrote 2048/2048 bytes at offset 2765312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2769408 ++wrote 2048/2048 bytes at offset 2769408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2773504 ++wrote 2048/2048 bytes at offset 2773504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2777600 ++wrote 2048/2048 bytes at offset 2777600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2781696 ++wrote 2048/2048 bytes at offset 2781696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2785792 ++wrote 2048/2048 bytes at offset 2785792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2789888 ++wrote 2048/2048 bytes at offset 2789888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2793984 ++wrote 2048/2048 bytes at offset 2793984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2798080 ++wrote 2048/2048 bytes at offset 2798080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2802176 ++wrote 2048/2048 bytes at offset 2802176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2806272 ++wrote 2048/2048 bytes at offset 2806272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2810368 ++wrote 2048/2048 bytes at offset 2810368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2814464 ++wrote 2048/2048 bytes at offset 2814464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2818560 ++wrote 2048/2048 bytes at offset 2818560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2822656 ++wrote 2048/2048 bytes at offset 2822656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2826752 ++wrote 2048/2048 bytes at offset 2826752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2830848 ++wrote 2048/2048 bytes at offset 2830848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2834944 ++wrote 2048/2048 bytes at offset 2834944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2839040 ++wrote 2048/2048 bytes at offset 2839040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2843136 ++wrote 2048/2048 bytes at offset 2843136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2847232 ++wrote 2048/2048 bytes at offset 2847232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2851328 ++wrote 2048/2048 bytes at offset 2851328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2855424 ++wrote 2048/2048 bytes at offset 2855424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2859520 ++wrote 2048/2048 bytes at offset 2859520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2863616 ++wrote 2048/2048 bytes at offset 2863616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2867712 ++wrote 2048/2048 bytes at offset 2867712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2871808 ++wrote 2048/2048 bytes at offset 2871808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2875904 ++wrote 2048/2048 bytes at offset 2875904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2880000 ++wrote 2048/2048 bytes at offset 2880000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2884096 ++wrote 2048/2048 bytes at offset 2884096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2888192 ++wrote 2048/2048 bytes at offset 2888192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2892288 ++wrote 2048/2048 bytes at offset 2892288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2896384 ++wrote 2048/2048 bytes at offset 2896384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2900480 ++wrote 2048/2048 bytes at offset 2900480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2904576 ++wrote 2048/2048 bytes at offset 2904576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2908672 ++wrote 2048/2048 bytes at offset 2908672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2912768 ++wrote 2048/2048 bytes at offset 2912768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2916864 ++wrote 2048/2048 bytes at offset 2916864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2920960 ++wrote 2048/2048 bytes at offset 2920960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2925056 ++wrote 2048/2048 bytes at offset 2925056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2929152 ++wrote 2048/2048 bytes at offset 2929152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2933248 ++wrote 2048/2048 bytes at offset 2933248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2937344 ++wrote 2048/2048 bytes at offset 2937344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2941440 ++wrote 2048/2048 bytes at offset 2941440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2945536 ++wrote 2048/2048 bytes at offset 2945536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2949632 ++wrote 2048/2048 bytes at offset 2949632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2953728 ++wrote 2048/2048 bytes at offset 2953728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2957824 ++wrote 2048/2048 bytes at offset 2957824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2961920 ++wrote 2048/2048 bytes at offset 2961920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2966016 ++wrote 2048/2048 bytes at offset 2966016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2970112 ++wrote 2048/2048 bytes at offset 2970112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2974208 ++wrote 2048/2048 bytes at offset 2974208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2978304 ++wrote 2048/2048 bytes at offset 2978304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2982400 ++wrote 2048/2048 bytes at offset 2982400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2986496 ++wrote 2048/2048 bytes at offset 2986496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2990592 ++wrote 2048/2048 bytes at offset 2990592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2994688 ++wrote 2048/2048 bytes at offset 2994688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2998784 ++wrote 2048/2048 bytes at offset 2998784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3002880 ++wrote 2048/2048 bytes at offset 3002880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3006976 ++wrote 2048/2048 bytes at offset 3006976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3011072 ++wrote 2048/2048 bytes at offset 3011072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3015168 ++wrote 2048/2048 bytes at offset 3015168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3019264 ++wrote 2048/2048 bytes at offset 3019264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3023360 ++wrote 2048/2048 bytes at offset 3023360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3027456 ++wrote 2048/2048 bytes at offset 3027456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3031552 ++wrote 2048/2048 bytes at offset 3031552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3035648 ++wrote 2048/2048 bytes at offset 3035648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3039744 ++wrote 2048/2048 bytes at offset 3039744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3043840 ++wrote 2048/2048 bytes at offset 3043840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3047936 ++wrote 2048/2048 bytes at offset 3047936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3052032 ++wrote 2048/2048 bytes at offset 3052032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3056128 ++wrote 2048/2048 bytes at offset 3056128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3060224 ++wrote 2048/2048 bytes at offset 3060224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3064320 ++wrote 2048/2048 bytes at offset 3064320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3068416 ++wrote 2048/2048 bytes at offset 3068416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3072512 ++wrote 2048/2048 bytes at offset 3072512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3076608 ++wrote 2048/2048 bytes at offset 3076608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3080704 ++wrote 2048/2048 bytes at offset 3080704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3084800 ++wrote 2048/2048 bytes at offset 3084800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3088896 ++wrote 2048/2048 bytes at offset 3088896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3092992 ++wrote 2048/2048 bytes at offset 3092992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3097088 ++wrote 2048/2048 bytes at offset 3097088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3101184 ++wrote 2048/2048 bytes at offset 3101184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3105280 ++wrote 2048/2048 bytes at offset 3105280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3109376 ++wrote 2048/2048 bytes at offset 3109376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3113472 ++wrote 2048/2048 bytes at offset 3113472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3117568 ++wrote 2048/2048 bytes at offset 3117568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3121664 ++wrote 2048/2048 bytes at offset 3121664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3125760 ++wrote 2048/2048 bytes at offset 3125760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3129856 ++wrote 2048/2048 bytes at offset 3129856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3133952 ++wrote 2048/2048 bytes at offset 3133952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3138048 ++wrote 2048/2048 bytes at offset 3138048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3142144 ++wrote 2048/2048 bytes at offset 3142144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 3 +-qemu-io> wrote 2048/2048 bytes at offset 3147264 ++=== IO: pattern 3 ++wrote 2048/2048 bytes at offset 3147264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3151360 ++wrote 2048/2048 bytes at offset 3151360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3155456 ++wrote 2048/2048 bytes at offset 3155456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3159552 ++wrote 2048/2048 bytes at offset 3159552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3163648 ++wrote 2048/2048 bytes at offset 3163648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3167744 ++wrote 2048/2048 bytes at offset 3167744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3171840 ++wrote 2048/2048 bytes at offset 3171840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3175936 ++wrote 2048/2048 bytes at offset 3175936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3180032 ++wrote 2048/2048 bytes at offset 3180032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3184128 ++wrote 2048/2048 bytes at offset 3184128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3188224 ++wrote 2048/2048 bytes at offset 3188224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3192320 ++wrote 2048/2048 bytes at offset 3192320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3196416 ++wrote 2048/2048 bytes at offset 3196416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3200512 ++wrote 2048/2048 bytes at offset 3200512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3204608 ++wrote 2048/2048 bytes at offset 3204608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3208704 ++wrote 2048/2048 bytes at offset 3208704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3212800 ++wrote 2048/2048 bytes at offset 3212800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3216896 ++wrote 2048/2048 bytes at offset 3216896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3220992 ++wrote 2048/2048 bytes at offset 3220992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3225088 ++wrote 2048/2048 bytes at offset 3225088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3229184 ++wrote 2048/2048 bytes at offset 3229184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3233280 ++wrote 2048/2048 bytes at offset 3233280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3237376 ++wrote 2048/2048 bytes at offset 3237376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3241472 ++wrote 2048/2048 bytes at offset 3241472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3245568 ++wrote 2048/2048 bytes at offset 3245568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3249664 ++wrote 2048/2048 bytes at offset 3249664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3253760 ++wrote 2048/2048 bytes at offset 3253760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3257856 ++wrote 2048/2048 bytes at offset 3257856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3261952 ++wrote 2048/2048 bytes at offset 3261952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3266048 ++wrote 2048/2048 bytes at offset 3266048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3270144 ++wrote 2048/2048 bytes at offset 3270144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3274240 ++wrote 2048/2048 bytes at offset 3274240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3278336 ++wrote 2048/2048 bytes at offset 3278336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3282432 ++wrote 2048/2048 bytes at offset 3282432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3286528 ++wrote 2048/2048 bytes at offset 3286528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3290624 ++wrote 2048/2048 bytes at offset 3290624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3294720 ++wrote 2048/2048 bytes at offset 3294720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3298816 ++wrote 2048/2048 bytes at offset 3298816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3302912 ++wrote 2048/2048 bytes at offset 3302912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3307008 ++wrote 2048/2048 bytes at offset 3307008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3311104 ++wrote 2048/2048 bytes at offset 3311104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3315200 ++wrote 2048/2048 bytes at offset 3315200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3319296 ++wrote 2048/2048 bytes at offset 3319296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3323392 ++wrote 2048/2048 bytes at offset 3323392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3327488 ++wrote 2048/2048 bytes at offset 3327488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3331584 ++wrote 2048/2048 bytes at offset 3331584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3335680 ++wrote 2048/2048 bytes at offset 3335680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3339776 ++wrote 2048/2048 bytes at offset 3339776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3343872 ++wrote 2048/2048 bytes at offset 3343872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3347968 ++wrote 2048/2048 bytes at offset 3347968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3352064 ++wrote 2048/2048 bytes at offset 3352064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3356160 ++wrote 2048/2048 bytes at offset 3356160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3360256 ++wrote 2048/2048 bytes at offset 3360256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3364352 ++wrote 2048/2048 bytes at offset 3364352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3368448 ++wrote 2048/2048 bytes at offset 3368448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3372544 ++wrote 2048/2048 bytes at offset 3372544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3376640 ++wrote 2048/2048 bytes at offset 3376640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3380736 ++wrote 2048/2048 bytes at offset 3380736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3384832 ++wrote 2048/2048 bytes at offset 3384832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3388928 ++wrote 2048/2048 bytes at offset 3388928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3393024 ++wrote 2048/2048 bytes at offset 3393024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3397120 ++wrote 2048/2048 bytes at offset 3397120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3401216 ++wrote 2048/2048 bytes at offset 3401216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3405312 ++wrote 2048/2048 bytes at offset 3405312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3409408 ++wrote 2048/2048 bytes at offset 3409408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3413504 ++wrote 2048/2048 bytes at offset 3413504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3417600 ++wrote 2048/2048 bytes at offset 3417600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3421696 ++wrote 2048/2048 bytes at offset 3421696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3425792 ++wrote 2048/2048 bytes at offset 3425792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3429888 ++wrote 2048/2048 bytes at offset 3429888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3433984 ++wrote 2048/2048 bytes at offset 3433984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3438080 ++wrote 2048/2048 bytes at offset 3438080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3442176 ++wrote 2048/2048 bytes at offset 3442176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3446272 ++wrote 2048/2048 bytes at offset 3446272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3450368 ++wrote 2048/2048 bytes at offset 3450368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3454464 ++wrote 2048/2048 bytes at offset 3454464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3458560 ++wrote 2048/2048 bytes at offset 3458560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3462656 ++wrote 2048/2048 bytes at offset 3462656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3466752 ++wrote 2048/2048 bytes at offset 3466752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3470848 ++wrote 2048/2048 bytes at offset 3470848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3474944 ++wrote 2048/2048 bytes at offset 3474944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3479040 ++wrote 2048/2048 bytes at offset 3479040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3483136 ++wrote 2048/2048 bytes at offset 3483136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3487232 ++wrote 2048/2048 bytes at offset 3487232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3491328 ++wrote 2048/2048 bytes at offset 3491328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3495424 ++wrote 2048/2048 bytes at offset 3495424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3499520 ++wrote 2048/2048 bytes at offset 3499520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3503616 ++wrote 2048/2048 bytes at offset 3503616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3507712 ++wrote 2048/2048 bytes at offset 3507712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3511808 ++wrote 2048/2048 bytes at offset 3511808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3515904 ++wrote 2048/2048 bytes at offset 3515904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3520000 ++wrote 2048/2048 bytes at offset 3520000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3524096 ++wrote 2048/2048 bytes at offset 3524096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3528192 ++wrote 2048/2048 bytes at offset 3528192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3532288 ++wrote 2048/2048 bytes at offset 3532288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3536384 ++wrote 2048/2048 bytes at offset 3536384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3540480 ++wrote 2048/2048 bytes at offset 3540480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3544576 ++wrote 2048/2048 bytes at offset 3544576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3548672 ++wrote 2048/2048 bytes at offset 3548672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3552768 ++wrote 2048/2048 bytes at offset 3552768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3556864 ++wrote 2048/2048 bytes at offset 3556864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3560960 ++wrote 2048/2048 bytes at offset 3560960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3565056 ++wrote 2048/2048 bytes at offset 3565056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3569152 ++wrote 2048/2048 bytes at offset 3569152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3573248 ++wrote 2048/2048 bytes at offset 3573248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3577344 ++wrote 2048/2048 bytes at offset 3577344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3581440 ++wrote 2048/2048 bytes at offset 3581440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3585536 ++wrote 2048/2048 bytes at offset 3585536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3589632 ++wrote 2048/2048 bytes at offset 3589632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3593728 ++wrote 2048/2048 bytes at offset 3593728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3597824 ++wrote 2048/2048 bytes at offset 3597824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3601920 ++wrote 2048/2048 bytes at offset 3601920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3606016 ++wrote 2048/2048 bytes at offset 3606016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3610112 ++wrote 2048/2048 bytes at offset 3610112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3614208 ++wrote 2048/2048 bytes at offset 3614208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3618304 ++wrote 2048/2048 bytes at offset 3618304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3622400 ++wrote 2048/2048 bytes at offset 3622400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3626496 ++wrote 2048/2048 bytes at offset 3626496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3630592 ++wrote 2048/2048 bytes at offset 3630592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3634688 ++wrote 2048/2048 bytes at offset 3634688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3638784 ++wrote 2048/2048 bytes at offset 3638784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3642880 ++wrote 2048/2048 bytes at offset 3642880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3646976 ++wrote 2048/2048 bytes at offset 3646976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3651072 ++wrote 2048/2048 bytes at offset 3651072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3655168 ++wrote 2048/2048 bytes at offset 3655168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3659264 ++wrote 2048/2048 bytes at offset 3659264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3663360 ++wrote 2048/2048 bytes at offset 3663360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3667456 ++wrote 2048/2048 bytes at offset 3667456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3671552 ++wrote 2048/2048 bytes at offset 3671552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3675648 ++wrote 2048/2048 bytes at offset 3675648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3679744 ++wrote 2048/2048 bytes at offset 3679744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3683840 ++wrote 2048/2048 bytes at offset 3683840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3687936 ++wrote 2048/2048 bytes at offset 3687936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3692032 ++wrote 2048/2048 bytes at offset 3692032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3696128 ++wrote 2048/2048 bytes at offset 3696128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3700224 ++wrote 2048/2048 bytes at offset 3700224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3704320 ++wrote 2048/2048 bytes at offset 3704320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3708416 ++wrote 2048/2048 bytes at offset 3708416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3712512 ++wrote 2048/2048 bytes at offset 3712512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3716608 ++wrote 2048/2048 bytes at offset 3716608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3720704 ++wrote 2048/2048 bytes at offset 3720704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3724800 ++wrote 2048/2048 bytes at offset 3724800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3728896 ++wrote 2048/2048 bytes at offset 3728896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3732992 ++wrote 2048/2048 bytes at offset 3732992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3737088 ++wrote 2048/2048 bytes at offset 3737088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3741184 ++wrote 2048/2048 bytes at offset 3741184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3745280 ++wrote 2048/2048 bytes at offset 3745280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3749376 ++wrote 2048/2048 bytes at offset 3749376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3753472 ++wrote 2048/2048 bytes at offset 3753472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3757568 ++wrote 2048/2048 bytes at offset 3757568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3761664 ++wrote 2048/2048 bytes at offset 3761664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3765760 ++wrote 2048/2048 bytes at offset 3765760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3769856 ++wrote 2048/2048 bytes at offset 3769856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3773952 ++wrote 2048/2048 bytes at offset 3773952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3778048 ++wrote 2048/2048 bytes at offset 3778048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3782144 ++wrote 2048/2048 bytes at offset 3782144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3786240 ++wrote 2048/2048 bytes at offset 3786240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3790336 ++wrote 2048/2048 bytes at offset 3790336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3794432 ++wrote 2048/2048 bytes at offset 3794432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3798528 ++wrote 2048/2048 bytes at offset 3798528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3802624 ++wrote 2048/2048 bytes at offset 3802624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3806720 ++wrote 2048/2048 bytes at offset 3806720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3810816 ++wrote 2048/2048 bytes at offset 3810816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3814912 ++wrote 2048/2048 bytes at offset 3814912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3819008 ++wrote 2048/2048 bytes at offset 3819008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3823104 ++wrote 2048/2048 bytes at offset 3823104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3827200 ++wrote 2048/2048 bytes at offset 3827200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3831296 ++wrote 2048/2048 bytes at offset 3831296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3835392 ++wrote 2048/2048 bytes at offset 3835392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3839488 ++wrote 2048/2048 bytes at offset 3839488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3843584 ++wrote 2048/2048 bytes at offset 3843584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3847680 ++wrote 2048/2048 bytes at offset 3847680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3851776 ++wrote 2048/2048 bytes at offset 3851776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3855872 ++wrote 2048/2048 bytes at offset 3855872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3859968 ++wrote 2048/2048 bytes at offset 3859968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3864064 ++wrote 2048/2048 bytes at offset 3864064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3868160 ++wrote 2048/2048 bytes at offset 3868160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3872256 ++wrote 2048/2048 bytes at offset 3872256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3876352 ++wrote 2048/2048 bytes at offset 3876352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3880448 ++wrote 2048/2048 bytes at offset 3880448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3884544 ++wrote 2048/2048 bytes at offset 3884544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3888640 ++wrote 2048/2048 bytes at offset 3888640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3892736 ++wrote 2048/2048 bytes at offset 3892736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3896832 ++wrote 2048/2048 bytes at offset 3896832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3900928 ++wrote 2048/2048 bytes at offset 3900928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3905024 ++wrote 2048/2048 bytes at offset 3905024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3909120 ++wrote 2048/2048 bytes at offset 3909120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3913216 ++wrote 2048/2048 bytes at offset 3913216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3917312 ++wrote 2048/2048 bytes at offset 3917312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3921408 ++wrote 2048/2048 bytes at offset 3921408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3925504 ++wrote 2048/2048 bytes at offset 3925504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3929600 ++wrote 2048/2048 bytes at offset 3929600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3933696 ++wrote 2048/2048 bytes at offset 3933696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3937792 ++wrote 2048/2048 bytes at offset 3937792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3941888 ++wrote 2048/2048 bytes at offset 3941888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3945984 ++wrote 2048/2048 bytes at offset 3945984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3950080 ++wrote 2048/2048 bytes at offset 3950080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3954176 ++wrote 2048/2048 bytes at offset 3954176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3958272 ++wrote 2048/2048 bytes at offset 3958272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3962368 ++wrote 2048/2048 bytes at offset 3962368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3966464 ++wrote 2048/2048 bytes at offset 3966464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3970560 ++wrote 2048/2048 bytes at offset 3970560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3974656 ++wrote 2048/2048 bytes at offset 3974656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3978752 ++wrote 2048/2048 bytes at offset 3978752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3982848 ++wrote 2048/2048 bytes at offset 3982848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3986944 ++wrote 2048/2048 bytes at offset 3986944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3991040 ++wrote 2048/2048 bytes at offset 3991040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3995136 ++wrote 2048/2048 bytes at offset 3995136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3999232 ++wrote 2048/2048 bytes at offset 3999232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4003328 ++wrote 2048/2048 bytes at offset 4003328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4007424 ++wrote 2048/2048 bytes at offset 4007424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4011520 ++wrote 2048/2048 bytes at offset 4011520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4015616 ++wrote 2048/2048 bytes at offset 4015616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4019712 ++wrote 2048/2048 bytes at offset 4019712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4023808 ++wrote 2048/2048 bytes at offset 4023808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4027904 ++wrote 2048/2048 bytes at offset 4027904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4032000 ++wrote 2048/2048 bytes at offset 4032000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4036096 ++wrote 2048/2048 bytes at offset 4036096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4040192 ++wrote 2048/2048 bytes at offset 4040192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4044288 ++wrote 2048/2048 bytes at offset 4044288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4048384 ++wrote 2048/2048 bytes at offset 4048384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4052480 ++wrote 2048/2048 bytes at offset 4052480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4056576 ++wrote 2048/2048 bytes at offset 4056576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4060672 ++wrote 2048/2048 bytes at offset 4060672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4064768 ++wrote 2048/2048 bytes at offset 4064768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4068864 ++wrote 2048/2048 bytes at offset 4068864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4072960 ++wrote 2048/2048 bytes at offset 4072960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4077056 ++wrote 2048/2048 bytes at offset 4077056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4081152 ++wrote 2048/2048 bytes at offset 4081152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4085248 ++wrote 2048/2048 bytes at offset 4085248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4089344 ++wrote 2048/2048 bytes at offset 4089344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4093440 ++wrote 2048/2048 bytes at offset 4093440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4097536 ++wrote 2048/2048 bytes at offset 4097536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4101632 ++wrote 2048/2048 bytes at offset 4101632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4105728 ++wrote 2048/2048 bytes at offset 4105728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4109824 ++wrote 2048/2048 bytes at offset 4109824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4113920 ++wrote 2048/2048 bytes at offset 4113920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4118016 ++wrote 2048/2048 bytes at offset 4118016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4122112 ++wrote 2048/2048 bytes at offset 4122112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4126208 ++wrote 2048/2048 bytes at offset 4126208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4130304 ++wrote 2048/2048 bytes at offset 4130304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4134400 ++wrote 2048/2048 bytes at offset 4134400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4138496 ++wrote 2048/2048 bytes at offset 4138496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4142592 ++wrote 2048/2048 bytes at offset 4142592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4146688 ++wrote 2048/2048 bytes at offset 4146688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4150784 ++wrote 2048/2048 bytes at offset 4150784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4154880 ++wrote 2048/2048 bytes at offset 4154880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4158976 ++wrote 2048/2048 bytes at offset 4158976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4163072 ++wrote 2048/2048 bytes at offset 4163072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4167168 ++wrote 2048/2048 bytes at offset 4167168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4171264 ++wrote 2048/2048 bytes at offset 4171264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4175360 ++wrote 2048/2048 bytes at offset 4175360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4179456 ++wrote 2048/2048 bytes at offset 4179456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4183552 ++wrote 2048/2048 bytes at offset 4183552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4187648 ++wrote 2048/2048 bytes at offset 4187648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4191744 ++wrote 2048/2048 bytes at offset 4191744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 5 +-qemu-io> wrote 8192/8192 bytes at offset 4196864 ++=== IO: pattern 5 ++wrote 8192/8192 bytes at offset 4196864 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4209152 ++wrote 8192/8192 bytes at offset 4209152 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4221440 ++wrote 8192/8192 bytes at offset 4221440 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4233728 ++wrote 8192/8192 bytes at offset 4233728 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4246016 ++wrote 8192/8192 bytes at offset 4246016 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4258304 ++wrote 8192/8192 bytes at offset 4258304 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4270592 ++wrote 8192/8192 bytes at offset 4270592 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4282880 ++wrote 8192/8192 bytes at offset 4282880 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295168 ++wrote 8192/8192 bytes at offset 4295168 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4307456 ++wrote 8192/8192 bytes at offset 4307456 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4319744 ++wrote 8192/8192 bytes at offset 4319744 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4332032 ++wrote 8192/8192 bytes at offset 4332032 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4344320 ++wrote 8192/8192 bytes at offset 4344320 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4356608 ++wrote 8192/8192 bytes at offset 4356608 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4368896 ++wrote 8192/8192 bytes at offset 4368896 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4381184 ++wrote 8192/8192 bytes at offset 4381184 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4393472 ++wrote 8192/8192 bytes at offset 4393472 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4405760 ++wrote 8192/8192 bytes at offset 4405760 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4418048 ++wrote 8192/8192 bytes at offset 4418048 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4430336 ++wrote 8192/8192 bytes at offset 4430336 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4442624 ++wrote 8192/8192 bytes at offset 4442624 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4454912 ++wrote 8192/8192 bytes at offset 4454912 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4467200 ++wrote 8192/8192 bytes at offset 4467200 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4479488 ++wrote 8192/8192 bytes at offset 4479488 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4491776 ++wrote 8192/8192 bytes at offset 4491776 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4504064 ++wrote 8192/8192 bytes at offset 4504064 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4516352 ++wrote 8192/8192 bytes at offset 4516352 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4528640 ++wrote 8192/8192 bytes at offset 4528640 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4540928 ++wrote 8192/8192 bytes at offset 4540928 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4553216 ++wrote 8192/8192 bytes at offset 4553216 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4565504 ++wrote 8192/8192 bytes at offset 4565504 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4577792 ++wrote 8192/8192 bytes at offset 4577792 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4590080 ++wrote 8192/8192 bytes at offset 4590080 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4602368 ++wrote 8192/8192 bytes at offset 4602368 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4614656 ++wrote 8192/8192 bytes at offset 4614656 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4626944 ++wrote 8192/8192 bytes at offset 4626944 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4639232 ++wrote 8192/8192 bytes at offset 4639232 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4651520 ++wrote 8192/8192 bytes at offset 4651520 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4663808 ++wrote 8192/8192 bytes at offset 4663808 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4676096 ++wrote 8192/8192 bytes at offset 4676096 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4688384 ++wrote 8192/8192 bytes at offset 4688384 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4700672 ++wrote 8192/8192 bytes at offset 4700672 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4712960 ++wrote 8192/8192 bytes at offset 4712960 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4725248 ++wrote 8192/8192 bytes at offset 4725248 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4737536 ++wrote 8192/8192 bytes at offset 4737536 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4749824 ++wrote 8192/8192 bytes at offset 4749824 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4762112 ++wrote 8192/8192 bytes at offset 4762112 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4774400 ++wrote 8192/8192 bytes at offset 4774400 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4786688 ++wrote 8192/8192 bytes at offset 4786688 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4798976 ++wrote 8192/8192 bytes at offset 4798976 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4811264 ++wrote 8192/8192 bytes at offset 4811264 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4823552 ++wrote 8192/8192 bytes at offset 4823552 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4835840 ++wrote 8192/8192 bytes at offset 4835840 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4848128 ++wrote 8192/8192 bytes at offset 4848128 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4860416 ++wrote 8192/8192 bytes at offset 4860416 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4872704 ++wrote 8192/8192 bytes at offset 4872704 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4884992 ++wrote 8192/8192 bytes at offset 4884992 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4897280 ++wrote 8192/8192 bytes at offset 4897280 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4909568 ++wrote 8192/8192 bytes at offset 4909568 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4921856 ++wrote 8192/8192 bytes at offset 4921856 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4934144 ++wrote 8192/8192 bytes at offset 4934144 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4946432 ++wrote 8192/8192 bytes at offset 4946432 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4958720 ++wrote 8192/8192 bytes at offset 4958720 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4971008 ++wrote 8192/8192 bytes at offset 4971008 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 244 +-qemu-io> wrote 12288/12288 bytes at offset 6285312 ++=== IO: pattern 244 ++wrote 12288/12288 bytes at offset 6285312 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 8384512 ++wrote 12288/12288 bytes at offset 8384512 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 10483712 ++wrote 12288/12288 bytes at offset 10483712 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 12582912 ++wrote 12288/12288 bytes at offset 12582912 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 14682112 ++wrote 12288/12288 bytes at offset 14682112 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 16781312 ++wrote 12288/12288 bytes at offset 16781312 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 18880512 ++wrote 12288/12288 bytes at offset 18880512 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 20979712 ++wrote 12288/12288 bytes at offset 20979712 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 1 +-qemu-io> read 4096/4096 bytes at offset 512 ++=== IO: pattern 1 ++read 4096/4096 bytes at offset 512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4608 ++read 4096/4096 bytes at offset 4608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 8704 ++read 4096/4096 bytes at offset 8704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 12800 ++read 4096/4096 bytes at offset 12800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 16896 ++read 4096/4096 bytes at offset 16896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 20992 ++read 4096/4096 bytes at offset 20992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 25088 ++read 4096/4096 bytes at offset 25088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 29184 ++read 4096/4096 bytes at offset 29184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 33280 ++read 4096/4096 bytes at offset 33280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 37376 ++read 4096/4096 bytes at offset 37376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 41472 ++read 4096/4096 bytes at offset 41472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 45568 ++read 4096/4096 bytes at offset 45568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 49664 ++read 4096/4096 bytes at offset 49664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 53760 ++read 4096/4096 bytes at offset 53760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 57856 ++read 4096/4096 bytes at offset 57856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 61952 ++read 4096/4096 bytes at offset 61952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 66048 ++read 4096/4096 bytes at offset 66048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 70144 ++read 4096/4096 bytes at offset 70144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 74240 ++read 4096/4096 bytes at offset 74240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 78336 ++read 4096/4096 bytes at offset 78336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 82432 ++read 4096/4096 bytes at offset 82432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 86528 ++read 4096/4096 bytes at offset 86528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 90624 ++read 4096/4096 bytes at offset 90624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 94720 ++read 4096/4096 bytes at offset 94720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 98816 ++read 4096/4096 bytes at offset 98816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 102912 ++read 4096/4096 bytes at offset 102912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 107008 ++read 4096/4096 bytes at offset 107008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 111104 ++read 4096/4096 bytes at offset 111104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 115200 ++read 4096/4096 bytes at offset 115200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 119296 ++read 4096/4096 bytes at offset 119296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 123392 ++read 4096/4096 bytes at offset 123392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 127488 ++read 4096/4096 bytes at offset 127488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 131584 ++read 4096/4096 bytes at offset 131584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 135680 ++read 4096/4096 bytes at offset 135680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 139776 ++read 4096/4096 bytes at offset 139776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 143872 ++read 4096/4096 bytes at offset 143872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 147968 ++read 4096/4096 bytes at offset 147968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 152064 ++read 4096/4096 bytes at offset 152064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 156160 ++read 4096/4096 bytes at offset 156160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 160256 ++read 4096/4096 bytes at offset 160256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 164352 ++read 4096/4096 bytes at offset 164352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 168448 ++read 4096/4096 bytes at offset 168448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 172544 ++read 4096/4096 bytes at offset 172544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 176640 ++read 4096/4096 bytes at offset 176640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 180736 ++read 4096/4096 bytes at offset 180736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 184832 ++read 4096/4096 bytes at offset 184832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 188928 ++read 4096/4096 bytes at offset 188928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 193024 ++read 4096/4096 bytes at offset 193024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 197120 ++read 4096/4096 bytes at offset 197120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 201216 ++read 4096/4096 bytes at offset 201216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 205312 ++read 4096/4096 bytes at offset 205312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 209408 ++read 4096/4096 bytes at offset 209408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 213504 ++read 4096/4096 bytes at offset 213504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 217600 ++read 4096/4096 bytes at offset 217600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 221696 ++read 4096/4096 bytes at offset 221696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 225792 ++read 4096/4096 bytes at offset 225792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 229888 ++read 4096/4096 bytes at offset 229888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 233984 ++read 4096/4096 bytes at offset 233984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 238080 ++read 4096/4096 bytes at offset 238080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 242176 ++read 4096/4096 bytes at offset 242176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 246272 ++read 4096/4096 bytes at offset 246272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 250368 ++read 4096/4096 bytes at offset 250368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 254464 ++read 4096/4096 bytes at offset 254464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 258560 ++read 4096/4096 bytes at offset 258560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 262656 ++read 4096/4096 bytes at offset 262656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 266752 ++read 4096/4096 bytes at offset 266752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 270848 ++read 4096/4096 bytes at offset 270848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 274944 ++read 4096/4096 bytes at offset 274944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 279040 ++read 4096/4096 bytes at offset 279040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 283136 ++read 4096/4096 bytes at offset 283136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 287232 ++read 4096/4096 bytes at offset 287232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 291328 ++read 4096/4096 bytes at offset 291328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 295424 ++read 4096/4096 bytes at offset 295424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 299520 ++read 4096/4096 bytes at offset 299520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 303616 ++read 4096/4096 bytes at offset 303616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 307712 ++read 4096/4096 bytes at offset 307712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 311808 ++read 4096/4096 bytes at offset 311808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 315904 ++read 4096/4096 bytes at offset 315904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 320000 ++read 4096/4096 bytes at offset 320000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 324096 ++read 4096/4096 bytes at offset 324096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 328192 ++read 4096/4096 bytes at offset 328192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 332288 ++read 4096/4096 bytes at offset 332288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 336384 ++read 4096/4096 bytes at offset 336384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 340480 ++read 4096/4096 bytes at offset 340480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 344576 ++read 4096/4096 bytes at offset 344576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 348672 ++read 4096/4096 bytes at offset 348672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 352768 ++read 4096/4096 bytes at offset 352768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 356864 ++read 4096/4096 bytes at offset 356864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 360960 ++read 4096/4096 bytes at offset 360960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 365056 ++read 4096/4096 bytes at offset 365056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 369152 ++read 4096/4096 bytes at offset 369152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 373248 ++read 4096/4096 bytes at offset 373248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 377344 ++read 4096/4096 bytes at offset 377344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 381440 ++read 4096/4096 bytes at offset 381440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 385536 ++read 4096/4096 bytes at offset 385536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 389632 ++read 4096/4096 bytes at offset 389632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 393728 ++read 4096/4096 bytes at offset 393728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 397824 ++read 4096/4096 bytes at offset 397824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 401920 ++read 4096/4096 bytes at offset 401920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 406016 ++read 4096/4096 bytes at offset 406016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 410112 ++read 4096/4096 bytes at offset 410112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 414208 ++read 4096/4096 bytes at offset 414208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 418304 ++read 4096/4096 bytes at offset 418304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 422400 ++read 4096/4096 bytes at offset 422400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 426496 ++read 4096/4096 bytes at offset 426496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 430592 ++read 4096/4096 bytes at offset 430592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 434688 ++read 4096/4096 bytes at offset 434688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 438784 ++read 4096/4096 bytes at offset 438784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 442880 ++read 4096/4096 bytes at offset 442880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 446976 ++read 4096/4096 bytes at offset 446976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 451072 ++read 4096/4096 bytes at offset 451072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 455168 ++read 4096/4096 bytes at offset 455168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 459264 ++read 4096/4096 bytes at offset 459264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 463360 ++read 4096/4096 bytes at offset 463360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 467456 ++read 4096/4096 bytes at offset 467456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 471552 ++read 4096/4096 bytes at offset 471552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 475648 ++read 4096/4096 bytes at offset 475648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 479744 ++read 4096/4096 bytes at offset 479744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 483840 ++read 4096/4096 bytes at offset 483840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 487936 ++read 4096/4096 bytes at offset 487936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 492032 ++read 4096/4096 bytes at offset 492032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 496128 ++read 4096/4096 bytes at offset 496128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 500224 ++read 4096/4096 bytes at offset 500224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 504320 ++read 4096/4096 bytes at offset 504320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 508416 ++read 4096/4096 bytes at offset 508416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 512512 ++read 4096/4096 bytes at offset 512512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 516608 ++read 4096/4096 bytes at offset 516608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 520704 ++read 4096/4096 bytes at offset 520704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 524800 ++read 4096/4096 bytes at offset 524800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 528896 ++read 4096/4096 bytes at offset 528896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 532992 ++read 4096/4096 bytes at offset 532992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 537088 ++read 4096/4096 bytes at offset 537088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 541184 ++read 4096/4096 bytes at offset 541184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 545280 ++read 4096/4096 bytes at offset 545280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 549376 ++read 4096/4096 bytes at offset 549376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 553472 ++read 4096/4096 bytes at offset 553472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 557568 ++read 4096/4096 bytes at offset 557568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 561664 ++read 4096/4096 bytes at offset 561664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 565760 ++read 4096/4096 bytes at offset 565760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 569856 ++read 4096/4096 bytes at offset 569856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 573952 ++read 4096/4096 bytes at offset 573952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 578048 ++read 4096/4096 bytes at offset 578048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 582144 ++read 4096/4096 bytes at offset 582144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 586240 ++read 4096/4096 bytes at offset 586240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 590336 ++read 4096/4096 bytes at offset 590336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 594432 ++read 4096/4096 bytes at offset 594432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 598528 ++read 4096/4096 bytes at offset 598528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 602624 ++read 4096/4096 bytes at offset 602624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 606720 ++read 4096/4096 bytes at offset 606720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 610816 ++read 4096/4096 bytes at offset 610816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 614912 ++read 4096/4096 bytes at offset 614912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 619008 ++read 4096/4096 bytes at offset 619008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 623104 ++read 4096/4096 bytes at offset 623104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 627200 ++read 4096/4096 bytes at offset 627200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 631296 ++read 4096/4096 bytes at offset 631296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 635392 ++read 4096/4096 bytes at offset 635392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 639488 ++read 4096/4096 bytes at offset 639488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 643584 ++read 4096/4096 bytes at offset 643584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 647680 ++read 4096/4096 bytes at offset 647680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 651776 ++read 4096/4096 bytes at offset 651776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 655872 ++read 4096/4096 bytes at offset 655872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 659968 ++read 4096/4096 bytes at offset 659968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 664064 ++read 4096/4096 bytes at offset 664064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 668160 ++read 4096/4096 bytes at offset 668160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 672256 ++read 4096/4096 bytes at offset 672256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 676352 ++read 4096/4096 bytes at offset 676352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 680448 ++read 4096/4096 bytes at offset 680448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 684544 ++read 4096/4096 bytes at offset 684544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 688640 ++read 4096/4096 bytes at offset 688640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 692736 ++read 4096/4096 bytes at offset 692736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 696832 ++read 4096/4096 bytes at offset 696832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 700928 ++read 4096/4096 bytes at offset 700928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 705024 ++read 4096/4096 bytes at offset 705024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 709120 ++read 4096/4096 bytes at offset 709120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 713216 ++read 4096/4096 bytes at offset 713216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 717312 ++read 4096/4096 bytes at offset 717312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 721408 ++read 4096/4096 bytes at offset 721408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 725504 ++read 4096/4096 bytes at offset 725504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 729600 ++read 4096/4096 bytes at offset 729600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 733696 ++read 4096/4096 bytes at offset 733696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 737792 ++read 4096/4096 bytes at offset 737792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 741888 ++read 4096/4096 bytes at offset 741888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 745984 ++read 4096/4096 bytes at offset 745984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 750080 ++read 4096/4096 bytes at offset 750080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 754176 ++read 4096/4096 bytes at offset 754176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 758272 ++read 4096/4096 bytes at offset 758272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 762368 ++read 4096/4096 bytes at offset 762368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 766464 ++read 4096/4096 bytes at offset 766464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 770560 ++read 4096/4096 bytes at offset 770560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 774656 ++read 4096/4096 bytes at offset 774656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 778752 ++read 4096/4096 bytes at offset 778752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 782848 ++read 4096/4096 bytes at offset 782848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 786944 ++read 4096/4096 bytes at offset 786944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 791040 ++read 4096/4096 bytes at offset 791040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 795136 ++read 4096/4096 bytes at offset 795136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 799232 ++read 4096/4096 bytes at offset 799232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 803328 ++read 4096/4096 bytes at offset 803328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 807424 ++read 4096/4096 bytes at offset 807424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 811520 ++read 4096/4096 bytes at offset 811520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 815616 ++read 4096/4096 bytes at offset 815616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 819712 ++read 4096/4096 bytes at offset 819712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 823808 ++read 4096/4096 bytes at offset 823808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 827904 ++read 4096/4096 bytes at offset 827904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 832000 ++read 4096/4096 bytes at offset 832000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 836096 ++read 4096/4096 bytes at offset 836096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 840192 ++read 4096/4096 bytes at offset 840192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 844288 ++read 4096/4096 bytes at offset 844288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 848384 ++read 4096/4096 bytes at offset 848384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 852480 ++read 4096/4096 bytes at offset 852480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 856576 ++read 4096/4096 bytes at offset 856576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 860672 ++read 4096/4096 bytes at offset 860672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 864768 ++read 4096/4096 bytes at offset 864768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 868864 ++read 4096/4096 bytes at offset 868864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 872960 ++read 4096/4096 bytes at offset 872960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 877056 ++read 4096/4096 bytes at offset 877056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 881152 ++read 4096/4096 bytes at offset 881152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 885248 ++read 4096/4096 bytes at offset 885248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 889344 ++read 4096/4096 bytes at offset 889344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 893440 ++read 4096/4096 bytes at offset 893440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 897536 ++read 4096/4096 bytes at offset 897536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 901632 ++read 4096/4096 bytes at offset 901632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 905728 ++read 4096/4096 bytes at offset 905728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 909824 ++read 4096/4096 bytes at offset 909824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 913920 ++read 4096/4096 bytes at offset 913920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 918016 ++read 4096/4096 bytes at offset 918016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 922112 ++read 4096/4096 bytes at offset 922112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 926208 ++read 4096/4096 bytes at offset 926208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 930304 ++read 4096/4096 bytes at offset 930304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 934400 ++read 4096/4096 bytes at offset 934400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 938496 ++read 4096/4096 bytes at offset 938496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 942592 ++read 4096/4096 bytes at offset 942592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 946688 ++read 4096/4096 bytes at offset 946688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 950784 ++read 4096/4096 bytes at offset 950784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 954880 ++read 4096/4096 bytes at offset 954880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 958976 ++read 4096/4096 bytes at offset 958976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 963072 ++read 4096/4096 bytes at offset 963072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 967168 ++read 4096/4096 bytes at offset 967168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 971264 ++read 4096/4096 bytes at offset 971264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 975360 ++read 4096/4096 bytes at offset 975360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 979456 ++read 4096/4096 bytes at offset 979456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 983552 ++read 4096/4096 bytes at offset 983552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 987648 ++read 4096/4096 bytes at offset 987648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 991744 ++read 4096/4096 bytes at offset 991744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 995840 ++read 4096/4096 bytes at offset 995840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 999936 ++read 4096/4096 bytes at offset 999936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1004032 ++read 4096/4096 bytes at offset 1004032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1008128 ++read 4096/4096 bytes at offset 1008128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1012224 ++read 4096/4096 bytes at offset 1012224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1016320 ++read 4096/4096 bytes at offset 1016320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1020416 ++read 4096/4096 bytes at offset 1020416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1024512 ++read 4096/4096 bytes at offset 1024512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1028608 ++read 4096/4096 bytes at offset 1028608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1032704 ++read 4096/4096 bytes at offset 1032704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1036800 ++read 4096/4096 bytes at offset 1036800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1040896 ++read 4096/4096 bytes at offset 1040896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1044992 ++read 4096/4096 bytes at offset 1044992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 5 +-qemu-io> read 2048/2048 bytes at offset 1051136 ++=== IO: pattern 5 ++read 2048/2048 bytes at offset 1051136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1055232 ++read 2048/2048 bytes at offset 1055232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1059328 ++read 2048/2048 bytes at offset 1059328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1063424 ++read 2048/2048 bytes at offset 1063424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1067520 ++read 2048/2048 bytes at offset 1067520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1071616 ++read 2048/2048 bytes at offset 1071616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1075712 ++read 2048/2048 bytes at offset 1075712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1079808 ++read 2048/2048 bytes at offset 1079808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1083904 ++read 2048/2048 bytes at offset 1083904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1088000 ++read 2048/2048 bytes at offset 1088000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1092096 ++read 2048/2048 bytes at offset 1092096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1096192 ++read 2048/2048 bytes at offset 1096192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1100288 ++read 2048/2048 bytes at offset 1100288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1104384 ++read 2048/2048 bytes at offset 1104384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1108480 ++read 2048/2048 bytes at offset 1108480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1112576 ++read 2048/2048 bytes at offset 1112576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1116672 ++read 2048/2048 bytes at offset 1116672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1120768 ++read 2048/2048 bytes at offset 1120768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1124864 ++read 2048/2048 bytes at offset 1124864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1128960 ++read 2048/2048 bytes at offset 1128960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1133056 ++read 2048/2048 bytes at offset 1133056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1137152 ++read 2048/2048 bytes at offset 1137152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1141248 ++read 2048/2048 bytes at offset 1141248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1145344 ++read 2048/2048 bytes at offset 1145344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1149440 ++read 2048/2048 bytes at offset 1149440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1153536 ++read 2048/2048 bytes at offset 1153536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1157632 ++read 2048/2048 bytes at offset 1157632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1161728 ++read 2048/2048 bytes at offset 1161728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1165824 ++read 2048/2048 bytes at offset 1165824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1169920 ++read 2048/2048 bytes at offset 1169920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1174016 ++read 2048/2048 bytes at offset 1174016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1178112 ++read 2048/2048 bytes at offset 1178112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1182208 ++read 2048/2048 bytes at offset 1182208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1186304 ++read 2048/2048 bytes at offset 1186304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1190400 ++read 2048/2048 bytes at offset 1190400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1194496 ++read 2048/2048 bytes at offset 1194496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1198592 ++read 2048/2048 bytes at offset 1198592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1202688 ++read 2048/2048 bytes at offset 1202688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1206784 ++read 2048/2048 bytes at offset 1206784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1210880 ++read 2048/2048 bytes at offset 1210880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1214976 ++read 2048/2048 bytes at offset 1214976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1219072 ++read 2048/2048 bytes at offset 1219072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1223168 ++read 2048/2048 bytes at offset 1223168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1227264 ++read 2048/2048 bytes at offset 1227264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1231360 ++read 2048/2048 bytes at offset 1231360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1235456 ++read 2048/2048 bytes at offset 1235456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1239552 ++read 2048/2048 bytes at offset 1239552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1243648 ++read 2048/2048 bytes at offset 1243648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1247744 ++read 2048/2048 bytes at offset 1247744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1251840 ++read 2048/2048 bytes at offset 1251840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1255936 ++read 2048/2048 bytes at offset 1255936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1260032 ++read 2048/2048 bytes at offset 1260032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1264128 ++read 2048/2048 bytes at offset 1264128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1268224 ++read 2048/2048 bytes at offset 1268224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1272320 ++read 2048/2048 bytes at offset 1272320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1276416 ++read 2048/2048 bytes at offset 1276416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1280512 ++read 2048/2048 bytes at offset 1280512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1284608 ++read 2048/2048 bytes at offset 1284608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1288704 ++read 2048/2048 bytes at offset 1288704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1292800 ++read 2048/2048 bytes at offset 1292800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1296896 ++read 2048/2048 bytes at offset 1296896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1300992 ++read 2048/2048 bytes at offset 1300992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1305088 ++read 2048/2048 bytes at offset 1305088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1309184 ++read 2048/2048 bytes at offset 1309184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1313280 ++read 2048/2048 bytes at offset 1313280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1317376 ++read 2048/2048 bytes at offset 1317376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1321472 ++read 2048/2048 bytes at offset 1321472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1325568 ++read 2048/2048 bytes at offset 1325568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1329664 ++read 2048/2048 bytes at offset 1329664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1333760 ++read 2048/2048 bytes at offset 1333760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1337856 ++read 2048/2048 bytes at offset 1337856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1341952 ++read 2048/2048 bytes at offset 1341952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1346048 ++read 2048/2048 bytes at offset 1346048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1350144 ++read 2048/2048 bytes at offset 1350144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1354240 ++read 2048/2048 bytes at offset 1354240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1358336 ++read 2048/2048 bytes at offset 1358336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1362432 ++read 2048/2048 bytes at offset 1362432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1366528 ++read 2048/2048 bytes at offset 1366528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1370624 ++read 2048/2048 bytes at offset 1370624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1374720 ++read 2048/2048 bytes at offset 1374720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1378816 ++read 2048/2048 bytes at offset 1378816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1382912 ++read 2048/2048 bytes at offset 1382912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1387008 ++read 2048/2048 bytes at offset 1387008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1391104 ++read 2048/2048 bytes at offset 1391104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1395200 ++read 2048/2048 bytes at offset 1395200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1399296 ++read 2048/2048 bytes at offset 1399296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1403392 ++read 2048/2048 bytes at offset 1403392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1407488 ++read 2048/2048 bytes at offset 1407488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1411584 ++read 2048/2048 bytes at offset 1411584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1415680 ++read 2048/2048 bytes at offset 1415680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1419776 ++read 2048/2048 bytes at offset 1419776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1423872 ++read 2048/2048 bytes at offset 1423872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1427968 ++read 2048/2048 bytes at offset 1427968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1432064 ++read 2048/2048 bytes at offset 1432064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1436160 ++read 2048/2048 bytes at offset 1436160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1440256 ++read 2048/2048 bytes at offset 1440256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1444352 ++read 2048/2048 bytes at offset 1444352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1448448 ++read 2048/2048 bytes at offset 1448448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1452544 ++read 2048/2048 bytes at offset 1452544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1456640 ++read 2048/2048 bytes at offset 1456640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1460736 ++read 2048/2048 bytes at offset 1460736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1464832 ++read 2048/2048 bytes at offset 1464832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1468928 ++read 2048/2048 bytes at offset 1468928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1473024 ++read 2048/2048 bytes at offset 1473024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1477120 ++read 2048/2048 bytes at offset 1477120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1481216 ++read 2048/2048 bytes at offset 1481216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1485312 ++read 2048/2048 bytes at offset 1485312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1489408 ++read 2048/2048 bytes at offset 1489408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1493504 ++read 2048/2048 bytes at offset 1493504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1497600 ++read 2048/2048 bytes at offset 1497600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1501696 ++read 2048/2048 bytes at offset 1501696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1505792 ++read 2048/2048 bytes at offset 1505792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1509888 ++read 2048/2048 bytes at offset 1509888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1513984 ++read 2048/2048 bytes at offset 1513984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1518080 ++read 2048/2048 bytes at offset 1518080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1522176 ++read 2048/2048 bytes at offset 1522176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1526272 ++read 2048/2048 bytes at offset 1526272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1530368 ++read 2048/2048 bytes at offset 1530368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1534464 ++read 2048/2048 bytes at offset 1534464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1538560 ++read 2048/2048 bytes at offset 1538560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1542656 ++read 2048/2048 bytes at offset 1542656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1546752 ++read 2048/2048 bytes at offset 1546752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1550848 ++read 2048/2048 bytes at offset 1550848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1554944 ++read 2048/2048 bytes at offset 1554944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1559040 ++read 2048/2048 bytes at offset 1559040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1563136 ++read 2048/2048 bytes at offset 1563136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1567232 ++read 2048/2048 bytes at offset 1567232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1571328 ++read 2048/2048 bytes at offset 1571328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1575424 ++read 2048/2048 bytes at offset 1575424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1579520 ++read 2048/2048 bytes at offset 1579520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1583616 ++read 2048/2048 bytes at offset 1583616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1587712 ++read 2048/2048 bytes at offset 1587712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1591808 ++read 2048/2048 bytes at offset 1591808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1595904 ++read 2048/2048 bytes at offset 1595904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1600000 ++read 2048/2048 bytes at offset 1600000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1604096 ++read 2048/2048 bytes at offset 1604096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1608192 ++read 2048/2048 bytes at offset 1608192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1612288 ++read 2048/2048 bytes at offset 1612288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1616384 ++read 2048/2048 bytes at offset 1616384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1620480 ++read 2048/2048 bytes at offset 1620480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1624576 ++read 2048/2048 bytes at offset 1624576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1628672 ++read 2048/2048 bytes at offset 1628672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1632768 ++read 2048/2048 bytes at offset 1632768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1636864 ++read 2048/2048 bytes at offset 1636864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1640960 ++read 2048/2048 bytes at offset 1640960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1645056 ++read 2048/2048 bytes at offset 1645056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1649152 ++read 2048/2048 bytes at offset 1649152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1653248 ++read 2048/2048 bytes at offset 1653248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1657344 ++read 2048/2048 bytes at offset 1657344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1661440 ++read 2048/2048 bytes at offset 1661440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1665536 ++read 2048/2048 bytes at offset 1665536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1669632 ++read 2048/2048 bytes at offset 1669632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1673728 ++read 2048/2048 bytes at offset 1673728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1677824 ++read 2048/2048 bytes at offset 1677824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1681920 ++read 2048/2048 bytes at offset 1681920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1686016 ++read 2048/2048 bytes at offset 1686016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1690112 ++read 2048/2048 bytes at offset 1690112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1694208 ++read 2048/2048 bytes at offset 1694208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1698304 ++read 2048/2048 bytes at offset 1698304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1702400 ++read 2048/2048 bytes at offset 1702400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1706496 ++read 2048/2048 bytes at offset 1706496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1710592 ++read 2048/2048 bytes at offset 1710592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1714688 ++read 2048/2048 bytes at offset 1714688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1718784 ++read 2048/2048 bytes at offset 1718784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1722880 ++read 2048/2048 bytes at offset 1722880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1726976 ++read 2048/2048 bytes at offset 1726976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1731072 ++read 2048/2048 bytes at offset 1731072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1735168 ++read 2048/2048 bytes at offset 1735168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1739264 ++read 2048/2048 bytes at offset 1739264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1743360 ++read 2048/2048 bytes at offset 1743360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1747456 ++read 2048/2048 bytes at offset 1747456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1751552 ++read 2048/2048 bytes at offset 1751552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1755648 ++read 2048/2048 bytes at offset 1755648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1759744 ++read 2048/2048 bytes at offset 1759744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1763840 ++read 2048/2048 bytes at offset 1763840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1767936 ++read 2048/2048 bytes at offset 1767936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1772032 ++read 2048/2048 bytes at offset 1772032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1776128 ++read 2048/2048 bytes at offset 1776128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1780224 ++read 2048/2048 bytes at offset 1780224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1784320 ++read 2048/2048 bytes at offset 1784320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1788416 ++read 2048/2048 bytes at offset 1788416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1792512 ++read 2048/2048 bytes at offset 1792512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1796608 ++read 2048/2048 bytes at offset 1796608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1800704 ++read 2048/2048 bytes at offset 1800704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1804800 ++read 2048/2048 bytes at offset 1804800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1808896 ++read 2048/2048 bytes at offset 1808896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1812992 ++read 2048/2048 bytes at offset 1812992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1817088 ++read 2048/2048 bytes at offset 1817088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1821184 ++read 2048/2048 bytes at offset 1821184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1825280 ++read 2048/2048 bytes at offset 1825280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1829376 ++read 2048/2048 bytes at offset 1829376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1833472 ++read 2048/2048 bytes at offset 1833472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1837568 ++read 2048/2048 bytes at offset 1837568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1841664 ++read 2048/2048 bytes at offset 1841664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1845760 ++read 2048/2048 bytes at offset 1845760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1849856 ++read 2048/2048 bytes at offset 1849856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1853952 ++read 2048/2048 bytes at offset 1853952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1858048 ++read 2048/2048 bytes at offset 1858048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1862144 ++read 2048/2048 bytes at offset 1862144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1866240 ++read 2048/2048 bytes at offset 1866240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1870336 ++read 2048/2048 bytes at offset 1870336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1874432 ++read 2048/2048 bytes at offset 1874432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1878528 ++read 2048/2048 bytes at offset 1878528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1882624 ++read 2048/2048 bytes at offset 1882624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1886720 ++read 2048/2048 bytes at offset 1886720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1890816 ++read 2048/2048 bytes at offset 1890816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1894912 ++read 2048/2048 bytes at offset 1894912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1899008 ++read 2048/2048 bytes at offset 1899008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1903104 ++read 2048/2048 bytes at offset 1903104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1907200 ++read 2048/2048 bytes at offset 1907200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1911296 ++read 2048/2048 bytes at offset 1911296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1915392 ++read 2048/2048 bytes at offset 1915392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1919488 ++read 2048/2048 bytes at offset 1919488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1923584 ++read 2048/2048 bytes at offset 1923584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1927680 ++read 2048/2048 bytes at offset 1927680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1931776 ++read 2048/2048 bytes at offset 1931776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1935872 ++read 2048/2048 bytes at offset 1935872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1939968 ++read 2048/2048 bytes at offset 1939968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1944064 ++read 2048/2048 bytes at offset 1944064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1948160 ++read 2048/2048 bytes at offset 1948160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1952256 ++read 2048/2048 bytes at offset 1952256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1956352 ++read 2048/2048 bytes at offset 1956352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1960448 ++read 2048/2048 bytes at offset 1960448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1964544 ++read 2048/2048 bytes at offset 1964544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1968640 ++read 2048/2048 bytes at offset 1968640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1972736 ++read 2048/2048 bytes at offset 1972736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1976832 ++read 2048/2048 bytes at offset 1976832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1980928 ++read 2048/2048 bytes at offset 1980928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1985024 ++read 2048/2048 bytes at offset 1985024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1989120 ++read 2048/2048 bytes at offset 1989120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1993216 ++read 2048/2048 bytes at offset 1993216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1997312 ++read 2048/2048 bytes at offset 1997312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2001408 ++read 2048/2048 bytes at offset 2001408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2005504 ++read 2048/2048 bytes at offset 2005504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2009600 ++read 2048/2048 bytes at offset 2009600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2013696 ++read 2048/2048 bytes at offset 2013696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2017792 ++read 2048/2048 bytes at offset 2017792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2021888 ++read 2048/2048 bytes at offset 2021888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2025984 ++read 2048/2048 bytes at offset 2025984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2030080 ++read 2048/2048 bytes at offset 2030080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2034176 ++read 2048/2048 bytes at offset 2034176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2038272 ++read 2048/2048 bytes at offset 2038272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2042368 ++read 2048/2048 bytes at offset 2042368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2046464 ++read 2048/2048 bytes at offset 2046464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2050560 ++read 2048/2048 bytes at offset 2050560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2054656 ++read 2048/2048 bytes at offset 2054656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2058752 ++read 2048/2048 bytes at offset 2058752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2062848 ++read 2048/2048 bytes at offset 2062848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2066944 ++read 2048/2048 bytes at offset 2066944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2071040 ++read 2048/2048 bytes at offset 2071040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2075136 ++read 2048/2048 bytes at offset 2075136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2079232 ++read 2048/2048 bytes at offset 2079232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2083328 ++read 2048/2048 bytes at offset 2083328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2087424 ++read 2048/2048 bytes at offset 2087424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2091520 ++read 2048/2048 bytes at offset 2091520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2095616 ++read 2048/2048 bytes at offset 2095616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 1 +-qemu-io> read 2048/2048 bytes at offset 2097664 ++=== IO: pattern 1 ++read 2048/2048 bytes at offset 2097664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2101760 ++read 2048/2048 bytes at offset 2101760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2105856 ++read 2048/2048 bytes at offset 2105856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2109952 ++read 2048/2048 bytes at offset 2109952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2114048 ++read 2048/2048 bytes at offset 2114048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2118144 ++read 2048/2048 bytes at offset 2118144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2122240 ++read 2048/2048 bytes at offset 2122240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2126336 ++read 2048/2048 bytes at offset 2126336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2130432 ++read 2048/2048 bytes at offset 2130432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2134528 ++read 2048/2048 bytes at offset 2134528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2138624 ++read 2048/2048 bytes at offset 2138624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2142720 ++read 2048/2048 bytes at offset 2142720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2146816 ++read 2048/2048 bytes at offset 2146816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2150912 ++read 2048/2048 bytes at offset 2150912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2155008 ++read 2048/2048 bytes at offset 2155008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2159104 ++read 2048/2048 bytes at offset 2159104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2163200 ++read 2048/2048 bytes at offset 2163200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2167296 ++read 2048/2048 bytes at offset 2167296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2171392 ++read 2048/2048 bytes at offset 2171392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2175488 ++read 2048/2048 bytes at offset 2175488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2179584 ++read 2048/2048 bytes at offset 2179584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2183680 ++read 2048/2048 bytes at offset 2183680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2187776 ++read 2048/2048 bytes at offset 2187776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2191872 ++read 2048/2048 bytes at offset 2191872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2195968 ++read 2048/2048 bytes at offset 2195968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2200064 ++read 2048/2048 bytes at offset 2200064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2204160 ++read 2048/2048 bytes at offset 2204160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2208256 ++read 2048/2048 bytes at offset 2208256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2212352 ++read 2048/2048 bytes at offset 2212352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2216448 ++read 2048/2048 bytes at offset 2216448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2220544 ++read 2048/2048 bytes at offset 2220544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2224640 ++read 2048/2048 bytes at offset 2224640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2228736 ++read 2048/2048 bytes at offset 2228736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2232832 ++read 2048/2048 bytes at offset 2232832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2236928 ++read 2048/2048 bytes at offset 2236928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2241024 ++read 2048/2048 bytes at offset 2241024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2245120 ++read 2048/2048 bytes at offset 2245120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2249216 ++read 2048/2048 bytes at offset 2249216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2253312 ++read 2048/2048 bytes at offset 2253312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2257408 ++read 2048/2048 bytes at offset 2257408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2261504 ++read 2048/2048 bytes at offset 2261504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2265600 ++read 2048/2048 bytes at offset 2265600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2269696 ++read 2048/2048 bytes at offset 2269696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2273792 ++read 2048/2048 bytes at offset 2273792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2277888 ++read 2048/2048 bytes at offset 2277888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2281984 ++read 2048/2048 bytes at offset 2281984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2286080 ++read 2048/2048 bytes at offset 2286080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2290176 ++read 2048/2048 bytes at offset 2290176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2294272 ++read 2048/2048 bytes at offset 2294272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2298368 ++read 2048/2048 bytes at offset 2298368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2302464 ++read 2048/2048 bytes at offset 2302464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2306560 ++read 2048/2048 bytes at offset 2306560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2310656 ++read 2048/2048 bytes at offset 2310656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2314752 ++read 2048/2048 bytes at offset 2314752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2318848 ++read 2048/2048 bytes at offset 2318848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2322944 ++read 2048/2048 bytes at offset 2322944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2327040 ++read 2048/2048 bytes at offset 2327040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2331136 ++read 2048/2048 bytes at offset 2331136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2335232 ++read 2048/2048 bytes at offset 2335232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2339328 ++read 2048/2048 bytes at offset 2339328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2343424 ++read 2048/2048 bytes at offset 2343424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2347520 ++read 2048/2048 bytes at offset 2347520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2351616 ++read 2048/2048 bytes at offset 2351616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2355712 ++read 2048/2048 bytes at offset 2355712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2359808 ++read 2048/2048 bytes at offset 2359808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2363904 ++read 2048/2048 bytes at offset 2363904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2368000 ++read 2048/2048 bytes at offset 2368000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2372096 ++read 2048/2048 bytes at offset 2372096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2376192 ++read 2048/2048 bytes at offset 2376192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2380288 ++read 2048/2048 bytes at offset 2380288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2384384 ++read 2048/2048 bytes at offset 2384384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2388480 ++read 2048/2048 bytes at offset 2388480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2392576 ++read 2048/2048 bytes at offset 2392576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2396672 ++read 2048/2048 bytes at offset 2396672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2400768 ++read 2048/2048 bytes at offset 2400768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2404864 ++read 2048/2048 bytes at offset 2404864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2408960 ++read 2048/2048 bytes at offset 2408960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2413056 ++read 2048/2048 bytes at offset 2413056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2417152 ++read 2048/2048 bytes at offset 2417152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2421248 ++read 2048/2048 bytes at offset 2421248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2425344 ++read 2048/2048 bytes at offset 2425344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2429440 ++read 2048/2048 bytes at offset 2429440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2433536 ++read 2048/2048 bytes at offset 2433536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2437632 ++read 2048/2048 bytes at offset 2437632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2441728 ++read 2048/2048 bytes at offset 2441728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2445824 ++read 2048/2048 bytes at offset 2445824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2449920 ++read 2048/2048 bytes at offset 2449920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2454016 ++read 2048/2048 bytes at offset 2454016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2458112 ++read 2048/2048 bytes at offset 2458112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2462208 ++read 2048/2048 bytes at offset 2462208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2466304 ++read 2048/2048 bytes at offset 2466304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2470400 ++read 2048/2048 bytes at offset 2470400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2474496 ++read 2048/2048 bytes at offset 2474496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2478592 ++read 2048/2048 bytes at offset 2478592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2482688 ++read 2048/2048 bytes at offset 2482688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2486784 ++read 2048/2048 bytes at offset 2486784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2490880 ++read 2048/2048 bytes at offset 2490880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2494976 ++read 2048/2048 bytes at offset 2494976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2499072 ++read 2048/2048 bytes at offset 2499072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2503168 ++read 2048/2048 bytes at offset 2503168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2507264 ++read 2048/2048 bytes at offset 2507264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2511360 ++read 2048/2048 bytes at offset 2511360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2515456 ++read 2048/2048 bytes at offset 2515456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2519552 ++read 2048/2048 bytes at offset 2519552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2523648 ++read 2048/2048 bytes at offset 2523648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2527744 ++read 2048/2048 bytes at offset 2527744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2531840 ++read 2048/2048 bytes at offset 2531840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2535936 ++read 2048/2048 bytes at offset 2535936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2540032 ++read 2048/2048 bytes at offset 2540032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2544128 ++read 2048/2048 bytes at offset 2544128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2548224 ++read 2048/2048 bytes at offset 2548224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2552320 ++read 2048/2048 bytes at offset 2552320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2556416 ++read 2048/2048 bytes at offset 2556416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2560512 ++read 2048/2048 bytes at offset 2560512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2564608 ++read 2048/2048 bytes at offset 2564608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2568704 ++read 2048/2048 bytes at offset 2568704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2572800 ++read 2048/2048 bytes at offset 2572800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2576896 ++read 2048/2048 bytes at offset 2576896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2580992 ++read 2048/2048 bytes at offset 2580992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2585088 ++read 2048/2048 bytes at offset 2585088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2589184 ++read 2048/2048 bytes at offset 2589184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2593280 ++read 2048/2048 bytes at offset 2593280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2597376 ++read 2048/2048 bytes at offset 2597376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2601472 ++read 2048/2048 bytes at offset 2601472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2605568 ++read 2048/2048 bytes at offset 2605568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2609664 ++read 2048/2048 bytes at offset 2609664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2613760 ++read 2048/2048 bytes at offset 2613760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2617856 ++read 2048/2048 bytes at offset 2617856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2621952 ++read 2048/2048 bytes at offset 2621952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2626048 ++read 2048/2048 bytes at offset 2626048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2630144 ++read 2048/2048 bytes at offset 2630144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2634240 ++read 2048/2048 bytes at offset 2634240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2638336 ++read 2048/2048 bytes at offset 2638336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2642432 ++read 2048/2048 bytes at offset 2642432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2646528 ++read 2048/2048 bytes at offset 2646528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2650624 ++read 2048/2048 bytes at offset 2650624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2654720 ++read 2048/2048 bytes at offset 2654720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2658816 ++read 2048/2048 bytes at offset 2658816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2662912 ++read 2048/2048 bytes at offset 2662912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2667008 ++read 2048/2048 bytes at offset 2667008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2671104 ++read 2048/2048 bytes at offset 2671104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2675200 ++read 2048/2048 bytes at offset 2675200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2679296 ++read 2048/2048 bytes at offset 2679296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2683392 ++read 2048/2048 bytes at offset 2683392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2687488 ++read 2048/2048 bytes at offset 2687488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2691584 ++read 2048/2048 bytes at offset 2691584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2695680 ++read 2048/2048 bytes at offset 2695680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2699776 ++read 2048/2048 bytes at offset 2699776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2703872 ++read 2048/2048 bytes at offset 2703872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2707968 ++read 2048/2048 bytes at offset 2707968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2712064 ++read 2048/2048 bytes at offset 2712064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2716160 ++read 2048/2048 bytes at offset 2716160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2720256 ++read 2048/2048 bytes at offset 2720256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2724352 ++read 2048/2048 bytes at offset 2724352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2728448 ++read 2048/2048 bytes at offset 2728448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2732544 ++read 2048/2048 bytes at offset 2732544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2736640 ++read 2048/2048 bytes at offset 2736640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2740736 ++read 2048/2048 bytes at offset 2740736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2744832 ++read 2048/2048 bytes at offset 2744832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2748928 ++read 2048/2048 bytes at offset 2748928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2753024 ++read 2048/2048 bytes at offset 2753024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2757120 ++read 2048/2048 bytes at offset 2757120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2761216 ++read 2048/2048 bytes at offset 2761216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2765312 ++read 2048/2048 bytes at offset 2765312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2769408 ++read 2048/2048 bytes at offset 2769408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2773504 ++read 2048/2048 bytes at offset 2773504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2777600 ++read 2048/2048 bytes at offset 2777600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2781696 ++read 2048/2048 bytes at offset 2781696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2785792 ++read 2048/2048 bytes at offset 2785792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2789888 ++read 2048/2048 bytes at offset 2789888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2793984 ++read 2048/2048 bytes at offset 2793984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2798080 ++read 2048/2048 bytes at offset 2798080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2802176 ++read 2048/2048 bytes at offset 2802176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2806272 ++read 2048/2048 bytes at offset 2806272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2810368 ++read 2048/2048 bytes at offset 2810368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2814464 ++read 2048/2048 bytes at offset 2814464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2818560 ++read 2048/2048 bytes at offset 2818560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2822656 ++read 2048/2048 bytes at offset 2822656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2826752 ++read 2048/2048 bytes at offset 2826752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2830848 ++read 2048/2048 bytes at offset 2830848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2834944 ++read 2048/2048 bytes at offset 2834944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2839040 ++read 2048/2048 bytes at offset 2839040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2843136 ++read 2048/2048 bytes at offset 2843136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2847232 ++read 2048/2048 bytes at offset 2847232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2851328 ++read 2048/2048 bytes at offset 2851328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2855424 ++read 2048/2048 bytes at offset 2855424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2859520 ++read 2048/2048 bytes at offset 2859520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2863616 ++read 2048/2048 bytes at offset 2863616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2867712 ++read 2048/2048 bytes at offset 2867712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2871808 ++read 2048/2048 bytes at offset 2871808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2875904 ++read 2048/2048 bytes at offset 2875904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2880000 ++read 2048/2048 bytes at offset 2880000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2884096 ++read 2048/2048 bytes at offset 2884096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2888192 ++read 2048/2048 bytes at offset 2888192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2892288 ++read 2048/2048 bytes at offset 2892288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2896384 ++read 2048/2048 bytes at offset 2896384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2900480 ++read 2048/2048 bytes at offset 2900480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2904576 ++read 2048/2048 bytes at offset 2904576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2908672 ++read 2048/2048 bytes at offset 2908672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2912768 ++read 2048/2048 bytes at offset 2912768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2916864 ++read 2048/2048 bytes at offset 2916864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2920960 ++read 2048/2048 bytes at offset 2920960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2925056 ++read 2048/2048 bytes at offset 2925056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2929152 ++read 2048/2048 bytes at offset 2929152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2933248 ++read 2048/2048 bytes at offset 2933248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2937344 ++read 2048/2048 bytes at offset 2937344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2941440 ++read 2048/2048 bytes at offset 2941440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2945536 ++read 2048/2048 bytes at offset 2945536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2949632 ++read 2048/2048 bytes at offset 2949632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2953728 ++read 2048/2048 bytes at offset 2953728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2957824 ++read 2048/2048 bytes at offset 2957824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2961920 ++read 2048/2048 bytes at offset 2961920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2966016 ++read 2048/2048 bytes at offset 2966016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2970112 ++read 2048/2048 bytes at offset 2970112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2974208 ++read 2048/2048 bytes at offset 2974208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2978304 ++read 2048/2048 bytes at offset 2978304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2982400 ++read 2048/2048 bytes at offset 2982400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2986496 ++read 2048/2048 bytes at offset 2986496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2990592 ++read 2048/2048 bytes at offset 2990592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2994688 ++read 2048/2048 bytes at offset 2994688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2998784 ++read 2048/2048 bytes at offset 2998784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3002880 ++read 2048/2048 bytes at offset 3002880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3006976 ++read 2048/2048 bytes at offset 3006976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3011072 ++read 2048/2048 bytes at offset 3011072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3015168 ++read 2048/2048 bytes at offset 3015168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3019264 ++read 2048/2048 bytes at offset 3019264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3023360 ++read 2048/2048 bytes at offset 3023360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3027456 ++read 2048/2048 bytes at offset 3027456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3031552 ++read 2048/2048 bytes at offset 3031552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3035648 ++read 2048/2048 bytes at offset 3035648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3039744 ++read 2048/2048 bytes at offset 3039744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3043840 ++read 2048/2048 bytes at offset 3043840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3047936 ++read 2048/2048 bytes at offset 3047936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3052032 ++read 2048/2048 bytes at offset 3052032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3056128 ++read 2048/2048 bytes at offset 3056128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3060224 ++read 2048/2048 bytes at offset 3060224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3064320 ++read 2048/2048 bytes at offset 3064320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3068416 ++read 2048/2048 bytes at offset 3068416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3072512 ++read 2048/2048 bytes at offset 3072512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3076608 ++read 2048/2048 bytes at offset 3076608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3080704 ++read 2048/2048 bytes at offset 3080704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3084800 ++read 2048/2048 bytes at offset 3084800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3088896 ++read 2048/2048 bytes at offset 3088896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3092992 ++read 2048/2048 bytes at offset 3092992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3097088 ++read 2048/2048 bytes at offset 3097088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3101184 ++read 2048/2048 bytes at offset 3101184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3105280 ++read 2048/2048 bytes at offset 3105280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3109376 ++read 2048/2048 bytes at offset 3109376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3113472 ++read 2048/2048 bytes at offset 3113472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3117568 ++read 2048/2048 bytes at offset 3117568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3121664 ++read 2048/2048 bytes at offset 3121664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3125760 ++read 2048/2048 bytes at offset 3125760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3129856 ++read 2048/2048 bytes at offset 3129856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3133952 ++read 2048/2048 bytes at offset 3133952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3138048 ++read 2048/2048 bytes at offset 3138048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3142144 ++read 2048/2048 bytes at offset 3142144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 3 +-qemu-io> read 2048/2048 bytes at offset 3147264 ++=== IO: pattern 3 ++read 2048/2048 bytes at offset 3147264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3151360 ++read 2048/2048 bytes at offset 3151360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3155456 ++read 2048/2048 bytes at offset 3155456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3159552 ++read 2048/2048 bytes at offset 3159552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3163648 ++read 2048/2048 bytes at offset 3163648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3167744 ++read 2048/2048 bytes at offset 3167744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3171840 ++read 2048/2048 bytes at offset 3171840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3175936 ++read 2048/2048 bytes at offset 3175936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3180032 ++read 2048/2048 bytes at offset 3180032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3184128 ++read 2048/2048 bytes at offset 3184128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3188224 ++read 2048/2048 bytes at offset 3188224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3192320 ++read 2048/2048 bytes at offset 3192320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3196416 ++read 2048/2048 bytes at offset 3196416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3200512 ++read 2048/2048 bytes at offset 3200512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3204608 ++read 2048/2048 bytes at offset 3204608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3208704 ++read 2048/2048 bytes at offset 3208704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3212800 ++read 2048/2048 bytes at offset 3212800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3216896 ++read 2048/2048 bytes at offset 3216896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3220992 ++read 2048/2048 bytes at offset 3220992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3225088 ++read 2048/2048 bytes at offset 3225088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3229184 ++read 2048/2048 bytes at offset 3229184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3233280 ++read 2048/2048 bytes at offset 3233280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3237376 ++read 2048/2048 bytes at offset 3237376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3241472 ++read 2048/2048 bytes at offset 3241472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3245568 ++read 2048/2048 bytes at offset 3245568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3249664 ++read 2048/2048 bytes at offset 3249664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3253760 ++read 2048/2048 bytes at offset 3253760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3257856 ++read 2048/2048 bytes at offset 3257856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3261952 ++read 2048/2048 bytes at offset 3261952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3266048 ++read 2048/2048 bytes at offset 3266048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3270144 ++read 2048/2048 bytes at offset 3270144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3274240 ++read 2048/2048 bytes at offset 3274240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3278336 ++read 2048/2048 bytes at offset 3278336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3282432 ++read 2048/2048 bytes at offset 3282432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3286528 ++read 2048/2048 bytes at offset 3286528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3290624 ++read 2048/2048 bytes at offset 3290624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3294720 ++read 2048/2048 bytes at offset 3294720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3298816 ++read 2048/2048 bytes at offset 3298816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3302912 ++read 2048/2048 bytes at offset 3302912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3307008 ++read 2048/2048 bytes at offset 3307008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3311104 ++read 2048/2048 bytes at offset 3311104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3315200 ++read 2048/2048 bytes at offset 3315200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3319296 ++read 2048/2048 bytes at offset 3319296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3323392 ++read 2048/2048 bytes at offset 3323392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3327488 ++read 2048/2048 bytes at offset 3327488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3331584 ++read 2048/2048 bytes at offset 3331584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3335680 ++read 2048/2048 bytes at offset 3335680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3339776 ++read 2048/2048 bytes at offset 3339776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3343872 ++read 2048/2048 bytes at offset 3343872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3347968 ++read 2048/2048 bytes at offset 3347968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3352064 ++read 2048/2048 bytes at offset 3352064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3356160 ++read 2048/2048 bytes at offset 3356160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3360256 ++read 2048/2048 bytes at offset 3360256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3364352 ++read 2048/2048 bytes at offset 3364352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3368448 ++read 2048/2048 bytes at offset 3368448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3372544 ++read 2048/2048 bytes at offset 3372544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3376640 ++read 2048/2048 bytes at offset 3376640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3380736 ++read 2048/2048 bytes at offset 3380736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3384832 ++read 2048/2048 bytes at offset 3384832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3388928 ++read 2048/2048 bytes at offset 3388928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3393024 ++read 2048/2048 bytes at offset 3393024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3397120 ++read 2048/2048 bytes at offset 3397120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3401216 ++read 2048/2048 bytes at offset 3401216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3405312 ++read 2048/2048 bytes at offset 3405312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3409408 ++read 2048/2048 bytes at offset 3409408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3413504 ++read 2048/2048 bytes at offset 3413504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3417600 ++read 2048/2048 bytes at offset 3417600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3421696 ++read 2048/2048 bytes at offset 3421696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3425792 ++read 2048/2048 bytes at offset 3425792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3429888 ++read 2048/2048 bytes at offset 3429888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3433984 ++read 2048/2048 bytes at offset 3433984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3438080 ++read 2048/2048 bytes at offset 3438080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3442176 ++read 2048/2048 bytes at offset 3442176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3446272 ++read 2048/2048 bytes at offset 3446272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3450368 ++read 2048/2048 bytes at offset 3450368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3454464 ++read 2048/2048 bytes at offset 3454464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3458560 ++read 2048/2048 bytes at offset 3458560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3462656 ++read 2048/2048 bytes at offset 3462656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3466752 ++read 2048/2048 bytes at offset 3466752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3470848 ++read 2048/2048 bytes at offset 3470848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3474944 ++read 2048/2048 bytes at offset 3474944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3479040 ++read 2048/2048 bytes at offset 3479040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3483136 ++read 2048/2048 bytes at offset 3483136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3487232 ++read 2048/2048 bytes at offset 3487232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3491328 ++read 2048/2048 bytes at offset 3491328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3495424 ++read 2048/2048 bytes at offset 3495424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3499520 ++read 2048/2048 bytes at offset 3499520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3503616 ++read 2048/2048 bytes at offset 3503616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3507712 ++read 2048/2048 bytes at offset 3507712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3511808 ++read 2048/2048 bytes at offset 3511808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3515904 ++read 2048/2048 bytes at offset 3515904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3520000 ++read 2048/2048 bytes at offset 3520000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3524096 ++read 2048/2048 bytes at offset 3524096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3528192 ++read 2048/2048 bytes at offset 3528192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3532288 ++read 2048/2048 bytes at offset 3532288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3536384 ++read 2048/2048 bytes at offset 3536384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3540480 ++read 2048/2048 bytes at offset 3540480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3544576 ++read 2048/2048 bytes at offset 3544576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3548672 ++read 2048/2048 bytes at offset 3548672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3552768 ++read 2048/2048 bytes at offset 3552768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3556864 ++read 2048/2048 bytes at offset 3556864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3560960 ++read 2048/2048 bytes at offset 3560960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3565056 ++read 2048/2048 bytes at offset 3565056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3569152 ++read 2048/2048 bytes at offset 3569152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3573248 ++read 2048/2048 bytes at offset 3573248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3577344 ++read 2048/2048 bytes at offset 3577344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3581440 ++read 2048/2048 bytes at offset 3581440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3585536 ++read 2048/2048 bytes at offset 3585536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3589632 ++read 2048/2048 bytes at offset 3589632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3593728 ++read 2048/2048 bytes at offset 3593728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3597824 ++read 2048/2048 bytes at offset 3597824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3601920 ++read 2048/2048 bytes at offset 3601920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3606016 ++read 2048/2048 bytes at offset 3606016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3610112 ++read 2048/2048 bytes at offset 3610112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3614208 ++read 2048/2048 bytes at offset 3614208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3618304 ++read 2048/2048 bytes at offset 3618304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3622400 ++read 2048/2048 bytes at offset 3622400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3626496 ++read 2048/2048 bytes at offset 3626496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3630592 ++read 2048/2048 bytes at offset 3630592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3634688 ++read 2048/2048 bytes at offset 3634688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3638784 ++read 2048/2048 bytes at offset 3638784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3642880 ++read 2048/2048 bytes at offset 3642880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3646976 ++read 2048/2048 bytes at offset 3646976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3651072 ++read 2048/2048 bytes at offset 3651072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3655168 ++read 2048/2048 bytes at offset 3655168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3659264 ++read 2048/2048 bytes at offset 3659264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3663360 ++read 2048/2048 bytes at offset 3663360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3667456 ++read 2048/2048 bytes at offset 3667456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3671552 ++read 2048/2048 bytes at offset 3671552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3675648 ++read 2048/2048 bytes at offset 3675648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3679744 ++read 2048/2048 bytes at offset 3679744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3683840 ++read 2048/2048 bytes at offset 3683840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3687936 ++read 2048/2048 bytes at offset 3687936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3692032 ++read 2048/2048 bytes at offset 3692032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3696128 ++read 2048/2048 bytes at offset 3696128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3700224 ++read 2048/2048 bytes at offset 3700224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3704320 ++read 2048/2048 bytes at offset 3704320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3708416 ++read 2048/2048 bytes at offset 3708416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3712512 ++read 2048/2048 bytes at offset 3712512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3716608 ++read 2048/2048 bytes at offset 3716608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3720704 ++read 2048/2048 bytes at offset 3720704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3724800 ++read 2048/2048 bytes at offset 3724800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3728896 ++read 2048/2048 bytes at offset 3728896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3732992 ++read 2048/2048 bytes at offset 3732992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3737088 ++read 2048/2048 bytes at offset 3737088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3741184 ++read 2048/2048 bytes at offset 3741184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3745280 ++read 2048/2048 bytes at offset 3745280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3749376 ++read 2048/2048 bytes at offset 3749376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3753472 ++read 2048/2048 bytes at offset 3753472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3757568 ++read 2048/2048 bytes at offset 3757568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3761664 ++read 2048/2048 bytes at offset 3761664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3765760 ++read 2048/2048 bytes at offset 3765760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3769856 ++read 2048/2048 bytes at offset 3769856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3773952 ++read 2048/2048 bytes at offset 3773952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3778048 ++read 2048/2048 bytes at offset 3778048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3782144 ++read 2048/2048 bytes at offset 3782144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3786240 ++read 2048/2048 bytes at offset 3786240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3790336 ++read 2048/2048 bytes at offset 3790336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3794432 ++read 2048/2048 bytes at offset 3794432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3798528 ++read 2048/2048 bytes at offset 3798528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3802624 ++read 2048/2048 bytes at offset 3802624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3806720 ++read 2048/2048 bytes at offset 3806720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3810816 ++read 2048/2048 bytes at offset 3810816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3814912 ++read 2048/2048 bytes at offset 3814912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3819008 ++read 2048/2048 bytes at offset 3819008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3823104 ++read 2048/2048 bytes at offset 3823104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3827200 ++read 2048/2048 bytes at offset 3827200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3831296 ++read 2048/2048 bytes at offset 3831296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3835392 ++read 2048/2048 bytes at offset 3835392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3839488 ++read 2048/2048 bytes at offset 3839488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3843584 ++read 2048/2048 bytes at offset 3843584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3847680 ++read 2048/2048 bytes at offset 3847680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3851776 ++read 2048/2048 bytes at offset 3851776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3855872 ++read 2048/2048 bytes at offset 3855872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3859968 ++read 2048/2048 bytes at offset 3859968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3864064 ++read 2048/2048 bytes at offset 3864064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3868160 ++read 2048/2048 bytes at offset 3868160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3872256 ++read 2048/2048 bytes at offset 3872256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3876352 ++read 2048/2048 bytes at offset 3876352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3880448 ++read 2048/2048 bytes at offset 3880448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3884544 ++read 2048/2048 bytes at offset 3884544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3888640 ++read 2048/2048 bytes at offset 3888640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3892736 ++read 2048/2048 bytes at offset 3892736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3896832 ++read 2048/2048 bytes at offset 3896832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3900928 ++read 2048/2048 bytes at offset 3900928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3905024 ++read 2048/2048 bytes at offset 3905024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3909120 ++read 2048/2048 bytes at offset 3909120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3913216 ++read 2048/2048 bytes at offset 3913216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3917312 ++read 2048/2048 bytes at offset 3917312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3921408 ++read 2048/2048 bytes at offset 3921408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3925504 ++read 2048/2048 bytes at offset 3925504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3929600 ++read 2048/2048 bytes at offset 3929600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3933696 ++read 2048/2048 bytes at offset 3933696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3937792 ++read 2048/2048 bytes at offset 3937792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3941888 ++read 2048/2048 bytes at offset 3941888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3945984 ++read 2048/2048 bytes at offset 3945984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3950080 ++read 2048/2048 bytes at offset 3950080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3954176 ++read 2048/2048 bytes at offset 3954176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3958272 ++read 2048/2048 bytes at offset 3958272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3962368 ++read 2048/2048 bytes at offset 3962368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3966464 ++read 2048/2048 bytes at offset 3966464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3970560 ++read 2048/2048 bytes at offset 3970560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3974656 ++read 2048/2048 bytes at offset 3974656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3978752 ++read 2048/2048 bytes at offset 3978752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3982848 ++read 2048/2048 bytes at offset 3982848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3986944 ++read 2048/2048 bytes at offset 3986944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3991040 ++read 2048/2048 bytes at offset 3991040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3995136 ++read 2048/2048 bytes at offset 3995136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3999232 ++read 2048/2048 bytes at offset 3999232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4003328 ++read 2048/2048 bytes at offset 4003328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4007424 ++read 2048/2048 bytes at offset 4007424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4011520 ++read 2048/2048 bytes at offset 4011520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4015616 ++read 2048/2048 bytes at offset 4015616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4019712 ++read 2048/2048 bytes at offset 4019712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4023808 ++read 2048/2048 bytes at offset 4023808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4027904 ++read 2048/2048 bytes at offset 4027904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4032000 ++read 2048/2048 bytes at offset 4032000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4036096 ++read 2048/2048 bytes at offset 4036096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4040192 ++read 2048/2048 bytes at offset 4040192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4044288 ++read 2048/2048 bytes at offset 4044288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4048384 ++read 2048/2048 bytes at offset 4048384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4052480 ++read 2048/2048 bytes at offset 4052480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4056576 ++read 2048/2048 bytes at offset 4056576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4060672 ++read 2048/2048 bytes at offset 4060672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4064768 ++read 2048/2048 bytes at offset 4064768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4068864 ++read 2048/2048 bytes at offset 4068864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4072960 ++read 2048/2048 bytes at offset 4072960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4077056 ++read 2048/2048 bytes at offset 4077056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4081152 ++read 2048/2048 bytes at offset 4081152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4085248 ++read 2048/2048 bytes at offset 4085248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4089344 ++read 2048/2048 bytes at offset 4089344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4093440 ++read 2048/2048 bytes at offset 4093440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4097536 ++read 2048/2048 bytes at offset 4097536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4101632 ++read 2048/2048 bytes at offset 4101632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4105728 ++read 2048/2048 bytes at offset 4105728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4109824 ++read 2048/2048 bytes at offset 4109824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4113920 ++read 2048/2048 bytes at offset 4113920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4118016 ++read 2048/2048 bytes at offset 4118016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4122112 ++read 2048/2048 bytes at offset 4122112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4126208 ++read 2048/2048 bytes at offset 4126208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4130304 ++read 2048/2048 bytes at offset 4130304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4134400 ++read 2048/2048 bytes at offset 4134400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4138496 ++read 2048/2048 bytes at offset 4138496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4142592 ++read 2048/2048 bytes at offset 4142592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4146688 ++read 2048/2048 bytes at offset 4146688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4150784 ++read 2048/2048 bytes at offset 4150784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4154880 ++read 2048/2048 bytes at offset 4154880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4158976 ++read 2048/2048 bytes at offset 4158976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4163072 ++read 2048/2048 bytes at offset 4163072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4167168 ++read 2048/2048 bytes at offset 4167168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4171264 ++read 2048/2048 bytes at offset 4171264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4175360 ++read 2048/2048 bytes at offset 4175360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4179456 ++read 2048/2048 bytes at offset 4179456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4183552 ++read 2048/2048 bytes at offset 4183552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4187648 ++read 2048/2048 bytes at offset 4187648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4191744 ++read 2048/2048 bytes at offset 4191744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 5 +-qemu-io> read 8192/8192 bytes at offset 4196864 ++=== IO: pattern 5 ++read 8192/8192 bytes at offset 4196864 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4209152 ++read 8192/8192 bytes at offset 4209152 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4221440 ++read 8192/8192 bytes at offset 4221440 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4233728 ++read 8192/8192 bytes at offset 4233728 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4246016 ++read 8192/8192 bytes at offset 4246016 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4258304 ++read 8192/8192 bytes at offset 4258304 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4270592 ++read 8192/8192 bytes at offset 4270592 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4282880 ++read 8192/8192 bytes at offset 4282880 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295168 ++read 8192/8192 bytes at offset 4295168 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4307456 ++read 8192/8192 bytes at offset 4307456 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4319744 ++read 8192/8192 bytes at offset 4319744 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4332032 ++read 8192/8192 bytes at offset 4332032 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4344320 ++read 8192/8192 bytes at offset 4344320 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4356608 ++read 8192/8192 bytes at offset 4356608 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4368896 ++read 8192/8192 bytes at offset 4368896 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4381184 ++read 8192/8192 bytes at offset 4381184 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4393472 ++read 8192/8192 bytes at offset 4393472 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4405760 ++read 8192/8192 bytes at offset 4405760 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4418048 ++read 8192/8192 bytes at offset 4418048 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4430336 ++read 8192/8192 bytes at offset 4430336 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4442624 ++read 8192/8192 bytes at offset 4442624 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4454912 ++read 8192/8192 bytes at offset 4454912 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4467200 ++read 8192/8192 bytes at offset 4467200 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4479488 ++read 8192/8192 bytes at offset 4479488 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4491776 ++read 8192/8192 bytes at offset 4491776 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4504064 ++read 8192/8192 bytes at offset 4504064 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4516352 ++read 8192/8192 bytes at offset 4516352 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4528640 ++read 8192/8192 bytes at offset 4528640 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4540928 ++read 8192/8192 bytes at offset 4540928 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4553216 ++read 8192/8192 bytes at offset 4553216 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4565504 ++read 8192/8192 bytes at offset 4565504 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4577792 ++read 8192/8192 bytes at offset 4577792 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4590080 ++read 8192/8192 bytes at offset 4590080 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4602368 ++read 8192/8192 bytes at offset 4602368 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4614656 ++read 8192/8192 bytes at offset 4614656 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4626944 ++read 8192/8192 bytes at offset 4626944 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4639232 ++read 8192/8192 bytes at offset 4639232 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4651520 ++read 8192/8192 bytes at offset 4651520 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4663808 ++read 8192/8192 bytes at offset 4663808 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4676096 ++read 8192/8192 bytes at offset 4676096 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4688384 ++read 8192/8192 bytes at offset 4688384 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4700672 ++read 8192/8192 bytes at offset 4700672 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4712960 ++read 8192/8192 bytes at offset 4712960 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4725248 ++read 8192/8192 bytes at offset 4725248 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4737536 ++read 8192/8192 bytes at offset 4737536 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4749824 ++read 8192/8192 bytes at offset 4749824 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4762112 ++read 8192/8192 bytes at offset 4762112 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4774400 ++read 8192/8192 bytes at offset 4774400 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4786688 ++read 8192/8192 bytes at offset 4786688 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4798976 ++read 8192/8192 bytes at offset 4798976 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4811264 ++read 8192/8192 bytes at offset 4811264 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4823552 ++read 8192/8192 bytes at offset 4823552 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4835840 ++read 8192/8192 bytes at offset 4835840 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4848128 ++read 8192/8192 bytes at offset 4848128 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4860416 ++read 8192/8192 bytes at offset 4860416 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4872704 ++read 8192/8192 bytes at offset 4872704 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4884992 ++read 8192/8192 bytes at offset 4884992 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4897280 ++read 8192/8192 bytes at offset 4897280 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4909568 ++read 8192/8192 bytes at offset 4909568 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4921856 ++read 8192/8192 bytes at offset 4921856 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4934144 ++read 8192/8192 bytes at offset 4934144 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4946432 ++read 8192/8192 bytes at offset 4946432 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4958720 ++read 8192/8192 bytes at offset 4958720 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4971008 ++read 8192/8192 bytes at offset 4971008 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 244 +-qemu-io> read 12288/12288 bytes at offset 6285312 ++=== IO: pattern 244 ++read 12288/12288 bytes at offset 6285312 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 8384512 ++read 12288/12288 bytes at offset 8384512 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 10483712 ++read 12288/12288 bytes at offset 10483712 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 12582912 ++read 12288/12288 bytes at offset 12582912 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 14682112 ++read 12288/12288 bytes at offset 14682112 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 16781312 ++read 12288/12288 bytes at offset 16781312 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 18880512 ++read 12288/12288 bytes at offset 18880512 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 20979712 ++read 12288/12288 bytes at offset 20979712 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 1 +-qemu-io> wrote 4096/4096 bytes at offset 512 ++=== IO: pattern 1 ++wrote 4096/4096 bytes at offset 512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4608 ++wrote 4096/4096 bytes at offset 4608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8704 ++wrote 4096/4096 bytes at offset 8704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 12800 ++wrote 4096/4096 bytes at offset 12800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 16896 ++wrote 4096/4096 bytes at offset 16896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 20992 ++wrote 4096/4096 bytes at offset 20992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 25088 ++wrote 4096/4096 bytes at offset 25088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 29184 ++wrote 4096/4096 bytes at offset 29184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 33280 ++wrote 4096/4096 bytes at offset 33280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 37376 ++wrote 4096/4096 bytes at offset 37376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 41472 ++wrote 4096/4096 bytes at offset 41472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 45568 ++wrote 4096/4096 bytes at offset 45568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 49664 ++wrote 4096/4096 bytes at offset 49664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 53760 ++wrote 4096/4096 bytes at offset 53760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 57856 ++wrote 4096/4096 bytes at offset 57856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 61952 ++wrote 4096/4096 bytes at offset 61952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 66048 ++wrote 4096/4096 bytes at offset 66048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 70144 ++wrote 4096/4096 bytes at offset 70144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 74240 ++wrote 4096/4096 bytes at offset 74240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 78336 ++wrote 4096/4096 bytes at offset 78336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 82432 ++wrote 4096/4096 bytes at offset 82432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 86528 ++wrote 4096/4096 bytes at offset 86528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 90624 ++wrote 4096/4096 bytes at offset 90624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 94720 ++wrote 4096/4096 bytes at offset 94720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 98816 ++wrote 4096/4096 bytes at offset 98816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 102912 ++wrote 4096/4096 bytes at offset 102912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 107008 ++wrote 4096/4096 bytes at offset 107008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 111104 ++wrote 4096/4096 bytes at offset 111104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 115200 ++wrote 4096/4096 bytes at offset 115200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 119296 ++wrote 4096/4096 bytes at offset 119296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 123392 ++wrote 4096/4096 bytes at offset 123392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 127488 ++wrote 4096/4096 bytes at offset 127488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 131584 ++wrote 4096/4096 bytes at offset 131584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 135680 ++wrote 4096/4096 bytes at offset 135680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 139776 ++wrote 4096/4096 bytes at offset 139776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 143872 ++wrote 4096/4096 bytes at offset 143872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 147968 ++wrote 4096/4096 bytes at offset 147968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 152064 ++wrote 4096/4096 bytes at offset 152064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 156160 ++wrote 4096/4096 bytes at offset 156160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 160256 ++wrote 4096/4096 bytes at offset 160256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 164352 ++wrote 4096/4096 bytes at offset 164352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 168448 ++wrote 4096/4096 bytes at offset 168448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 172544 ++wrote 4096/4096 bytes at offset 172544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 176640 ++wrote 4096/4096 bytes at offset 176640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 180736 ++wrote 4096/4096 bytes at offset 180736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 184832 ++wrote 4096/4096 bytes at offset 184832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 188928 ++wrote 4096/4096 bytes at offset 188928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 193024 ++wrote 4096/4096 bytes at offset 193024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 197120 ++wrote 4096/4096 bytes at offset 197120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 201216 ++wrote 4096/4096 bytes at offset 201216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 205312 ++wrote 4096/4096 bytes at offset 205312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 209408 ++wrote 4096/4096 bytes at offset 209408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 213504 ++wrote 4096/4096 bytes at offset 213504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 217600 ++wrote 4096/4096 bytes at offset 217600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 221696 ++wrote 4096/4096 bytes at offset 221696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 225792 ++wrote 4096/4096 bytes at offset 225792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 229888 ++wrote 4096/4096 bytes at offset 229888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 233984 ++wrote 4096/4096 bytes at offset 233984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 238080 ++wrote 4096/4096 bytes at offset 238080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 242176 ++wrote 4096/4096 bytes at offset 242176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 246272 ++wrote 4096/4096 bytes at offset 246272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 250368 ++wrote 4096/4096 bytes at offset 250368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 254464 ++wrote 4096/4096 bytes at offset 254464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 258560 ++wrote 4096/4096 bytes at offset 258560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 262656 ++wrote 4096/4096 bytes at offset 262656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 266752 ++wrote 4096/4096 bytes at offset 266752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 270848 ++wrote 4096/4096 bytes at offset 270848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 274944 ++wrote 4096/4096 bytes at offset 274944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 279040 ++wrote 4096/4096 bytes at offset 279040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 283136 ++wrote 4096/4096 bytes at offset 283136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 287232 ++wrote 4096/4096 bytes at offset 287232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 291328 ++wrote 4096/4096 bytes at offset 291328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 295424 ++wrote 4096/4096 bytes at offset 295424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 299520 ++wrote 4096/4096 bytes at offset 299520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 303616 ++wrote 4096/4096 bytes at offset 303616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 307712 ++wrote 4096/4096 bytes at offset 307712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 311808 ++wrote 4096/4096 bytes at offset 311808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 315904 ++wrote 4096/4096 bytes at offset 315904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 320000 ++wrote 4096/4096 bytes at offset 320000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 324096 ++wrote 4096/4096 bytes at offset 324096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 328192 ++wrote 4096/4096 bytes at offset 328192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 332288 ++wrote 4096/4096 bytes at offset 332288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 336384 ++wrote 4096/4096 bytes at offset 336384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 340480 ++wrote 4096/4096 bytes at offset 340480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 344576 ++wrote 4096/4096 bytes at offset 344576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 348672 ++wrote 4096/4096 bytes at offset 348672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 352768 ++wrote 4096/4096 bytes at offset 352768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 356864 ++wrote 4096/4096 bytes at offset 356864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 360960 ++wrote 4096/4096 bytes at offset 360960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 365056 ++wrote 4096/4096 bytes at offset 365056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 369152 ++wrote 4096/4096 bytes at offset 369152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 373248 ++wrote 4096/4096 bytes at offset 373248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 377344 ++wrote 4096/4096 bytes at offset 377344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 381440 ++wrote 4096/4096 bytes at offset 381440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 385536 ++wrote 4096/4096 bytes at offset 385536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 389632 ++wrote 4096/4096 bytes at offset 389632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 393728 ++wrote 4096/4096 bytes at offset 393728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 397824 ++wrote 4096/4096 bytes at offset 397824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 401920 ++wrote 4096/4096 bytes at offset 401920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 406016 ++wrote 4096/4096 bytes at offset 406016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 410112 ++wrote 4096/4096 bytes at offset 410112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 414208 ++wrote 4096/4096 bytes at offset 414208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 418304 ++wrote 4096/4096 bytes at offset 418304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 422400 ++wrote 4096/4096 bytes at offset 422400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 426496 ++wrote 4096/4096 bytes at offset 426496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 430592 ++wrote 4096/4096 bytes at offset 430592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 434688 ++wrote 4096/4096 bytes at offset 434688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 438784 ++wrote 4096/4096 bytes at offset 438784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 442880 ++wrote 4096/4096 bytes at offset 442880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 446976 ++wrote 4096/4096 bytes at offset 446976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 451072 ++wrote 4096/4096 bytes at offset 451072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 455168 ++wrote 4096/4096 bytes at offset 455168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 459264 ++wrote 4096/4096 bytes at offset 459264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 463360 ++wrote 4096/4096 bytes at offset 463360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 467456 ++wrote 4096/4096 bytes at offset 467456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 471552 ++wrote 4096/4096 bytes at offset 471552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 475648 ++wrote 4096/4096 bytes at offset 475648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 479744 ++wrote 4096/4096 bytes at offset 479744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 483840 ++wrote 4096/4096 bytes at offset 483840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 487936 ++wrote 4096/4096 bytes at offset 487936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 492032 ++wrote 4096/4096 bytes at offset 492032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 496128 ++wrote 4096/4096 bytes at offset 496128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 500224 ++wrote 4096/4096 bytes at offset 500224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 504320 ++wrote 4096/4096 bytes at offset 504320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 508416 ++wrote 4096/4096 bytes at offset 508416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 512512 ++wrote 4096/4096 bytes at offset 512512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 516608 ++wrote 4096/4096 bytes at offset 516608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 520704 ++wrote 4096/4096 bytes at offset 520704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 524800 ++wrote 4096/4096 bytes at offset 524800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 528896 ++wrote 4096/4096 bytes at offset 528896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 532992 ++wrote 4096/4096 bytes at offset 532992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 537088 ++wrote 4096/4096 bytes at offset 537088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 541184 ++wrote 4096/4096 bytes at offset 541184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 545280 ++wrote 4096/4096 bytes at offset 545280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 549376 ++wrote 4096/4096 bytes at offset 549376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 553472 ++wrote 4096/4096 bytes at offset 553472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 557568 ++wrote 4096/4096 bytes at offset 557568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 561664 ++wrote 4096/4096 bytes at offset 561664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 565760 ++wrote 4096/4096 bytes at offset 565760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 569856 ++wrote 4096/4096 bytes at offset 569856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 573952 ++wrote 4096/4096 bytes at offset 573952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 578048 ++wrote 4096/4096 bytes at offset 578048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 582144 ++wrote 4096/4096 bytes at offset 582144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 586240 ++wrote 4096/4096 bytes at offset 586240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 590336 ++wrote 4096/4096 bytes at offset 590336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 594432 ++wrote 4096/4096 bytes at offset 594432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 598528 ++wrote 4096/4096 bytes at offset 598528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 602624 ++wrote 4096/4096 bytes at offset 602624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 606720 ++wrote 4096/4096 bytes at offset 606720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 610816 ++wrote 4096/4096 bytes at offset 610816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 614912 ++wrote 4096/4096 bytes at offset 614912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 619008 ++wrote 4096/4096 bytes at offset 619008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 623104 ++wrote 4096/4096 bytes at offset 623104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 627200 ++wrote 4096/4096 bytes at offset 627200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 631296 ++wrote 4096/4096 bytes at offset 631296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 635392 ++wrote 4096/4096 bytes at offset 635392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 639488 ++wrote 4096/4096 bytes at offset 639488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 643584 ++wrote 4096/4096 bytes at offset 643584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 647680 ++wrote 4096/4096 bytes at offset 647680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 651776 ++wrote 4096/4096 bytes at offset 651776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 655872 ++wrote 4096/4096 bytes at offset 655872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 659968 ++wrote 4096/4096 bytes at offset 659968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 664064 ++wrote 4096/4096 bytes at offset 664064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 668160 ++wrote 4096/4096 bytes at offset 668160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 672256 ++wrote 4096/4096 bytes at offset 672256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 676352 ++wrote 4096/4096 bytes at offset 676352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 680448 ++wrote 4096/4096 bytes at offset 680448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 684544 ++wrote 4096/4096 bytes at offset 684544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 688640 ++wrote 4096/4096 bytes at offset 688640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 692736 ++wrote 4096/4096 bytes at offset 692736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 696832 ++wrote 4096/4096 bytes at offset 696832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 700928 ++wrote 4096/4096 bytes at offset 700928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 705024 ++wrote 4096/4096 bytes at offset 705024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 709120 ++wrote 4096/4096 bytes at offset 709120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 713216 ++wrote 4096/4096 bytes at offset 713216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 717312 ++wrote 4096/4096 bytes at offset 717312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 721408 ++wrote 4096/4096 bytes at offset 721408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 725504 ++wrote 4096/4096 bytes at offset 725504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 729600 ++wrote 4096/4096 bytes at offset 729600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 733696 ++wrote 4096/4096 bytes at offset 733696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 737792 ++wrote 4096/4096 bytes at offset 737792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 741888 ++wrote 4096/4096 bytes at offset 741888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 745984 ++wrote 4096/4096 bytes at offset 745984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 750080 ++wrote 4096/4096 bytes at offset 750080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 754176 ++wrote 4096/4096 bytes at offset 754176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 758272 ++wrote 4096/4096 bytes at offset 758272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 762368 ++wrote 4096/4096 bytes at offset 762368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 766464 ++wrote 4096/4096 bytes at offset 766464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 770560 ++wrote 4096/4096 bytes at offset 770560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 774656 ++wrote 4096/4096 bytes at offset 774656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 778752 ++wrote 4096/4096 bytes at offset 778752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 782848 ++wrote 4096/4096 bytes at offset 782848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 786944 ++wrote 4096/4096 bytes at offset 786944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 791040 ++wrote 4096/4096 bytes at offset 791040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 795136 ++wrote 4096/4096 bytes at offset 795136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 799232 ++wrote 4096/4096 bytes at offset 799232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 803328 ++wrote 4096/4096 bytes at offset 803328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 807424 ++wrote 4096/4096 bytes at offset 807424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 811520 ++wrote 4096/4096 bytes at offset 811520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 815616 ++wrote 4096/4096 bytes at offset 815616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 819712 ++wrote 4096/4096 bytes at offset 819712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 823808 ++wrote 4096/4096 bytes at offset 823808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 827904 ++wrote 4096/4096 bytes at offset 827904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 832000 ++wrote 4096/4096 bytes at offset 832000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 836096 ++wrote 4096/4096 bytes at offset 836096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 840192 ++wrote 4096/4096 bytes at offset 840192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 844288 ++wrote 4096/4096 bytes at offset 844288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 848384 ++wrote 4096/4096 bytes at offset 848384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 852480 ++wrote 4096/4096 bytes at offset 852480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 856576 ++wrote 4096/4096 bytes at offset 856576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 860672 ++wrote 4096/4096 bytes at offset 860672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 864768 ++wrote 4096/4096 bytes at offset 864768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 868864 ++wrote 4096/4096 bytes at offset 868864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 872960 ++wrote 4096/4096 bytes at offset 872960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 877056 ++wrote 4096/4096 bytes at offset 877056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 881152 ++wrote 4096/4096 bytes at offset 881152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 885248 ++wrote 4096/4096 bytes at offset 885248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 889344 ++wrote 4096/4096 bytes at offset 889344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 893440 ++wrote 4096/4096 bytes at offset 893440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 897536 ++wrote 4096/4096 bytes at offset 897536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 901632 ++wrote 4096/4096 bytes at offset 901632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 905728 ++wrote 4096/4096 bytes at offset 905728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 909824 ++wrote 4096/4096 bytes at offset 909824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 913920 ++wrote 4096/4096 bytes at offset 913920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 918016 ++wrote 4096/4096 bytes at offset 918016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 922112 ++wrote 4096/4096 bytes at offset 922112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 926208 ++wrote 4096/4096 bytes at offset 926208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 930304 ++wrote 4096/4096 bytes at offset 930304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 934400 ++wrote 4096/4096 bytes at offset 934400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 938496 ++wrote 4096/4096 bytes at offset 938496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 942592 ++wrote 4096/4096 bytes at offset 942592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 946688 ++wrote 4096/4096 bytes at offset 946688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 950784 ++wrote 4096/4096 bytes at offset 950784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 954880 ++wrote 4096/4096 bytes at offset 954880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 958976 ++wrote 4096/4096 bytes at offset 958976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 963072 ++wrote 4096/4096 bytes at offset 963072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 967168 ++wrote 4096/4096 bytes at offset 967168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 971264 ++wrote 4096/4096 bytes at offset 971264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 975360 ++wrote 4096/4096 bytes at offset 975360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 979456 ++wrote 4096/4096 bytes at offset 979456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 983552 ++wrote 4096/4096 bytes at offset 983552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 987648 ++wrote 4096/4096 bytes at offset 987648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 991744 ++wrote 4096/4096 bytes at offset 991744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 995840 ++wrote 4096/4096 bytes at offset 995840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 999936 ++wrote 4096/4096 bytes at offset 999936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1004032 ++wrote 4096/4096 bytes at offset 1004032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1008128 ++wrote 4096/4096 bytes at offset 1008128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1012224 ++wrote 4096/4096 bytes at offset 1012224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1016320 ++wrote 4096/4096 bytes at offset 1016320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1020416 ++wrote 4096/4096 bytes at offset 1020416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1024512 ++wrote 4096/4096 bytes at offset 1024512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1028608 ++wrote 4096/4096 bytes at offset 1028608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1032704 ++wrote 4096/4096 bytes at offset 1032704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1036800 ++wrote 4096/4096 bytes at offset 1036800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1040896 ++wrote 4096/4096 bytes at offset 1040896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1044992 ++wrote 4096/4096 bytes at offset 1044992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 5 +-qemu-io> wrote 2048/2048 bytes at offset 1051136 ++=== IO: pattern 5 ++wrote 2048/2048 bytes at offset 1051136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1055232 ++wrote 2048/2048 bytes at offset 1055232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1059328 ++wrote 2048/2048 bytes at offset 1059328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1063424 ++wrote 2048/2048 bytes at offset 1063424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1067520 ++wrote 2048/2048 bytes at offset 1067520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1071616 ++wrote 2048/2048 bytes at offset 1071616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1075712 ++wrote 2048/2048 bytes at offset 1075712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1079808 ++wrote 2048/2048 bytes at offset 1079808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1083904 ++wrote 2048/2048 bytes at offset 1083904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1088000 ++wrote 2048/2048 bytes at offset 1088000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1092096 ++wrote 2048/2048 bytes at offset 1092096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1096192 ++wrote 2048/2048 bytes at offset 1096192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1100288 ++wrote 2048/2048 bytes at offset 1100288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1104384 ++wrote 2048/2048 bytes at offset 1104384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1108480 ++wrote 2048/2048 bytes at offset 1108480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1112576 ++wrote 2048/2048 bytes at offset 1112576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1116672 ++wrote 2048/2048 bytes at offset 1116672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1120768 ++wrote 2048/2048 bytes at offset 1120768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1124864 ++wrote 2048/2048 bytes at offset 1124864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1128960 ++wrote 2048/2048 bytes at offset 1128960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1133056 ++wrote 2048/2048 bytes at offset 1133056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1137152 ++wrote 2048/2048 bytes at offset 1137152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1141248 ++wrote 2048/2048 bytes at offset 1141248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1145344 ++wrote 2048/2048 bytes at offset 1145344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1149440 ++wrote 2048/2048 bytes at offset 1149440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1153536 ++wrote 2048/2048 bytes at offset 1153536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1157632 ++wrote 2048/2048 bytes at offset 1157632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1161728 ++wrote 2048/2048 bytes at offset 1161728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1165824 ++wrote 2048/2048 bytes at offset 1165824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1169920 ++wrote 2048/2048 bytes at offset 1169920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1174016 ++wrote 2048/2048 bytes at offset 1174016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1178112 ++wrote 2048/2048 bytes at offset 1178112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1182208 ++wrote 2048/2048 bytes at offset 1182208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1186304 ++wrote 2048/2048 bytes at offset 1186304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1190400 ++wrote 2048/2048 bytes at offset 1190400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1194496 ++wrote 2048/2048 bytes at offset 1194496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1198592 ++wrote 2048/2048 bytes at offset 1198592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1202688 ++wrote 2048/2048 bytes at offset 1202688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1206784 ++wrote 2048/2048 bytes at offset 1206784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1210880 ++wrote 2048/2048 bytes at offset 1210880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1214976 ++wrote 2048/2048 bytes at offset 1214976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1219072 ++wrote 2048/2048 bytes at offset 1219072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1223168 ++wrote 2048/2048 bytes at offset 1223168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1227264 ++wrote 2048/2048 bytes at offset 1227264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1231360 ++wrote 2048/2048 bytes at offset 1231360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1235456 ++wrote 2048/2048 bytes at offset 1235456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1239552 ++wrote 2048/2048 bytes at offset 1239552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1243648 ++wrote 2048/2048 bytes at offset 1243648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1247744 ++wrote 2048/2048 bytes at offset 1247744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1251840 ++wrote 2048/2048 bytes at offset 1251840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1255936 ++wrote 2048/2048 bytes at offset 1255936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1260032 ++wrote 2048/2048 bytes at offset 1260032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1264128 ++wrote 2048/2048 bytes at offset 1264128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1268224 ++wrote 2048/2048 bytes at offset 1268224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1272320 ++wrote 2048/2048 bytes at offset 1272320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1276416 ++wrote 2048/2048 bytes at offset 1276416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1280512 ++wrote 2048/2048 bytes at offset 1280512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1284608 ++wrote 2048/2048 bytes at offset 1284608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1288704 ++wrote 2048/2048 bytes at offset 1288704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1292800 ++wrote 2048/2048 bytes at offset 1292800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1296896 ++wrote 2048/2048 bytes at offset 1296896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1300992 ++wrote 2048/2048 bytes at offset 1300992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1305088 ++wrote 2048/2048 bytes at offset 1305088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1309184 ++wrote 2048/2048 bytes at offset 1309184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1313280 ++wrote 2048/2048 bytes at offset 1313280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1317376 ++wrote 2048/2048 bytes at offset 1317376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1321472 ++wrote 2048/2048 bytes at offset 1321472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1325568 ++wrote 2048/2048 bytes at offset 1325568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1329664 ++wrote 2048/2048 bytes at offset 1329664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1333760 ++wrote 2048/2048 bytes at offset 1333760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1337856 ++wrote 2048/2048 bytes at offset 1337856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1341952 ++wrote 2048/2048 bytes at offset 1341952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1346048 ++wrote 2048/2048 bytes at offset 1346048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1350144 ++wrote 2048/2048 bytes at offset 1350144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1354240 ++wrote 2048/2048 bytes at offset 1354240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1358336 ++wrote 2048/2048 bytes at offset 1358336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1362432 ++wrote 2048/2048 bytes at offset 1362432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1366528 ++wrote 2048/2048 bytes at offset 1366528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1370624 ++wrote 2048/2048 bytes at offset 1370624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1374720 ++wrote 2048/2048 bytes at offset 1374720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1378816 ++wrote 2048/2048 bytes at offset 1378816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1382912 ++wrote 2048/2048 bytes at offset 1382912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1387008 ++wrote 2048/2048 bytes at offset 1387008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1391104 ++wrote 2048/2048 bytes at offset 1391104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1395200 ++wrote 2048/2048 bytes at offset 1395200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1399296 ++wrote 2048/2048 bytes at offset 1399296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1403392 ++wrote 2048/2048 bytes at offset 1403392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1407488 ++wrote 2048/2048 bytes at offset 1407488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1411584 ++wrote 2048/2048 bytes at offset 1411584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1415680 ++wrote 2048/2048 bytes at offset 1415680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1419776 ++wrote 2048/2048 bytes at offset 1419776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1423872 ++wrote 2048/2048 bytes at offset 1423872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1427968 ++wrote 2048/2048 bytes at offset 1427968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1432064 ++wrote 2048/2048 bytes at offset 1432064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1436160 ++wrote 2048/2048 bytes at offset 1436160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1440256 ++wrote 2048/2048 bytes at offset 1440256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1444352 ++wrote 2048/2048 bytes at offset 1444352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1448448 ++wrote 2048/2048 bytes at offset 1448448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1452544 ++wrote 2048/2048 bytes at offset 1452544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1456640 ++wrote 2048/2048 bytes at offset 1456640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1460736 ++wrote 2048/2048 bytes at offset 1460736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1464832 ++wrote 2048/2048 bytes at offset 1464832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1468928 ++wrote 2048/2048 bytes at offset 1468928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1473024 ++wrote 2048/2048 bytes at offset 1473024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1477120 ++wrote 2048/2048 bytes at offset 1477120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1481216 ++wrote 2048/2048 bytes at offset 1481216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1485312 ++wrote 2048/2048 bytes at offset 1485312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1489408 ++wrote 2048/2048 bytes at offset 1489408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1493504 ++wrote 2048/2048 bytes at offset 1493504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1497600 ++wrote 2048/2048 bytes at offset 1497600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1501696 ++wrote 2048/2048 bytes at offset 1501696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1505792 ++wrote 2048/2048 bytes at offset 1505792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1509888 ++wrote 2048/2048 bytes at offset 1509888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1513984 ++wrote 2048/2048 bytes at offset 1513984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1518080 ++wrote 2048/2048 bytes at offset 1518080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1522176 ++wrote 2048/2048 bytes at offset 1522176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1526272 ++wrote 2048/2048 bytes at offset 1526272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1530368 ++wrote 2048/2048 bytes at offset 1530368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1534464 ++wrote 2048/2048 bytes at offset 1534464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1538560 ++wrote 2048/2048 bytes at offset 1538560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1542656 ++wrote 2048/2048 bytes at offset 1542656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1546752 ++wrote 2048/2048 bytes at offset 1546752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1550848 ++wrote 2048/2048 bytes at offset 1550848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1554944 ++wrote 2048/2048 bytes at offset 1554944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1559040 ++wrote 2048/2048 bytes at offset 1559040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1563136 ++wrote 2048/2048 bytes at offset 1563136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1567232 ++wrote 2048/2048 bytes at offset 1567232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1571328 ++wrote 2048/2048 bytes at offset 1571328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1575424 ++wrote 2048/2048 bytes at offset 1575424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1579520 ++wrote 2048/2048 bytes at offset 1579520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1583616 ++wrote 2048/2048 bytes at offset 1583616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1587712 ++wrote 2048/2048 bytes at offset 1587712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1591808 ++wrote 2048/2048 bytes at offset 1591808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1595904 ++wrote 2048/2048 bytes at offset 1595904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1600000 ++wrote 2048/2048 bytes at offset 1600000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1604096 ++wrote 2048/2048 bytes at offset 1604096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1608192 ++wrote 2048/2048 bytes at offset 1608192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1612288 ++wrote 2048/2048 bytes at offset 1612288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1616384 ++wrote 2048/2048 bytes at offset 1616384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1620480 ++wrote 2048/2048 bytes at offset 1620480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1624576 ++wrote 2048/2048 bytes at offset 1624576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1628672 ++wrote 2048/2048 bytes at offset 1628672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1632768 ++wrote 2048/2048 bytes at offset 1632768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1636864 ++wrote 2048/2048 bytes at offset 1636864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1640960 ++wrote 2048/2048 bytes at offset 1640960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1645056 ++wrote 2048/2048 bytes at offset 1645056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1649152 ++wrote 2048/2048 bytes at offset 1649152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1653248 ++wrote 2048/2048 bytes at offset 1653248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1657344 ++wrote 2048/2048 bytes at offset 1657344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1661440 ++wrote 2048/2048 bytes at offset 1661440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1665536 ++wrote 2048/2048 bytes at offset 1665536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1669632 ++wrote 2048/2048 bytes at offset 1669632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1673728 ++wrote 2048/2048 bytes at offset 1673728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1677824 ++wrote 2048/2048 bytes at offset 1677824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1681920 ++wrote 2048/2048 bytes at offset 1681920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1686016 ++wrote 2048/2048 bytes at offset 1686016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1690112 ++wrote 2048/2048 bytes at offset 1690112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1694208 ++wrote 2048/2048 bytes at offset 1694208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1698304 ++wrote 2048/2048 bytes at offset 1698304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1702400 ++wrote 2048/2048 bytes at offset 1702400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1706496 ++wrote 2048/2048 bytes at offset 1706496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1710592 ++wrote 2048/2048 bytes at offset 1710592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1714688 ++wrote 2048/2048 bytes at offset 1714688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1718784 ++wrote 2048/2048 bytes at offset 1718784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1722880 ++wrote 2048/2048 bytes at offset 1722880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1726976 ++wrote 2048/2048 bytes at offset 1726976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1731072 ++wrote 2048/2048 bytes at offset 1731072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1735168 ++wrote 2048/2048 bytes at offset 1735168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1739264 ++wrote 2048/2048 bytes at offset 1739264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1743360 ++wrote 2048/2048 bytes at offset 1743360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1747456 ++wrote 2048/2048 bytes at offset 1747456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1751552 ++wrote 2048/2048 bytes at offset 1751552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1755648 ++wrote 2048/2048 bytes at offset 1755648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1759744 ++wrote 2048/2048 bytes at offset 1759744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1763840 ++wrote 2048/2048 bytes at offset 1763840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1767936 ++wrote 2048/2048 bytes at offset 1767936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1772032 ++wrote 2048/2048 bytes at offset 1772032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1776128 ++wrote 2048/2048 bytes at offset 1776128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1780224 ++wrote 2048/2048 bytes at offset 1780224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1784320 ++wrote 2048/2048 bytes at offset 1784320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1788416 ++wrote 2048/2048 bytes at offset 1788416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1792512 ++wrote 2048/2048 bytes at offset 1792512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1796608 ++wrote 2048/2048 bytes at offset 1796608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1800704 ++wrote 2048/2048 bytes at offset 1800704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1804800 ++wrote 2048/2048 bytes at offset 1804800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1808896 ++wrote 2048/2048 bytes at offset 1808896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1812992 ++wrote 2048/2048 bytes at offset 1812992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1817088 ++wrote 2048/2048 bytes at offset 1817088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1821184 ++wrote 2048/2048 bytes at offset 1821184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1825280 ++wrote 2048/2048 bytes at offset 1825280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1829376 ++wrote 2048/2048 bytes at offset 1829376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1833472 ++wrote 2048/2048 bytes at offset 1833472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1837568 ++wrote 2048/2048 bytes at offset 1837568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1841664 ++wrote 2048/2048 bytes at offset 1841664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1845760 ++wrote 2048/2048 bytes at offset 1845760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1849856 ++wrote 2048/2048 bytes at offset 1849856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1853952 ++wrote 2048/2048 bytes at offset 1853952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1858048 ++wrote 2048/2048 bytes at offset 1858048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1862144 ++wrote 2048/2048 bytes at offset 1862144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1866240 ++wrote 2048/2048 bytes at offset 1866240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1870336 ++wrote 2048/2048 bytes at offset 1870336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1874432 ++wrote 2048/2048 bytes at offset 1874432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1878528 ++wrote 2048/2048 bytes at offset 1878528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1882624 ++wrote 2048/2048 bytes at offset 1882624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1886720 ++wrote 2048/2048 bytes at offset 1886720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1890816 ++wrote 2048/2048 bytes at offset 1890816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1894912 ++wrote 2048/2048 bytes at offset 1894912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1899008 ++wrote 2048/2048 bytes at offset 1899008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1903104 ++wrote 2048/2048 bytes at offset 1903104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1907200 ++wrote 2048/2048 bytes at offset 1907200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1911296 ++wrote 2048/2048 bytes at offset 1911296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1915392 ++wrote 2048/2048 bytes at offset 1915392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1919488 ++wrote 2048/2048 bytes at offset 1919488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1923584 ++wrote 2048/2048 bytes at offset 1923584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1927680 ++wrote 2048/2048 bytes at offset 1927680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1931776 ++wrote 2048/2048 bytes at offset 1931776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1935872 ++wrote 2048/2048 bytes at offset 1935872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1939968 ++wrote 2048/2048 bytes at offset 1939968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1944064 ++wrote 2048/2048 bytes at offset 1944064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1948160 ++wrote 2048/2048 bytes at offset 1948160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1952256 ++wrote 2048/2048 bytes at offset 1952256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1956352 ++wrote 2048/2048 bytes at offset 1956352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1960448 ++wrote 2048/2048 bytes at offset 1960448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1964544 ++wrote 2048/2048 bytes at offset 1964544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1968640 ++wrote 2048/2048 bytes at offset 1968640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1972736 ++wrote 2048/2048 bytes at offset 1972736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1976832 ++wrote 2048/2048 bytes at offset 1976832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1980928 ++wrote 2048/2048 bytes at offset 1980928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1985024 ++wrote 2048/2048 bytes at offset 1985024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1989120 ++wrote 2048/2048 bytes at offset 1989120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1993216 ++wrote 2048/2048 bytes at offset 1993216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1997312 ++wrote 2048/2048 bytes at offset 1997312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2001408 ++wrote 2048/2048 bytes at offset 2001408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2005504 ++wrote 2048/2048 bytes at offset 2005504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2009600 ++wrote 2048/2048 bytes at offset 2009600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2013696 ++wrote 2048/2048 bytes at offset 2013696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2017792 ++wrote 2048/2048 bytes at offset 2017792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2021888 ++wrote 2048/2048 bytes at offset 2021888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2025984 ++wrote 2048/2048 bytes at offset 2025984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2030080 ++wrote 2048/2048 bytes at offset 2030080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2034176 ++wrote 2048/2048 bytes at offset 2034176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2038272 ++wrote 2048/2048 bytes at offset 2038272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2042368 ++wrote 2048/2048 bytes at offset 2042368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2046464 ++wrote 2048/2048 bytes at offset 2046464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2050560 ++wrote 2048/2048 bytes at offset 2050560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2054656 ++wrote 2048/2048 bytes at offset 2054656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2058752 ++wrote 2048/2048 bytes at offset 2058752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2062848 ++wrote 2048/2048 bytes at offset 2062848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2066944 ++wrote 2048/2048 bytes at offset 2066944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2071040 ++wrote 2048/2048 bytes at offset 2071040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2075136 ++wrote 2048/2048 bytes at offset 2075136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2079232 ++wrote 2048/2048 bytes at offset 2079232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2083328 ++wrote 2048/2048 bytes at offset 2083328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2087424 ++wrote 2048/2048 bytes at offset 2087424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2091520 ++wrote 2048/2048 bytes at offset 2091520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2095616 ++wrote 2048/2048 bytes at offset 2095616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 1 +-qemu-io> wrote 2048/2048 bytes at offset 2097664 ++=== IO: pattern 1 ++wrote 2048/2048 bytes at offset 2097664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2101760 ++wrote 2048/2048 bytes at offset 2101760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2105856 ++wrote 2048/2048 bytes at offset 2105856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2109952 ++wrote 2048/2048 bytes at offset 2109952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2114048 ++wrote 2048/2048 bytes at offset 2114048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2118144 ++wrote 2048/2048 bytes at offset 2118144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2122240 ++wrote 2048/2048 bytes at offset 2122240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2126336 ++wrote 2048/2048 bytes at offset 2126336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2130432 ++wrote 2048/2048 bytes at offset 2130432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2134528 ++wrote 2048/2048 bytes at offset 2134528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2138624 ++wrote 2048/2048 bytes at offset 2138624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2142720 ++wrote 2048/2048 bytes at offset 2142720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2146816 ++wrote 2048/2048 bytes at offset 2146816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2150912 ++wrote 2048/2048 bytes at offset 2150912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2155008 ++wrote 2048/2048 bytes at offset 2155008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2159104 ++wrote 2048/2048 bytes at offset 2159104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2163200 ++wrote 2048/2048 bytes at offset 2163200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2167296 ++wrote 2048/2048 bytes at offset 2167296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2171392 ++wrote 2048/2048 bytes at offset 2171392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2175488 ++wrote 2048/2048 bytes at offset 2175488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2179584 ++wrote 2048/2048 bytes at offset 2179584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2183680 ++wrote 2048/2048 bytes at offset 2183680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2187776 ++wrote 2048/2048 bytes at offset 2187776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2191872 ++wrote 2048/2048 bytes at offset 2191872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2195968 ++wrote 2048/2048 bytes at offset 2195968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2200064 ++wrote 2048/2048 bytes at offset 2200064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2204160 ++wrote 2048/2048 bytes at offset 2204160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2208256 ++wrote 2048/2048 bytes at offset 2208256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2212352 ++wrote 2048/2048 bytes at offset 2212352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2216448 ++wrote 2048/2048 bytes at offset 2216448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2220544 ++wrote 2048/2048 bytes at offset 2220544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2224640 ++wrote 2048/2048 bytes at offset 2224640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2228736 ++wrote 2048/2048 bytes at offset 2228736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2232832 ++wrote 2048/2048 bytes at offset 2232832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2236928 ++wrote 2048/2048 bytes at offset 2236928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2241024 ++wrote 2048/2048 bytes at offset 2241024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2245120 ++wrote 2048/2048 bytes at offset 2245120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2249216 ++wrote 2048/2048 bytes at offset 2249216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2253312 ++wrote 2048/2048 bytes at offset 2253312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2257408 ++wrote 2048/2048 bytes at offset 2257408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2261504 ++wrote 2048/2048 bytes at offset 2261504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2265600 ++wrote 2048/2048 bytes at offset 2265600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2269696 ++wrote 2048/2048 bytes at offset 2269696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2273792 ++wrote 2048/2048 bytes at offset 2273792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2277888 ++wrote 2048/2048 bytes at offset 2277888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2281984 ++wrote 2048/2048 bytes at offset 2281984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2286080 ++wrote 2048/2048 bytes at offset 2286080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2290176 ++wrote 2048/2048 bytes at offset 2290176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2294272 ++wrote 2048/2048 bytes at offset 2294272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2298368 ++wrote 2048/2048 bytes at offset 2298368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2302464 ++wrote 2048/2048 bytes at offset 2302464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2306560 ++wrote 2048/2048 bytes at offset 2306560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2310656 ++wrote 2048/2048 bytes at offset 2310656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2314752 ++wrote 2048/2048 bytes at offset 2314752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2318848 ++wrote 2048/2048 bytes at offset 2318848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2322944 ++wrote 2048/2048 bytes at offset 2322944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2327040 ++wrote 2048/2048 bytes at offset 2327040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2331136 ++wrote 2048/2048 bytes at offset 2331136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2335232 ++wrote 2048/2048 bytes at offset 2335232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2339328 ++wrote 2048/2048 bytes at offset 2339328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2343424 ++wrote 2048/2048 bytes at offset 2343424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2347520 ++wrote 2048/2048 bytes at offset 2347520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2351616 ++wrote 2048/2048 bytes at offset 2351616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2355712 ++wrote 2048/2048 bytes at offset 2355712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2359808 ++wrote 2048/2048 bytes at offset 2359808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2363904 ++wrote 2048/2048 bytes at offset 2363904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2368000 ++wrote 2048/2048 bytes at offset 2368000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2372096 ++wrote 2048/2048 bytes at offset 2372096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2376192 ++wrote 2048/2048 bytes at offset 2376192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2380288 ++wrote 2048/2048 bytes at offset 2380288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2384384 ++wrote 2048/2048 bytes at offset 2384384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2388480 ++wrote 2048/2048 bytes at offset 2388480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2392576 ++wrote 2048/2048 bytes at offset 2392576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2396672 ++wrote 2048/2048 bytes at offset 2396672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2400768 ++wrote 2048/2048 bytes at offset 2400768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2404864 ++wrote 2048/2048 bytes at offset 2404864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2408960 ++wrote 2048/2048 bytes at offset 2408960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2413056 ++wrote 2048/2048 bytes at offset 2413056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2417152 ++wrote 2048/2048 bytes at offset 2417152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2421248 ++wrote 2048/2048 bytes at offset 2421248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2425344 ++wrote 2048/2048 bytes at offset 2425344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2429440 ++wrote 2048/2048 bytes at offset 2429440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2433536 ++wrote 2048/2048 bytes at offset 2433536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2437632 ++wrote 2048/2048 bytes at offset 2437632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2441728 ++wrote 2048/2048 bytes at offset 2441728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2445824 ++wrote 2048/2048 bytes at offset 2445824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2449920 ++wrote 2048/2048 bytes at offset 2449920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2454016 ++wrote 2048/2048 bytes at offset 2454016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2458112 ++wrote 2048/2048 bytes at offset 2458112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2462208 ++wrote 2048/2048 bytes at offset 2462208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2466304 ++wrote 2048/2048 bytes at offset 2466304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2470400 ++wrote 2048/2048 bytes at offset 2470400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2474496 ++wrote 2048/2048 bytes at offset 2474496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2478592 ++wrote 2048/2048 bytes at offset 2478592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2482688 ++wrote 2048/2048 bytes at offset 2482688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2486784 ++wrote 2048/2048 bytes at offset 2486784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2490880 ++wrote 2048/2048 bytes at offset 2490880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2494976 ++wrote 2048/2048 bytes at offset 2494976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2499072 ++wrote 2048/2048 bytes at offset 2499072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2503168 ++wrote 2048/2048 bytes at offset 2503168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2507264 ++wrote 2048/2048 bytes at offset 2507264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2511360 ++wrote 2048/2048 bytes at offset 2511360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2515456 ++wrote 2048/2048 bytes at offset 2515456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2519552 ++wrote 2048/2048 bytes at offset 2519552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2523648 ++wrote 2048/2048 bytes at offset 2523648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2527744 ++wrote 2048/2048 bytes at offset 2527744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2531840 ++wrote 2048/2048 bytes at offset 2531840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2535936 ++wrote 2048/2048 bytes at offset 2535936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2540032 ++wrote 2048/2048 bytes at offset 2540032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2544128 ++wrote 2048/2048 bytes at offset 2544128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2548224 ++wrote 2048/2048 bytes at offset 2548224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2552320 ++wrote 2048/2048 bytes at offset 2552320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2556416 ++wrote 2048/2048 bytes at offset 2556416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2560512 ++wrote 2048/2048 bytes at offset 2560512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2564608 ++wrote 2048/2048 bytes at offset 2564608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2568704 ++wrote 2048/2048 bytes at offset 2568704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2572800 ++wrote 2048/2048 bytes at offset 2572800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2576896 ++wrote 2048/2048 bytes at offset 2576896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2580992 ++wrote 2048/2048 bytes at offset 2580992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2585088 ++wrote 2048/2048 bytes at offset 2585088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2589184 ++wrote 2048/2048 bytes at offset 2589184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2593280 ++wrote 2048/2048 bytes at offset 2593280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2597376 ++wrote 2048/2048 bytes at offset 2597376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2601472 ++wrote 2048/2048 bytes at offset 2601472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2605568 ++wrote 2048/2048 bytes at offset 2605568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2609664 ++wrote 2048/2048 bytes at offset 2609664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2613760 ++wrote 2048/2048 bytes at offset 2613760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2617856 ++wrote 2048/2048 bytes at offset 2617856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2621952 ++wrote 2048/2048 bytes at offset 2621952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2626048 ++wrote 2048/2048 bytes at offset 2626048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2630144 ++wrote 2048/2048 bytes at offset 2630144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2634240 ++wrote 2048/2048 bytes at offset 2634240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2638336 ++wrote 2048/2048 bytes at offset 2638336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2642432 ++wrote 2048/2048 bytes at offset 2642432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2646528 ++wrote 2048/2048 bytes at offset 2646528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2650624 ++wrote 2048/2048 bytes at offset 2650624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2654720 ++wrote 2048/2048 bytes at offset 2654720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2658816 ++wrote 2048/2048 bytes at offset 2658816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2662912 ++wrote 2048/2048 bytes at offset 2662912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2667008 ++wrote 2048/2048 bytes at offset 2667008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2671104 ++wrote 2048/2048 bytes at offset 2671104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2675200 ++wrote 2048/2048 bytes at offset 2675200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2679296 ++wrote 2048/2048 bytes at offset 2679296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2683392 ++wrote 2048/2048 bytes at offset 2683392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2687488 ++wrote 2048/2048 bytes at offset 2687488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2691584 ++wrote 2048/2048 bytes at offset 2691584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2695680 ++wrote 2048/2048 bytes at offset 2695680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2699776 ++wrote 2048/2048 bytes at offset 2699776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2703872 ++wrote 2048/2048 bytes at offset 2703872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2707968 ++wrote 2048/2048 bytes at offset 2707968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2712064 ++wrote 2048/2048 bytes at offset 2712064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2716160 ++wrote 2048/2048 bytes at offset 2716160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2720256 ++wrote 2048/2048 bytes at offset 2720256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2724352 ++wrote 2048/2048 bytes at offset 2724352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2728448 ++wrote 2048/2048 bytes at offset 2728448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2732544 ++wrote 2048/2048 bytes at offset 2732544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2736640 ++wrote 2048/2048 bytes at offset 2736640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2740736 ++wrote 2048/2048 bytes at offset 2740736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2744832 ++wrote 2048/2048 bytes at offset 2744832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2748928 ++wrote 2048/2048 bytes at offset 2748928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2753024 ++wrote 2048/2048 bytes at offset 2753024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2757120 ++wrote 2048/2048 bytes at offset 2757120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2761216 ++wrote 2048/2048 bytes at offset 2761216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2765312 ++wrote 2048/2048 bytes at offset 2765312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2769408 ++wrote 2048/2048 bytes at offset 2769408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2773504 ++wrote 2048/2048 bytes at offset 2773504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2777600 ++wrote 2048/2048 bytes at offset 2777600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2781696 ++wrote 2048/2048 bytes at offset 2781696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2785792 ++wrote 2048/2048 bytes at offset 2785792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2789888 ++wrote 2048/2048 bytes at offset 2789888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2793984 ++wrote 2048/2048 bytes at offset 2793984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2798080 ++wrote 2048/2048 bytes at offset 2798080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2802176 ++wrote 2048/2048 bytes at offset 2802176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2806272 ++wrote 2048/2048 bytes at offset 2806272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2810368 ++wrote 2048/2048 bytes at offset 2810368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2814464 ++wrote 2048/2048 bytes at offset 2814464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2818560 ++wrote 2048/2048 bytes at offset 2818560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2822656 ++wrote 2048/2048 bytes at offset 2822656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2826752 ++wrote 2048/2048 bytes at offset 2826752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2830848 ++wrote 2048/2048 bytes at offset 2830848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2834944 ++wrote 2048/2048 bytes at offset 2834944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2839040 ++wrote 2048/2048 bytes at offset 2839040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2843136 ++wrote 2048/2048 bytes at offset 2843136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2847232 ++wrote 2048/2048 bytes at offset 2847232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2851328 ++wrote 2048/2048 bytes at offset 2851328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2855424 ++wrote 2048/2048 bytes at offset 2855424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2859520 ++wrote 2048/2048 bytes at offset 2859520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2863616 ++wrote 2048/2048 bytes at offset 2863616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2867712 ++wrote 2048/2048 bytes at offset 2867712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2871808 ++wrote 2048/2048 bytes at offset 2871808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2875904 ++wrote 2048/2048 bytes at offset 2875904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2880000 ++wrote 2048/2048 bytes at offset 2880000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2884096 ++wrote 2048/2048 bytes at offset 2884096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2888192 ++wrote 2048/2048 bytes at offset 2888192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2892288 ++wrote 2048/2048 bytes at offset 2892288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2896384 ++wrote 2048/2048 bytes at offset 2896384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2900480 ++wrote 2048/2048 bytes at offset 2900480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2904576 ++wrote 2048/2048 bytes at offset 2904576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2908672 ++wrote 2048/2048 bytes at offset 2908672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2912768 ++wrote 2048/2048 bytes at offset 2912768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2916864 ++wrote 2048/2048 bytes at offset 2916864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2920960 ++wrote 2048/2048 bytes at offset 2920960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2925056 ++wrote 2048/2048 bytes at offset 2925056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2929152 ++wrote 2048/2048 bytes at offset 2929152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2933248 ++wrote 2048/2048 bytes at offset 2933248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2937344 ++wrote 2048/2048 bytes at offset 2937344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2941440 ++wrote 2048/2048 bytes at offset 2941440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2945536 ++wrote 2048/2048 bytes at offset 2945536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2949632 ++wrote 2048/2048 bytes at offset 2949632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2953728 ++wrote 2048/2048 bytes at offset 2953728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2957824 ++wrote 2048/2048 bytes at offset 2957824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2961920 ++wrote 2048/2048 bytes at offset 2961920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2966016 ++wrote 2048/2048 bytes at offset 2966016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2970112 ++wrote 2048/2048 bytes at offset 2970112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2974208 ++wrote 2048/2048 bytes at offset 2974208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2978304 ++wrote 2048/2048 bytes at offset 2978304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2982400 ++wrote 2048/2048 bytes at offset 2982400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2986496 ++wrote 2048/2048 bytes at offset 2986496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2990592 ++wrote 2048/2048 bytes at offset 2990592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2994688 ++wrote 2048/2048 bytes at offset 2994688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2998784 ++wrote 2048/2048 bytes at offset 2998784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3002880 ++wrote 2048/2048 bytes at offset 3002880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3006976 ++wrote 2048/2048 bytes at offset 3006976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3011072 ++wrote 2048/2048 bytes at offset 3011072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3015168 ++wrote 2048/2048 bytes at offset 3015168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3019264 ++wrote 2048/2048 bytes at offset 3019264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3023360 ++wrote 2048/2048 bytes at offset 3023360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3027456 ++wrote 2048/2048 bytes at offset 3027456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3031552 ++wrote 2048/2048 bytes at offset 3031552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3035648 ++wrote 2048/2048 bytes at offset 3035648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3039744 ++wrote 2048/2048 bytes at offset 3039744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3043840 ++wrote 2048/2048 bytes at offset 3043840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3047936 ++wrote 2048/2048 bytes at offset 3047936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3052032 ++wrote 2048/2048 bytes at offset 3052032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3056128 ++wrote 2048/2048 bytes at offset 3056128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3060224 ++wrote 2048/2048 bytes at offset 3060224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3064320 ++wrote 2048/2048 bytes at offset 3064320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3068416 ++wrote 2048/2048 bytes at offset 3068416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3072512 ++wrote 2048/2048 bytes at offset 3072512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3076608 ++wrote 2048/2048 bytes at offset 3076608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3080704 ++wrote 2048/2048 bytes at offset 3080704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3084800 ++wrote 2048/2048 bytes at offset 3084800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3088896 ++wrote 2048/2048 bytes at offset 3088896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3092992 ++wrote 2048/2048 bytes at offset 3092992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3097088 ++wrote 2048/2048 bytes at offset 3097088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3101184 ++wrote 2048/2048 bytes at offset 3101184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3105280 ++wrote 2048/2048 bytes at offset 3105280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3109376 ++wrote 2048/2048 bytes at offset 3109376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3113472 ++wrote 2048/2048 bytes at offset 3113472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3117568 ++wrote 2048/2048 bytes at offset 3117568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3121664 ++wrote 2048/2048 bytes at offset 3121664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3125760 ++wrote 2048/2048 bytes at offset 3125760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3129856 ++wrote 2048/2048 bytes at offset 3129856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3133952 ++wrote 2048/2048 bytes at offset 3133952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3138048 ++wrote 2048/2048 bytes at offset 3138048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3142144 ++wrote 2048/2048 bytes at offset 3142144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 3 +-qemu-io> wrote 2048/2048 bytes at offset 3147264 ++=== IO: pattern 3 ++wrote 2048/2048 bytes at offset 3147264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3151360 ++wrote 2048/2048 bytes at offset 3151360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3155456 ++wrote 2048/2048 bytes at offset 3155456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3159552 ++wrote 2048/2048 bytes at offset 3159552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3163648 ++wrote 2048/2048 bytes at offset 3163648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3167744 ++wrote 2048/2048 bytes at offset 3167744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3171840 ++wrote 2048/2048 bytes at offset 3171840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3175936 ++wrote 2048/2048 bytes at offset 3175936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3180032 ++wrote 2048/2048 bytes at offset 3180032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3184128 ++wrote 2048/2048 bytes at offset 3184128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3188224 ++wrote 2048/2048 bytes at offset 3188224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3192320 ++wrote 2048/2048 bytes at offset 3192320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3196416 ++wrote 2048/2048 bytes at offset 3196416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3200512 ++wrote 2048/2048 bytes at offset 3200512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3204608 ++wrote 2048/2048 bytes at offset 3204608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3208704 ++wrote 2048/2048 bytes at offset 3208704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3212800 ++wrote 2048/2048 bytes at offset 3212800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3216896 ++wrote 2048/2048 bytes at offset 3216896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3220992 ++wrote 2048/2048 bytes at offset 3220992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3225088 ++wrote 2048/2048 bytes at offset 3225088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3229184 ++wrote 2048/2048 bytes at offset 3229184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3233280 ++wrote 2048/2048 bytes at offset 3233280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3237376 ++wrote 2048/2048 bytes at offset 3237376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3241472 ++wrote 2048/2048 bytes at offset 3241472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3245568 ++wrote 2048/2048 bytes at offset 3245568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3249664 ++wrote 2048/2048 bytes at offset 3249664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3253760 ++wrote 2048/2048 bytes at offset 3253760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3257856 ++wrote 2048/2048 bytes at offset 3257856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3261952 ++wrote 2048/2048 bytes at offset 3261952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3266048 ++wrote 2048/2048 bytes at offset 3266048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3270144 ++wrote 2048/2048 bytes at offset 3270144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3274240 ++wrote 2048/2048 bytes at offset 3274240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3278336 ++wrote 2048/2048 bytes at offset 3278336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3282432 ++wrote 2048/2048 bytes at offset 3282432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3286528 ++wrote 2048/2048 bytes at offset 3286528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3290624 ++wrote 2048/2048 bytes at offset 3290624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3294720 ++wrote 2048/2048 bytes at offset 3294720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3298816 ++wrote 2048/2048 bytes at offset 3298816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3302912 ++wrote 2048/2048 bytes at offset 3302912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3307008 ++wrote 2048/2048 bytes at offset 3307008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3311104 ++wrote 2048/2048 bytes at offset 3311104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3315200 ++wrote 2048/2048 bytes at offset 3315200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3319296 ++wrote 2048/2048 bytes at offset 3319296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3323392 ++wrote 2048/2048 bytes at offset 3323392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3327488 ++wrote 2048/2048 bytes at offset 3327488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3331584 ++wrote 2048/2048 bytes at offset 3331584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3335680 ++wrote 2048/2048 bytes at offset 3335680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3339776 ++wrote 2048/2048 bytes at offset 3339776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3343872 ++wrote 2048/2048 bytes at offset 3343872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3347968 ++wrote 2048/2048 bytes at offset 3347968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3352064 ++wrote 2048/2048 bytes at offset 3352064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3356160 ++wrote 2048/2048 bytes at offset 3356160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3360256 ++wrote 2048/2048 bytes at offset 3360256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3364352 ++wrote 2048/2048 bytes at offset 3364352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3368448 ++wrote 2048/2048 bytes at offset 3368448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3372544 ++wrote 2048/2048 bytes at offset 3372544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3376640 ++wrote 2048/2048 bytes at offset 3376640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3380736 ++wrote 2048/2048 bytes at offset 3380736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3384832 ++wrote 2048/2048 bytes at offset 3384832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3388928 ++wrote 2048/2048 bytes at offset 3388928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3393024 ++wrote 2048/2048 bytes at offset 3393024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3397120 ++wrote 2048/2048 bytes at offset 3397120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3401216 ++wrote 2048/2048 bytes at offset 3401216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3405312 ++wrote 2048/2048 bytes at offset 3405312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3409408 ++wrote 2048/2048 bytes at offset 3409408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3413504 ++wrote 2048/2048 bytes at offset 3413504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3417600 ++wrote 2048/2048 bytes at offset 3417600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3421696 ++wrote 2048/2048 bytes at offset 3421696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3425792 ++wrote 2048/2048 bytes at offset 3425792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3429888 ++wrote 2048/2048 bytes at offset 3429888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3433984 ++wrote 2048/2048 bytes at offset 3433984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3438080 ++wrote 2048/2048 bytes at offset 3438080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3442176 ++wrote 2048/2048 bytes at offset 3442176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3446272 ++wrote 2048/2048 bytes at offset 3446272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3450368 ++wrote 2048/2048 bytes at offset 3450368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3454464 ++wrote 2048/2048 bytes at offset 3454464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3458560 ++wrote 2048/2048 bytes at offset 3458560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3462656 ++wrote 2048/2048 bytes at offset 3462656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3466752 ++wrote 2048/2048 bytes at offset 3466752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3470848 ++wrote 2048/2048 bytes at offset 3470848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3474944 ++wrote 2048/2048 bytes at offset 3474944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3479040 ++wrote 2048/2048 bytes at offset 3479040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3483136 ++wrote 2048/2048 bytes at offset 3483136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3487232 ++wrote 2048/2048 bytes at offset 3487232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3491328 ++wrote 2048/2048 bytes at offset 3491328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3495424 ++wrote 2048/2048 bytes at offset 3495424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3499520 ++wrote 2048/2048 bytes at offset 3499520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3503616 ++wrote 2048/2048 bytes at offset 3503616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3507712 ++wrote 2048/2048 bytes at offset 3507712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3511808 ++wrote 2048/2048 bytes at offset 3511808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3515904 ++wrote 2048/2048 bytes at offset 3515904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3520000 ++wrote 2048/2048 bytes at offset 3520000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3524096 ++wrote 2048/2048 bytes at offset 3524096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3528192 ++wrote 2048/2048 bytes at offset 3528192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3532288 ++wrote 2048/2048 bytes at offset 3532288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3536384 ++wrote 2048/2048 bytes at offset 3536384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3540480 ++wrote 2048/2048 bytes at offset 3540480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3544576 ++wrote 2048/2048 bytes at offset 3544576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3548672 ++wrote 2048/2048 bytes at offset 3548672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3552768 ++wrote 2048/2048 bytes at offset 3552768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3556864 ++wrote 2048/2048 bytes at offset 3556864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3560960 ++wrote 2048/2048 bytes at offset 3560960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3565056 ++wrote 2048/2048 bytes at offset 3565056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3569152 ++wrote 2048/2048 bytes at offset 3569152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3573248 ++wrote 2048/2048 bytes at offset 3573248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3577344 ++wrote 2048/2048 bytes at offset 3577344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3581440 ++wrote 2048/2048 bytes at offset 3581440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3585536 ++wrote 2048/2048 bytes at offset 3585536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3589632 ++wrote 2048/2048 bytes at offset 3589632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3593728 ++wrote 2048/2048 bytes at offset 3593728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3597824 ++wrote 2048/2048 bytes at offset 3597824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3601920 ++wrote 2048/2048 bytes at offset 3601920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3606016 ++wrote 2048/2048 bytes at offset 3606016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3610112 ++wrote 2048/2048 bytes at offset 3610112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3614208 ++wrote 2048/2048 bytes at offset 3614208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3618304 ++wrote 2048/2048 bytes at offset 3618304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3622400 ++wrote 2048/2048 bytes at offset 3622400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3626496 ++wrote 2048/2048 bytes at offset 3626496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3630592 ++wrote 2048/2048 bytes at offset 3630592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3634688 ++wrote 2048/2048 bytes at offset 3634688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3638784 ++wrote 2048/2048 bytes at offset 3638784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3642880 ++wrote 2048/2048 bytes at offset 3642880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3646976 ++wrote 2048/2048 bytes at offset 3646976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3651072 ++wrote 2048/2048 bytes at offset 3651072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3655168 ++wrote 2048/2048 bytes at offset 3655168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3659264 ++wrote 2048/2048 bytes at offset 3659264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3663360 ++wrote 2048/2048 bytes at offset 3663360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3667456 ++wrote 2048/2048 bytes at offset 3667456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3671552 ++wrote 2048/2048 bytes at offset 3671552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3675648 ++wrote 2048/2048 bytes at offset 3675648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3679744 ++wrote 2048/2048 bytes at offset 3679744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3683840 ++wrote 2048/2048 bytes at offset 3683840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3687936 ++wrote 2048/2048 bytes at offset 3687936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3692032 ++wrote 2048/2048 bytes at offset 3692032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3696128 ++wrote 2048/2048 bytes at offset 3696128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3700224 ++wrote 2048/2048 bytes at offset 3700224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3704320 ++wrote 2048/2048 bytes at offset 3704320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3708416 ++wrote 2048/2048 bytes at offset 3708416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3712512 ++wrote 2048/2048 bytes at offset 3712512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3716608 ++wrote 2048/2048 bytes at offset 3716608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3720704 ++wrote 2048/2048 bytes at offset 3720704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3724800 ++wrote 2048/2048 bytes at offset 3724800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3728896 ++wrote 2048/2048 bytes at offset 3728896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3732992 ++wrote 2048/2048 bytes at offset 3732992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3737088 ++wrote 2048/2048 bytes at offset 3737088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3741184 ++wrote 2048/2048 bytes at offset 3741184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3745280 ++wrote 2048/2048 bytes at offset 3745280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3749376 ++wrote 2048/2048 bytes at offset 3749376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3753472 ++wrote 2048/2048 bytes at offset 3753472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3757568 ++wrote 2048/2048 bytes at offset 3757568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3761664 ++wrote 2048/2048 bytes at offset 3761664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3765760 ++wrote 2048/2048 bytes at offset 3765760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3769856 ++wrote 2048/2048 bytes at offset 3769856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3773952 ++wrote 2048/2048 bytes at offset 3773952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3778048 ++wrote 2048/2048 bytes at offset 3778048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3782144 ++wrote 2048/2048 bytes at offset 3782144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3786240 ++wrote 2048/2048 bytes at offset 3786240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3790336 ++wrote 2048/2048 bytes at offset 3790336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3794432 ++wrote 2048/2048 bytes at offset 3794432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3798528 ++wrote 2048/2048 bytes at offset 3798528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3802624 ++wrote 2048/2048 bytes at offset 3802624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3806720 ++wrote 2048/2048 bytes at offset 3806720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3810816 ++wrote 2048/2048 bytes at offset 3810816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3814912 ++wrote 2048/2048 bytes at offset 3814912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3819008 ++wrote 2048/2048 bytes at offset 3819008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3823104 ++wrote 2048/2048 bytes at offset 3823104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3827200 ++wrote 2048/2048 bytes at offset 3827200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3831296 ++wrote 2048/2048 bytes at offset 3831296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3835392 ++wrote 2048/2048 bytes at offset 3835392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3839488 ++wrote 2048/2048 bytes at offset 3839488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3843584 ++wrote 2048/2048 bytes at offset 3843584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3847680 ++wrote 2048/2048 bytes at offset 3847680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3851776 ++wrote 2048/2048 bytes at offset 3851776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3855872 ++wrote 2048/2048 bytes at offset 3855872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3859968 ++wrote 2048/2048 bytes at offset 3859968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3864064 ++wrote 2048/2048 bytes at offset 3864064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3868160 ++wrote 2048/2048 bytes at offset 3868160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3872256 ++wrote 2048/2048 bytes at offset 3872256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3876352 ++wrote 2048/2048 bytes at offset 3876352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3880448 ++wrote 2048/2048 bytes at offset 3880448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3884544 ++wrote 2048/2048 bytes at offset 3884544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3888640 ++wrote 2048/2048 bytes at offset 3888640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3892736 ++wrote 2048/2048 bytes at offset 3892736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3896832 ++wrote 2048/2048 bytes at offset 3896832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3900928 ++wrote 2048/2048 bytes at offset 3900928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3905024 ++wrote 2048/2048 bytes at offset 3905024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3909120 ++wrote 2048/2048 bytes at offset 3909120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3913216 ++wrote 2048/2048 bytes at offset 3913216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3917312 ++wrote 2048/2048 bytes at offset 3917312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3921408 ++wrote 2048/2048 bytes at offset 3921408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3925504 ++wrote 2048/2048 bytes at offset 3925504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3929600 ++wrote 2048/2048 bytes at offset 3929600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3933696 ++wrote 2048/2048 bytes at offset 3933696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3937792 ++wrote 2048/2048 bytes at offset 3937792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3941888 ++wrote 2048/2048 bytes at offset 3941888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3945984 ++wrote 2048/2048 bytes at offset 3945984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3950080 ++wrote 2048/2048 bytes at offset 3950080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3954176 ++wrote 2048/2048 bytes at offset 3954176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3958272 ++wrote 2048/2048 bytes at offset 3958272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3962368 ++wrote 2048/2048 bytes at offset 3962368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3966464 ++wrote 2048/2048 bytes at offset 3966464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3970560 ++wrote 2048/2048 bytes at offset 3970560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3974656 ++wrote 2048/2048 bytes at offset 3974656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3978752 ++wrote 2048/2048 bytes at offset 3978752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3982848 ++wrote 2048/2048 bytes at offset 3982848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3986944 ++wrote 2048/2048 bytes at offset 3986944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3991040 ++wrote 2048/2048 bytes at offset 3991040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3995136 ++wrote 2048/2048 bytes at offset 3995136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3999232 ++wrote 2048/2048 bytes at offset 3999232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4003328 ++wrote 2048/2048 bytes at offset 4003328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4007424 ++wrote 2048/2048 bytes at offset 4007424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4011520 ++wrote 2048/2048 bytes at offset 4011520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4015616 ++wrote 2048/2048 bytes at offset 4015616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4019712 ++wrote 2048/2048 bytes at offset 4019712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4023808 ++wrote 2048/2048 bytes at offset 4023808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4027904 ++wrote 2048/2048 bytes at offset 4027904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4032000 ++wrote 2048/2048 bytes at offset 4032000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4036096 ++wrote 2048/2048 bytes at offset 4036096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4040192 ++wrote 2048/2048 bytes at offset 4040192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4044288 ++wrote 2048/2048 bytes at offset 4044288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4048384 ++wrote 2048/2048 bytes at offset 4048384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4052480 ++wrote 2048/2048 bytes at offset 4052480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4056576 ++wrote 2048/2048 bytes at offset 4056576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4060672 ++wrote 2048/2048 bytes at offset 4060672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4064768 ++wrote 2048/2048 bytes at offset 4064768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4068864 ++wrote 2048/2048 bytes at offset 4068864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4072960 ++wrote 2048/2048 bytes at offset 4072960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4077056 ++wrote 2048/2048 bytes at offset 4077056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4081152 ++wrote 2048/2048 bytes at offset 4081152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4085248 ++wrote 2048/2048 bytes at offset 4085248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4089344 ++wrote 2048/2048 bytes at offset 4089344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4093440 ++wrote 2048/2048 bytes at offset 4093440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4097536 ++wrote 2048/2048 bytes at offset 4097536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4101632 ++wrote 2048/2048 bytes at offset 4101632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4105728 ++wrote 2048/2048 bytes at offset 4105728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4109824 ++wrote 2048/2048 bytes at offset 4109824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4113920 ++wrote 2048/2048 bytes at offset 4113920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4118016 ++wrote 2048/2048 bytes at offset 4118016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4122112 ++wrote 2048/2048 bytes at offset 4122112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4126208 ++wrote 2048/2048 bytes at offset 4126208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4130304 ++wrote 2048/2048 bytes at offset 4130304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4134400 ++wrote 2048/2048 bytes at offset 4134400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4138496 ++wrote 2048/2048 bytes at offset 4138496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4142592 ++wrote 2048/2048 bytes at offset 4142592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4146688 ++wrote 2048/2048 bytes at offset 4146688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4150784 ++wrote 2048/2048 bytes at offset 4150784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4154880 ++wrote 2048/2048 bytes at offset 4154880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4158976 ++wrote 2048/2048 bytes at offset 4158976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4163072 ++wrote 2048/2048 bytes at offset 4163072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4167168 ++wrote 2048/2048 bytes at offset 4167168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4171264 ++wrote 2048/2048 bytes at offset 4171264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4175360 ++wrote 2048/2048 bytes at offset 4175360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4179456 ++wrote 2048/2048 bytes at offset 4179456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4183552 ++wrote 2048/2048 bytes at offset 4183552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4187648 ++wrote 2048/2048 bytes at offset 4187648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4191744 ++wrote 2048/2048 bytes at offset 4191744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 5 +-qemu-io> wrote 8192/8192 bytes at offset 4196864 ++=== IO: pattern 5 ++wrote 8192/8192 bytes at offset 4196864 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4209152 ++wrote 8192/8192 bytes at offset 4209152 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4221440 ++wrote 8192/8192 bytes at offset 4221440 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4233728 ++wrote 8192/8192 bytes at offset 4233728 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4246016 ++wrote 8192/8192 bytes at offset 4246016 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4258304 ++wrote 8192/8192 bytes at offset 4258304 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4270592 ++wrote 8192/8192 bytes at offset 4270592 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4282880 ++wrote 8192/8192 bytes at offset 4282880 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295168 ++wrote 8192/8192 bytes at offset 4295168 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4307456 ++wrote 8192/8192 bytes at offset 4307456 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4319744 ++wrote 8192/8192 bytes at offset 4319744 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4332032 ++wrote 8192/8192 bytes at offset 4332032 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4344320 ++wrote 8192/8192 bytes at offset 4344320 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4356608 ++wrote 8192/8192 bytes at offset 4356608 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4368896 ++wrote 8192/8192 bytes at offset 4368896 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4381184 ++wrote 8192/8192 bytes at offset 4381184 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4393472 ++wrote 8192/8192 bytes at offset 4393472 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4405760 ++wrote 8192/8192 bytes at offset 4405760 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4418048 ++wrote 8192/8192 bytes at offset 4418048 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4430336 ++wrote 8192/8192 bytes at offset 4430336 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4442624 ++wrote 8192/8192 bytes at offset 4442624 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4454912 ++wrote 8192/8192 bytes at offset 4454912 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4467200 ++wrote 8192/8192 bytes at offset 4467200 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4479488 ++wrote 8192/8192 bytes at offset 4479488 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4491776 ++wrote 8192/8192 bytes at offset 4491776 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4504064 ++wrote 8192/8192 bytes at offset 4504064 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4516352 ++wrote 8192/8192 bytes at offset 4516352 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4528640 ++wrote 8192/8192 bytes at offset 4528640 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4540928 ++wrote 8192/8192 bytes at offset 4540928 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4553216 ++wrote 8192/8192 bytes at offset 4553216 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4565504 ++wrote 8192/8192 bytes at offset 4565504 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4577792 ++wrote 8192/8192 bytes at offset 4577792 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4590080 ++wrote 8192/8192 bytes at offset 4590080 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4602368 ++wrote 8192/8192 bytes at offset 4602368 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4614656 ++wrote 8192/8192 bytes at offset 4614656 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4626944 ++wrote 8192/8192 bytes at offset 4626944 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4639232 ++wrote 8192/8192 bytes at offset 4639232 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4651520 ++wrote 8192/8192 bytes at offset 4651520 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4663808 ++wrote 8192/8192 bytes at offset 4663808 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4676096 ++wrote 8192/8192 bytes at offset 4676096 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4688384 ++wrote 8192/8192 bytes at offset 4688384 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4700672 ++wrote 8192/8192 bytes at offset 4700672 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4712960 ++wrote 8192/8192 bytes at offset 4712960 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4725248 ++wrote 8192/8192 bytes at offset 4725248 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4737536 ++wrote 8192/8192 bytes at offset 4737536 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4749824 ++wrote 8192/8192 bytes at offset 4749824 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4762112 ++wrote 8192/8192 bytes at offset 4762112 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4774400 ++wrote 8192/8192 bytes at offset 4774400 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4786688 ++wrote 8192/8192 bytes at offset 4786688 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4798976 ++wrote 8192/8192 bytes at offset 4798976 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4811264 ++wrote 8192/8192 bytes at offset 4811264 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4823552 ++wrote 8192/8192 bytes at offset 4823552 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4835840 ++wrote 8192/8192 bytes at offset 4835840 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4848128 ++wrote 8192/8192 bytes at offset 4848128 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4860416 ++wrote 8192/8192 bytes at offset 4860416 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4872704 ++wrote 8192/8192 bytes at offset 4872704 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4884992 ++wrote 8192/8192 bytes at offset 4884992 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4897280 ++wrote 8192/8192 bytes at offset 4897280 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4909568 ++wrote 8192/8192 bytes at offset 4909568 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4921856 ++wrote 8192/8192 bytes at offset 4921856 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4934144 ++wrote 8192/8192 bytes at offset 4934144 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4946432 ++wrote 8192/8192 bytes at offset 4946432 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4958720 ++wrote 8192/8192 bytes at offset 4958720 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4971008 ++wrote 8192/8192 bytes at offset 4971008 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 244 +-qemu-io> wrote 12288/12288 bytes at offset 6285312 ++=== IO: pattern 244 ++wrote 12288/12288 bytes at offset 6285312 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 8384512 ++wrote 12288/12288 bytes at offset 8384512 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 10483712 ++wrote 12288/12288 bytes at offset 10483712 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 12582912 ++wrote 12288/12288 bytes at offset 12582912 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 14682112 ++wrote 12288/12288 bytes at offset 14682112 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 16781312 ++wrote 12288/12288 bytes at offset 16781312 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 18880512 ++wrote 12288/12288 bytes at offset 18880512 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 20979712 ++wrote 12288/12288 bytes at offset 20979712 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 1 +-qemu-io> read 4096/4096 bytes at offset 512 ++=== IO: pattern 1 ++read 4096/4096 bytes at offset 512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4608 ++read 4096/4096 bytes at offset 4608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 8704 ++read 4096/4096 bytes at offset 8704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 12800 ++read 4096/4096 bytes at offset 12800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 16896 ++read 4096/4096 bytes at offset 16896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 20992 ++read 4096/4096 bytes at offset 20992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 25088 ++read 4096/4096 bytes at offset 25088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 29184 ++read 4096/4096 bytes at offset 29184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 33280 ++read 4096/4096 bytes at offset 33280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 37376 ++read 4096/4096 bytes at offset 37376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 41472 ++read 4096/4096 bytes at offset 41472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 45568 ++read 4096/4096 bytes at offset 45568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 49664 ++read 4096/4096 bytes at offset 49664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 53760 ++read 4096/4096 bytes at offset 53760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 57856 ++read 4096/4096 bytes at offset 57856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 61952 ++read 4096/4096 bytes at offset 61952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 66048 ++read 4096/4096 bytes at offset 66048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 70144 ++read 4096/4096 bytes at offset 70144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 74240 ++read 4096/4096 bytes at offset 74240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 78336 ++read 4096/4096 bytes at offset 78336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 82432 ++read 4096/4096 bytes at offset 82432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 86528 ++read 4096/4096 bytes at offset 86528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 90624 ++read 4096/4096 bytes at offset 90624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 94720 ++read 4096/4096 bytes at offset 94720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 98816 ++read 4096/4096 bytes at offset 98816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 102912 ++read 4096/4096 bytes at offset 102912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 107008 ++read 4096/4096 bytes at offset 107008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 111104 ++read 4096/4096 bytes at offset 111104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 115200 ++read 4096/4096 bytes at offset 115200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 119296 ++read 4096/4096 bytes at offset 119296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 123392 ++read 4096/4096 bytes at offset 123392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 127488 ++read 4096/4096 bytes at offset 127488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 131584 ++read 4096/4096 bytes at offset 131584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 135680 ++read 4096/4096 bytes at offset 135680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 139776 ++read 4096/4096 bytes at offset 139776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 143872 ++read 4096/4096 bytes at offset 143872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 147968 ++read 4096/4096 bytes at offset 147968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 152064 ++read 4096/4096 bytes at offset 152064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 156160 ++read 4096/4096 bytes at offset 156160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 160256 ++read 4096/4096 bytes at offset 160256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 164352 ++read 4096/4096 bytes at offset 164352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 168448 ++read 4096/4096 bytes at offset 168448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 172544 ++read 4096/4096 bytes at offset 172544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 176640 ++read 4096/4096 bytes at offset 176640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 180736 ++read 4096/4096 bytes at offset 180736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 184832 ++read 4096/4096 bytes at offset 184832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 188928 ++read 4096/4096 bytes at offset 188928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 193024 ++read 4096/4096 bytes at offset 193024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 197120 ++read 4096/4096 bytes at offset 197120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 201216 ++read 4096/4096 bytes at offset 201216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 205312 ++read 4096/4096 bytes at offset 205312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 209408 ++read 4096/4096 bytes at offset 209408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 213504 ++read 4096/4096 bytes at offset 213504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 217600 ++read 4096/4096 bytes at offset 217600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 221696 ++read 4096/4096 bytes at offset 221696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 225792 ++read 4096/4096 bytes at offset 225792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 229888 ++read 4096/4096 bytes at offset 229888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 233984 ++read 4096/4096 bytes at offset 233984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 238080 ++read 4096/4096 bytes at offset 238080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 242176 ++read 4096/4096 bytes at offset 242176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 246272 ++read 4096/4096 bytes at offset 246272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 250368 ++read 4096/4096 bytes at offset 250368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 254464 ++read 4096/4096 bytes at offset 254464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 258560 ++read 4096/4096 bytes at offset 258560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 262656 ++read 4096/4096 bytes at offset 262656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 266752 ++read 4096/4096 bytes at offset 266752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 270848 ++read 4096/4096 bytes at offset 270848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 274944 ++read 4096/4096 bytes at offset 274944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 279040 ++read 4096/4096 bytes at offset 279040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 283136 ++read 4096/4096 bytes at offset 283136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 287232 ++read 4096/4096 bytes at offset 287232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 291328 ++read 4096/4096 bytes at offset 291328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 295424 ++read 4096/4096 bytes at offset 295424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 299520 ++read 4096/4096 bytes at offset 299520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 303616 ++read 4096/4096 bytes at offset 303616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 307712 ++read 4096/4096 bytes at offset 307712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 311808 ++read 4096/4096 bytes at offset 311808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 315904 ++read 4096/4096 bytes at offset 315904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 320000 ++read 4096/4096 bytes at offset 320000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 324096 ++read 4096/4096 bytes at offset 324096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 328192 ++read 4096/4096 bytes at offset 328192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 332288 ++read 4096/4096 bytes at offset 332288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 336384 ++read 4096/4096 bytes at offset 336384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 340480 ++read 4096/4096 bytes at offset 340480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 344576 ++read 4096/4096 bytes at offset 344576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 348672 ++read 4096/4096 bytes at offset 348672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 352768 ++read 4096/4096 bytes at offset 352768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 356864 ++read 4096/4096 bytes at offset 356864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 360960 ++read 4096/4096 bytes at offset 360960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 365056 ++read 4096/4096 bytes at offset 365056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 369152 ++read 4096/4096 bytes at offset 369152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 373248 ++read 4096/4096 bytes at offset 373248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 377344 ++read 4096/4096 bytes at offset 377344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 381440 ++read 4096/4096 bytes at offset 381440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 385536 ++read 4096/4096 bytes at offset 385536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 389632 ++read 4096/4096 bytes at offset 389632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 393728 ++read 4096/4096 bytes at offset 393728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 397824 ++read 4096/4096 bytes at offset 397824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 401920 ++read 4096/4096 bytes at offset 401920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 406016 ++read 4096/4096 bytes at offset 406016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 410112 ++read 4096/4096 bytes at offset 410112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 414208 ++read 4096/4096 bytes at offset 414208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 418304 ++read 4096/4096 bytes at offset 418304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 422400 ++read 4096/4096 bytes at offset 422400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 426496 ++read 4096/4096 bytes at offset 426496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 430592 ++read 4096/4096 bytes at offset 430592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 434688 ++read 4096/4096 bytes at offset 434688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 438784 ++read 4096/4096 bytes at offset 438784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 442880 ++read 4096/4096 bytes at offset 442880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 446976 ++read 4096/4096 bytes at offset 446976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 451072 ++read 4096/4096 bytes at offset 451072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 455168 ++read 4096/4096 bytes at offset 455168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 459264 ++read 4096/4096 bytes at offset 459264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 463360 ++read 4096/4096 bytes at offset 463360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 467456 ++read 4096/4096 bytes at offset 467456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 471552 ++read 4096/4096 bytes at offset 471552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 475648 ++read 4096/4096 bytes at offset 475648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 479744 ++read 4096/4096 bytes at offset 479744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 483840 ++read 4096/4096 bytes at offset 483840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 487936 ++read 4096/4096 bytes at offset 487936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 492032 ++read 4096/4096 bytes at offset 492032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 496128 ++read 4096/4096 bytes at offset 496128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 500224 ++read 4096/4096 bytes at offset 500224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 504320 ++read 4096/4096 bytes at offset 504320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 508416 ++read 4096/4096 bytes at offset 508416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 512512 ++read 4096/4096 bytes at offset 512512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 516608 ++read 4096/4096 bytes at offset 516608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 520704 ++read 4096/4096 bytes at offset 520704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 524800 ++read 4096/4096 bytes at offset 524800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 528896 ++read 4096/4096 bytes at offset 528896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 532992 ++read 4096/4096 bytes at offset 532992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 537088 ++read 4096/4096 bytes at offset 537088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 541184 ++read 4096/4096 bytes at offset 541184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 545280 ++read 4096/4096 bytes at offset 545280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 549376 ++read 4096/4096 bytes at offset 549376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 553472 ++read 4096/4096 bytes at offset 553472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 557568 ++read 4096/4096 bytes at offset 557568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 561664 ++read 4096/4096 bytes at offset 561664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 565760 ++read 4096/4096 bytes at offset 565760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 569856 ++read 4096/4096 bytes at offset 569856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 573952 ++read 4096/4096 bytes at offset 573952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 578048 ++read 4096/4096 bytes at offset 578048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 582144 ++read 4096/4096 bytes at offset 582144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 586240 ++read 4096/4096 bytes at offset 586240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 590336 ++read 4096/4096 bytes at offset 590336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 594432 ++read 4096/4096 bytes at offset 594432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 598528 ++read 4096/4096 bytes at offset 598528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 602624 ++read 4096/4096 bytes at offset 602624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 606720 ++read 4096/4096 bytes at offset 606720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 610816 ++read 4096/4096 bytes at offset 610816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 614912 ++read 4096/4096 bytes at offset 614912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 619008 ++read 4096/4096 bytes at offset 619008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 623104 ++read 4096/4096 bytes at offset 623104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 627200 ++read 4096/4096 bytes at offset 627200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 631296 ++read 4096/4096 bytes at offset 631296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 635392 ++read 4096/4096 bytes at offset 635392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 639488 ++read 4096/4096 bytes at offset 639488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 643584 ++read 4096/4096 bytes at offset 643584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 647680 ++read 4096/4096 bytes at offset 647680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 651776 ++read 4096/4096 bytes at offset 651776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 655872 ++read 4096/4096 bytes at offset 655872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 659968 ++read 4096/4096 bytes at offset 659968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 664064 ++read 4096/4096 bytes at offset 664064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 668160 ++read 4096/4096 bytes at offset 668160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 672256 ++read 4096/4096 bytes at offset 672256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 676352 ++read 4096/4096 bytes at offset 676352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 680448 ++read 4096/4096 bytes at offset 680448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 684544 ++read 4096/4096 bytes at offset 684544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 688640 ++read 4096/4096 bytes at offset 688640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 692736 ++read 4096/4096 bytes at offset 692736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 696832 ++read 4096/4096 bytes at offset 696832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 700928 ++read 4096/4096 bytes at offset 700928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 705024 ++read 4096/4096 bytes at offset 705024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 709120 ++read 4096/4096 bytes at offset 709120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 713216 ++read 4096/4096 bytes at offset 713216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 717312 ++read 4096/4096 bytes at offset 717312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 721408 ++read 4096/4096 bytes at offset 721408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 725504 ++read 4096/4096 bytes at offset 725504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 729600 ++read 4096/4096 bytes at offset 729600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 733696 ++read 4096/4096 bytes at offset 733696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 737792 ++read 4096/4096 bytes at offset 737792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 741888 ++read 4096/4096 bytes at offset 741888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 745984 ++read 4096/4096 bytes at offset 745984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 750080 ++read 4096/4096 bytes at offset 750080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 754176 ++read 4096/4096 bytes at offset 754176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 758272 ++read 4096/4096 bytes at offset 758272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 762368 ++read 4096/4096 bytes at offset 762368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 766464 ++read 4096/4096 bytes at offset 766464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 770560 ++read 4096/4096 bytes at offset 770560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 774656 ++read 4096/4096 bytes at offset 774656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 778752 ++read 4096/4096 bytes at offset 778752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 782848 ++read 4096/4096 bytes at offset 782848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 786944 ++read 4096/4096 bytes at offset 786944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 791040 ++read 4096/4096 bytes at offset 791040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 795136 ++read 4096/4096 bytes at offset 795136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 799232 ++read 4096/4096 bytes at offset 799232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 803328 ++read 4096/4096 bytes at offset 803328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 807424 ++read 4096/4096 bytes at offset 807424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 811520 ++read 4096/4096 bytes at offset 811520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 815616 ++read 4096/4096 bytes at offset 815616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 819712 ++read 4096/4096 bytes at offset 819712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 823808 ++read 4096/4096 bytes at offset 823808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 827904 ++read 4096/4096 bytes at offset 827904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 832000 ++read 4096/4096 bytes at offset 832000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 836096 ++read 4096/4096 bytes at offset 836096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 840192 ++read 4096/4096 bytes at offset 840192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 844288 ++read 4096/4096 bytes at offset 844288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 848384 ++read 4096/4096 bytes at offset 848384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 852480 ++read 4096/4096 bytes at offset 852480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 856576 ++read 4096/4096 bytes at offset 856576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 860672 ++read 4096/4096 bytes at offset 860672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 864768 ++read 4096/4096 bytes at offset 864768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 868864 ++read 4096/4096 bytes at offset 868864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 872960 ++read 4096/4096 bytes at offset 872960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 877056 ++read 4096/4096 bytes at offset 877056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 881152 ++read 4096/4096 bytes at offset 881152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 885248 ++read 4096/4096 bytes at offset 885248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 889344 ++read 4096/4096 bytes at offset 889344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 893440 ++read 4096/4096 bytes at offset 893440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 897536 ++read 4096/4096 bytes at offset 897536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 901632 ++read 4096/4096 bytes at offset 901632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 905728 ++read 4096/4096 bytes at offset 905728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 909824 ++read 4096/4096 bytes at offset 909824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 913920 ++read 4096/4096 bytes at offset 913920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 918016 ++read 4096/4096 bytes at offset 918016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 922112 ++read 4096/4096 bytes at offset 922112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 926208 ++read 4096/4096 bytes at offset 926208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 930304 ++read 4096/4096 bytes at offset 930304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 934400 ++read 4096/4096 bytes at offset 934400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 938496 ++read 4096/4096 bytes at offset 938496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 942592 ++read 4096/4096 bytes at offset 942592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 946688 ++read 4096/4096 bytes at offset 946688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 950784 ++read 4096/4096 bytes at offset 950784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 954880 ++read 4096/4096 bytes at offset 954880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 958976 ++read 4096/4096 bytes at offset 958976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 963072 ++read 4096/4096 bytes at offset 963072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 967168 ++read 4096/4096 bytes at offset 967168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 971264 ++read 4096/4096 bytes at offset 971264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 975360 ++read 4096/4096 bytes at offset 975360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 979456 ++read 4096/4096 bytes at offset 979456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 983552 ++read 4096/4096 bytes at offset 983552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 987648 ++read 4096/4096 bytes at offset 987648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 991744 ++read 4096/4096 bytes at offset 991744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 995840 ++read 4096/4096 bytes at offset 995840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 999936 ++read 4096/4096 bytes at offset 999936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1004032 ++read 4096/4096 bytes at offset 1004032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1008128 ++read 4096/4096 bytes at offset 1008128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1012224 ++read 4096/4096 bytes at offset 1012224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1016320 ++read 4096/4096 bytes at offset 1016320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1020416 ++read 4096/4096 bytes at offset 1020416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1024512 ++read 4096/4096 bytes at offset 1024512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1028608 ++read 4096/4096 bytes at offset 1028608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1032704 ++read 4096/4096 bytes at offset 1032704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1036800 ++read 4096/4096 bytes at offset 1036800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1040896 ++read 4096/4096 bytes at offset 1040896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1044992 ++read 4096/4096 bytes at offset 1044992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 5 +-qemu-io> read 2048/2048 bytes at offset 1051136 ++=== IO: pattern 5 ++read 2048/2048 bytes at offset 1051136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1055232 ++read 2048/2048 bytes at offset 1055232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1059328 ++read 2048/2048 bytes at offset 1059328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1063424 ++read 2048/2048 bytes at offset 1063424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1067520 ++read 2048/2048 bytes at offset 1067520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1071616 ++read 2048/2048 bytes at offset 1071616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1075712 ++read 2048/2048 bytes at offset 1075712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1079808 ++read 2048/2048 bytes at offset 1079808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1083904 ++read 2048/2048 bytes at offset 1083904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1088000 ++read 2048/2048 bytes at offset 1088000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1092096 ++read 2048/2048 bytes at offset 1092096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1096192 ++read 2048/2048 bytes at offset 1096192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1100288 ++read 2048/2048 bytes at offset 1100288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1104384 ++read 2048/2048 bytes at offset 1104384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1108480 ++read 2048/2048 bytes at offset 1108480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1112576 ++read 2048/2048 bytes at offset 1112576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1116672 ++read 2048/2048 bytes at offset 1116672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1120768 ++read 2048/2048 bytes at offset 1120768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1124864 ++read 2048/2048 bytes at offset 1124864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1128960 ++read 2048/2048 bytes at offset 1128960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1133056 ++read 2048/2048 bytes at offset 1133056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1137152 ++read 2048/2048 bytes at offset 1137152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1141248 ++read 2048/2048 bytes at offset 1141248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1145344 ++read 2048/2048 bytes at offset 1145344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1149440 ++read 2048/2048 bytes at offset 1149440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1153536 ++read 2048/2048 bytes at offset 1153536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1157632 ++read 2048/2048 bytes at offset 1157632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1161728 ++read 2048/2048 bytes at offset 1161728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1165824 ++read 2048/2048 bytes at offset 1165824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1169920 ++read 2048/2048 bytes at offset 1169920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1174016 ++read 2048/2048 bytes at offset 1174016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1178112 ++read 2048/2048 bytes at offset 1178112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1182208 ++read 2048/2048 bytes at offset 1182208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1186304 ++read 2048/2048 bytes at offset 1186304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1190400 ++read 2048/2048 bytes at offset 1190400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1194496 ++read 2048/2048 bytes at offset 1194496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1198592 ++read 2048/2048 bytes at offset 1198592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1202688 ++read 2048/2048 bytes at offset 1202688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1206784 ++read 2048/2048 bytes at offset 1206784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1210880 ++read 2048/2048 bytes at offset 1210880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1214976 ++read 2048/2048 bytes at offset 1214976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1219072 ++read 2048/2048 bytes at offset 1219072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1223168 ++read 2048/2048 bytes at offset 1223168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1227264 ++read 2048/2048 bytes at offset 1227264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1231360 ++read 2048/2048 bytes at offset 1231360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1235456 ++read 2048/2048 bytes at offset 1235456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1239552 ++read 2048/2048 bytes at offset 1239552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1243648 ++read 2048/2048 bytes at offset 1243648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1247744 ++read 2048/2048 bytes at offset 1247744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1251840 ++read 2048/2048 bytes at offset 1251840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1255936 ++read 2048/2048 bytes at offset 1255936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1260032 ++read 2048/2048 bytes at offset 1260032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1264128 ++read 2048/2048 bytes at offset 1264128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1268224 ++read 2048/2048 bytes at offset 1268224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1272320 ++read 2048/2048 bytes at offset 1272320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1276416 ++read 2048/2048 bytes at offset 1276416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1280512 ++read 2048/2048 bytes at offset 1280512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1284608 ++read 2048/2048 bytes at offset 1284608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1288704 ++read 2048/2048 bytes at offset 1288704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1292800 ++read 2048/2048 bytes at offset 1292800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1296896 ++read 2048/2048 bytes at offset 1296896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1300992 ++read 2048/2048 bytes at offset 1300992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1305088 ++read 2048/2048 bytes at offset 1305088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1309184 ++read 2048/2048 bytes at offset 1309184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1313280 ++read 2048/2048 bytes at offset 1313280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1317376 ++read 2048/2048 bytes at offset 1317376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1321472 ++read 2048/2048 bytes at offset 1321472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1325568 ++read 2048/2048 bytes at offset 1325568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1329664 ++read 2048/2048 bytes at offset 1329664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1333760 ++read 2048/2048 bytes at offset 1333760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1337856 ++read 2048/2048 bytes at offset 1337856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1341952 ++read 2048/2048 bytes at offset 1341952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1346048 ++read 2048/2048 bytes at offset 1346048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1350144 ++read 2048/2048 bytes at offset 1350144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1354240 ++read 2048/2048 bytes at offset 1354240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1358336 ++read 2048/2048 bytes at offset 1358336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1362432 ++read 2048/2048 bytes at offset 1362432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1366528 ++read 2048/2048 bytes at offset 1366528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1370624 ++read 2048/2048 bytes at offset 1370624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1374720 ++read 2048/2048 bytes at offset 1374720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1378816 ++read 2048/2048 bytes at offset 1378816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1382912 ++read 2048/2048 bytes at offset 1382912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1387008 ++read 2048/2048 bytes at offset 1387008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1391104 ++read 2048/2048 bytes at offset 1391104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1395200 ++read 2048/2048 bytes at offset 1395200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1399296 ++read 2048/2048 bytes at offset 1399296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1403392 ++read 2048/2048 bytes at offset 1403392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1407488 ++read 2048/2048 bytes at offset 1407488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1411584 ++read 2048/2048 bytes at offset 1411584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1415680 ++read 2048/2048 bytes at offset 1415680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1419776 ++read 2048/2048 bytes at offset 1419776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1423872 ++read 2048/2048 bytes at offset 1423872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1427968 ++read 2048/2048 bytes at offset 1427968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1432064 ++read 2048/2048 bytes at offset 1432064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1436160 ++read 2048/2048 bytes at offset 1436160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1440256 ++read 2048/2048 bytes at offset 1440256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1444352 ++read 2048/2048 bytes at offset 1444352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1448448 ++read 2048/2048 bytes at offset 1448448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1452544 ++read 2048/2048 bytes at offset 1452544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1456640 ++read 2048/2048 bytes at offset 1456640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1460736 ++read 2048/2048 bytes at offset 1460736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1464832 ++read 2048/2048 bytes at offset 1464832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1468928 ++read 2048/2048 bytes at offset 1468928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1473024 ++read 2048/2048 bytes at offset 1473024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1477120 ++read 2048/2048 bytes at offset 1477120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1481216 ++read 2048/2048 bytes at offset 1481216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1485312 ++read 2048/2048 bytes at offset 1485312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1489408 ++read 2048/2048 bytes at offset 1489408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1493504 ++read 2048/2048 bytes at offset 1493504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1497600 ++read 2048/2048 bytes at offset 1497600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1501696 ++read 2048/2048 bytes at offset 1501696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1505792 ++read 2048/2048 bytes at offset 1505792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1509888 ++read 2048/2048 bytes at offset 1509888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1513984 ++read 2048/2048 bytes at offset 1513984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1518080 ++read 2048/2048 bytes at offset 1518080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1522176 ++read 2048/2048 bytes at offset 1522176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1526272 ++read 2048/2048 bytes at offset 1526272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1530368 ++read 2048/2048 bytes at offset 1530368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1534464 ++read 2048/2048 bytes at offset 1534464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1538560 ++read 2048/2048 bytes at offset 1538560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1542656 ++read 2048/2048 bytes at offset 1542656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1546752 ++read 2048/2048 bytes at offset 1546752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1550848 ++read 2048/2048 bytes at offset 1550848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1554944 ++read 2048/2048 bytes at offset 1554944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1559040 ++read 2048/2048 bytes at offset 1559040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1563136 ++read 2048/2048 bytes at offset 1563136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1567232 ++read 2048/2048 bytes at offset 1567232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1571328 ++read 2048/2048 bytes at offset 1571328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1575424 ++read 2048/2048 bytes at offset 1575424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1579520 ++read 2048/2048 bytes at offset 1579520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1583616 ++read 2048/2048 bytes at offset 1583616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1587712 ++read 2048/2048 bytes at offset 1587712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1591808 ++read 2048/2048 bytes at offset 1591808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1595904 ++read 2048/2048 bytes at offset 1595904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1600000 ++read 2048/2048 bytes at offset 1600000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1604096 ++read 2048/2048 bytes at offset 1604096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1608192 ++read 2048/2048 bytes at offset 1608192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1612288 ++read 2048/2048 bytes at offset 1612288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1616384 ++read 2048/2048 bytes at offset 1616384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1620480 ++read 2048/2048 bytes at offset 1620480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1624576 ++read 2048/2048 bytes at offset 1624576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1628672 ++read 2048/2048 bytes at offset 1628672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1632768 ++read 2048/2048 bytes at offset 1632768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1636864 ++read 2048/2048 bytes at offset 1636864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1640960 ++read 2048/2048 bytes at offset 1640960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1645056 ++read 2048/2048 bytes at offset 1645056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1649152 ++read 2048/2048 bytes at offset 1649152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1653248 ++read 2048/2048 bytes at offset 1653248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1657344 ++read 2048/2048 bytes at offset 1657344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1661440 ++read 2048/2048 bytes at offset 1661440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1665536 ++read 2048/2048 bytes at offset 1665536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1669632 ++read 2048/2048 bytes at offset 1669632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1673728 ++read 2048/2048 bytes at offset 1673728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1677824 ++read 2048/2048 bytes at offset 1677824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1681920 ++read 2048/2048 bytes at offset 1681920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1686016 ++read 2048/2048 bytes at offset 1686016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1690112 ++read 2048/2048 bytes at offset 1690112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1694208 ++read 2048/2048 bytes at offset 1694208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1698304 ++read 2048/2048 bytes at offset 1698304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1702400 ++read 2048/2048 bytes at offset 1702400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1706496 ++read 2048/2048 bytes at offset 1706496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1710592 ++read 2048/2048 bytes at offset 1710592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1714688 ++read 2048/2048 bytes at offset 1714688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1718784 ++read 2048/2048 bytes at offset 1718784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1722880 ++read 2048/2048 bytes at offset 1722880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1726976 ++read 2048/2048 bytes at offset 1726976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1731072 ++read 2048/2048 bytes at offset 1731072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1735168 ++read 2048/2048 bytes at offset 1735168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1739264 ++read 2048/2048 bytes at offset 1739264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1743360 ++read 2048/2048 bytes at offset 1743360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1747456 ++read 2048/2048 bytes at offset 1747456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1751552 ++read 2048/2048 bytes at offset 1751552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1755648 ++read 2048/2048 bytes at offset 1755648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1759744 ++read 2048/2048 bytes at offset 1759744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1763840 ++read 2048/2048 bytes at offset 1763840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1767936 ++read 2048/2048 bytes at offset 1767936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1772032 ++read 2048/2048 bytes at offset 1772032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1776128 ++read 2048/2048 bytes at offset 1776128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1780224 ++read 2048/2048 bytes at offset 1780224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1784320 ++read 2048/2048 bytes at offset 1784320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1788416 ++read 2048/2048 bytes at offset 1788416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1792512 ++read 2048/2048 bytes at offset 1792512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1796608 ++read 2048/2048 bytes at offset 1796608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1800704 ++read 2048/2048 bytes at offset 1800704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1804800 ++read 2048/2048 bytes at offset 1804800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1808896 ++read 2048/2048 bytes at offset 1808896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1812992 ++read 2048/2048 bytes at offset 1812992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1817088 ++read 2048/2048 bytes at offset 1817088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1821184 ++read 2048/2048 bytes at offset 1821184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1825280 ++read 2048/2048 bytes at offset 1825280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1829376 ++read 2048/2048 bytes at offset 1829376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1833472 ++read 2048/2048 bytes at offset 1833472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1837568 ++read 2048/2048 bytes at offset 1837568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1841664 ++read 2048/2048 bytes at offset 1841664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1845760 ++read 2048/2048 bytes at offset 1845760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1849856 ++read 2048/2048 bytes at offset 1849856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1853952 ++read 2048/2048 bytes at offset 1853952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1858048 ++read 2048/2048 bytes at offset 1858048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1862144 ++read 2048/2048 bytes at offset 1862144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1866240 ++read 2048/2048 bytes at offset 1866240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1870336 ++read 2048/2048 bytes at offset 1870336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1874432 ++read 2048/2048 bytes at offset 1874432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1878528 ++read 2048/2048 bytes at offset 1878528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1882624 ++read 2048/2048 bytes at offset 1882624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1886720 ++read 2048/2048 bytes at offset 1886720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1890816 ++read 2048/2048 bytes at offset 1890816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1894912 ++read 2048/2048 bytes at offset 1894912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1899008 ++read 2048/2048 bytes at offset 1899008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1903104 ++read 2048/2048 bytes at offset 1903104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1907200 ++read 2048/2048 bytes at offset 1907200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1911296 ++read 2048/2048 bytes at offset 1911296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1915392 ++read 2048/2048 bytes at offset 1915392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1919488 ++read 2048/2048 bytes at offset 1919488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1923584 ++read 2048/2048 bytes at offset 1923584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1927680 ++read 2048/2048 bytes at offset 1927680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1931776 ++read 2048/2048 bytes at offset 1931776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1935872 ++read 2048/2048 bytes at offset 1935872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1939968 ++read 2048/2048 bytes at offset 1939968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1944064 ++read 2048/2048 bytes at offset 1944064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1948160 ++read 2048/2048 bytes at offset 1948160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1952256 ++read 2048/2048 bytes at offset 1952256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1956352 ++read 2048/2048 bytes at offset 1956352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1960448 ++read 2048/2048 bytes at offset 1960448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1964544 ++read 2048/2048 bytes at offset 1964544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1968640 ++read 2048/2048 bytes at offset 1968640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1972736 ++read 2048/2048 bytes at offset 1972736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1976832 ++read 2048/2048 bytes at offset 1976832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1980928 ++read 2048/2048 bytes at offset 1980928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1985024 ++read 2048/2048 bytes at offset 1985024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1989120 ++read 2048/2048 bytes at offset 1989120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1993216 ++read 2048/2048 bytes at offset 1993216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1997312 ++read 2048/2048 bytes at offset 1997312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2001408 ++read 2048/2048 bytes at offset 2001408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2005504 ++read 2048/2048 bytes at offset 2005504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2009600 ++read 2048/2048 bytes at offset 2009600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2013696 ++read 2048/2048 bytes at offset 2013696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2017792 ++read 2048/2048 bytes at offset 2017792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2021888 ++read 2048/2048 bytes at offset 2021888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2025984 ++read 2048/2048 bytes at offset 2025984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2030080 ++read 2048/2048 bytes at offset 2030080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2034176 ++read 2048/2048 bytes at offset 2034176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2038272 ++read 2048/2048 bytes at offset 2038272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2042368 ++read 2048/2048 bytes at offset 2042368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2046464 ++read 2048/2048 bytes at offset 2046464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2050560 ++read 2048/2048 bytes at offset 2050560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2054656 ++read 2048/2048 bytes at offset 2054656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2058752 ++read 2048/2048 bytes at offset 2058752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2062848 ++read 2048/2048 bytes at offset 2062848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2066944 ++read 2048/2048 bytes at offset 2066944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2071040 ++read 2048/2048 bytes at offset 2071040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2075136 ++read 2048/2048 bytes at offset 2075136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2079232 ++read 2048/2048 bytes at offset 2079232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2083328 ++read 2048/2048 bytes at offset 2083328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2087424 ++read 2048/2048 bytes at offset 2087424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2091520 ++read 2048/2048 bytes at offset 2091520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2095616 ++read 2048/2048 bytes at offset 2095616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 1 +-qemu-io> read 2048/2048 bytes at offset 2097664 ++=== IO: pattern 1 ++read 2048/2048 bytes at offset 2097664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2101760 ++read 2048/2048 bytes at offset 2101760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2105856 ++read 2048/2048 bytes at offset 2105856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2109952 ++read 2048/2048 bytes at offset 2109952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2114048 ++read 2048/2048 bytes at offset 2114048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2118144 ++read 2048/2048 bytes at offset 2118144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2122240 ++read 2048/2048 bytes at offset 2122240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2126336 ++read 2048/2048 bytes at offset 2126336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2130432 ++read 2048/2048 bytes at offset 2130432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2134528 ++read 2048/2048 bytes at offset 2134528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2138624 ++read 2048/2048 bytes at offset 2138624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2142720 ++read 2048/2048 bytes at offset 2142720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2146816 ++read 2048/2048 bytes at offset 2146816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2150912 ++read 2048/2048 bytes at offset 2150912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2155008 ++read 2048/2048 bytes at offset 2155008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2159104 ++read 2048/2048 bytes at offset 2159104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2163200 ++read 2048/2048 bytes at offset 2163200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2167296 ++read 2048/2048 bytes at offset 2167296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2171392 ++read 2048/2048 bytes at offset 2171392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2175488 ++read 2048/2048 bytes at offset 2175488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2179584 ++read 2048/2048 bytes at offset 2179584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2183680 ++read 2048/2048 bytes at offset 2183680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2187776 ++read 2048/2048 bytes at offset 2187776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2191872 ++read 2048/2048 bytes at offset 2191872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2195968 ++read 2048/2048 bytes at offset 2195968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2200064 ++read 2048/2048 bytes at offset 2200064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2204160 ++read 2048/2048 bytes at offset 2204160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2208256 ++read 2048/2048 bytes at offset 2208256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2212352 ++read 2048/2048 bytes at offset 2212352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2216448 ++read 2048/2048 bytes at offset 2216448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2220544 ++read 2048/2048 bytes at offset 2220544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2224640 ++read 2048/2048 bytes at offset 2224640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2228736 ++read 2048/2048 bytes at offset 2228736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2232832 ++read 2048/2048 bytes at offset 2232832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2236928 ++read 2048/2048 bytes at offset 2236928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2241024 ++read 2048/2048 bytes at offset 2241024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2245120 ++read 2048/2048 bytes at offset 2245120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2249216 ++read 2048/2048 bytes at offset 2249216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2253312 ++read 2048/2048 bytes at offset 2253312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2257408 ++read 2048/2048 bytes at offset 2257408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2261504 ++read 2048/2048 bytes at offset 2261504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2265600 ++read 2048/2048 bytes at offset 2265600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2269696 ++read 2048/2048 bytes at offset 2269696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2273792 ++read 2048/2048 bytes at offset 2273792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2277888 ++read 2048/2048 bytes at offset 2277888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2281984 ++read 2048/2048 bytes at offset 2281984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2286080 ++read 2048/2048 bytes at offset 2286080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2290176 ++read 2048/2048 bytes at offset 2290176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2294272 ++read 2048/2048 bytes at offset 2294272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2298368 ++read 2048/2048 bytes at offset 2298368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2302464 ++read 2048/2048 bytes at offset 2302464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2306560 ++read 2048/2048 bytes at offset 2306560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2310656 ++read 2048/2048 bytes at offset 2310656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2314752 ++read 2048/2048 bytes at offset 2314752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2318848 ++read 2048/2048 bytes at offset 2318848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2322944 ++read 2048/2048 bytes at offset 2322944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2327040 ++read 2048/2048 bytes at offset 2327040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2331136 ++read 2048/2048 bytes at offset 2331136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2335232 ++read 2048/2048 bytes at offset 2335232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2339328 ++read 2048/2048 bytes at offset 2339328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2343424 ++read 2048/2048 bytes at offset 2343424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2347520 ++read 2048/2048 bytes at offset 2347520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2351616 ++read 2048/2048 bytes at offset 2351616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2355712 ++read 2048/2048 bytes at offset 2355712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2359808 ++read 2048/2048 bytes at offset 2359808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2363904 ++read 2048/2048 bytes at offset 2363904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2368000 ++read 2048/2048 bytes at offset 2368000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2372096 ++read 2048/2048 bytes at offset 2372096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2376192 ++read 2048/2048 bytes at offset 2376192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2380288 ++read 2048/2048 bytes at offset 2380288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2384384 ++read 2048/2048 bytes at offset 2384384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2388480 ++read 2048/2048 bytes at offset 2388480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2392576 ++read 2048/2048 bytes at offset 2392576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2396672 ++read 2048/2048 bytes at offset 2396672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2400768 ++read 2048/2048 bytes at offset 2400768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2404864 ++read 2048/2048 bytes at offset 2404864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2408960 ++read 2048/2048 bytes at offset 2408960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2413056 ++read 2048/2048 bytes at offset 2413056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2417152 ++read 2048/2048 bytes at offset 2417152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2421248 ++read 2048/2048 bytes at offset 2421248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2425344 ++read 2048/2048 bytes at offset 2425344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2429440 ++read 2048/2048 bytes at offset 2429440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2433536 ++read 2048/2048 bytes at offset 2433536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2437632 ++read 2048/2048 bytes at offset 2437632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2441728 ++read 2048/2048 bytes at offset 2441728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2445824 ++read 2048/2048 bytes at offset 2445824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2449920 ++read 2048/2048 bytes at offset 2449920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2454016 ++read 2048/2048 bytes at offset 2454016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2458112 ++read 2048/2048 bytes at offset 2458112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2462208 ++read 2048/2048 bytes at offset 2462208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2466304 ++read 2048/2048 bytes at offset 2466304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2470400 ++read 2048/2048 bytes at offset 2470400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2474496 ++read 2048/2048 bytes at offset 2474496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2478592 ++read 2048/2048 bytes at offset 2478592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2482688 ++read 2048/2048 bytes at offset 2482688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2486784 ++read 2048/2048 bytes at offset 2486784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2490880 ++read 2048/2048 bytes at offset 2490880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2494976 ++read 2048/2048 bytes at offset 2494976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2499072 ++read 2048/2048 bytes at offset 2499072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2503168 ++read 2048/2048 bytes at offset 2503168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2507264 ++read 2048/2048 bytes at offset 2507264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2511360 ++read 2048/2048 bytes at offset 2511360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2515456 ++read 2048/2048 bytes at offset 2515456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2519552 ++read 2048/2048 bytes at offset 2519552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2523648 ++read 2048/2048 bytes at offset 2523648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2527744 ++read 2048/2048 bytes at offset 2527744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2531840 ++read 2048/2048 bytes at offset 2531840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2535936 ++read 2048/2048 bytes at offset 2535936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2540032 ++read 2048/2048 bytes at offset 2540032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2544128 ++read 2048/2048 bytes at offset 2544128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2548224 ++read 2048/2048 bytes at offset 2548224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2552320 ++read 2048/2048 bytes at offset 2552320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2556416 ++read 2048/2048 bytes at offset 2556416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2560512 ++read 2048/2048 bytes at offset 2560512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2564608 ++read 2048/2048 bytes at offset 2564608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2568704 ++read 2048/2048 bytes at offset 2568704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2572800 ++read 2048/2048 bytes at offset 2572800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2576896 ++read 2048/2048 bytes at offset 2576896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2580992 ++read 2048/2048 bytes at offset 2580992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2585088 ++read 2048/2048 bytes at offset 2585088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2589184 ++read 2048/2048 bytes at offset 2589184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2593280 ++read 2048/2048 bytes at offset 2593280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2597376 ++read 2048/2048 bytes at offset 2597376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2601472 ++read 2048/2048 bytes at offset 2601472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2605568 ++read 2048/2048 bytes at offset 2605568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2609664 ++read 2048/2048 bytes at offset 2609664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2613760 ++read 2048/2048 bytes at offset 2613760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2617856 ++read 2048/2048 bytes at offset 2617856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2621952 ++read 2048/2048 bytes at offset 2621952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2626048 ++read 2048/2048 bytes at offset 2626048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2630144 ++read 2048/2048 bytes at offset 2630144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2634240 ++read 2048/2048 bytes at offset 2634240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2638336 ++read 2048/2048 bytes at offset 2638336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2642432 ++read 2048/2048 bytes at offset 2642432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2646528 ++read 2048/2048 bytes at offset 2646528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2650624 ++read 2048/2048 bytes at offset 2650624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2654720 ++read 2048/2048 bytes at offset 2654720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2658816 ++read 2048/2048 bytes at offset 2658816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2662912 ++read 2048/2048 bytes at offset 2662912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2667008 ++read 2048/2048 bytes at offset 2667008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2671104 ++read 2048/2048 bytes at offset 2671104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2675200 ++read 2048/2048 bytes at offset 2675200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2679296 ++read 2048/2048 bytes at offset 2679296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2683392 ++read 2048/2048 bytes at offset 2683392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2687488 ++read 2048/2048 bytes at offset 2687488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2691584 ++read 2048/2048 bytes at offset 2691584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2695680 ++read 2048/2048 bytes at offset 2695680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2699776 ++read 2048/2048 bytes at offset 2699776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2703872 ++read 2048/2048 bytes at offset 2703872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2707968 ++read 2048/2048 bytes at offset 2707968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2712064 ++read 2048/2048 bytes at offset 2712064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2716160 ++read 2048/2048 bytes at offset 2716160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2720256 ++read 2048/2048 bytes at offset 2720256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2724352 ++read 2048/2048 bytes at offset 2724352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2728448 ++read 2048/2048 bytes at offset 2728448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2732544 ++read 2048/2048 bytes at offset 2732544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2736640 ++read 2048/2048 bytes at offset 2736640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2740736 ++read 2048/2048 bytes at offset 2740736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2744832 ++read 2048/2048 bytes at offset 2744832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2748928 ++read 2048/2048 bytes at offset 2748928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2753024 ++read 2048/2048 bytes at offset 2753024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2757120 ++read 2048/2048 bytes at offset 2757120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2761216 ++read 2048/2048 bytes at offset 2761216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2765312 ++read 2048/2048 bytes at offset 2765312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2769408 ++read 2048/2048 bytes at offset 2769408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2773504 ++read 2048/2048 bytes at offset 2773504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2777600 ++read 2048/2048 bytes at offset 2777600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2781696 ++read 2048/2048 bytes at offset 2781696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2785792 ++read 2048/2048 bytes at offset 2785792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2789888 ++read 2048/2048 bytes at offset 2789888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2793984 ++read 2048/2048 bytes at offset 2793984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2798080 ++read 2048/2048 bytes at offset 2798080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2802176 ++read 2048/2048 bytes at offset 2802176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2806272 ++read 2048/2048 bytes at offset 2806272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2810368 ++read 2048/2048 bytes at offset 2810368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2814464 ++read 2048/2048 bytes at offset 2814464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2818560 ++read 2048/2048 bytes at offset 2818560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2822656 ++read 2048/2048 bytes at offset 2822656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2826752 ++read 2048/2048 bytes at offset 2826752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2830848 ++read 2048/2048 bytes at offset 2830848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2834944 ++read 2048/2048 bytes at offset 2834944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2839040 ++read 2048/2048 bytes at offset 2839040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2843136 ++read 2048/2048 bytes at offset 2843136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2847232 ++read 2048/2048 bytes at offset 2847232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2851328 ++read 2048/2048 bytes at offset 2851328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2855424 ++read 2048/2048 bytes at offset 2855424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2859520 ++read 2048/2048 bytes at offset 2859520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2863616 ++read 2048/2048 bytes at offset 2863616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2867712 ++read 2048/2048 bytes at offset 2867712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2871808 ++read 2048/2048 bytes at offset 2871808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2875904 ++read 2048/2048 bytes at offset 2875904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2880000 ++read 2048/2048 bytes at offset 2880000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2884096 ++read 2048/2048 bytes at offset 2884096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2888192 ++read 2048/2048 bytes at offset 2888192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2892288 ++read 2048/2048 bytes at offset 2892288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2896384 ++read 2048/2048 bytes at offset 2896384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2900480 ++read 2048/2048 bytes at offset 2900480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2904576 ++read 2048/2048 bytes at offset 2904576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2908672 ++read 2048/2048 bytes at offset 2908672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2912768 ++read 2048/2048 bytes at offset 2912768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2916864 ++read 2048/2048 bytes at offset 2916864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2920960 ++read 2048/2048 bytes at offset 2920960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2925056 ++read 2048/2048 bytes at offset 2925056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2929152 ++read 2048/2048 bytes at offset 2929152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2933248 ++read 2048/2048 bytes at offset 2933248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2937344 ++read 2048/2048 bytes at offset 2937344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2941440 ++read 2048/2048 bytes at offset 2941440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2945536 ++read 2048/2048 bytes at offset 2945536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2949632 ++read 2048/2048 bytes at offset 2949632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2953728 ++read 2048/2048 bytes at offset 2953728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2957824 ++read 2048/2048 bytes at offset 2957824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2961920 ++read 2048/2048 bytes at offset 2961920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2966016 ++read 2048/2048 bytes at offset 2966016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2970112 ++read 2048/2048 bytes at offset 2970112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2974208 ++read 2048/2048 bytes at offset 2974208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2978304 ++read 2048/2048 bytes at offset 2978304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2982400 ++read 2048/2048 bytes at offset 2982400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2986496 ++read 2048/2048 bytes at offset 2986496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2990592 ++read 2048/2048 bytes at offset 2990592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2994688 ++read 2048/2048 bytes at offset 2994688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2998784 ++read 2048/2048 bytes at offset 2998784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3002880 ++read 2048/2048 bytes at offset 3002880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3006976 ++read 2048/2048 bytes at offset 3006976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3011072 ++read 2048/2048 bytes at offset 3011072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3015168 ++read 2048/2048 bytes at offset 3015168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3019264 ++read 2048/2048 bytes at offset 3019264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3023360 ++read 2048/2048 bytes at offset 3023360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3027456 ++read 2048/2048 bytes at offset 3027456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3031552 ++read 2048/2048 bytes at offset 3031552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3035648 ++read 2048/2048 bytes at offset 3035648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3039744 ++read 2048/2048 bytes at offset 3039744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3043840 ++read 2048/2048 bytes at offset 3043840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3047936 ++read 2048/2048 bytes at offset 3047936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3052032 ++read 2048/2048 bytes at offset 3052032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3056128 ++read 2048/2048 bytes at offset 3056128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3060224 ++read 2048/2048 bytes at offset 3060224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3064320 ++read 2048/2048 bytes at offset 3064320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3068416 ++read 2048/2048 bytes at offset 3068416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3072512 ++read 2048/2048 bytes at offset 3072512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3076608 ++read 2048/2048 bytes at offset 3076608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3080704 ++read 2048/2048 bytes at offset 3080704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3084800 ++read 2048/2048 bytes at offset 3084800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3088896 ++read 2048/2048 bytes at offset 3088896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3092992 ++read 2048/2048 bytes at offset 3092992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3097088 ++read 2048/2048 bytes at offset 3097088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3101184 ++read 2048/2048 bytes at offset 3101184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3105280 ++read 2048/2048 bytes at offset 3105280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3109376 ++read 2048/2048 bytes at offset 3109376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3113472 ++read 2048/2048 bytes at offset 3113472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3117568 ++read 2048/2048 bytes at offset 3117568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3121664 ++read 2048/2048 bytes at offset 3121664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3125760 ++read 2048/2048 bytes at offset 3125760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3129856 ++read 2048/2048 bytes at offset 3129856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3133952 ++read 2048/2048 bytes at offset 3133952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3138048 ++read 2048/2048 bytes at offset 3138048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3142144 ++read 2048/2048 bytes at offset 3142144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 3 +-qemu-io> read 2048/2048 bytes at offset 3147264 ++=== IO: pattern 3 ++read 2048/2048 bytes at offset 3147264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3151360 ++read 2048/2048 bytes at offset 3151360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3155456 ++read 2048/2048 bytes at offset 3155456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3159552 ++read 2048/2048 bytes at offset 3159552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3163648 ++read 2048/2048 bytes at offset 3163648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3167744 ++read 2048/2048 bytes at offset 3167744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3171840 ++read 2048/2048 bytes at offset 3171840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3175936 ++read 2048/2048 bytes at offset 3175936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3180032 ++read 2048/2048 bytes at offset 3180032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3184128 ++read 2048/2048 bytes at offset 3184128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3188224 ++read 2048/2048 bytes at offset 3188224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3192320 ++read 2048/2048 bytes at offset 3192320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3196416 ++read 2048/2048 bytes at offset 3196416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3200512 ++read 2048/2048 bytes at offset 3200512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3204608 ++read 2048/2048 bytes at offset 3204608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3208704 ++read 2048/2048 bytes at offset 3208704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3212800 ++read 2048/2048 bytes at offset 3212800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3216896 ++read 2048/2048 bytes at offset 3216896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3220992 ++read 2048/2048 bytes at offset 3220992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3225088 ++read 2048/2048 bytes at offset 3225088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3229184 ++read 2048/2048 bytes at offset 3229184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3233280 ++read 2048/2048 bytes at offset 3233280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3237376 ++read 2048/2048 bytes at offset 3237376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3241472 ++read 2048/2048 bytes at offset 3241472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3245568 ++read 2048/2048 bytes at offset 3245568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3249664 ++read 2048/2048 bytes at offset 3249664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3253760 ++read 2048/2048 bytes at offset 3253760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3257856 ++read 2048/2048 bytes at offset 3257856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3261952 ++read 2048/2048 bytes at offset 3261952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3266048 ++read 2048/2048 bytes at offset 3266048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3270144 ++read 2048/2048 bytes at offset 3270144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3274240 ++read 2048/2048 bytes at offset 3274240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3278336 ++read 2048/2048 bytes at offset 3278336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3282432 ++read 2048/2048 bytes at offset 3282432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3286528 ++read 2048/2048 bytes at offset 3286528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3290624 ++read 2048/2048 bytes at offset 3290624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3294720 ++read 2048/2048 bytes at offset 3294720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3298816 ++read 2048/2048 bytes at offset 3298816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3302912 ++read 2048/2048 bytes at offset 3302912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3307008 ++read 2048/2048 bytes at offset 3307008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3311104 ++read 2048/2048 bytes at offset 3311104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3315200 ++read 2048/2048 bytes at offset 3315200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3319296 ++read 2048/2048 bytes at offset 3319296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3323392 ++read 2048/2048 bytes at offset 3323392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3327488 ++read 2048/2048 bytes at offset 3327488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3331584 ++read 2048/2048 bytes at offset 3331584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3335680 ++read 2048/2048 bytes at offset 3335680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3339776 ++read 2048/2048 bytes at offset 3339776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3343872 ++read 2048/2048 bytes at offset 3343872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3347968 ++read 2048/2048 bytes at offset 3347968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3352064 ++read 2048/2048 bytes at offset 3352064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3356160 ++read 2048/2048 bytes at offset 3356160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3360256 ++read 2048/2048 bytes at offset 3360256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3364352 ++read 2048/2048 bytes at offset 3364352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3368448 ++read 2048/2048 bytes at offset 3368448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3372544 ++read 2048/2048 bytes at offset 3372544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3376640 ++read 2048/2048 bytes at offset 3376640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3380736 ++read 2048/2048 bytes at offset 3380736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3384832 ++read 2048/2048 bytes at offset 3384832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3388928 ++read 2048/2048 bytes at offset 3388928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3393024 ++read 2048/2048 bytes at offset 3393024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3397120 ++read 2048/2048 bytes at offset 3397120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3401216 ++read 2048/2048 bytes at offset 3401216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3405312 ++read 2048/2048 bytes at offset 3405312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3409408 ++read 2048/2048 bytes at offset 3409408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3413504 ++read 2048/2048 bytes at offset 3413504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3417600 ++read 2048/2048 bytes at offset 3417600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3421696 ++read 2048/2048 bytes at offset 3421696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3425792 ++read 2048/2048 bytes at offset 3425792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3429888 ++read 2048/2048 bytes at offset 3429888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3433984 ++read 2048/2048 bytes at offset 3433984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3438080 ++read 2048/2048 bytes at offset 3438080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3442176 ++read 2048/2048 bytes at offset 3442176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3446272 ++read 2048/2048 bytes at offset 3446272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3450368 ++read 2048/2048 bytes at offset 3450368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3454464 ++read 2048/2048 bytes at offset 3454464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3458560 ++read 2048/2048 bytes at offset 3458560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3462656 ++read 2048/2048 bytes at offset 3462656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3466752 ++read 2048/2048 bytes at offset 3466752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3470848 ++read 2048/2048 bytes at offset 3470848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3474944 ++read 2048/2048 bytes at offset 3474944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3479040 ++read 2048/2048 bytes at offset 3479040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3483136 ++read 2048/2048 bytes at offset 3483136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3487232 ++read 2048/2048 bytes at offset 3487232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3491328 ++read 2048/2048 bytes at offset 3491328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3495424 ++read 2048/2048 bytes at offset 3495424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3499520 ++read 2048/2048 bytes at offset 3499520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3503616 ++read 2048/2048 bytes at offset 3503616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3507712 ++read 2048/2048 bytes at offset 3507712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3511808 ++read 2048/2048 bytes at offset 3511808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3515904 ++read 2048/2048 bytes at offset 3515904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3520000 ++read 2048/2048 bytes at offset 3520000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3524096 ++read 2048/2048 bytes at offset 3524096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3528192 ++read 2048/2048 bytes at offset 3528192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3532288 ++read 2048/2048 bytes at offset 3532288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3536384 ++read 2048/2048 bytes at offset 3536384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3540480 ++read 2048/2048 bytes at offset 3540480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3544576 ++read 2048/2048 bytes at offset 3544576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3548672 ++read 2048/2048 bytes at offset 3548672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3552768 ++read 2048/2048 bytes at offset 3552768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3556864 ++read 2048/2048 bytes at offset 3556864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3560960 ++read 2048/2048 bytes at offset 3560960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3565056 ++read 2048/2048 bytes at offset 3565056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3569152 ++read 2048/2048 bytes at offset 3569152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3573248 ++read 2048/2048 bytes at offset 3573248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3577344 ++read 2048/2048 bytes at offset 3577344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3581440 ++read 2048/2048 bytes at offset 3581440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3585536 ++read 2048/2048 bytes at offset 3585536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3589632 ++read 2048/2048 bytes at offset 3589632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3593728 ++read 2048/2048 bytes at offset 3593728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3597824 ++read 2048/2048 bytes at offset 3597824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3601920 ++read 2048/2048 bytes at offset 3601920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3606016 ++read 2048/2048 bytes at offset 3606016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3610112 ++read 2048/2048 bytes at offset 3610112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3614208 ++read 2048/2048 bytes at offset 3614208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3618304 ++read 2048/2048 bytes at offset 3618304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3622400 ++read 2048/2048 bytes at offset 3622400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3626496 ++read 2048/2048 bytes at offset 3626496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3630592 ++read 2048/2048 bytes at offset 3630592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3634688 ++read 2048/2048 bytes at offset 3634688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3638784 ++read 2048/2048 bytes at offset 3638784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3642880 ++read 2048/2048 bytes at offset 3642880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3646976 ++read 2048/2048 bytes at offset 3646976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3651072 ++read 2048/2048 bytes at offset 3651072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3655168 ++read 2048/2048 bytes at offset 3655168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3659264 ++read 2048/2048 bytes at offset 3659264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3663360 ++read 2048/2048 bytes at offset 3663360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3667456 ++read 2048/2048 bytes at offset 3667456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3671552 ++read 2048/2048 bytes at offset 3671552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3675648 ++read 2048/2048 bytes at offset 3675648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3679744 ++read 2048/2048 bytes at offset 3679744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3683840 ++read 2048/2048 bytes at offset 3683840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3687936 ++read 2048/2048 bytes at offset 3687936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3692032 ++read 2048/2048 bytes at offset 3692032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3696128 ++read 2048/2048 bytes at offset 3696128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3700224 ++read 2048/2048 bytes at offset 3700224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3704320 ++read 2048/2048 bytes at offset 3704320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3708416 ++read 2048/2048 bytes at offset 3708416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3712512 ++read 2048/2048 bytes at offset 3712512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3716608 ++read 2048/2048 bytes at offset 3716608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3720704 ++read 2048/2048 bytes at offset 3720704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3724800 ++read 2048/2048 bytes at offset 3724800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3728896 ++read 2048/2048 bytes at offset 3728896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3732992 ++read 2048/2048 bytes at offset 3732992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3737088 ++read 2048/2048 bytes at offset 3737088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3741184 ++read 2048/2048 bytes at offset 3741184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3745280 ++read 2048/2048 bytes at offset 3745280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3749376 ++read 2048/2048 bytes at offset 3749376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3753472 ++read 2048/2048 bytes at offset 3753472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3757568 ++read 2048/2048 bytes at offset 3757568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3761664 ++read 2048/2048 bytes at offset 3761664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3765760 ++read 2048/2048 bytes at offset 3765760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3769856 ++read 2048/2048 bytes at offset 3769856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3773952 ++read 2048/2048 bytes at offset 3773952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3778048 ++read 2048/2048 bytes at offset 3778048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3782144 ++read 2048/2048 bytes at offset 3782144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3786240 ++read 2048/2048 bytes at offset 3786240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3790336 ++read 2048/2048 bytes at offset 3790336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3794432 ++read 2048/2048 bytes at offset 3794432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3798528 ++read 2048/2048 bytes at offset 3798528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3802624 ++read 2048/2048 bytes at offset 3802624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3806720 ++read 2048/2048 bytes at offset 3806720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3810816 ++read 2048/2048 bytes at offset 3810816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3814912 ++read 2048/2048 bytes at offset 3814912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3819008 ++read 2048/2048 bytes at offset 3819008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3823104 ++read 2048/2048 bytes at offset 3823104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3827200 ++read 2048/2048 bytes at offset 3827200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3831296 ++read 2048/2048 bytes at offset 3831296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3835392 ++read 2048/2048 bytes at offset 3835392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3839488 ++read 2048/2048 bytes at offset 3839488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3843584 ++read 2048/2048 bytes at offset 3843584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3847680 ++read 2048/2048 bytes at offset 3847680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3851776 ++read 2048/2048 bytes at offset 3851776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3855872 ++read 2048/2048 bytes at offset 3855872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3859968 ++read 2048/2048 bytes at offset 3859968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3864064 ++read 2048/2048 bytes at offset 3864064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3868160 ++read 2048/2048 bytes at offset 3868160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3872256 ++read 2048/2048 bytes at offset 3872256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3876352 ++read 2048/2048 bytes at offset 3876352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3880448 ++read 2048/2048 bytes at offset 3880448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3884544 ++read 2048/2048 bytes at offset 3884544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3888640 ++read 2048/2048 bytes at offset 3888640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3892736 ++read 2048/2048 bytes at offset 3892736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3896832 ++read 2048/2048 bytes at offset 3896832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3900928 ++read 2048/2048 bytes at offset 3900928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3905024 ++read 2048/2048 bytes at offset 3905024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3909120 ++read 2048/2048 bytes at offset 3909120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3913216 ++read 2048/2048 bytes at offset 3913216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3917312 ++read 2048/2048 bytes at offset 3917312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3921408 ++read 2048/2048 bytes at offset 3921408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3925504 ++read 2048/2048 bytes at offset 3925504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3929600 ++read 2048/2048 bytes at offset 3929600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3933696 ++read 2048/2048 bytes at offset 3933696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3937792 ++read 2048/2048 bytes at offset 3937792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3941888 ++read 2048/2048 bytes at offset 3941888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3945984 ++read 2048/2048 bytes at offset 3945984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3950080 ++read 2048/2048 bytes at offset 3950080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3954176 ++read 2048/2048 bytes at offset 3954176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3958272 ++read 2048/2048 bytes at offset 3958272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3962368 ++read 2048/2048 bytes at offset 3962368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3966464 ++read 2048/2048 bytes at offset 3966464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3970560 ++read 2048/2048 bytes at offset 3970560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3974656 ++read 2048/2048 bytes at offset 3974656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3978752 ++read 2048/2048 bytes at offset 3978752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3982848 ++read 2048/2048 bytes at offset 3982848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3986944 ++read 2048/2048 bytes at offset 3986944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3991040 ++read 2048/2048 bytes at offset 3991040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3995136 ++read 2048/2048 bytes at offset 3995136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3999232 ++read 2048/2048 bytes at offset 3999232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4003328 ++read 2048/2048 bytes at offset 4003328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4007424 ++read 2048/2048 bytes at offset 4007424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4011520 ++read 2048/2048 bytes at offset 4011520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4015616 ++read 2048/2048 bytes at offset 4015616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4019712 ++read 2048/2048 bytes at offset 4019712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4023808 ++read 2048/2048 bytes at offset 4023808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4027904 ++read 2048/2048 bytes at offset 4027904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4032000 ++read 2048/2048 bytes at offset 4032000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4036096 ++read 2048/2048 bytes at offset 4036096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4040192 ++read 2048/2048 bytes at offset 4040192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4044288 ++read 2048/2048 bytes at offset 4044288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4048384 ++read 2048/2048 bytes at offset 4048384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4052480 ++read 2048/2048 bytes at offset 4052480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4056576 ++read 2048/2048 bytes at offset 4056576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4060672 ++read 2048/2048 bytes at offset 4060672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4064768 ++read 2048/2048 bytes at offset 4064768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4068864 ++read 2048/2048 bytes at offset 4068864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4072960 ++read 2048/2048 bytes at offset 4072960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4077056 ++read 2048/2048 bytes at offset 4077056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4081152 ++read 2048/2048 bytes at offset 4081152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4085248 ++read 2048/2048 bytes at offset 4085248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4089344 ++read 2048/2048 bytes at offset 4089344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4093440 ++read 2048/2048 bytes at offset 4093440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4097536 ++read 2048/2048 bytes at offset 4097536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4101632 ++read 2048/2048 bytes at offset 4101632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4105728 ++read 2048/2048 bytes at offset 4105728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4109824 ++read 2048/2048 bytes at offset 4109824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4113920 ++read 2048/2048 bytes at offset 4113920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4118016 ++read 2048/2048 bytes at offset 4118016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4122112 ++read 2048/2048 bytes at offset 4122112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4126208 ++read 2048/2048 bytes at offset 4126208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4130304 ++read 2048/2048 bytes at offset 4130304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4134400 ++read 2048/2048 bytes at offset 4134400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4138496 ++read 2048/2048 bytes at offset 4138496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4142592 ++read 2048/2048 bytes at offset 4142592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4146688 ++read 2048/2048 bytes at offset 4146688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4150784 ++read 2048/2048 bytes at offset 4150784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4154880 ++read 2048/2048 bytes at offset 4154880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4158976 ++read 2048/2048 bytes at offset 4158976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4163072 ++read 2048/2048 bytes at offset 4163072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4167168 ++read 2048/2048 bytes at offset 4167168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4171264 ++read 2048/2048 bytes at offset 4171264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4175360 ++read 2048/2048 bytes at offset 4175360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4179456 ++read 2048/2048 bytes at offset 4179456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4183552 ++read 2048/2048 bytes at offset 4183552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4187648 ++read 2048/2048 bytes at offset 4187648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4191744 ++read 2048/2048 bytes at offset 4191744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 5 +-qemu-io> read 8192/8192 bytes at offset 4196864 ++=== IO: pattern 5 ++read 8192/8192 bytes at offset 4196864 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4209152 ++read 8192/8192 bytes at offset 4209152 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4221440 ++read 8192/8192 bytes at offset 4221440 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4233728 ++read 8192/8192 bytes at offset 4233728 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4246016 ++read 8192/8192 bytes at offset 4246016 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4258304 ++read 8192/8192 bytes at offset 4258304 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4270592 ++read 8192/8192 bytes at offset 4270592 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4282880 ++read 8192/8192 bytes at offset 4282880 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295168 ++read 8192/8192 bytes at offset 4295168 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4307456 ++read 8192/8192 bytes at offset 4307456 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4319744 ++read 8192/8192 bytes at offset 4319744 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4332032 ++read 8192/8192 bytes at offset 4332032 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4344320 ++read 8192/8192 bytes at offset 4344320 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4356608 ++read 8192/8192 bytes at offset 4356608 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4368896 ++read 8192/8192 bytes at offset 4368896 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4381184 ++read 8192/8192 bytes at offset 4381184 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4393472 ++read 8192/8192 bytes at offset 4393472 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4405760 ++read 8192/8192 bytes at offset 4405760 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4418048 ++read 8192/8192 bytes at offset 4418048 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4430336 ++read 8192/8192 bytes at offset 4430336 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4442624 ++read 8192/8192 bytes at offset 4442624 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4454912 ++read 8192/8192 bytes at offset 4454912 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4467200 ++read 8192/8192 bytes at offset 4467200 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4479488 ++read 8192/8192 bytes at offset 4479488 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4491776 ++read 8192/8192 bytes at offset 4491776 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4504064 ++read 8192/8192 bytes at offset 4504064 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4516352 ++read 8192/8192 bytes at offset 4516352 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4528640 ++read 8192/8192 bytes at offset 4528640 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4540928 ++read 8192/8192 bytes at offset 4540928 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4553216 ++read 8192/8192 bytes at offset 4553216 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4565504 ++read 8192/8192 bytes at offset 4565504 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4577792 ++read 8192/8192 bytes at offset 4577792 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4590080 ++read 8192/8192 bytes at offset 4590080 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4602368 ++read 8192/8192 bytes at offset 4602368 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4614656 ++read 8192/8192 bytes at offset 4614656 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4626944 ++read 8192/8192 bytes at offset 4626944 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4639232 ++read 8192/8192 bytes at offset 4639232 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4651520 ++read 8192/8192 bytes at offset 4651520 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4663808 ++read 8192/8192 bytes at offset 4663808 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4676096 ++read 8192/8192 bytes at offset 4676096 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4688384 ++read 8192/8192 bytes at offset 4688384 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4700672 ++read 8192/8192 bytes at offset 4700672 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4712960 ++read 8192/8192 bytes at offset 4712960 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4725248 ++read 8192/8192 bytes at offset 4725248 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4737536 ++read 8192/8192 bytes at offset 4737536 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4749824 ++read 8192/8192 bytes at offset 4749824 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4762112 ++read 8192/8192 bytes at offset 4762112 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4774400 ++read 8192/8192 bytes at offset 4774400 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4786688 ++read 8192/8192 bytes at offset 4786688 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4798976 ++read 8192/8192 bytes at offset 4798976 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4811264 ++read 8192/8192 bytes at offset 4811264 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4823552 ++read 8192/8192 bytes at offset 4823552 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4835840 ++read 8192/8192 bytes at offset 4835840 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4848128 ++read 8192/8192 bytes at offset 4848128 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4860416 ++read 8192/8192 bytes at offset 4860416 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4872704 ++read 8192/8192 bytes at offset 4872704 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4884992 ++read 8192/8192 bytes at offset 4884992 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4897280 ++read 8192/8192 bytes at offset 4897280 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4909568 ++read 8192/8192 bytes at offset 4909568 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4921856 ++read 8192/8192 bytes at offset 4921856 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4934144 ++read 8192/8192 bytes at offset 4934144 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4946432 ++read 8192/8192 bytes at offset 4946432 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4958720 ++read 8192/8192 bytes at offset 4958720 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4971008 ++read 8192/8192 bytes at offset 4971008 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 244 +-qemu-io> read 12288/12288 bytes at offset 6285312 ++=== IO: pattern 244 ++read 12288/12288 bytes at offset 6285312 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 8384512 ++read 12288/12288 bytes at offset 8384512 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 10483712 ++read 12288/12288 bytes at offset 10483712 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 12582912 ++read 12288/12288 bytes at offset 12582912 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 14682112 ++read 12288/12288 bytes at offset 14682112 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 16781312 ++read 12288/12288 bytes at offset 16781312 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 18880512 ++read 12288/12288 bytes at offset 18880512 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 20979712 ++read 12288/12288 bytes at offset 20979712 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> No errors were found on the image. ++No errors were found on the image. + With offset 4294967808: + === IO: pattern 1 +-qemu-io> wrote 4096/4096 bytes at offset 4294967808 ++wrote 4096/4096 bytes at offset 4294967808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4294971904 ++wrote 4096/4096 bytes at offset 4294971904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4294976000 ++wrote 4096/4096 bytes at offset 4294976000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4294980096 ++wrote 4096/4096 bytes at offset 4294980096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4294984192 ++wrote 4096/4096 bytes at offset 4294984192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4294988288 ++wrote 4096/4096 bytes at offset 4294988288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4294992384 ++wrote 4096/4096 bytes at offset 4294992384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4294996480 ++wrote 4096/4096 bytes at offset 4294996480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295000576 ++wrote 4096/4096 bytes at offset 4295000576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295004672 ++wrote 4096/4096 bytes at offset 4295004672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295008768 ++wrote 4096/4096 bytes at offset 4295008768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295012864 ++wrote 4096/4096 bytes at offset 4295012864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295016960 ++wrote 4096/4096 bytes at offset 4295016960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295021056 ++wrote 4096/4096 bytes at offset 4295021056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295025152 ++wrote 4096/4096 bytes at offset 4295025152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295029248 ++wrote 4096/4096 bytes at offset 4295029248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295033344 ++wrote 4096/4096 bytes at offset 4295033344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295037440 ++wrote 4096/4096 bytes at offset 4295037440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295041536 ++wrote 4096/4096 bytes at offset 4295041536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295045632 ++wrote 4096/4096 bytes at offset 4295045632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295049728 ++wrote 4096/4096 bytes at offset 4295049728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295053824 ++wrote 4096/4096 bytes at offset 4295053824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295057920 ++wrote 4096/4096 bytes at offset 4295057920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295062016 ++wrote 4096/4096 bytes at offset 4295062016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295066112 ++wrote 4096/4096 bytes at offset 4295066112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295070208 ++wrote 4096/4096 bytes at offset 4295070208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295074304 ++wrote 4096/4096 bytes at offset 4295074304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295078400 ++wrote 4096/4096 bytes at offset 4295078400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295082496 ++wrote 4096/4096 bytes at offset 4295082496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295086592 ++wrote 4096/4096 bytes at offset 4295086592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295090688 ++wrote 4096/4096 bytes at offset 4295090688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295094784 ++wrote 4096/4096 bytes at offset 4295094784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295098880 ++wrote 4096/4096 bytes at offset 4295098880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295102976 ++wrote 4096/4096 bytes at offset 4295102976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295107072 ++wrote 4096/4096 bytes at offset 4295107072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295111168 ++wrote 4096/4096 bytes at offset 4295111168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295115264 ++wrote 4096/4096 bytes at offset 4295115264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295119360 ++wrote 4096/4096 bytes at offset 4295119360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295123456 ++wrote 4096/4096 bytes at offset 4295123456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295127552 ++wrote 4096/4096 bytes at offset 4295127552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295131648 ++wrote 4096/4096 bytes at offset 4295131648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295135744 ++wrote 4096/4096 bytes at offset 4295135744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295139840 ++wrote 4096/4096 bytes at offset 4295139840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295143936 ++wrote 4096/4096 bytes at offset 4295143936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295148032 ++wrote 4096/4096 bytes at offset 4295148032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295152128 ++wrote 4096/4096 bytes at offset 4295152128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295156224 ++wrote 4096/4096 bytes at offset 4295156224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295160320 ++wrote 4096/4096 bytes at offset 4295160320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295164416 ++wrote 4096/4096 bytes at offset 4295164416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295168512 ++wrote 4096/4096 bytes at offset 4295168512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295172608 ++wrote 4096/4096 bytes at offset 4295172608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295176704 ++wrote 4096/4096 bytes at offset 4295176704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295180800 ++wrote 4096/4096 bytes at offset 4295180800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295184896 ++wrote 4096/4096 bytes at offset 4295184896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295188992 ++wrote 4096/4096 bytes at offset 4295188992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295193088 ++wrote 4096/4096 bytes at offset 4295193088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295197184 ++wrote 4096/4096 bytes at offset 4295197184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295201280 ++wrote 4096/4096 bytes at offset 4295201280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295205376 ++wrote 4096/4096 bytes at offset 4295205376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295209472 ++wrote 4096/4096 bytes at offset 4295209472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295213568 ++wrote 4096/4096 bytes at offset 4295213568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295217664 ++wrote 4096/4096 bytes at offset 4295217664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295221760 ++wrote 4096/4096 bytes at offset 4295221760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295225856 ++wrote 4096/4096 bytes at offset 4295225856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295229952 ++wrote 4096/4096 bytes at offset 4295229952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295234048 ++wrote 4096/4096 bytes at offset 4295234048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295238144 ++wrote 4096/4096 bytes at offset 4295238144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295242240 ++wrote 4096/4096 bytes at offset 4295242240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295246336 ++wrote 4096/4096 bytes at offset 4295246336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295250432 ++wrote 4096/4096 bytes at offset 4295250432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295254528 ++wrote 4096/4096 bytes at offset 4295254528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295258624 ++wrote 4096/4096 bytes at offset 4295258624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295262720 ++wrote 4096/4096 bytes at offset 4295262720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295266816 ++wrote 4096/4096 bytes at offset 4295266816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295270912 ++wrote 4096/4096 bytes at offset 4295270912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295275008 ++wrote 4096/4096 bytes at offset 4295275008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295279104 ++wrote 4096/4096 bytes at offset 4295279104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295283200 ++wrote 4096/4096 bytes at offset 4295283200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295287296 ++wrote 4096/4096 bytes at offset 4295287296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295291392 ++wrote 4096/4096 bytes at offset 4295291392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295295488 ++wrote 4096/4096 bytes at offset 4295295488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295299584 ++wrote 4096/4096 bytes at offset 4295299584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295303680 ++wrote 4096/4096 bytes at offset 4295303680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295307776 ++wrote 4096/4096 bytes at offset 4295307776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295311872 ++wrote 4096/4096 bytes at offset 4295311872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295315968 ++wrote 4096/4096 bytes at offset 4295315968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295320064 ++wrote 4096/4096 bytes at offset 4295320064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295324160 ++wrote 4096/4096 bytes at offset 4295324160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295328256 ++wrote 4096/4096 bytes at offset 4295328256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295332352 ++wrote 4096/4096 bytes at offset 4295332352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295336448 ++wrote 4096/4096 bytes at offset 4295336448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295340544 ++wrote 4096/4096 bytes at offset 4295340544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295344640 ++wrote 4096/4096 bytes at offset 4295344640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295348736 ++wrote 4096/4096 bytes at offset 4295348736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295352832 ++wrote 4096/4096 bytes at offset 4295352832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295356928 ++wrote 4096/4096 bytes at offset 4295356928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295361024 ++wrote 4096/4096 bytes at offset 4295361024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295365120 ++wrote 4096/4096 bytes at offset 4295365120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295369216 ++wrote 4096/4096 bytes at offset 4295369216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295373312 ++wrote 4096/4096 bytes at offset 4295373312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295377408 ++wrote 4096/4096 bytes at offset 4295377408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295381504 ++wrote 4096/4096 bytes at offset 4295381504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295385600 ++wrote 4096/4096 bytes at offset 4295385600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295389696 ++wrote 4096/4096 bytes at offset 4295389696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295393792 ++wrote 4096/4096 bytes at offset 4295393792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295397888 ++wrote 4096/4096 bytes at offset 4295397888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295401984 ++wrote 4096/4096 bytes at offset 4295401984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295406080 ++wrote 4096/4096 bytes at offset 4295406080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295410176 ++wrote 4096/4096 bytes at offset 4295410176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295414272 ++wrote 4096/4096 bytes at offset 4295414272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295418368 ++wrote 4096/4096 bytes at offset 4295418368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295422464 ++wrote 4096/4096 bytes at offset 4295422464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295426560 ++wrote 4096/4096 bytes at offset 4295426560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295430656 ++wrote 4096/4096 bytes at offset 4295430656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295434752 ++wrote 4096/4096 bytes at offset 4295434752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295438848 ++wrote 4096/4096 bytes at offset 4295438848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295442944 ++wrote 4096/4096 bytes at offset 4295442944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295447040 ++wrote 4096/4096 bytes at offset 4295447040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295451136 ++wrote 4096/4096 bytes at offset 4295451136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295455232 ++wrote 4096/4096 bytes at offset 4295455232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295459328 ++wrote 4096/4096 bytes at offset 4295459328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295463424 ++wrote 4096/4096 bytes at offset 4295463424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295467520 ++wrote 4096/4096 bytes at offset 4295467520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295471616 ++wrote 4096/4096 bytes at offset 4295471616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295475712 ++wrote 4096/4096 bytes at offset 4295475712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295479808 ++wrote 4096/4096 bytes at offset 4295479808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295483904 ++wrote 4096/4096 bytes at offset 4295483904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295488000 ++wrote 4096/4096 bytes at offset 4295488000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295492096 ++wrote 4096/4096 bytes at offset 4295492096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295496192 ++wrote 4096/4096 bytes at offset 4295496192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295500288 ++wrote 4096/4096 bytes at offset 4295500288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295504384 ++wrote 4096/4096 bytes at offset 4295504384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295508480 ++wrote 4096/4096 bytes at offset 4295508480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295512576 ++wrote 4096/4096 bytes at offset 4295512576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295516672 ++wrote 4096/4096 bytes at offset 4295516672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295520768 ++wrote 4096/4096 bytes at offset 4295520768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295524864 ++wrote 4096/4096 bytes at offset 4295524864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295528960 ++wrote 4096/4096 bytes at offset 4295528960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295533056 ++wrote 4096/4096 bytes at offset 4295533056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295537152 ++wrote 4096/4096 bytes at offset 4295537152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295541248 ++wrote 4096/4096 bytes at offset 4295541248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295545344 ++wrote 4096/4096 bytes at offset 4295545344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295549440 ++wrote 4096/4096 bytes at offset 4295549440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295553536 ++wrote 4096/4096 bytes at offset 4295553536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295557632 ++wrote 4096/4096 bytes at offset 4295557632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295561728 ++wrote 4096/4096 bytes at offset 4295561728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295565824 ++wrote 4096/4096 bytes at offset 4295565824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295569920 ++wrote 4096/4096 bytes at offset 4295569920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295574016 ++wrote 4096/4096 bytes at offset 4295574016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295578112 ++wrote 4096/4096 bytes at offset 4295578112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295582208 ++wrote 4096/4096 bytes at offset 4295582208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295586304 ++wrote 4096/4096 bytes at offset 4295586304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295590400 ++wrote 4096/4096 bytes at offset 4295590400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295594496 ++wrote 4096/4096 bytes at offset 4295594496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295598592 ++wrote 4096/4096 bytes at offset 4295598592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295602688 ++wrote 4096/4096 bytes at offset 4295602688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295606784 ++wrote 4096/4096 bytes at offset 4295606784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295610880 ++wrote 4096/4096 bytes at offset 4295610880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295614976 ++wrote 4096/4096 bytes at offset 4295614976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295619072 ++wrote 4096/4096 bytes at offset 4295619072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295623168 ++wrote 4096/4096 bytes at offset 4295623168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295627264 ++wrote 4096/4096 bytes at offset 4295627264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295631360 ++wrote 4096/4096 bytes at offset 4295631360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295635456 ++wrote 4096/4096 bytes at offset 4295635456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295639552 ++wrote 4096/4096 bytes at offset 4295639552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295643648 ++wrote 4096/4096 bytes at offset 4295643648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295647744 ++wrote 4096/4096 bytes at offset 4295647744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295651840 ++wrote 4096/4096 bytes at offset 4295651840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295655936 ++wrote 4096/4096 bytes at offset 4295655936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295660032 ++wrote 4096/4096 bytes at offset 4295660032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295664128 ++wrote 4096/4096 bytes at offset 4295664128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295668224 ++wrote 4096/4096 bytes at offset 4295668224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295672320 ++wrote 4096/4096 bytes at offset 4295672320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295676416 ++wrote 4096/4096 bytes at offset 4295676416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295680512 ++wrote 4096/4096 bytes at offset 4295680512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295684608 ++wrote 4096/4096 bytes at offset 4295684608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295688704 ++wrote 4096/4096 bytes at offset 4295688704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295692800 ++wrote 4096/4096 bytes at offset 4295692800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295696896 ++wrote 4096/4096 bytes at offset 4295696896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295700992 ++wrote 4096/4096 bytes at offset 4295700992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295705088 ++wrote 4096/4096 bytes at offset 4295705088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295709184 ++wrote 4096/4096 bytes at offset 4295709184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295713280 ++wrote 4096/4096 bytes at offset 4295713280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295717376 ++wrote 4096/4096 bytes at offset 4295717376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295721472 ++wrote 4096/4096 bytes at offset 4295721472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295725568 ++wrote 4096/4096 bytes at offset 4295725568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295729664 ++wrote 4096/4096 bytes at offset 4295729664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295733760 ++wrote 4096/4096 bytes at offset 4295733760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295737856 ++wrote 4096/4096 bytes at offset 4295737856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295741952 ++wrote 4096/4096 bytes at offset 4295741952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295746048 ++wrote 4096/4096 bytes at offset 4295746048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295750144 ++wrote 4096/4096 bytes at offset 4295750144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295754240 ++wrote 4096/4096 bytes at offset 4295754240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295758336 ++wrote 4096/4096 bytes at offset 4295758336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295762432 ++wrote 4096/4096 bytes at offset 4295762432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295766528 ++wrote 4096/4096 bytes at offset 4295766528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295770624 ++wrote 4096/4096 bytes at offset 4295770624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295774720 ++wrote 4096/4096 bytes at offset 4295774720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295778816 ++wrote 4096/4096 bytes at offset 4295778816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295782912 ++wrote 4096/4096 bytes at offset 4295782912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295787008 ++wrote 4096/4096 bytes at offset 4295787008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295791104 ++wrote 4096/4096 bytes at offset 4295791104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295795200 ++wrote 4096/4096 bytes at offset 4295795200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295799296 ++wrote 4096/4096 bytes at offset 4295799296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295803392 ++wrote 4096/4096 bytes at offset 4295803392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295807488 ++wrote 4096/4096 bytes at offset 4295807488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295811584 ++wrote 4096/4096 bytes at offset 4295811584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295815680 ++wrote 4096/4096 bytes at offset 4295815680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295819776 ++wrote 4096/4096 bytes at offset 4295819776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295823872 ++wrote 4096/4096 bytes at offset 4295823872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295827968 ++wrote 4096/4096 bytes at offset 4295827968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295832064 ++wrote 4096/4096 bytes at offset 4295832064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295836160 ++wrote 4096/4096 bytes at offset 4295836160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295840256 ++wrote 4096/4096 bytes at offset 4295840256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295844352 ++wrote 4096/4096 bytes at offset 4295844352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295848448 ++wrote 4096/4096 bytes at offset 4295848448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295852544 ++wrote 4096/4096 bytes at offset 4295852544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295856640 ++wrote 4096/4096 bytes at offset 4295856640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295860736 ++wrote 4096/4096 bytes at offset 4295860736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295864832 ++wrote 4096/4096 bytes at offset 4295864832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295868928 ++wrote 4096/4096 bytes at offset 4295868928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295873024 ++wrote 4096/4096 bytes at offset 4295873024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295877120 ++wrote 4096/4096 bytes at offset 4295877120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295881216 ++wrote 4096/4096 bytes at offset 4295881216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295885312 ++wrote 4096/4096 bytes at offset 4295885312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295889408 ++wrote 4096/4096 bytes at offset 4295889408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295893504 ++wrote 4096/4096 bytes at offset 4295893504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295897600 ++wrote 4096/4096 bytes at offset 4295897600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295901696 ++wrote 4096/4096 bytes at offset 4295901696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295905792 ++wrote 4096/4096 bytes at offset 4295905792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295909888 ++wrote 4096/4096 bytes at offset 4295909888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295913984 ++wrote 4096/4096 bytes at offset 4295913984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295918080 ++wrote 4096/4096 bytes at offset 4295918080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295922176 ++wrote 4096/4096 bytes at offset 4295922176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295926272 ++wrote 4096/4096 bytes at offset 4295926272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295930368 ++wrote 4096/4096 bytes at offset 4295930368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295934464 ++wrote 4096/4096 bytes at offset 4295934464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295938560 ++wrote 4096/4096 bytes at offset 4295938560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295942656 ++wrote 4096/4096 bytes at offset 4295942656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295946752 ++wrote 4096/4096 bytes at offset 4295946752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295950848 ++wrote 4096/4096 bytes at offset 4295950848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295954944 ++wrote 4096/4096 bytes at offset 4295954944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295959040 ++wrote 4096/4096 bytes at offset 4295959040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295963136 ++wrote 4096/4096 bytes at offset 4295963136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295967232 ++wrote 4096/4096 bytes at offset 4295967232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295971328 ++wrote 4096/4096 bytes at offset 4295971328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295975424 ++wrote 4096/4096 bytes at offset 4295975424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295979520 ++wrote 4096/4096 bytes at offset 4295979520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295983616 ++wrote 4096/4096 bytes at offset 4295983616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295987712 ++wrote 4096/4096 bytes at offset 4295987712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295991808 ++wrote 4096/4096 bytes at offset 4295991808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295995904 ++wrote 4096/4096 bytes at offset 4295995904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296000000 ++wrote 4096/4096 bytes at offset 4296000000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296004096 ++wrote 4096/4096 bytes at offset 4296004096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296008192 ++wrote 4096/4096 bytes at offset 4296008192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296012288 ++wrote 4096/4096 bytes at offset 4296012288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 5 +-qemu-io> wrote 2048/2048 bytes at offset 4296018432 ++=== IO: pattern 5 ++wrote 2048/2048 bytes at offset 4296018432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296022528 ++wrote 2048/2048 bytes at offset 4296022528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296026624 ++wrote 2048/2048 bytes at offset 4296026624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296030720 ++wrote 2048/2048 bytes at offset 4296030720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296034816 ++wrote 2048/2048 bytes at offset 4296034816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296038912 ++wrote 2048/2048 bytes at offset 4296038912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296043008 ++wrote 2048/2048 bytes at offset 4296043008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296047104 ++wrote 2048/2048 bytes at offset 4296047104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296051200 ++wrote 2048/2048 bytes at offset 4296051200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296055296 ++wrote 2048/2048 bytes at offset 4296055296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296059392 ++wrote 2048/2048 bytes at offset 4296059392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296063488 ++wrote 2048/2048 bytes at offset 4296063488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296067584 ++wrote 2048/2048 bytes at offset 4296067584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296071680 ++wrote 2048/2048 bytes at offset 4296071680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296075776 ++wrote 2048/2048 bytes at offset 4296075776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296079872 ++wrote 2048/2048 bytes at offset 4296079872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296083968 ++wrote 2048/2048 bytes at offset 4296083968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296088064 ++wrote 2048/2048 bytes at offset 4296088064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296092160 ++wrote 2048/2048 bytes at offset 4296092160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296096256 ++wrote 2048/2048 bytes at offset 4296096256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296100352 ++wrote 2048/2048 bytes at offset 4296100352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296104448 ++wrote 2048/2048 bytes at offset 4296104448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296108544 ++wrote 2048/2048 bytes at offset 4296108544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296112640 ++wrote 2048/2048 bytes at offset 4296112640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296116736 ++wrote 2048/2048 bytes at offset 4296116736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296120832 ++wrote 2048/2048 bytes at offset 4296120832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296124928 ++wrote 2048/2048 bytes at offset 4296124928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296129024 ++wrote 2048/2048 bytes at offset 4296129024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296133120 ++wrote 2048/2048 bytes at offset 4296133120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296137216 ++wrote 2048/2048 bytes at offset 4296137216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296141312 ++wrote 2048/2048 bytes at offset 4296141312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296145408 ++wrote 2048/2048 bytes at offset 4296145408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296149504 ++wrote 2048/2048 bytes at offset 4296149504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296153600 ++wrote 2048/2048 bytes at offset 4296153600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296157696 ++wrote 2048/2048 bytes at offset 4296157696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296161792 ++wrote 2048/2048 bytes at offset 4296161792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296165888 ++wrote 2048/2048 bytes at offset 4296165888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296169984 ++wrote 2048/2048 bytes at offset 4296169984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296174080 ++wrote 2048/2048 bytes at offset 4296174080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296178176 ++wrote 2048/2048 bytes at offset 4296178176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296182272 ++wrote 2048/2048 bytes at offset 4296182272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296186368 ++wrote 2048/2048 bytes at offset 4296186368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296190464 ++wrote 2048/2048 bytes at offset 4296190464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296194560 ++wrote 2048/2048 bytes at offset 4296194560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296198656 ++wrote 2048/2048 bytes at offset 4296198656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296202752 ++wrote 2048/2048 bytes at offset 4296202752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296206848 ++wrote 2048/2048 bytes at offset 4296206848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296210944 ++wrote 2048/2048 bytes at offset 4296210944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296215040 ++wrote 2048/2048 bytes at offset 4296215040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296219136 ++wrote 2048/2048 bytes at offset 4296219136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296223232 ++wrote 2048/2048 bytes at offset 4296223232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296227328 ++wrote 2048/2048 bytes at offset 4296227328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296231424 ++wrote 2048/2048 bytes at offset 4296231424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296235520 ++wrote 2048/2048 bytes at offset 4296235520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296239616 ++wrote 2048/2048 bytes at offset 4296239616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296243712 ++wrote 2048/2048 bytes at offset 4296243712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296247808 ++wrote 2048/2048 bytes at offset 4296247808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296251904 ++wrote 2048/2048 bytes at offset 4296251904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296256000 ++wrote 2048/2048 bytes at offset 4296256000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296260096 ++wrote 2048/2048 bytes at offset 4296260096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296264192 ++wrote 2048/2048 bytes at offset 4296264192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296268288 ++wrote 2048/2048 bytes at offset 4296268288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296272384 ++wrote 2048/2048 bytes at offset 4296272384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296276480 ++wrote 2048/2048 bytes at offset 4296276480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296280576 ++wrote 2048/2048 bytes at offset 4296280576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296284672 ++wrote 2048/2048 bytes at offset 4296284672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296288768 ++wrote 2048/2048 bytes at offset 4296288768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296292864 ++wrote 2048/2048 bytes at offset 4296292864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296296960 ++wrote 2048/2048 bytes at offset 4296296960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296301056 ++wrote 2048/2048 bytes at offset 4296301056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296305152 ++wrote 2048/2048 bytes at offset 4296305152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296309248 ++wrote 2048/2048 bytes at offset 4296309248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296313344 ++wrote 2048/2048 bytes at offset 4296313344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296317440 ++wrote 2048/2048 bytes at offset 4296317440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296321536 ++wrote 2048/2048 bytes at offset 4296321536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296325632 ++wrote 2048/2048 bytes at offset 4296325632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296329728 ++wrote 2048/2048 bytes at offset 4296329728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296333824 ++wrote 2048/2048 bytes at offset 4296333824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296337920 ++wrote 2048/2048 bytes at offset 4296337920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296342016 ++wrote 2048/2048 bytes at offset 4296342016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296346112 ++wrote 2048/2048 bytes at offset 4296346112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296350208 ++wrote 2048/2048 bytes at offset 4296350208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296354304 ++wrote 2048/2048 bytes at offset 4296354304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296358400 ++wrote 2048/2048 bytes at offset 4296358400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296362496 ++wrote 2048/2048 bytes at offset 4296362496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296366592 ++wrote 2048/2048 bytes at offset 4296366592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296370688 ++wrote 2048/2048 bytes at offset 4296370688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296374784 ++wrote 2048/2048 bytes at offset 4296374784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296378880 ++wrote 2048/2048 bytes at offset 4296378880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296382976 ++wrote 2048/2048 bytes at offset 4296382976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296387072 ++wrote 2048/2048 bytes at offset 4296387072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296391168 ++wrote 2048/2048 bytes at offset 4296391168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296395264 ++wrote 2048/2048 bytes at offset 4296395264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296399360 ++wrote 2048/2048 bytes at offset 4296399360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296403456 ++wrote 2048/2048 bytes at offset 4296403456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296407552 ++wrote 2048/2048 bytes at offset 4296407552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296411648 ++wrote 2048/2048 bytes at offset 4296411648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296415744 ++wrote 2048/2048 bytes at offset 4296415744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296419840 ++wrote 2048/2048 bytes at offset 4296419840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296423936 ++wrote 2048/2048 bytes at offset 4296423936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296428032 ++wrote 2048/2048 bytes at offset 4296428032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296432128 ++wrote 2048/2048 bytes at offset 4296432128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296436224 ++wrote 2048/2048 bytes at offset 4296436224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296440320 ++wrote 2048/2048 bytes at offset 4296440320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296444416 ++wrote 2048/2048 bytes at offset 4296444416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296448512 ++wrote 2048/2048 bytes at offset 4296448512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296452608 ++wrote 2048/2048 bytes at offset 4296452608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296456704 ++wrote 2048/2048 bytes at offset 4296456704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296460800 ++wrote 2048/2048 bytes at offset 4296460800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296464896 ++wrote 2048/2048 bytes at offset 4296464896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296468992 ++wrote 2048/2048 bytes at offset 4296468992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296473088 ++wrote 2048/2048 bytes at offset 4296473088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296477184 ++wrote 2048/2048 bytes at offset 4296477184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296481280 ++wrote 2048/2048 bytes at offset 4296481280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296485376 ++wrote 2048/2048 bytes at offset 4296485376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296489472 ++wrote 2048/2048 bytes at offset 4296489472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296493568 ++wrote 2048/2048 bytes at offset 4296493568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296497664 ++wrote 2048/2048 bytes at offset 4296497664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296501760 ++wrote 2048/2048 bytes at offset 4296501760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296505856 ++wrote 2048/2048 bytes at offset 4296505856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296509952 ++wrote 2048/2048 bytes at offset 4296509952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296514048 ++wrote 2048/2048 bytes at offset 4296514048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296518144 ++wrote 2048/2048 bytes at offset 4296518144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296522240 ++wrote 2048/2048 bytes at offset 4296522240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296526336 ++wrote 2048/2048 bytes at offset 4296526336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296530432 ++wrote 2048/2048 bytes at offset 4296530432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296534528 ++wrote 2048/2048 bytes at offset 4296534528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296538624 ++wrote 2048/2048 bytes at offset 4296538624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296542720 ++wrote 2048/2048 bytes at offset 4296542720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296546816 ++wrote 2048/2048 bytes at offset 4296546816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296550912 ++wrote 2048/2048 bytes at offset 4296550912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296555008 ++wrote 2048/2048 bytes at offset 4296555008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296559104 ++wrote 2048/2048 bytes at offset 4296559104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296563200 ++wrote 2048/2048 bytes at offset 4296563200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296567296 ++wrote 2048/2048 bytes at offset 4296567296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296571392 ++wrote 2048/2048 bytes at offset 4296571392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296575488 ++wrote 2048/2048 bytes at offset 4296575488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296579584 ++wrote 2048/2048 bytes at offset 4296579584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296583680 ++wrote 2048/2048 bytes at offset 4296583680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296587776 ++wrote 2048/2048 bytes at offset 4296587776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296591872 ++wrote 2048/2048 bytes at offset 4296591872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296595968 ++wrote 2048/2048 bytes at offset 4296595968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296600064 ++wrote 2048/2048 bytes at offset 4296600064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296604160 ++wrote 2048/2048 bytes at offset 4296604160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296608256 ++wrote 2048/2048 bytes at offset 4296608256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296612352 ++wrote 2048/2048 bytes at offset 4296612352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296616448 ++wrote 2048/2048 bytes at offset 4296616448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296620544 ++wrote 2048/2048 bytes at offset 4296620544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296624640 ++wrote 2048/2048 bytes at offset 4296624640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296628736 ++wrote 2048/2048 bytes at offset 4296628736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296632832 ++wrote 2048/2048 bytes at offset 4296632832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296636928 ++wrote 2048/2048 bytes at offset 4296636928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296641024 ++wrote 2048/2048 bytes at offset 4296641024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296645120 ++wrote 2048/2048 bytes at offset 4296645120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296649216 ++wrote 2048/2048 bytes at offset 4296649216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296653312 ++wrote 2048/2048 bytes at offset 4296653312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296657408 ++wrote 2048/2048 bytes at offset 4296657408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296661504 ++wrote 2048/2048 bytes at offset 4296661504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296665600 ++wrote 2048/2048 bytes at offset 4296665600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296669696 ++wrote 2048/2048 bytes at offset 4296669696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296673792 ++wrote 2048/2048 bytes at offset 4296673792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296677888 ++wrote 2048/2048 bytes at offset 4296677888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296681984 ++wrote 2048/2048 bytes at offset 4296681984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296686080 ++wrote 2048/2048 bytes at offset 4296686080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296690176 ++wrote 2048/2048 bytes at offset 4296690176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296694272 ++wrote 2048/2048 bytes at offset 4296694272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296698368 ++wrote 2048/2048 bytes at offset 4296698368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296702464 ++wrote 2048/2048 bytes at offset 4296702464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296706560 ++wrote 2048/2048 bytes at offset 4296706560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296710656 ++wrote 2048/2048 bytes at offset 4296710656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296714752 ++wrote 2048/2048 bytes at offset 4296714752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296718848 ++wrote 2048/2048 bytes at offset 4296718848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296722944 ++wrote 2048/2048 bytes at offset 4296722944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296727040 ++wrote 2048/2048 bytes at offset 4296727040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296731136 ++wrote 2048/2048 bytes at offset 4296731136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296735232 ++wrote 2048/2048 bytes at offset 4296735232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296739328 ++wrote 2048/2048 bytes at offset 4296739328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296743424 ++wrote 2048/2048 bytes at offset 4296743424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296747520 ++wrote 2048/2048 bytes at offset 4296747520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296751616 ++wrote 2048/2048 bytes at offset 4296751616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296755712 ++wrote 2048/2048 bytes at offset 4296755712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296759808 ++wrote 2048/2048 bytes at offset 4296759808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296763904 ++wrote 2048/2048 bytes at offset 4296763904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296768000 ++wrote 2048/2048 bytes at offset 4296768000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296772096 ++wrote 2048/2048 bytes at offset 4296772096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296776192 ++wrote 2048/2048 bytes at offset 4296776192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296780288 ++wrote 2048/2048 bytes at offset 4296780288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296784384 ++wrote 2048/2048 bytes at offset 4296784384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296788480 ++wrote 2048/2048 bytes at offset 4296788480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296792576 ++wrote 2048/2048 bytes at offset 4296792576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296796672 ++wrote 2048/2048 bytes at offset 4296796672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296800768 ++wrote 2048/2048 bytes at offset 4296800768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296804864 ++wrote 2048/2048 bytes at offset 4296804864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296808960 ++wrote 2048/2048 bytes at offset 4296808960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296813056 ++wrote 2048/2048 bytes at offset 4296813056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296817152 ++wrote 2048/2048 bytes at offset 4296817152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296821248 ++wrote 2048/2048 bytes at offset 4296821248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296825344 ++wrote 2048/2048 bytes at offset 4296825344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296829440 ++wrote 2048/2048 bytes at offset 4296829440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296833536 ++wrote 2048/2048 bytes at offset 4296833536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296837632 ++wrote 2048/2048 bytes at offset 4296837632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296841728 ++wrote 2048/2048 bytes at offset 4296841728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296845824 ++wrote 2048/2048 bytes at offset 4296845824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296849920 ++wrote 2048/2048 bytes at offset 4296849920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296854016 ++wrote 2048/2048 bytes at offset 4296854016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296858112 ++wrote 2048/2048 bytes at offset 4296858112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296862208 ++wrote 2048/2048 bytes at offset 4296862208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296866304 ++wrote 2048/2048 bytes at offset 4296866304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296870400 ++wrote 2048/2048 bytes at offset 4296870400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296874496 ++wrote 2048/2048 bytes at offset 4296874496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296878592 ++wrote 2048/2048 bytes at offset 4296878592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296882688 ++wrote 2048/2048 bytes at offset 4296882688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296886784 ++wrote 2048/2048 bytes at offset 4296886784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296890880 ++wrote 2048/2048 bytes at offset 4296890880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296894976 ++wrote 2048/2048 bytes at offset 4296894976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296899072 ++wrote 2048/2048 bytes at offset 4296899072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296903168 ++wrote 2048/2048 bytes at offset 4296903168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296907264 ++wrote 2048/2048 bytes at offset 4296907264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296911360 ++wrote 2048/2048 bytes at offset 4296911360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296915456 ++wrote 2048/2048 bytes at offset 4296915456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296919552 ++wrote 2048/2048 bytes at offset 4296919552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296923648 ++wrote 2048/2048 bytes at offset 4296923648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296927744 ++wrote 2048/2048 bytes at offset 4296927744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296931840 ++wrote 2048/2048 bytes at offset 4296931840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296935936 ++wrote 2048/2048 bytes at offset 4296935936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296940032 ++wrote 2048/2048 bytes at offset 4296940032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296944128 ++wrote 2048/2048 bytes at offset 4296944128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296948224 ++wrote 2048/2048 bytes at offset 4296948224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296952320 ++wrote 2048/2048 bytes at offset 4296952320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296956416 ++wrote 2048/2048 bytes at offset 4296956416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296960512 ++wrote 2048/2048 bytes at offset 4296960512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296964608 ++wrote 2048/2048 bytes at offset 4296964608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296968704 ++wrote 2048/2048 bytes at offset 4296968704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296972800 ++wrote 2048/2048 bytes at offset 4296972800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296976896 ++wrote 2048/2048 bytes at offset 4296976896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296980992 ++wrote 2048/2048 bytes at offset 4296980992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296985088 ++wrote 2048/2048 bytes at offset 4296985088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296989184 ++wrote 2048/2048 bytes at offset 4296989184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296993280 ++wrote 2048/2048 bytes at offset 4296993280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296997376 ++wrote 2048/2048 bytes at offset 4296997376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297001472 ++wrote 2048/2048 bytes at offset 4297001472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297005568 ++wrote 2048/2048 bytes at offset 4297005568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297009664 ++wrote 2048/2048 bytes at offset 4297009664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297013760 ++wrote 2048/2048 bytes at offset 4297013760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297017856 ++wrote 2048/2048 bytes at offset 4297017856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297021952 ++wrote 2048/2048 bytes at offset 4297021952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297026048 ++wrote 2048/2048 bytes at offset 4297026048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297030144 ++wrote 2048/2048 bytes at offset 4297030144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297034240 ++wrote 2048/2048 bytes at offset 4297034240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297038336 ++wrote 2048/2048 bytes at offset 4297038336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297042432 ++wrote 2048/2048 bytes at offset 4297042432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297046528 ++wrote 2048/2048 bytes at offset 4297046528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297050624 ++wrote 2048/2048 bytes at offset 4297050624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297054720 ++wrote 2048/2048 bytes at offset 4297054720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297058816 ++wrote 2048/2048 bytes at offset 4297058816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297062912 ++wrote 2048/2048 bytes at offset 4297062912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 1 +-qemu-io> wrote 2048/2048 bytes at offset 4297064960 ++=== IO: pattern 1 ++wrote 2048/2048 bytes at offset 4297064960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297069056 ++wrote 2048/2048 bytes at offset 4297069056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297073152 ++wrote 2048/2048 bytes at offset 4297073152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297077248 ++wrote 2048/2048 bytes at offset 4297077248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297081344 ++wrote 2048/2048 bytes at offset 4297081344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297085440 ++wrote 2048/2048 bytes at offset 4297085440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297089536 ++wrote 2048/2048 bytes at offset 4297089536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297093632 ++wrote 2048/2048 bytes at offset 4297093632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297097728 ++wrote 2048/2048 bytes at offset 4297097728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297101824 ++wrote 2048/2048 bytes at offset 4297101824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297105920 ++wrote 2048/2048 bytes at offset 4297105920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297110016 ++wrote 2048/2048 bytes at offset 4297110016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297114112 ++wrote 2048/2048 bytes at offset 4297114112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297118208 ++wrote 2048/2048 bytes at offset 4297118208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297122304 ++wrote 2048/2048 bytes at offset 4297122304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297126400 ++wrote 2048/2048 bytes at offset 4297126400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297130496 ++wrote 2048/2048 bytes at offset 4297130496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297134592 ++wrote 2048/2048 bytes at offset 4297134592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297138688 ++wrote 2048/2048 bytes at offset 4297138688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297142784 ++wrote 2048/2048 bytes at offset 4297142784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297146880 ++wrote 2048/2048 bytes at offset 4297146880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297150976 ++wrote 2048/2048 bytes at offset 4297150976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297155072 ++wrote 2048/2048 bytes at offset 4297155072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297159168 ++wrote 2048/2048 bytes at offset 4297159168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297163264 ++wrote 2048/2048 bytes at offset 4297163264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297167360 ++wrote 2048/2048 bytes at offset 4297167360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297171456 ++wrote 2048/2048 bytes at offset 4297171456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297175552 ++wrote 2048/2048 bytes at offset 4297175552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297179648 ++wrote 2048/2048 bytes at offset 4297179648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297183744 ++wrote 2048/2048 bytes at offset 4297183744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297187840 ++wrote 2048/2048 bytes at offset 4297187840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297191936 ++wrote 2048/2048 bytes at offset 4297191936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297196032 ++wrote 2048/2048 bytes at offset 4297196032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297200128 ++wrote 2048/2048 bytes at offset 4297200128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297204224 ++wrote 2048/2048 bytes at offset 4297204224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297208320 ++wrote 2048/2048 bytes at offset 4297208320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297212416 ++wrote 2048/2048 bytes at offset 4297212416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297216512 ++wrote 2048/2048 bytes at offset 4297216512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297220608 ++wrote 2048/2048 bytes at offset 4297220608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297224704 ++wrote 2048/2048 bytes at offset 4297224704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297228800 ++wrote 2048/2048 bytes at offset 4297228800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297232896 ++wrote 2048/2048 bytes at offset 4297232896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297236992 ++wrote 2048/2048 bytes at offset 4297236992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297241088 ++wrote 2048/2048 bytes at offset 4297241088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297245184 ++wrote 2048/2048 bytes at offset 4297245184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297249280 ++wrote 2048/2048 bytes at offset 4297249280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297253376 ++wrote 2048/2048 bytes at offset 4297253376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297257472 ++wrote 2048/2048 bytes at offset 4297257472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297261568 ++wrote 2048/2048 bytes at offset 4297261568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297265664 ++wrote 2048/2048 bytes at offset 4297265664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297269760 ++wrote 2048/2048 bytes at offset 4297269760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297273856 ++wrote 2048/2048 bytes at offset 4297273856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297277952 ++wrote 2048/2048 bytes at offset 4297277952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297282048 ++wrote 2048/2048 bytes at offset 4297282048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297286144 ++wrote 2048/2048 bytes at offset 4297286144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297290240 ++wrote 2048/2048 bytes at offset 4297290240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297294336 ++wrote 2048/2048 bytes at offset 4297294336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297298432 ++wrote 2048/2048 bytes at offset 4297298432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297302528 ++wrote 2048/2048 bytes at offset 4297302528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297306624 ++wrote 2048/2048 bytes at offset 4297306624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297310720 ++wrote 2048/2048 bytes at offset 4297310720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297314816 ++wrote 2048/2048 bytes at offset 4297314816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297318912 ++wrote 2048/2048 bytes at offset 4297318912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297323008 ++wrote 2048/2048 bytes at offset 4297323008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297327104 ++wrote 2048/2048 bytes at offset 4297327104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297331200 ++wrote 2048/2048 bytes at offset 4297331200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297335296 ++wrote 2048/2048 bytes at offset 4297335296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297339392 ++wrote 2048/2048 bytes at offset 4297339392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297343488 ++wrote 2048/2048 bytes at offset 4297343488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297347584 ++wrote 2048/2048 bytes at offset 4297347584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297351680 ++wrote 2048/2048 bytes at offset 4297351680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297355776 ++wrote 2048/2048 bytes at offset 4297355776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297359872 ++wrote 2048/2048 bytes at offset 4297359872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297363968 ++wrote 2048/2048 bytes at offset 4297363968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297368064 ++wrote 2048/2048 bytes at offset 4297368064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297372160 ++wrote 2048/2048 bytes at offset 4297372160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297376256 ++wrote 2048/2048 bytes at offset 4297376256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297380352 ++wrote 2048/2048 bytes at offset 4297380352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297384448 ++wrote 2048/2048 bytes at offset 4297384448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297388544 ++wrote 2048/2048 bytes at offset 4297388544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297392640 ++wrote 2048/2048 bytes at offset 4297392640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297396736 ++wrote 2048/2048 bytes at offset 4297396736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297400832 ++wrote 2048/2048 bytes at offset 4297400832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297404928 ++wrote 2048/2048 bytes at offset 4297404928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297409024 ++wrote 2048/2048 bytes at offset 4297409024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297413120 ++wrote 2048/2048 bytes at offset 4297413120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297417216 ++wrote 2048/2048 bytes at offset 4297417216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297421312 ++wrote 2048/2048 bytes at offset 4297421312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297425408 ++wrote 2048/2048 bytes at offset 4297425408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297429504 ++wrote 2048/2048 bytes at offset 4297429504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297433600 ++wrote 2048/2048 bytes at offset 4297433600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297437696 ++wrote 2048/2048 bytes at offset 4297437696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297441792 ++wrote 2048/2048 bytes at offset 4297441792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297445888 ++wrote 2048/2048 bytes at offset 4297445888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297449984 ++wrote 2048/2048 bytes at offset 4297449984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297454080 ++wrote 2048/2048 bytes at offset 4297454080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297458176 ++wrote 2048/2048 bytes at offset 4297458176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297462272 ++wrote 2048/2048 bytes at offset 4297462272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297466368 ++wrote 2048/2048 bytes at offset 4297466368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297470464 ++wrote 2048/2048 bytes at offset 4297470464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297474560 ++wrote 2048/2048 bytes at offset 4297474560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297478656 ++wrote 2048/2048 bytes at offset 4297478656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297482752 ++wrote 2048/2048 bytes at offset 4297482752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297486848 ++wrote 2048/2048 bytes at offset 4297486848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297490944 ++wrote 2048/2048 bytes at offset 4297490944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297495040 ++wrote 2048/2048 bytes at offset 4297495040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297499136 ++wrote 2048/2048 bytes at offset 4297499136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297503232 ++wrote 2048/2048 bytes at offset 4297503232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297507328 ++wrote 2048/2048 bytes at offset 4297507328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297511424 ++wrote 2048/2048 bytes at offset 4297511424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297515520 ++wrote 2048/2048 bytes at offset 4297515520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297519616 ++wrote 2048/2048 bytes at offset 4297519616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297523712 ++wrote 2048/2048 bytes at offset 4297523712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297527808 ++wrote 2048/2048 bytes at offset 4297527808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297531904 ++wrote 2048/2048 bytes at offset 4297531904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297536000 ++wrote 2048/2048 bytes at offset 4297536000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297540096 ++wrote 2048/2048 bytes at offset 4297540096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297544192 ++wrote 2048/2048 bytes at offset 4297544192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297548288 ++wrote 2048/2048 bytes at offset 4297548288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297552384 ++wrote 2048/2048 bytes at offset 4297552384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297556480 ++wrote 2048/2048 bytes at offset 4297556480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297560576 ++wrote 2048/2048 bytes at offset 4297560576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297564672 ++wrote 2048/2048 bytes at offset 4297564672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297568768 ++wrote 2048/2048 bytes at offset 4297568768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297572864 ++wrote 2048/2048 bytes at offset 4297572864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297576960 ++wrote 2048/2048 bytes at offset 4297576960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297581056 ++wrote 2048/2048 bytes at offset 4297581056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297585152 ++wrote 2048/2048 bytes at offset 4297585152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297589248 ++wrote 2048/2048 bytes at offset 4297589248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297593344 ++wrote 2048/2048 bytes at offset 4297593344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297597440 ++wrote 2048/2048 bytes at offset 4297597440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297601536 ++wrote 2048/2048 bytes at offset 4297601536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297605632 ++wrote 2048/2048 bytes at offset 4297605632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297609728 ++wrote 2048/2048 bytes at offset 4297609728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297613824 ++wrote 2048/2048 bytes at offset 4297613824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297617920 ++wrote 2048/2048 bytes at offset 4297617920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297622016 ++wrote 2048/2048 bytes at offset 4297622016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297626112 ++wrote 2048/2048 bytes at offset 4297626112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297630208 ++wrote 2048/2048 bytes at offset 4297630208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297634304 ++wrote 2048/2048 bytes at offset 4297634304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297638400 ++wrote 2048/2048 bytes at offset 4297638400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297642496 ++wrote 2048/2048 bytes at offset 4297642496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297646592 ++wrote 2048/2048 bytes at offset 4297646592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297650688 ++wrote 2048/2048 bytes at offset 4297650688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297654784 ++wrote 2048/2048 bytes at offset 4297654784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297658880 ++wrote 2048/2048 bytes at offset 4297658880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297662976 ++wrote 2048/2048 bytes at offset 4297662976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297667072 ++wrote 2048/2048 bytes at offset 4297667072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297671168 ++wrote 2048/2048 bytes at offset 4297671168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297675264 ++wrote 2048/2048 bytes at offset 4297675264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297679360 ++wrote 2048/2048 bytes at offset 4297679360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297683456 ++wrote 2048/2048 bytes at offset 4297683456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297687552 ++wrote 2048/2048 bytes at offset 4297687552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297691648 ++wrote 2048/2048 bytes at offset 4297691648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297695744 ++wrote 2048/2048 bytes at offset 4297695744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297699840 ++wrote 2048/2048 bytes at offset 4297699840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297703936 ++wrote 2048/2048 bytes at offset 4297703936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297708032 ++wrote 2048/2048 bytes at offset 4297708032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297712128 ++wrote 2048/2048 bytes at offset 4297712128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297716224 ++wrote 2048/2048 bytes at offset 4297716224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297720320 ++wrote 2048/2048 bytes at offset 4297720320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297724416 ++wrote 2048/2048 bytes at offset 4297724416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297728512 ++wrote 2048/2048 bytes at offset 4297728512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297732608 ++wrote 2048/2048 bytes at offset 4297732608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297736704 ++wrote 2048/2048 bytes at offset 4297736704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297740800 ++wrote 2048/2048 bytes at offset 4297740800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297744896 ++wrote 2048/2048 bytes at offset 4297744896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297748992 ++wrote 2048/2048 bytes at offset 4297748992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297753088 ++wrote 2048/2048 bytes at offset 4297753088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297757184 ++wrote 2048/2048 bytes at offset 4297757184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297761280 ++wrote 2048/2048 bytes at offset 4297761280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297765376 ++wrote 2048/2048 bytes at offset 4297765376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297769472 ++wrote 2048/2048 bytes at offset 4297769472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297773568 ++wrote 2048/2048 bytes at offset 4297773568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297777664 ++wrote 2048/2048 bytes at offset 4297777664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297781760 ++wrote 2048/2048 bytes at offset 4297781760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297785856 ++wrote 2048/2048 bytes at offset 4297785856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297789952 ++wrote 2048/2048 bytes at offset 4297789952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297794048 ++wrote 2048/2048 bytes at offset 4297794048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297798144 ++wrote 2048/2048 bytes at offset 4297798144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297802240 ++wrote 2048/2048 bytes at offset 4297802240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297806336 ++wrote 2048/2048 bytes at offset 4297806336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297810432 ++wrote 2048/2048 bytes at offset 4297810432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297814528 ++wrote 2048/2048 bytes at offset 4297814528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297818624 ++wrote 2048/2048 bytes at offset 4297818624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297822720 ++wrote 2048/2048 bytes at offset 4297822720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297826816 ++wrote 2048/2048 bytes at offset 4297826816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297830912 ++wrote 2048/2048 bytes at offset 4297830912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297835008 ++wrote 2048/2048 bytes at offset 4297835008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297839104 ++wrote 2048/2048 bytes at offset 4297839104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297843200 ++wrote 2048/2048 bytes at offset 4297843200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297847296 ++wrote 2048/2048 bytes at offset 4297847296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297851392 ++wrote 2048/2048 bytes at offset 4297851392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297855488 ++wrote 2048/2048 bytes at offset 4297855488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297859584 ++wrote 2048/2048 bytes at offset 4297859584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297863680 ++wrote 2048/2048 bytes at offset 4297863680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297867776 ++wrote 2048/2048 bytes at offset 4297867776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297871872 ++wrote 2048/2048 bytes at offset 4297871872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297875968 ++wrote 2048/2048 bytes at offset 4297875968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297880064 ++wrote 2048/2048 bytes at offset 4297880064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297884160 ++wrote 2048/2048 bytes at offset 4297884160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297888256 ++wrote 2048/2048 bytes at offset 4297888256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297892352 ++wrote 2048/2048 bytes at offset 4297892352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297896448 ++wrote 2048/2048 bytes at offset 4297896448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297900544 ++wrote 2048/2048 bytes at offset 4297900544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297904640 ++wrote 2048/2048 bytes at offset 4297904640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297908736 ++wrote 2048/2048 bytes at offset 4297908736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297912832 ++wrote 2048/2048 bytes at offset 4297912832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297916928 ++wrote 2048/2048 bytes at offset 4297916928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297921024 ++wrote 2048/2048 bytes at offset 4297921024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297925120 ++wrote 2048/2048 bytes at offset 4297925120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297929216 ++wrote 2048/2048 bytes at offset 4297929216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297933312 ++wrote 2048/2048 bytes at offset 4297933312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297937408 ++wrote 2048/2048 bytes at offset 4297937408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297941504 ++wrote 2048/2048 bytes at offset 4297941504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297945600 ++wrote 2048/2048 bytes at offset 4297945600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297949696 ++wrote 2048/2048 bytes at offset 4297949696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297953792 ++wrote 2048/2048 bytes at offset 4297953792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297957888 ++wrote 2048/2048 bytes at offset 4297957888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297961984 ++wrote 2048/2048 bytes at offset 4297961984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297966080 ++wrote 2048/2048 bytes at offset 4297966080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297970176 ++wrote 2048/2048 bytes at offset 4297970176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297974272 ++wrote 2048/2048 bytes at offset 4297974272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297978368 ++wrote 2048/2048 bytes at offset 4297978368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297982464 ++wrote 2048/2048 bytes at offset 4297982464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297986560 ++wrote 2048/2048 bytes at offset 4297986560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297990656 ++wrote 2048/2048 bytes at offset 4297990656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297994752 ++wrote 2048/2048 bytes at offset 4297994752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297998848 ++wrote 2048/2048 bytes at offset 4297998848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298002944 ++wrote 2048/2048 bytes at offset 4298002944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298007040 ++wrote 2048/2048 bytes at offset 4298007040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298011136 ++wrote 2048/2048 bytes at offset 4298011136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298015232 ++wrote 2048/2048 bytes at offset 4298015232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298019328 ++wrote 2048/2048 bytes at offset 4298019328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298023424 ++wrote 2048/2048 bytes at offset 4298023424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298027520 ++wrote 2048/2048 bytes at offset 4298027520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298031616 ++wrote 2048/2048 bytes at offset 4298031616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298035712 ++wrote 2048/2048 bytes at offset 4298035712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298039808 ++wrote 2048/2048 bytes at offset 4298039808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298043904 ++wrote 2048/2048 bytes at offset 4298043904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298048000 ++wrote 2048/2048 bytes at offset 4298048000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298052096 ++wrote 2048/2048 bytes at offset 4298052096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298056192 ++wrote 2048/2048 bytes at offset 4298056192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298060288 ++wrote 2048/2048 bytes at offset 4298060288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298064384 ++wrote 2048/2048 bytes at offset 4298064384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298068480 ++wrote 2048/2048 bytes at offset 4298068480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298072576 ++wrote 2048/2048 bytes at offset 4298072576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298076672 ++wrote 2048/2048 bytes at offset 4298076672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298080768 ++wrote 2048/2048 bytes at offset 4298080768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298084864 ++wrote 2048/2048 bytes at offset 4298084864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298088960 ++wrote 2048/2048 bytes at offset 4298088960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298093056 ++wrote 2048/2048 bytes at offset 4298093056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298097152 ++wrote 2048/2048 bytes at offset 4298097152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298101248 ++wrote 2048/2048 bytes at offset 4298101248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298105344 ++wrote 2048/2048 bytes at offset 4298105344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298109440 ++wrote 2048/2048 bytes at offset 4298109440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 3 +-qemu-io> wrote 2048/2048 bytes at offset 4298114560 ++=== IO: pattern 3 ++wrote 2048/2048 bytes at offset 4298114560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298118656 ++wrote 2048/2048 bytes at offset 4298118656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298122752 ++wrote 2048/2048 bytes at offset 4298122752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298126848 ++wrote 2048/2048 bytes at offset 4298126848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298130944 ++wrote 2048/2048 bytes at offset 4298130944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298135040 ++wrote 2048/2048 bytes at offset 4298135040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298139136 ++wrote 2048/2048 bytes at offset 4298139136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298143232 ++wrote 2048/2048 bytes at offset 4298143232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298147328 ++wrote 2048/2048 bytes at offset 4298147328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298151424 ++wrote 2048/2048 bytes at offset 4298151424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298155520 ++wrote 2048/2048 bytes at offset 4298155520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298159616 ++wrote 2048/2048 bytes at offset 4298159616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298163712 ++wrote 2048/2048 bytes at offset 4298163712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298167808 ++wrote 2048/2048 bytes at offset 4298167808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298171904 ++wrote 2048/2048 bytes at offset 4298171904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298176000 ++wrote 2048/2048 bytes at offset 4298176000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298180096 ++wrote 2048/2048 bytes at offset 4298180096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298184192 ++wrote 2048/2048 bytes at offset 4298184192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298188288 ++wrote 2048/2048 bytes at offset 4298188288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298192384 ++wrote 2048/2048 bytes at offset 4298192384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298196480 ++wrote 2048/2048 bytes at offset 4298196480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298200576 ++wrote 2048/2048 bytes at offset 4298200576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298204672 ++wrote 2048/2048 bytes at offset 4298204672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298208768 ++wrote 2048/2048 bytes at offset 4298208768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298212864 ++wrote 2048/2048 bytes at offset 4298212864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298216960 ++wrote 2048/2048 bytes at offset 4298216960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298221056 ++wrote 2048/2048 bytes at offset 4298221056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298225152 ++wrote 2048/2048 bytes at offset 4298225152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298229248 ++wrote 2048/2048 bytes at offset 4298229248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298233344 ++wrote 2048/2048 bytes at offset 4298233344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298237440 ++wrote 2048/2048 bytes at offset 4298237440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298241536 ++wrote 2048/2048 bytes at offset 4298241536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298245632 ++wrote 2048/2048 bytes at offset 4298245632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298249728 ++wrote 2048/2048 bytes at offset 4298249728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298253824 ++wrote 2048/2048 bytes at offset 4298253824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298257920 ++wrote 2048/2048 bytes at offset 4298257920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298262016 ++wrote 2048/2048 bytes at offset 4298262016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298266112 ++wrote 2048/2048 bytes at offset 4298266112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298270208 ++wrote 2048/2048 bytes at offset 4298270208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298274304 ++wrote 2048/2048 bytes at offset 4298274304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298278400 ++wrote 2048/2048 bytes at offset 4298278400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298282496 ++wrote 2048/2048 bytes at offset 4298282496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298286592 ++wrote 2048/2048 bytes at offset 4298286592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298290688 ++wrote 2048/2048 bytes at offset 4298290688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298294784 ++wrote 2048/2048 bytes at offset 4298294784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298298880 ++wrote 2048/2048 bytes at offset 4298298880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298302976 ++wrote 2048/2048 bytes at offset 4298302976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298307072 ++wrote 2048/2048 bytes at offset 4298307072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298311168 ++wrote 2048/2048 bytes at offset 4298311168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298315264 ++wrote 2048/2048 bytes at offset 4298315264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298319360 ++wrote 2048/2048 bytes at offset 4298319360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298323456 ++wrote 2048/2048 bytes at offset 4298323456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298327552 ++wrote 2048/2048 bytes at offset 4298327552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298331648 ++wrote 2048/2048 bytes at offset 4298331648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298335744 ++wrote 2048/2048 bytes at offset 4298335744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298339840 ++wrote 2048/2048 bytes at offset 4298339840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298343936 ++wrote 2048/2048 bytes at offset 4298343936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298348032 ++wrote 2048/2048 bytes at offset 4298348032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298352128 ++wrote 2048/2048 bytes at offset 4298352128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298356224 ++wrote 2048/2048 bytes at offset 4298356224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298360320 ++wrote 2048/2048 bytes at offset 4298360320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298364416 ++wrote 2048/2048 bytes at offset 4298364416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298368512 ++wrote 2048/2048 bytes at offset 4298368512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298372608 ++wrote 2048/2048 bytes at offset 4298372608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298376704 ++wrote 2048/2048 bytes at offset 4298376704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298380800 ++wrote 2048/2048 bytes at offset 4298380800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298384896 ++wrote 2048/2048 bytes at offset 4298384896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298388992 ++wrote 2048/2048 bytes at offset 4298388992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298393088 ++wrote 2048/2048 bytes at offset 4298393088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298397184 ++wrote 2048/2048 bytes at offset 4298397184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298401280 ++wrote 2048/2048 bytes at offset 4298401280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298405376 ++wrote 2048/2048 bytes at offset 4298405376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298409472 ++wrote 2048/2048 bytes at offset 4298409472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298413568 ++wrote 2048/2048 bytes at offset 4298413568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298417664 ++wrote 2048/2048 bytes at offset 4298417664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298421760 ++wrote 2048/2048 bytes at offset 4298421760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298425856 ++wrote 2048/2048 bytes at offset 4298425856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298429952 ++wrote 2048/2048 bytes at offset 4298429952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298434048 ++wrote 2048/2048 bytes at offset 4298434048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298438144 ++wrote 2048/2048 bytes at offset 4298438144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298442240 ++wrote 2048/2048 bytes at offset 4298442240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298446336 ++wrote 2048/2048 bytes at offset 4298446336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298450432 ++wrote 2048/2048 bytes at offset 4298450432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298454528 ++wrote 2048/2048 bytes at offset 4298454528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298458624 ++wrote 2048/2048 bytes at offset 4298458624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298462720 ++wrote 2048/2048 bytes at offset 4298462720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298466816 ++wrote 2048/2048 bytes at offset 4298466816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298470912 ++wrote 2048/2048 bytes at offset 4298470912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298475008 ++wrote 2048/2048 bytes at offset 4298475008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298479104 ++wrote 2048/2048 bytes at offset 4298479104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298483200 ++wrote 2048/2048 bytes at offset 4298483200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298487296 ++wrote 2048/2048 bytes at offset 4298487296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298491392 ++wrote 2048/2048 bytes at offset 4298491392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298495488 ++wrote 2048/2048 bytes at offset 4298495488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298499584 ++wrote 2048/2048 bytes at offset 4298499584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298503680 ++wrote 2048/2048 bytes at offset 4298503680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298507776 ++wrote 2048/2048 bytes at offset 4298507776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298511872 ++wrote 2048/2048 bytes at offset 4298511872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298515968 ++wrote 2048/2048 bytes at offset 4298515968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298520064 ++wrote 2048/2048 bytes at offset 4298520064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298524160 ++wrote 2048/2048 bytes at offset 4298524160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298528256 ++wrote 2048/2048 bytes at offset 4298528256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298532352 ++wrote 2048/2048 bytes at offset 4298532352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298536448 ++wrote 2048/2048 bytes at offset 4298536448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298540544 ++wrote 2048/2048 bytes at offset 4298540544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298544640 ++wrote 2048/2048 bytes at offset 4298544640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298548736 ++wrote 2048/2048 bytes at offset 4298548736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298552832 ++wrote 2048/2048 bytes at offset 4298552832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298556928 ++wrote 2048/2048 bytes at offset 4298556928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298561024 ++wrote 2048/2048 bytes at offset 4298561024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298565120 ++wrote 2048/2048 bytes at offset 4298565120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298569216 ++wrote 2048/2048 bytes at offset 4298569216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298573312 ++wrote 2048/2048 bytes at offset 4298573312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298577408 ++wrote 2048/2048 bytes at offset 4298577408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298581504 ++wrote 2048/2048 bytes at offset 4298581504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298585600 ++wrote 2048/2048 bytes at offset 4298585600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298589696 ++wrote 2048/2048 bytes at offset 4298589696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298593792 ++wrote 2048/2048 bytes at offset 4298593792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298597888 ++wrote 2048/2048 bytes at offset 4298597888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298601984 ++wrote 2048/2048 bytes at offset 4298601984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298606080 ++wrote 2048/2048 bytes at offset 4298606080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298610176 ++wrote 2048/2048 bytes at offset 4298610176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298614272 ++wrote 2048/2048 bytes at offset 4298614272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298618368 ++wrote 2048/2048 bytes at offset 4298618368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298622464 ++wrote 2048/2048 bytes at offset 4298622464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298626560 ++wrote 2048/2048 bytes at offset 4298626560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298630656 ++wrote 2048/2048 bytes at offset 4298630656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298634752 ++wrote 2048/2048 bytes at offset 4298634752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298638848 ++wrote 2048/2048 bytes at offset 4298638848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298642944 ++wrote 2048/2048 bytes at offset 4298642944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298647040 ++wrote 2048/2048 bytes at offset 4298647040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298651136 ++wrote 2048/2048 bytes at offset 4298651136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298655232 ++wrote 2048/2048 bytes at offset 4298655232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298659328 ++wrote 2048/2048 bytes at offset 4298659328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298663424 ++wrote 2048/2048 bytes at offset 4298663424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298667520 ++wrote 2048/2048 bytes at offset 4298667520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298671616 ++wrote 2048/2048 bytes at offset 4298671616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298675712 ++wrote 2048/2048 bytes at offset 4298675712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298679808 ++wrote 2048/2048 bytes at offset 4298679808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298683904 ++wrote 2048/2048 bytes at offset 4298683904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298688000 ++wrote 2048/2048 bytes at offset 4298688000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298692096 ++wrote 2048/2048 bytes at offset 4298692096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298696192 ++wrote 2048/2048 bytes at offset 4298696192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298700288 ++wrote 2048/2048 bytes at offset 4298700288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298704384 ++wrote 2048/2048 bytes at offset 4298704384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298708480 ++wrote 2048/2048 bytes at offset 4298708480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298712576 ++wrote 2048/2048 bytes at offset 4298712576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298716672 ++wrote 2048/2048 bytes at offset 4298716672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298720768 ++wrote 2048/2048 bytes at offset 4298720768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298724864 ++wrote 2048/2048 bytes at offset 4298724864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298728960 ++wrote 2048/2048 bytes at offset 4298728960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298733056 ++wrote 2048/2048 bytes at offset 4298733056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298737152 ++wrote 2048/2048 bytes at offset 4298737152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298741248 ++wrote 2048/2048 bytes at offset 4298741248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298745344 ++wrote 2048/2048 bytes at offset 4298745344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298749440 ++wrote 2048/2048 bytes at offset 4298749440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298753536 ++wrote 2048/2048 bytes at offset 4298753536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298757632 ++wrote 2048/2048 bytes at offset 4298757632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298761728 ++wrote 2048/2048 bytes at offset 4298761728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298765824 ++wrote 2048/2048 bytes at offset 4298765824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298769920 ++wrote 2048/2048 bytes at offset 4298769920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298774016 ++wrote 2048/2048 bytes at offset 4298774016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298778112 ++wrote 2048/2048 bytes at offset 4298778112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298782208 ++wrote 2048/2048 bytes at offset 4298782208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298786304 ++wrote 2048/2048 bytes at offset 4298786304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298790400 ++wrote 2048/2048 bytes at offset 4298790400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298794496 ++wrote 2048/2048 bytes at offset 4298794496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298798592 ++wrote 2048/2048 bytes at offset 4298798592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298802688 ++wrote 2048/2048 bytes at offset 4298802688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298806784 ++wrote 2048/2048 bytes at offset 4298806784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298810880 ++wrote 2048/2048 bytes at offset 4298810880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298814976 ++wrote 2048/2048 bytes at offset 4298814976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298819072 ++wrote 2048/2048 bytes at offset 4298819072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298823168 ++wrote 2048/2048 bytes at offset 4298823168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298827264 ++wrote 2048/2048 bytes at offset 4298827264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298831360 ++wrote 2048/2048 bytes at offset 4298831360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298835456 ++wrote 2048/2048 bytes at offset 4298835456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298839552 ++wrote 2048/2048 bytes at offset 4298839552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298843648 ++wrote 2048/2048 bytes at offset 4298843648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298847744 ++wrote 2048/2048 bytes at offset 4298847744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298851840 ++wrote 2048/2048 bytes at offset 4298851840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298855936 ++wrote 2048/2048 bytes at offset 4298855936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298860032 ++wrote 2048/2048 bytes at offset 4298860032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298864128 ++wrote 2048/2048 bytes at offset 4298864128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298868224 ++wrote 2048/2048 bytes at offset 4298868224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298872320 ++wrote 2048/2048 bytes at offset 4298872320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298876416 ++wrote 2048/2048 bytes at offset 4298876416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298880512 ++wrote 2048/2048 bytes at offset 4298880512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298884608 ++wrote 2048/2048 bytes at offset 4298884608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298888704 ++wrote 2048/2048 bytes at offset 4298888704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298892800 ++wrote 2048/2048 bytes at offset 4298892800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298896896 ++wrote 2048/2048 bytes at offset 4298896896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298900992 ++wrote 2048/2048 bytes at offset 4298900992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298905088 ++wrote 2048/2048 bytes at offset 4298905088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298909184 ++wrote 2048/2048 bytes at offset 4298909184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298913280 ++wrote 2048/2048 bytes at offset 4298913280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298917376 ++wrote 2048/2048 bytes at offset 4298917376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298921472 ++wrote 2048/2048 bytes at offset 4298921472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298925568 ++wrote 2048/2048 bytes at offset 4298925568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298929664 ++wrote 2048/2048 bytes at offset 4298929664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298933760 ++wrote 2048/2048 bytes at offset 4298933760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298937856 ++wrote 2048/2048 bytes at offset 4298937856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298941952 ++wrote 2048/2048 bytes at offset 4298941952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298946048 ++wrote 2048/2048 bytes at offset 4298946048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298950144 ++wrote 2048/2048 bytes at offset 4298950144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298954240 ++wrote 2048/2048 bytes at offset 4298954240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298958336 ++wrote 2048/2048 bytes at offset 4298958336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298962432 ++wrote 2048/2048 bytes at offset 4298962432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298966528 ++wrote 2048/2048 bytes at offset 4298966528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298970624 ++wrote 2048/2048 bytes at offset 4298970624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298974720 ++wrote 2048/2048 bytes at offset 4298974720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298978816 ++wrote 2048/2048 bytes at offset 4298978816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298982912 ++wrote 2048/2048 bytes at offset 4298982912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298987008 ++wrote 2048/2048 bytes at offset 4298987008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298991104 ++wrote 2048/2048 bytes at offset 4298991104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298995200 ++wrote 2048/2048 bytes at offset 4298995200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298999296 ++wrote 2048/2048 bytes at offset 4298999296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299003392 ++wrote 2048/2048 bytes at offset 4299003392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299007488 ++wrote 2048/2048 bytes at offset 4299007488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299011584 ++wrote 2048/2048 bytes at offset 4299011584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299015680 ++wrote 2048/2048 bytes at offset 4299015680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299019776 ++wrote 2048/2048 bytes at offset 4299019776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299023872 ++wrote 2048/2048 bytes at offset 4299023872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299027968 ++wrote 2048/2048 bytes at offset 4299027968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299032064 ++wrote 2048/2048 bytes at offset 4299032064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299036160 ++wrote 2048/2048 bytes at offset 4299036160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299040256 ++wrote 2048/2048 bytes at offset 4299040256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299044352 ++wrote 2048/2048 bytes at offset 4299044352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299048448 ++wrote 2048/2048 bytes at offset 4299048448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299052544 ++wrote 2048/2048 bytes at offset 4299052544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299056640 ++wrote 2048/2048 bytes at offset 4299056640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299060736 ++wrote 2048/2048 bytes at offset 4299060736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299064832 ++wrote 2048/2048 bytes at offset 4299064832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299068928 ++wrote 2048/2048 bytes at offset 4299068928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299073024 ++wrote 2048/2048 bytes at offset 4299073024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299077120 ++wrote 2048/2048 bytes at offset 4299077120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299081216 ++wrote 2048/2048 bytes at offset 4299081216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299085312 ++wrote 2048/2048 bytes at offset 4299085312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299089408 ++wrote 2048/2048 bytes at offset 4299089408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299093504 ++wrote 2048/2048 bytes at offset 4299093504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299097600 ++wrote 2048/2048 bytes at offset 4299097600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299101696 ++wrote 2048/2048 bytes at offset 4299101696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299105792 ++wrote 2048/2048 bytes at offset 4299105792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299109888 ++wrote 2048/2048 bytes at offset 4299109888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299113984 ++wrote 2048/2048 bytes at offset 4299113984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299118080 ++wrote 2048/2048 bytes at offset 4299118080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299122176 ++wrote 2048/2048 bytes at offset 4299122176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299126272 ++wrote 2048/2048 bytes at offset 4299126272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299130368 ++wrote 2048/2048 bytes at offset 4299130368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299134464 ++wrote 2048/2048 bytes at offset 4299134464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299138560 ++wrote 2048/2048 bytes at offset 4299138560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299142656 ++wrote 2048/2048 bytes at offset 4299142656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299146752 ++wrote 2048/2048 bytes at offset 4299146752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299150848 ++wrote 2048/2048 bytes at offset 4299150848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299154944 ++wrote 2048/2048 bytes at offset 4299154944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299159040 ++wrote 2048/2048 bytes at offset 4299159040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 5 +-qemu-io> wrote 8192/8192 bytes at offset 4299164160 ++=== IO: pattern 5 ++wrote 8192/8192 bytes at offset 4299164160 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299176448 ++wrote 8192/8192 bytes at offset 4299176448 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299188736 ++wrote 8192/8192 bytes at offset 4299188736 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299201024 ++wrote 8192/8192 bytes at offset 4299201024 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299213312 ++wrote 8192/8192 bytes at offset 4299213312 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299225600 ++wrote 8192/8192 bytes at offset 4299225600 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299237888 ++wrote 8192/8192 bytes at offset 4299237888 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299250176 ++wrote 8192/8192 bytes at offset 4299250176 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299262464 ++wrote 8192/8192 bytes at offset 4299262464 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299274752 ++wrote 8192/8192 bytes at offset 4299274752 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299287040 ++wrote 8192/8192 bytes at offset 4299287040 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299299328 ++wrote 8192/8192 bytes at offset 4299299328 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299311616 ++wrote 8192/8192 bytes at offset 4299311616 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299323904 ++wrote 8192/8192 bytes at offset 4299323904 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299336192 ++wrote 8192/8192 bytes at offset 4299336192 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299348480 ++wrote 8192/8192 bytes at offset 4299348480 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299360768 ++wrote 8192/8192 bytes at offset 4299360768 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299373056 ++wrote 8192/8192 bytes at offset 4299373056 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299385344 ++wrote 8192/8192 bytes at offset 4299385344 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299397632 ++wrote 8192/8192 bytes at offset 4299397632 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299409920 ++wrote 8192/8192 bytes at offset 4299409920 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299422208 ++wrote 8192/8192 bytes at offset 4299422208 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299434496 ++wrote 8192/8192 bytes at offset 4299434496 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299446784 ++wrote 8192/8192 bytes at offset 4299446784 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299459072 ++wrote 8192/8192 bytes at offset 4299459072 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299471360 ++wrote 8192/8192 bytes at offset 4299471360 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299483648 ++wrote 8192/8192 bytes at offset 4299483648 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299495936 ++wrote 8192/8192 bytes at offset 4299495936 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299508224 ++wrote 8192/8192 bytes at offset 4299508224 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299520512 ++wrote 8192/8192 bytes at offset 4299520512 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299532800 ++wrote 8192/8192 bytes at offset 4299532800 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299545088 ++wrote 8192/8192 bytes at offset 4299545088 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299557376 ++wrote 8192/8192 bytes at offset 4299557376 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299569664 ++wrote 8192/8192 bytes at offset 4299569664 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299581952 ++wrote 8192/8192 bytes at offset 4299581952 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299594240 ++wrote 8192/8192 bytes at offset 4299594240 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299606528 ++wrote 8192/8192 bytes at offset 4299606528 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299618816 ++wrote 8192/8192 bytes at offset 4299618816 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299631104 ++wrote 8192/8192 bytes at offset 4299631104 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299643392 ++wrote 8192/8192 bytes at offset 4299643392 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299655680 ++wrote 8192/8192 bytes at offset 4299655680 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299667968 ++wrote 8192/8192 bytes at offset 4299667968 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299680256 ++wrote 8192/8192 bytes at offset 4299680256 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299692544 ++wrote 8192/8192 bytes at offset 4299692544 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299704832 ++wrote 8192/8192 bytes at offset 4299704832 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299717120 ++wrote 8192/8192 bytes at offset 4299717120 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299729408 ++wrote 8192/8192 bytes at offset 4299729408 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299741696 ++wrote 8192/8192 bytes at offset 4299741696 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299753984 ++wrote 8192/8192 bytes at offset 4299753984 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299766272 ++wrote 8192/8192 bytes at offset 4299766272 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299778560 ++wrote 8192/8192 bytes at offset 4299778560 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299790848 ++wrote 8192/8192 bytes at offset 4299790848 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299803136 ++wrote 8192/8192 bytes at offset 4299803136 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299815424 ++wrote 8192/8192 bytes at offset 4299815424 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299827712 ++wrote 8192/8192 bytes at offset 4299827712 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299840000 ++wrote 8192/8192 bytes at offset 4299840000 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299852288 ++wrote 8192/8192 bytes at offset 4299852288 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299864576 ++wrote 8192/8192 bytes at offset 4299864576 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299876864 ++wrote 8192/8192 bytes at offset 4299876864 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299889152 ++wrote 8192/8192 bytes at offset 4299889152 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299901440 ++wrote 8192/8192 bytes at offset 4299901440 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299913728 ++wrote 8192/8192 bytes at offset 4299913728 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299926016 ++wrote 8192/8192 bytes at offset 4299926016 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299938304 ++wrote 8192/8192 bytes at offset 4299938304 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 244 +-qemu-io> wrote 12288/12288 bytes at offset 4301252608 ++=== IO: pattern 244 ++wrote 12288/12288 bytes at offset 4301252608 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 4303351808 ++wrote 12288/12288 bytes at offset 4303351808 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 4305451008 ++wrote 12288/12288 bytes at offset 4305451008 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 4307550208 ++wrote 12288/12288 bytes at offset 4307550208 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 4309649408 ++wrote 12288/12288 bytes at offset 4309649408 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 4311748608 ++wrote 12288/12288 bytes at offset 4311748608 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 4313847808 ++wrote 12288/12288 bytes at offset 4313847808 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 4315947008 ++wrote 12288/12288 bytes at offset 4315947008 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 1 +-qemu-io> read 4096/4096 bytes at offset 4294967808 ++=== IO: pattern 1 ++read 4096/4096 bytes at offset 4294967808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294971904 ++read 4096/4096 bytes at offset 4294971904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294976000 ++read 4096/4096 bytes at offset 4294976000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294980096 ++read 4096/4096 bytes at offset 4294980096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294984192 ++read 4096/4096 bytes at offset 4294984192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294988288 ++read 4096/4096 bytes at offset 4294988288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294992384 ++read 4096/4096 bytes at offset 4294992384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294996480 ++read 4096/4096 bytes at offset 4294996480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295000576 ++read 4096/4096 bytes at offset 4295000576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295004672 ++read 4096/4096 bytes at offset 4295004672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295008768 ++read 4096/4096 bytes at offset 4295008768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295012864 ++read 4096/4096 bytes at offset 4295012864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295016960 ++read 4096/4096 bytes at offset 4295016960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295021056 ++read 4096/4096 bytes at offset 4295021056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295025152 ++read 4096/4096 bytes at offset 4295025152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295029248 ++read 4096/4096 bytes at offset 4295029248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295033344 ++read 4096/4096 bytes at offset 4295033344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295037440 ++read 4096/4096 bytes at offset 4295037440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295041536 ++read 4096/4096 bytes at offset 4295041536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295045632 ++read 4096/4096 bytes at offset 4295045632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295049728 ++read 4096/4096 bytes at offset 4295049728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295053824 ++read 4096/4096 bytes at offset 4295053824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295057920 ++read 4096/4096 bytes at offset 4295057920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295062016 ++read 4096/4096 bytes at offset 4295062016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295066112 ++read 4096/4096 bytes at offset 4295066112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295070208 ++read 4096/4096 bytes at offset 4295070208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295074304 ++read 4096/4096 bytes at offset 4295074304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295078400 ++read 4096/4096 bytes at offset 4295078400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295082496 ++read 4096/4096 bytes at offset 4295082496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295086592 ++read 4096/4096 bytes at offset 4295086592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295090688 ++read 4096/4096 bytes at offset 4295090688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295094784 ++read 4096/4096 bytes at offset 4295094784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295098880 ++read 4096/4096 bytes at offset 4295098880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295102976 ++read 4096/4096 bytes at offset 4295102976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295107072 ++read 4096/4096 bytes at offset 4295107072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295111168 ++read 4096/4096 bytes at offset 4295111168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295115264 ++read 4096/4096 bytes at offset 4295115264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295119360 ++read 4096/4096 bytes at offset 4295119360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295123456 ++read 4096/4096 bytes at offset 4295123456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295127552 ++read 4096/4096 bytes at offset 4295127552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295131648 ++read 4096/4096 bytes at offset 4295131648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295135744 ++read 4096/4096 bytes at offset 4295135744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295139840 ++read 4096/4096 bytes at offset 4295139840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295143936 ++read 4096/4096 bytes at offset 4295143936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295148032 ++read 4096/4096 bytes at offset 4295148032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295152128 ++read 4096/4096 bytes at offset 4295152128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295156224 ++read 4096/4096 bytes at offset 4295156224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295160320 ++read 4096/4096 bytes at offset 4295160320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295164416 ++read 4096/4096 bytes at offset 4295164416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295168512 ++read 4096/4096 bytes at offset 4295168512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295172608 ++read 4096/4096 bytes at offset 4295172608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295176704 ++read 4096/4096 bytes at offset 4295176704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295180800 ++read 4096/4096 bytes at offset 4295180800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295184896 ++read 4096/4096 bytes at offset 4295184896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295188992 ++read 4096/4096 bytes at offset 4295188992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295193088 ++read 4096/4096 bytes at offset 4295193088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295197184 ++read 4096/4096 bytes at offset 4295197184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295201280 ++read 4096/4096 bytes at offset 4295201280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295205376 ++read 4096/4096 bytes at offset 4295205376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295209472 ++read 4096/4096 bytes at offset 4295209472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295213568 ++read 4096/4096 bytes at offset 4295213568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295217664 ++read 4096/4096 bytes at offset 4295217664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295221760 ++read 4096/4096 bytes at offset 4295221760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295225856 ++read 4096/4096 bytes at offset 4295225856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295229952 ++read 4096/4096 bytes at offset 4295229952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295234048 ++read 4096/4096 bytes at offset 4295234048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295238144 ++read 4096/4096 bytes at offset 4295238144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295242240 ++read 4096/4096 bytes at offset 4295242240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295246336 ++read 4096/4096 bytes at offset 4295246336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295250432 ++read 4096/4096 bytes at offset 4295250432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295254528 ++read 4096/4096 bytes at offset 4295254528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295258624 ++read 4096/4096 bytes at offset 4295258624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295262720 ++read 4096/4096 bytes at offset 4295262720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295266816 ++read 4096/4096 bytes at offset 4295266816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295270912 ++read 4096/4096 bytes at offset 4295270912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295275008 ++read 4096/4096 bytes at offset 4295275008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295279104 ++read 4096/4096 bytes at offset 4295279104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295283200 ++read 4096/4096 bytes at offset 4295283200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295287296 ++read 4096/4096 bytes at offset 4295287296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295291392 ++read 4096/4096 bytes at offset 4295291392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295295488 ++read 4096/4096 bytes at offset 4295295488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295299584 ++read 4096/4096 bytes at offset 4295299584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295303680 ++read 4096/4096 bytes at offset 4295303680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295307776 ++read 4096/4096 bytes at offset 4295307776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295311872 ++read 4096/4096 bytes at offset 4295311872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295315968 ++read 4096/4096 bytes at offset 4295315968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295320064 ++read 4096/4096 bytes at offset 4295320064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295324160 ++read 4096/4096 bytes at offset 4295324160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295328256 ++read 4096/4096 bytes at offset 4295328256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295332352 ++read 4096/4096 bytes at offset 4295332352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295336448 ++read 4096/4096 bytes at offset 4295336448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295340544 ++read 4096/4096 bytes at offset 4295340544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295344640 ++read 4096/4096 bytes at offset 4295344640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295348736 ++read 4096/4096 bytes at offset 4295348736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295352832 ++read 4096/4096 bytes at offset 4295352832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295356928 ++read 4096/4096 bytes at offset 4295356928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295361024 ++read 4096/4096 bytes at offset 4295361024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295365120 ++read 4096/4096 bytes at offset 4295365120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295369216 ++read 4096/4096 bytes at offset 4295369216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295373312 ++read 4096/4096 bytes at offset 4295373312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295377408 ++read 4096/4096 bytes at offset 4295377408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295381504 ++read 4096/4096 bytes at offset 4295381504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295385600 ++read 4096/4096 bytes at offset 4295385600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295389696 ++read 4096/4096 bytes at offset 4295389696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295393792 ++read 4096/4096 bytes at offset 4295393792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295397888 ++read 4096/4096 bytes at offset 4295397888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295401984 ++read 4096/4096 bytes at offset 4295401984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295406080 ++read 4096/4096 bytes at offset 4295406080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295410176 ++read 4096/4096 bytes at offset 4295410176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295414272 ++read 4096/4096 bytes at offset 4295414272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295418368 ++read 4096/4096 bytes at offset 4295418368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295422464 ++read 4096/4096 bytes at offset 4295422464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295426560 ++read 4096/4096 bytes at offset 4295426560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295430656 ++read 4096/4096 bytes at offset 4295430656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295434752 ++read 4096/4096 bytes at offset 4295434752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295438848 ++read 4096/4096 bytes at offset 4295438848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295442944 ++read 4096/4096 bytes at offset 4295442944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295447040 ++read 4096/4096 bytes at offset 4295447040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295451136 ++read 4096/4096 bytes at offset 4295451136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295455232 ++read 4096/4096 bytes at offset 4295455232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295459328 ++read 4096/4096 bytes at offset 4295459328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295463424 ++read 4096/4096 bytes at offset 4295463424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295467520 ++read 4096/4096 bytes at offset 4295467520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295471616 ++read 4096/4096 bytes at offset 4295471616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295475712 ++read 4096/4096 bytes at offset 4295475712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295479808 ++read 4096/4096 bytes at offset 4295479808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295483904 ++read 4096/4096 bytes at offset 4295483904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295488000 ++read 4096/4096 bytes at offset 4295488000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295492096 ++read 4096/4096 bytes at offset 4295492096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295496192 ++read 4096/4096 bytes at offset 4295496192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295500288 ++read 4096/4096 bytes at offset 4295500288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295504384 ++read 4096/4096 bytes at offset 4295504384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295508480 ++read 4096/4096 bytes at offset 4295508480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295512576 ++read 4096/4096 bytes at offset 4295512576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295516672 ++read 4096/4096 bytes at offset 4295516672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295520768 ++read 4096/4096 bytes at offset 4295520768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295524864 ++read 4096/4096 bytes at offset 4295524864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295528960 ++read 4096/4096 bytes at offset 4295528960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295533056 ++read 4096/4096 bytes at offset 4295533056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295537152 ++read 4096/4096 bytes at offset 4295537152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295541248 ++read 4096/4096 bytes at offset 4295541248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295545344 ++read 4096/4096 bytes at offset 4295545344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295549440 ++read 4096/4096 bytes at offset 4295549440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295553536 ++read 4096/4096 bytes at offset 4295553536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295557632 ++read 4096/4096 bytes at offset 4295557632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295561728 ++read 4096/4096 bytes at offset 4295561728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295565824 ++read 4096/4096 bytes at offset 4295565824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295569920 ++read 4096/4096 bytes at offset 4295569920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295574016 ++read 4096/4096 bytes at offset 4295574016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295578112 ++read 4096/4096 bytes at offset 4295578112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295582208 ++read 4096/4096 bytes at offset 4295582208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295586304 ++read 4096/4096 bytes at offset 4295586304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295590400 ++read 4096/4096 bytes at offset 4295590400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295594496 ++read 4096/4096 bytes at offset 4295594496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295598592 ++read 4096/4096 bytes at offset 4295598592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295602688 ++read 4096/4096 bytes at offset 4295602688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295606784 ++read 4096/4096 bytes at offset 4295606784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295610880 ++read 4096/4096 bytes at offset 4295610880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295614976 ++read 4096/4096 bytes at offset 4295614976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295619072 ++read 4096/4096 bytes at offset 4295619072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295623168 ++read 4096/4096 bytes at offset 4295623168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295627264 ++read 4096/4096 bytes at offset 4295627264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295631360 ++read 4096/4096 bytes at offset 4295631360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295635456 ++read 4096/4096 bytes at offset 4295635456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295639552 ++read 4096/4096 bytes at offset 4295639552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295643648 ++read 4096/4096 bytes at offset 4295643648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295647744 ++read 4096/4096 bytes at offset 4295647744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295651840 ++read 4096/4096 bytes at offset 4295651840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295655936 ++read 4096/4096 bytes at offset 4295655936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295660032 ++read 4096/4096 bytes at offset 4295660032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295664128 ++read 4096/4096 bytes at offset 4295664128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295668224 ++read 4096/4096 bytes at offset 4295668224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295672320 ++read 4096/4096 bytes at offset 4295672320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295676416 ++read 4096/4096 bytes at offset 4295676416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295680512 ++read 4096/4096 bytes at offset 4295680512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295684608 ++read 4096/4096 bytes at offset 4295684608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295688704 ++read 4096/4096 bytes at offset 4295688704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295692800 ++read 4096/4096 bytes at offset 4295692800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295696896 ++read 4096/4096 bytes at offset 4295696896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295700992 ++read 4096/4096 bytes at offset 4295700992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295705088 ++read 4096/4096 bytes at offset 4295705088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295709184 ++read 4096/4096 bytes at offset 4295709184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295713280 ++read 4096/4096 bytes at offset 4295713280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295717376 ++read 4096/4096 bytes at offset 4295717376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295721472 ++read 4096/4096 bytes at offset 4295721472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295725568 ++read 4096/4096 bytes at offset 4295725568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295729664 ++read 4096/4096 bytes at offset 4295729664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295733760 ++read 4096/4096 bytes at offset 4295733760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295737856 ++read 4096/4096 bytes at offset 4295737856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295741952 ++read 4096/4096 bytes at offset 4295741952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295746048 ++read 4096/4096 bytes at offset 4295746048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295750144 ++read 4096/4096 bytes at offset 4295750144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295754240 ++read 4096/4096 bytes at offset 4295754240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295758336 ++read 4096/4096 bytes at offset 4295758336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295762432 ++read 4096/4096 bytes at offset 4295762432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295766528 ++read 4096/4096 bytes at offset 4295766528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295770624 ++read 4096/4096 bytes at offset 4295770624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295774720 ++read 4096/4096 bytes at offset 4295774720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295778816 ++read 4096/4096 bytes at offset 4295778816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295782912 ++read 4096/4096 bytes at offset 4295782912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295787008 ++read 4096/4096 bytes at offset 4295787008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295791104 ++read 4096/4096 bytes at offset 4295791104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295795200 ++read 4096/4096 bytes at offset 4295795200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295799296 ++read 4096/4096 bytes at offset 4295799296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295803392 ++read 4096/4096 bytes at offset 4295803392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295807488 ++read 4096/4096 bytes at offset 4295807488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295811584 ++read 4096/4096 bytes at offset 4295811584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295815680 ++read 4096/4096 bytes at offset 4295815680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295819776 ++read 4096/4096 bytes at offset 4295819776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295823872 ++read 4096/4096 bytes at offset 4295823872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295827968 ++read 4096/4096 bytes at offset 4295827968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295832064 ++read 4096/4096 bytes at offset 4295832064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295836160 ++read 4096/4096 bytes at offset 4295836160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295840256 ++read 4096/4096 bytes at offset 4295840256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295844352 ++read 4096/4096 bytes at offset 4295844352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295848448 ++read 4096/4096 bytes at offset 4295848448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295852544 ++read 4096/4096 bytes at offset 4295852544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295856640 ++read 4096/4096 bytes at offset 4295856640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295860736 ++read 4096/4096 bytes at offset 4295860736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295864832 ++read 4096/4096 bytes at offset 4295864832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295868928 ++read 4096/4096 bytes at offset 4295868928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295873024 ++read 4096/4096 bytes at offset 4295873024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295877120 ++read 4096/4096 bytes at offset 4295877120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295881216 ++read 4096/4096 bytes at offset 4295881216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295885312 ++read 4096/4096 bytes at offset 4295885312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295889408 ++read 4096/4096 bytes at offset 4295889408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295893504 ++read 4096/4096 bytes at offset 4295893504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295897600 ++read 4096/4096 bytes at offset 4295897600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295901696 ++read 4096/4096 bytes at offset 4295901696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295905792 ++read 4096/4096 bytes at offset 4295905792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295909888 ++read 4096/4096 bytes at offset 4295909888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295913984 ++read 4096/4096 bytes at offset 4295913984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295918080 ++read 4096/4096 bytes at offset 4295918080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295922176 ++read 4096/4096 bytes at offset 4295922176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295926272 ++read 4096/4096 bytes at offset 4295926272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295930368 ++read 4096/4096 bytes at offset 4295930368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295934464 ++read 4096/4096 bytes at offset 4295934464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295938560 ++read 4096/4096 bytes at offset 4295938560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295942656 ++read 4096/4096 bytes at offset 4295942656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295946752 ++read 4096/4096 bytes at offset 4295946752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295950848 ++read 4096/4096 bytes at offset 4295950848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295954944 ++read 4096/4096 bytes at offset 4295954944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295959040 ++read 4096/4096 bytes at offset 4295959040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295963136 ++read 4096/4096 bytes at offset 4295963136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295967232 ++read 4096/4096 bytes at offset 4295967232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295971328 ++read 4096/4096 bytes at offset 4295971328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295975424 ++read 4096/4096 bytes at offset 4295975424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295979520 ++read 4096/4096 bytes at offset 4295979520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295983616 ++read 4096/4096 bytes at offset 4295983616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295987712 ++read 4096/4096 bytes at offset 4295987712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295991808 ++read 4096/4096 bytes at offset 4295991808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295995904 ++read 4096/4096 bytes at offset 4295995904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4296000000 ++read 4096/4096 bytes at offset 4296000000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4296004096 ++read 4096/4096 bytes at offset 4296004096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4296008192 ++read 4096/4096 bytes at offset 4296008192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4296012288 ++read 4096/4096 bytes at offset 4296012288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 5 +-qemu-io> read 2048/2048 bytes at offset 4296018432 ++=== IO: pattern 5 ++read 2048/2048 bytes at offset 4296018432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296022528 ++read 2048/2048 bytes at offset 4296022528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296026624 ++read 2048/2048 bytes at offset 4296026624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296030720 ++read 2048/2048 bytes at offset 4296030720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296034816 ++read 2048/2048 bytes at offset 4296034816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296038912 ++read 2048/2048 bytes at offset 4296038912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296043008 ++read 2048/2048 bytes at offset 4296043008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296047104 ++read 2048/2048 bytes at offset 4296047104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296051200 ++read 2048/2048 bytes at offset 4296051200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296055296 ++read 2048/2048 bytes at offset 4296055296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296059392 ++read 2048/2048 bytes at offset 4296059392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296063488 ++read 2048/2048 bytes at offset 4296063488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296067584 ++read 2048/2048 bytes at offset 4296067584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296071680 ++read 2048/2048 bytes at offset 4296071680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296075776 ++read 2048/2048 bytes at offset 4296075776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296079872 ++read 2048/2048 bytes at offset 4296079872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296083968 ++read 2048/2048 bytes at offset 4296083968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296088064 ++read 2048/2048 bytes at offset 4296088064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296092160 ++read 2048/2048 bytes at offset 4296092160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296096256 ++read 2048/2048 bytes at offset 4296096256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296100352 ++read 2048/2048 bytes at offset 4296100352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296104448 ++read 2048/2048 bytes at offset 4296104448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296108544 ++read 2048/2048 bytes at offset 4296108544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296112640 ++read 2048/2048 bytes at offset 4296112640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296116736 ++read 2048/2048 bytes at offset 4296116736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296120832 ++read 2048/2048 bytes at offset 4296120832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296124928 ++read 2048/2048 bytes at offset 4296124928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296129024 ++read 2048/2048 bytes at offset 4296129024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296133120 ++read 2048/2048 bytes at offset 4296133120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296137216 ++read 2048/2048 bytes at offset 4296137216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296141312 ++read 2048/2048 bytes at offset 4296141312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296145408 ++read 2048/2048 bytes at offset 4296145408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296149504 ++read 2048/2048 bytes at offset 4296149504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296153600 ++read 2048/2048 bytes at offset 4296153600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296157696 ++read 2048/2048 bytes at offset 4296157696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296161792 ++read 2048/2048 bytes at offset 4296161792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296165888 ++read 2048/2048 bytes at offset 4296165888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296169984 ++read 2048/2048 bytes at offset 4296169984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296174080 ++read 2048/2048 bytes at offset 4296174080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296178176 ++read 2048/2048 bytes at offset 4296178176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296182272 ++read 2048/2048 bytes at offset 4296182272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296186368 ++read 2048/2048 bytes at offset 4296186368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296190464 ++read 2048/2048 bytes at offset 4296190464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296194560 ++read 2048/2048 bytes at offset 4296194560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296198656 ++read 2048/2048 bytes at offset 4296198656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296202752 ++read 2048/2048 bytes at offset 4296202752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296206848 ++read 2048/2048 bytes at offset 4296206848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296210944 ++read 2048/2048 bytes at offset 4296210944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296215040 ++read 2048/2048 bytes at offset 4296215040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296219136 ++read 2048/2048 bytes at offset 4296219136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296223232 ++read 2048/2048 bytes at offset 4296223232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296227328 ++read 2048/2048 bytes at offset 4296227328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296231424 ++read 2048/2048 bytes at offset 4296231424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296235520 ++read 2048/2048 bytes at offset 4296235520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296239616 ++read 2048/2048 bytes at offset 4296239616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296243712 ++read 2048/2048 bytes at offset 4296243712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296247808 ++read 2048/2048 bytes at offset 4296247808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296251904 ++read 2048/2048 bytes at offset 4296251904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296256000 ++read 2048/2048 bytes at offset 4296256000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296260096 ++read 2048/2048 bytes at offset 4296260096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296264192 ++read 2048/2048 bytes at offset 4296264192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296268288 ++read 2048/2048 bytes at offset 4296268288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296272384 ++read 2048/2048 bytes at offset 4296272384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296276480 ++read 2048/2048 bytes at offset 4296276480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296280576 ++read 2048/2048 bytes at offset 4296280576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296284672 ++read 2048/2048 bytes at offset 4296284672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296288768 ++read 2048/2048 bytes at offset 4296288768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296292864 ++read 2048/2048 bytes at offset 4296292864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296296960 ++read 2048/2048 bytes at offset 4296296960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296301056 ++read 2048/2048 bytes at offset 4296301056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296305152 ++read 2048/2048 bytes at offset 4296305152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296309248 ++read 2048/2048 bytes at offset 4296309248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296313344 ++read 2048/2048 bytes at offset 4296313344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296317440 ++read 2048/2048 bytes at offset 4296317440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296321536 ++read 2048/2048 bytes at offset 4296321536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296325632 ++read 2048/2048 bytes at offset 4296325632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296329728 ++read 2048/2048 bytes at offset 4296329728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296333824 ++read 2048/2048 bytes at offset 4296333824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296337920 ++read 2048/2048 bytes at offset 4296337920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296342016 ++read 2048/2048 bytes at offset 4296342016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296346112 ++read 2048/2048 bytes at offset 4296346112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296350208 ++read 2048/2048 bytes at offset 4296350208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296354304 ++read 2048/2048 bytes at offset 4296354304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296358400 ++read 2048/2048 bytes at offset 4296358400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296362496 ++read 2048/2048 bytes at offset 4296362496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296366592 ++read 2048/2048 bytes at offset 4296366592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296370688 ++read 2048/2048 bytes at offset 4296370688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296374784 ++read 2048/2048 bytes at offset 4296374784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296378880 ++read 2048/2048 bytes at offset 4296378880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296382976 ++read 2048/2048 bytes at offset 4296382976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296387072 ++read 2048/2048 bytes at offset 4296387072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296391168 ++read 2048/2048 bytes at offset 4296391168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296395264 ++read 2048/2048 bytes at offset 4296395264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296399360 ++read 2048/2048 bytes at offset 4296399360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296403456 ++read 2048/2048 bytes at offset 4296403456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296407552 ++read 2048/2048 bytes at offset 4296407552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296411648 ++read 2048/2048 bytes at offset 4296411648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296415744 ++read 2048/2048 bytes at offset 4296415744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296419840 ++read 2048/2048 bytes at offset 4296419840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296423936 ++read 2048/2048 bytes at offset 4296423936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296428032 ++read 2048/2048 bytes at offset 4296428032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296432128 ++read 2048/2048 bytes at offset 4296432128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296436224 ++read 2048/2048 bytes at offset 4296436224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296440320 ++read 2048/2048 bytes at offset 4296440320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296444416 ++read 2048/2048 bytes at offset 4296444416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296448512 ++read 2048/2048 bytes at offset 4296448512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296452608 ++read 2048/2048 bytes at offset 4296452608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296456704 ++read 2048/2048 bytes at offset 4296456704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296460800 ++read 2048/2048 bytes at offset 4296460800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296464896 ++read 2048/2048 bytes at offset 4296464896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296468992 ++read 2048/2048 bytes at offset 4296468992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296473088 ++read 2048/2048 bytes at offset 4296473088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296477184 ++read 2048/2048 bytes at offset 4296477184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296481280 ++read 2048/2048 bytes at offset 4296481280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296485376 ++read 2048/2048 bytes at offset 4296485376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296489472 ++read 2048/2048 bytes at offset 4296489472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296493568 ++read 2048/2048 bytes at offset 4296493568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296497664 ++read 2048/2048 bytes at offset 4296497664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296501760 ++read 2048/2048 bytes at offset 4296501760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296505856 ++read 2048/2048 bytes at offset 4296505856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296509952 ++read 2048/2048 bytes at offset 4296509952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296514048 ++read 2048/2048 bytes at offset 4296514048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296518144 ++read 2048/2048 bytes at offset 4296518144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296522240 ++read 2048/2048 bytes at offset 4296522240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296526336 ++read 2048/2048 bytes at offset 4296526336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296530432 ++read 2048/2048 bytes at offset 4296530432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296534528 ++read 2048/2048 bytes at offset 4296534528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296538624 ++read 2048/2048 bytes at offset 4296538624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296542720 ++read 2048/2048 bytes at offset 4296542720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296546816 ++read 2048/2048 bytes at offset 4296546816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296550912 ++read 2048/2048 bytes at offset 4296550912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296555008 ++read 2048/2048 bytes at offset 4296555008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296559104 ++read 2048/2048 bytes at offset 4296559104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296563200 ++read 2048/2048 bytes at offset 4296563200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296567296 ++read 2048/2048 bytes at offset 4296567296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296571392 ++read 2048/2048 bytes at offset 4296571392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296575488 ++read 2048/2048 bytes at offset 4296575488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296579584 ++read 2048/2048 bytes at offset 4296579584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296583680 ++read 2048/2048 bytes at offset 4296583680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296587776 ++read 2048/2048 bytes at offset 4296587776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296591872 ++read 2048/2048 bytes at offset 4296591872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296595968 ++read 2048/2048 bytes at offset 4296595968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296600064 ++read 2048/2048 bytes at offset 4296600064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296604160 ++read 2048/2048 bytes at offset 4296604160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296608256 ++read 2048/2048 bytes at offset 4296608256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296612352 ++read 2048/2048 bytes at offset 4296612352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296616448 ++read 2048/2048 bytes at offset 4296616448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296620544 ++read 2048/2048 bytes at offset 4296620544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296624640 ++read 2048/2048 bytes at offset 4296624640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296628736 ++read 2048/2048 bytes at offset 4296628736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296632832 ++read 2048/2048 bytes at offset 4296632832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296636928 ++read 2048/2048 bytes at offset 4296636928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296641024 ++read 2048/2048 bytes at offset 4296641024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296645120 ++read 2048/2048 bytes at offset 4296645120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296649216 ++read 2048/2048 bytes at offset 4296649216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296653312 ++read 2048/2048 bytes at offset 4296653312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296657408 ++read 2048/2048 bytes at offset 4296657408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296661504 ++read 2048/2048 bytes at offset 4296661504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296665600 ++read 2048/2048 bytes at offset 4296665600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296669696 ++read 2048/2048 bytes at offset 4296669696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296673792 ++read 2048/2048 bytes at offset 4296673792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296677888 ++read 2048/2048 bytes at offset 4296677888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296681984 ++read 2048/2048 bytes at offset 4296681984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296686080 ++read 2048/2048 bytes at offset 4296686080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296690176 ++read 2048/2048 bytes at offset 4296690176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296694272 ++read 2048/2048 bytes at offset 4296694272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296698368 ++read 2048/2048 bytes at offset 4296698368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296702464 ++read 2048/2048 bytes at offset 4296702464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296706560 ++read 2048/2048 bytes at offset 4296706560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296710656 ++read 2048/2048 bytes at offset 4296710656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296714752 ++read 2048/2048 bytes at offset 4296714752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296718848 ++read 2048/2048 bytes at offset 4296718848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296722944 ++read 2048/2048 bytes at offset 4296722944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296727040 ++read 2048/2048 bytes at offset 4296727040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296731136 ++read 2048/2048 bytes at offset 4296731136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296735232 ++read 2048/2048 bytes at offset 4296735232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296739328 ++read 2048/2048 bytes at offset 4296739328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296743424 ++read 2048/2048 bytes at offset 4296743424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296747520 ++read 2048/2048 bytes at offset 4296747520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296751616 ++read 2048/2048 bytes at offset 4296751616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296755712 ++read 2048/2048 bytes at offset 4296755712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296759808 ++read 2048/2048 bytes at offset 4296759808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296763904 ++read 2048/2048 bytes at offset 4296763904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296768000 ++read 2048/2048 bytes at offset 4296768000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296772096 ++read 2048/2048 bytes at offset 4296772096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296776192 ++read 2048/2048 bytes at offset 4296776192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296780288 ++read 2048/2048 bytes at offset 4296780288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296784384 ++read 2048/2048 bytes at offset 4296784384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296788480 ++read 2048/2048 bytes at offset 4296788480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296792576 ++read 2048/2048 bytes at offset 4296792576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296796672 ++read 2048/2048 bytes at offset 4296796672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296800768 ++read 2048/2048 bytes at offset 4296800768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296804864 ++read 2048/2048 bytes at offset 4296804864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296808960 ++read 2048/2048 bytes at offset 4296808960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296813056 ++read 2048/2048 bytes at offset 4296813056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296817152 ++read 2048/2048 bytes at offset 4296817152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296821248 ++read 2048/2048 bytes at offset 4296821248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296825344 ++read 2048/2048 bytes at offset 4296825344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296829440 ++read 2048/2048 bytes at offset 4296829440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296833536 ++read 2048/2048 bytes at offset 4296833536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296837632 ++read 2048/2048 bytes at offset 4296837632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296841728 ++read 2048/2048 bytes at offset 4296841728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296845824 ++read 2048/2048 bytes at offset 4296845824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296849920 ++read 2048/2048 bytes at offset 4296849920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296854016 ++read 2048/2048 bytes at offset 4296854016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296858112 ++read 2048/2048 bytes at offset 4296858112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296862208 ++read 2048/2048 bytes at offset 4296862208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296866304 ++read 2048/2048 bytes at offset 4296866304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296870400 ++read 2048/2048 bytes at offset 4296870400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296874496 ++read 2048/2048 bytes at offset 4296874496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296878592 ++read 2048/2048 bytes at offset 4296878592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296882688 ++read 2048/2048 bytes at offset 4296882688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296886784 ++read 2048/2048 bytes at offset 4296886784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296890880 ++read 2048/2048 bytes at offset 4296890880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296894976 ++read 2048/2048 bytes at offset 4296894976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296899072 ++read 2048/2048 bytes at offset 4296899072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296903168 ++read 2048/2048 bytes at offset 4296903168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296907264 ++read 2048/2048 bytes at offset 4296907264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296911360 ++read 2048/2048 bytes at offset 4296911360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296915456 ++read 2048/2048 bytes at offset 4296915456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296919552 ++read 2048/2048 bytes at offset 4296919552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296923648 ++read 2048/2048 bytes at offset 4296923648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296927744 ++read 2048/2048 bytes at offset 4296927744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296931840 ++read 2048/2048 bytes at offset 4296931840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296935936 ++read 2048/2048 bytes at offset 4296935936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296940032 ++read 2048/2048 bytes at offset 4296940032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296944128 ++read 2048/2048 bytes at offset 4296944128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296948224 ++read 2048/2048 bytes at offset 4296948224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296952320 ++read 2048/2048 bytes at offset 4296952320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296956416 ++read 2048/2048 bytes at offset 4296956416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296960512 ++read 2048/2048 bytes at offset 4296960512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296964608 ++read 2048/2048 bytes at offset 4296964608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296968704 ++read 2048/2048 bytes at offset 4296968704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296972800 ++read 2048/2048 bytes at offset 4296972800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296976896 ++read 2048/2048 bytes at offset 4296976896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296980992 ++read 2048/2048 bytes at offset 4296980992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296985088 ++read 2048/2048 bytes at offset 4296985088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296989184 ++read 2048/2048 bytes at offset 4296989184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296993280 ++read 2048/2048 bytes at offset 4296993280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296997376 ++read 2048/2048 bytes at offset 4296997376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297001472 ++read 2048/2048 bytes at offset 4297001472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297005568 ++read 2048/2048 bytes at offset 4297005568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297009664 ++read 2048/2048 bytes at offset 4297009664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297013760 ++read 2048/2048 bytes at offset 4297013760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297017856 ++read 2048/2048 bytes at offset 4297017856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297021952 ++read 2048/2048 bytes at offset 4297021952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297026048 ++read 2048/2048 bytes at offset 4297026048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297030144 ++read 2048/2048 bytes at offset 4297030144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297034240 ++read 2048/2048 bytes at offset 4297034240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297038336 ++read 2048/2048 bytes at offset 4297038336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297042432 ++read 2048/2048 bytes at offset 4297042432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297046528 ++read 2048/2048 bytes at offset 4297046528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297050624 ++read 2048/2048 bytes at offset 4297050624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297054720 ++read 2048/2048 bytes at offset 4297054720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297058816 ++read 2048/2048 bytes at offset 4297058816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297062912 ++read 2048/2048 bytes at offset 4297062912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 1 +-qemu-io> read 2048/2048 bytes at offset 4297064960 ++=== IO: pattern 1 ++read 2048/2048 bytes at offset 4297064960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297069056 ++read 2048/2048 bytes at offset 4297069056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297073152 ++read 2048/2048 bytes at offset 4297073152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297077248 ++read 2048/2048 bytes at offset 4297077248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297081344 ++read 2048/2048 bytes at offset 4297081344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297085440 ++read 2048/2048 bytes at offset 4297085440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297089536 ++read 2048/2048 bytes at offset 4297089536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297093632 ++read 2048/2048 bytes at offset 4297093632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297097728 ++read 2048/2048 bytes at offset 4297097728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297101824 ++read 2048/2048 bytes at offset 4297101824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297105920 ++read 2048/2048 bytes at offset 4297105920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297110016 ++read 2048/2048 bytes at offset 4297110016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297114112 ++read 2048/2048 bytes at offset 4297114112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297118208 ++read 2048/2048 bytes at offset 4297118208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297122304 ++read 2048/2048 bytes at offset 4297122304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297126400 ++read 2048/2048 bytes at offset 4297126400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297130496 ++read 2048/2048 bytes at offset 4297130496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297134592 ++read 2048/2048 bytes at offset 4297134592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297138688 ++read 2048/2048 bytes at offset 4297138688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297142784 ++read 2048/2048 bytes at offset 4297142784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297146880 ++read 2048/2048 bytes at offset 4297146880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297150976 ++read 2048/2048 bytes at offset 4297150976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297155072 ++read 2048/2048 bytes at offset 4297155072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297159168 ++read 2048/2048 bytes at offset 4297159168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297163264 ++read 2048/2048 bytes at offset 4297163264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297167360 ++read 2048/2048 bytes at offset 4297167360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297171456 ++read 2048/2048 bytes at offset 4297171456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297175552 ++read 2048/2048 bytes at offset 4297175552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297179648 ++read 2048/2048 bytes at offset 4297179648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297183744 ++read 2048/2048 bytes at offset 4297183744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297187840 ++read 2048/2048 bytes at offset 4297187840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297191936 ++read 2048/2048 bytes at offset 4297191936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297196032 ++read 2048/2048 bytes at offset 4297196032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297200128 ++read 2048/2048 bytes at offset 4297200128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297204224 ++read 2048/2048 bytes at offset 4297204224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297208320 ++read 2048/2048 bytes at offset 4297208320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297212416 ++read 2048/2048 bytes at offset 4297212416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297216512 ++read 2048/2048 bytes at offset 4297216512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297220608 ++read 2048/2048 bytes at offset 4297220608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297224704 ++read 2048/2048 bytes at offset 4297224704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297228800 ++read 2048/2048 bytes at offset 4297228800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297232896 ++read 2048/2048 bytes at offset 4297232896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297236992 ++read 2048/2048 bytes at offset 4297236992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297241088 ++read 2048/2048 bytes at offset 4297241088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297245184 ++read 2048/2048 bytes at offset 4297245184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297249280 ++read 2048/2048 bytes at offset 4297249280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297253376 ++read 2048/2048 bytes at offset 4297253376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297257472 ++read 2048/2048 bytes at offset 4297257472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297261568 ++read 2048/2048 bytes at offset 4297261568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297265664 ++read 2048/2048 bytes at offset 4297265664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297269760 ++read 2048/2048 bytes at offset 4297269760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297273856 ++read 2048/2048 bytes at offset 4297273856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297277952 ++read 2048/2048 bytes at offset 4297277952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297282048 ++read 2048/2048 bytes at offset 4297282048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297286144 ++read 2048/2048 bytes at offset 4297286144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297290240 ++read 2048/2048 bytes at offset 4297290240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297294336 ++read 2048/2048 bytes at offset 4297294336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297298432 ++read 2048/2048 bytes at offset 4297298432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297302528 ++read 2048/2048 bytes at offset 4297302528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297306624 ++read 2048/2048 bytes at offset 4297306624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297310720 ++read 2048/2048 bytes at offset 4297310720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297314816 ++read 2048/2048 bytes at offset 4297314816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297318912 ++read 2048/2048 bytes at offset 4297318912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297323008 ++read 2048/2048 bytes at offset 4297323008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297327104 ++read 2048/2048 bytes at offset 4297327104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297331200 ++read 2048/2048 bytes at offset 4297331200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297335296 ++read 2048/2048 bytes at offset 4297335296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297339392 ++read 2048/2048 bytes at offset 4297339392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297343488 ++read 2048/2048 bytes at offset 4297343488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297347584 ++read 2048/2048 bytes at offset 4297347584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297351680 ++read 2048/2048 bytes at offset 4297351680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297355776 ++read 2048/2048 bytes at offset 4297355776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297359872 ++read 2048/2048 bytes at offset 4297359872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297363968 ++read 2048/2048 bytes at offset 4297363968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297368064 ++read 2048/2048 bytes at offset 4297368064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297372160 ++read 2048/2048 bytes at offset 4297372160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297376256 ++read 2048/2048 bytes at offset 4297376256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297380352 ++read 2048/2048 bytes at offset 4297380352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297384448 ++read 2048/2048 bytes at offset 4297384448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297388544 ++read 2048/2048 bytes at offset 4297388544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297392640 ++read 2048/2048 bytes at offset 4297392640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297396736 ++read 2048/2048 bytes at offset 4297396736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297400832 ++read 2048/2048 bytes at offset 4297400832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297404928 ++read 2048/2048 bytes at offset 4297404928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297409024 ++read 2048/2048 bytes at offset 4297409024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297413120 ++read 2048/2048 bytes at offset 4297413120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297417216 ++read 2048/2048 bytes at offset 4297417216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297421312 ++read 2048/2048 bytes at offset 4297421312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297425408 ++read 2048/2048 bytes at offset 4297425408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297429504 ++read 2048/2048 bytes at offset 4297429504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297433600 ++read 2048/2048 bytes at offset 4297433600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297437696 ++read 2048/2048 bytes at offset 4297437696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297441792 ++read 2048/2048 bytes at offset 4297441792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297445888 ++read 2048/2048 bytes at offset 4297445888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297449984 ++read 2048/2048 bytes at offset 4297449984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297454080 ++read 2048/2048 bytes at offset 4297454080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297458176 ++read 2048/2048 bytes at offset 4297458176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297462272 ++read 2048/2048 bytes at offset 4297462272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297466368 ++read 2048/2048 bytes at offset 4297466368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297470464 ++read 2048/2048 bytes at offset 4297470464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297474560 ++read 2048/2048 bytes at offset 4297474560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297478656 ++read 2048/2048 bytes at offset 4297478656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297482752 ++read 2048/2048 bytes at offset 4297482752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297486848 ++read 2048/2048 bytes at offset 4297486848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297490944 ++read 2048/2048 bytes at offset 4297490944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297495040 ++read 2048/2048 bytes at offset 4297495040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297499136 ++read 2048/2048 bytes at offset 4297499136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297503232 ++read 2048/2048 bytes at offset 4297503232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297507328 ++read 2048/2048 bytes at offset 4297507328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297511424 ++read 2048/2048 bytes at offset 4297511424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297515520 ++read 2048/2048 bytes at offset 4297515520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297519616 ++read 2048/2048 bytes at offset 4297519616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297523712 ++read 2048/2048 bytes at offset 4297523712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297527808 ++read 2048/2048 bytes at offset 4297527808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297531904 ++read 2048/2048 bytes at offset 4297531904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297536000 ++read 2048/2048 bytes at offset 4297536000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297540096 ++read 2048/2048 bytes at offset 4297540096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297544192 ++read 2048/2048 bytes at offset 4297544192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297548288 ++read 2048/2048 bytes at offset 4297548288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297552384 ++read 2048/2048 bytes at offset 4297552384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297556480 ++read 2048/2048 bytes at offset 4297556480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297560576 ++read 2048/2048 bytes at offset 4297560576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297564672 ++read 2048/2048 bytes at offset 4297564672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297568768 ++read 2048/2048 bytes at offset 4297568768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297572864 ++read 2048/2048 bytes at offset 4297572864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297576960 ++read 2048/2048 bytes at offset 4297576960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297581056 ++read 2048/2048 bytes at offset 4297581056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297585152 ++read 2048/2048 bytes at offset 4297585152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297589248 ++read 2048/2048 bytes at offset 4297589248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297593344 ++read 2048/2048 bytes at offset 4297593344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297597440 ++read 2048/2048 bytes at offset 4297597440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297601536 ++read 2048/2048 bytes at offset 4297601536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297605632 ++read 2048/2048 bytes at offset 4297605632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297609728 ++read 2048/2048 bytes at offset 4297609728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297613824 ++read 2048/2048 bytes at offset 4297613824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297617920 ++read 2048/2048 bytes at offset 4297617920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297622016 ++read 2048/2048 bytes at offset 4297622016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297626112 ++read 2048/2048 bytes at offset 4297626112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297630208 ++read 2048/2048 bytes at offset 4297630208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297634304 ++read 2048/2048 bytes at offset 4297634304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297638400 ++read 2048/2048 bytes at offset 4297638400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297642496 ++read 2048/2048 bytes at offset 4297642496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297646592 ++read 2048/2048 bytes at offset 4297646592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297650688 ++read 2048/2048 bytes at offset 4297650688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297654784 ++read 2048/2048 bytes at offset 4297654784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297658880 ++read 2048/2048 bytes at offset 4297658880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297662976 ++read 2048/2048 bytes at offset 4297662976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297667072 ++read 2048/2048 bytes at offset 4297667072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297671168 ++read 2048/2048 bytes at offset 4297671168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297675264 ++read 2048/2048 bytes at offset 4297675264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297679360 ++read 2048/2048 bytes at offset 4297679360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297683456 ++read 2048/2048 bytes at offset 4297683456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297687552 ++read 2048/2048 bytes at offset 4297687552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297691648 ++read 2048/2048 bytes at offset 4297691648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297695744 ++read 2048/2048 bytes at offset 4297695744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297699840 ++read 2048/2048 bytes at offset 4297699840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297703936 ++read 2048/2048 bytes at offset 4297703936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297708032 ++read 2048/2048 bytes at offset 4297708032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297712128 ++read 2048/2048 bytes at offset 4297712128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297716224 ++read 2048/2048 bytes at offset 4297716224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297720320 ++read 2048/2048 bytes at offset 4297720320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297724416 ++read 2048/2048 bytes at offset 4297724416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297728512 ++read 2048/2048 bytes at offset 4297728512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297732608 ++read 2048/2048 bytes at offset 4297732608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297736704 ++read 2048/2048 bytes at offset 4297736704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297740800 ++read 2048/2048 bytes at offset 4297740800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297744896 ++read 2048/2048 bytes at offset 4297744896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297748992 ++read 2048/2048 bytes at offset 4297748992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297753088 ++read 2048/2048 bytes at offset 4297753088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297757184 ++read 2048/2048 bytes at offset 4297757184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297761280 ++read 2048/2048 bytes at offset 4297761280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297765376 ++read 2048/2048 bytes at offset 4297765376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297769472 ++read 2048/2048 bytes at offset 4297769472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297773568 ++read 2048/2048 bytes at offset 4297773568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297777664 ++read 2048/2048 bytes at offset 4297777664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297781760 ++read 2048/2048 bytes at offset 4297781760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297785856 ++read 2048/2048 bytes at offset 4297785856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297789952 ++read 2048/2048 bytes at offset 4297789952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297794048 ++read 2048/2048 bytes at offset 4297794048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297798144 ++read 2048/2048 bytes at offset 4297798144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297802240 ++read 2048/2048 bytes at offset 4297802240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297806336 ++read 2048/2048 bytes at offset 4297806336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297810432 ++read 2048/2048 bytes at offset 4297810432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297814528 ++read 2048/2048 bytes at offset 4297814528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297818624 ++read 2048/2048 bytes at offset 4297818624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297822720 ++read 2048/2048 bytes at offset 4297822720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297826816 ++read 2048/2048 bytes at offset 4297826816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297830912 ++read 2048/2048 bytes at offset 4297830912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297835008 ++read 2048/2048 bytes at offset 4297835008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297839104 ++read 2048/2048 bytes at offset 4297839104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297843200 ++read 2048/2048 bytes at offset 4297843200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297847296 ++read 2048/2048 bytes at offset 4297847296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297851392 ++read 2048/2048 bytes at offset 4297851392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297855488 ++read 2048/2048 bytes at offset 4297855488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297859584 ++read 2048/2048 bytes at offset 4297859584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297863680 ++read 2048/2048 bytes at offset 4297863680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297867776 ++read 2048/2048 bytes at offset 4297867776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297871872 ++read 2048/2048 bytes at offset 4297871872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297875968 ++read 2048/2048 bytes at offset 4297875968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297880064 ++read 2048/2048 bytes at offset 4297880064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297884160 ++read 2048/2048 bytes at offset 4297884160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297888256 ++read 2048/2048 bytes at offset 4297888256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297892352 ++read 2048/2048 bytes at offset 4297892352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297896448 ++read 2048/2048 bytes at offset 4297896448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297900544 ++read 2048/2048 bytes at offset 4297900544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297904640 ++read 2048/2048 bytes at offset 4297904640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297908736 ++read 2048/2048 bytes at offset 4297908736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297912832 ++read 2048/2048 bytes at offset 4297912832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297916928 ++read 2048/2048 bytes at offset 4297916928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297921024 ++read 2048/2048 bytes at offset 4297921024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297925120 ++read 2048/2048 bytes at offset 4297925120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297929216 ++read 2048/2048 bytes at offset 4297929216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297933312 ++read 2048/2048 bytes at offset 4297933312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297937408 ++read 2048/2048 bytes at offset 4297937408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297941504 ++read 2048/2048 bytes at offset 4297941504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297945600 ++read 2048/2048 bytes at offset 4297945600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297949696 ++read 2048/2048 bytes at offset 4297949696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297953792 ++read 2048/2048 bytes at offset 4297953792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297957888 ++read 2048/2048 bytes at offset 4297957888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297961984 ++read 2048/2048 bytes at offset 4297961984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297966080 ++read 2048/2048 bytes at offset 4297966080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297970176 ++read 2048/2048 bytes at offset 4297970176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297974272 ++read 2048/2048 bytes at offset 4297974272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297978368 ++read 2048/2048 bytes at offset 4297978368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297982464 ++read 2048/2048 bytes at offset 4297982464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297986560 ++read 2048/2048 bytes at offset 4297986560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297990656 ++read 2048/2048 bytes at offset 4297990656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297994752 ++read 2048/2048 bytes at offset 4297994752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297998848 ++read 2048/2048 bytes at offset 4297998848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298002944 ++read 2048/2048 bytes at offset 4298002944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298007040 ++read 2048/2048 bytes at offset 4298007040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298011136 ++read 2048/2048 bytes at offset 4298011136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298015232 ++read 2048/2048 bytes at offset 4298015232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298019328 ++read 2048/2048 bytes at offset 4298019328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298023424 ++read 2048/2048 bytes at offset 4298023424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298027520 ++read 2048/2048 bytes at offset 4298027520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298031616 ++read 2048/2048 bytes at offset 4298031616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298035712 ++read 2048/2048 bytes at offset 4298035712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298039808 ++read 2048/2048 bytes at offset 4298039808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298043904 ++read 2048/2048 bytes at offset 4298043904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298048000 ++read 2048/2048 bytes at offset 4298048000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298052096 ++read 2048/2048 bytes at offset 4298052096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298056192 ++read 2048/2048 bytes at offset 4298056192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298060288 ++read 2048/2048 bytes at offset 4298060288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298064384 ++read 2048/2048 bytes at offset 4298064384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298068480 ++read 2048/2048 bytes at offset 4298068480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298072576 ++read 2048/2048 bytes at offset 4298072576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298076672 ++read 2048/2048 bytes at offset 4298076672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298080768 ++read 2048/2048 bytes at offset 4298080768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298084864 ++read 2048/2048 bytes at offset 4298084864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298088960 ++read 2048/2048 bytes at offset 4298088960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298093056 ++read 2048/2048 bytes at offset 4298093056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298097152 ++read 2048/2048 bytes at offset 4298097152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298101248 ++read 2048/2048 bytes at offset 4298101248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298105344 ++read 2048/2048 bytes at offset 4298105344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298109440 ++read 2048/2048 bytes at offset 4298109440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 3 +-qemu-io> read 2048/2048 bytes at offset 4298114560 ++=== IO: pattern 3 ++read 2048/2048 bytes at offset 4298114560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298118656 ++read 2048/2048 bytes at offset 4298118656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298122752 ++read 2048/2048 bytes at offset 4298122752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298126848 ++read 2048/2048 bytes at offset 4298126848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298130944 ++read 2048/2048 bytes at offset 4298130944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298135040 ++read 2048/2048 bytes at offset 4298135040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298139136 ++read 2048/2048 bytes at offset 4298139136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298143232 ++read 2048/2048 bytes at offset 4298143232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298147328 ++read 2048/2048 bytes at offset 4298147328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298151424 ++read 2048/2048 bytes at offset 4298151424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298155520 ++read 2048/2048 bytes at offset 4298155520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298159616 ++read 2048/2048 bytes at offset 4298159616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298163712 ++read 2048/2048 bytes at offset 4298163712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298167808 ++read 2048/2048 bytes at offset 4298167808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298171904 ++read 2048/2048 bytes at offset 4298171904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298176000 ++read 2048/2048 bytes at offset 4298176000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298180096 ++read 2048/2048 bytes at offset 4298180096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298184192 ++read 2048/2048 bytes at offset 4298184192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298188288 ++read 2048/2048 bytes at offset 4298188288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298192384 ++read 2048/2048 bytes at offset 4298192384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298196480 ++read 2048/2048 bytes at offset 4298196480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298200576 ++read 2048/2048 bytes at offset 4298200576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298204672 ++read 2048/2048 bytes at offset 4298204672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298208768 ++read 2048/2048 bytes at offset 4298208768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298212864 ++read 2048/2048 bytes at offset 4298212864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298216960 ++read 2048/2048 bytes at offset 4298216960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298221056 ++read 2048/2048 bytes at offset 4298221056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298225152 ++read 2048/2048 bytes at offset 4298225152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298229248 ++read 2048/2048 bytes at offset 4298229248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298233344 ++read 2048/2048 bytes at offset 4298233344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298237440 ++read 2048/2048 bytes at offset 4298237440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298241536 ++read 2048/2048 bytes at offset 4298241536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298245632 ++read 2048/2048 bytes at offset 4298245632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298249728 ++read 2048/2048 bytes at offset 4298249728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298253824 ++read 2048/2048 bytes at offset 4298253824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298257920 ++read 2048/2048 bytes at offset 4298257920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298262016 ++read 2048/2048 bytes at offset 4298262016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298266112 ++read 2048/2048 bytes at offset 4298266112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298270208 ++read 2048/2048 bytes at offset 4298270208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298274304 ++read 2048/2048 bytes at offset 4298274304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298278400 ++read 2048/2048 bytes at offset 4298278400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298282496 ++read 2048/2048 bytes at offset 4298282496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298286592 ++read 2048/2048 bytes at offset 4298286592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298290688 ++read 2048/2048 bytes at offset 4298290688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298294784 ++read 2048/2048 bytes at offset 4298294784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298298880 ++read 2048/2048 bytes at offset 4298298880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298302976 ++read 2048/2048 bytes at offset 4298302976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298307072 ++read 2048/2048 bytes at offset 4298307072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298311168 ++read 2048/2048 bytes at offset 4298311168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298315264 ++read 2048/2048 bytes at offset 4298315264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298319360 ++read 2048/2048 bytes at offset 4298319360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298323456 ++read 2048/2048 bytes at offset 4298323456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298327552 ++read 2048/2048 bytes at offset 4298327552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298331648 ++read 2048/2048 bytes at offset 4298331648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298335744 ++read 2048/2048 bytes at offset 4298335744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298339840 ++read 2048/2048 bytes at offset 4298339840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298343936 ++read 2048/2048 bytes at offset 4298343936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298348032 ++read 2048/2048 bytes at offset 4298348032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298352128 ++read 2048/2048 bytes at offset 4298352128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298356224 ++read 2048/2048 bytes at offset 4298356224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298360320 ++read 2048/2048 bytes at offset 4298360320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298364416 ++read 2048/2048 bytes at offset 4298364416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298368512 ++read 2048/2048 bytes at offset 4298368512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298372608 ++read 2048/2048 bytes at offset 4298372608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298376704 ++read 2048/2048 bytes at offset 4298376704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298380800 ++read 2048/2048 bytes at offset 4298380800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298384896 ++read 2048/2048 bytes at offset 4298384896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298388992 ++read 2048/2048 bytes at offset 4298388992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298393088 ++read 2048/2048 bytes at offset 4298393088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298397184 ++read 2048/2048 bytes at offset 4298397184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298401280 ++read 2048/2048 bytes at offset 4298401280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298405376 ++read 2048/2048 bytes at offset 4298405376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298409472 ++read 2048/2048 bytes at offset 4298409472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298413568 ++read 2048/2048 bytes at offset 4298413568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298417664 ++read 2048/2048 bytes at offset 4298417664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298421760 ++read 2048/2048 bytes at offset 4298421760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298425856 ++read 2048/2048 bytes at offset 4298425856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298429952 ++read 2048/2048 bytes at offset 4298429952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298434048 ++read 2048/2048 bytes at offset 4298434048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298438144 ++read 2048/2048 bytes at offset 4298438144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298442240 ++read 2048/2048 bytes at offset 4298442240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298446336 ++read 2048/2048 bytes at offset 4298446336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298450432 ++read 2048/2048 bytes at offset 4298450432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298454528 ++read 2048/2048 bytes at offset 4298454528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298458624 ++read 2048/2048 bytes at offset 4298458624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298462720 ++read 2048/2048 bytes at offset 4298462720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298466816 ++read 2048/2048 bytes at offset 4298466816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298470912 ++read 2048/2048 bytes at offset 4298470912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298475008 ++read 2048/2048 bytes at offset 4298475008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298479104 ++read 2048/2048 bytes at offset 4298479104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298483200 ++read 2048/2048 bytes at offset 4298483200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298487296 ++read 2048/2048 bytes at offset 4298487296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298491392 ++read 2048/2048 bytes at offset 4298491392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298495488 ++read 2048/2048 bytes at offset 4298495488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298499584 ++read 2048/2048 bytes at offset 4298499584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298503680 ++read 2048/2048 bytes at offset 4298503680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298507776 ++read 2048/2048 bytes at offset 4298507776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298511872 ++read 2048/2048 bytes at offset 4298511872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298515968 ++read 2048/2048 bytes at offset 4298515968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298520064 ++read 2048/2048 bytes at offset 4298520064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298524160 ++read 2048/2048 bytes at offset 4298524160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298528256 ++read 2048/2048 bytes at offset 4298528256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298532352 ++read 2048/2048 bytes at offset 4298532352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298536448 ++read 2048/2048 bytes at offset 4298536448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298540544 ++read 2048/2048 bytes at offset 4298540544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298544640 ++read 2048/2048 bytes at offset 4298544640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298548736 ++read 2048/2048 bytes at offset 4298548736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298552832 ++read 2048/2048 bytes at offset 4298552832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298556928 ++read 2048/2048 bytes at offset 4298556928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298561024 ++read 2048/2048 bytes at offset 4298561024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298565120 ++read 2048/2048 bytes at offset 4298565120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298569216 ++read 2048/2048 bytes at offset 4298569216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298573312 ++read 2048/2048 bytes at offset 4298573312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298577408 ++read 2048/2048 bytes at offset 4298577408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298581504 ++read 2048/2048 bytes at offset 4298581504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298585600 ++read 2048/2048 bytes at offset 4298585600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298589696 ++read 2048/2048 bytes at offset 4298589696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298593792 ++read 2048/2048 bytes at offset 4298593792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298597888 ++read 2048/2048 bytes at offset 4298597888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298601984 ++read 2048/2048 bytes at offset 4298601984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298606080 ++read 2048/2048 bytes at offset 4298606080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298610176 ++read 2048/2048 bytes at offset 4298610176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298614272 ++read 2048/2048 bytes at offset 4298614272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298618368 ++read 2048/2048 bytes at offset 4298618368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298622464 ++read 2048/2048 bytes at offset 4298622464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298626560 ++read 2048/2048 bytes at offset 4298626560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298630656 ++read 2048/2048 bytes at offset 4298630656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298634752 ++read 2048/2048 bytes at offset 4298634752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298638848 ++read 2048/2048 bytes at offset 4298638848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298642944 ++read 2048/2048 bytes at offset 4298642944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298647040 ++read 2048/2048 bytes at offset 4298647040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298651136 ++read 2048/2048 bytes at offset 4298651136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298655232 ++read 2048/2048 bytes at offset 4298655232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298659328 ++read 2048/2048 bytes at offset 4298659328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298663424 ++read 2048/2048 bytes at offset 4298663424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298667520 ++read 2048/2048 bytes at offset 4298667520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298671616 ++read 2048/2048 bytes at offset 4298671616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298675712 ++read 2048/2048 bytes at offset 4298675712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298679808 ++read 2048/2048 bytes at offset 4298679808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298683904 ++read 2048/2048 bytes at offset 4298683904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298688000 ++read 2048/2048 bytes at offset 4298688000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298692096 ++read 2048/2048 bytes at offset 4298692096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298696192 ++read 2048/2048 bytes at offset 4298696192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298700288 ++read 2048/2048 bytes at offset 4298700288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298704384 ++read 2048/2048 bytes at offset 4298704384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298708480 ++read 2048/2048 bytes at offset 4298708480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298712576 ++read 2048/2048 bytes at offset 4298712576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298716672 ++read 2048/2048 bytes at offset 4298716672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298720768 ++read 2048/2048 bytes at offset 4298720768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298724864 ++read 2048/2048 bytes at offset 4298724864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298728960 ++read 2048/2048 bytes at offset 4298728960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298733056 ++read 2048/2048 bytes at offset 4298733056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298737152 ++read 2048/2048 bytes at offset 4298737152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298741248 ++read 2048/2048 bytes at offset 4298741248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298745344 ++read 2048/2048 bytes at offset 4298745344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298749440 ++read 2048/2048 bytes at offset 4298749440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298753536 ++read 2048/2048 bytes at offset 4298753536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298757632 ++read 2048/2048 bytes at offset 4298757632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298761728 ++read 2048/2048 bytes at offset 4298761728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298765824 ++read 2048/2048 bytes at offset 4298765824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298769920 ++read 2048/2048 bytes at offset 4298769920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298774016 ++read 2048/2048 bytes at offset 4298774016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298778112 ++read 2048/2048 bytes at offset 4298778112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298782208 ++read 2048/2048 bytes at offset 4298782208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298786304 ++read 2048/2048 bytes at offset 4298786304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298790400 ++read 2048/2048 bytes at offset 4298790400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298794496 ++read 2048/2048 bytes at offset 4298794496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298798592 ++read 2048/2048 bytes at offset 4298798592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298802688 ++read 2048/2048 bytes at offset 4298802688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298806784 ++read 2048/2048 bytes at offset 4298806784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298810880 ++read 2048/2048 bytes at offset 4298810880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298814976 ++read 2048/2048 bytes at offset 4298814976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298819072 ++read 2048/2048 bytes at offset 4298819072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298823168 ++read 2048/2048 bytes at offset 4298823168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298827264 ++read 2048/2048 bytes at offset 4298827264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298831360 ++read 2048/2048 bytes at offset 4298831360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298835456 ++read 2048/2048 bytes at offset 4298835456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298839552 ++read 2048/2048 bytes at offset 4298839552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298843648 ++read 2048/2048 bytes at offset 4298843648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298847744 ++read 2048/2048 bytes at offset 4298847744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298851840 ++read 2048/2048 bytes at offset 4298851840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298855936 ++read 2048/2048 bytes at offset 4298855936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298860032 ++read 2048/2048 bytes at offset 4298860032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298864128 ++read 2048/2048 bytes at offset 4298864128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298868224 ++read 2048/2048 bytes at offset 4298868224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298872320 ++read 2048/2048 bytes at offset 4298872320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298876416 ++read 2048/2048 bytes at offset 4298876416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298880512 ++read 2048/2048 bytes at offset 4298880512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298884608 ++read 2048/2048 bytes at offset 4298884608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298888704 ++read 2048/2048 bytes at offset 4298888704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298892800 ++read 2048/2048 bytes at offset 4298892800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298896896 ++read 2048/2048 bytes at offset 4298896896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298900992 ++read 2048/2048 bytes at offset 4298900992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298905088 ++read 2048/2048 bytes at offset 4298905088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298909184 ++read 2048/2048 bytes at offset 4298909184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298913280 ++read 2048/2048 bytes at offset 4298913280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298917376 ++read 2048/2048 bytes at offset 4298917376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298921472 ++read 2048/2048 bytes at offset 4298921472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298925568 ++read 2048/2048 bytes at offset 4298925568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298929664 ++read 2048/2048 bytes at offset 4298929664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298933760 ++read 2048/2048 bytes at offset 4298933760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298937856 ++read 2048/2048 bytes at offset 4298937856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298941952 ++read 2048/2048 bytes at offset 4298941952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298946048 ++read 2048/2048 bytes at offset 4298946048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298950144 ++read 2048/2048 bytes at offset 4298950144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298954240 ++read 2048/2048 bytes at offset 4298954240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298958336 ++read 2048/2048 bytes at offset 4298958336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298962432 ++read 2048/2048 bytes at offset 4298962432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298966528 ++read 2048/2048 bytes at offset 4298966528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298970624 ++read 2048/2048 bytes at offset 4298970624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298974720 ++read 2048/2048 bytes at offset 4298974720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298978816 ++read 2048/2048 bytes at offset 4298978816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298982912 ++read 2048/2048 bytes at offset 4298982912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298987008 ++read 2048/2048 bytes at offset 4298987008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298991104 ++read 2048/2048 bytes at offset 4298991104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298995200 ++read 2048/2048 bytes at offset 4298995200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298999296 ++read 2048/2048 bytes at offset 4298999296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299003392 ++read 2048/2048 bytes at offset 4299003392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299007488 ++read 2048/2048 bytes at offset 4299007488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299011584 ++read 2048/2048 bytes at offset 4299011584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299015680 ++read 2048/2048 bytes at offset 4299015680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299019776 ++read 2048/2048 bytes at offset 4299019776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299023872 ++read 2048/2048 bytes at offset 4299023872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299027968 ++read 2048/2048 bytes at offset 4299027968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299032064 ++read 2048/2048 bytes at offset 4299032064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299036160 ++read 2048/2048 bytes at offset 4299036160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299040256 ++read 2048/2048 bytes at offset 4299040256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299044352 ++read 2048/2048 bytes at offset 4299044352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299048448 ++read 2048/2048 bytes at offset 4299048448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299052544 ++read 2048/2048 bytes at offset 4299052544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299056640 ++read 2048/2048 bytes at offset 4299056640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299060736 ++read 2048/2048 bytes at offset 4299060736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299064832 ++read 2048/2048 bytes at offset 4299064832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299068928 ++read 2048/2048 bytes at offset 4299068928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299073024 ++read 2048/2048 bytes at offset 4299073024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299077120 ++read 2048/2048 bytes at offset 4299077120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299081216 ++read 2048/2048 bytes at offset 4299081216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299085312 ++read 2048/2048 bytes at offset 4299085312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299089408 ++read 2048/2048 bytes at offset 4299089408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299093504 ++read 2048/2048 bytes at offset 4299093504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299097600 ++read 2048/2048 bytes at offset 4299097600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299101696 ++read 2048/2048 bytes at offset 4299101696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299105792 ++read 2048/2048 bytes at offset 4299105792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299109888 ++read 2048/2048 bytes at offset 4299109888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299113984 ++read 2048/2048 bytes at offset 4299113984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299118080 ++read 2048/2048 bytes at offset 4299118080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299122176 ++read 2048/2048 bytes at offset 4299122176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299126272 ++read 2048/2048 bytes at offset 4299126272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299130368 ++read 2048/2048 bytes at offset 4299130368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299134464 ++read 2048/2048 bytes at offset 4299134464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299138560 ++read 2048/2048 bytes at offset 4299138560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299142656 ++read 2048/2048 bytes at offset 4299142656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299146752 ++read 2048/2048 bytes at offset 4299146752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299150848 ++read 2048/2048 bytes at offset 4299150848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299154944 ++read 2048/2048 bytes at offset 4299154944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299159040 ++read 2048/2048 bytes at offset 4299159040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 5 +-qemu-io> read 8192/8192 bytes at offset 4299164160 ++=== IO: pattern 5 ++read 8192/8192 bytes at offset 4299164160 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299176448 ++read 8192/8192 bytes at offset 4299176448 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299188736 ++read 8192/8192 bytes at offset 4299188736 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299201024 ++read 8192/8192 bytes at offset 4299201024 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299213312 ++read 8192/8192 bytes at offset 4299213312 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299225600 ++read 8192/8192 bytes at offset 4299225600 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299237888 ++read 8192/8192 bytes at offset 4299237888 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299250176 ++read 8192/8192 bytes at offset 4299250176 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299262464 ++read 8192/8192 bytes at offset 4299262464 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299274752 ++read 8192/8192 bytes at offset 4299274752 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299287040 ++read 8192/8192 bytes at offset 4299287040 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299299328 ++read 8192/8192 bytes at offset 4299299328 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299311616 ++read 8192/8192 bytes at offset 4299311616 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299323904 ++read 8192/8192 bytes at offset 4299323904 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299336192 ++read 8192/8192 bytes at offset 4299336192 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299348480 ++read 8192/8192 bytes at offset 4299348480 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299360768 ++read 8192/8192 bytes at offset 4299360768 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299373056 ++read 8192/8192 bytes at offset 4299373056 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299385344 ++read 8192/8192 bytes at offset 4299385344 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299397632 ++read 8192/8192 bytes at offset 4299397632 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299409920 ++read 8192/8192 bytes at offset 4299409920 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299422208 ++read 8192/8192 bytes at offset 4299422208 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299434496 ++read 8192/8192 bytes at offset 4299434496 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299446784 ++read 8192/8192 bytes at offset 4299446784 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299459072 ++read 8192/8192 bytes at offset 4299459072 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299471360 ++read 8192/8192 bytes at offset 4299471360 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299483648 ++read 8192/8192 bytes at offset 4299483648 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299495936 ++read 8192/8192 bytes at offset 4299495936 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299508224 ++read 8192/8192 bytes at offset 4299508224 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299520512 ++read 8192/8192 bytes at offset 4299520512 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299532800 ++read 8192/8192 bytes at offset 4299532800 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299545088 ++read 8192/8192 bytes at offset 4299545088 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299557376 ++read 8192/8192 bytes at offset 4299557376 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299569664 ++read 8192/8192 bytes at offset 4299569664 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299581952 ++read 8192/8192 bytes at offset 4299581952 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299594240 ++read 8192/8192 bytes at offset 4299594240 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299606528 ++read 8192/8192 bytes at offset 4299606528 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299618816 ++read 8192/8192 bytes at offset 4299618816 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299631104 ++read 8192/8192 bytes at offset 4299631104 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299643392 ++read 8192/8192 bytes at offset 4299643392 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299655680 ++read 8192/8192 bytes at offset 4299655680 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299667968 ++read 8192/8192 bytes at offset 4299667968 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299680256 ++read 8192/8192 bytes at offset 4299680256 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299692544 ++read 8192/8192 bytes at offset 4299692544 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299704832 ++read 8192/8192 bytes at offset 4299704832 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299717120 ++read 8192/8192 bytes at offset 4299717120 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299729408 ++read 8192/8192 bytes at offset 4299729408 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299741696 ++read 8192/8192 bytes at offset 4299741696 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299753984 ++read 8192/8192 bytes at offset 4299753984 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299766272 ++read 8192/8192 bytes at offset 4299766272 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299778560 ++read 8192/8192 bytes at offset 4299778560 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299790848 ++read 8192/8192 bytes at offset 4299790848 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299803136 ++read 8192/8192 bytes at offset 4299803136 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299815424 ++read 8192/8192 bytes at offset 4299815424 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299827712 ++read 8192/8192 bytes at offset 4299827712 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299840000 ++read 8192/8192 bytes at offset 4299840000 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299852288 ++read 8192/8192 bytes at offset 4299852288 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299864576 ++read 8192/8192 bytes at offset 4299864576 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299876864 ++read 8192/8192 bytes at offset 4299876864 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299889152 ++read 8192/8192 bytes at offset 4299889152 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299901440 ++read 8192/8192 bytes at offset 4299901440 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299913728 ++read 8192/8192 bytes at offset 4299913728 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299926016 ++read 8192/8192 bytes at offset 4299926016 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299938304 ++read 8192/8192 bytes at offset 4299938304 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 244 +-qemu-io> read 12288/12288 bytes at offset 4301252608 ++=== IO: pattern 244 ++read 12288/12288 bytes at offset 4301252608 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4303351808 ++read 12288/12288 bytes at offset 4303351808 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4305451008 ++read 12288/12288 bytes at offset 4305451008 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4307550208 ++read 12288/12288 bytes at offset 4307550208 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4309649408 ++read 12288/12288 bytes at offset 4309649408 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4311748608 ++read 12288/12288 bytes at offset 4311748608 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4313847808 ++read 12288/12288 bytes at offset 4313847808 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4315947008 ++read 12288/12288 bytes at offset 4315947008 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 1 +-qemu-io> wrote 4096/4096 bytes at offset 4294967808 ++=== IO: pattern 1 ++wrote 4096/4096 bytes at offset 4294967808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4294971904 ++wrote 4096/4096 bytes at offset 4294971904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4294976000 ++wrote 4096/4096 bytes at offset 4294976000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4294980096 ++wrote 4096/4096 bytes at offset 4294980096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4294984192 ++wrote 4096/4096 bytes at offset 4294984192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4294988288 ++wrote 4096/4096 bytes at offset 4294988288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4294992384 ++wrote 4096/4096 bytes at offset 4294992384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4294996480 ++wrote 4096/4096 bytes at offset 4294996480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295000576 ++wrote 4096/4096 bytes at offset 4295000576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295004672 ++wrote 4096/4096 bytes at offset 4295004672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295008768 ++wrote 4096/4096 bytes at offset 4295008768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295012864 ++wrote 4096/4096 bytes at offset 4295012864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295016960 ++wrote 4096/4096 bytes at offset 4295016960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295021056 ++wrote 4096/4096 bytes at offset 4295021056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295025152 ++wrote 4096/4096 bytes at offset 4295025152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295029248 ++wrote 4096/4096 bytes at offset 4295029248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295033344 ++wrote 4096/4096 bytes at offset 4295033344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295037440 ++wrote 4096/4096 bytes at offset 4295037440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295041536 ++wrote 4096/4096 bytes at offset 4295041536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295045632 ++wrote 4096/4096 bytes at offset 4295045632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295049728 ++wrote 4096/4096 bytes at offset 4295049728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295053824 ++wrote 4096/4096 bytes at offset 4295053824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295057920 ++wrote 4096/4096 bytes at offset 4295057920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295062016 ++wrote 4096/4096 bytes at offset 4295062016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295066112 ++wrote 4096/4096 bytes at offset 4295066112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295070208 ++wrote 4096/4096 bytes at offset 4295070208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295074304 ++wrote 4096/4096 bytes at offset 4295074304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295078400 ++wrote 4096/4096 bytes at offset 4295078400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295082496 ++wrote 4096/4096 bytes at offset 4295082496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295086592 ++wrote 4096/4096 bytes at offset 4295086592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295090688 ++wrote 4096/4096 bytes at offset 4295090688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295094784 ++wrote 4096/4096 bytes at offset 4295094784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295098880 ++wrote 4096/4096 bytes at offset 4295098880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295102976 ++wrote 4096/4096 bytes at offset 4295102976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295107072 ++wrote 4096/4096 bytes at offset 4295107072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295111168 ++wrote 4096/4096 bytes at offset 4295111168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295115264 ++wrote 4096/4096 bytes at offset 4295115264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295119360 ++wrote 4096/4096 bytes at offset 4295119360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295123456 ++wrote 4096/4096 bytes at offset 4295123456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295127552 ++wrote 4096/4096 bytes at offset 4295127552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295131648 ++wrote 4096/4096 bytes at offset 4295131648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295135744 ++wrote 4096/4096 bytes at offset 4295135744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295139840 ++wrote 4096/4096 bytes at offset 4295139840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295143936 ++wrote 4096/4096 bytes at offset 4295143936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295148032 ++wrote 4096/4096 bytes at offset 4295148032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295152128 ++wrote 4096/4096 bytes at offset 4295152128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295156224 ++wrote 4096/4096 bytes at offset 4295156224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295160320 ++wrote 4096/4096 bytes at offset 4295160320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295164416 ++wrote 4096/4096 bytes at offset 4295164416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295168512 ++wrote 4096/4096 bytes at offset 4295168512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295172608 ++wrote 4096/4096 bytes at offset 4295172608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295176704 ++wrote 4096/4096 bytes at offset 4295176704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295180800 ++wrote 4096/4096 bytes at offset 4295180800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295184896 ++wrote 4096/4096 bytes at offset 4295184896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295188992 ++wrote 4096/4096 bytes at offset 4295188992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295193088 ++wrote 4096/4096 bytes at offset 4295193088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295197184 ++wrote 4096/4096 bytes at offset 4295197184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295201280 ++wrote 4096/4096 bytes at offset 4295201280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295205376 ++wrote 4096/4096 bytes at offset 4295205376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295209472 ++wrote 4096/4096 bytes at offset 4295209472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295213568 ++wrote 4096/4096 bytes at offset 4295213568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295217664 ++wrote 4096/4096 bytes at offset 4295217664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295221760 ++wrote 4096/4096 bytes at offset 4295221760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295225856 ++wrote 4096/4096 bytes at offset 4295225856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295229952 ++wrote 4096/4096 bytes at offset 4295229952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295234048 ++wrote 4096/4096 bytes at offset 4295234048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295238144 ++wrote 4096/4096 bytes at offset 4295238144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295242240 ++wrote 4096/4096 bytes at offset 4295242240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295246336 ++wrote 4096/4096 bytes at offset 4295246336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295250432 ++wrote 4096/4096 bytes at offset 4295250432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295254528 ++wrote 4096/4096 bytes at offset 4295254528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295258624 ++wrote 4096/4096 bytes at offset 4295258624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295262720 ++wrote 4096/4096 bytes at offset 4295262720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295266816 ++wrote 4096/4096 bytes at offset 4295266816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295270912 ++wrote 4096/4096 bytes at offset 4295270912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295275008 ++wrote 4096/4096 bytes at offset 4295275008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295279104 ++wrote 4096/4096 bytes at offset 4295279104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295283200 ++wrote 4096/4096 bytes at offset 4295283200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295287296 ++wrote 4096/4096 bytes at offset 4295287296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295291392 ++wrote 4096/4096 bytes at offset 4295291392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295295488 ++wrote 4096/4096 bytes at offset 4295295488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295299584 ++wrote 4096/4096 bytes at offset 4295299584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295303680 ++wrote 4096/4096 bytes at offset 4295303680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295307776 ++wrote 4096/4096 bytes at offset 4295307776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295311872 ++wrote 4096/4096 bytes at offset 4295311872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295315968 ++wrote 4096/4096 bytes at offset 4295315968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295320064 ++wrote 4096/4096 bytes at offset 4295320064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295324160 ++wrote 4096/4096 bytes at offset 4295324160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295328256 ++wrote 4096/4096 bytes at offset 4295328256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295332352 ++wrote 4096/4096 bytes at offset 4295332352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295336448 ++wrote 4096/4096 bytes at offset 4295336448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295340544 ++wrote 4096/4096 bytes at offset 4295340544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295344640 ++wrote 4096/4096 bytes at offset 4295344640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295348736 ++wrote 4096/4096 bytes at offset 4295348736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295352832 ++wrote 4096/4096 bytes at offset 4295352832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295356928 ++wrote 4096/4096 bytes at offset 4295356928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295361024 ++wrote 4096/4096 bytes at offset 4295361024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295365120 ++wrote 4096/4096 bytes at offset 4295365120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295369216 ++wrote 4096/4096 bytes at offset 4295369216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295373312 ++wrote 4096/4096 bytes at offset 4295373312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295377408 ++wrote 4096/4096 bytes at offset 4295377408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295381504 ++wrote 4096/4096 bytes at offset 4295381504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295385600 ++wrote 4096/4096 bytes at offset 4295385600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295389696 ++wrote 4096/4096 bytes at offset 4295389696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295393792 ++wrote 4096/4096 bytes at offset 4295393792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295397888 ++wrote 4096/4096 bytes at offset 4295397888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295401984 ++wrote 4096/4096 bytes at offset 4295401984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295406080 ++wrote 4096/4096 bytes at offset 4295406080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295410176 ++wrote 4096/4096 bytes at offset 4295410176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295414272 ++wrote 4096/4096 bytes at offset 4295414272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295418368 ++wrote 4096/4096 bytes at offset 4295418368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295422464 ++wrote 4096/4096 bytes at offset 4295422464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295426560 ++wrote 4096/4096 bytes at offset 4295426560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295430656 ++wrote 4096/4096 bytes at offset 4295430656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295434752 ++wrote 4096/4096 bytes at offset 4295434752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295438848 ++wrote 4096/4096 bytes at offset 4295438848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295442944 ++wrote 4096/4096 bytes at offset 4295442944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295447040 ++wrote 4096/4096 bytes at offset 4295447040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295451136 ++wrote 4096/4096 bytes at offset 4295451136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295455232 ++wrote 4096/4096 bytes at offset 4295455232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295459328 ++wrote 4096/4096 bytes at offset 4295459328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295463424 ++wrote 4096/4096 bytes at offset 4295463424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295467520 ++wrote 4096/4096 bytes at offset 4295467520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295471616 ++wrote 4096/4096 bytes at offset 4295471616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295475712 ++wrote 4096/4096 bytes at offset 4295475712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295479808 ++wrote 4096/4096 bytes at offset 4295479808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295483904 ++wrote 4096/4096 bytes at offset 4295483904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295488000 ++wrote 4096/4096 bytes at offset 4295488000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295492096 ++wrote 4096/4096 bytes at offset 4295492096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295496192 ++wrote 4096/4096 bytes at offset 4295496192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295500288 ++wrote 4096/4096 bytes at offset 4295500288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295504384 ++wrote 4096/4096 bytes at offset 4295504384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295508480 ++wrote 4096/4096 bytes at offset 4295508480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295512576 ++wrote 4096/4096 bytes at offset 4295512576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295516672 ++wrote 4096/4096 bytes at offset 4295516672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295520768 ++wrote 4096/4096 bytes at offset 4295520768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295524864 ++wrote 4096/4096 bytes at offset 4295524864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295528960 ++wrote 4096/4096 bytes at offset 4295528960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295533056 ++wrote 4096/4096 bytes at offset 4295533056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295537152 ++wrote 4096/4096 bytes at offset 4295537152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295541248 ++wrote 4096/4096 bytes at offset 4295541248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295545344 ++wrote 4096/4096 bytes at offset 4295545344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295549440 ++wrote 4096/4096 bytes at offset 4295549440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295553536 ++wrote 4096/4096 bytes at offset 4295553536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295557632 ++wrote 4096/4096 bytes at offset 4295557632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295561728 ++wrote 4096/4096 bytes at offset 4295561728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295565824 ++wrote 4096/4096 bytes at offset 4295565824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295569920 ++wrote 4096/4096 bytes at offset 4295569920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295574016 ++wrote 4096/4096 bytes at offset 4295574016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295578112 ++wrote 4096/4096 bytes at offset 4295578112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295582208 ++wrote 4096/4096 bytes at offset 4295582208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295586304 ++wrote 4096/4096 bytes at offset 4295586304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295590400 ++wrote 4096/4096 bytes at offset 4295590400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295594496 ++wrote 4096/4096 bytes at offset 4295594496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295598592 ++wrote 4096/4096 bytes at offset 4295598592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295602688 ++wrote 4096/4096 bytes at offset 4295602688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295606784 ++wrote 4096/4096 bytes at offset 4295606784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295610880 ++wrote 4096/4096 bytes at offset 4295610880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295614976 ++wrote 4096/4096 bytes at offset 4295614976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295619072 ++wrote 4096/4096 bytes at offset 4295619072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295623168 ++wrote 4096/4096 bytes at offset 4295623168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295627264 ++wrote 4096/4096 bytes at offset 4295627264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295631360 ++wrote 4096/4096 bytes at offset 4295631360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295635456 ++wrote 4096/4096 bytes at offset 4295635456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295639552 ++wrote 4096/4096 bytes at offset 4295639552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295643648 ++wrote 4096/4096 bytes at offset 4295643648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295647744 ++wrote 4096/4096 bytes at offset 4295647744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295651840 ++wrote 4096/4096 bytes at offset 4295651840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295655936 ++wrote 4096/4096 bytes at offset 4295655936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295660032 ++wrote 4096/4096 bytes at offset 4295660032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295664128 ++wrote 4096/4096 bytes at offset 4295664128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295668224 ++wrote 4096/4096 bytes at offset 4295668224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295672320 ++wrote 4096/4096 bytes at offset 4295672320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295676416 ++wrote 4096/4096 bytes at offset 4295676416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295680512 ++wrote 4096/4096 bytes at offset 4295680512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295684608 ++wrote 4096/4096 bytes at offset 4295684608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295688704 ++wrote 4096/4096 bytes at offset 4295688704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295692800 ++wrote 4096/4096 bytes at offset 4295692800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295696896 ++wrote 4096/4096 bytes at offset 4295696896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295700992 ++wrote 4096/4096 bytes at offset 4295700992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295705088 ++wrote 4096/4096 bytes at offset 4295705088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295709184 ++wrote 4096/4096 bytes at offset 4295709184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295713280 ++wrote 4096/4096 bytes at offset 4295713280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295717376 ++wrote 4096/4096 bytes at offset 4295717376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295721472 ++wrote 4096/4096 bytes at offset 4295721472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295725568 ++wrote 4096/4096 bytes at offset 4295725568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295729664 ++wrote 4096/4096 bytes at offset 4295729664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295733760 ++wrote 4096/4096 bytes at offset 4295733760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295737856 ++wrote 4096/4096 bytes at offset 4295737856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295741952 ++wrote 4096/4096 bytes at offset 4295741952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295746048 ++wrote 4096/4096 bytes at offset 4295746048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295750144 ++wrote 4096/4096 bytes at offset 4295750144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295754240 ++wrote 4096/4096 bytes at offset 4295754240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295758336 ++wrote 4096/4096 bytes at offset 4295758336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295762432 ++wrote 4096/4096 bytes at offset 4295762432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295766528 ++wrote 4096/4096 bytes at offset 4295766528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295770624 ++wrote 4096/4096 bytes at offset 4295770624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295774720 ++wrote 4096/4096 bytes at offset 4295774720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295778816 ++wrote 4096/4096 bytes at offset 4295778816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295782912 ++wrote 4096/4096 bytes at offset 4295782912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295787008 ++wrote 4096/4096 bytes at offset 4295787008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295791104 ++wrote 4096/4096 bytes at offset 4295791104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295795200 ++wrote 4096/4096 bytes at offset 4295795200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295799296 ++wrote 4096/4096 bytes at offset 4295799296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295803392 ++wrote 4096/4096 bytes at offset 4295803392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295807488 ++wrote 4096/4096 bytes at offset 4295807488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295811584 ++wrote 4096/4096 bytes at offset 4295811584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295815680 ++wrote 4096/4096 bytes at offset 4295815680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295819776 ++wrote 4096/4096 bytes at offset 4295819776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295823872 ++wrote 4096/4096 bytes at offset 4295823872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295827968 ++wrote 4096/4096 bytes at offset 4295827968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295832064 ++wrote 4096/4096 bytes at offset 4295832064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295836160 ++wrote 4096/4096 bytes at offset 4295836160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295840256 ++wrote 4096/4096 bytes at offset 4295840256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295844352 ++wrote 4096/4096 bytes at offset 4295844352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295848448 ++wrote 4096/4096 bytes at offset 4295848448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295852544 ++wrote 4096/4096 bytes at offset 4295852544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295856640 ++wrote 4096/4096 bytes at offset 4295856640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295860736 ++wrote 4096/4096 bytes at offset 4295860736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295864832 ++wrote 4096/4096 bytes at offset 4295864832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295868928 ++wrote 4096/4096 bytes at offset 4295868928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295873024 ++wrote 4096/4096 bytes at offset 4295873024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295877120 ++wrote 4096/4096 bytes at offset 4295877120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295881216 ++wrote 4096/4096 bytes at offset 4295881216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295885312 ++wrote 4096/4096 bytes at offset 4295885312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295889408 ++wrote 4096/4096 bytes at offset 4295889408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295893504 ++wrote 4096/4096 bytes at offset 4295893504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295897600 ++wrote 4096/4096 bytes at offset 4295897600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295901696 ++wrote 4096/4096 bytes at offset 4295901696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295905792 ++wrote 4096/4096 bytes at offset 4295905792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295909888 ++wrote 4096/4096 bytes at offset 4295909888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295913984 ++wrote 4096/4096 bytes at offset 4295913984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295918080 ++wrote 4096/4096 bytes at offset 4295918080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295922176 ++wrote 4096/4096 bytes at offset 4295922176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295926272 ++wrote 4096/4096 bytes at offset 4295926272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295930368 ++wrote 4096/4096 bytes at offset 4295930368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295934464 ++wrote 4096/4096 bytes at offset 4295934464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295938560 ++wrote 4096/4096 bytes at offset 4295938560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295942656 ++wrote 4096/4096 bytes at offset 4295942656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295946752 ++wrote 4096/4096 bytes at offset 4295946752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295950848 ++wrote 4096/4096 bytes at offset 4295950848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295954944 ++wrote 4096/4096 bytes at offset 4295954944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295959040 ++wrote 4096/4096 bytes at offset 4295959040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295963136 ++wrote 4096/4096 bytes at offset 4295963136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295967232 ++wrote 4096/4096 bytes at offset 4295967232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295971328 ++wrote 4096/4096 bytes at offset 4295971328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295975424 ++wrote 4096/4096 bytes at offset 4295975424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295979520 ++wrote 4096/4096 bytes at offset 4295979520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295983616 ++wrote 4096/4096 bytes at offset 4295983616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295987712 ++wrote 4096/4096 bytes at offset 4295987712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295991808 ++wrote 4096/4096 bytes at offset 4295991808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295995904 ++wrote 4096/4096 bytes at offset 4295995904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296000000 ++wrote 4096/4096 bytes at offset 4296000000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296004096 ++wrote 4096/4096 bytes at offset 4296004096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296008192 ++wrote 4096/4096 bytes at offset 4296008192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296012288 ++wrote 4096/4096 bytes at offset 4296012288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 5 +-qemu-io> wrote 2048/2048 bytes at offset 4296018432 ++=== IO: pattern 5 ++wrote 2048/2048 bytes at offset 4296018432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296022528 ++wrote 2048/2048 bytes at offset 4296022528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296026624 ++wrote 2048/2048 bytes at offset 4296026624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296030720 ++wrote 2048/2048 bytes at offset 4296030720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296034816 ++wrote 2048/2048 bytes at offset 4296034816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296038912 ++wrote 2048/2048 bytes at offset 4296038912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296043008 ++wrote 2048/2048 bytes at offset 4296043008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296047104 ++wrote 2048/2048 bytes at offset 4296047104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296051200 ++wrote 2048/2048 bytes at offset 4296051200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296055296 ++wrote 2048/2048 bytes at offset 4296055296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296059392 ++wrote 2048/2048 bytes at offset 4296059392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296063488 ++wrote 2048/2048 bytes at offset 4296063488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296067584 ++wrote 2048/2048 bytes at offset 4296067584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296071680 ++wrote 2048/2048 bytes at offset 4296071680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296075776 ++wrote 2048/2048 bytes at offset 4296075776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296079872 ++wrote 2048/2048 bytes at offset 4296079872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296083968 ++wrote 2048/2048 bytes at offset 4296083968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296088064 ++wrote 2048/2048 bytes at offset 4296088064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296092160 ++wrote 2048/2048 bytes at offset 4296092160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296096256 ++wrote 2048/2048 bytes at offset 4296096256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296100352 ++wrote 2048/2048 bytes at offset 4296100352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296104448 ++wrote 2048/2048 bytes at offset 4296104448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296108544 ++wrote 2048/2048 bytes at offset 4296108544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296112640 ++wrote 2048/2048 bytes at offset 4296112640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296116736 ++wrote 2048/2048 bytes at offset 4296116736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296120832 ++wrote 2048/2048 bytes at offset 4296120832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296124928 ++wrote 2048/2048 bytes at offset 4296124928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296129024 ++wrote 2048/2048 bytes at offset 4296129024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296133120 ++wrote 2048/2048 bytes at offset 4296133120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296137216 ++wrote 2048/2048 bytes at offset 4296137216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296141312 ++wrote 2048/2048 bytes at offset 4296141312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296145408 ++wrote 2048/2048 bytes at offset 4296145408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296149504 ++wrote 2048/2048 bytes at offset 4296149504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296153600 ++wrote 2048/2048 bytes at offset 4296153600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296157696 ++wrote 2048/2048 bytes at offset 4296157696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296161792 ++wrote 2048/2048 bytes at offset 4296161792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296165888 ++wrote 2048/2048 bytes at offset 4296165888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296169984 ++wrote 2048/2048 bytes at offset 4296169984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296174080 ++wrote 2048/2048 bytes at offset 4296174080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296178176 ++wrote 2048/2048 bytes at offset 4296178176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296182272 ++wrote 2048/2048 bytes at offset 4296182272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296186368 ++wrote 2048/2048 bytes at offset 4296186368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296190464 ++wrote 2048/2048 bytes at offset 4296190464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296194560 ++wrote 2048/2048 bytes at offset 4296194560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296198656 ++wrote 2048/2048 bytes at offset 4296198656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296202752 ++wrote 2048/2048 bytes at offset 4296202752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296206848 ++wrote 2048/2048 bytes at offset 4296206848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296210944 ++wrote 2048/2048 bytes at offset 4296210944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296215040 ++wrote 2048/2048 bytes at offset 4296215040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296219136 ++wrote 2048/2048 bytes at offset 4296219136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296223232 ++wrote 2048/2048 bytes at offset 4296223232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296227328 ++wrote 2048/2048 bytes at offset 4296227328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296231424 ++wrote 2048/2048 bytes at offset 4296231424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296235520 ++wrote 2048/2048 bytes at offset 4296235520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296239616 ++wrote 2048/2048 bytes at offset 4296239616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296243712 ++wrote 2048/2048 bytes at offset 4296243712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296247808 ++wrote 2048/2048 bytes at offset 4296247808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296251904 ++wrote 2048/2048 bytes at offset 4296251904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296256000 ++wrote 2048/2048 bytes at offset 4296256000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296260096 ++wrote 2048/2048 bytes at offset 4296260096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296264192 ++wrote 2048/2048 bytes at offset 4296264192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296268288 ++wrote 2048/2048 bytes at offset 4296268288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296272384 ++wrote 2048/2048 bytes at offset 4296272384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296276480 ++wrote 2048/2048 bytes at offset 4296276480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296280576 ++wrote 2048/2048 bytes at offset 4296280576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296284672 ++wrote 2048/2048 bytes at offset 4296284672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296288768 ++wrote 2048/2048 bytes at offset 4296288768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296292864 ++wrote 2048/2048 bytes at offset 4296292864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296296960 ++wrote 2048/2048 bytes at offset 4296296960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296301056 ++wrote 2048/2048 bytes at offset 4296301056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296305152 ++wrote 2048/2048 bytes at offset 4296305152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296309248 ++wrote 2048/2048 bytes at offset 4296309248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296313344 ++wrote 2048/2048 bytes at offset 4296313344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296317440 ++wrote 2048/2048 bytes at offset 4296317440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296321536 ++wrote 2048/2048 bytes at offset 4296321536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296325632 ++wrote 2048/2048 bytes at offset 4296325632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296329728 ++wrote 2048/2048 bytes at offset 4296329728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296333824 ++wrote 2048/2048 bytes at offset 4296333824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296337920 ++wrote 2048/2048 bytes at offset 4296337920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296342016 ++wrote 2048/2048 bytes at offset 4296342016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296346112 ++wrote 2048/2048 bytes at offset 4296346112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296350208 ++wrote 2048/2048 bytes at offset 4296350208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296354304 ++wrote 2048/2048 bytes at offset 4296354304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296358400 ++wrote 2048/2048 bytes at offset 4296358400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296362496 ++wrote 2048/2048 bytes at offset 4296362496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296366592 ++wrote 2048/2048 bytes at offset 4296366592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296370688 ++wrote 2048/2048 bytes at offset 4296370688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296374784 ++wrote 2048/2048 bytes at offset 4296374784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296378880 ++wrote 2048/2048 bytes at offset 4296378880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296382976 ++wrote 2048/2048 bytes at offset 4296382976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296387072 ++wrote 2048/2048 bytes at offset 4296387072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296391168 ++wrote 2048/2048 bytes at offset 4296391168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296395264 ++wrote 2048/2048 bytes at offset 4296395264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296399360 ++wrote 2048/2048 bytes at offset 4296399360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296403456 ++wrote 2048/2048 bytes at offset 4296403456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296407552 ++wrote 2048/2048 bytes at offset 4296407552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296411648 ++wrote 2048/2048 bytes at offset 4296411648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296415744 ++wrote 2048/2048 bytes at offset 4296415744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296419840 ++wrote 2048/2048 bytes at offset 4296419840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296423936 ++wrote 2048/2048 bytes at offset 4296423936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296428032 ++wrote 2048/2048 bytes at offset 4296428032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296432128 ++wrote 2048/2048 bytes at offset 4296432128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296436224 ++wrote 2048/2048 bytes at offset 4296436224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296440320 ++wrote 2048/2048 bytes at offset 4296440320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296444416 ++wrote 2048/2048 bytes at offset 4296444416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296448512 ++wrote 2048/2048 bytes at offset 4296448512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296452608 ++wrote 2048/2048 bytes at offset 4296452608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296456704 ++wrote 2048/2048 bytes at offset 4296456704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296460800 ++wrote 2048/2048 bytes at offset 4296460800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296464896 ++wrote 2048/2048 bytes at offset 4296464896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296468992 ++wrote 2048/2048 bytes at offset 4296468992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296473088 ++wrote 2048/2048 bytes at offset 4296473088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296477184 ++wrote 2048/2048 bytes at offset 4296477184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296481280 ++wrote 2048/2048 bytes at offset 4296481280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296485376 ++wrote 2048/2048 bytes at offset 4296485376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296489472 ++wrote 2048/2048 bytes at offset 4296489472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296493568 ++wrote 2048/2048 bytes at offset 4296493568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296497664 ++wrote 2048/2048 bytes at offset 4296497664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296501760 ++wrote 2048/2048 bytes at offset 4296501760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296505856 ++wrote 2048/2048 bytes at offset 4296505856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296509952 ++wrote 2048/2048 bytes at offset 4296509952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296514048 ++wrote 2048/2048 bytes at offset 4296514048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296518144 ++wrote 2048/2048 bytes at offset 4296518144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296522240 ++wrote 2048/2048 bytes at offset 4296522240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296526336 ++wrote 2048/2048 bytes at offset 4296526336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296530432 ++wrote 2048/2048 bytes at offset 4296530432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296534528 ++wrote 2048/2048 bytes at offset 4296534528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296538624 ++wrote 2048/2048 bytes at offset 4296538624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296542720 ++wrote 2048/2048 bytes at offset 4296542720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296546816 ++wrote 2048/2048 bytes at offset 4296546816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296550912 ++wrote 2048/2048 bytes at offset 4296550912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296555008 ++wrote 2048/2048 bytes at offset 4296555008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296559104 ++wrote 2048/2048 bytes at offset 4296559104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296563200 ++wrote 2048/2048 bytes at offset 4296563200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296567296 ++wrote 2048/2048 bytes at offset 4296567296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296571392 ++wrote 2048/2048 bytes at offset 4296571392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296575488 ++wrote 2048/2048 bytes at offset 4296575488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296579584 ++wrote 2048/2048 bytes at offset 4296579584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296583680 ++wrote 2048/2048 bytes at offset 4296583680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296587776 ++wrote 2048/2048 bytes at offset 4296587776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296591872 ++wrote 2048/2048 bytes at offset 4296591872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296595968 ++wrote 2048/2048 bytes at offset 4296595968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296600064 ++wrote 2048/2048 bytes at offset 4296600064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296604160 ++wrote 2048/2048 bytes at offset 4296604160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296608256 ++wrote 2048/2048 bytes at offset 4296608256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296612352 ++wrote 2048/2048 bytes at offset 4296612352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296616448 ++wrote 2048/2048 bytes at offset 4296616448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296620544 ++wrote 2048/2048 bytes at offset 4296620544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296624640 ++wrote 2048/2048 bytes at offset 4296624640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296628736 ++wrote 2048/2048 bytes at offset 4296628736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296632832 ++wrote 2048/2048 bytes at offset 4296632832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296636928 ++wrote 2048/2048 bytes at offset 4296636928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296641024 ++wrote 2048/2048 bytes at offset 4296641024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296645120 ++wrote 2048/2048 bytes at offset 4296645120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296649216 ++wrote 2048/2048 bytes at offset 4296649216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296653312 ++wrote 2048/2048 bytes at offset 4296653312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296657408 ++wrote 2048/2048 bytes at offset 4296657408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296661504 ++wrote 2048/2048 bytes at offset 4296661504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296665600 ++wrote 2048/2048 bytes at offset 4296665600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296669696 ++wrote 2048/2048 bytes at offset 4296669696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296673792 ++wrote 2048/2048 bytes at offset 4296673792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296677888 ++wrote 2048/2048 bytes at offset 4296677888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296681984 ++wrote 2048/2048 bytes at offset 4296681984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296686080 ++wrote 2048/2048 bytes at offset 4296686080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296690176 ++wrote 2048/2048 bytes at offset 4296690176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296694272 ++wrote 2048/2048 bytes at offset 4296694272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296698368 ++wrote 2048/2048 bytes at offset 4296698368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296702464 ++wrote 2048/2048 bytes at offset 4296702464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296706560 ++wrote 2048/2048 bytes at offset 4296706560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296710656 ++wrote 2048/2048 bytes at offset 4296710656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296714752 ++wrote 2048/2048 bytes at offset 4296714752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296718848 ++wrote 2048/2048 bytes at offset 4296718848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296722944 ++wrote 2048/2048 bytes at offset 4296722944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296727040 ++wrote 2048/2048 bytes at offset 4296727040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296731136 ++wrote 2048/2048 bytes at offset 4296731136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296735232 ++wrote 2048/2048 bytes at offset 4296735232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296739328 ++wrote 2048/2048 bytes at offset 4296739328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296743424 ++wrote 2048/2048 bytes at offset 4296743424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296747520 ++wrote 2048/2048 bytes at offset 4296747520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296751616 ++wrote 2048/2048 bytes at offset 4296751616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296755712 ++wrote 2048/2048 bytes at offset 4296755712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296759808 ++wrote 2048/2048 bytes at offset 4296759808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296763904 ++wrote 2048/2048 bytes at offset 4296763904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296768000 ++wrote 2048/2048 bytes at offset 4296768000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296772096 ++wrote 2048/2048 bytes at offset 4296772096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296776192 ++wrote 2048/2048 bytes at offset 4296776192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296780288 ++wrote 2048/2048 bytes at offset 4296780288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296784384 ++wrote 2048/2048 bytes at offset 4296784384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296788480 ++wrote 2048/2048 bytes at offset 4296788480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296792576 ++wrote 2048/2048 bytes at offset 4296792576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296796672 ++wrote 2048/2048 bytes at offset 4296796672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296800768 ++wrote 2048/2048 bytes at offset 4296800768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296804864 ++wrote 2048/2048 bytes at offset 4296804864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296808960 ++wrote 2048/2048 bytes at offset 4296808960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296813056 ++wrote 2048/2048 bytes at offset 4296813056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296817152 ++wrote 2048/2048 bytes at offset 4296817152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296821248 ++wrote 2048/2048 bytes at offset 4296821248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296825344 ++wrote 2048/2048 bytes at offset 4296825344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296829440 ++wrote 2048/2048 bytes at offset 4296829440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296833536 ++wrote 2048/2048 bytes at offset 4296833536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296837632 ++wrote 2048/2048 bytes at offset 4296837632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296841728 ++wrote 2048/2048 bytes at offset 4296841728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296845824 ++wrote 2048/2048 bytes at offset 4296845824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296849920 ++wrote 2048/2048 bytes at offset 4296849920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296854016 ++wrote 2048/2048 bytes at offset 4296854016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296858112 ++wrote 2048/2048 bytes at offset 4296858112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296862208 ++wrote 2048/2048 bytes at offset 4296862208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296866304 ++wrote 2048/2048 bytes at offset 4296866304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296870400 ++wrote 2048/2048 bytes at offset 4296870400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296874496 ++wrote 2048/2048 bytes at offset 4296874496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296878592 ++wrote 2048/2048 bytes at offset 4296878592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296882688 ++wrote 2048/2048 bytes at offset 4296882688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296886784 ++wrote 2048/2048 bytes at offset 4296886784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296890880 ++wrote 2048/2048 bytes at offset 4296890880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296894976 ++wrote 2048/2048 bytes at offset 4296894976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296899072 ++wrote 2048/2048 bytes at offset 4296899072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296903168 ++wrote 2048/2048 bytes at offset 4296903168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296907264 ++wrote 2048/2048 bytes at offset 4296907264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296911360 ++wrote 2048/2048 bytes at offset 4296911360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296915456 ++wrote 2048/2048 bytes at offset 4296915456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296919552 ++wrote 2048/2048 bytes at offset 4296919552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296923648 ++wrote 2048/2048 bytes at offset 4296923648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296927744 ++wrote 2048/2048 bytes at offset 4296927744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296931840 ++wrote 2048/2048 bytes at offset 4296931840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296935936 ++wrote 2048/2048 bytes at offset 4296935936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296940032 ++wrote 2048/2048 bytes at offset 4296940032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296944128 ++wrote 2048/2048 bytes at offset 4296944128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296948224 ++wrote 2048/2048 bytes at offset 4296948224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296952320 ++wrote 2048/2048 bytes at offset 4296952320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296956416 ++wrote 2048/2048 bytes at offset 4296956416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296960512 ++wrote 2048/2048 bytes at offset 4296960512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296964608 ++wrote 2048/2048 bytes at offset 4296964608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296968704 ++wrote 2048/2048 bytes at offset 4296968704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296972800 ++wrote 2048/2048 bytes at offset 4296972800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296976896 ++wrote 2048/2048 bytes at offset 4296976896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296980992 ++wrote 2048/2048 bytes at offset 4296980992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296985088 ++wrote 2048/2048 bytes at offset 4296985088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296989184 ++wrote 2048/2048 bytes at offset 4296989184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296993280 ++wrote 2048/2048 bytes at offset 4296993280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296997376 ++wrote 2048/2048 bytes at offset 4296997376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297001472 ++wrote 2048/2048 bytes at offset 4297001472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297005568 ++wrote 2048/2048 bytes at offset 4297005568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297009664 ++wrote 2048/2048 bytes at offset 4297009664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297013760 ++wrote 2048/2048 bytes at offset 4297013760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297017856 ++wrote 2048/2048 bytes at offset 4297017856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297021952 ++wrote 2048/2048 bytes at offset 4297021952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297026048 ++wrote 2048/2048 bytes at offset 4297026048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297030144 ++wrote 2048/2048 bytes at offset 4297030144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297034240 ++wrote 2048/2048 bytes at offset 4297034240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297038336 ++wrote 2048/2048 bytes at offset 4297038336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297042432 ++wrote 2048/2048 bytes at offset 4297042432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297046528 ++wrote 2048/2048 bytes at offset 4297046528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297050624 ++wrote 2048/2048 bytes at offset 4297050624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297054720 ++wrote 2048/2048 bytes at offset 4297054720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297058816 ++wrote 2048/2048 bytes at offset 4297058816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297062912 ++wrote 2048/2048 bytes at offset 4297062912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 1 +-qemu-io> wrote 2048/2048 bytes at offset 4297064960 ++=== IO: pattern 1 ++wrote 2048/2048 bytes at offset 4297064960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297069056 ++wrote 2048/2048 bytes at offset 4297069056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297073152 ++wrote 2048/2048 bytes at offset 4297073152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297077248 ++wrote 2048/2048 bytes at offset 4297077248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297081344 ++wrote 2048/2048 bytes at offset 4297081344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297085440 ++wrote 2048/2048 bytes at offset 4297085440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297089536 ++wrote 2048/2048 bytes at offset 4297089536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297093632 ++wrote 2048/2048 bytes at offset 4297093632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297097728 ++wrote 2048/2048 bytes at offset 4297097728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297101824 ++wrote 2048/2048 bytes at offset 4297101824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297105920 ++wrote 2048/2048 bytes at offset 4297105920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297110016 ++wrote 2048/2048 bytes at offset 4297110016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297114112 ++wrote 2048/2048 bytes at offset 4297114112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297118208 ++wrote 2048/2048 bytes at offset 4297118208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297122304 ++wrote 2048/2048 bytes at offset 4297122304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297126400 ++wrote 2048/2048 bytes at offset 4297126400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297130496 ++wrote 2048/2048 bytes at offset 4297130496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297134592 ++wrote 2048/2048 bytes at offset 4297134592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297138688 ++wrote 2048/2048 bytes at offset 4297138688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297142784 ++wrote 2048/2048 bytes at offset 4297142784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297146880 ++wrote 2048/2048 bytes at offset 4297146880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297150976 ++wrote 2048/2048 bytes at offset 4297150976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297155072 ++wrote 2048/2048 bytes at offset 4297155072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297159168 ++wrote 2048/2048 bytes at offset 4297159168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297163264 ++wrote 2048/2048 bytes at offset 4297163264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297167360 ++wrote 2048/2048 bytes at offset 4297167360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297171456 ++wrote 2048/2048 bytes at offset 4297171456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297175552 ++wrote 2048/2048 bytes at offset 4297175552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297179648 ++wrote 2048/2048 bytes at offset 4297179648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297183744 ++wrote 2048/2048 bytes at offset 4297183744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297187840 ++wrote 2048/2048 bytes at offset 4297187840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297191936 ++wrote 2048/2048 bytes at offset 4297191936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297196032 ++wrote 2048/2048 bytes at offset 4297196032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297200128 ++wrote 2048/2048 bytes at offset 4297200128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297204224 ++wrote 2048/2048 bytes at offset 4297204224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297208320 ++wrote 2048/2048 bytes at offset 4297208320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297212416 ++wrote 2048/2048 bytes at offset 4297212416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297216512 ++wrote 2048/2048 bytes at offset 4297216512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297220608 ++wrote 2048/2048 bytes at offset 4297220608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297224704 ++wrote 2048/2048 bytes at offset 4297224704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297228800 ++wrote 2048/2048 bytes at offset 4297228800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297232896 ++wrote 2048/2048 bytes at offset 4297232896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297236992 ++wrote 2048/2048 bytes at offset 4297236992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297241088 ++wrote 2048/2048 bytes at offset 4297241088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297245184 ++wrote 2048/2048 bytes at offset 4297245184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297249280 ++wrote 2048/2048 bytes at offset 4297249280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297253376 ++wrote 2048/2048 bytes at offset 4297253376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297257472 ++wrote 2048/2048 bytes at offset 4297257472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297261568 ++wrote 2048/2048 bytes at offset 4297261568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297265664 ++wrote 2048/2048 bytes at offset 4297265664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297269760 ++wrote 2048/2048 bytes at offset 4297269760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297273856 ++wrote 2048/2048 bytes at offset 4297273856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297277952 ++wrote 2048/2048 bytes at offset 4297277952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297282048 ++wrote 2048/2048 bytes at offset 4297282048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297286144 ++wrote 2048/2048 bytes at offset 4297286144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297290240 ++wrote 2048/2048 bytes at offset 4297290240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297294336 ++wrote 2048/2048 bytes at offset 4297294336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297298432 ++wrote 2048/2048 bytes at offset 4297298432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297302528 ++wrote 2048/2048 bytes at offset 4297302528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297306624 ++wrote 2048/2048 bytes at offset 4297306624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297310720 ++wrote 2048/2048 bytes at offset 4297310720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297314816 ++wrote 2048/2048 bytes at offset 4297314816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297318912 ++wrote 2048/2048 bytes at offset 4297318912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297323008 ++wrote 2048/2048 bytes at offset 4297323008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297327104 ++wrote 2048/2048 bytes at offset 4297327104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297331200 ++wrote 2048/2048 bytes at offset 4297331200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297335296 ++wrote 2048/2048 bytes at offset 4297335296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297339392 ++wrote 2048/2048 bytes at offset 4297339392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297343488 ++wrote 2048/2048 bytes at offset 4297343488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297347584 ++wrote 2048/2048 bytes at offset 4297347584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297351680 ++wrote 2048/2048 bytes at offset 4297351680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297355776 ++wrote 2048/2048 bytes at offset 4297355776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297359872 ++wrote 2048/2048 bytes at offset 4297359872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297363968 ++wrote 2048/2048 bytes at offset 4297363968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297368064 ++wrote 2048/2048 bytes at offset 4297368064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297372160 ++wrote 2048/2048 bytes at offset 4297372160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297376256 ++wrote 2048/2048 bytes at offset 4297376256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297380352 ++wrote 2048/2048 bytes at offset 4297380352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297384448 ++wrote 2048/2048 bytes at offset 4297384448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297388544 ++wrote 2048/2048 bytes at offset 4297388544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297392640 ++wrote 2048/2048 bytes at offset 4297392640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297396736 ++wrote 2048/2048 bytes at offset 4297396736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297400832 ++wrote 2048/2048 bytes at offset 4297400832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297404928 ++wrote 2048/2048 bytes at offset 4297404928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297409024 ++wrote 2048/2048 bytes at offset 4297409024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297413120 ++wrote 2048/2048 bytes at offset 4297413120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297417216 ++wrote 2048/2048 bytes at offset 4297417216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297421312 ++wrote 2048/2048 bytes at offset 4297421312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297425408 ++wrote 2048/2048 bytes at offset 4297425408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297429504 ++wrote 2048/2048 bytes at offset 4297429504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297433600 ++wrote 2048/2048 bytes at offset 4297433600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297437696 ++wrote 2048/2048 bytes at offset 4297437696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297441792 ++wrote 2048/2048 bytes at offset 4297441792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297445888 ++wrote 2048/2048 bytes at offset 4297445888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297449984 ++wrote 2048/2048 bytes at offset 4297449984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297454080 ++wrote 2048/2048 bytes at offset 4297454080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297458176 ++wrote 2048/2048 bytes at offset 4297458176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297462272 ++wrote 2048/2048 bytes at offset 4297462272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297466368 ++wrote 2048/2048 bytes at offset 4297466368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297470464 ++wrote 2048/2048 bytes at offset 4297470464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297474560 ++wrote 2048/2048 bytes at offset 4297474560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297478656 ++wrote 2048/2048 bytes at offset 4297478656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297482752 ++wrote 2048/2048 bytes at offset 4297482752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297486848 ++wrote 2048/2048 bytes at offset 4297486848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297490944 ++wrote 2048/2048 bytes at offset 4297490944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297495040 ++wrote 2048/2048 bytes at offset 4297495040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297499136 ++wrote 2048/2048 bytes at offset 4297499136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297503232 ++wrote 2048/2048 bytes at offset 4297503232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297507328 ++wrote 2048/2048 bytes at offset 4297507328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297511424 ++wrote 2048/2048 bytes at offset 4297511424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297515520 ++wrote 2048/2048 bytes at offset 4297515520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297519616 ++wrote 2048/2048 bytes at offset 4297519616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297523712 ++wrote 2048/2048 bytes at offset 4297523712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297527808 ++wrote 2048/2048 bytes at offset 4297527808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297531904 ++wrote 2048/2048 bytes at offset 4297531904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297536000 ++wrote 2048/2048 bytes at offset 4297536000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297540096 ++wrote 2048/2048 bytes at offset 4297540096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297544192 ++wrote 2048/2048 bytes at offset 4297544192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297548288 ++wrote 2048/2048 bytes at offset 4297548288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297552384 ++wrote 2048/2048 bytes at offset 4297552384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297556480 ++wrote 2048/2048 bytes at offset 4297556480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297560576 ++wrote 2048/2048 bytes at offset 4297560576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297564672 ++wrote 2048/2048 bytes at offset 4297564672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297568768 ++wrote 2048/2048 bytes at offset 4297568768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297572864 ++wrote 2048/2048 bytes at offset 4297572864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297576960 ++wrote 2048/2048 bytes at offset 4297576960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297581056 ++wrote 2048/2048 bytes at offset 4297581056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297585152 ++wrote 2048/2048 bytes at offset 4297585152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297589248 ++wrote 2048/2048 bytes at offset 4297589248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297593344 ++wrote 2048/2048 bytes at offset 4297593344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297597440 ++wrote 2048/2048 bytes at offset 4297597440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297601536 ++wrote 2048/2048 bytes at offset 4297601536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297605632 ++wrote 2048/2048 bytes at offset 4297605632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297609728 ++wrote 2048/2048 bytes at offset 4297609728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297613824 ++wrote 2048/2048 bytes at offset 4297613824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297617920 ++wrote 2048/2048 bytes at offset 4297617920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297622016 ++wrote 2048/2048 bytes at offset 4297622016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297626112 ++wrote 2048/2048 bytes at offset 4297626112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297630208 ++wrote 2048/2048 bytes at offset 4297630208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297634304 ++wrote 2048/2048 bytes at offset 4297634304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297638400 ++wrote 2048/2048 bytes at offset 4297638400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297642496 ++wrote 2048/2048 bytes at offset 4297642496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297646592 ++wrote 2048/2048 bytes at offset 4297646592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297650688 ++wrote 2048/2048 bytes at offset 4297650688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297654784 ++wrote 2048/2048 bytes at offset 4297654784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297658880 ++wrote 2048/2048 bytes at offset 4297658880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297662976 ++wrote 2048/2048 bytes at offset 4297662976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297667072 ++wrote 2048/2048 bytes at offset 4297667072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297671168 ++wrote 2048/2048 bytes at offset 4297671168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297675264 ++wrote 2048/2048 bytes at offset 4297675264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297679360 ++wrote 2048/2048 bytes at offset 4297679360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297683456 ++wrote 2048/2048 bytes at offset 4297683456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297687552 ++wrote 2048/2048 bytes at offset 4297687552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297691648 ++wrote 2048/2048 bytes at offset 4297691648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297695744 ++wrote 2048/2048 bytes at offset 4297695744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297699840 ++wrote 2048/2048 bytes at offset 4297699840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297703936 ++wrote 2048/2048 bytes at offset 4297703936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297708032 ++wrote 2048/2048 bytes at offset 4297708032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297712128 ++wrote 2048/2048 bytes at offset 4297712128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297716224 ++wrote 2048/2048 bytes at offset 4297716224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297720320 ++wrote 2048/2048 bytes at offset 4297720320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297724416 ++wrote 2048/2048 bytes at offset 4297724416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297728512 ++wrote 2048/2048 bytes at offset 4297728512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297732608 ++wrote 2048/2048 bytes at offset 4297732608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297736704 ++wrote 2048/2048 bytes at offset 4297736704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297740800 ++wrote 2048/2048 bytes at offset 4297740800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297744896 ++wrote 2048/2048 bytes at offset 4297744896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297748992 ++wrote 2048/2048 bytes at offset 4297748992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297753088 ++wrote 2048/2048 bytes at offset 4297753088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297757184 ++wrote 2048/2048 bytes at offset 4297757184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297761280 ++wrote 2048/2048 bytes at offset 4297761280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297765376 ++wrote 2048/2048 bytes at offset 4297765376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297769472 ++wrote 2048/2048 bytes at offset 4297769472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297773568 ++wrote 2048/2048 bytes at offset 4297773568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297777664 ++wrote 2048/2048 bytes at offset 4297777664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297781760 ++wrote 2048/2048 bytes at offset 4297781760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297785856 ++wrote 2048/2048 bytes at offset 4297785856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297789952 ++wrote 2048/2048 bytes at offset 4297789952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297794048 ++wrote 2048/2048 bytes at offset 4297794048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297798144 ++wrote 2048/2048 bytes at offset 4297798144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297802240 ++wrote 2048/2048 bytes at offset 4297802240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297806336 ++wrote 2048/2048 bytes at offset 4297806336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297810432 ++wrote 2048/2048 bytes at offset 4297810432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297814528 ++wrote 2048/2048 bytes at offset 4297814528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297818624 ++wrote 2048/2048 bytes at offset 4297818624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297822720 ++wrote 2048/2048 bytes at offset 4297822720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297826816 ++wrote 2048/2048 bytes at offset 4297826816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297830912 ++wrote 2048/2048 bytes at offset 4297830912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297835008 ++wrote 2048/2048 bytes at offset 4297835008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297839104 ++wrote 2048/2048 bytes at offset 4297839104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297843200 ++wrote 2048/2048 bytes at offset 4297843200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297847296 ++wrote 2048/2048 bytes at offset 4297847296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297851392 ++wrote 2048/2048 bytes at offset 4297851392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297855488 ++wrote 2048/2048 bytes at offset 4297855488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297859584 ++wrote 2048/2048 bytes at offset 4297859584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297863680 ++wrote 2048/2048 bytes at offset 4297863680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297867776 ++wrote 2048/2048 bytes at offset 4297867776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297871872 ++wrote 2048/2048 bytes at offset 4297871872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297875968 ++wrote 2048/2048 bytes at offset 4297875968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297880064 ++wrote 2048/2048 bytes at offset 4297880064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297884160 ++wrote 2048/2048 bytes at offset 4297884160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297888256 ++wrote 2048/2048 bytes at offset 4297888256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297892352 ++wrote 2048/2048 bytes at offset 4297892352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297896448 ++wrote 2048/2048 bytes at offset 4297896448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297900544 ++wrote 2048/2048 bytes at offset 4297900544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297904640 ++wrote 2048/2048 bytes at offset 4297904640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297908736 ++wrote 2048/2048 bytes at offset 4297908736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297912832 ++wrote 2048/2048 bytes at offset 4297912832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297916928 ++wrote 2048/2048 bytes at offset 4297916928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297921024 ++wrote 2048/2048 bytes at offset 4297921024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297925120 ++wrote 2048/2048 bytes at offset 4297925120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297929216 ++wrote 2048/2048 bytes at offset 4297929216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297933312 ++wrote 2048/2048 bytes at offset 4297933312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297937408 ++wrote 2048/2048 bytes at offset 4297937408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297941504 ++wrote 2048/2048 bytes at offset 4297941504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297945600 ++wrote 2048/2048 bytes at offset 4297945600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297949696 ++wrote 2048/2048 bytes at offset 4297949696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297953792 ++wrote 2048/2048 bytes at offset 4297953792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297957888 ++wrote 2048/2048 bytes at offset 4297957888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297961984 ++wrote 2048/2048 bytes at offset 4297961984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297966080 ++wrote 2048/2048 bytes at offset 4297966080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297970176 ++wrote 2048/2048 bytes at offset 4297970176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297974272 ++wrote 2048/2048 bytes at offset 4297974272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297978368 ++wrote 2048/2048 bytes at offset 4297978368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297982464 ++wrote 2048/2048 bytes at offset 4297982464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297986560 ++wrote 2048/2048 bytes at offset 4297986560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297990656 ++wrote 2048/2048 bytes at offset 4297990656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297994752 ++wrote 2048/2048 bytes at offset 4297994752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297998848 ++wrote 2048/2048 bytes at offset 4297998848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298002944 ++wrote 2048/2048 bytes at offset 4298002944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298007040 ++wrote 2048/2048 bytes at offset 4298007040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298011136 ++wrote 2048/2048 bytes at offset 4298011136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298015232 ++wrote 2048/2048 bytes at offset 4298015232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298019328 ++wrote 2048/2048 bytes at offset 4298019328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298023424 ++wrote 2048/2048 bytes at offset 4298023424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298027520 ++wrote 2048/2048 bytes at offset 4298027520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298031616 ++wrote 2048/2048 bytes at offset 4298031616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298035712 ++wrote 2048/2048 bytes at offset 4298035712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298039808 ++wrote 2048/2048 bytes at offset 4298039808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298043904 ++wrote 2048/2048 bytes at offset 4298043904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298048000 ++wrote 2048/2048 bytes at offset 4298048000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298052096 ++wrote 2048/2048 bytes at offset 4298052096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298056192 ++wrote 2048/2048 bytes at offset 4298056192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298060288 ++wrote 2048/2048 bytes at offset 4298060288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298064384 ++wrote 2048/2048 bytes at offset 4298064384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298068480 ++wrote 2048/2048 bytes at offset 4298068480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298072576 ++wrote 2048/2048 bytes at offset 4298072576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298076672 ++wrote 2048/2048 bytes at offset 4298076672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298080768 ++wrote 2048/2048 bytes at offset 4298080768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298084864 ++wrote 2048/2048 bytes at offset 4298084864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298088960 ++wrote 2048/2048 bytes at offset 4298088960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298093056 ++wrote 2048/2048 bytes at offset 4298093056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298097152 ++wrote 2048/2048 bytes at offset 4298097152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298101248 ++wrote 2048/2048 bytes at offset 4298101248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298105344 ++wrote 2048/2048 bytes at offset 4298105344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298109440 ++wrote 2048/2048 bytes at offset 4298109440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 3 +-qemu-io> wrote 2048/2048 bytes at offset 4298114560 ++=== IO: pattern 3 ++wrote 2048/2048 bytes at offset 4298114560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298118656 ++wrote 2048/2048 bytes at offset 4298118656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298122752 ++wrote 2048/2048 bytes at offset 4298122752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298126848 ++wrote 2048/2048 bytes at offset 4298126848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298130944 ++wrote 2048/2048 bytes at offset 4298130944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298135040 ++wrote 2048/2048 bytes at offset 4298135040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298139136 ++wrote 2048/2048 bytes at offset 4298139136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298143232 ++wrote 2048/2048 bytes at offset 4298143232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298147328 ++wrote 2048/2048 bytes at offset 4298147328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298151424 ++wrote 2048/2048 bytes at offset 4298151424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298155520 ++wrote 2048/2048 bytes at offset 4298155520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298159616 ++wrote 2048/2048 bytes at offset 4298159616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298163712 ++wrote 2048/2048 bytes at offset 4298163712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298167808 ++wrote 2048/2048 bytes at offset 4298167808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298171904 ++wrote 2048/2048 bytes at offset 4298171904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298176000 ++wrote 2048/2048 bytes at offset 4298176000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298180096 ++wrote 2048/2048 bytes at offset 4298180096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298184192 ++wrote 2048/2048 bytes at offset 4298184192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298188288 ++wrote 2048/2048 bytes at offset 4298188288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298192384 ++wrote 2048/2048 bytes at offset 4298192384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298196480 ++wrote 2048/2048 bytes at offset 4298196480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298200576 ++wrote 2048/2048 bytes at offset 4298200576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298204672 ++wrote 2048/2048 bytes at offset 4298204672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298208768 ++wrote 2048/2048 bytes at offset 4298208768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298212864 ++wrote 2048/2048 bytes at offset 4298212864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298216960 ++wrote 2048/2048 bytes at offset 4298216960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298221056 ++wrote 2048/2048 bytes at offset 4298221056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298225152 ++wrote 2048/2048 bytes at offset 4298225152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298229248 ++wrote 2048/2048 bytes at offset 4298229248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298233344 ++wrote 2048/2048 bytes at offset 4298233344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298237440 ++wrote 2048/2048 bytes at offset 4298237440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298241536 ++wrote 2048/2048 bytes at offset 4298241536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298245632 ++wrote 2048/2048 bytes at offset 4298245632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298249728 ++wrote 2048/2048 bytes at offset 4298249728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298253824 ++wrote 2048/2048 bytes at offset 4298253824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298257920 ++wrote 2048/2048 bytes at offset 4298257920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298262016 ++wrote 2048/2048 bytes at offset 4298262016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298266112 ++wrote 2048/2048 bytes at offset 4298266112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298270208 ++wrote 2048/2048 bytes at offset 4298270208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298274304 ++wrote 2048/2048 bytes at offset 4298274304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298278400 ++wrote 2048/2048 bytes at offset 4298278400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298282496 ++wrote 2048/2048 bytes at offset 4298282496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298286592 ++wrote 2048/2048 bytes at offset 4298286592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298290688 ++wrote 2048/2048 bytes at offset 4298290688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298294784 ++wrote 2048/2048 bytes at offset 4298294784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298298880 ++wrote 2048/2048 bytes at offset 4298298880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298302976 ++wrote 2048/2048 bytes at offset 4298302976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298307072 ++wrote 2048/2048 bytes at offset 4298307072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298311168 ++wrote 2048/2048 bytes at offset 4298311168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298315264 ++wrote 2048/2048 bytes at offset 4298315264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298319360 ++wrote 2048/2048 bytes at offset 4298319360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298323456 ++wrote 2048/2048 bytes at offset 4298323456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298327552 ++wrote 2048/2048 bytes at offset 4298327552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298331648 ++wrote 2048/2048 bytes at offset 4298331648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298335744 ++wrote 2048/2048 bytes at offset 4298335744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298339840 ++wrote 2048/2048 bytes at offset 4298339840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298343936 ++wrote 2048/2048 bytes at offset 4298343936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298348032 ++wrote 2048/2048 bytes at offset 4298348032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298352128 ++wrote 2048/2048 bytes at offset 4298352128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298356224 ++wrote 2048/2048 bytes at offset 4298356224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298360320 ++wrote 2048/2048 bytes at offset 4298360320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298364416 ++wrote 2048/2048 bytes at offset 4298364416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298368512 ++wrote 2048/2048 bytes at offset 4298368512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298372608 ++wrote 2048/2048 bytes at offset 4298372608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298376704 ++wrote 2048/2048 bytes at offset 4298376704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298380800 ++wrote 2048/2048 bytes at offset 4298380800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298384896 ++wrote 2048/2048 bytes at offset 4298384896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298388992 ++wrote 2048/2048 bytes at offset 4298388992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298393088 ++wrote 2048/2048 bytes at offset 4298393088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298397184 ++wrote 2048/2048 bytes at offset 4298397184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298401280 ++wrote 2048/2048 bytes at offset 4298401280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298405376 ++wrote 2048/2048 bytes at offset 4298405376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298409472 ++wrote 2048/2048 bytes at offset 4298409472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298413568 ++wrote 2048/2048 bytes at offset 4298413568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298417664 ++wrote 2048/2048 bytes at offset 4298417664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298421760 ++wrote 2048/2048 bytes at offset 4298421760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298425856 ++wrote 2048/2048 bytes at offset 4298425856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298429952 ++wrote 2048/2048 bytes at offset 4298429952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298434048 ++wrote 2048/2048 bytes at offset 4298434048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298438144 ++wrote 2048/2048 bytes at offset 4298438144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298442240 ++wrote 2048/2048 bytes at offset 4298442240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298446336 ++wrote 2048/2048 bytes at offset 4298446336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298450432 ++wrote 2048/2048 bytes at offset 4298450432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298454528 ++wrote 2048/2048 bytes at offset 4298454528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298458624 ++wrote 2048/2048 bytes at offset 4298458624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298462720 ++wrote 2048/2048 bytes at offset 4298462720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298466816 ++wrote 2048/2048 bytes at offset 4298466816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298470912 ++wrote 2048/2048 bytes at offset 4298470912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298475008 ++wrote 2048/2048 bytes at offset 4298475008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298479104 ++wrote 2048/2048 bytes at offset 4298479104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298483200 ++wrote 2048/2048 bytes at offset 4298483200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298487296 ++wrote 2048/2048 bytes at offset 4298487296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298491392 ++wrote 2048/2048 bytes at offset 4298491392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298495488 ++wrote 2048/2048 bytes at offset 4298495488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298499584 ++wrote 2048/2048 bytes at offset 4298499584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298503680 ++wrote 2048/2048 bytes at offset 4298503680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298507776 ++wrote 2048/2048 bytes at offset 4298507776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298511872 ++wrote 2048/2048 bytes at offset 4298511872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298515968 ++wrote 2048/2048 bytes at offset 4298515968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298520064 ++wrote 2048/2048 bytes at offset 4298520064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298524160 ++wrote 2048/2048 bytes at offset 4298524160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298528256 ++wrote 2048/2048 bytes at offset 4298528256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298532352 ++wrote 2048/2048 bytes at offset 4298532352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298536448 ++wrote 2048/2048 bytes at offset 4298536448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298540544 ++wrote 2048/2048 bytes at offset 4298540544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298544640 ++wrote 2048/2048 bytes at offset 4298544640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298548736 ++wrote 2048/2048 bytes at offset 4298548736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298552832 ++wrote 2048/2048 bytes at offset 4298552832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298556928 ++wrote 2048/2048 bytes at offset 4298556928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298561024 ++wrote 2048/2048 bytes at offset 4298561024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298565120 ++wrote 2048/2048 bytes at offset 4298565120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298569216 ++wrote 2048/2048 bytes at offset 4298569216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298573312 ++wrote 2048/2048 bytes at offset 4298573312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298577408 ++wrote 2048/2048 bytes at offset 4298577408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298581504 ++wrote 2048/2048 bytes at offset 4298581504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298585600 ++wrote 2048/2048 bytes at offset 4298585600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298589696 ++wrote 2048/2048 bytes at offset 4298589696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298593792 ++wrote 2048/2048 bytes at offset 4298593792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298597888 ++wrote 2048/2048 bytes at offset 4298597888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298601984 ++wrote 2048/2048 bytes at offset 4298601984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298606080 ++wrote 2048/2048 bytes at offset 4298606080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298610176 ++wrote 2048/2048 bytes at offset 4298610176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298614272 ++wrote 2048/2048 bytes at offset 4298614272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298618368 ++wrote 2048/2048 bytes at offset 4298618368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298622464 ++wrote 2048/2048 bytes at offset 4298622464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298626560 ++wrote 2048/2048 bytes at offset 4298626560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298630656 ++wrote 2048/2048 bytes at offset 4298630656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298634752 ++wrote 2048/2048 bytes at offset 4298634752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298638848 ++wrote 2048/2048 bytes at offset 4298638848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298642944 ++wrote 2048/2048 bytes at offset 4298642944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298647040 ++wrote 2048/2048 bytes at offset 4298647040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298651136 ++wrote 2048/2048 bytes at offset 4298651136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298655232 ++wrote 2048/2048 bytes at offset 4298655232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298659328 ++wrote 2048/2048 bytes at offset 4298659328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298663424 ++wrote 2048/2048 bytes at offset 4298663424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298667520 ++wrote 2048/2048 bytes at offset 4298667520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298671616 ++wrote 2048/2048 bytes at offset 4298671616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298675712 ++wrote 2048/2048 bytes at offset 4298675712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298679808 ++wrote 2048/2048 bytes at offset 4298679808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298683904 ++wrote 2048/2048 bytes at offset 4298683904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298688000 ++wrote 2048/2048 bytes at offset 4298688000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298692096 ++wrote 2048/2048 bytes at offset 4298692096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298696192 ++wrote 2048/2048 bytes at offset 4298696192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298700288 ++wrote 2048/2048 bytes at offset 4298700288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298704384 ++wrote 2048/2048 bytes at offset 4298704384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298708480 ++wrote 2048/2048 bytes at offset 4298708480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298712576 ++wrote 2048/2048 bytes at offset 4298712576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298716672 ++wrote 2048/2048 bytes at offset 4298716672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298720768 ++wrote 2048/2048 bytes at offset 4298720768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298724864 ++wrote 2048/2048 bytes at offset 4298724864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298728960 ++wrote 2048/2048 bytes at offset 4298728960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298733056 ++wrote 2048/2048 bytes at offset 4298733056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298737152 ++wrote 2048/2048 bytes at offset 4298737152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298741248 ++wrote 2048/2048 bytes at offset 4298741248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298745344 ++wrote 2048/2048 bytes at offset 4298745344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298749440 ++wrote 2048/2048 bytes at offset 4298749440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298753536 ++wrote 2048/2048 bytes at offset 4298753536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298757632 ++wrote 2048/2048 bytes at offset 4298757632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298761728 ++wrote 2048/2048 bytes at offset 4298761728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298765824 ++wrote 2048/2048 bytes at offset 4298765824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298769920 ++wrote 2048/2048 bytes at offset 4298769920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298774016 ++wrote 2048/2048 bytes at offset 4298774016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298778112 ++wrote 2048/2048 bytes at offset 4298778112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298782208 ++wrote 2048/2048 bytes at offset 4298782208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298786304 ++wrote 2048/2048 bytes at offset 4298786304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298790400 ++wrote 2048/2048 bytes at offset 4298790400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298794496 ++wrote 2048/2048 bytes at offset 4298794496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298798592 ++wrote 2048/2048 bytes at offset 4298798592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298802688 ++wrote 2048/2048 bytes at offset 4298802688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298806784 ++wrote 2048/2048 bytes at offset 4298806784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298810880 ++wrote 2048/2048 bytes at offset 4298810880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298814976 ++wrote 2048/2048 bytes at offset 4298814976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298819072 ++wrote 2048/2048 bytes at offset 4298819072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298823168 ++wrote 2048/2048 bytes at offset 4298823168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298827264 ++wrote 2048/2048 bytes at offset 4298827264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298831360 ++wrote 2048/2048 bytes at offset 4298831360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298835456 ++wrote 2048/2048 bytes at offset 4298835456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298839552 ++wrote 2048/2048 bytes at offset 4298839552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298843648 ++wrote 2048/2048 bytes at offset 4298843648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298847744 ++wrote 2048/2048 bytes at offset 4298847744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298851840 ++wrote 2048/2048 bytes at offset 4298851840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298855936 ++wrote 2048/2048 bytes at offset 4298855936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298860032 ++wrote 2048/2048 bytes at offset 4298860032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298864128 ++wrote 2048/2048 bytes at offset 4298864128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298868224 ++wrote 2048/2048 bytes at offset 4298868224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298872320 ++wrote 2048/2048 bytes at offset 4298872320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298876416 ++wrote 2048/2048 bytes at offset 4298876416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298880512 ++wrote 2048/2048 bytes at offset 4298880512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298884608 ++wrote 2048/2048 bytes at offset 4298884608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298888704 ++wrote 2048/2048 bytes at offset 4298888704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298892800 ++wrote 2048/2048 bytes at offset 4298892800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298896896 ++wrote 2048/2048 bytes at offset 4298896896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298900992 ++wrote 2048/2048 bytes at offset 4298900992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298905088 ++wrote 2048/2048 bytes at offset 4298905088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298909184 ++wrote 2048/2048 bytes at offset 4298909184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298913280 ++wrote 2048/2048 bytes at offset 4298913280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298917376 ++wrote 2048/2048 bytes at offset 4298917376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298921472 ++wrote 2048/2048 bytes at offset 4298921472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298925568 ++wrote 2048/2048 bytes at offset 4298925568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298929664 ++wrote 2048/2048 bytes at offset 4298929664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298933760 ++wrote 2048/2048 bytes at offset 4298933760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298937856 ++wrote 2048/2048 bytes at offset 4298937856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298941952 ++wrote 2048/2048 bytes at offset 4298941952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298946048 ++wrote 2048/2048 bytes at offset 4298946048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298950144 ++wrote 2048/2048 bytes at offset 4298950144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298954240 ++wrote 2048/2048 bytes at offset 4298954240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298958336 ++wrote 2048/2048 bytes at offset 4298958336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298962432 ++wrote 2048/2048 bytes at offset 4298962432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298966528 ++wrote 2048/2048 bytes at offset 4298966528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298970624 ++wrote 2048/2048 bytes at offset 4298970624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298974720 ++wrote 2048/2048 bytes at offset 4298974720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298978816 ++wrote 2048/2048 bytes at offset 4298978816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298982912 ++wrote 2048/2048 bytes at offset 4298982912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298987008 ++wrote 2048/2048 bytes at offset 4298987008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298991104 ++wrote 2048/2048 bytes at offset 4298991104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298995200 ++wrote 2048/2048 bytes at offset 4298995200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298999296 ++wrote 2048/2048 bytes at offset 4298999296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299003392 ++wrote 2048/2048 bytes at offset 4299003392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299007488 ++wrote 2048/2048 bytes at offset 4299007488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299011584 ++wrote 2048/2048 bytes at offset 4299011584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299015680 ++wrote 2048/2048 bytes at offset 4299015680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299019776 ++wrote 2048/2048 bytes at offset 4299019776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299023872 ++wrote 2048/2048 bytes at offset 4299023872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299027968 ++wrote 2048/2048 bytes at offset 4299027968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299032064 ++wrote 2048/2048 bytes at offset 4299032064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299036160 ++wrote 2048/2048 bytes at offset 4299036160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299040256 ++wrote 2048/2048 bytes at offset 4299040256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299044352 ++wrote 2048/2048 bytes at offset 4299044352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299048448 ++wrote 2048/2048 bytes at offset 4299048448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299052544 ++wrote 2048/2048 bytes at offset 4299052544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299056640 ++wrote 2048/2048 bytes at offset 4299056640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299060736 ++wrote 2048/2048 bytes at offset 4299060736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299064832 ++wrote 2048/2048 bytes at offset 4299064832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299068928 ++wrote 2048/2048 bytes at offset 4299068928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299073024 ++wrote 2048/2048 bytes at offset 4299073024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299077120 ++wrote 2048/2048 bytes at offset 4299077120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299081216 ++wrote 2048/2048 bytes at offset 4299081216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299085312 ++wrote 2048/2048 bytes at offset 4299085312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299089408 ++wrote 2048/2048 bytes at offset 4299089408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299093504 ++wrote 2048/2048 bytes at offset 4299093504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299097600 ++wrote 2048/2048 bytes at offset 4299097600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299101696 ++wrote 2048/2048 bytes at offset 4299101696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299105792 ++wrote 2048/2048 bytes at offset 4299105792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299109888 ++wrote 2048/2048 bytes at offset 4299109888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299113984 ++wrote 2048/2048 bytes at offset 4299113984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299118080 ++wrote 2048/2048 bytes at offset 4299118080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299122176 ++wrote 2048/2048 bytes at offset 4299122176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299126272 ++wrote 2048/2048 bytes at offset 4299126272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299130368 ++wrote 2048/2048 bytes at offset 4299130368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299134464 ++wrote 2048/2048 bytes at offset 4299134464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299138560 ++wrote 2048/2048 bytes at offset 4299138560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299142656 ++wrote 2048/2048 bytes at offset 4299142656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299146752 ++wrote 2048/2048 bytes at offset 4299146752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299150848 ++wrote 2048/2048 bytes at offset 4299150848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299154944 ++wrote 2048/2048 bytes at offset 4299154944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299159040 ++wrote 2048/2048 bytes at offset 4299159040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 5 +-qemu-io> wrote 8192/8192 bytes at offset 4299164160 ++=== IO: pattern 5 ++wrote 8192/8192 bytes at offset 4299164160 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299176448 ++wrote 8192/8192 bytes at offset 4299176448 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299188736 ++wrote 8192/8192 bytes at offset 4299188736 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299201024 ++wrote 8192/8192 bytes at offset 4299201024 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299213312 ++wrote 8192/8192 bytes at offset 4299213312 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299225600 ++wrote 8192/8192 bytes at offset 4299225600 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299237888 ++wrote 8192/8192 bytes at offset 4299237888 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299250176 ++wrote 8192/8192 bytes at offset 4299250176 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299262464 ++wrote 8192/8192 bytes at offset 4299262464 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299274752 ++wrote 8192/8192 bytes at offset 4299274752 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299287040 ++wrote 8192/8192 bytes at offset 4299287040 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299299328 ++wrote 8192/8192 bytes at offset 4299299328 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299311616 ++wrote 8192/8192 bytes at offset 4299311616 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299323904 ++wrote 8192/8192 bytes at offset 4299323904 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299336192 ++wrote 8192/8192 bytes at offset 4299336192 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299348480 ++wrote 8192/8192 bytes at offset 4299348480 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299360768 ++wrote 8192/8192 bytes at offset 4299360768 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299373056 ++wrote 8192/8192 bytes at offset 4299373056 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299385344 ++wrote 8192/8192 bytes at offset 4299385344 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299397632 ++wrote 8192/8192 bytes at offset 4299397632 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299409920 ++wrote 8192/8192 bytes at offset 4299409920 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299422208 ++wrote 8192/8192 bytes at offset 4299422208 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299434496 ++wrote 8192/8192 bytes at offset 4299434496 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299446784 ++wrote 8192/8192 bytes at offset 4299446784 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299459072 ++wrote 8192/8192 bytes at offset 4299459072 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299471360 ++wrote 8192/8192 bytes at offset 4299471360 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299483648 ++wrote 8192/8192 bytes at offset 4299483648 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299495936 ++wrote 8192/8192 bytes at offset 4299495936 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299508224 ++wrote 8192/8192 bytes at offset 4299508224 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299520512 ++wrote 8192/8192 bytes at offset 4299520512 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299532800 ++wrote 8192/8192 bytes at offset 4299532800 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299545088 ++wrote 8192/8192 bytes at offset 4299545088 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299557376 ++wrote 8192/8192 bytes at offset 4299557376 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299569664 ++wrote 8192/8192 bytes at offset 4299569664 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299581952 ++wrote 8192/8192 bytes at offset 4299581952 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299594240 ++wrote 8192/8192 bytes at offset 4299594240 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299606528 ++wrote 8192/8192 bytes at offset 4299606528 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299618816 ++wrote 8192/8192 bytes at offset 4299618816 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299631104 ++wrote 8192/8192 bytes at offset 4299631104 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299643392 ++wrote 8192/8192 bytes at offset 4299643392 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299655680 ++wrote 8192/8192 bytes at offset 4299655680 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299667968 ++wrote 8192/8192 bytes at offset 4299667968 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299680256 ++wrote 8192/8192 bytes at offset 4299680256 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299692544 ++wrote 8192/8192 bytes at offset 4299692544 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299704832 ++wrote 8192/8192 bytes at offset 4299704832 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299717120 ++wrote 8192/8192 bytes at offset 4299717120 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299729408 ++wrote 8192/8192 bytes at offset 4299729408 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299741696 ++wrote 8192/8192 bytes at offset 4299741696 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299753984 ++wrote 8192/8192 bytes at offset 4299753984 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299766272 ++wrote 8192/8192 bytes at offset 4299766272 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299778560 ++wrote 8192/8192 bytes at offset 4299778560 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299790848 ++wrote 8192/8192 bytes at offset 4299790848 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299803136 ++wrote 8192/8192 bytes at offset 4299803136 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299815424 ++wrote 8192/8192 bytes at offset 4299815424 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299827712 ++wrote 8192/8192 bytes at offset 4299827712 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299840000 ++wrote 8192/8192 bytes at offset 4299840000 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299852288 ++wrote 8192/8192 bytes at offset 4299852288 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299864576 ++wrote 8192/8192 bytes at offset 4299864576 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299876864 ++wrote 8192/8192 bytes at offset 4299876864 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299889152 ++wrote 8192/8192 bytes at offset 4299889152 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299901440 ++wrote 8192/8192 bytes at offset 4299901440 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299913728 ++wrote 8192/8192 bytes at offset 4299913728 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299926016 ++wrote 8192/8192 bytes at offset 4299926016 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299938304 ++wrote 8192/8192 bytes at offset 4299938304 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 244 +-qemu-io> wrote 12288/12288 bytes at offset 4301252608 ++=== IO: pattern 244 ++wrote 12288/12288 bytes at offset 4301252608 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 4303351808 ++wrote 12288/12288 bytes at offset 4303351808 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 4305451008 ++wrote 12288/12288 bytes at offset 4305451008 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 4307550208 ++wrote 12288/12288 bytes at offset 4307550208 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 4309649408 ++wrote 12288/12288 bytes at offset 4309649408 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 4311748608 ++wrote 12288/12288 bytes at offset 4311748608 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 4313847808 ++wrote 12288/12288 bytes at offset 4313847808 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 4315947008 ++wrote 12288/12288 bytes at offset 4315947008 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 1 +-qemu-io> read 4096/4096 bytes at offset 4294967808 ++=== IO: pattern 1 ++read 4096/4096 bytes at offset 4294967808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294971904 ++read 4096/4096 bytes at offset 4294971904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294976000 ++read 4096/4096 bytes at offset 4294976000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294980096 ++read 4096/4096 bytes at offset 4294980096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294984192 ++read 4096/4096 bytes at offset 4294984192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294988288 ++read 4096/4096 bytes at offset 4294988288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294992384 ++read 4096/4096 bytes at offset 4294992384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294996480 ++read 4096/4096 bytes at offset 4294996480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295000576 ++read 4096/4096 bytes at offset 4295000576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295004672 ++read 4096/4096 bytes at offset 4295004672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295008768 ++read 4096/4096 bytes at offset 4295008768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295012864 ++read 4096/4096 bytes at offset 4295012864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295016960 ++read 4096/4096 bytes at offset 4295016960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295021056 ++read 4096/4096 bytes at offset 4295021056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295025152 ++read 4096/4096 bytes at offset 4295025152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295029248 ++read 4096/4096 bytes at offset 4295029248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295033344 ++read 4096/4096 bytes at offset 4295033344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295037440 ++read 4096/4096 bytes at offset 4295037440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295041536 ++read 4096/4096 bytes at offset 4295041536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295045632 ++read 4096/4096 bytes at offset 4295045632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295049728 ++read 4096/4096 bytes at offset 4295049728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295053824 ++read 4096/4096 bytes at offset 4295053824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295057920 ++read 4096/4096 bytes at offset 4295057920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295062016 ++read 4096/4096 bytes at offset 4295062016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295066112 ++read 4096/4096 bytes at offset 4295066112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295070208 ++read 4096/4096 bytes at offset 4295070208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295074304 ++read 4096/4096 bytes at offset 4295074304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295078400 ++read 4096/4096 bytes at offset 4295078400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295082496 ++read 4096/4096 bytes at offset 4295082496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295086592 ++read 4096/4096 bytes at offset 4295086592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295090688 ++read 4096/4096 bytes at offset 4295090688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295094784 ++read 4096/4096 bytes at offset 4295094784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295098880 ++read 4096/4096 bytes at offset 4295098880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295102976 ++read 4096/4096 bytes at offset 4295102976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295107072 ++read 4096/4096 bytes at offset 4295107072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295111168 ++read 4096/4096 bytes at offset 4295111168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295115264 ++read 4096/4096 bytes at offset 4295115264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295119360 ++read 4096/4096 bytes at offset 4295119360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295123456 ++read 4096/4096 bytes at offset 4295123456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295127552 ++read 4096/4096 bytes at offset 4295127552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295131648 ++read 4096/4096 bytes at offset 4295131648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295135744 ++read 4096/4096 bytes at offset 4295135744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295139840 ++read 4096/4096 bytes at offset 4295139840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295143936 ++read 4096/4096 bytes at offset 4295143936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295148032 ++read 4096/4096 bytes at offset 4295148032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295152128 ++read 4096/4096 bytes at offset 4295152128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295156224 ++read 4096/4096 bytes at offset 4295156224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295160320 ++read 4096/4096 bytes at offset 4295160320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295164416 ++read 4096/4096 bytes at offset 4295164416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295168512 ++read 4096/4096 bytes at offset 4295168512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295172608 ++read 4096/4096 bytes at offset 4295172608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295176704 ++read 4096/4096 bytes at offset 4295176704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295180800 ++read 4096/4096 bytes at offset 4295180800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295184896 ++read 4096/4096 bytes at offset 4295184896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295188992 ++read 4096/4096 bytes at offset 4295188992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295193088 ++read 4096/4096 bytes at offset 4295193088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295197184 ++read 4096/4096 bytes at offset 4295197184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295201280 ++read 4096/4096 bytes at offset 4295201280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295205376 ++read 4096/4096 bytes at offset 4295205376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295209472 ++read 4096/4096 bytes at offset 4295209472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295213568 ++read 4096/4096 bytes at offset 4295213568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295217664 ++read 4096/4096 bytes at offset 4295217664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295221760 ++read 4096/4096 bytes at offset 4295221760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295225856 ++read 4096/4096 bytes at offset 4295225856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295229952 ++read 4096/4096 bytes at offset 4295229952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295234048 ++read 4096/4096 bytes at offset 4295234048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295238144 ++read 4096/4096 bytes at offset 4295238144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295242240 ++read 4096/4096 bytes at offset 4295242240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295246336 ++read 4096/4096 bytes at offset 4295246336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295250432 ++read 4096/4096 bytes at offset 4295250432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295254528 ++read 4096/4096 bytes at offset 4295254528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295258624 ++read 4096/4096 bytes at offset 4295258624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295262720 ++read 4096/4096 bytes at offset 4295262720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295266816 ++read 4096/4096 bytes at offset 4295266816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295270912 ++read 4096/4096 bytes at offset 4295270912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295275008 ++read 4096/4096 bytes at offset 4295275008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295279104 ++read 4096/4096 bytes at offset 4295279104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295283200 ++read 4096/4096 bytes at offset 4295283200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295287296 ++read 4096/4096 bytes at offset 4295287296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295291392 ++read 4096/4096 bytes at offset 4295291392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295295488 ++read 4096/4096 bytes at offset 4295295488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295299584 ++read 4096/4096 bytes at offset 4295299584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295303680 ++read 4096/4096 bytes at offset 4295303680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295307776 ++read 4096/4096 bytes at offset 4295307776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295311872 ++read 4096/4096 bytes at offset 4295311872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295315968 ++read 4096/4096 bytes at offset 4295315968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295320064 ++read 4096/4096 bytes at offset 4295320064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295324160 ++read 4096/4096 bytes at offset 4295324160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295328256 ++read 4096/4096 bytes at offset 4295328256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295332352 ++read 4096/4096 bytes at offset 4295332352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295336448 ++read 4096/4096 bytes at offset 4295336448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295340544 ++read 4096/4096 bytes at offset 4295340544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295344640 ++read 4096/4096 bytes at offset 4295344640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295348736 ++read 4096/4096 bytes at offset 4295348736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295352832 ++read 4096/4096 bytes at offset 4295352832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295356928 ++read 4096/4096 bytes at offset 4295356928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295361024 ++read 4096/4096 bytes at offset 4295361024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295365120 ++read 4096/4096 bytes at offset 4295365120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295369216 ++read 4096/4096 bytes at offset 4295369216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295373312 ++read 4096/4096 bytes at offset 4295373312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295377408 ++read 4096/4096 bytes at offset 4295377408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295381504 ++read 4096/4096 bytes at offset 4295381504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295385600 ++read 4096/4096 bytes at offset 4295385600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295389696 ++read 4096/4096 bytes at offset 4295389696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295393792 ++read 4096/4096 bytes at offset 4295393792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295397888 ++read 4096/4096 bytes at offset 4295397888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295401984 ++read 4096/4096 bytes at offset 4295401984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295406080 ++read 4096/4096 bytes at offset 4295406080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295410176 ++read 4096/4096 bytes at offset 4295410176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295414272 ++read 4096/4096 bytes at offset 4295414272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295418368 ++read 4096/4096 bytes at offset 4295418368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295422464 ++read 4096/4096 bytes at offset 4295422464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295426560 ++read 4096/4096 bytes at offset 4295426560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295430656 ++read 4096/4096 bytes at offset 4295430656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295434752 ++read 4096/4096 bytes at offset 4295434752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295438848 ++read 4096/4096 bytes at offset 4295438848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295442944 ++read 4096/4096 bytes at offset 4295442944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295447040 ++read 4096/4096 bytes at offset 4295447040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295451136 ++read 4096/4096 bytes at offset 4295451136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295455232 ++read 4096/4096 bytes at offset 4295455232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295459328 ++read 4096/4096 bytes at offset 4295459328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295463424 ++read 4096/4096 bytes at offset 4295463424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295467520 ++read 4096/4096 bytes at offset 4295467520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295471616 ++read 4096/4096 bytes at offset 4295471616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295475712 ++read 4096/4096 bytes at offset 4295475712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295479808 ++read 4096/4096 bytes at offset 4295479808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295483904 ++read 4096/4096 bytes at offset 4295483904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295488000 ++read 4096/4096 bytes at offset 4295488000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295492096 ++read 4096/4096 bytes at offset 4295492096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295496192 ++read 4096/4096 bytes at offset 4295496192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295500288 ++read 4096/4096 bytes at offset 4295500288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295504384 ++read 4096/4096 bytes at offset 4295504384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295508480 ++read 4096/4096 bytes at offset 4295508480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295512576 ++read 4096/4096 bytes at offset 4295512576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295516672 ++read 4096/4096 bytes at offset 4295516672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295520768 ++read 4096/4096 bytes at offset 4295520768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295524864 ++read 4096/4096 bytes at offset 4295524864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295528960 ++read 4096/4096 bytes at offset 4295528960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295533056 ++read 4096/4096 bytes at offset 4295533056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295537152 ++read 4096/4096 bytes at offset 4295537152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295541248 ++read 4096/4096 bytes at offset 4295541248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295545344 ++read 4096/4096 bytes at offset 4295545344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295549440 ++read 4096/4096 bytes at offset 4295549440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295553536 ++read 4096/4096 bytes at offset 4295553536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295557632 ++read 4096/4096 bytes at offset 4295557632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295561728 ++read 4096/4096 bytes at offset 4295561728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295565824 ++read 4096/4096 bytes at offset 4295565824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295569920 ++read 4096/4096 bytes at offset 4295569920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295574016 ++read 4096/4096 bytes at offset 4295574016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295578112 ++read 4096/4096 bytes at offset 4295578112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295582208 ++read 4096/4096 bytes at offset 4295582208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295586304 ++read 4096/4096 bytes at offset 4295586304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295590400 ++read 4096/4096 bytes at offset 4295590400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295594496 ++read 4096/4096 bytes at offset 4295594496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295598592 ++read 4096/4096 bytes at offset 4295598592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295602688 ++read 4096/4096 bytes at offset 4295602688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295606784 ++read 4096/4096 bytes at offset 4295606784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295610880 ++read 4096/4096 bytes at offset 4295610880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295614976 ++read 4096/4096 bytes at offset 4295614976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295619072 ++read 4096/4096 bytes at offset 4295619072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295623168 ++read 4096/4096 bytes at offset 4295623168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295627264 ++read 4096/4096 bytes at offset 4295627264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295631360 ++read 4096/4096 bytes at offset 4295631360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295635456 ++read 4096/4096 bytes at offset 4295635456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295639552 ++read 4096/4096 bytes at offset 4295639552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295643648 ++read 4096/4096 bytes at offset 4295643648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295647744 ++read 4096/4096 bytes at offset 4295647744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295651840 ++read 4096/4096 bytes at offset 4295651840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295655936 ++read 4096/4096 bytes at offset 4295655936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295660032 ++read 4096/4096 bytes at offset 4295660032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295664128 ++read 4096/4096 bytes at offset 4295664128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295668224 ++read 4096/4096 bytes at offset 4295668224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295672320 ++read 4096/4096 bytes at offset 4295672320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295676416 ++read 4096/4096 bytes at offset 4295676416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295680512 ++read 4096/4096 bytes at offset 4295680512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295684608 ++read 4096/4096 bytes at offset 4295684608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295688704 ++read 4096/4096 bytes at offset 4295688704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295692800 ++read 4096/4096 bytes at offset 4295692800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295696896 ++read 4096/4096 bytes at offset 4295696896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295700992 ++read 4096/4096 bytes at offset 4295700992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295705088 ++read 4096/4096 bytes at offset 4295705088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295709184 ++read 4096/4096 bytes at offset 4295709184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295713280 ++read 4096/4096 bytes at offset 4295713280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295717376 ++read 4096/4096 bytes at offset 4295717376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295721472 ++read 4096/4096 bytes at offset 4295721472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295725568 ++read 4096/4096 bytes at offset 4295725568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295729664 ++read 4096/4096 bytes at offset 4295729664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295733760 ++read 4096/4096 bytes at offset 4295733760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295737856 ++read 4096/4096 bytes at offset 4295737856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295741952 ++read 4096/4096 bytes at offset 4295741952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295746048 ++read 4096/4096 bytes at offset 4295746048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295750144 ++read 4096/4096 bytes at offset 4295750144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295754240 ++read 4096/4096 bytes at offset 4295754240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295758336 ++read 4096/4096 bytes at offset 4295758336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295762432 ++read 4096/4096 bytes at offset 4295762432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295766528 ++read 4096/4096 bytes at offset 4295766528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295770624 ++read 4096/4096 bytes at offset 4295770624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295774720 ++read 4096/4096 bytes at offset 4295774720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295778816 ++read 4096/4096 bytes at offset 4295778816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295782912 ++read 4096/4096 bytes at offset 4295782912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295787008 ++read 4096/4096 bytes at offset 4295787008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295791104 ++read 4096/4096 bytes at offset 4295791104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295795200 ++read 4096/4096 bytes at offset 4295795200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295799296 ++read 4096/4096 bytes at offset 4295799296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295803392 ++read 4096/4096 bytes at offset 4295803392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295807488 ++read 4096/4096 bytes at offset 4295807488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295811584 ++read 4096/4096 bytes at offset 4295811584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295815680 ++read 4096/4096 bytes at offset 4295815680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295819776 ++read 4096/4096 bytes at offset 4295819776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295823872 ++read 4096/4096 bytes at offset 4295823872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295827968 ++read 4096/4096 bytes at offset 4295827968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295832064 ++read 4096/4096 bytes at offset 4295832064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295836160 ++read 4096/4096 bytes at offset 4295836160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295840256 ++read 4096/4096 bytes at offset 4295840256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295844352 ++read 4096/4096 bytes at offset 4295844352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295848448 ++read 4096/4096 bytes at offset 4295848448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295852544 ++read 4096/4096 bytes at offset 4295852544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295856640 ++read 4096/4096 bytes at offset 4295856640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295860736 ++read 4096/4096 bytes at offset 4295860736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295864832 ++read 4096/4096 bytes at offset 4295864832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295868928 ++read 4096/4096 bytes at offset 4295868928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295873024 ++read 4096/4096 bytes at offset 4295873024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295877120 ++read 4096/4096 bytes at offset 4295877120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295881216 ++read 4096/4096 bytes at offset 4295881216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295885312 ++read 4096/4096 bytes at offset 4295885312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295889408 ++read 4096/4096 bytes at offset 4295889408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295893504 ++read 4096/4096 bytes at offset 4295893504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295897600 ++read 4096/4096 bytes at offset 4295897600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295901696 ++read 4096/4096 bytes at offset 4295901696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295905792 ++read 4096/4096 bytes at offset 4295905792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295909888 ++read 4096/4096 bytes at offset 4295909888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295913984 ++read 4096/4096 bytes at offset 4295913984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295918080 ++read 4096/4096 bytes at offset 4295918080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295922176 ++read 4096/4096 bytes at offset 4295922176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295926272 ++read 4096/4096 bytes at offset 4295926272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295930368 ++read 4096/4096 bytes at offset 4295930368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295934464 ++read 4096/4096 bytes at offset 4295934464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295938560 ++read 4096/4096 bytes at offset 4295938560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295942656 ++read 4096/4096 bytes at offset 4295942656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295946752 ++read 4096/4096 bytes at offset 4295946752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295950848 ++read 4096/4096 bytes at offset 4295950848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295954944 ++read 4096/4096 bytes at offset 4295954944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295959040 ++read 4096/4096 bytes at offset 4295959040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295963136 ++read 4096/4096 bytes at offset 4295963136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295967232 ++read 4096/4096 bytes at offset 4295967232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295971328 ++read 4096/4096 bytes at offset 4295971328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295975424 ++read 4096/4096 bytes at offset 4295975424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295979520 ++read 4096/4096 bytes at offset 4295979520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295983616 ++read 4096/4096 bytes at offset 4295983616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295987712 ++read 4096/4096 bytes at offset 4295987712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295991808 ++read 4096/4096 bytes at offset 4295991808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295995904 ++read 4096/4096 bytes at offset 4295995904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4296000000 ++read 4096/4096 bytes at offset 4296000000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4296004096 ++read 4096/4096 bytes at offset 4296004096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4296008192 ++read 4096/4096 bytes at offset 4296008192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4296012288 ++read 4096/4096 bytes at offset 4296012288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 5 +-qemu-io> read 2048/2048 bytes at offset 4296018432 ++=== IO: pattern 5 ++read 2048/2048 bytes at offset 4296018432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296022528 ++read 2048/2048 bytes at offset 4296022528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296026624 ++read 2048/2048 bytes at offset 4296026624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296030720 ++read 2048/2048 bytes at offset 4296030720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296034816 ++read 2048/2048 bytes at offset 4296034816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296038912 ++read 2048/2048 bytes at offset 4296038912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296043008 ++read 2048/2048 bytes at offset 4296043008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296047104 ++read 2048/2048 bytes at offset 4296047104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296051200 ++read 2048/2048 bytes at offset 4296051200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296055296 ++read 2048/2048 bytes at offset 4296055296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296059392 ++read 2048/2048 bytes at offset 4296059392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296063488 ++read 2048/2048 bytes at offset 4296063488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296067584 ++read 2048/2048 bytes at offset 4296067584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296071680 ++read 2048/2048 bytes at offset 4296071680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296075776 ++read 2048/2048 bytes at offset 4296075776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296079872 ++read 2048/2048 bytes at offset 4296079872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296083968 ++read 2048/2048 bytes at offset 4296083968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296088064 ++read 2048/2048 bytes at offset 4296088064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296092160 ++read 2048/2048 bytes at offset 4296092160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296096256 ++read 2048/2048 bytes at offset 4296096256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296100352 ++read 2048/2048 bytes at offset 4296100352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296104448 ++read 2048/2048 bytes at offset 4296104448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296108544 ++read 2048/2048 bytes at offset 4296108544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296112640 ++read 2048/2048 bytes at offset 4296112640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296116736 ++read 2048/2048 bytes at offset 4296116736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296120832 ++read 2048/2048 bytes at offset 4296120832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296124928 ++read 2048/2048 bytes at offset 4296124928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296129024 ++read 2048/2048 bytes at offset 4296129024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296133120 ++read 2048/2048 bytes at offset 4296133120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296137216 ++read 2048/2048 bytes at offset 4296137216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296141312 ++read 2048/2048 bytes at offset 4296141312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296145408 ++read 2048/2048 bytes at offset 4296145408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296149504 ++read 2048/2048 bytes at offset 4296149504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296153600 ++read 2048/2048 bytes at offset 4296153600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296157696 ++read 2048/2048 bytes at offset 4296157696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296161792 ++read 2048/2048 bytes at offset 4296161792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296165888 ++read 2048/2048 bytes at offset 4296165888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296169984 ++read 2048/2048 bytes at offset 4296169984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296174080 ++read 2048/2048 bytes at offset 4296174080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296178176 ++read 2048/2048 bytes at offset 4296178176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296182272 ++read 2048/2048 bytes at offset 4296182272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296186368 ++read 2048/2048 bytes at offset 4296186368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296190464 ++read 2048/2048 bytes at offset 4296190464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296194560 ++read 2048/2048 bytes at offset 4296194560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296198656 ++read 2048/2048 bytes at offset 4296198656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296202752 ++read 2048/2048 bytes at offset 4296202752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296206848 ++read 2048/2048 bytes at offset 4296206848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296210944 ++read 2048/2048 bytes at offset 4296210944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296215040 ++read 2048/2048 bytes at offset 4296215040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296219136 ++read 2048/2048 bytes at offset 4296219136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296223232 ++read 2048/2048 bytes at offset 4296223232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296227328 ++read 2048/2048 bytes at offset 4296227328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296231424 ++read 2048/2048 bytes at offset 4296231424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296235520 ++read 2048/2048 bytes at offset 4296235520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296239616 ++read 2048/2048 bytes at offset 4296239616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296243712 ++read 2048/2048 bytes at offset 4296243712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296247808 ++read 2048/2048 bytes at offset 4296247808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296251904 ++read 2048/2048 bytes at offset 4296251904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296256000 ++read 2048/2048 bytes at offset 4296256000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296260096 ++read 2048/2048 bytes at offset 4296260096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296264192 ++read 2048/2048 bytes at offset 4296264192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296268288 ++read 2048/2048 bytes at offset 4296268288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296272384 ++read 2048/2048 bytes at offset 4296272384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296276480 ++read 2048/2048 bytes at offset 4296276480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296280576 ++read 2048/2048 bytes at offset 4296280576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296284672 ++read 2048/2048 bytes at offset 4296284672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296288768 ++read 2048/2048 bytes at offset 4296288768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296292864 ++read 2048/2048 bytes at offset 4296292864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296296960 ++read 2048/2048 bytes at offset 4296296960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296301056 ++read 2048/2048 bytes at offset 4296301056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296305152 ++read 2048/2048 bytes at offset 4296305152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296309248 ++read 2048/2048 bytes at offset 4296309248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296313344 ++read 2048/2048 bytes at offset 4296313344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296317440 ++read 2048/2048 bytes at offset 4296317440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296321536 ++read 2048/2048 bytes at offset 4296321536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296325632 ++read 2048/2048 bytes at offset 4296325632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296329728 ++read 2048/2048 bytes at offset 4296329728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296333824 ++read 2048/2048 bytes at offset 4296333824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296337920 ++read 2048/2048 bytes at offset 4296337920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296342016 ++read 2048/2048 bytes at offset 4296342016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296346112 ++read 2048/2048 bytes at offset 4296346112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296350208 ++read 2048/2048 bytes at offset 4296350208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296354304 ++read 2048/2048 bytes at offset 4296354304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296358400 ++read 2048/2048 bytes at offset 4296358400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296362496 ++read 2048/2048 bytes at offset 4296362496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296366592 ++read 2048/2048 bytes at offset 4296366592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296370688 ++read 2048/2048 bytes at offset 4296370688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296374784 ++read 2048/2048 bytes at offset 4296374784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296378880 ++read 2048/2048 bytes at offset 4296378880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296382976 ++read 2048/2048 bytes at offset 4296382976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296387072 ++read 2048/2048 bytes at offset 4296387072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296391168 ++read 2048/2048 bytes at offset 4296391168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296395264 ++read 2048/2048 bytes at offset 4296395264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296399360 ++read 2048/2048 bytes at offset 4296399360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296403456 ++read 2048/2048 bytes at offset 4296403456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296407552 ++read 2048/2048 bytes at offset 4296407552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296411648 ++read 2048/2048 bytes at offset 4296411648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296415744 ++read 2048/2048 bytes at offset 4296415744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296419840 ++read 2048/2048 bytes at offset 4296419840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296423936 ++read 2048/2048 bytes at offset 4296423936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296428032 ++read 2048/2048 bytes at offset 4296428032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296432128 ++read 2048/2048 bytes at offset 4296432128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296436224 ++read 2048/2048 bytes at offset 4296436224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296440320 ++read 2048/2048 bytes at offset 4296440320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296444416 ++read 2048/2048 bytes at offset 4296444416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296448512 ++read 2048/2048 bytes at offset 4296448512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296452608 ++read 2048/2048 bytes at offset 4296452608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296456704 ++read 2048/2048 bytes at offset 4296456704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296460800 ++read 2048/2048 bytes at offset 4296460800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296464896 ++read 2048/2048 bytes at offset 4296464896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296468992 ++read 2048/2048 bytes at offset 4296468992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296473088 ++read 2048/2048 bytes at offset 4296473088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296477184 ++read 2048/2048 bytes at offset 4296477184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296481280 ++read 2048/2048 bytes at offset 4296481280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296485376 ++read 2048/2048 bytes at offset 4296485376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296489472 ++read 2048/2048 bytes at offset 4296489472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296493568 ++read 2048/2048 bytes at offset 4296493568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296497664 ++read 2048/2048 bytes at offset 4296497664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296501760 ++read 2048/2048 bytes at offset 4296501760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296505856 ++read 2048/2048 bytes at offset 4296505856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296509952 ++read 2048/2048 bytes at offset 4296509952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296514048 ++read 2048/2048 bytes at offset 4296514048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296518144 ++read 2048/2048 bytes at offset 4296518144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296522240 ++read 2048/2048 bytes at offset 4296522240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296526336 ++read 2048/2048 bytes at offset 4296526336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296530432 ++read 2048/2048 bytes at offset 4296530432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296534528 ++read 2048/2048 bytes at offset 4296534528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296538624 ++read 2048/2048 bytes at offset 4296538624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296542720 ++read 2048/2048 bytes at offset 4296542720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296546816 ++read 2048/2048 bytes at offset 4296546816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296550912 ++read 2048/2048 bytes at offset 4296550912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296555008 ++read 2048/2048 bytes at offset 4296555008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296559104 ++read 2048/2048 bytes at offset 4296559104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296563200 ++read 2048/2048 bytes at offset 4296563200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296567296 ++read 2048/2048 bytes at offset 4296567296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296571392 ++read 2048/2048 bytes at offset 4296571392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296575488 ++read 2048/2048 bytes at offset 4296575488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296579584 ++read 2048/2048 bytes at offset 4296579584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296583680 ++read 2048/2048 bytes at offset 4296583680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296587776 ++read 2048/2048 bytes at offset 4296587776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296591872 ++read 2048/2048 bytes at offset 4296591872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296595968 ++read 2048/2048 bytes at offset 4296595968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296600064 ++read 2048/2048 bytes at offset 4296600064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296604160 ++read 2048/2048 bytes at offset 4296604160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296608256 ++read 2048/2048 bytes at offset 4296608256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296612352 ++read 2048/2048 bytes at offset 4296612352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296616448 ++read 2048/2048 bytes at offset 4296616448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296620544 ++read 2048/2048 bytes at offset 4296620544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296624640 ++read 2048/2048 bytes at offset 4296624640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296628736 ++read 2048/2048 bytes at offset 4296628736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296632832 ++read 2048/2048 bytes at offset 4296632832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296636928 ++read 2048/2048 bytes at offset 4296636928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296641024 ++read 2048/2048 bytes at offset 4296641024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296645120 ++read 2048/2048 bytes at offset 4296645120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296649216 ++read 2048/2048 bytes at offset 4296649216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296653312 ++read 2048/2048 bytes at offset 4296653312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296657408 ++read 2048/2048 bytes at offset 4296657408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296661504 ++read 2048/2048 bytes at offset 4296661504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296665600 ++read 2048/2048 bytes at offset 4296665600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296669696 ++read 2048/2048 bytes at offset 4296669696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296673792 ++read 2048/2048 bytes at offset 4296673792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296677888 ++read 2048/2048 bytes at offset 4296677888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296681984 ++read 2048/2048 bytes at offset 4296681984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296686080 ++read 2048/2048 bytes at offset 4296686080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296690176 ++read 2048/2048 bytes at offset 4296690176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296694272 ++read 2048/2048 bytes at offset 4296694272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296698368 ++read 2048/2048 bytes at offset 4296698368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296702464 ++read 2048/2048 bytes at offset 4296702464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296706560 ++read 2048/2048 bytes at offset 4296706560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296710656 ++read 2048/2048 bytes at offset 4296710656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296714752 ++read 2048/2048 bytes at offset 4296714752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296718848 ++read 2048/2048 bytes at offset 4296718848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296722944 ++read 2048/2048 bytes at offset 4296722944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296727040 ++read 2048/2048 bytes at offset 4296727040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296731136 ++read 2048/2048 bytes at offset 4296731136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296735232 ++read 2048/2048 bytes at offset 4296735232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296739328 ++read 2048/2048 bytes at offset 4296739328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296743424 ++read 2048/2048 bytes at offset 4296743424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296747520 ++read 2048/2048 bytes at offset 4296747520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296751616 ++read 2048/2048 bytes at offset 4296751616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296755712 ++read 2048/2048 bytes at offset 4296755712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296759808 ++read 2048/2048 bytes at offset 4296759808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296763904 ++read 2048/2048 bytes at offset 4296763904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296768000 ++read 2048/2048 bytes at offset 4296768000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296772096 ++read 2048/2048 bytes at offset 4296772096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296776192 ++read 2048/2048 bytes at offset 4296776192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296780288 ++read 2048/2048 bytes at offset 4296780288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296784384 ++read 2048/2048 bytes at offset 4296784384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296788480 ++read 2048/2048 bytes at offset 4296788480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296792576 ++read 2048/2048 bytes at offset 4296792576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296796672 ++read 2048/2048 bytes at offset 4296796672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296800768 ++read 2048/2048 bytes at offset 4296800768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296804864 ++read 2048/2048 bytes at offset 4296804864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296808960 ++read 2048/2048 bytes at offset 4296808960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296813056 ++read 2048/2048 bytes at offset 4296813056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296817152 ++read 2048/2048 bytes at offset 4296817152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296821248 ++read 2048/2048 bytes at offset 4296821248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296825344 ++read 2048/2048 bytes at offset 4296825344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296829440 ++read 2048/2048 bytes at offset 4296829440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296833536 ++read 2048/2048 bytes at offset 4296833536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296837632 ++read 2048/2048 bytes at offset 4296837632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296841728 ++read 2048/2048 bytes at offset 4296841728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296845824 ++read 2048/2048 bytes at offset 4296845824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296849920 ++read 2048/2048 bytes at offset 4296849920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296854016 ++read 2048/2048 bytes at offset 4296854016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296858112 ++read 2048/2048 bytes at offset 4296858112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296862208 ++read 2048/2048 bytes at offset 4296862208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296866304 ++read 2048/2048 bytes at offset 4296866304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296870400 ++read 2048/2048 bytes at offset 4296870400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296874496 ++read 2048/2048 bytes at offset 4296874496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296878592 ++read 2048/2048 bytes at offset 4296878592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296882688 ++read 2048/2048 bytes at offset 4296882688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296886784 ++read 2048/2048 bytes at offset 4296886784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296890880 ++read 2048/2048 bytes at offset 4296890880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296894976 ++read 2048/2048 bytes at offset 4296894976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296899072 ++read 2048/2048 bytes at offset 4296899072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296903168 ++read 2048/2048 bytes at offset 4296903168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296907264 ++read 2048/2048 bytes at offset 4296907264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296911360 ++read 2048/2048 bytes at offset 4296911360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296915456 ++read 2048/2048 bytes at offset 4296915456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296919552 ++read 2048/2048 bytes at offset 4296919552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296923648 ++read 2048/2048 bytes at offset 4296923648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296927744 ++read 2048/2048 bytes at offset 4296927744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296931840 ++read 2048/2048 bytes at offset 4296931840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296935936 ++read 2048/2048 bytes at offset 4296935936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296940032 ++read 2048/2048 bytes at offset 4296940032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296944128 ++read 2048/2048 bytes at offset 4296944128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296948224 ++read 2048/2048 bytes at offset 4296948224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296952320 ++read 2048/2048 bytes at offset 4296952320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296956416 ++read 2048/2048 bytes at offset 4296956416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296960512 ++read 2048/2048 bytes at offset 4296960512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296964608 ++read 2048/2048 bytes at offset 4296964608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296968704 ++read 2048/2048 bytes at offset 4296968704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296972800 ++read 2048/2048 bytes at offset 4296972800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296976896 ++read 2048/2048 bytes at offset 4296976896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296980992 ++read 2048/2048 bytes at offset 4296980992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296985088 ++read 2048/2048 bytes at offset 4296985088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296989184 ++read 2048/2048 bytes at offset 4296989184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296993280 ++read 2048/2048 bytes at offset 4296993280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296997376 ++read 2048/2048 bytes at offset 4296997376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297001472 ++read 2048/2048 bytes at offset 4297001472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297005568 ++read 2048/2048 bytes at offset 4297005568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297009664 ++read 2048/2048 bytes at offset 4297009664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297013760 ++read 2048/2048 bytes at offset 4297013760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297017856 ++read 2048/2048 bytes at offset 4297017856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297021952 ++read 2048/2048 bytes at offset 4297021952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297026048 ++read 2048/2048 bytes at offset 4297026048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297030144 ++read 2048/2048 bytes at offset 4297030144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297034240 ++read 2048/2048 bytes at offset 4297034240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297038336 ++read 2048/2048 bytes at offset 4297038336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297042432 ++read 2048/2048 bytes at offset 4297042432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297046528 ++read 2048/2048 bytes at offset 4297046528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297050624 ++read 2048/2048 bytes at offset 4297050624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297054720 ++read 2048/2048 bytes at offset 4297054720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297058816 ++read 2048/2048 bytes at offset 4297058816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297062912 ++read 2048/2048 bytes at offset 4297062912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 1 +-qemu-io> read 2048/2048 bytes at offset 4297064960 ++=== IO: pattern 1 ++read 2048/2048 bytes at offset 4297064960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297069056 ++read 2048/2048 bytes at offset 4297069056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297073152 ++read 2048/2048 bytes at offset 4297073152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297077248 ++read 2048/2048 bytes at offset 4297077248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297081344 ++read 2048/2048 bytes at offset 4297081344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297085440 ++read 2048/2048 bytes at offset 4297085440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297089536 ++read 2048/2048 bytes at offset 4297089536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297093632 ++read 2048/2048 bytes at offset 4297093632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297097728 ++read 2048/2048 bytes at offset 4297097728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297101824 ++read 2048/2048 bytes at offset 4297101824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297105920 ++read 2048/2048 bytes at offset 4297105920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297110016 ++read 2048/2048 bytes at offset 4297110016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297114112 ++read 2048/2048 bytes at offset 4297114112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297118208 ++read 2048/2048 bytes at offset 4297118208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297122304 ++read 2048/2048 bytes at offset 4297122304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297126400 ++read 2048/2048 bytes at offset 4297126400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297130496 ++read 2048/2048 bytes at offset 4297130496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297134592 ++read 2048/2048 bytes at offset 4297134592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297138688 ++read 2048/2048 bytes at offset 4297138688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297142784 ++read 2048/2048 bytes at offset 4297142784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297146880 ++read 2048/2048 bytes at offset 4297146880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297150976 ++read 2048/2048 bytes at offset 4297150976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297155072 ++read 2048/2048 bytes at offset 4297155072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297159168 ++read 2048/2048 bytes at offset 4297159168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297163264 ++read 2048/2048 bytes at offset 4297163264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297167360 ++read 2048/2048 bytes at offset 4297167360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297171456 ++read 2048/2048 bytes at offset 4297171456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297175552 ++read 2048/2048 bytes at offset 4297175552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297179648 ++read 2048/2048 bytes at offset 4297179648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297183744 ++read 2048/2048 bytes at offset 4297183744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297187840 ++read 2048/2048 bytes at offset 4297187840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297191936 ++read 2048/2048 bytes at offset 4297191936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297196032 ++read 2048/2048 bytes at offset 4297196032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297200128 ++read 2048/2048 bytes at offset 4297200128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297204224 ++read 2048/2048 bytes at offset 4297204224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297208320 ++read 2048/2048 bytes at offset 4297208320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297212416 ++read 2048/2048 bytes at offset 4297212416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297216512 ++read 2048/2048 bytes at offset 4297216512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297220608 ++read 2048/2048 bytes at offset 4297220608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297224704 ++read 2048/2048 bytes at offset 4297224704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297228800 ++read 2048/2048 bytes at offset 4297228800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297232896 ++read 2048/2048 bytes at offset 4297232896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297236992 ++read 2048/2048 bytes at offset 4297236992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297241088 ++read 2048/2048 bytes at offset 4297241088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297245184 ++read 2048/2048 bytes at offset 4297245184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297249280 ++read 2048/2048 bytes at offset 4297249280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297253376 ++read 2048/2048 bytes at offset 4297253376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297257472 ++read 2048/2048 bytes at offset 4297257472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297261568 ++read 2048/2048 bytes at offset 4297261568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297265664 ++read 2048/2048 bytes at offset 4297265664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297269760 ++read 2048/2048 bytes at offset 4297269760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297273856 ++read 2048/2048 bytes at offset 4297273856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297277952 ++read 2048/2048 bytes at offset 4297277952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297282048 ++read 2048/2048 bytes at offset 4297282048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297286144 ++read 2048/2048 bytes at offset 4297286144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297290240 ++read 2048/2048 bytes at offset 4297290240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297294336 ++read 2048/2048 bytes at offset 4297294336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297298432 ++read 2048/2048 bytes at offset 4297298432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297302528 ++read 2048/2048 bytes at offset 4297302528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297306624 ++read 2048/2048 bytes at offset 4297306624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297310720 ++read 2048/2048 bytes at offset 4297310720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297314816 ++read 2048/2048 bytes at offset 4297314816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297318912 ++read 2048/2048 bytes at offset 4297318912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297323008 ++read 2048/2048 bytes at offset 4297323008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297327104 ++read 2048/2048 bytes at offset 4297327104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297331200 ++read 2048/2048 bytes at offset 4297331200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297335296 ++read 2048/2048 bytes at offset 4297335296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297339392 ++read 2048/2048 bytes at offset 4297339392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297343488 ++read 2048/2048 bytes at offset 4297343488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297347584 ++read 2048/2048 bytes at offset 4297347584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297351680 ++read 2048/2048 bytes at offset 4297351680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297355776 ++read 2048/2048 bytes at offset 4297355776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297359872 ++read 2048/2048 bytes at offset 4297359872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297363968 ++read 2048/2048 bytes at offset 4297363968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297368064 ++read 2048/2048 bytes at offset 4297368064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297372160 ++read 2048/2048 bytes at offset 4297372160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297376256 ++read 2048/2048 bytes at offset 4297376256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297380352 ++read 2048/2048 bytes at offset 4297380352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297384448 ++read 2048/2048 bytes at offset 4297384448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297388544 ++read 2048/2048 bytes at offset 4297388544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297392640 ++read 2048/2048 bytes at offset 4297392640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297396736 ++read 2048/2048 bytes at offset 4297396736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297400832 ++read 2048/2048 bytes at offset 4297400832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297404928 ++read 2048/2048 bytes at offset 4297404928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297409024 ++read 2048/2048 bytes at offset 4297409024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297413120 ++read 2048/2048 bytes at offset 4297413120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297417216 ++read 2048/2048 bytes at offset 4297417216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297421312 ++read 2048/2048 bytes at offset 4297421312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297425408 ++read 2048/2048 bytes at offset 4297425408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297429504 ++read 2048/2048 bytes at offset 4297429504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297433600 ++read 2048/2048 bytes at offset 4297433600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297437696 ++read 2048/2048 bytes at offset 4297437696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297441792 ++read 2048/2048 bytes at offset 4297441792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297445888 ++read 2048/2048 bytes at offset 4297445888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297449984 ++read 2048/2048 bytes at offset 4297449984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297454080 ++read 2048/2048 bytes at offset 4297454080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297458176 ++read 2048/2048 bytes at offset 4297458176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297462272 ++read 2048/2048 bytes at offset 4297462272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297466368 ++read 2048/2048 bytes at offset 4297466368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297470464 ++read 2048/2048 bytes at offset 4297470464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297474560 ++read 2048/2048 bytes at offset 4297474560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297478656 ++read 2048/2048 bytes at offset 4297478656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297482752 ++read 2048/2048 bytes at offset 4297482752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297486848 ++read 2048/2048 bytes at offset 4297486848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297490944 ++read 2048/2048 bytes at offset 4297490944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297495040 ++read 2048/2048 bytes at offset 4297495040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297499136 ++read 2048/2048 bytes at offset 4297499136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297503232 ++read 2048/2048 bytes at offset 4297503232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297507328 ++read 2048/2048 bytes at offset 4297507328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297511424 ++read 2048/2048 bytes at offset 4297511424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297515520 ++read 2048/2048 bytes at offset 4297515520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297519616 ++read 2048/2048 bytes at offset 4297519616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297523712 ++read 2048/2048 bytes at offset 4297523712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297527808 ++read 2048/2048 bytes at offset 4297527808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297531904 ++read 2048/2048 bytes at offset 4297531904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297536000 ++read 2048/2048 bytes at offset 4297536000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297540096 ++read 2048/2048 bytes at offset 4297540096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297544192 ++read 2048/2048 bytes at offset 4297544192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297548288 ++read 2048/2048 bytes at offset 4297548288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297552384 ++read 2048/2048 bytes at offset 4297552384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297556480 ++read 2048/2048 bytes at offset 4297556480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297560576 ++read 2048/2048 bytes at offset 4297560576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297564672 ++read 2048/2048 bytes at offset 4297564672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297568768 ++read 2048/2048 bytes at offset 4297568768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297572864 ++read 2048/2048 bytes at offset 4297572864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297576960 ++read 2048/2048 bytes at offset 4297576960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297581056 ++read 2048/2048 bytes at offset 4297581056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297585152 ++read 2048/2048 bytes at offset 4297585152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297589248 ++read 2048/2048 bytes at offset 4297589248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297593344 ++read 2048/2048 bytes at offset 4297593344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297597440 ++read 2048/2048 bytes at offset 4297597440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297601536 ++read 2048/2048 bytes at offset 4297601536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297605632 ++read 2048/2048 bytes at offset 4297605632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297609728 ++read 2048/2048 bytes at offset 4297609728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297613824 ++read 2048/2048 bytes at offset 4297613824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297617920 ++read 2048/2048 bytes at offset 4297617920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297622016 ++read 2048/2048 bytes at offset 4297622016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297626112 ++read 2048/2048 bytes at offset 4297626112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297630208 ++read 2048/2048 bytes at offset 4297630208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297634304 ++read 2048/2048 bytes at offset 4297634304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297638400 ++read 2048/2048 bytes at offset 4297638400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297642496 ++read 2048/2048 bytes at offset 4297642496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297646592 ++read 2048/2048 bytes at offset 4297646592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297650688 ++read 2048/2048 bytes at offset 4297650688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297654784 ++read 2048/2048 bytes at offset 4297654784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297658880 ++read 2048/2048 bytes at offset 4297658880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297662976 ++read 2048/2048 bytes at offset 4297662976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297667072 ++read 2048/2048 bytes at offset 4297667072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297671168 ++read 2048/2048 bytes at offset 4297671168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297675264 ++read 2048/2048 bytes at offset 4297675264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297679360 ++read 2048/2048 bytes at offset 4297679360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297683456 ++read 2048/2048 bytes at offset 4297683456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297687552 ++read 2048/2048 bytes at offset 4297687552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297691648 ++read 2048/2048 bytes at offset 4297691648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297695744 ++read 2048/2048 bytes at offset 4297695744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297699840 ++read 2048/2048 bytes at offset 4297699840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297703936 ++read 2048/2048 bytes at offset 4297703936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297708032 ++read 2048/2048 bytes at offset 4297708032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297712128 ++read 2048/2048 bytes at offset 4297712128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297716224 ++read 2048/2048 bytes at offset 4297716224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297720320 ++read 2048/2048 bytes at offset 4297720320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297724416 ++read 2048/2048 bytes at offset 4297724416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297728512 ++read 2048/2048 bytes at offset 4297728512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297732608 ++read 2048/2048 bytes at offset 4297732608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297736704 ++read 2048/2048 bytes at offset 4297736704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297740800 ++read 2048/2048 bytes at offset 4297740800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297744896 ++read 2048/2048 bytes at offset 4297744896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297748992 ++read 2048/2048 bytes at offset 4297748992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297753088 ++read 2048/2048 bytes at offset 4297753088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297757184 ++read 2048/2048 bytes at offset 4297757184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297761280 ++read 2048/2048 bytes at offset 4297761280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297765376 ++read 2048/2048 bytes at offset 4297765376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297769472 ++read 2048/2048 bytes at offset 4297769472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297773568 ++read 2048/2048 bytes at offset 4297773568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297777664 ++read 2048/2048 bytes at offset 4297777664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297781760 ++read 2048/2048 bytes at offset 4297781760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297785856 ++read 2048/2048 bytes at offset 4297785856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297789952 ++read 2048/2048 bytes at offset 4297789952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297794048 ++read 2048/2048 bytes at offset 4297794048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297798144 ++read 2048/2048 bytes at offset 4297798144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297802240 ++read 2048/2048 bytes at offset 4297802240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297806336 ++read 2048/2048 bytes at offset 4297806336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297810432 ++read 2048/2048 bytes at offset 4297810432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297814528 ++read 2048/2048 bytes at offset 4297814528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297818624 ++read 2048/2048 bytes at offset 4297818624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297822720 ++read 2048/2048 bytes at offset 4297822720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297826816 ++read 2048/2048 bytes at offset 4297826816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297830912 ++read 2048/2048 bytes at offset 4297830912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297835008 ++read 2048/2048 bytes at offset 4297835008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297839104 ++read 2048/2048 bytes at offset 4297839104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297843200 ++read 2048/2048 bytes at offset 4297843200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297847296 ++read 2048/2048 bytes at offset 4297847296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297851392 ++read 2048/2048 bytes at offset 4297851392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297855488 ++read 2048/2048 bytes at offset 4297855488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297859584 ++read 2048/2048 bytes at offset 4297859584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297863680 ++read 2048/2048 bytes at offset 4297863680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297867776 ++read 2048/2048 bytes at offset 4297867776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297871872 ++read 2048/2048 bytes at offset 4297871872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297875968 ++read 2048/2048 bytes at offset 4297875968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297880064 ++read 2048/2048 bytes at offset 4297880064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297884160 ++read 2048/2048 bytes at offset 4297884160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297888256 ++read 2048/2048 bytes at offset 4297888256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297892352 ++read 2048/2048 bytes at offset 4297892352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297896448 ++read 2048/2048 bytes at offset 4297896448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297900544 ++read 2048/2048 bytes at offset 4297900544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297904640 ++read 2048/2048 bytes at offset 4297904640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297908736 ++read 2048/2048 bytes at offset 4297908736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297912832 ++read 2048/2048 bytes at offset 4297912832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297916928 ++read 2048/2048 bytes at offset 4297916928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297921024 ++read 2048/2048 bytes at offset 4297921024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297925120 ++read 2048/2048 bytes at offset 4297925120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297929216 ++read 2048/2048 bytes at offset 4297929216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297933312 ++read 2048/2048 bytes at offset 4297933312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297937408 ++read 2048/2048 bytes at offset 4297937408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297941504 ++read 2048/2048 bytes at offset 4297941504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297945600 ++read 2048/2048 bytes at offset 4297945600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297949696 ++read 2048/2048 bytes at offset 4297949696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297953792 ++read 2048/2048 bytes at offset 4297953792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297957888 ++read 2048/2048 bytes at offset 4297957888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297961984 ++read 2048/2048 bytes at offset 4297961984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297966080 ++read 2048/2048 bytes at offset 4297966080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297970176 ++read 2048/2048 bytes at offset 4297970176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297974272 ++read 2048/2048 bytes at offset 4297974272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297978368 ++read 2048/2048 bytes at offset 4297978368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297982464 ++read 2048/2048 bytes at offset 4297982464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297986560 ++read 2048/2048 bytes at offset 4297986560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297990656 ++read 2048/2048 bytes at offset 4297990656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297994752 ++read 2048/2048 bytes at offset 4297994752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297998848 ++read 2048/2048 bytes at offset 4297998848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298002944 ++read 2048/2048 bytes at offset 4298002944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298007040 ++read 2048/2048 bytes at offset 4298007040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298011136 ++read 2048/2048 bytes at offset 4298011136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298015232 ++read 2048/2048 bytes at offset 4298015232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298019328 ++read 2048/2048 bytes at offset 4298019328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298023424 ++read 2048/2048 bytes at offset 4298023424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298027520 ++read 2048/2048 bytes at offset 4298027520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298031616 ++read 2048/2048 bytes at offset 4298031616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298035712 ++read 2048/2048 bytes at offset 4298035712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298039808 ++read 2048/2048 bytes at offset 4298039808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298043904 ++read 2048/2048 bytes at offset 4298043904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298048000 ++read 2048/2048 bytes at offset 4298048000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298052096 ++read 2048/2048 bytes at offset 4298052096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298056192 ++read 2048/2048 bytes at offset 4298056192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298060288 ++read 2048/2048 bytes at offset 4298060288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298064384 ++read 2048/2048 bytes at offset 4298064384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298068480 ++read 2048/2048 bytes at offset 4298068480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298072576 ++read 2048/2048 bytes at offset 4298072576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298076672 ++read 2048/2048 bytes at offset 4298076672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298080768 ++read 2048/2048 bytes at offset 4298080768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298084864 ++read 2048/2048 bytes at offset 4298084864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298088960 ++read 2048/2048 bytes at offset 4298088960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298093056 ++read 2048/2048 bytes at offset 4298093056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298097152 ++read 2048/2048 bytes at offset 4298097152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298101248 ++read 2048/2048 bytes at offset 4298101248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298105344 ++read 2048/2048 bytes at offset 4298105344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298109440 ++read 2048/2048 bytes at offset 4298109440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 3 +-qemu-io> read 2048/2048 bytes at offset 4298114560 ++=== IO: pattern 3 ++read 2048/2048 bytes at offset 4298114560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298118656 ++read 2048/2048 bytes at offset 4298118656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298122752 ++read 2048/2048 bytes at offset 4298122752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298126848 ++read 2048/2048 bytes at offset 4298126848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298130944 ++read 2048/2048 bytes at offset 4298130944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298135040 ++read 2048/2048 bytes at offset 4298135040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298139136 ++read 2048/2048 bytes at offset 4298139136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298143232 ++read 2048/2048 bytes at offset 4298143232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298147328 ++read 2048/2048 bytes at offset 4298147328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298151424 ++read 2048/2048 bytes at offset 4298151424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298155520 ++read 2048/2048 bytes at offset 4298155520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298159616 ++read 2048/2048 bytes at offset 4298159616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298163712 ++read 2048/2048 bytes at offset 4298163712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298167808 ++read 2048/2048 bytes at offset 4298167808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298171904 ++read 2048/2048 bytes at offset 4298171904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298176000 ++read 2048/2048 bytes at offset 4298176000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298180096 ++read 2048/2048 bytes at offset 4298180096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298184192 ++read 2048/2048 bytes at offset 4298184192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298188288 ++read 2048/2048 bytes at offset 4298188288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298192384 ++read 2048/2048 bytes at offset 4298192384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298196480 ++read 2048/2048 bytes at offset 4298196480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298200576 ++read 2048/2048 bytes at offset 4298200576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298204672 ++read 2048/2048 bytes at offset 4298204672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298208768 ++read 2048/2048 bytes at offset 4298208768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298212864 ++read 2048/2048 bytes at offset 4298212864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298216960 ++read 2048/2048 bytes at offset 4298216960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298221056 ++read 2048/2048 bytes at offset 4298221056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298225152 ++read 2048/2048 bytes at offset 4298225152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298229248 ++read 2048/2048 bytes at offset 4298229248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298233344 ++read 2048/2048 bytes at offset 4298233344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298237440 ++read 2048/2048 bytes at offset 4298237440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298241536 ++read 2048/2048 bytes at offset 4298241536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298245632 ++read 2048/2048 bytes at offset 4298245632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298249728 ++read 2048/2048 bytes at offset 4298249728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298253824 ++read 2048/2048 bytes at offset 4298253824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298257920 ++read 2048/2048 bytes at offset 4298257920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298262016 ++read 2048/2048 bytes at offset 4298262016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298266112 ++read 2048/2048 bytes at offset 4298266112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298270208 ++read 2048/2048 bytes at offset 4298270208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298274304 ++read 2048/2048 bytes at offset 4298274304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298278400 ++read 2048/2048 bytes at offset 4298278400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298282496 ++read 2048/2048 bytes at offset 4298282496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298286592 ++read 2048/2048 bytes at offset 4298286592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298290688 ++read 2048/2048 bytes at offset 4298290688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298294784 ++read 2048/2048 bytes at offset 4298294784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298298880 ++read 2048/2048 bytes at offset 4298298880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298302976 ++read 2048/2048 bytes at offset 4298302976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298307072 ++read 2048/2048 bytes at offset 4298307072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298311168 ++read 2048/2048 bytes at offset 4298311168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298315264 ++read 2048/2048 bytes at offset 4298315264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298319360 ++read 2048/2048 bytes at offset 4298319360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298323456 ++read 2048/2048 bytes at offset 4298323456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298327552 ++read 2048/2048 bytes at offset 4298327552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298331648 ++read 2048/2048 bytes at offset 4298331648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298335744 ++read 2048/2048 bytes at offset 4298335744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298339840 ++read 2048/2048 bytes at offset 4298339840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298343936 ++read 2048/2048 bytes at offset 4298343936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298348032 ++read 2048/2048 bytes at offset 4298348032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298352128 ++read 2048/2048 bytes at offset 4298352128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298356224 ++read 2048/2048 bytes at offset 4298356224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298360320 ++read 2048/2048 bytes at offset 4298360320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298364416 ++read 2048/2048 bytes at offset 4298364416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298368512 ++read 2048/2048 bytes at offset 4298368512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298372608 ++read 2048/2048 bytes at offset 4298372608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298376704 ++read 2048/2048 bytes at offset 4298376704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298380800 ++read 2048/2048 bytes at offset 4298380800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298384896 ++read 2048/2048 bytes at offset 4298384896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298388992 ++read 2048/2048 bytes at offset 4298388992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298393088 ++read 2048/2048 bytes at offset 4298393088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298397184 ++read 2048/2048 bytes at offset 4298397184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298401280 ++read 2048/2048 bytes at offset 4298401280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298405376 ++read 2048/2048 bytes at offset 4298405376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298409472 ++read 2048/2048 bytes at offset 4298409472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298413568 ++read 2048/2048 bytes at offset 4298413568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298417664 ++read 2048/2048 bytes at offset 4298417664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298421760 ++read 2048/2048 bytes at offset 4298421760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298425856 ++read 2048/2048 bytes at offset 4298425856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298429952 ++read 2048/2048 bytes at offset 4298429952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298434048 ++read 2048/2048 bytes at offset 4298434048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298438144 ++read 2048/2048 bytes at offset 4298438144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298442240 ++read 2048/2048 bytes at offset 4298442240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298446336 ++read 2048/2048 bytes at offset 4298446336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298450432 ++read 2048/2048 bytes at offset 4298450432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298454528 ++read 2048/2048 bytes at offset 4298454528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298458624 ++read 2048/2048 bytes at offset 4298458624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298462720 ++read 2048/2048 bytes at offset 4298462720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298466816 ++read 2048/2048 bytes at offset 4298466816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298470912 ++read 2048/2048 bytes at offset 4298470912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298475008 ++read 2048/2048 bytes at offset 4298475008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298479104 ++read 2048/2048 bytes at offset 4298479104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298483200 ++read 2048/2048 bytes at offset 4298483200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298487296 ++read 2048/2048 bytes at offset 4298487296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298491392 ++read 2048/2048 bytes at offset 4298491392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298495488 ++read 2048/2048 bytes at offset 4298495488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298499584 ++read 2048/2048 bytes at offset 4298499584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298503680 ++read 2048/2048 bytes at offset 4298503680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298507776 ++read 2048/2048 bytes at offset 4298507776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298511872 ++read 2048/2048 bytes at offset 4298511872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298515968 ++read 2048/2048 bytes at offset 4298515968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298520064 ++read 2048/2048 bytes at offset 4298520064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298524160 ++read 2048/2048 bytes at offset 4298524160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298528256 ++read 2048/2048 bytes at offset 4298528256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298532352 ++read 2048/2048 bytes at offset 4298532352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298536448 ++read 2048/2048 bytes at offset 4298536448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298540544 ++read 2048/2048 bytes at offset 4298540544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298544640 ++read 2048/2048 bytes at offset 4298544640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298548736 ++read 2048/2048 bytes at offset 4298548736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298552832 ++read 2048/2048 bytes at offset 4298552832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298556928 ++read 2048/2048 bytes at offset 4298556928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298561024 ++read 2048/2048 bytes at offset 4298561024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298565120 ++read 2048/2048 bytes at offset 4298565120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298569216 ++read 2048/2048 bytes at offset 4298569216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298573312 ++read 2048/2048 bytes at offset 4298573312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298577408 ++read 2048/2048 bytes at offset 4298577408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298581504 ++read 2048/2048 bytes at offset 4298581504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298585600 ++read 2048/2048 bytes at offset 4298585600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298589696 ++read 2048/2048 bytes at offset 4298589696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298593792 ++read 2048/2048 bytes at offset 4298593792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298597888 ++read 2048/2048 bytes at offset 4298597888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298601984 ++read 2048/2048 bytes at offset 4298601984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298606080 ++read 2048/2048 bytes at offset 4298606080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298610176 ++read 2048/2048 bytes at offset 4298610176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298614272 ++read 2048/2048 bytes at offset 4298614272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298618368 ++read 2048/2048 bytes at offset 4298618368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298622464 ++read 2048/2048 bytes at offset 4298622464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298626560 ++read 2048/2048 bytes at offset 4298626560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298630656 ++read 2048/2048 bytes at offset 4298630656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298634752 ++read 2048/2048 bytes at offset 4298634752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298638848 ++read 2048/2048 bytes at offset 4298638848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298642944 ++read 2048/2048 bytes at offset 4298642944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298647040 ++read 2048/2048 bytes at offset 4298647040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298651136 ++read 2048/2048 bytes at offset 4298651136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298655232 ++read 2048/2048 bytes at offset 4298655232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298659328 ++read 2048/2048 bytes at offset 4298659328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298663424 ++read 2048/2048 bytes at offset 4298663424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298667520 ++read 2048/2048 bytes at offset 4298667520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298671616 ++read 2048/2048 bytes at offset 4298671616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298675712 ++read 2048/2048 bytes at offset 4298675712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298679808 ++read 2048/2048 bytes at offset 4298679808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298683904 ++read 2048/2048 bytes at offset 4298683904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298688000 ++read 2048/2048 bytes at offset 4298688000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298692096 ++read 2048/2048 bytes at offset 4298692096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298696192 ++read 2048/2048 bytes at offset 4298696192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298700288 ++read 2048/2048 bytes at offset 4298700288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298704384 ++read 2048/2048 bytes at offset 4298704384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298708480 ++read 2048/2048 bytes at offset 4298708480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298712576 ++read 2048/2048 bytes at offset 4298712576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298716672 ++read 2048/2048 bytes at offset 4298716672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298720768 ++read 2048/2048 bytes at offset 4298720768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298724864 ++read 2048/2048 bytes at offset 4298724864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298728960 ++read 2048/2048 bytes at offset 4298728960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298733056 ++read 2048/2048 bytes at offset 4298733056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298737152 ++read 2048/2048 bytes at offset 4298737152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298741248 ++read 2048/2048 bytes at offset 4298741248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298745344 ++read 2048/2048 bytes at offset 4298745344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298749440 ++read 2048/2048 bytes at offset 4298749440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298753536 ++read 2048/2048 bytes at offset 4298753536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298757632 ++read 2048/2048 bytes at offset 4298757632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298761728 ++read 2048/2048 bytes at offset 4298761728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298765824 ++read 2048/2048 bytes at offset 4298765824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298769920 ++read 2048/2048 bytes at offset 4298769920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298774016 ++read 2048/2048 bytes at offset 4298774016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298778112 ++read 2048/2048 bytes at offset 4298778112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298782208 ++read 2048/2048 bytes at offset 4298782208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298786304 ++read 2048/2048 bytes at offset 4298786304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298790400 ++read 2048/2048 bytes at offset 4298790400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298794496 ++read 2048/2048 bytes at offset 4298794496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298798592 ++read 2048/2048 bytes at offset 4298798592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298802688 ++read 2048/2048 bytes at offset 4298802688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298806784 ++read 2048/2048 bytes at offset 4298806784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298810880 ++read 2048/2048 bytes at offset 4298810880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298814976 ++read 2048/2048 bytes at offset 4298814976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298819072 ++read 2048/2048 bytes at offset 4298819072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298823168 ++read 2048/2048 bytes at offset 4298823168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298827264 ++read 2048/2048 bytes at offset 4298827264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298831360 ++read 2048/2048 bytes at offset 4298831360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298835456 ++read 2048/2048 bytes at offset 4298835456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298839552 ++read 2048/2048 bytes at offset 4298839552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298843648 ++read 2048/2048 bytes at offset 4298843648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298847744 ++read 2048/2048 bytes at offset 4298847744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298851840 ++read 2048/2048 bytes at offset 4298851840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298855936 ++read 2048/2048 bytes at offset 4298855936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298860032 ++read 2048/2048 bytes at offset 4298860032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298864128 ++read 2048/2048 bytes at offset 4298864128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298868224 ++read 2048/2048 bytes at offset 4298868224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298872320 ++read 2048/2048 bytes at offset 4298872320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298876416 ++read 2048/2048 bytes at offset 4298876416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298880512 ++read 2048/2048 bytes at offset 4298880512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298884608 ++read 2048/2048 bytes at offset 4298884608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298888704 ++read 2048/2048 bytes at offset 4298888704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298892800 ++read 2048/2048 bytes at offset 4298892800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298896896 ++read 2048/2048 bytes at offset 4298896896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298900992 ++read 2048/2048 bytes at offset 4298900992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298905088 ++read 2048/2048 bytes at offset 4298905088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298909184 ++read 2048/2048 bytes at offset 4298909184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298913280 ++read 2048/2048 bytes at offset 4298913280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298917376 ++read 2048/2048 bytes at offset 4298917376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298921472 ++read 2048/2048 bytes at offset 4298921472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298925568 ++read 2048/2048 bytes at offset 4298925568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298929664 ++read 2048/2048 bytes at offset 4298929664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298933760 ++read 2048/2048 bytes at offset 4298933760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298937856 ++read 2048/2048 bytes at offset 4298937856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298941952 ++read 2048/2048 bytes at offset 4298941952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298946048 ++read 2048/2048 bytes at offset 4298946048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298950144 ++read 2048/2048 bytes at offset 4298950144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298954240 ++read 2048/2048 bytes at offset 4298954240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298958336 ++read 2048/2048 bytes at offset 4298958336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298962432 ++read 2048/2048 bytes at offset 4298962432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298966528 ++read 2048/2048 bytes at offset 4298966528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298970624 ++read 2048/2048 bytes at offset 4298970624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298974720 ++read 2048/2048 bytes at offset 4298974720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298978816 ++read 2048/2048 bytes at offset 4298978816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298982912 ++read 2048/2048 bytes at offset 4298982912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298987008 ++read 2048/2048 bytes at offset 4298987008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298991104 ++read 2048/2048 bytes at offset 4298991104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298995200 ++read 2048/2048 bytes at offset 4298995200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298999296 ++read 2048/2048 bytes at offset 4298999296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299003392 ++read 2048/2048 bytes at offset 4299003392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299007488 ++read 2048/2048 bytes at offset 4299007488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299011584 ++read 2048/2048 bytes at offset 4299011584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299015680 ++read 2048/2048 bytes at offset 4299015680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299019776 ++read 2048/2048 bytes at offset 4299019776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299023872 ++read 2048/2048 bytes at offset 4299023872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299027968 ++read 2048/2048 bytes at offset 4299027968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299032064 ++read 2048/2048 bytes at offset 4299032064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299036160 ++read 2048/2048 bytes at offset 4299036160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299040256 ++read 2048/2048 bytes at offset 4299040256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299044352 ++read 2048/2048 bytes at offset 4299044352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299048448 ++read 2048/2048 bytes at offset 4299048448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299052544 ++read 2048/2048 bytes at offset 4299052544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299056640 ++read 2048/2048 bytes at offset 4299056640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299060736 ++read 2048/2048 bytes at offset 4299060736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299064832 ++read 2048/2048 bytes at offset 4299064832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299068928 ++read 2048/2048 bytes at offset 4299068928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299073024 ++read 2048/2048 bytes at offset 4299073024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299077120 ++read 2048/2048 bytes at offset 4299077120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299081216 ++read 2048/2048 bytes at offset 4299081216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299085312 ++read 2048/2048 bytes at offset 4299085312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299089408 ++read 2048/2048 bytes at offset 4299089408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299093504 ++read 2048/2048 bytes at offset 4299093504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299097600 ++read 2048/2048 bytes at offset 4299097600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299101696 ++read 2048/2048 bytes at offset 4299101696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299105792 ++read 2048/2048 bytes at offset 4299105792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299109888 ++read 2048/2048 bytes at offset 4299109888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299113984 ++read 2048/2048 bytes at offset 4299113984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299118080 ++read 2048/2048 bytes at offset 4299118080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299122176 ++read 2048/2048 bytes at offset 4299122176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299126272 ++read 2048/2048 bytes at offset 4299126272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299130368 ++read 2048/2048 bytes at offset 4299130368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299134464 ++read 2048/2048 bytes at offset 4299134464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299138560 ++read 2048/2048 bytes at offset 4299138560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299142656 ++read 2048/2048 bytes at offset 4299142656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299146752 ++read 2048/2048 bytes at offset 4299146752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299150848 ++read 2048/2048 bytes at offset 4299150848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299154944 ++read 2048/2048 bytes at offset 4299154944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299159040 ++read 2048/2048 bytes at offset 4299159040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 5 +-qemu-io> read 8192/8192 bytes at offset 4299164160 ++=== IO: pattern 5 ++read 8192/8192 bytes at offset 4299164160 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299176448 ++read 8192/8192 bytes at offset 4299176448 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299188736 ++read 8192/8192 bytes at offset 4299188736 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299201024 ++read 8192/8192 bytes at offset 4299201024 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299213312 ++read 8192/8192 bytes at offset 4299213312 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299225600 ++read 8192/8192 bytes at offset 4299225600 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299237888 ++read 8192/8192 bytes at offset 4299237888 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299250176 ++read 8192/8192 bytes at offset 4299250176 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299262464 ++read 8192/8192 bytes at offset 4299262464 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299274752 ++read 8192/8192 bytes at offset 4299274752 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299287040 ++read 8192/8192 bytes at offset 4299287040 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299299328 ++read 8192/8192 bytes at offset 4299299328 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299311616 ++read 8192/8192 bytes at offset 4299311616 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299323904 ++read 8192/8192 bytes at offset 4299323904 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299336192 ++read 8192/8192 bytes at offset 4299336192 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299348480 ++read 8192/8192 bytes at offset 4299348480 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299360768 ++read 8192/8192 bytes at offset 4299360768 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299373056 ++read 8192/8192 bytes at offset 4299373056 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299385344 ++read 8192/8192 bytes at offset 4299385344 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299397632 ++read 8192/8192 bytes at offset 4299397632 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299409920 ++read 8192/8192 bytes at offset 4299409920 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299422208 ++read 8192/8192 bytes at offset 4299422208 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299434496 ++read 8192/8192 bytes at offset 4299434496 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299446784 ++read 8192/8192 bytes at offset 4299446784 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299459072 ++read 8192/8192 bytes at offset 4299459072 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299471360 ++read 8192/8192 bytes at offset 4299471360 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299483648 ++read 8192/8192 bytes at offset 4299483648 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299495936 ++read 8192/8192 bytes at offset 4299495936 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299508224 ++read 8192/8192 bytes at offset 4299508224 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299520512 ++read 8192/8192 bytes at offset 4299520512 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299532800 ++read 8192/8192 bytes at offset 4299532800 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299545088 ++read 8192/8192 bytes at offset 4299545088 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299557376 ++read 8192/8192 bytes at offset 4299557376 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299569664 ++read 8192/8192 bytes at offset 4299569664 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299581952 ++read 8192/8192 bytes at offset 4299581952 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299594240 ++read 8192/8192 bytes at offset 4299594240 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299606528 ++read 8192/8192 bytes at offset 4299606528 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299618816 ++read 8192/8192 bytes at offset 4299618816 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299631104 ++read 8192/8192 bytes at offset 4299631104 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299643392 ++read 8192/8192 bytes at offset 4299643392 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299655680 ++read 8192/8192 bytes at offset 4299655680 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299667968 ++read 8192/8192 bytes at offset 4299667968 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299680256 ++read 8192/8192 bytes at offset 4299680256 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299692544 ++read 8192/8192 bytes at offset 4299692544 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299704832 ++read 8192/8192 bytes at offset 4299704832 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299717120 ++read 8192/8192 bytes at offset 4299717120 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299729408 ++read 8192/8192 bytes at offset 4299729408 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299741696 ++read 8192/8192 bytes at offset 4299741696 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299753984 ++read 8192/8192 bytes at offset 4299753984 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299766272 ++read 8192/8192 bytes at offset 4299766272 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299778560 ++read 8192/8192 bytes at offset 4299778560 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299790848 ++read 8192/8192 bytes at offset 4299790848 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299803136 ++read 8192/8192 bytes at offset 4299803136 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299815424 ++read 8192/8192 bytes at offset 4299815424 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299827712 ++read 8192/8192 bytes at offset 4299827712 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299840000 ++read 8192/8192 bytes at offset 4299840000 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299852288 ++read 8192/8192 bytes at offset 4299852288 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299864576 ++read 8192/8192 bytes at offset 4299864576 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299876864 ++read 8192/8192 bytes at offset 4299876864 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299889152 ++read 8192/8192 bytes at offset 4299889152 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299901440 ++read 8192/8192 bytes at offset 4299901440 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299913728 ++read 8192/8192 bytes at offset 4299913728 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299926016 ++read 8192/8192 bytes at offset 4299926016 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299938304 ++read 8192/8192 bytes at offset 4299938304 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 244 +-qemu-io> read 12288/12288 bytes at offset 4301252608 ++=== IO: pattern 244 ++read 12288/12288 bytes at offset 4301252608 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4303351808 ++read 12288/12288 bytes at offset 4303351808 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4305451008 ++read 12288/12288 bytes at offset 4305451008 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4307550208 ++read 12288/12288 bytes at offset 4307550208 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4309649408 ++read 12288/12288 bytes at offset 4309649408 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4311748608 ++read 12288/12288 bytes at offset 4311748608 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4313847808 ++read 12288/12288 bytes at offset 4313847808 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4315947008 ++read 12288/12288 bytes at offset 4315947008 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> No errors were found on the image. ++No errors were found on the image. + *** done +diff --git a/tests/qemu-iotests/014.out b/tests/qemu-iotests/014.out +index 0258d75..4744b4b 100644 +--- a/tests/qemu-iotests/014.out ++++ b/tests/qemu-iotests/014.out +@@ -4,64071 +4,64071 @@ Testing empty image: + test2: With offset 0 + === Clusters to be compressed [1] + === IO: pattern 165 +-qemu-io> wrote 4096/4096 bytes at offset 16384 ++wrote 4096/4096 bytes at offset 16384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 53248 ++wrote 4096/4096 bytes at offset 53248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 90112 ++wrote 4096/4096 bytes at offset 90112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 126976 ++wrote 4096/4096 bytes at offset 126976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 163840 ++wrote 4096/4096 bytes at offset 163840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 200704 ++wrote 4096/4096 bytes at offset 200704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 237568 ++wrote 4096/4096 bytes at offset 237568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 274432 ++wrote 4096/4096 bytes at offset 274432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 311296 ++wrote 4096/4096 bytes at offset 311296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 348160 ++wrote 4096/4096 bytes at offset 348160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 385024 ++wrote 4096/4096 bytes at offset 385024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 421888 ++wrote 4096/4096 bytes at offset 421888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 458752 ++wrote 4096/4096 bytes at offset 458752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 495616 ++wrote 4096/4096 bytes at offset 495616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 532480 ++wrote 4096/4096 bytes at offset 532480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 569344 ++wrote 4096/4096 bytes at offset 569344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 606208 ++wrote 4096/4096 bytes at offset 606208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 643072 ++wrote 4096/4096 bytes at offset 643072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 679936 ++wrote 4096/4096 bytes at offset 679936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 716800 ++wrote 4096/4096 bytes at offset 716800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 753664 ++wrote 4096/4096 bytes at offset 753664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 790528 ++wrote 4096/4096 bytes at offset 790528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 827392 ++wrote 4096/4096 bytes at offset 827392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 864256 ++wrote 4096/4096 bytes at offset 864256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 901120 ++wrote 4096/4096 bytes at offset 901120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 937984 ++wrote 4096/4096 bytes at offset 937984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 974848 ++wrote 4096/4096 bytes at offset 974848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1011712 ++wrote 4096/4096 bytes at offset 1011712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1048576 ++wrote 4096/4096 bytes at offset 1048576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1085440 ++wrote 4096/4096 bytes at offset 1085440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1122304 ++wrote 4096/4096 bytes at offset 1122304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1159168 ++wrote 4096/4096 bytes at offset 1159168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1196032 ++wrote 4096/4096 bytes at offset 1196032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1232896 ++wrote 4096/4096 bytes at offset 1232896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1269760 ++wrote 4096/4096 bytes at offset 1269760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1306624 ++wrote 4096/4096 bytes at offset 1306624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1343488 ++wrote 4096/4096 bytes at offset 1343488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1380352 ++wrote 4096/4096 bytes at offset 1380352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1417216 ++wrote 4096/4096 bytes at offset 1417216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1454080 ++wrote 4096/4096 bytes at offset 1454080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1490944 ++wrote 4096/4096 bytes at offset 1490944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1527808 ++wrote 4096/4096 bytes at offset 1527808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1564672 ++wrote 4096/4096 bytes at offset 1564672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1601536 ++wrote 4096/4096 bytes at offset 1601536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1638400 ++wrote 4096/4096 bytes at offset 1638400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1675264 ++wrote 4096/4096 bytes at offset 1675264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1712128 ++wrote 4096/4096 bytes at offset 1712128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1748992 ++wrote 4096/4096 bytes at offset 1748992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1785856 ++wrote 4096/4096 bytes at offset 1785856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1822720 ++wrote 4096/4096 bytes at offset 1822720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1859584 ++wrote 4096/4096 bytes at offset 1859584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1896448 ++wrote 4096/4096 bytes at offset 1896448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1933312 ++wrote 4096/4096 bytes at offset 1933312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1970176 ++wrote 4096/4096 bytes at offset 1970176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2007040 ++wrote 4096/4096 bytes at offset 2007040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2043904 ++wrote 4096/4096 bytes at offset 2043904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2080768 ++wrote 4096/4096 bytes at offset 2080768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2117632 ++wrote 4096/4096 bytes at offset 2117632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2154496 ++wrote 4096/4096 bytes at offset 2154496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2191360 ++wrote 4096/4096 bytes at offset 2191360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2228224 ++wrote 4096/4096 bytes at offset 2228224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2265088 ++wrote 4096/4096 bytes at offset 2265088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2301952 ++wrote 4096/4096 bytes at offset 2301952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2338816 ++wrote 4096/4096 bytes at offset 2338816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2375680 ++wrote 4096/4096 bytes at offset 2375680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2412544 ++wrote 4096/4096 bytes at offset 2412544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2449408 ++wrote 4096/4096 bytes at offset 2449408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2486272 ++wrote 4096/4096 bytes at offset 2486272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2523136 ++wrote 4096/4096 bytes at offset 2523136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2560000 ++wrote 4096/4096 bytes at offset 2560000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2596864 ++wrote 4096/4096 bytes at offset 2596864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2633728 ++wrote 4096/4096 bytes at offset 2633728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2670592 ++wrote 4096/4096 bytes at offset 2670592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2707456 ++wrote 4096/4096 bytes at offset 2707456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2744320 ++wrote 4096/4096 bytes at offset 2744320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2781184 ++wrote 4096/4096 bytes at offset 2781184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2818048 ++wrote 4096/4096 bytes at offset 2818048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2854912 ++wrote 4096/4096 bytes at offset 2854912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2891776 ++wrote 4096/4096 bytes at offset 2891776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2928640 ++wrote 4096/4096 bytes at offset 2928640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2965504 ++wrote 4096/4096 bytes at offset 2965504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3002368 ++wrote 4096/4096 bytes at offset 3002368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3039232 ++wrote 4096/4096 bytes at offset 3039232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3076096 ++wrote 4096/4096 bytes at offset 3076096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3112960 ++wrote 4096/4096 bytes at offset 3112960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3149824 ++wrote 4096/4096 bytes at offset 3149824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3186688 ++wrote 4096/4096 bytes at offset 3186688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3223552 ++wrote 4096/4096 bytes at offset 3223552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3260416 ++wrote 4096/4096 bytes at offset 3260416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3297280 ++wrote 4096/4096 bytes at offset 3297280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3334144 ++wrote 4096/4096 bytes at offset 3334144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3371008 ++wrote 4096/4096 bytes at offset 3371008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3407872 ++wrote 4096/4096 bytes at offset 3407872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3444736 ++wrote 4096/4096 bytes at offset 3444736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3481600 ++wrote 4096/4096 bytes at offset 3481600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3518464 ++wrote 4096/4096 bytes at offset 3518464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3555328 ++wrote 4096/4096 bytes at offset 3555328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3592192 ++wrote 4096/4096 bytes at offset 3592192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3629056 ++wrote 4096/4096 bytes at offset 3629056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3665920 ++wrote 4096/4096 bytes at offset 3665920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3702784 ++wrote 4096/4096 bytes at offset 3702784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3739648 ++wrote 4096/4096 bytes at offset 3739648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3776512 ++wrote 4096/4096 bytes at offset 3776512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3813376 ++wrote 4096/4096 bytes at offset 3813376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3850240 ++wrote 4096/4096 bytes at offset 3850240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3887104 ++wrote 4096/4096 bytes at offset 3887104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3923968 ++wrote 4096/4096 bytes at offset 3923968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3960832 ++wrote 4096/4096 bytes at offset 3960832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3997696 ++wrote 4096/4096 bytes at offset 3997696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4034560 ++wrote 4096/4096 bytes at offset 4034560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4071424 ++wrote 4096/4096 bytes at offset 4071424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4108288 ++wrote 4096/4096 bytes at offset 4108288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4145152 ++wrote 4096/4096 bytes at offset 4145152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4182016 ++wrote 4096/4096 bytes at offset 4182016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4218880 ++wrote 4096/4096 bytes at offset 4218880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4255744 ++wrote 4096/4096 bytes at offset 4255744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4292608 ++wrote 4096/4096 bytes at offset 4292608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4329472 ++wrote 4096/4096 bytes at offset 4329472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4366336 ++wrote 4096/4096 bytes at offset 4366336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4403200 ++wrote 4096/4096 bytes at offset 4403200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4440064 ++wrote 4096/4096 bytes at offset 4440064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4476928 ++wrote 4096/4096 bytes at offset 4476928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4513792 ++wrote 4096/4096 bytes at offset 4513792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4550656 ++wrote 4096/4096 bytes at offset 4550656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4587520 ++wrote 4096/4096 bytes at offset 4587520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4624384 ++wrote 4096/4096 bytes at offset 4624384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4661248 ++wrote 4096/4096 bytes at offset 4661248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4698112 ++wrote 4096/4096 bytes at offset 4698112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4734976 ++wrote 4096/4096 bytes at offset 4734976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4771840 ++wrote 4096/4096 bytes at offset 4771840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4808704 ++wrote 4096/4096 bytes at offset 4808704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4845568 ++wrote 4096/4096 bytes at offset 4845568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4882432 ++wrote 4096/4096 bytes at offset 4882432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4919296 ++wrote 4096/4096 bytes at offset 4919296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4956160 ++wrote 4096/4096 bytes at offset 4956160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4993024 ++wrote 4096/4096 bytes at offset 4993024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5029888 ++wrote 4096/4096 bytes at offset 5029888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5066752 ++wrote 4096/4096 bytes at offset 5066752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5103616 ++wrote 4096/4096 bytes at offset 5103616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5140480 ++wrote 4096/4096 bytes at offset 5140480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5177344 ++wrote 4096/4096 bytes at offset 5177344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5214208 ++wrote 4096/4096 bytes at offset 5214208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5251072 ++wrote 4096/4096 bytes at offset 5251072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5287936 ++wrote 4096/4096 bytes at offset 5287936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5324800 ++wrote 4096/4096 bytes at offset 5324800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5361664 ++wrote 4096/4096 bytes at offset 5361664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5398528 ++wrote 4096/4096 bytes at offset 5398528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5435392 ++wrote 4096/4096 bytes at offset 5435392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5472256 ++wrote 4096/4096 bytes at offset 5472256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5509120 ++wrote 4096/4096 bytes at offset 5509120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5545984 ++wrote 4096/4096 bytes at offset 5545984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5582848 ++wrote 4096/4096 bytes at offset 5582848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5619712 ++wrote 4096/4096 bytes at offset 5619712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5656576 ++wrote 4096/4096 bytes at offset 5656576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5693440 ++wrote 4096/4096 bytes at offset 5693440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5730304 ++wrote 4096/4096 bytes at offset 5730304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5767168 ++wrote 4096/4096 bytes at offset 5767168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5804032 ++wrote 4096/4096 bytes at offset 5804032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5840896 ++wrote 4096/4096 bytes at offset 5840896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5877760 ++wrote 4096/4096 bytes at offset 5877760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5914624 ++wrote 4096/4096 bytes at offset 5914624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5951488 ++wrote 4096/4096 bytes at offset 5951488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5988352 ++wrote 4096/4096 bytes at offset 5988352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6025216 ++wrote 4096/4096 bytes at offset 6025216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6062080 ++wrote 4096/4096 bytes at offset 6062080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6098944 ++wrote 4096/4096 bytes at offset 6098944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6135808 ++wrote 4096/4096 bytes at offset 6135808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6172672 ++wrote 4096/4096 bytes at offset 6172672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6209536 ++wrote 4096/4096 bytes at offset 6209536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6246400 ++wrote 4096/4096 bytes at offset 6246400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6283264 ++wrote 4096/4096 bytes at offset 6283264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6320128 ++wrote 4096/4096 bytes at offset 6320128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6356992 ++wrote 4096/4096 bytes at offset 6356992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6393856 ++wrote 4096/4096 bytes at offset 6393856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6430720 ++wrote 4096/4096 bytes at offset 6430720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6467584 ++wrote 4096/4096 bytes at offset 6467584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6504448 ++wrote 4096/4096 bytes at offset 6504448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6541312 ++wrote 4096/4096 bytes at offset 6541312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6578176 ++wrote 4096/4096 bytes at offset 6578176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6615040 ++wrote 4096/4096 bytes at offset 6615040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6651904 ++wrote 4096/4096 bytes at offset 6651904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6688768 ++wrote 4096/4096 bytes at offset 6688768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6725632 ++wrote 4096/4096 bytes at offset 6725632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6762496 ++wrote 4096/4096 bytes at offset 6762496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6799360 ++wrote 4096/4096 bytes at offset 6799360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6836224 ++wrote 4096/4096 bytes at offset 6836224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6873088 ++wrote 4096/4096 bytes at offset 6873088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6909952 ++wrote 4096/4096 bytes at offset 6909952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6946816 ++wrote 4096/4096 bytes at offset 6946816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6983680 ++wrote 4096/4096 bytes at offset 6983680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7020544 ++wrote 4096/4096 bytes at offset 7020544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7057408 ++wrote 4096/4096 bytes at offset 7057408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7094272 ++wrote 4096/4096 bytes at offset 7094272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7131136 ++wrote 4096/4096 bytes at offset 7131136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7168000 ++wrote 4096/4096 bytes at offset 7168000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7204864 ++wrote 4096/4096 bytes at offset 7204864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7241728 ++wrote 4096/4096 bytes at offset 7241728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7278592 ++wrote 4096/4096 bytes at offset 7278592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7315456 ++wrote 4096/4096 bytes at offset 7315456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7352320 ++wrote 4096/4096 bytes at offset 7352320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7389184 ++wrote 4096/4096 bytes at offset 7389184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7426048 ++wrote 4096/4096 bytes at offset 7426048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7462912 ++wrote 4096/4096 bytes at offset 7462912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7499776 ++wrote 4096/4096 bytes at offset 7499776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7536640 ++wrote 4096/4096 bytes at offset 7536640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7573504 ++wrote 4096/4096 bytes at offset 7573504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7610368 ++wrote 4096/4096 bytes at offset 7610368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7647232 ++wrote 4096/4096 bytes at offset 7647232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7684096 ++wrote 4096/4096 bytes at offset 7684096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7720960 ++wrote 4096/4096 bytes at offset 7720960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7757824 ++wrote 4096/4096 bytes at offset 7757824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7794688 ++wrote 4096/4096 bytes at offset 7794688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7831552 ++wrote 4096/4096 bytes at offset 7831552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7868416 ++wrote 4096/4096 bytes at offset 7868416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7905280 ++wrote 4096/4096 bytes at offset 7905280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7942144 ++wrote 4096/4096 bytes at offset 7942144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7979008 ++wrote 4096/4096 bytes at offset 7979008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8015872 ++wrote 4096/4096 bytes at offset 8015872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8052736 ++wrote 4096/4096 bytes at offset 8052736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8089600 ++wrote 4096/4096 bytes at offset 8089600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8126464 ++wrote 4096/4096 bytes at offset 8126464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8163328 ++wrote 4096/4096 bytes at offset 8163328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8200192 ++wrote 4096/4096 bytes at offset 8200192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8237056 ++wrote 4096/4096 bytes at offset 8237056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8273920 ++wrote 4096/4096 bytes at offset 8273920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8310784 ++wrote 4096/4096 bytes at offset 8310784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8347648 ++wrote 4096/4096 bytes at offset 8347648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8384512 ++wrote 4096/4096 bytes at offset 8384512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8421376 ++wrote 4096/4096 bytes at offset 8421376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8458240 ++wrote 4096/4096 bytes at offset 8458240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8495104 ++wrote 4096/4096 bytes at offset 8495104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8531968 ++wrote 4096/4096 bytes at offset 8531968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8568832 ++wrote 4096/4096 bytes at offset 8568832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8605696 ++wrote 4096/4096 bytes at offset 8605696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8642560 ++wrote 4096/4096 bytes at offset 8642560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8679424 ++wrote 4096/4096 bytes at offset 8679424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8716288 ++wrote 4096/4096 bytes at offset 8716288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8753152 ++wrote 4096/4096 bytes at offset 8753152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8790016 ++wrote 4096/4096 bytes at offset 8790016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8826880 ++wrote 4096/4096 bytes at offset 8826880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8863744 ++wrote 4096/4096 bytes at offset 8863744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8900608 ++wrote 4096/4096 bytes at offset 8900608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8937472 ++wrote 4096/4096 bytes at offset 8937472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8974336 ++wrote 4096/4096 bytes at offset 8974336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 9011200 ++wrote 4096/4096 bytes at offset 9011200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 9048064 ++wrote 4096/4096 bytes at offset 9048064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 9084928 ++wrote 4096/4096 bytes at offset 9084928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 9121792 ++wrote 4096/4096 bytes at offset 9121792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 9158656 ++wrote 4096/4096 bytes at offset 9158656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 9195520 ++wrote 4096/4096 bytes at offset 9195520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 9232384 ++wrote 4096/4096 bytes at offset 9232384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 9269248 ++wrote 4096/4096 bytes at offset 9269248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 9306112 ++wrote 4096/4096 bytes at offset 9306112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 9342976 ++wrote 4096/4096 bytes at offset 9342976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 9379840 ++wrote 4096/4096 bytes at offset 9379840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 9416704 ++wrote 4096/4096 bytes at offset 9416704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === Clusters to be compressed [2] ++=== Clusters to be compressed [2] + === IO: pattern 165 +-qemu-io> wrote 4096/4096 bytes at offset 20480 ++wrote 4096/4096 bytes at offset 20480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 57344 ++wrote 4096/4096 bytes at offset 57344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 94208 ++wrote 4096/4096 bytes at offset 94208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 131072 ++wrote 4096/4096 bytes at offset 131072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 167936 ++wrote 4096/4096 bytes at offset 167936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 204800 ++wrote 4096/4096 bytes at offset 204800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 241664 ++wrote 4096/4096 bytes at offset 241664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 278528 ++wrote 4096/4096 bytes at offset 278528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 315392 ++wrote 4096/4096 bytes at offset 315392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 352256 ++wrote 4096/4096 bytes at offset 352256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 389120 ++wrote 4096/4096 bytes at offset 389120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 425984 ++wrote 4096/4096 bytes at offset 425984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 462848 ++wrote 4096/4096 bytes at offset 462848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 499712 ++wrote 4096/4096 bytes at offset 499712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 536576 ++wrote 4096/4096 bytes at offset 536576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 573440 ++wrote 4096/4096 bytes at offset 573440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 610304 ++wrote 4096/4096 bytes at offset 610304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 647168 ++wrote 4096/4096 bytes at offset 647168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 684032 ++wrote 4096/4096 bytes at offset 684032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 720896 ++wrote 4096/4096 bytes at offset 720896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 757760 ++wrote 4096/4096 bytes at offset 757760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 794624 ++wrote 4096/4096 bytes at offset 794624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 831488 ++wrote 4096/4096 bytes at offset 831488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 868352 ++wrote 4096/4096 bytes at offset 868352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 905216 ++wrote 4096/4096 bytes at offset 905216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 942080 ++wrote 4096/4096 bytes at offset 942080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 978944 ++wrote 4096/4096 bytes at offset 978944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1015808 ++wrote 4096/4096 bytes at offset 1015808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1052672 ++wrote 4096/4096 bytes at offset 1052672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1089536 ++wrote 4096/4096 bytes at offset 1089536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1126400 ++wrote 4096/4096 bytes at offset 1126400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1163264 ++wrote 4096/4096 bytes at offset 1163264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1200128 ++wrote 4096/4096 bytes at offset 1200128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1236992 ++wrote 4096/4096 bytes at offset 1236992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1273856 ++wrote 4096/4096 bytes at offset 1273856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1310720 ++wrote 4096/4096 bytes at offset 1310720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1347584 ++wrote 4096/4096 bytes at offset 1347584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1384448 ++wrote 4096/4096 bytes at offset 1384448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1421312 ++wrote 4096/4096 bytes at offset 1421312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1458176 ++wrote 4096/4096 bytes at offset 1458176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1495040 ++wrote 4096/4096 bytes at offset 1495040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1531904 ++wrote 4096/4096 bytes at offset 1531904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1568768 ++wrote 4096/4096 bytes at offset 1568768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1605632 ++wrote 4096/4096 bytes at offset 1605632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1642496 ++wrote 4096/4096 bytes at offset 1642496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1679360 ++wrote 4096/4096 bytes at offset 1679360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1716224 ++wrote 4096/4096 bytes at offset 1716224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1753088 ++wrote 4096/4096 bytes at offset 1753088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1789952 ++wrote 4096/4096 bytes at offset 1789952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1826816 ++wrote 4096/4096 bytes at offset 1826816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1863680 ++wrote 4096/4096 bytes at offset 1863680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1900544 ++wrote 4096/4096 bytes at offset 1900544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1937408 ++wrote 4096/4096 bytes at offset 1937408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1974272 ++wrote 4096/4096 bytes at offset 1974272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2011136 ++wrote 4096/4096 bytes at offset 2011136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2048000 ++wrote 4096/4096 bytes at offset 2048000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2084864 ++wrote 4096/4096 bytes at offset 2084864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2121728 ++wrote 4096/4096 bytes at offset 2121728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2158592 ++wrote 4096/4096 bytes at offset 2158592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2195456 ++wrote 4096/4096 bytes at offset 2195456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2232320 ++wrote 4096/4096 bytes at offset 2232320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2269184 ++wrote 4096/4096 bytes at offset 2269184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2306048 ++wrote 4096/4096 bytes at offset 2306048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2342912 ++wrote 4096/4096 bytes at offset 2342912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2379776 ++wrote 4096/4096 bytes at offset 2379776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2416640 ++wrote 4096/4096 bytes at offset 2416640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2453504 ++wrote 4096/4096 bytes at offset 2453504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2490368 ++wrote 4096/4096 bytes at offset 2490368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2527232 ++wrote 4096/4096 bytes at offset 2527232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2564096 ++wrote 4096/4096 bytes at offset 2564096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2600960 ++wrote 4096/4096 bytes at offset 2600960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2637824 ++wrote 4096/4096 bytes at offset 2637824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2674688 ++wrote 4096/4096 bytes at offset 2674688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2711552 ++wrote 4096/4096 bytes at offset 2711552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2748416 ++wrote 4096/4096 bytes at offset 2748416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2785280 ++wrote 4096/4096 bytes at offset 2785280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2822144 ++wrote 4096/4096 bytes at offset 2822144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2859008 ++wrote 4096/4096 bytes at offset 2859008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2895872 ++wrote 4096/4096 bytes at offset 2895872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2932736 ++wrote 4096/4096 bytes at offset 2932736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2969600 ++wrote 4096/4096 bytes at offset 2969600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3006464 ++wrote 4096/4096 bytes at offset 3006464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3043328 ++wrote 4096/4096 bytes at offset 3043328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3080192 ++wrote 4096/4096 bytes at offset 3080192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3117056 ++wrote 4096/4096 bytes at offset 3117056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3153920 ++wrote 4096/4096 bytes at offset 3153920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3190784 ++wrote 4096/4096 bytes at offset 3190784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3227648 ++wrote 4096/4096 bytes at offset 3227648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3264512 ++wrote 4096/4096 bytes at offset 3264512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3301376 ++wrote 4096/4096 bytes at offset 3301376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3338240 ++wrote 4096/4096 bytes at offset 3338240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3375104 ++wrote 4096/4096 bytes at offset 3375104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3411968 ++wrote 4096/4096 bytes at offset 3411968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3448832 ++wrote 4096/4096 bytes at offset 3448832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3485696 ++wrote 4096/4096 bytes at offset 3485696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3522560 ++wrote 4096/4096 bytes at offset 3522560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3559424 ++wrote 4096/4096 bytes at offset 3559424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3596288 ++wrote 4096/4096 bytes at offset 3596288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3633152 ++wrote 4096/4096 bytes at offset 3633152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3670016 ++wrote 4096/4096 bytes at offset 3670016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3706880 ++wrote 4096/4096 bytes at offset 3706880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3743744 ++wrote 4096/4096 bytes at offset 3743744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3780608 ++wrote 4096/4096 bytes at offset 3780608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3817472 ++wrote 4096/4096 bytes at offset 3817472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3854336 ++wrote 4096/4096 bytes at offset 3854336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3891200 ++wrote 4096/4096 bytes at offset 3891200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3928064 ++wrote 4096/4096 bytes at offset 3928064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3964928 ++wrote 4096/4096 bytes at offset 3964928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4001792 ++wrote 4096/4096 bytes at offset 4001792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4038656 ++wrote 4096/4096 bytes at offset 4038656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4075520 ++wrote 4096/4096 bytes at offset 4075520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4112384 ++wrote 4096/4096 bytes at offset 4112384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4149248 ++wrote 4096/4096 bytes at offset 4149248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4186112 ++wrote 4096/4096 bytes at offset 4186112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4222976 ++wrote 4096/4096 bytes at offset 4222976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4259840 ++wrote 4096/4096 bytes at offset 4259840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296704 ++wrote 4096/4096 bytes at offset 4296704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4333568 ++wrote 4096/4096 bytes at offset 4333568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4370432 ++wrote 4096/4096 bytes at offset 4370432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4407296 ++wrote 4096/4096 bytes at offset 4407296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4444160 ++wrote 4096/4096 bytes at offset 4444160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4481024 ++wrote 4096/4096 bytes at offset 4481024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4517888 ++wrote 4096/4096 bytes at offset 4517888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4554752 ++wrote 4096/4096 bytes at offset 4554752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4591616 ++wrote 4096/4096 bytes at offset 4591616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4628480 ++wrote 4096/4096 bytes at offset 4628480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4665344 ++wrote 4096/4096 bytes at offset 4665344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4702208 ++wrote 4096/4096 bytes at offset 4702208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4739072 ++wrote 4096/4096 bytes at offset 4739072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4775936 ++wrote 4096/4096 bytes at offset 4775936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4812800 ++wrote 4096/4096 bytes at offset 4812800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4849664 ++wrote 4096/4096 bytes at offset 4849664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4886528 ++wrote 4096/4096 bytes at offset 4886528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4923392 ++wrote 4096/4096 bytes at offset 4923392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4960256 ++wrote 4096/4096 bytes at offset 4960256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4997120 ++wrote 4096/4096 bytes at offset 4997120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5033984 ++wrote 4096/4096 bytes at offset 5033984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5070848 ++wrote 4096/4096 bytes at offset 5070848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5107712 ++wrote 4096/4096 bytes at offset 5107712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5144576 ++wrote 4096/4096 bytes at offset 5144576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5181440 ++wrote 4096/4096 bytes at offset 5181440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5218304 ++wrote 4096/4096 bytes at offset 5218304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5255168 ++wrote 4096/4096 bytes at offset 5255168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5292032 ++wrote 4096/4096 bytes at offset 5292032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5328896 ++wrote 4096/4096 bytes at offset 5328896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5365760 ++wrote 4096/4096 bytes at offset 5365760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5402624 ++wrote 4096/4096 bytes at offset 5402624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5439488 ++wrote 4096/4096 bytes at offset 5439488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5476352 ++wrote 4096/4096 bytes at offset 5476352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5513216 ++wrote 4096/4096 bytes at offset 5513216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5550080 ++wrote 4096/4096 bytes at offset 5550080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5586944 ++wrote 4096/4096 bytes at offset 5586944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5623808 ++wrote 4096/4096 bytes at offset 5623808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5660672 ++wrote 4096/4096 bytes at offset 5660672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5697536 ++wrote 4096/4096 bytes at offset 5697536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5734400 ++wrote 4096/4096 bytes at offset 5734400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5771264 ++wrote 4096/4096 bytes at offset 5771264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5808128 ++wrote 4096/4096 bytes at offset 5808128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5844992 ++wrote 4096/4096 bytes at offset 5844992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5881856 ++wrote 4096/4096 bytes at offset 5881856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5918720 ++wrote 4096/4096 bytes at offset 5918720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5955584 ++wrote 4096/4096 bytes at offset 5955584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5992448 ++wrote 4096/4096 bytes at offset 5992448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6029312 ++wrote 4096/4096 bytes at offset 6029312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6066176 ++wrote 4096/4096 bytes at offset 6066176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6103040 ++wrote 4096/4096 bytes at offset 6103040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6139904 ++wrote 4096/4096 bytes at offset 6139904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6176768 ++wrote 4096/4096 bytes at offset 6176768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6213632 ++wrote 4096/4096 bytes at offset 6213632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6250496 ++wrote 4096/4096 bytes at offset 6250496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6287360 ++wrote 4096/4096 bytes at offset 6287360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6324224 ++wrote 4096/4096 bytes at offset 6324224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6361088 ++wrote 4096/4096 bytes at offset 6361088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6397952 ++wrote 4096/4096 bytes at offset 6397952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6434816 ++wrote 4096/4096 bytes at offset 6434816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6471680 ++wrote 4096/4096 bytes at offset 6471680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6508544 ++wrote 4096/4096 bytes at offset 6508544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6545408 ++wrote 4096/4096 bytes at offset 6545408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6582272 ++wrote 4096/4096 bytes at offset 6582272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6619136 ++wrote 4096/4096 bytes at offset 6619136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6656000 ++wrote 4096/4096 bytes at offset 6656000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6692864 ++wrote 4096/4096 bytes at offset 6692864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6729728 ++wrote 4096/4096 bytes at offset 6729728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6766592 ++wrote 4096/4096 bytes at offset 6766592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6803456 ++wrote 4096/4096 bytes at offset 6803456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6840320 ++wrote 4096/4096 bytes at offset 6840320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6877184 ++wrote 4096/4096 bytes at offset 6877184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6914048 ++wrote 4096/4096 bytes at offset 6914048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6950912 ++wrote 4096/4096 bytes at offset 6950912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6987776 ++wrote 4096/4096 bytes at offset 6987776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7024640 ++wrote 4096/4096 bytes at offset 7024640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7061504 ++wrote 4096/4096 bytes at offset 7061504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7098368 ++wrote 4096/4096 bytes at offset 7098368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7135232 ++wrote 4096/4096 bytes at offset 7135232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7172096 ++wrote 4096/4096 bytes at offset 7172096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7208960 ++wrote 4096/4096 bytes at offset 7208960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7245824 ++wrote 4096/4096 bytes at offset 7245824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7282688 ++wrote 4096/4096 bytes at offset 7282688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7319552 ++wrote 4096/4096 bytes at offset 7319552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7356416 ++wrote 4096/4096 bytes at offset 7356416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7393280 ++wrote 4096/4096 bytes at offset 7393280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7430144 ++wrote 4096/4096 bytes at offset 7430144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7467008 ++wrote 4096/4096 bytes at offset 7467008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7503872 ++wrote 4096/4096 bytes at offset 7503872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7540736 ++wrote 4096/4096 bytes at offset 7540736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7577600 ++wrote 4096/4096 bytes at offset 7577600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7614464 ++wrote 4096/4096 bytes at offset 7614464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7651328 ++wrote 4096/4096 bytes at offset 7651328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7688192 ++wrote 4096/4096 bytes at offset 7688192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7725056 ++wrote 4096/4096 bytes at offset 7725056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7761920 ++wrote 4096/4096 bytes at offset 7761920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7798784 ++wrote 4096/4096 bytes at offset 7798784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7835648 ++wrote 4096/4096 bytes at offset 7835648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7872512 ++wrote 4096/4096 bytes at offset 7872512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7909376 ++wrote 4096/4096 bytes at offset 7909376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7946240 ++wrote 4096/4096 bytes at offset 7946240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7983104 ++wrote 4096/4096 bytes at offset 7983104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8019968 ++wrote 4096/4096 bytes at offset 8019968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8056832 ++wrote 4096/4096 bytes at offset 8056832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8093696 ++wrote 4096/4096 bytes at offset 8093696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8130560 ++wrote 4096/4096 bytes at offset 8130560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8167424 ++wrote 4096/4096 bytes at offset 8167424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8204288 ++wrote 4096/4096 bytes at offset 8204288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8241152 ++wrote 4096/4096 bytes at offset 8241152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8278016 ++wrote 4096/4096 bytes at offset 8278016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8314880 ++wrote 4096/4096 bytes at offset 8314880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8351744 ++wrote 4096/4096 bytes at offset 8351744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8388608 ++wrote 4096/4096 bytes at offset 8388608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8425472 ++wrote 4096/4096 bytes at offset 8425472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8462336 ++wrote 4096/4096 bytes at offset 8462336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8499200 ++wrote 4096/4096 bytes at offset 8499200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8536064 ++wrote 4096/4096 bytes at offset 8536064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8572928 ++wrote 4096/4096 bytes at offset 8572928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8609792 ++wrote 4096/4096 bytes at offset 8609792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8646656 ++wrote 4096/4096 bytes at offset 8646656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8683520 ++wrote 4096/4096 bytes at offset 8683520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8720384 ++wrote 4096/4096 bytes at offset 8720384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8757248 ++wrote 4096/4096 bytes at offset 8757248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8794112 ++wrote 4096/4096 bytes at offset 8794112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8830976 ++wrote 4096/4096 bytes at offset 8830976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8867840 ++wrote 4096/4096 bytes at offset 8867840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8904704 ++wrote 4096/4096 bytes at offset 8904704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8941568 ++wrote 4096/4096 bytes at offset 8941568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8978432 ++wrote 4096/4096 bytes at offset 8978432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 9015296 ++wrote 4096/4096 bytes at offset 9015296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 9052160 ++wrote 4096/4096 bytes at offset 9052160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 9089024 ++wrote 4096/4096 bytes at offset 9089024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 9125888 ++wrote 4096/4096 bytes at offset 9125888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 9162752 ++wrote 4096/4096 bytes at offset 9162752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 9199616 ++wrote 4096/4096 bytes at offset 9199616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 9236480 ++wrote 4096/4096 bytes at offset 9236480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 9273344 ++wrote 4096/4096 bytes at offset 9273344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 9310208 ++wrote 4096/4096 bytes at offset 9310208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 9347072 ++wrote 4096/4096 bytes at offset 9347072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 9383936 ++wrote 4096/4096 bytes at offset 9383936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 9420800 ++wrote 4096/4096 bytes at offset 9420800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === Clusters to be compressed [3] ++=== Clusters to be compressed [3] + === IO: pattern 165 +-qemu-io> wrote 4096/4096 bytes at offset 32768 ++wrote 4096/4096 bytes at offset 32768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 69632 ++wrote 4096/4096 bytes at offset 69632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 106496 ++wrote 4096/4096 bytes at offset 106496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 143360 ++wrote 4096/4096 bytes at offset 143360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 180224 ++wrote 4096/4096 bytes at offset 180224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 217088 ++wrote 4096/4096 bytes at offset 217088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 253952 ++wrote 4096/4096 bytes at offset 253952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 290816 ++wrote 4096/4096 bytes at offset 290816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 327680 ++wrote 4096/4096 bytes at offset 327680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 364544 ++wrote 4096/4096 bytes at offset 364544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 401408 ++wrote 4096/4096 bytes at offset 401408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 438272 ++wrote 4096/4096 bytes at offset 438272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 475136 ++wrote 4096/4096 bytes at offset 475136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 512000 ++wrote 4096/4096 bytes at offset 512000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 548864 ++wrote 4096/4096 bytes at offset 548864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 585728 ++wrote 4096/4096 bytes at offset 585728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 622592 ++wrote 4096/4096 bytes at offset 622592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 659456 ++wrote 4096/4096 bytes at offset 659456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 696320 ++wrote 4096/4096 bytes at offset 696320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 733184 ++wrote 4096/4096 bytes at offset 733184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 770048 ++wrote 4096/4096 bytes at offset 770048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 806912 ++wrote 4096/4096 bytes at offset 806912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 843776 ++wrote 4096/4096 bytes at offset 843776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 880640 ++wrote 4096/4096 bytes at offset 880640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 917504 ++wrote 4096/4096 bytes at offset 917504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 954368 ++wrote 4096/4096 bytes at offset 954368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 991232 ++wrote 4096/4096 bytes at offset 991232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1028096 ++wrote 4096/4096 bytes at offset 1028096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1064960 ++wrote 4096/4096 bytes at offset 1064960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1101824 ++wrote 4096/4096 bytes at offset 1101824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1138688 ++wrote 4096/4096 bytes at offset 1138688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1175552 ++wrote 4096/4096 bytes at offset 1175552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1212416 ++wrote 4096/4096 bytes at offset 1212416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1249280 ++wrote 4096/4096 bytes at offset 1249280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1286144 ++wrote 4096/4096 bytes at offset 1286144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1323008 ++wrote 4096/4096 bytes at offset 1323008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1359872 ++wrote 4096/4096 bytes at offset 1359872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1396736 ++wrote 4096/4096 bytes at offset 1396736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1433600 ++wrote 4096/4096 bytes at offset 1433600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1470464 ++wrote 4096/4096 bytes at offset 1470464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1507328 ++wrote 4096/4096 bytes at offset 1507328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1544192 ++wrote 4096/4096 bytes at offset 1544192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1581056 ++wrote 4096/4096 bytes at offset 1581056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1617920 ++wrote 4096/4096 bytes at offset 1617920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1654784 ++wrote 4096/4096 bytes at offset 1654784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1691648 ++wrote 4096/4096 bytes at offset 1691648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1728512 ++wrote 4096/4096 bytes at offset 1728512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1765376 ++wrote 4096/4096 bytes at offset 1765376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1802240 ++wrote 4096/4096 bytes at offset 1802240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1839104 ++wrote 4096/4096 bytes at offset 1839104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1875968 ++wrote 4096/4096 bytes at offset 1875968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1912832 ++wrote 4096/4096 bytes at offset 1912832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1949696 ++wrote 4096/4096 bytes at offset 1949696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1986560 ++wrote 4096/4096 bytes at offset 1986560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2023424 ++wrote 4096/4096 bytes at offset 2023424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2060288 ++wrote 4096/4096 bytes at offset 2060288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2097152 ++wrote 4096/4096 bytes at offset 2097152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2134016 ++wrote 4096/4096 bytes at offset 2134016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2170880 ++wrote 4096/4096 bytes at offset 2170880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2207744 ++wrote 4096/4096 bytes at offset 2207744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2244608 ++wrote 4096/4096 bytes at offset 2244608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2281472 ++wrote 4096/4096 bytes at offset 2281472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2318336 ++wrote 4096/4096 bytes at offset 2318336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2355200 ++wrote 4096/4096 bytes at offset 2355200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2392064 ++wrote 4096/4096 bytes at offset 2392064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2428928 ++wrote 4096/4096 bytes at offset 2428928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2465792 ++wrote 4096/4096 bytes at offset 2465792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2502656 ++wrote 4096/4096 bytes at offset 2502656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2539520 ++wrote 4096/4096 bytes at offset 2539520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2576384 ++wrote 4096/4096 bytes at offset 2576384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2613248 ++wrote 4096/4096 bytes at offset 2613248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2650112 ++wrote 4096/4096 bytes at offset 2650112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2686976 ++wrote 4096/4096 bytes at offset 2686976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2723840 ++wrote 4096/4096 bytes at offset 2723840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2760704 ++wrote 4096/4096 bytes at offset 2760704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2797568 ++wrote 4096/4096 bytes at offset 2797568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2834432 ++wrote 4096/4096 bytes at offset 2834432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2871296 ++wrote 4096/4096 bytes at offset 2871296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2908160 ++wrote 4096/4096 bytes at offset 2908160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2945024 ++wrote 4096/4096 bytes at offset 2945024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2981888 ++wrote 4096/4096 bytes at offset 2981888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3018752 ++wrote 4096/4096 bytes at offset 3018752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3055616 ++wrote 4096/4096 bytes at offset 3055616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3092480 ++wrote 4096/4096 bytes at offset 3092480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3129344 ++wrote 4096/4096 bytes at offset 3129344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3166208 ++wrote 4096/4096 bytes at offset 3166208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3203072 ++wrote 4096/4096 bytes at offset 3203072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3239936 ++wrote 4096/4096 bytes at offset 3239936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3276800 ++wrote 4096/4096 bytes at offset 3276800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3313664 ++wrote 4096/4096 bytes at offset 3313664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3350528 ++wrote 4096/4096 bytes at offset 3350528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3387392 ++wrote 4096/4096 bytes at offset 3387392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3424256 ++wrote 4096/4096 bytes at offset 3424256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3461120 ++wrote 4096/4096 bytes at offset 3461120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3497984 ++wrote 4096/4096 bytes at offset 3497984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3534848 ++wrote 4096/4096 bytes at offset 3534848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3571712 ++wrote 4096/4096 bytes at offset 3571712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3608576 ++wrote 4096/4096 bytes at offset 3608576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3645440 ++wrote 4096/4096 bytes at offset 3645440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3682304 ++wrote 4096/4096 bytes at offset 3682304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3719168 ++wrote 4096/4096 bytes at offset 3719168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3756032 ++wrote 4096/4096 bytes at offset 3756032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3792896 ++wrote 4096/4096 bytes at offset 3792896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3829760 ++wrote 4096/4096 bytes at offset 3829760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3866624 ++wrote 4096/4096 bytes at offset 3866624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3903488 ++wrote 4096/4096 bytes at offset 3903488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3940352 ++wrote 4096/4096 bytes at offset 3940352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3977216 ++wrote 4096/4096 bytes at offset 3977216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4014080 ++wrote 4096/4096 bytes at offset 4014080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4050944 ++wrote 4096/4096 bytes at offset 4050944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4087808 ++wrote 4096/4096 bytes at offset 4087808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4124672 ++wrote 4096/4096 bytes at offset 4124672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4161536 ++wrote 4096/4096 bytes at offset 4161536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4198400 ++wrote 4096/4096 bytes at offset 4198400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4235264 ++wrote 4096/4096 bytes at offset 4235264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4272128 ++wrote 4096/4096 bytes at offset 4272128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4308992 ++wrote 4096/4096 bytes at offset 4308992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4345856 ++wrote 4096/4096 bytes at offset 4345856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4382720 ++wrote 4096/4096 bytes at offset 4382720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4419584 ++wrote 4096/4096 bytes at offset 4419584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4456448 ++wrote 4096/4096 bytes at offset 4456448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4493312 ++wrote 4096/4096 bytes at offset 4493312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4530176 ++wrote 4096/4096 bytes at offset 4530176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4567040 ++wrote 4096/4096 bytes at offset 4567040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4603904 ++wrote 4096/4096 bytes at offset 4603904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4640768 ++wrote 4096/4096 bytes at offset 4640768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4677632 ++wrote 4096/4096 bytes at offset 4677632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4714496 ++wrote 4096/4096 bytes at offset 4714496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4751360 ++wrote 4096/4096 bytes at offset 4751360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4788224 ++wrote 4096/4096 bytes at offset 4788224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4825088 ++wrote 4096/4096 bytes at offset 4825088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4861952 ++wrote 4096/4096 bytes at offset 4861952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4898816 ++wrote 4096/4096 bytes at offset 4898816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4935680 ++wrote 4096/4096 bytes at offset 4935680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4972544 ++wrote 4096/4096 bytes at offset 4972544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5009408 ++wrote 4096/4096 bytes at offset 5009408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5046272 ++wrote 4096/4096 bytes at offset 5046272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5083136 ++wrote 4096/4096 bytes at offset 5083136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5120000 ++wrote 4096/4096 bytes at offset 5120000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5156864 ++wrote 4096/4096 bytes at offset 5156864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5193728 ++wrote 4096/4096 bytes at offset 5193728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5230592 ++wrote 4096/4096 bytes at offset 5230592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5267456 ++wrote 4096/4096 bytes at offset 5267456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5304320 ++wrote 4096/4096 bytes at offset 5304320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5341184 ++wrote 4096/4096 bytes at offset 5341184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5378048 ++wrote 4096/4096 bytes at offset 5378048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5414912 ++wrote 4096/4096 bytes at offset 5414912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5451776 ++wrote 4096/4096 bytes at offset 5451776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5488640 ++wrote 4096/4096 bytes at offset 5488640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5525504 ++wrote 4096/4096 bytes at offset 5525504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5562368 ++wrote 4096/4096 bytes at offset 5562368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5599232 ++wrote 4096/4096 bytes at offset 5599232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5636096 ++wrote 4096/4096 bytes at offset 5636096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5672960 ++wrote 4096/4096 bytes at offset 5672960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5709824 ++wrote 4096/4096 bytes at offset 5709824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5746688 ++wrote 4096/4096 bytes at offset 5746688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5783552 ++wrote 4096/4096 bytes at offset 5783552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5820416 ++wrote 4096/4096 bytes at offset 5820416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5857280 ++wrote 4096/4096 bytes at offset 5857280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5894144 ++wrote 4096/4096 bytes at offset 5894144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5931008 ++wrote 4096/4096 bytes at offset 5931008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5967872 ++wrote 4096/4096 bytes at offset 5967872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6004736 ++wrote 4096/4096 bytes at offset 6004736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6041600 ++wrote 4096/4096 bytes at offset 6041600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6078464 ++wrote 4096/4096 bytes at offset 6078464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6115328 ++wrote 4096/4096 bytes at offset 6115328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6152192 ++wrote 4096/4096 bytes at offset 6152192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6189056 ++wrote 4096/4096 bytes at offset 6189056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6225920 ++wrote 4096/4096 bytes at offset 6225920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6262784 ++wrote 4096/4096 bytes at offset 6262784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6299648 ++wrote 4096/4096 bytes at offset 6299648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6336512 ++wrote 4096/4096 bytes at offset 6336512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6373376 ++wrote 4096/4096 bytes at offset 6373376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6410240 ++wrote 4096/4096 bytes at offset 6410240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6447104 ++wrote 4096/4096 bytes at offset 6447104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6483968 ++wrote 4096/4096 bytes at offset 6483968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6520832 ++wrote 4096/4096 bytes at offset 6520832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6557696 ++wrote 4096/4096 bytes at offset 6557696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6594560 ++wrote 4096/4096 bytes at offset 6594560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6631424 ++wrote 4096/4096 bytes at offset 6631424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6668288 ++wrote 4096/4096 bytes at offset 6668288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6705152 ++wrote 4096/4096 bytes at offset 6705152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6742016 ++wrote 4096/4096 bytes at offset 6742016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6778880 ++wrote 4096/4096 bytes at offset 6778880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6815744 ++wrote 4096/4096 bytes at offset 6815744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6852608 ++wrote 4096/4096 bytes at offset 6852608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6889472 ++wrote 4096/4096 bytes at offset 6889472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6926336 ++wrote 4096/4096 bytes at offset 6926336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6963200 ++wrote 4096/4096 bytes at offset 6963200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7000064 ++wrote 4096/4096 bytes at offset 7000064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7036928 ++wrote 4096/4096 bytes at offset 7036928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7073792 ++wrote 4096/4096 bytes at offset 7073792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7110656 ++wrote 4096/4096 bytes at offset 7110656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7147520 ++wrote 4096/4096 bytes at offset 7147520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7184384 ++wrote 4096/4096 bytes at offset 7184384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7221248 ++wrote 4096/4096 bytes at offset 7221248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7258112 ++wrote 4096/4096 bytes at offset 7258112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7294976 ++wrote 4096/4096 bytes at offset 7294976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7331840 ++wrote 4096/4096 bytes at offset 7331840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7368704 ++wrote 4096/4096 bytes at offset 7368704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7405568 ++wrote 4096/4096 bytes at offset 7405568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7442432 ++wrote 4096/4096 bytes at offset 7442432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7479296 ++wrote 4096/4096 bytes at offset 7479296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7516160 ++wrote 4096/4096 bytes at offset 7516160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7553024 ++wrote 4096/4096 bytes at offset 7553024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7589888 ++wrote 4096/4096 bytes at offset 7589888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7626752 ++wrote 4096/4096 bytes at offset 7626752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7663616 ++wrote 4096/4096 bytes at offset 7663616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7700480 ++wrote 4096/4096 bytes at offset 7700480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7737344 ++wrote 4096/4096 bytes at offset 7737344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7774208 ++wrote 4096/4096 bytes at offset 7774208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7811072 ++wrote 4096/4096 bytes at offset 7811072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7847936 ++wrote 4096/4096 bytes at offset 7847936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7884800 ++wrote 4096/4096 bytes at offset 7884800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7921664 ++wrote 4096/4096 bytes at offset 7921664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7958528 ++wrote 4096/4096 bytes at offset 7958528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7995392 ++wrote 4096/4096 bytes at offset 7995392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8032256 ++wrote 4096/4096 bytes at offset 8032256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8069120 ++wrote 4096/4096 bytes at offset 8069120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8105984 ++wrote 4096/4096 bytes at offset 8105984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8142848 ++wrote 4096/4096 bytes at offset 8142848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8179712 ++wrote 4096/4096 bytes at offset 8179712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8216576 ++wrote 4096/4096 bytes at offset 8216576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8253440 ++wrote 4096/4096 bytes at offset 8253440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8290304 ++wrote 4096/4096 bytes at offset 8290304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8327168 ++wrote 4096/4096 bytes at offset 8327168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8364032 ++wrote 4096/4096 bytes at offset 8364032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8400896 ++wrote 4096/4096 bytes at offset 8400896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8437760 ++wrote 4096/4096 bytes at offset 8437760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8474624 ++wrote 4096/4096 bytes at offset 8474624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8511488 ++wrote 4096/4096 bytes at offset 8511488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8548352 ++wrote 4096/4096 bytes at offset 8548352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8585216 ++wrote 4096/4096 bytes at offset 8585216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8622080 ++wrote 4096/4096 bytes at offset 8622080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8658944 ++wrote 4096/4096 bytes at offset 8658944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8695808 ++wrote 4096/4096 bytes at offset 8695808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8732672 ++wrote 4096/4096 bytes at offset 8732672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8769536 ++wrote 4096/4096 bytes at offset 8769536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8806400 ++wrote 4096/4096 bytes at offset 8806400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8843264 ++wrote 4096/4096 bytes at offset 8843264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8880128 ++wrote 4096/4096 bytes at offset 8880128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8916992 ++wrote 4096/4096 bytes at offset 8916992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8953856 ++wrote 4096/4096 bytes at offset 8953856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8990720 ++wrote 4096/4096 bytes at offset 8990720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 9027584 ++wrote 4096/4096 bytes at offset 9027584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 9064448 ++wrote 4096/4096 bytes at offset 9064448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 9101312 ++wrote 4096/4096 bytes at offset 9101312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 9138176 ++wrote 4096/4096 bytes at offset 9138176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 9175040 ++wrote 4096/4096 bytes at offset 9175040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 9211904 ++wrote 4096/4096 bytes at offset 9211904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 9248768 ++wrote 4096/4096 bytes at offset 9248768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 9285632 ++wrote 4096/4096 bytes at offset 9285632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 9322496 ++wrote 4096/4096 bytes at offset 9322496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 9359360 ++wrote 4096/4096 bytes at offset 9359360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 9396224 ++wrote 4096/4096 bytes at offset 9396224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 9433088 ++wrote 4096/4096 bytes at offset 9433088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === Used clusters [1] ++=== Used clusters [1] + === IO: pattern 165 +-qemu-io> wrote 4096/4096 bytes at offset 0 ++wrote 4096/4096 bytes at offset 0 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 36864 ++wrote 4096/4096 bytes at offset 36864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 73728 ++wrote 4096/4096 bytes at offset 73728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 110592 ++wrote 4096/4096 bytes at offset 110592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 147456 ++wrote 4096/4096 bytes at offset 147456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 184320 ++wrote 4096/4096 bytes at offset 184320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 221184 ++wrote 4096/4096 bytes at offset 221184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 258048 ++wrote 4096/4096 bytes at offset 258048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 294912 ++wrote 4096/4096 bytes at offset 294912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 331776 ++wrote 4096/4096 bytes at offset 331776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 368640 ++wrote 4096/4096 bytes at offset 368640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 405504 ++wrote 4096/4096 bytes at offset 405504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 442368 ++wrote 4096/4096 bytes at offset 442368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 479232 ++wrote 4096/4096 bytes at offset 479232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 516096 ++wrote 4096/4096 bytes at offset 516096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 552960 ++wrote 4096/4096 bytes at offset 552960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 589824 ++wrote 4096/4096 bytes at offset 589824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 626688 ++wrote 4096/4096 bytes at offset 626688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 663552 ++wrote 4096/4096 bytes at offset 663552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 700416 ++wrote 4096/4096 bytes at offset 700416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 737280 ++wrote 4096/4096 bytes at offset 737280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 774144 ++wrote 4096/4096 bytes at offset 774144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 811008 ++wrote 4096/4096 bytes at offset 811008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 847872 ++wrote 4096/4096 bytes at offset 847872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 884736 ++wrote 4096/4096 bytes at offset 884736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 921600 ++wrote 4096/4096 bytes at offset 921600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 958464 ++wrote 4096/4096 bytes at offset 958464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 995328 ++wrote 4096/4096 bytes at offset 995328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1032192 ++wrote 4096/4096 bytes at offset 1032192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1069056 ++wrote 4096/4096 bytes at offset 1069056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1105920 ++wrote 4096/4096 bytes at offset 1105920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1142784 ++wrote 4096/4096 bytes at offset 1142784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1179648 ++wrote 4096/4096 bytes at offset 1179648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1216512 ++wrote 4096/4096 bytes at offset 1216512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1253376 ++wrote 4096/4096 bytes at offset 1253376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1290240 ++wrote 4096/4096 bytes at offset 1290240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1327104 ++wrote 4096/4096 bytes at offset 1327104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1363968 ++wrote 4096/4096 bytes at offset 1363968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1400832 ++wrote 4096/4096 bytes at offset 1400832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1437696 ++wrote 4096/4096 bytes at offset 1437696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1474560 ++wrote 4096/4096 bytes at offset 1474560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1511424 ++wrote 4096/4096 bytes at offset 1511424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1548288 ++wrote 4096/4096 bytes at offset 1548288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1585152 ++wrote 4096/4096 bytes at offset 1585152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1622016 ++wrote 4096/4096 bytes at offset 1622016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1658880 ++wrote 4096/4096 bytes at offset 1658880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1695744 ++wrote 4096/4096 bytes at offset 1695744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1732608 ++wrote 4096/4096 bytes at offset 1732608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1769472 ++wrote 4096/4096 bytes at offset 1769472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1806336 ++wrote 4096/4096 bytes at offset 1806336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1843200 ++wrote 4096/4096 bytes at offset 1843200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1880064 ++wrote 4096/4096 bytes at offset 1880064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1916928 ++wrote 4096/4096 bytes at offset 1916928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1953792 ++wrote 4096/4096 bytes at offset 1953792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1990656 ++wrote 4096/4096 bytes at offset 1990656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2027520 ++wrote 4096/4096 bytes at offset 2027520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2064384 ++wrote 4096/4096 bytes at offset 2064384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2101248 ++wrote 4096/4096 bytes at offset 2101248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2138112 ++wrote 4096/4096 bytes at offset 2138112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2174976 ++wrote 4096/4096 bytes at offset 2174976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2211840 ++wrote 4096/4096 bytes at offset 2211840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2248704 ++wrote 4096/4096 bytes at offset 2248704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2285568 ++wrote 4096/4096 bytes at offset 2285568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2322432 ++wrote 4096/4096 bytes at offset 2322432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2359296 ++wrote 4096/4096 bytes at offset 2359296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2396160 ++wrote 4096/4096 bytes at offset 2396160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2433024 ++wrote 4096/4096 bytes at offset 2433024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2469888 ++wrote 4096/4096 bytes at offset 2469888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2506752 ++wrote 4096/4096 bytes at offset 2506752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2543616 ++wrote 4096/4096 bytes at offset 2543616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2580480 ++wrote 4096/4096 bytes at offset 2580480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2617344 ++wrote 4096/4096 bytes at offset 2617344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2654208 ++wrote 4096/4096 bytes at offset 2654208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2691072 ++wrote 4096/4096 bytes at offset 2691072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2727936 ++wrote 4096/4096 bytes at offset 2727936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2764800 ++wrote 4096/4096 bytes at offset 2764800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2801664 ++wrote 4096/4096 bytes at offset 2801664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2838528 ++wrote 4096/4096 bytes at offset 2838528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2875392 ++wrote 4096/4096 bytes at offset 2875392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2912256 ++wrote 4096/4096 bytes at offset 2912256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2949120 ++wrote 4096/4096 bytes at offset 2949120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2985984 ++wrote 4096/4096 bytes at offset 2985984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3022848 ++wrote 4096/4096 bytes at offset 3022848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3059712 ++wrote 4096/4096 bytes at offset 3059712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3096576 ++wrote 4096/4096 bytes at offset 3096576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3133440 ++wrote 4096/4096 bytes at offset 3133440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3170304 ++wrote 4096/4096 bytes at offset 3170304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3207168 ++wrote 4096/4096 bytes at offset 3207168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3244032 ++wrote 4096/4096 bytes at offset 3244032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3280896 ++wrote 4096/4096 bytes at offset 3280896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3317760 ++wrote 4096/4096 bytes at offset 3317760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3354624 ++wrote 4096/4096 bytes at offset 3354624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3391488 ++wrote 4096/4096 bytes at offset 3391488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3428352 ++wrote 4096/4096 bytes at offset 3428352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3465216 ++wrote 4096/4096 bytes at offset 3465216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3502080 ++wrote 4096/4096 bytes at offset 3502080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3538944 ++wrote 4096/4096 bytes at offset 3538944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3575808 ++wrote 4096/4096 bytes at offset 3575808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3612672 ++wrote 4096/4096 bytes at offset 3612672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3649536 ++wrote 4096/4096 bytes at offset 3649536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3686400 ++wrote 4096/4096 bytes at offset 3686400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3723264 ++wrote 4096/4096 bytes at offset 3723264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3760128 ++wrote 4096/4096 bytes at offset 3760128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3796992 ++wrote 4096/4096 bytes at offset 3796992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3833856 ++wrote 4096/4096 bytes at offset 3833856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3870720 ++wrote 4096/4096 bytes at offset 3870720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3907584 ++wrote 4096/4096 bytes at offset 3907584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3944448 ++wrote 4096/4096 bytes at offset 3944448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3981312 ++wrote 4096/4096 bytes at offset 3981312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4018176 ++wrote 4096/4096 bytes at offset 4018176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4055040 ++wrote 4096/4096 bytes at offset 4055040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4091904 ++wrote 4096/4096 bytes at offset 4091904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4128768 ++wrote 4096/4096 bytes at offset 4128768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4165632 ++wrote 4096/4096 bytes at offset 4165632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4202496 ++wrote 4096/4096 bytes at offset 4202496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4239360 ++wrote 4096/4096 bytes at offset 4239360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4276224 ++wrote 4096/4096 bytes at offset 4276224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4313088 ++wrote 4096/4096 bytes at offset 4313088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4349952 ++wrote 4096/4096 bytes at offset 4349952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4386816 ++wrote 4096/4096 bytes at offset 4386816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4423680 ++wrote 4096/4096 bytes at offset 4423680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4460544 ++wrote 4096/4096 bytes at offset 4460544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4497408 ++wrote 4096/4096 bytes at offset 4497408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4534272 ++wrote 4096/4096 bytes at offset 4534272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4571136 ++wrote 4096/4096 bytes at offset 4571136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4608000 ++wrote 4096/4096 bytes at offset 4608000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4644864 ++wrote 4096/4096 bytes at offset 4644864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4681728 ++wrote 4096/4096 bytes at offset 4681728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4718592 ++wrote 4096/4096 bytes at offset 4718592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4755456 ++wrote 4096/4096 bytes at offset 4755456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4792320 ++wrote 4096/4096 bytes at offset 4792320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4829184 ++wrote 4096/4096 bytes at offset 4829184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4866048 ++wrote 4096/4096 bytes at offset 4866048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4902912 ++wrote 4096/4096 bytes at offset 4902912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4939776 ++wrote 4096/4096 bytes at offset 4939776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4976640 ++wrote 4096/4096 bytes at offset 4976640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5013504 ++wrote 4096/4096 bytes at offset 5013504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5050368 ++wrote 4096/4096 bytes at offset 5050368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5087232 ++wrote 4096/4096 bytes at offset 5087232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5124096 ++wrote 4096/4096 bytes at offset 5124096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5160960 ++wrote 4096/4096 bytes at offset 5160960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5197824 ++wrote 4096/4096 bytes at offset 5197824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5234688 ++wrote 4096/4096 bytes at offset 5234688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5271552 ++wrote 4096/4096 bytes at offset 5271552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5308416 ++wrote 4096/4096 bytes at offset 5308416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5345280 ++wrote 4096/4096 bytes at offset 5345280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5382144 ++wrote 4096/4096 bytes at offset 5382144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5419008 ++wrote 4096/4096 bytes at offset 5419008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5455872 ++wrote 4096/4096 bytes at offset 5455872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5492736 ++wrote 4096/4096 bytes at offset 5492736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5529600 ++wrote 4096/4096 bytes at offset 5529600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5566464 ++wrote 4096/4096 bytes at offset 5566464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5603328 ++wrote 4096/4096 bytes at offset 5603328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5640192 ++wrote 4096/4096 bytes at offset 5640192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5677056 ++wrote 4096/4096 bytes at offset 5677056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5713920 ++wrote 4096/4096 bytes at offset 5713920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5750784 ++wrote 4096/4096 bytes at offset 5750784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5787648 ++wrote 4096/4096 bytes at offset 5787648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5824512 ++wrote 4096/4096 bytes at offset 5824512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5861376 ++wrote 4096/4096 bytes at offset 5861376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5898240 ++wrote 4096/4096 bytes at offset 5898240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5935104 ++wrote 4096/4096 bytes at offset 5935104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5971968 ++wrote 4096/4096 bytes at offset 5971968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6008832 ++wrote 4096/4096 bytes at offset 6008832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6045696 ++wrote 4096/4096 bytes at offset 6045696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6082560 ++wrote 4096/4096 bytes at offset 6082560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6119424 ++wrote 4096/4096 bytes at offset 6119424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6156288 ++wrote 4096/4096 bytes at offset 6156288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6193152 ++wrote 4096/4096 bytes at offset 6193152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6230016 ++wrote 4096/4096 bytes at offset 6230016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6266880 ++wrote 4096/4096 bytes at offset 6266880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6303744 ++wrote 4096/4096 bytes at offset 6303744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6340608 ++wrote 4096/4096 bytes at offset 6340608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6377472 ++wrote 4096/4096 bytes at offset 6377472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6414336 ++wrote 4096/4096 bytes at offset 6414336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6451200 ++wrote 4096/4096 bytes at offset 6451200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6488064 ++wrote 4096/4096 bytes at offset 6488064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6524928 ++wrote 4096/4096 bytes at offset 6524928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6561792 ++wrote 4096/4096 bytes at offset 6561792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6598656 ++wrote 4096/4096 bytes at offset 6598656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6635520 ++wrote 4096/4096 bytes at offset 6635520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6672384 ++wrote 4096/4096 bytes at offset 6672384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6709248 ++wrote 4096/4096 bytes at offset 6709248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6746112 ++wrote 4096/4096 bytes at offset 6746112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6782976 ++wrote 4096/4096 bytes at offset 6782976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6819840 ++wrote 4096/4096 bytes at offset 6819840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6856704 ++wrote 4096/4096 bytes at offset 6856704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6893568 ++wrote 4096/4096 bytes at offset 6893568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6930432 ++wrote 4096/4096 bytes at offset 6930432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6967296 ++wrote 4096/4096 bytes at offset 6967296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7004160 ++wrote 4096/4096 bytes at offset 7004160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7041024 ++wrote 4096/4096 bytes at offset 7041024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7077888 ++wrote 4096/4096 bytes at offset 7077888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7114752 ++wrote 4096/4096 bytes at offset 7114752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7151616 ++wrote 4096/4096 bytes at offset 7151616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7188480 ++wrote 4096/4096 bytes at offset 7188480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7225344 ++wrote 4096/4096 bytes at offset 7225344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7262208 ++wrote 4096/4096 bytes at offset 7262208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7299072 ++wrote 4096/4096 bytes at offset 7299072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7335936 ++wrote 4096/4096 bytes at offset 7335936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7372800 ++wrote 4096/4096 bytes at offset 7372800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7409664 ++wrote 4096/4096 bytes at offset 7409664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7446528 ++wrote 4096/4096 bytes at offset 7446528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7483392 ++wrote 4096/4096 bytes at offset 7483392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7520256 ++wrote 4096/4096 bytes at offset 7520256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7557120 ++wrote 4096/4096 bytes at offset 7557120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7593984 ++wrote 4096/4096 bytes at offset 7593984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7630848 ++wrote 4096/4096 bytes at offset 7630848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7667712 ++wrote 4096/4096 bytes at offset 7667712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7704576 ++wrote 4096/4096 bytes at offset 7704576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7741440 ++wrote 4096/4096 bytes at offset 7741440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7778304 ++wrote 4096/4096 bytes at offset 7778304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7815168 ++wrote 4096/4096 bytes at offset 7815168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7852032 ++wrote 4096/4096 bytes at offset 7852032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7888896 ++wrote 4096/4096 bytes at offset 7888896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7925760 ++wrote 4096/4096 bytes at offset 7925760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7962624 ++wrote 4096/4096 bytes at offset 7962624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7999488 ++wrote 4096/4096 bytes at offset 7999488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8036352 ++wrote 4096/4096 bytes at offset 8036352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8073216 ++wrote 4096/4096 bytes at offset 8073216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8110080 ++wrote 4096/4096 bytes at offset 8110080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8146944 ++wrote 4096/4096 bytes at offset 8146944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8183808 ++wrote 4096/4096 bytes at offset 8183808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8220672 ++wrote 4096/4096 bytes at offset 8220672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8257536 ++wrote 4096/4096 bytes at offset 8257536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8294400 ++wrote 4096/4096 bytes at offset 8294400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8331264 ++wrote 4096/4096 bytes at offset 8331264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8368128 ++wrote 4096/4096 bytes at offset 8368128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8404992 ++wrote 4096/4096 bytes at offset 8404992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8441856 ++wrote 4096/4096 bytes at offset 8441856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8478720 ++wrote 4096/4096 bytes at offset 8478720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8515584 ++wrote 4096/4096 bytes at offset 8515584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8552448 ++wrote 4096/4096 bytes at offset 8552448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8589312 ++wrote 4096/4096 bytes at offset 8589312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8626176 ++wrote 4096/4096 bytes at offset 8626176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8663040 ++wrote 4096/4096 bytes at offset 8663040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8699904 ++wrote 4096/4096 bytes at offset 8699904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8736768 ++wrote 4096/4096 bytes at offset 8736768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8773632 ++wrote 4096/4096 bytes at offset 8773632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8810496 ++wrote 4096/4096 bytes at offset 8810496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8847360 ++wrote 4096/4096 bytes at offset 8847360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8884224 ++wrote 4096/4096 bytes at offset 8884224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8921088 ++wrote 4096/4096 bytes at offset 8921088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8957952 ++wrote 4096/4096 bytes at offset 8957952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8994816 ++wrote 4096/4096 bytes at offset 8994816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 9031680 ++wrote 4096/4096 bytes at offset 9031680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 9068544 ++wrote 4096/4096 bytes at offset 9068544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 9105408 ++wrote 4096/4096 bytes at offset 9105408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 9142272 ++wrote 4096/4096 bytes at offset 9142272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 9179136 ++wrote 4096/4096 bytes at offset 9179136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 9216000 ++wrote 4096/4096 bytes at offset 9216000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 9252864 ++wrote 4096/4096 bytes at offset 9252864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 9289728 ++wrote 4096/4096 bytes at offset 9289728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 9326592 ++wrote 4096/4096 bytes at offset 9326592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 9363456 ++wrote 4096/4096 bytes at offset 9363456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 9400320 ++wrote 4096/4096 bytes at offset 9400320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === Used clusters [2] ++=== Used clusters [2] + === IO: pattern 165 +-qemu-io> wrote 4096/4096 bytes at offset 4096 ++wrote 4096/4096 bytes at offset 4096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 40960 ++wrote 4096/4096 bytes at offset 40960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 77824 ++wrote 4096/4096 bytes at offset 77824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 114688 ++wrote 4096/4096 bytes at offset 114688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 151552 ++wrote 4096/4096 bytes at offset 151552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 188416 ++wrote 4096/4096 bytes at offset 188416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 225280 ++wrote 4096/4096 bytes at offset 225280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 262144 ++wrote 4096/4096 bytes at offset 262144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 299008 ++wrote 4096/4096 bytes at offset 299008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 335872 ++wrote 4096/4096 bytes at offset 335872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 372736 ++wrote 4096/4096 bytes at offset 372736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 409600 ++wrote 4096/4096 bytes at offset 409600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 446464 ++wrote 4096/4096 bytes at offset 446464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 483328 ++wrote 4096/4096 bytes at offset 483328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 520192 ++wrote 4096/4096 bytes at offset 520192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 557056 ++wrote 4096/4096 bytes at offset 557056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 593920 ++wrote 4096/4096 bytes at offset 593920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 630784 ++wrote 4096/4096 bytes at offset 630784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 667648 ++wrote 4096/4096 bytes at offset 667648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 704512 ++wrote 4096/4096 bytes at offset 704512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 741376 ++wrote 4096/4096 bytes at offset 741376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 778240 ++wrote 4096/4096 bytes at offset 778240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 815104 ++wrote 4096/4096 bytes at offset 815104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 851968 ++wrote 4096/4096 bytes at offset 851968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 888832 ++wrote 4096/4096 bytes at offset 888832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 925696 ++wrote 4096/4096 bytes at offset 925696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 962560 ++wrote 4096/4096 bytes at offset 962560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 999424 ++wrote 4096/4096 bytes at offset 999424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1036288 ++wrote 4096/4096 bytes at offset 1036288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1073152 ++wrote 4096/4096 bytes at offset 1073152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1110016 ++wrote 4096/4096 bytes at offset 1110016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1146880 ++wrote 4096/4096 bytes at offset 1146880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1183744 ++wrote 4096/4096 bytes at offset 1183744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1220608 ++wrote 4096/4096 bytes at offset 1220608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1257472 ++wrote 4096/4096 bytes at offset 1257472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1294336 ++wrote 4096/4096 bytes at offset 1294336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1331200 ++wrote 4096/4096 bytes at offset 1331200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1368064 ++wrote 4096/4096 bytes at offset 1368064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1404928 ++wrote 4096/4096 bytes at offset 1404928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1441792 ++wrote 4096/4096 bytes at offset 1441792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1478656 ++wrote 4096/4096 bytes at offset 1478656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1515520 ++wrote 4096/4096 bytes at offset 1515520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1552384 ++wrote 4096/4096 bytes at offset 1552384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1589248 ++wrote 4096/4096 bytes at offset 1589248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1626112 ++wrote 4096/4096 bytes at offset 1626112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1662976 ++wrote 4096/4096 bytes at offset 1662976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1699840 ++wrote 4096/4096 bytes at offset 1699840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1736704 ++wrote 4096/4096 bytes at offset 1736704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1773568 ++wrote 4096/4096 bytes at offset 1773568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1810432 ++wrote 4096/4096 bytes at offset 1810432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1847296 ++wrote 4096/4096 bytes at offset 1847296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1884160 ++wrote 4096/4096 bytes at offset 1884160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1921024 ++wrote 4096/4096 bytes at offset 1921024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1957888 ++wrote 4096/4096 bytes at offset 1957888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1994752 ++wrote 4096/4096 bytes at offset 1994752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2031616 ++wrote 4096/4096 bytes at offset 2031616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2068480 ++wrote 4096/4096 bytes at offset 2068480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2105344 ++wrote 4096/4096 bytes at offset 2105344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2142208 ++wrote 4096/4096 bytes at offset 2142208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2179072 ++wrote 4096/4096 bytes at offset 2179072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2215936 ++wrote 4096/4096 bytes at offset 2215936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2252800 ++wrote 4096/4096 bytes at offset 2252800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2289664 ++wrote 4096/4096 bytes at offset 2289664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2326528 ++wrote 4096/4096 bytes at offset 2326528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2363392 ++wrote 4096/4096 bytes at offset 2363392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2400256 ++wrote 4096/4096 bytes at offset 2400256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2437120 ++wrote 4096/4096 bytes at offset 2437120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2473984 ++wrote 4096/4096 bytes at offset 2473984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2510848 ++wrote 4096/4096 bytes at offset 2510848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2547712 ++wrote 4096/4096 bytes at offset 2547712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2584576 ++wrote 4096/4096 bytes at offset 2584576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2621440 ++wrote 4096/4096 bytes at offset 2621440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2658304 ++wrote 4096/4096 bytes at offset 2658304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2695168 ++wrote 4096/4096 bytes at offset 2695168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2732032 ++wrote 4096/4096 bytes at offset 2732032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2768896 ++wrote 4096/4096 bytes at offset 2768896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2805760 ++wrote 4096/4096 bytes at offset 2805760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2842624 ++wrote 4096/4096 bytes at offset 2842624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2879488 ++wrote 4096/4096 bytes at offset 2879488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2916352 ++wrote 4096/4096 bytes at offset 2916352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2953216 ++wrote 4096/4096 bytes at offset 2953216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2990080 ++wrote 4096/4096 bytes at offset 2990080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3026944 ++wrote 4096/4096 bytes at offset 3026944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3063808 ++wrote 4096/4096 bytes at offset 3063808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3100672 ++wrote 4096/4096 bytes at offset 3100672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3137536 ++wrote 4096/4096 bytes at offset 3137536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3174400 ++wrote 4096/4096 bytes at offset 3174400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3211264 ++wrote 4096/4096 bytes at offset 3211264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3248128 ++wrote 4096/4096 bytes at offset 3248128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3284992 ++wrote 4096/4096 bytes at offset 3284992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3321856 ++wrote 4096/4096 bytes at offset 3321856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3358720 ++wrote 4096/4096 bytes at offset 3358720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3395584 ++wrote 4096/4096 bytes at offset 3395584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3432448 ++wrote 4096/4096 bytes at offset 3432448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3469312 ++wrote 4096/4096 bytes at offset 3469312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3506176 ++wrote 4096/4096 bytes at offset 3506176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3543040 ++wrote 4096/4096 bytes at offset 3543040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3579904 ++wrote 4096/4096 bytes at offset 3579904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3616768 ++wrote 4096/4096 bytes at offset 3616768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3653632 ++wrote 4096/4096 bytes at offset 3653632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3690496 ++wrote 4096/4096 bytes at offset 3690496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3727360 ++wrote 4096/4096 bytes at offset 3727360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3764224 ++wrote 4096/4096 bytes at offset 3764224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3801088 ++wrote 4096/4096 bytes at offset 3801088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3837952 ++wrote 4096/4096 bytes at offset 3837952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3874816 ++wrote 4096/4096 bytes at offset 3874816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3911680 ++wrote 4096/4096 bytes at offset 3911680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3948544 ++wrote 4096/4096 bytes at offset 3948544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3985408 ++wrote 4096/4096 bytes at offset 3985408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4022272 ++wrote 4096/4096 bytes at offset 4022272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4059136 ++wrote 4096/4096 bytes at offset 4059136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4096000 ++wrote 4096/4096 bytes at offset 4096000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4132864 ++wrote 4096/4096 bytes at offset 4132864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4169728 ++wrote 4096/4096 bytes at offset 4169728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4206592 ++wrote 4096/4096 bytes at offset 4206592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4243456 ++wrote 4096/4096 bytes at offset 4243456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4280320 ++wrote 4096/4096 bytes at offset 4280320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4317184 ++wrote 4096/4096 bytes at offset 4317184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4354048 ++wrote 4096/4096 bytes at offset 4354048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4390912 ++wrote 4096/4096 bytes at offset 4390912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4427776 ++wrote 4096/4096 bytes at offset 4427776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4464640 ++wrote 4096/4096 bytes at offset 4464640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4501504 ++wrote 4096/4096 bytes at offset 4501504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4538368 ++wrote 4096/4096 bytes at offset 4538368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4575232 ++wrote 4096/4096 bytes at offset 4575232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4612096 ++wrote 4096/4096 bytes at offset 4612096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4648960 ++wrote 4096/4096 bytes at offset 4648960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4685824 ++wrote 4096/4096 bytes at offset 4685824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4722688 ++wrote 4096/4096 bytes at offset 4722688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4759552 ++wrote 4096/4096 bytes at offset 4759552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4796416 ++wrote 4096/4096 bytes at offset 4796416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4833280 ++wrote 4096/4096 bytes at offset 4833280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4870144 ++wrote 4096/4096 bytes at offset 4870144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4907008 ++wrote 4096/4096 bytes at offset 4907008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4943872 ++wrote 4096/4096 bytes at offset 4943872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4980736 ++wrote 4096/4096 bytes at offset 4980736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5017600 ++wrote 4096/4096 bytes at offset 5017600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5054464 ++wrote 4096/4096 bytes at offset 5054464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5091328 ++wrote 4096/4096 bytes at offset 5091328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5128192 ++wrote 4096/4096 bytes at offset 5128192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5165056 ++wrote 4096/4096 bytes at offset 5165056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5201920 ++wrote 4096/4096 bytes at offset 5201920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5238784 ++wrote 4096/4096 bytes at offset 5238784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5275648 ++wrote 4096/4096 bytes at offset 5275648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5312512 ++wrote 4096/4096 bytes at offset 5312512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5349376 ++wrote 4096/4096 bytes at offset 5349376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5386240 ++wrote 4096/4096 bytes at offset 5386240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5423104 ++wrote 4096/4096 bytes at offset 5423104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5459968 ++wrote 4096/4096 bytes at offset 5459968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5496832 ++wrote 4096/4096 bytes at offset 5496832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5533696 ++wrote 4096/4096 bytes at offset 5533696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5570560 ++wrote 4096/4096 bytes at offset 5570560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5607424 ++wrote 4096/4096 bytes at offset 5607424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5644288 ++wrote 4096/4096 bytes at offset 5644288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5681152 ++wrote 4096/4096 bytes at offset 5681152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5718016 ++wrote 4096/4096 bytes at offset 5718016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5754880 ++wrote 4096/4096 bytes at offset 5754880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5791744 ++wrote 4096/4096 bytes at offset 5791744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5828608 ++wrote 4096/4096 bytes at offset 5828608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5865472 ++wrote 4096/4096 bytes at offset 5865472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5902336 ++wrote 4096/4096 bytes at offset 5902336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5939200 ++wrote 4096/4096 bytes at offset 5939200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5976064 ++wrote 4096/4096 bytes at offset 5976064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6012928 ++wrote 4096/4096 bytes at offset 6012928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6049792 ++wrote 4096/4096 bytes at offset 6049792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6086656 ++wrote 4096/4096 bytes at offset 6086656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6123520 ++wrote 4096/4096 bytes at offset 6123520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6160384 ++wrote 4096/4096 bytes at offset 6160384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6197248 ++wrote 4096/4096 bytes at offset 6197248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6234112 ++wrote 4096/4096 bytes at offset 6234112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6270976 ++wrote 4096/4096 bytes at offset 6270976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6307840 ++wrote 4096/4096 bytes at offset 6307840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6344704 ++wrote 4096/4096 bytes at offset 6344704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6381568 ++wrote 4096/4096 bytes at offset 6381568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6418432 ++wrote 4096/4096 bytes at offset 6418432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6455296 ++wrote 4096/4096 bytes at offset 6455296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6492160 ++wrote 4096/4096 bytes at offset 6492160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6529024 ++wrote 4096/4096 bytes at offset 6529024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6565888 ++wrote 4096/4096 bytes at offset 6565888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6602752 ++wrote 4096/4096 bytes at offset 6602752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6639616 ++wrote 4096/4096 bytes at offset 6639616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6676480 ++wrote 4096/4096 bytes at offset 6676480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6713344 ++wrote 4096/4096 bytes at offset 6713344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6750208 ++wrote 4096/4096 bytes at offset 6750208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6787072 ++wrote 4096/4096 bytes at offset 6787072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6823936 ++wrote 4096/4096 bytes at offset 6823936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6860800 ++wrote 4096/4096 bytes at offset 6860800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6897664 ++wrote 4096/4096 bytes at offset 6897664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6934528 ++wrote 4096/4096 bytes at offset 6934528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6971392 ++wrote 4096/4096 bytes at offset 6971392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7008256 ++wrote 4096/4096 bytes at offset 7008256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7045120 ++wrote 4096/4096 bytes at offset 7045120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7081984 ++wrote 4096/4096 bytes at offset 7081984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7118848 ++wrote 4096/4096 bytes at offset 7118848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7155712 ++wrote 4096/4096 bytes at offset 7155712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7192576 ++wrote 4096/4096 bytes at offset 7192576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7229440 ++wrote 4096/4096 bytes at offset 7229440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7266304 ++wrote 4096/4096 bytes at offset 7266304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7303168 ++wrote 4096/4096 bytes at offset 7303168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7340032 ++wrote 4096/4096 bytes at offset 7340032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7376896 ++wrote 4096/4096 bytes at offset 7376896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7413760 ++wrote 4096/4096 bytes at offset 7413760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7450624 ++wrote 4096/4096 bytes at offset 7450624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7487488 ++wrote 4096/4096 bytes at offset 7487488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7524352 ++wrote 4096/4096 bytes at offset 7524352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7561216 ++wrote 4096/4096 bytes at offset 7561216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7598080 ++wrote 4096/4096 bytes at offset 7598080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7634944 ++wrote 4096/4096 bytes at offset 7634944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7671808 ++wrote 4096/4096 bytes at offset 7671808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7708672 ++wrote 4096/4096 bytes at offset 7708672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7745536 ++wrote 4096/4096 bytes at offset 7745536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7782400 ++wrote 4096/4096 bytes at offset 7782400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7819264 ++wrote 4096/4096 bytes at offset 7819264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7856128 ++wrote 4096/4096 bytes at offset 7856128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7892992 ++wrote 4096/4096 bytes at offset 7892992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7929856 ++wrote 4096/4096 bytes at offset 7929856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7966720 ++wrote 4096/4096 bytes at offset 7966720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8003584 ++wrote 4096/4096 bytes at offset 8003584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8040448 ++wrote 4096/4096 bytes at offset 8040448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8077312 ++wrote 4096/4096 bytes at offset 8077312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8114176 ++wrote 4096/4096 bytes at offset 8114176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8151040 ++wrote 4096/4096 bytes at offset 8151040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8187904 ++wrote 4096/4096 bytes at offset 8187904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8224768 ++wrote 4096/4096 bytes at offset 8224768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8261632 ++wrote 4096/4096 bytes at offset 8261632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8298496 ++wrote 4096/4096 bytes at offset 8298496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8335360 ++wrote 4096/4096 bytes at offset 8335360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8372224 ++wrote 4096/4096 bytes at offset 8372224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8409088 ++wrote 4096/4096 bytes at offset 8409088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8445952 ++wrote 4096/4096 bytes at offset 8445952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8482816 ++wrote 4096/4096 bytes at offset 8482816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8519680 ++wrote 4096/4096 bytes at offset 8519680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8556544 ++wrote 4096/4096 bytes at offset 8556544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8593408 ++wrote 4096/4096 bytes at offset 8593408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8630272 ++wrote 4096/4096 bytes at offset 8630272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8667136 ++wrote 4096/4096 bytes at offset 8667136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8704000 ++wrote 4096/4096 bytes at offset 8704000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8740864 ++wrote 4096/4096 bytes at offset 8740864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8777728 ++wrote 4096/4096 bytes at offset 8777728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8814592 ++wrote 4096/4096 bytes at offset 8814592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8851456 ++wrote 4096/4096 bytes at offset 8851456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8888320 ++wrote 4096/4096 bytes at offset 8888320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8925184 ++wrote 4096/4096 bytes at offset 8925184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8962048 ++wrote 4096/4096 bytes at offset 8962048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8998912 ++wrote 4096/4096 bytes at offset 8998912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 9035776 ++wrote 4096/4096 bytes at offset 9035776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 9072640 ++wrote 4096/4096 bytes at offset 9072640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 9109504 ++wrote 4096/4096 bytes at offset 9109504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 9146368 ++wrote 4096/4096 bytes at offset 9146368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 9183232 ++wrote 4096/4096 bytes at offset 9183232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 9220096 ++wrote 4096/4096 bytes at offset 9220096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 9256960 ++wrote 4096/4096 bytes at offset 9256960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 9293824 ++wrote 4096/4096 bytes at offset 9293824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 9330688 ++wrote 4096/4096 bytes at offset 9330688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 9367552 ++wrote 4096/4096 bytes at offset 9367552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 9404416 ++wrote 4096/4096 bytes at offset 9404416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === Used clusters [3] ++=== Used clusters [3] + === IO: pattern 165 +-qemu-io> wrote 4096/4096 bytes at offset 12288 ++wrote 4096/4096 bytes at offset 12288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 49152 ++wrote 4096/4096 bytes at offset 49152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 86016 ++wrote 4096/4096 bytes at offset 86016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 122880 ++wrote 4096/4096 bytes at offset 122880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 159744 ++wrote 4096/4096 bytes at offset 159744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 196608 ++wrote 4096/4096 bytes at offset 196608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 233472 ++wrote 4096/4096 bytes at offset 233472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 270336 ++wrote 4096/4096 bytes at offset 270336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 307200 ++wrote 4096/4096 bytes at offset 307200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 344064 ++wrote 4096/4096 bytes at offset 344064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 380928 ++wrote 4096/4096 bytes at offset 380928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 417792 ++wrote 4096/4096 bytes at offset 417792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 454656 ++wrote 4096/4096 bytes at offset 454656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 491520 ++wrote 4096/4096 bytes at offset 491520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 528384 ++wrote 4096/4096 bytes at offset 528384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 565248 ++wrote 4096/4096 bytes at offset 565248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 602112 ++wrote 4096/4096 bytes at offset 602112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 638976 ++wrote 4096/4096 bytes at offset 638976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 675840 ++wrote 4096/4096 bytes at offset 675840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 712704 ++wrote 4096/4096 bytes at offset 712704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 749568 ++wrote 4096/4096 bytes at offset 749568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 786432 ++wrote 4096/4096 bytes at offset 786432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 823296 ++wrote 4096/4096 bytes at offset 823296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 860160 ++wrote 4096/4096 bytes at offset 860160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 897024 ++wrote 4096/4096 bytes at offset 897024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 933888 ++wrote 4096/4096 bytes at offset 933888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 970752 ++wrote 4096/4096 bytes at offset 970752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1007616 ++wrote 4096/4096 bytes at offset 1007616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1044480 ++wrote 4096/4096 bytes at offset 1044480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1081344 ++wrote 4096/4096 bytes at offset 1081344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1118208 ++wrote 4096/4096 bytes at offset 1118208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1155072 ++wrote 4096/4096 bytes at offset 1155072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1191936 ++wrote 4096/4096 bytes at offset 1191936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1228800 ++wrote 4096/4096 bytes at offset 1228800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1265664 ++wrote 4096/4096 bytes at offset 1265664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1302528 ++wrote 4096/4096 bytes at offset 1302528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1339392 ++wrote 4096/4096 bytes at offset 1339392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1376256 ++wrote 4096/4096 bytes at offset 1376256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1413120 ++wrote 4096/4096 bytes at offset 1413120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1449984 ++wrote 4096/4096 bytes at offset 1449984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1486848 ++wrote 4096/4096 bytes at offset 1486848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1523712 ++wrote 4096/4096 bytes at offset 1523712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1560576 ++wrote 4096/4096 bytes at offset 1560576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1597440 ++wrote 4096/4096 bytes at offset 1597440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1634304 ++wrote 4096/4096 bytes at offset 1634304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1671168 ++wrote 4096/4096 bytes at offset 1671168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1708032 ++wrote 4096/4096 bytes at offset 1708032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1744896 ++wrote 4096/4096 bytes at offset 1744896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1781760 ++wrote 4096/4096 bytes at offset 1781760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1818624 ++wrote 4096/4096 bytes at offset 1818624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1855488 ++wrote 4096/4096 bytes at offset 1855488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1892352 ++wrote 4096/4096 bytes at offset 1892352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1929216 ++wrote 4096/4096 bytes at offset 1929216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1966080 ++wrote 4096/4096 bytes at offset 1966080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2002944 ++wrote 4096/4096 bytes at offset 2002944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2039808 ++wrote 4096/4096 bytes at offset 2039808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2076672 ++wrote 4096/4096 bytes at offset 2076672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2113536 ++wrote 4096/4096 bytes at offset 2113536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2150400 ++wrote 4096/4096 bytes at offset 2150400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2187264 ++wrote 4096/4096 bytes at offset 2187264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2224128 ++wrote 4096/4096 bytes at offset 2224128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2260992 ++wrote 4096/4096 bytes at offset 2260992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2297856 ++wrote 4096/4096 bytes at offset 2297856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2334720 ++wrote 4096/4096 bytes at offset 2334720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2371584 ++wrote 4096/4096 bytes at offset 2371584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2408448 ++wrote 4096/4096 bytes at offset 2408448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2445312 ++wrote 4096/4096 bytes at offset 2445312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2482176 ++wrote 4096/4096 bytes at offset 2482176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2519040 ++wrote 4096/4096 bytes at offset 2519040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2555904 ++wrote 4096/4096 bytes at offset 2555904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2592768 ++wrote 4096/4096 bytes at offset 2592768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2629632 ++wrote 4096/4096 bytes at offset 2629632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2666496 ++wrote 4096/4096 bytes at offset 2666496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2703360 ++wrote 4096/4096 bytes at offset 2703360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2740224 ++wrote 4096/4096 bytes at offset 2740224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2777088 ++wrote 4096/4096 bytes at offset 2777088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2813952 ++wrote 4096/4096 bytes at offset 2813952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2850816 ++wrote 4096/4096 bytes at offset 2850816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2887680 ++wrote 4096/4096 bytes at offset 2887680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2924544 ++wrote 4096/4096 bytes at offset 2924544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2961408 ++wrote 4096/4096 bytes at offset 2961408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 2998272 ++wrote 4096/4096 bytes at offset 2998272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3035136 ++wrote 4096/4096 bytes at offset 3035136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3072000 ++wrote 4096/4096 bytes at offset 3072000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3108864 ++wrote 4096/4096 bytes at offset 3108864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3145728 ++wrote 4096/4096 bytes at offset 3145728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3182592 ++wrote 4096/4096 bytes at offset 3182592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3219456 ++wrote 4096/4096 bytes at offset 3219456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3256320 ++wrote 4096/4096 bytes at offset 3256320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3293184 ++wrote 4096/4096 bytes at offset 3293184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3330048 ++wrote 4096/4096 bytes at offset 3330048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3366912 ++wrote 4096/4096 bytes at offset 3366912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3403776 ++wrote 4096/4096 bytes at offset 3403776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3440640 ++wrote 4096/4096 bytes at offset 3440640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3477504 ++wrote 4096/4096 bytes at offset 3477504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3514368 ++wrote 4096/4096 bytes at offset 3514368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3551232 ++wrote 4096/4096 bytes at offset 3551232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3588096 ++wrote 4096/4096 bytes at offset 3588096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3624960 ++wrote 4096/4096 bytes at offset 3624960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3661824 ++wrote 4096/4096 bytes at offset 3661824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3698688 ++wrote 4096/4096 bytes at offset 3698688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3735552 ++wrote 4096/4096 bytes at offset 3735552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3772416 ++wrote 4096/4096 bytes at offset 3772416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3809280 ++wrote 4096/4096 bytes at offset 3809280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3846144 ++wrote 4096/4096 bytes at offset 3846144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3883008 ++wrote 4096/4096 bytes at offset 3883008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3919872 ++wrote 4096/4096 bytes at offset 3919872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3956736 ++wrote 4096/4096 bytes at offset 3956736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 3993600 ++wrote 4096/4096 bytes at offset 3993600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4030464 ++wrote 4096/4096 bytes at offset 4030464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4067328 ++wrote 4096/4096 bytes at offset 4067328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4104192 ++wrote 4096/4096 bytes at offset 4104192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4141056 ++wrote 4096/4096 bytes at offset 4141056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4177920 ++wrote 4096/4096 bytes at offset 4177920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4214784 ++wrote 4096/4096 bytes at offset 4214784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4251648 ++wrote 4096/4096 bytes at offset 4251648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4288512 ++wrote 4096/4096 bytes at offset 4288512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4325376 ++wrote 4096/4096 bytes at offset 4325376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4362240 ++wrote 4096/4096 bytes at offset 4362240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4399104 ++wrote 4096/4096 bytes at offset 4399104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4435968 ++wrote 4096/4096 bytes at offset 4435968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4472832 ++wrote 4096/4096 bytes at offset 4472832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4509696 ++wrote 4096/4096 bytes at offset 4509696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4546560 ++wrote 4096/4096 bytes at offset 4546560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4583424 ++wrote 4096/4096 bytes at offset 4583424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4620288 ++wrote 4096/4096 bytes at offset 4620288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4657152 ++wrote 4096/4096 bytes at offset 4657152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4694016 ++wrote 4096/4096 bytes at offset 4694016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4730880 ++wrote 4096/4096 bytes at offset 4730880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4767744 ++wrote 4096/4096 bytes at offset 4767744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4804608 ++wrote 4096/4096 bytes at offset 4804608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4841472 ++wrote 4096/4096 bytes at offset 4841472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4878336 ++wrote 4096/4096 bytes at offset 4878336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4915200 ++wrote 4096/4096 bytes at offset 4915200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4952064 ++wrote 4096/4096 bytes at offset 4952064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4988928 ++wrote 4096/4096 bytes at offset 4988928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5025792 ++wrote 4096/4096 bytes at offset 5025792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5062656 ++wrote 4096/4096 bytes at offset 5062656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5099520 ++wrote 4096/4096 bytes at offset 5099520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5136384 ++wrote 4096/4096 bytes at offset 5136384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5173248 ++wrote 4096/4096 bytes at offset 5173248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5210112 ++wrote 4096/4096 bytes at offset 5210112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5246976 ++wrote 4096/4096 bytes at offset 5246976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5283840 ++wrote 4096/4096 bytes at offset 5283840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5320704 ++wrote 4096/4096 bytes at offset 5320704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5357568 ++wrote 4096/4096 bytes at offset 5357568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5394432 ++wrote 4096/4096 bytes at offset 5394432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5431296 ++wrote 4096/4096 bytes at offset 5431296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5468160 ++wrote 4096/4096 bytes at offset 5468160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5505024 ++wrote 4096/4096 bytes at offset 5505024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5541888 ++wrote 4096/4096 bytes at offset 5541888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5578752 ++wrote 4096/4096 bytes at offset 5578752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5615616 ++wrote 4096/4096 bytes at offset 5615616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5652480 ++wrote 4096/4096 bytes at offset 5652480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5689344 ++wrote 4096/4096 bytes at offset 5689344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5726208 ++wrote 4096/4096 bytes at offset 5726208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5763072 ++wrote 4096/4096 bytes at offset 5763072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5799936 ++wrote 4096/4096 bytes at offset 5799936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5836800 ++wrote 4096/4096 bytes at offset 5836800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5873664 ++wrote 4096/4096 bytes at offset 5873664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5910528 ++wrote 4096/4096 bytes at offset 5910528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5947392 ++wrote 4096/4096 bytes at offset 5947392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 5984256 ++wrote 4096/4096 bytes at offset 5984256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6021120 ++wrote 4096/4096 bytes at offset 6021120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6057984 ++wrote 4096/4096 bytes at offset 6057984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6094848 ++wrote 4096/4096 bytes at offset 6094848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6131712 ++wrote 4096/4096 bytes at offset 6131712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6168576 ++wrote 4096/4096 bytes at offset 6168576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6205440 ++wrote 4096/4096 bytes at offset 6205440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6242304 ++wrote 4096/4096 bytes at offset 6242304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6279168 ++wrote 4096/4096 bytes at offset 6279168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6316032 ++wrote 4096/4096 bytes at offset 6316032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6352896 ++wrote 4096/4096 bytes at offset 6352896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6389760 ++wrote 4096/4096 bytes at offset 6389760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6426624 ++wrote 4096/4096 bytes at offset 6426624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6463488 ++wrote 4096/4096 bytes at offset 6463488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6500352 ++wrote 4096/4096 bytes at offset 6500352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6537216 ++wrote 4096/4096 bytes at offset 6537216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6574080 ++wrote 4096/4096 bytes at offset 6574080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6610944 ++wrote 4096/4096 bytes at offset 6610944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6647808 ++wrote 4096/4096 bytes at offset 6647808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6684672 ++wrote 4096/4096 bytes at offset 6684672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6721536 ++wrote 4096/4096 bytes at offset 6721536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6758400 ++wrote 4096/4096 bytes at offset 6758400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6795264 ++wrote 4096/4096 bytes at offset 6795264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6832128 ++wrote 4096/4096 bytes at offset 6832128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6868992 ++wrote 4096/4096 bytes at offset 6868992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6905856 ++wrote 4096/4096 bytes at offset 6905856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6942720 ++wrote 4096/4096 bytes at offset 6942720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 6979584 ++wrote 4096/4096 bytes at offset 6979584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7016448 ++wrote 4096/4096 bytes at offset 7016448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7053312 ++wrote 4096/4096 bytes at offset 7053312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7090176 ++wrote 4096/4096 bytes at offset 7090176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7127040 ++wrote 4096/4096 bytes at offset 7127040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7163904 ++wrote 4096/4096 bytes at offset 7163904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7200768 ++wrote 4096/4096 bytes at offset 7200768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7237632 ++wrote 4096/4096 bytes at offset 7237632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7274496 ++wrote 4096/4096 bytes at offset 7274496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7311360 ++wrote 4096/4096 bytes at offset 7311360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7348224 ++wrote 4096/4096 bytes at offset 7348224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7385088 ++wrote 4096/4096 bytes at offset 7385088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7421952 ++wrote 4096/4096 bytes at offset 7421952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7458816 ++wrote 4096/4096 bytes at offset 7458816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7495680 ++wrote 4096/4096 bytes at offset 7495680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7532544 ++wrote 4096/4096 bytes at offset 7532544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7569408 ++wrote 4096/4096 bytes at offset 7569408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7606272 ++wrote 4096/4096 bytes at offset 7606272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7643136 ++wrote 4096/4096 bytes at offset 7643136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7680000 ++wrote 4096/4096 bytes at offset 7680000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7716864 ++wrote 4096/4096 bytes at offset 7716864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7753728 ++wrote 4096/4096 bytes at offset 7753728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7790592 ++wrote 4096/4096 bytes at offset 7790592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7827456 ++wrote 4096/4096 bytes at offset 7827456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7864320 ++wrote 4096/4096 bytes at offset 7864320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7901184 ++wrote 4096/4096 bytes at offset 7901184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7938048 ++wrote 4096/4096 bytes at offset 7938048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 7974912 ++wrote 4096/4096 bytes at offset 7974912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8011776 ++wrote 4096/4096 bytes at offset 8011776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8048640 ++wrote 4096/4096 bytes at offset 8048640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8085504 ++wrote 4096/4096 bytes at offset 8085504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8122368 ++wrote 4096/4096 bytes at offset 8122368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8159232 ++wrote 4096/4096 bytes at offset 8159232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8196096 ++wrote 4096/4096 bytes at offset 8196096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8232960 ++wrote 4096/4096 bytes at offset 8232960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8269824 ++wrote 4096/4096 bytes at offset 8269824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8306688 ++wrote 4096/4096 bytes at offset 8306688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8343552 ++wrote 4096/4096 bytes at offset 8343552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8380416 ++wrote 4096/4096 bytes at offset 8380416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8417280 ++wrote 4096/4096 bytes at offset 8417280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8454144 ++wrote 4096/4096 bytes at offset 8454144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8491008 ++wrote 4096/4096 bytes at offset 8491008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8527872 ++wrote 4096/4096 bytes at offset 8527872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8564736 ++wrote 4096/4096 bytes at offset 8564736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8601600 ++wrote 4096/4096 bytes at offset 8601600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8638464 ++wrote 4096/4096 bytes at offset 8638464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8675328 ++wrote 4096/4096 bytes at offset 8675328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8712192 ++wrote 4096/4096 bytes at offset 8712192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8749056 ++wrote 4096/4096 bytes at offset 8749056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8785920 ++wrote 4096/4096 bytes at offset 8785920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8822784 ++wrote 4096/4096 bytes at offset 8822784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8859648 ++wrote 4096/4096 bytes at offset 8859648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8896512 ++wrote 4096/4096 bytes at offset 8896512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8933376 ++wrote 4096/4096 bytes at offset 8933376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8970240 ++wrote 4096/4096 bytes at offset 8970240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 9007104 ++wrote 4096/4096 bytes at offset 9007104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 9043968 ++wrote 4096/4096 bytes at offset 9043968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 9080832 ++wrote 4096/4096 bytes at offset 9080832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 9117696 ++wrote 4096/4096 bytes at offset 9117696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 9154560 ++wrote 4096/4096 bytes at offset 9154560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 9191424 ++wrote 4096/4096 bytes at offset 9191424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 9228288 ++wrote 4096/4096 bytes at offset 9228288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 9265152 ++wrote 4096/4096 bytes at offset 9265152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 9302016 ++wrote 4096/4096 bytes at offset 9302016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 9338880 ++wrote 4096/4096 bytes at offset 9338880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 9375744 ++wrote 4096/4096 bytes at offset 9375744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 9412608 ++wrote 4096/4096 bytes at offset 9412608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === Read used/compressed clusters ++=== Read used/compressed clusters + === IO: pattern 165 +-qemu-io> read 8192/8192 bytes at offset 0 ++read 8192/8192 bytes at offset 0 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 36864 ++read 8192/8192 bytes at offset 36864 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 73728 ++read 8192/8192 bytes at offset 73728 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 110592 ++read 8192/8192 bytes at offset 110592 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 147456 ++read 8192/8192 bytes at offset 147456 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 184320 ++read 8192/8192 bytes at offset 184320 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 221184 ++read 8192/8192 bytes at offset 221184 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 258048 ++read 8192/8192 bytes at offset 258048 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 294912 ++read 8192/8192 bytes at offset 294912 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 331776 ++read 8192/8192 bytes at offset 331776 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 368640 ++read 8192/8192 bytes at offset 368640 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 405504 ++read 8192/8192 bytes at offset 405504 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 442368 ++read 8192/8192 bytes at offset 442368 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 479232 ++read 8192/8192 bytes at offset 479232 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 516096 ++read 8192/8192 bytes at offset 516096 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 552960 ++read 8192/8192 bytes at offset 552960 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 589824 ++read 8192/8192 bytes at offset 589824 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 626688 ++read 8192/8192 bytes at offset 626688 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 663552 ++read 8192/8192 bytes at offset 663552 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 700416 ++read 8192/8192 bytes at offset 700416 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 737280 ++read 8192/8192 bytes at offset 737280 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 774144 ++read 8192/8192 bytes at offset 774144 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 811008 ++read 8192/8192 bytes at offset 811008 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 847872 ++read 8192/8192 bytes at offset 847872 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 884736 ++read 8192/8192 bytes at offset 884736 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 921600 ++read 8192/8192 bytes at offset 921600 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 958464 ++read 8192/8192 bytes at offset 958464 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 995328 ++read 8192/8192 bytes at offset 995328 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1032192 ++read 8192/8192 bytes at offset 1032192 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1069056 ++read 8192/8192 bytes at offset 1069056 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1105920 ++read 8192/8192 bytes at offset 1105920 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1142784 ++read 8192/8192 bytes at offset 1142784 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1179648 ++read 8192/8192 bytes at offset 1179648 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1216512 ++read 8192/8192 bytes at offset 1216512 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1253376 ++read 8192/8192 bytes at offset 1253376 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1290240 ++read 8192/8192 bytes at offset 1290240 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1327104 ++read 8192/8192 bytes at offset 1327104 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1363968 ++read 8192/8192 bytes at offset 1363968 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1400832 ++read 8192/8192 bytes at offset 1400832 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1437696 ++read 8192/8192 bytes at offset 1437696 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1474560 ++read 8192/8192 bytes at offset 1474560 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1511424 ++read 8192/8192 bytes at offset 1511424 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1548288 ++read 8192/8192 bytes at offset 1548288 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1585152 ++read 8192/8192 bytes at offset 1585152 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1622016 ++read 8192/8192 bytes at offset 1622016 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1658880 ++read 8192/8192 bytes at offset 1658880 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1695744 ++read 8192/8192 bytes at offset 1695744 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1732608 ++read 8192/8192 bytes at offset 1732608 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1769472 ++read 8192/8192 bytes at offset 1769472 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1806336 ++read 8192/8192 bytes at offset 1806336 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1843200 ++read 8192/8192 bytes at offset 1843200 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1880064 ++read 8192/8192 bytes at offset 1880064 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1916928 ++read 8192/8192 bytes at offset 1916928 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1953792 ++read 8192/8192 bytes at offset 1953792 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1990656 ++read 8192/8192 bytes at offset 1990656 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2027520 ++read 8192/8192 bytes at offset 2027520 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2064384 ++read 8192/8192 bytes at offset 2064384 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2101248 ++read 8192/8192 bytes at offset 2101248 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2138112 ++read 8192/8192 bytes at offset 2138112 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2174976 ++read 8192/8192 bytes at offset 2174976 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2211840 ++read 8192/8192 bytes at offset 2211840 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2248704 ++read 8192/8192 bytes at offset 2248704 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2285568 ++read 8192/8192 bytes at offset 2285568 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2322432 ++read 8192/8192 bytes at offset 2322432 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2359296 ++read 8192/8192 bytes at offset 2359296 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2396160 ++read 8192/8192 bytes at offset 2396160 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2433024 ++read 8192/8192 bytes at offset 2433024 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2469888 ++read 8192/8192 bytes at offset 2469888 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2506752 ++read 8192/8192 bytes at offset 2506752 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2543616 ++read 8192/8192 bytes at offset 2543616 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2580480 ++read 8192/8192 bytes at offset 2580480 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2617344 ++read 8192/8192 bytes at offset 2617344 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2654208 ++read 8192/8192 bytes at offset 2654208 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2691072 ++read 8192/8192 bytes at offset 2691072 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2727936 ++read 8192/8192 bytes at offset 2727936 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2764800 ++read 8192/8192 bytes at offset 2764800 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2801664 ++read 8192/8192 bytes at offset 2801664 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2838528 ++read 8192/8192 bytes at offset 2838528 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2875392 ++read 8192/8192 bytes at offset 2875392 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2912256 ++read 8192/8192 bytes at offset 2912256 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2949120 ++read 8192/8192 bytes at offset 2949120 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2985984 ++read 8192/8192 bytes at offset 2985984 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 3022848 ++read 8192/8192 bytes at offset 3022848 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 3059712 ++read 8192/8192 bytes at offset 3059712 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 3096576 ++read 8192/8192 bytes at offset 3096576 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 3133440 ++read 8192/8192 bytes at offset 3133440 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 3170304 ++read 8192/8192 bytes at offset 3170304 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 3207168 ++read 8192/8192 bytes at offset 3207168 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 3244032 ++read 8192/8192 bytes at offset 3244032 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 3280896 ++read 8192/8192 bytes at offset 3280896 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 3317760 ++read 8192/8192 bytes at offset 3317760 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 3354624 ++read 8192/8192 bytes at offset 3354624 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 3391488 ++read 8192/8192 bytes at offset 3391488 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 3428352 ++read 8192/8192 bytes at offset 3428352 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 3465216 ++read 8192/8192 bytes at offset 3465216 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 3502080 ++read 8192/8192 bytes at offset 3502080 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 3538944 ++read 8192/8192 bytes at offset 3538944 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 3575808 ++read 8192/8192 bytes at offset 3575808 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 3612672 ++read 8192/8192 bytes at offset 3612672 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 3649536 ++read 8192/8192 bytes at offset 3649536 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 3686400 ++read 8192/8192 bytes at offset 3686400 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 3723264 ++read 8192/8192 bytes at offset 3723264 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 3760128 ++read 8192/8192 bytes at offset 3760128 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 3796992 ++read 8192/8192 bytes at offset 3796992 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 3833856 ++read 8192/8192 bytes at offset 3833856 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 3870720 ++read 8192/8192 bytes at offset 3870720 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 3907584 ++read 8192/8192 bytes at offset 3907584 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 3944448 ++read 8192/8192 bytes at offset 3944448 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 3981312 ++read 8192/8192 bytes at offset 3981312 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4018176 ++read 8192/8192 bytes at offset 4018176 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4055040 ++read 8192/8192 bytes at offset 4055040 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4091904 ++read 8192/8192 bytes at offset 4091904 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4128768 ++read 8192/8192 bytes at offset 4128768 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4165632 ++read 8192/8192 bytes at offset 4165632 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4202496 ++read 8192/8192 bytes at offset 4202496 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4239360 ++read 8192/8192 bytes at offset 4239360 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4276224 ++read 8192/8192 bytes at offset 4276224 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4313088 ++read 8192/8192 bytes at offset 4313088 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4349952 ++read 8192/8192 bytes at offset 4349952 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4386816 ++read 8192/8192 bytes at offset 4386816 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4423680 ++read 8192/8192 bytes at offset 4423680 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4460544 ++read 8192/8192 bytes at offset 4460544 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4497408 ++read 8192/8192 bytes at offset 4497408 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4534272 ++read 8192/8192 bytes at offset 4534272 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4571136 ++read 8192/8192 bytes at offset 4571136 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4608000 ++read 8192/8192 bytes at offset 4608000 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4644864 ++read 8192/8192 bytes at offset 4644864 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4681728 ++read 8192/8192 bytes at offset 4681728 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4718592 ++read 8192/8192 bytes at offset 4718592 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4755456 ++read 8192/8192 bytes at offset 4755456 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4792320 ++read 8192/8192 bytes at offset 4792320 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4829184 ++read 8192/8192 bytes at offset 4829184 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4866048 ++read 8192/8192 bytes at offset 4866048 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4902912 ++read 8192/8192 bytes at offset 4902912 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4939776 ++read 8192/8192 bytes at offset 4939776 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4976640 ++read 8192/8192 bytes at offset 4976640 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 5013504 ++read 8192/8192 bytes at offset 5013504 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 5050368 ++read 8192/8192 bytes at offset 5050368 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 5087232 ++read 8192/8192 bytes at offset 5087232 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 5124096 ++read 8192/8192 bytes at offset 5124096 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 5160960 ++read 8192/8192 bytes at offset 5160960 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 5197824 ++read 8192/8192 bytes at offset 5197824 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 5234688 ++read 8192/8192 bytes at offset 5234688 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 5271552 ++read 8192/8192 bytes at offset 5271552 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 5308416 ++read 8192/8192 bytes at offset 5308416 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 5345280 ++read 8192/8192 bytes at offset 5345280 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 5382144 ++read 8192/8192 bytes at offset 5382144 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 5419008 ++read 8192/8192 bytes at offset 5419008 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 5455872 ++read 8192/8192 bytes at offset 5455872 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 5492736 ++read 8192/8192 bytes at offset 5492736 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 5529600 ++read 8192/8192 bytes at offset 5529600 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 5566464 ++read 8192/8192 bytes at offset 5566464 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 5603328 ++read 8192/8192 bytes at offset 5603328 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 5640192 ++read 8192/8192 bytes at offset 5640192 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 5677056 ++read 8192/8192 bytes at offset 5677056 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 5713920 ++read 8192/8192 bytes at offset 5713920 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 5750784 ++read 8192/8192 bytes at offset 5750784 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 5787648 ++read 8192/8192 bytes at offset 5787648 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 5824512 ++read 8192/8192 bytes at offset 5824512 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 5861376 ++read 8192/8192 bytes at offset 5861376 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 5898240 ++read 8192/8192 bytes at offset 5898240 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 5935104 ++read 8192/8192 bytes at offset 5935104 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 5971968 ++read 8192/8192 bytes at offset 5971968 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 6008832 ++read 8192/8192 bytes at offset 6008832 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 6045696 ++read 8192/8192 bytes at offset 6045696 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 6082560 ++read 8192/8192 bytes at offset 6082560 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 6119424 ++read 8192/8192 bytes at offset 6119424 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 6156288 ++read 8192/8192 bytes at offset 6156288 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 6193152 ++read 8192/8192 bytes at offset 6193152 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 6230016 ++read 8192/8192 bytes at offset 6230016 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 6266880 ++read 8192/8192 bytes at offset 6266880 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 6303744 ++read 8192/8192 bytes at offset 6303744 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 6340608 ++read 8192/8192 bytes at offset 6340608 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 6377472 ++read 8192/8192 bytes at offset 6377472 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 6414336 ++read 8192/8192 bytes at offset 6414336 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 6451200 ++read 8192/8192 bytes at offset 6451200 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 6488064 ++read 8192/8192 bytes at offset 6488064 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 6524928 ++read 8192/8192 bytes at offset 6524928 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 6561792 ++read 8192/8192 bytes at offset 6561792 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 6598656 ++read 8192/8192 bytes at offset 6598656 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 6635520 ++read 8192/8192 bytes at offset 6635520 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 6672384 ++read 8192/8192 bytes at offset 6672384 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 6709248 ++read 8192/8192 bytes at offset 6709248 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 6746112 ++read 8192/8192 bytes at offset 6746112 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 6782976 ++read 8192/8192 bytes at offset 6782976 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 6819840 ++read 8192/8192 bytes at offset 6819840 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 6856704 ++read 8192/8192 bytes at offset 6856704 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 6893568 ++read 8192/8192 bytes at offset 6893568 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 6930432 ++read 8192/8192 bytes at offset 6930432 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 6967296 ++read 8192/8192 bytes at offset 6967296 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 7004160 ++read 8192/8192 bytes at offset 7004160 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 7041024 ++read 8192/8192 bytes at offset 7041024 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 7077888 ++read 8192/8192 bytes at offset 7077888 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 7114752 ++read 8192/8192 bytes at offset 7114752 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 7151616 ++read 8192/8192 bytes at offset 7151616 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 7188480 ++read 8192/8192 bytes at offset 7188480 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 7225344 ++read 8192/8192 bytes at offset 7225344 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 7262208 ++read 8192/8192 bytes at offset 7262208 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 7299072 ++read 8192/8192 bytes at offset 7299072 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 7335936 ++read 8192/8192 bytes at offset 7335936 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 7372800 ++read 8192/8192 bytes at offset 7372800 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 7409664 ++read 8192/8192 bytes at offset 7409664 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 7446528 ++read 8192/8192 bytes at offset 7446528 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 7483392 ++read 8192/8192 bytes at offset 7483392 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 7520256 ++read 8192/8192 bytes at offset 7520256 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 7557120 ++read 8192/8192 bytes at offset 7557120 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 7593984 ++read 8192/8192 bytes at offset 7593984 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 7630848 ++read 8192/8192 bytes at offset 7630848 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 7667712 ++read 8192/8192 bytes at offset 7667712 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 7704576 ++read 8192/8192 bytes at offset 7704576 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 7741440 ++read 8192/8192 bytes at offset 7741440 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 7778304 ++read 8192/8192 bytes at offset 7778304 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 7815168 ++read 8192/8192 bytes at offset 7815168 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 7852032 ++read 8192/8192 bytes at offset 7852032 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 7888896 ++read 8192/8192 bytes at offset 7888896 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 7925760 ++read 8192/8192 bytes at offset 7925760 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 7962624 ++read 8192/8192 bytes at offset 7962624 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 7999488 ++read 8192/8192 bytes at offset 7999488 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 8036352 ++read 8192/8192 bytes at offset 8036352 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 8073216 ++read 8192/8192 bytes at offset 8073216 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 8110080 ++read 8192/8192 bytes at offset 8110080 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 8146944 ++read 8192/8192 bytes at offset 8146944 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 8183808 ++read 8192/8192 bytes at offset 8183808 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 8220672 ++read 8192/8192 bytes at offset 8220672 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 8257536 ++read 8192/8192 bytes at offset 8257536 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 8294400 ++read 8192/8192 bytes at offset 8294400 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 8331264 ++read 8192/8192 bytes at offset 8331264 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 8368128 ++read 8192/8192 bytes at offset 8368128 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 8404992 ++read 8192/8192 bytes at offset 8404992 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 8441856 ++read 8192/8192 bytes at offset 8441856 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 8478720 ++read 8192/8192 bytes at offset 8478720 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 8515584 ++read 8192/8192 bytes at offset 8515584 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 8552448 ++read 8192/8192 bytes at offset 8552448 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 8589312 ++read 8192/8192 bytes at offset 8589312 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 8626176 ++read 8192/8192 bytes at offset 8626176 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 8663040 ++read 8192/8192 bytes at offset 8663040 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 8699904 ++read 8192/8192 bytes at offset 8699904 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 8736768 ++read 8192/8192 bytes at offset 8736768 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 8773632 ++read 8192/8192 bytes at offset 8773632 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 8810496 ++read 8192/8192 bytes at offset 8810496 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 8847360 ++read 8192/8192 bytes at offset 8847360 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 8884224 ++read 8192/8192 bytes at offset 8884224 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 8921088 ++read 8192/8192 bytes at offset 8921088 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 8957952 ++read 8192/8192 bytes at offset 8957952 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 8994816 ++read 8192/8192 bytes at offset 8994816 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 9031680 ++read 8192/8192 bytes at offset 9031680 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 9068544 ++read 8192/8192 bytes at offset 9068544 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 9105408 ++read 8192/8192 bytes at offset 9105408 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 9142272 ++read 8192/8192 bytes at offset 9142272 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 9179136 ++read 8192/8192 bytes at offset 9179136 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 9216000 ++read 8192/8192 bytes at offset 9216000 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 9252864 ++read 8192/8192 bytes at offset 9252864 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 9289728 ++read 8192/8192 bytes at offset 9289728 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 9326592 ++read 8192/8192 bytes at offset 9326592 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 9363456 ++read 8192/8192 bytes at offset 9363456 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 9400320 ++read 8192/8192 bytes at offset 9400320 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 165 +-qemu-io> read 12288/12288 bytes at offset 12288 ++=== IO: pattern 165 ++read 12288/12288 bytes at offset 12288 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 49152 ++read 12288/12288 bytes at offset 49152 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 86016 ++read 12288/12288 bytes at offset 86016 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 122880 ++read 12288/12288 bytes at offset 122880 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 159744 ++read 12288/12288 bytes at offset 159744 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 196608 ++read 12288/12288 bytes at offset 196608 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 233472 ++read 12288/12288 bytes at offset 233472 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 270336 ++read 12288/12288 bytes at offset 270336 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 307200 ++read 12288/12288 bytes at offset 307200 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 344064 ++read 12288/12288 bytes at offset 344064 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 380928 ++read 12288/12288 bytes at offset 380928 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 417792 ++read 12288/12288 bytes at offset 417792 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 454656 ++read 12288/12288 bytes at offset 454656 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 491520 ++read 12288/12288 bytes at offset 491520 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 528384 ++read 12288/12288 bytes at offset 528384 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 565248 ++read 12288/12288 bytes at offset 565248 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 602112 ++read 12288/12288 bytes at offset 602112 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 638976 ++read 12288/12288 bytes at offset 638976 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 675840 ++read 12288/12288 bytes at offset 675840 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 712704 ++read 12288/12288 bytes at offset 712704 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 749568 ++read 12288/12288 bytes at offset 749568 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 786432 ++read 12288/12288 bytes at offset 786432 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 823296 ++read 12288/12288 bytes at offset 823296 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 860160 ++read 12288/12288 bytes at offset 860160 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 897024 ++read 12288/12288 bytes at offset 897024 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 933888 ++read 12288/12288 bytes at offset 933888 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 970752 ++read 12288/12288 bytes at offset 970752 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 1007616 ++read 12288/12288 bytes at offset 1007616 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 1044480 ++read 12288/12288 bytes at offset 1044480 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 1081344 ++read 12288/12288 bytes at offset 1081344 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 1118208 ++read 12288/12288 bytes at offset 1118208 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 1155072 ++read 12288/12288 bytes at offset 1155072 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 1191936 ++read 12288/12288 bytes at offset 1191936 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 1228800 ++read 12288/12288 bytes at offset 1228800 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 1265664 ++read 12288/12288 bytes at offset 1265664 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 1302528 ++read 12288/12288 bytes at offset 1302528 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 1339392 ++read 12288/12288 bytes at offset 1339392 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 1376256 ++read 12288/12288 bytes at offset 1376256 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 1413120 ++read 12288/12288 bytes at offset 1413120 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 1449984 ++read 12288/12288 bytes at offset 1449984 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 1486848 ++read 12288/12288 bytes at offset 1486848 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 1523712 ++read 12288/12288 bytes at offset 1523712 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 1560576 ++read 12288/12288 bytes at offset 1560576 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 1597440 ++read 12288/12288 bytes at offset 1597440 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 1634304 ++read 12288/12288 bytes at offset 1634304 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 1671168 ++read 12288/12288 bytes at offset 1671168 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 1708032 ++read 12288/12288 bytes at offset 1708032 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 1744896 ++read 12288/12288 bytes at offset 1744896 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 1781760 ++read 12288/12288 bytes at offset 1781760 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 1818624 ++read 12288/12288 bytes at offset 1818624 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 1855488 ++read 12288/12288 bytes at offset 1855488 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 1892352 ++read 12288/12288 bytes at offset 1892352 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 1929216 ++read 12288/12288 bytes at offset 1929216 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 1966080 ++read 12288/12288 bytes at offset 1966080 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 2002944 ++read 12288/12288 bytes at offset 2002944 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 2039808 ++read 12288/12288 bytes at offset 2039808 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 2076672 ++read 12288/12288 bytes at offset 2076672 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 2113536 ++read 12288/12288 bytes at offset 2113536 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 2150400 ++read 12288/12288 bytes at offset 2150400 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 2187264 ++read 12288/12288 bytes at offset 2187264 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 2224128 ++read 12288/12288 bytes at offset 2224128 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 2260992 ++read 12288/12288 bytes at offset 2260992 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 2297856 ++read 12288/12288 bytes at offset 2297856 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 2334720 ++read 12288/12288 bytes at offset 2334720 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 2371584 ++read 12288/12288 bytes at offset 2371584 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 2408448 ++read 12288/12288 bytes at offset 2408448 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 2445312 ++read 12288/12288 bytes at offset 2445312 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 2482176 ++read 12288/12288 bytes at offset 2482176 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 2519040 ++read 12288/12288 bytes at offset 2519040 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 2555904 ++read 12288/12288 bytes at offset 2555904 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 2592768 ++read 12288/12288 bytes at offset 2592768 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 2629632 ++read 12288/12288 bytes at offset 2629632 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 2666496 ++read 12288/12288 bytes at offset 2666496 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 2703360 ++read 12288/12288 bytes at offset 2703360 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 2740224 ++read 12288/12288 bytes at offset 2740224 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 2777088 ++read 12288/12288 bytes at offset 2777088 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 2813952 ++read 12288/12288 bytes at offset 2813952 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 2850816 ++read 12288/12288 bytes at offset 2850816 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 2887680 ++read 12288/12288 bytes at offset 2887680 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 2924544 ++read 12288/12288 bytes at offset 2924544 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 2961408 ++read 12288/12288 bytes at offset 2961408 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 2998272 ++read 12288/12288 bytes at offset 2998272 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 3035136 ++read 12288/12288 bytes at offset 3035136 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 3072000 ++read 12288/12288 bytes at offset 3072000 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 3108864 ++read 12288/12288 bytes at offset 3108864 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 3145728 ++read 12288/12288 bytes at offset 3145728 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 3182592 ++read 12288/12288 bytes at offset 3182592 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 3219456 ++read 12288/12288 bytes at offset 3219456 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 3256320 ++read 12288/12288 bytes at offset 3256320 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 3293184 ++read 12288/12288 bytes at offset 3293184 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 3330048 ++read 12288/12288 bytes at offset 3330048 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 3366912 ++read 12288/12288 bytes at offset 3366912 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 3403776 ++read 12288/12288 bytes at offset 3403776 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 3440640 ++read 12288/12288 bytes at offset 3440640 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 3477504 ++read 12288/12288 bytes at offset 3477504 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 3514368 ++read 12288/12288 bytes at offset 3514368 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 3551232 ++read 12288/12288 bytes at offset 3551232 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 3588096 ++read 12288/12288 bytes at offset 3588096 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 3624960 ++read 12288/12288 bytes at offset 3624960 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 3661824 ++read 12288/12288 bytes at offset 3661824 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 3698688 ++read 12288/12288 bytes at offset 3698688 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 3735552 ++read 12288/12288 bytes at offset 3735552 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 3772416 ++read 12288/12288 bytes at offset 3772416 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 3809280 ++read 12288/12288 bytes at offset 3809280 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 3846144 ++read 12288/12288 bytes at offset 3846144 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 3883008 ++read 12288/12288 bytes at offset 3883008 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 3919872 ++read 12288/12288 bytes at offset 3919872 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 3956736 ++read 12288/12288 bytes at offset 3956736 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 3993600 ++read 12288/12288 bytes at offset 3993600 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4030464 ++read 12288/12288 bytes at offset 4030464 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4067328 ++read 12288/12288 bytes at offset 4067328 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4104192 ++read 12288/12288 bytes at offset 4104192 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4141056 ++read 12288/12288 bytes at offset 4141056 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4177920 ++read 12288/12288 bytes at offset 4177920 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4214784 ++read 12288/12288 bytes at offset 4214784 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4251648 ++read 12288/12288 bytes at offset 4251648 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4288512 ++read 12288/12288 bytes at offset 4288512 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4325376 ++read 12288/12288 bytes at offset 4325376 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4362240 ++read 12288/12288 bytes at offset 4362240 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4399104 ++read 12288/12288 bytes at offset 4399104 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4435968 ++read 12288/12288 bytes at offset 4435968 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4472832 ++read 12288/12288 bytes at offset 4472832 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4509696 ++read 12288/12288 bytes at offset 4509696 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4546560 ++read 12288/12288 bytes at offset 4546560 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4583424 ++read 12288/12288 bytes at offset 4583424 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4620288 ++read 12288/12288 bytes at offset 4620288 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4657152 ++read 12288/12288 bytes at offset 4657152 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4694016 ++read 12288/12288 bytes at offset 4694016 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4730880 ++read 12288/12288 bytes at offset 4730880 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4767744 ++read 12288/12288 bytes at offset 4767744 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4804608 ++read 12288/12288 bytes at offset 4804608 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4841472 ++read 12288/12288 bytes at offset 4841472 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4878336 ++read 12288/12288 bytes at offset 4878336 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4915200 ++read 12288/12288 bytes at offset 4915200 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4952064 ++read 12288/12288 bytes at offset 4952064 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4988928 ++read 12288/12288 bytes at offset 4988928 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 5025792 ++read 12288/12288 bytes at offset 5025792 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 5062656 ++read 12288/12288 bytes at offset 5062656 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 5099520 ++read 12288/12288 bytes at offset 5099520 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 5136384 ++read 12288/12288 bytes at offset 5136384 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 5173248 ++read 12288/12288 bytes at offset 5173248 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 5210112 ++read 12288/12288 bytes at offset 5210112 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 5246976 ++read 12288/12288 bytes at offset 5246976 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 5283840 ++read 12288/12288 bytes at offset 5283840 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 5320704 ++read 12288/12288 bytes at offset 5320704 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 5357568 ++read 12288/12288 bytes at offset 5357568 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 5394432 ++read 12288/12288 bytes at offset 5394432 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 5431296 ++read 12288/12288 bytes at offset 5431296 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 5468160 ++read 12288/12288 bytes at offset 5468160 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 5505024 ++read 12288/12288 bytes at offset 5505024 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 5541888 ++read 12288/12288 bytes at offset 5541888 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 5578752 ++read 12288/12288 bytes at offset 5578752 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 5615616 ++read 12288/12288 bytes at offset 5615616 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 5652480 ++read 12288/12288 bytes at offset 5652480 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 5689344 ++read 12288/12288 bytes at offset 5689344 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 5726208 ++read 12288/12288 bytes at offset 5726208 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 5763072 ++read 12288/12288 bytes at offset 5763072 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 5799936 ++read 12288/12288 bytes at offset 5799936 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 5836800 ++read 12288/12288 bytes at offset 5836800 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 5873664 ++read 12288/12288 bytes at offset 5873664 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 5910528 ++read 12288/12288 bytes at offset 5910528 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 5947392 ++read 12288/12288 bytes at offset 5947392 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 5984256 ++read 12288/12288 bytes at offset 5984256 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 6021120 ++read 12288/12288 bytes at offset 6021120 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 6057984 ++read 12288/12288 bytes at offset 6057984 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 6094848 ++read 12288/12288 bytes at offset 6094848 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 6131712 ++read 12288/12288 bytes at offset 6131712 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 6168576 ++read 12288/12288 bytes at offset 6168576 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 6205440 ++read 12288/12288 bytes at offset 6205440 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 6242304 ++read 12288/12288 bytes at offset 6242304 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 6279168 ++read 12288/12288 bytes at offset 6279168 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 6316032 ++read 12288/12288 bytes at offset 6316032 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 6352896 ++read 12288/12288 bytes at offset 6352896 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 6389760 ++read 12288/12288 bytes at offset 6389760 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 6426624 ++read 12288/12288 bytes at offset 6426624 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 6463488 ++read 12288/12288 bytes at offset 6463488 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 6500352 ++read 12288/12288 bytes at offset 6500352 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 6537216 ++read 12288/12288 bytes at offset 6537216 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 6574080 ++read 12288/12288 bytes at offset 6574080 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 6610944 ++read 12288/12288 bytes at offset 6610944 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 6647808 ++read 12288/12288 bytes at offset 6647808 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 6684672 ++read 12288/12288 bytes at offset 6684672 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 6721536 ++read 12288/12288 bytes at offset 6721536 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 6758400 ++read 12288/12288 bytes at offset 6758400 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 6795264 ++read 12288/12288 bytes at offset 6795264 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 6832128 ++read 12288/12288 bytes at offset 6832128 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 6868992 ++read 12288/12288 bytes at offset 6868992 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 6905856 ++read 12288/12288 bytes at offset 6905856 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 6942720 ++read 12288/12288 bytes at offset 6942720 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 6979584 ++read 12288/12288 bytes at offset 6979584 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 7016448 ++read 12288/12288 bytes at offset 7016448 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 7053312 ++read 12288/12288 bytes at offset 7053312 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 7090176 ++read 12288/12288 bytes at offset 7090176 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 7127040 ++read 12288/12288 bytes at offset 7127040 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 7163904 ++read 12288/12288 bytes at offset 7163904 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 7200768 ++read 12288/12288 bytes at offset 7200768 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 7237632 ++read 12288/12288 bytes at offset 7237632 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 7274496 ++read 12288/12288 bytes at offset 7274496 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 7311360 ++read 12288/12288 bytes at offset 7311360 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 7348224 ++read 12288/12288 bytes at offset 7348224 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 7385088 ++read 12288/12288 bytes at offset 7385088 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 7421952 ++read 12288/12288 bytes at offset 7421952 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 7458816 ++read 12288/12288 bytes at offset 7458816 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 7495680 ++read 12288/12288 bytes at offset 7495680 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 7532544 ++read 12288/12288 bytes at offset 7532544 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 7569408 ++read 12288/12288 bytes at offset 7569408 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 7606272 ++read 12288/12288 bytes at offset 7606272 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 7643136 ++read 12288/12288 bytes at offset 7643136 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 7680000 ++read 12288/12288 bytes at offset 7680000 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 7716864 ++read 12288/12288 bytes at offset 7716864 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 7753728 ++read 12288/12288 bytes at offset 7753728 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 7790592 ++read 12288/12288 bytes at offset 7790592 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 7827456 ++read 12288/12288 bytes at offset 7827456 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 7864320 ++read 12288/12288 bytes at offset 7864320 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 7901184 ++read 12288/12288 bytes at offset 7901184 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 7938048 ++read 12288/12288 bytes at offset 7938048 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 7974912 ++read 12288/12288 bytes at offset 7974912 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 8011776 ++read 12288/12288 bytes at offset 8011776 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 8048640 ++read 12288/12288 bytes at offset 8048640 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 8085504 ++read 12288/12288 bytes at offset 8085504 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 8122368 ++read 12288/12288 bytes at offset 8122368 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 8159232 ++read 12288/12288 bytes at offset 8159232 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 8196096 ++read 12288/12288 bytes at offset 8196096 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 8232960 ++read 12288/12288 bytes at offset 8232960 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 8269824 ++read 12288/12288 bytes at offset 8269824 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 8306688 ++read 12288/12288 bytes at offset 8306688 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 8343552 ++read 12288/12288 bytes at offset 8343552 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 8380416 ++read 12288/12288 bytes at offset 8380416 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 8417280 ++read 12288/12288 bytes at offset 8417280 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 8454144 ++read 12288/12288 bytes at offset 8454144 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 8491008 ++read 12288/12288 bytes at offset 8491008 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 8527872 ++read 12288/12288 bytes at offset 8527872 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 8564736 ++read 12288/12288 bytes at offset 8564736 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 8601600 ++read 12288/12288 bytes at offset 8601600 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 8638464 ++read 12288/12288 bytes at offset 8638464 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 8675328 ++read 12288/12288 bytes at offset 8675328 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 8712192 ++read 12288/12288 bytes at offset 8712192 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 8749056 ++read 12288/12288 bytes at offset 8749056 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 8785920 ++read 12288/12288 bytes at offset 8785920 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 8822784 ++read 12288/12288 bytes at offset 8822784 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 8859648 ++read 12288/12288 bytes at offset 8859648 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 8896512 ++read 12288/12288 bytes at offset 8896512 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 8933376 ++read 12288/12288 bytes at offset 8933376 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 8970240 ++read 12288/12288 bytes at offset 8970240 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 9007104 ++read 12288/12288 bytes at offset 9007104 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 9043968 ++read 12288/12288 bytes at offset 9043968 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 9080832 ++read 12288/12288 bytes at offset 9080832 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 9117696 ++read 12288/12288 bytes at offset 9117696 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 9154560 ++read 12288/12288 bytes at offset 9154560 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 9191424 ++read 12288/12288 bytes at offset 9191424 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 9228288 ++read 12288/12288 bytes at offset 9228288 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 9265152 ++read 12288/12288 bytes at offset 9265152 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 9302016 ++read 12288/12288 bytes at offset 9302016 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 9338880 ++read 12288/12288 bytes at offset 9338880 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 9375744 ++read 12288/12288 bytes at offset 9375744 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 9412608 ++read 12288/12288 bytes at offset 9412608 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 165 +-qemu-io> read 4096/4096 bytes at offset 32768 ++=== IO: pattern 165 ++read 4096/4096 bytes at offset 32768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 69632 ++read 4096/4096 bytes at offset 69632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 106496 ++read 4096/4096 bytes at offset 106496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 143360 ++read 4096/4096 bytes at offset 143360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 180224 ++read 4096/4096 bytes at offset 180224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 217088 ++read 4096/4096 bytes at offset 217088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 253952 ++read 4096/4096 bytes at offset 253952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 290816 ++read 4096/4096 bytes at offset 290816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 327680 ++read 4096/4096 bytes at offset 327680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 364544 ++read 4096/4096 bytes at offset 364544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 401408 ++read 4096/4096 bytes at offset 401408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 438272 ++read 4096/4096 bytes at offset 438272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 475136 ++read 4096/4096 bytes at offset 475136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 512000 ++read 4096/4096 bytes at offset 512000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 548864 ++read 4096/4096 bytes at offset 548864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 585728 ++read 4096/4096 bytes at offset 585728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 622592 ++read 4096/4096 bytes at offset 622592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 659456 ++read 4096/4096 bytes at offset 659456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 696320 ++read 4096/4096 bytes at offset 696320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 733184 ++read 4096/4096 bytes at offset 733184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 770048 ++read 4096/4096 bytes at offset 770048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 806912 ++read 4096/4096 bytes at offset 806912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 843776 ++read 4096/4096 bytes at offset 843776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 880640 ++read 4096/4096 bytes at offset 880640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 917504 ++read 4096/4096 bytes at offset 917504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 954368 ++read 4096/4096 bytes at offset 954368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 991232 ++read 4096/4096 bytes at offset 991232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1028096 ++read 4096/4096 bytes at offset 1028096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1064960 ++read 4096/4096 bytes at offset 1064960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1101824 ++read 4096/4096 bytes at offset 1101824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1138688 ++read 4096/4096 bytes at offset 1138688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1175552 ++read 4096/4096 bytes at offset 1175552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1212416 ++read 4096/4096 bytes at offset 1212416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1249280 ++read 4096/4096 bytes at offset 1249280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1286144 ++read 4096/4096 bytes at offset 1286144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1323008 ++read 4096/4096 bytes at offset 1323008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1359872 ++read 4096/4096 bytes at offset 1359872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1396736 ++read 4096/4096 bytes at offset 1396736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1433600 ++read 4096/4096 bytes at offset 1433600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1470464 ++read 4096/4096 bytes at offset 1470464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1507328 ++read 4096/4096 bytes at offset 1507328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1544192 ++read 4096/4096 bytes at offset 1544192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1581056 ++read 4096/4096 bytes at offset 1581056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1617920 ++read 4096/4096 bytes at offset 1617920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1654784 ++read 4096/4096 bytes at offset 1654784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1691648 ++read 4096/4096 bytes at offset 1691648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1728512 ++read 4096/4096 bytes at offset 1728512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1765376 ++read 4096/4096 bytes at offset 1765376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1802240 ++read 4096/4096 bytes at offset 1802240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1839104 ++read 4096/4096 bytes at offset 1839104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1875968 ++read 4096/4096 bytes at offset 1875968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1912832 ++read 4096/4096 bytes at offset 1912832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1949696 ++read 4096/4096 bytes at offset 1949696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1986560 ++read 4096/4096 bytes at offset 1986560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 2023424 ++read 4096/4096 bytes at offset 2023424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 2060288 ++read 4096/4096 bytes at offset 2060288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 2097152 ++read 4096/4096 bytes at offset 2097152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 2134016 ++read 4096/4096 bytes at offset 2134016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 2170880 ++read 4096/4096 bytes at offset 2170880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 2207744 ++read 4096/4096 bytes at offset 2207744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 2244608 ++read 4096/4096 bytes at offset 2244608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 2281472 ++read 4096/4096 bytes at offset 2281472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 2318336 ++read 4096/4096 bytes at offset 2318336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 2355200 ++read 4096/4096 bytes at offset 2355200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 2392064 ++read 4096/4096 bytes at offset 2392064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 2428928 ++read 4096/4096 bytes at offset 2428928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 2465792 ++read 4096/4096 bytes at offset 2465792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 2502656 ++read 4096/4096 bytes at offset 2502656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 2539520 ++read 4096/4096 bytes at offset 2539520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 2576384 ++read 4096/4096 bytes at offset 2576384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 2613248 ++read 4096/4096 bytes at offset 2613248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 2650112 ++read 4096/4096 bytes at offset 2650112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 2686976 ++read 4096/4096 bytes at offset 2686976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 2723840 ++read 4096/4096 bytes at offset 2723840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 2760704 ++read 4096/4096 bytes at offset 2760704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 2797568 ++read 4096/4096 bytes at offset 2797568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 2834432 ++read 4096/4096 bytes at offset 2834432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 2871296 ++read 4096/4096 bytes at offset 2871296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 2908160 ++read 4096/4096 bytes at offset 2908160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 2945024 ++read 4096/4096 bytes at offset 2945024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 2981888 ++read 4096/4096 bytes at offset 2981888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 3018752 ++read 4096/4096 bytes at offset 3018752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 3055616 ++read 4096/4096 bytes at offset 3055616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 3092480 ++read 4096/4096 bytes at offset 3092480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 3129344 ++read 4096/4096 bytes at offset 3129344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 3166208 ++read 4096/4096 bytes at offset 3166208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 3203072 ++read 4096/4096 bytes at offset 3203072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 3239936 ++read 4096/4096 bytes at offset 3239936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 3276800 ++read 4096/4096 bytes at offset 3276800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 3313664 ++read 4096/4096 bytes at offset 3313664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 3350528 ++read 4096/4096 bytes at offset 3350528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 3387392 ++read 4096/4096 bytes at offset 3387392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 3424256 ++read 4096/4096 bytes at offset 3424256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 3461120 ++read 4096/4096 bytes at offset 3461120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 3497984 ++read 4096/4096 bytes at offset 3497984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 3534848 ++read 4096/4096 bytes at offset 3534848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 3571712 ++read 4096/4096 bytes at offset 3571712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 3608576 ++read 4096/4096 bytes at offset 3608576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 3645440 ++read 4096/4096 bytes at offset 3645440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 3682304 ++read 4096/4096 bytes at offset 3682304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 3719168 ++read 4096/4096 bytes at offset 3719168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 3756032 ++read 4096/4096 bytes at offset 3756032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 3792896 ++read 4096/4096 bytes at offset 3792896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 3829760 ++read 4096/4096 bytes at offset 3829760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 3866624 ++read 4096/4096 bytes at offset 3866624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 3903488 ++read 4096/4096 bytes at offset 3903488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 3940352 ++read 4096/4096 bytes at offset 3940352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 3977216 ++read 4096/4096 bytes at offset 3977216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4014080 ++read 4096/4096 bytes at offset 4014080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4050944 ++read 4096/4096 bytes at offset 4050944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4087808 ++read 4096/4096 bytes at offset 4087808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4124672 ++read 4096/4096 bytes at offset 4124672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4161536 ++read 4096/4096 bytes at offset 4161536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4198400 ++read 4096/4096 bytes at offset 4198400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4235264 ++read 4096/4096 bytes at offset 4235264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4272128 ++read 4096/4096 bytes at offset 4272128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4308992 ++read 4096/4096 bytes at offset 4308992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4345856 ++read 4096/4096 bytes at offset 4345856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4382720 ++read 4096/4096 bytes at offset 4382720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4419584 ++read 4096/4096 bytes at offset 4419584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4456448 ++read 4096/4096 bytes at offset 4456448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4493312 ++read 4096/4096 bytes at offset 4493312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4530176 ++read 4096/4096 bytes at offset 4530176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4567040 ++read 4096/4096 bytes at offset 4567040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4603904 ++read 4096/4096 bytes at offset 4603904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4640768 ++read 4096/4096 bytes at offset 4640768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4677632 ++read 4096/4096 bytes at offset 4677632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4714496 ++read 4096/4096 bytes at offset 4714496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4751360 ++read 4096/4096 bytes at offset 4751360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4788224 ++read 4096/4096 bytes at offset 4788224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4825088 ++read 4096/4096 bytes at offset 4825088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4861952 ++read 4096/4096 bytes at offset 4861952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4898816 ++read 4096/4096 bytes at offset 4898816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4935680 ++read 4096/4096 bytes at offset 4935680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4972544 ++read 4096/4096 bytes at offset 4972544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 5009408 ++read 4096/4096 bytes at offset 5009408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 5046272 ++read 4096/4096 bytes at offset 5046272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 5083136 ++read 4096/4096 bytes at offset 5083136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 5120000 ++read 4096/4096 bytes at offset 5120000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 5156864 ++read 4096/4096 bytes at offset 5156864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 5193728 ++read 4096/4096 bytes at offset 5193728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 5230592 ++read 4096/4096 bytes at offset 5230592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 5267456 ++read 4096/4096 bytes at offset 5267456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 5304320 ++read 4096/4096 bytes at offset 5304320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 5341184 ++read 4096/4096 bytes at offset 5341184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 5378048 ++read 4096/4096 bytes at offset 5378048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 5414912 ++read 4096/4096 bytes at offset 5414912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 5451776 ++read 4096/4096 bytes at offset 5451776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 5488640 ++read 4096/4096 bytes at offset 5488640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 5525504 ++read 4096/4096 bytes at offset 5525504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 5562368 ++read 4096/4096 bytes at offset 5562368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 5599232 ++read 4096/4096 bytes at offset 5599232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 5636096 ++read 4096/4096 bytes at offset 5636096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 5672960 ++read 4096/4096 bytes at offset 5672960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 5709824 ++read 4096/4096 bytes at offset 5709824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 5746688 ++read 4096/4096 bytes at offset 5746688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 5783552 ++read 4096/4096 bytes at offset 5783552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 5820416 ++read 4096/4096 bytes at offset 5820416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 5857280 ++read 4096/4096 bytes at offset 5857280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 5894144 ++read 4096/4096 bytes at offset 5894144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 5931008 ++read 4096/4096 bytes at offset 5931008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 5967872 ++read 4096/4096 bytes at offset 5967872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 6004736 ++read 4096/4096 bytes at offset 6004736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 6041600 ++read 4096/4096 bytes at offset 6041600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 6078464 ++read 4096/4096 bytes at offset 6078464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 6115328 ++read 4096/4096 bytes at offset 6115328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 6152192 ++read 4096/4096 bytes at offset 6152192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 6189056 ++read 4096/4096 bytes at offset 6189056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 6225920 ++read 4096/4096 bytes at offset 6225920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 6262784 ++read 4096/4096 bytes at offset 6262784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 6299648 ++read 4096/4096 bytes at offset 6299648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 6336512 ++read 4096/4096 bytes at offset 6336512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 6373376 ++read 4096/4096 bytes at offset 6373376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 6410240 ++read 4096/4096 bytes at offset 6410240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 6447104 ++read 4096/4096 bytes at offset 6447104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 6483968 ++read 4096/4096 bytes at offset 6483968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 6520832 ++read 4096/4096 bytes at offset 6520832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 6557696 ++read 4096/4096 bytes at offset 6557696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 6594560 ++read 4096/4096 bytes at offset 6594560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 6631424 ++read 4096/4096 bytes at offset 6631424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 6668288 ++read 4096/4096 bytes at offset 6668288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 6705152 ++read 4096/4096 bytes at offset 6705152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 6742016 ++read 4096/4096 bytes at offset 6742016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 6778880 ++read 4096/4096 bytes at offset 6778880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 6815744 ++read 4096/4096 bytes at offset 6815744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 6852608 ++read 4096/4096 bytes at offset 6852608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 6889472 ++read 4096/4096 bytes at offset 6889472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 6926336 ++read 4096/4096 bytes at offset 6926336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 6963200 ++read 4096/4096 bytes at offset 6963200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 7000064 ++read 4096/4096 bytes at offset 7000064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 7036928 ++read 4096/4096 bytes at offset 7036928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 7073792 ++read 4096/4096 bytes at offset 7073792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 7110656 ++read 4096/4096 bytes at offset 7110656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 7147520 ++read 4096/4096 bytes at offset 7147520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 7184384 ++read 4096/4096 bytes at offset 7184384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 7221248 ++read 4096/4096 bytes at offset 7221248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 7258112 ++read 4096/4096 bytes at offset 7258112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 7294976 ++read 4096/4096 bytes at offset 7294976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 7331840 ++read 4096/4096 bytes at offset 7331840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 7368704 ++read 4096/4096 bytes at offset 7368704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 7405568 ++read 4096/4096 bytes at offset 7405568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 7442432 ++read 4096/4096 bytes at offset 7442432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 7479296 ++read 4096/4096 bytes at offset 7479296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 7516160 ++read 4096/4096 bytes at offset 7516160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 7553024 ++read 4096/4096 bytes at offset 7553024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 7589888 ++read 4096/4096 bytes at offset 7589888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 7626752 ++read 4096/4096 bytes at offset 7626752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 7663616 ++read 4096/4096 bytes at offset 7663616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 7700480 ++read 4096/4096 bytes at offset 7700480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 7737344 ++read 4096/4096 bytes at offset 7737344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 7774208 ++read 4096/4096 bytes at offset 7774208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 7811072 ++read 4096/4096 bytes at offset 7811072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 7847936 ++read 4096/4096 bytes at offset 7847936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 7884800 ++read 4096/4096 bytes at offset 7884800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 7921664 ++read 4096/4096 bytes at offset 7921664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 7958528 ++read 4096/4096 bytes at offset 7958528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 7995392 ++read 4096/4096 bytes at offset 7995392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 8032256 ++read 4096/4096 bytes at offset 8032256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 8069120 ++read 4096/4096 bytes at offset 8069120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 8105984 ++read 4096/4096 bytes at offset 8105984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 8142848 ++read 4096/4096 bytes at offset 8142848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 8179712 ++read 4096/4096 bytes at offset 8179712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 8216576 ++read 4096/4096 bytes at offset 8216576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 8253440 ++read 4096/4096 bytes at offset 8253440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 8290304 ++read 4096/4096 bytes at offset 8290304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 8327168 ++read 4096/4096 bytes at offset 8327168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 8364032 ++read 4096/4096 bytes at offset 8364032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 8400896 ++read 4096/4096 bytes at offset 8400896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 8437760 ++read 4096/4096 bytes at offset 8437760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 8474624 ++read 4096/4096 bytes at offset 8474624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 8511488 ++read 4096/4096 bytes at offset 8511488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 8548352 ++read 4096/4096 bytes at offset 8548352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 8585216 ++read 4096/4096 bytes at offset 8585216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 8622080 ++read 4096/4096 bytes at offset 8622080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 8658944 ++read 4096/4096 bytes at offset 8658944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 8695808 ++read 4096/4096 bytes at offset 8695808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 8732672 ++read 4096/4096 bytes at offset 8732672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 8769536 ++read 4096/4096 bytes at offset 8769536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 8806400 ++read 4096/4096 bytes at offset 8806400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 8843264 ++read 4096/4096 bytes at offset 8843264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 8880128 ++read 4096/4096 bytes at offset 8880128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 8916992 ++read 4096/4096 bytes at offset 8916992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 8953856 ++read 4096/4096 bytes at offset 8953856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 8990720 ++read 4096/4096 bytes at offset 8990720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 9027584 ++read 4096/4096 bytes at offset 9027584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 9064448 ++read 4096/4096 bytes at offset 9064448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 9101312 ++read 4096/4096 bytes at offset 9101312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 9138176 ++read 4096/4096 bytes at offset 9138176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 9175040 ++read 4096/4096 bytes at offset 9175040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 9211904 ++read 4096/4096 bytes at offset 9211904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 9248768 ++read 4096/4096 bytes at offset 9248768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 9285632 ++read 4096/4096 bytes at offset 9285632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 9322496 ++read 4096/4096 bytes at offset 9322496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 9359360 ++read 4096/4096 bytes at offset 9359360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 9396224 ++read 4096/4096 bytes at offset 9396224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 9433088 ++read 4096/4096 bytes at offset 9433088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === Read zeros ++=== Read zeros + === IO: pattern 0 +-qemu-io> read 4096/4096 bytes at offset 8192 ++read 4096/4096 bytes at offset 8192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 45056 ++read 4096/4096 bytes at offset 45056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 81920 ++read 4096/4096 bytes at offset 81920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 118784 ++read 4096/4096 bytes at offset 118784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 155648 ++read 4096/4096 bytes at offset 155648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 192512 ++read 4096/4096 bytes at offset 192512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 229376 ++read 4096/4096 bytes at offset 229376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 266240 ++read 4096/4096 bytes at offset 266240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 303104 ++read 4096/4096 bytes at offset 303104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 339968 ++read 4096/4096 bytes at offset 339968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 376832 ++read 4096/4096 bytes at offset 376832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 413696 ++read 4096/4096 bytes at offset 413696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 450560 ++read 4096/4096 bytes at offset 450560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 487424 ++read 4096/4096 bytes at offset 487424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 524288 ++read 4096/4096 bytes at offset 524288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 561152 ++read 4096/4096 bytes at offset 561152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 598016 ++read 4096/4096 bytes at offset 598016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 634880 ++read 4096/4096 bytes at offset 634880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 671744 ++read 4096/4096 bytes at offset 671744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 708608 ++read 4096/4096 bytes at offset 708608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 745472 ++read 4096/4096 bytes at offset 745472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 782336 ++read 4096/4096 bytes at offset 782336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 819200 ++read 4096/4096 bytes at offset 819200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 856064 ++read 4096/4096 bytes at offset 856064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 892928 ++read 4096/4096 bytes at offset 892928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 929792 ++read 4096/4096 bytes at offset 929792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 966656 ++read 4096/4096 bytes at offset 966656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1003520 ++read 4096/4096 bytes at offset 1003520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1040384 ++read 4096/4096 bytes at offset 1040384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1077248 ++read 4096/4096 bytes at offset 1077248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1114112 ++read 4096/4096 bytes at offset 1114112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1150976 ++read 4096/4096 bytes at offset 1150976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1187840 ++read 4096/4096 bytes at offset 1187840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1224704 ++read 4096/4096 bytes at offset 1224704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1261568 ++read 4096/4096 bytes at offset 1261568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1298432 ++read 4096/4096 bytes at offset 1298432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1335296 ++read 4096/4096 bytes at offset 1335296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1372160 ++read 4096/4096 bytes at offset 1372160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1409024 ++read 4096/4096 bytes at offset 1409024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1445888 ++read 4096/4096 bytes at offset 1445888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1482752 ++read 4096/4096 bytes at offset 1482752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1519616 ++read 4096/4096 bytes at offset 1519616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1556480 ++read 4096/4096 bytes at offset 1556480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1593344 ++read 4096/4096 bytes at offset 1593344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1630208 ++read 4096/4096 bytes at offset 1630208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1667072 ++read 4096/4096 bytes at offset 1667072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1703936 ++read 4096/4096 bytes at offset 1703936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1740800 ++read 4096/4096 bytes at offset 1740800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1777664 ++read 4096/4096 bytes at offset 1777664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1814528 ++read 4096/4096 bytes at offset 1814528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1851392 ++read 4096/4096 bytes at offset 1851392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1888256 ++read 4096/4096 bytes at offset 1888256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1925120 ++read 4096/4096 bytes at offset 1925120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1961984 ++read 4096/4096 bytes at offset 1961984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1998848 ++read 4096/4096 bytes at offset 1998848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 2035712 ++read 4096/4096 bytes at offset 2035712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 2072576 ++read 4096/4096 bytes at offset 2072576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 2109440 ++read 4096/4096 bytes at offset 2109440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 2146304 ++read 4096/4096 bytes at offset 2146304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 2183168 ++read 4096/4096 bytes at offset 2183168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 2220032 ++read 4096/4096 bytes at offset 2220032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 2256896 ++read 4096/4096 bytes at offset 2256896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 2293760 ++read 4096/4096 bytes at offset 2293760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 2330624 ++read 4096/4096 bytes at offset 2330624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 2367488 ++read 4096/4096 bytes at offset 2367488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 2404352 ++read 4096/4096 bytes at offset 2404352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 2441216 ++read 4096/4096 bytes at offset 2441216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 2478080 ++read 4096/4096 bytes at offset 2478080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 2514944 ++read 4096/4096 bytes at offset 2514944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 2551808 ++read 4096/4096 bytes at offset 2551808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 2588672 ++read 4096/4096 bytes at offset 2588672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 2625536 ++read 4096/4096 bytes at offset 2625536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 2662400 ++read 4096/4096 bytes at offset 2662400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 2699264 ++read 4096/4096 bytes at offset 2699264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 2736128 ++read 4096/4096 bytes at offset 2736128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 2772992 ++read 4096/4096 bytes at offset 2772992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 2809856 ++read 4096/4096 bytes at offset 2809856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 2846720 ++read 4096/4096 bytes at offset 2846720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 2883584 ++read 4096/4096 bytes at offset 2883584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 2920448 ++read 4096/4096 bytes at offset 2920448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 2957312 ++read 4096/4096 bytes at offset 2957312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 2994176 ++read 4096/4096 bytes at offset 2994176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 3031040 ++read 4096/4096 bytes at offset 3031040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 3067904 ++read 4096/4096 bytes at offset 3067904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 3104768 ++read 4096/4096 bytes at offset 3104768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 3141632 ++read 4096/4096 bytes at offset 3141632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 3178496 ++read 4096/4096 bytes at offset 3178496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 3215360 ++read 4096/4096 bytes at offset 3215360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 3252224 ++read 4096/4096 bytes at offset 3252224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 3289088 ++read 4096/4096 bytes at offset 3289088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 3325952 ++read 4096/4096 bytes at offset 3325952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 3362816 ++read 4096/4096 bytes at offset 3362816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 3399680 ++read 4096/4096 bytes at offset 3399680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 3436544 ++read 4096/4096 bytes at offset 3436544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 3473408 ++read 4096/4096 bytes at offset 3473408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 3510272 ++read 4096/4096 bytes at offset 3510272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 3547136 ++read 4096/4096 bytes at offset 3547136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 3584000 ++read 4096/4096 bytes at offset 3584000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 3620864 ++read 4096/4096 bytes at offset 3620864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 3657728 ++read 4096/4096 bytes at offset 3657728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 3694592 ++read 4096/4096 bytes at offset 3694592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 3731456 ++read 4096/4096 bytes at offset 3731456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 3768320 ++read 4096/4096 bytes at offset 3768320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 3805184 ++read 4096/4096 bytes at offset 3805184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 3842048 ++read 4096/4096 bytes at offset 3842048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 3878912 ++read 4096/4096 bytes at offset 3878912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 3915776 ++read 4096/4096 bytes at offset 3915776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 3952640 ++read 4096/4096 bytes at offset 3952640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 3989504 ++read 4096/4096 bytes at offset 3989504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4026368 ++read 4096/4096 bytes at offset 4026368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4063232 ++read 4096/4096 bytes at offset 4063232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4100096 ++read 4096/4096 bytes at offset 4100096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4136960 ++read 4096/4096 bytes at offset 4136960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4173824 ++read 4096/4096 bytes at offset 4173824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4210688 ++read 4096/4096 bytes at offset 4210688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4247552 ++read 4096/4096 bytes at offset 4247552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4284416 ++read 4096/4096 bytes at offset 4284416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4321280 ++read 4096/4096 bytes at offset 4321280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4358144 ++read 4096/4096 bytes at offset 4358144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4395008 ++read 4096/4096 bytes at offset 4395008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4431872 ++read 4096/4096 bytes at offset 4431872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4468736 ++read 4096/4096 bytes at offset 4468736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4505600 ++read 4096/4096 bytes at offset 4505600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4542464 ++read 4096/4096 bytes at offset 4542464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4579328 ++read 4096/4096 bytes at offset 4579328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4616192 ++read 4096/4096 bytes at offset 4616192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4653056 ++read 4096/4096 bytes at offset 4653056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4689920 ++read 4096/4096 bytes at offset 4689920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4726784 ++read 4096/4096 bytes at offset 4726784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4763648 ++read 4096/4096 bytes at offset 4763648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4800512 ++read 4096/4096 bytes at offset 4800512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4837376 ++read 4096/4096 bytes at offset 4837376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4874240 ++read 4096/4096 bytes at offset 4874240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4911104 ++read 4096/4096 bytes at offset 4911104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4947968 ++read 4096/4096 bytes at offset 4947968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4984832 ++read 4096/4096 bytes at offset 4984832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 5021696 ++read 4096/4096 bytes at offset 5021696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 5058560 ++read 4096/4096 bytes at offset 5058560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 5095424 ++read 4096/4096 bytes at offset 5095424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 5132288 ++read 4096/4096 bytes at offset 5132288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 5169152 ++read 4096/4096 bytes at offset 5169152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 5206016 ++read 4096/4096 bytes at offset 5206016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 5242880 ++read 4096/4096 bytes at offset 5242880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 5279744 ++read 4096/4096 bytes at offset 5279744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 5316608 ++read 4096/4096 bytes at offset 5316608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 5353472 ++read 4096/4096 bytes at offset 5353472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 5390336 ++read 4096/4096 bytes at offset 5390336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 5427200 ++read 4096/4096 bytes at offset 5427200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 5464064 ++read 4096/4096 bytes at offset 5464064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 5500928 ++read 4096/4096 bytes at offset 5500928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 5537792 ++read 4096/4096 bytes at offset 5537792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 5574656 ++read 4096/4096 bytes at offset 5574656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 5611520 ++read 4096/4096 bytes at offset 5611520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 5648384 ++read 4096/4096 bytes at offset 5648384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 5685248 ++read 4096/4096 bytes at offset 5685248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 5722112 ++read 4096/4096 bytes at offset 5722112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 5758976 ++read 4096/4096 bytes at offset 5758976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 5795840 ++read 4096/4096 bytes at offset 5795840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 5832704 ++read 4096/4096 bytes at offset 5832704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 5869568 ++read 4096/4096 bytes at offset 5869568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 5906432 ++read 4096/4096 bytes at offset 5906432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 5943296 ++read 4096/4096 bytes at offset 5943296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 5980160 ++read 4096/4096 bytes at offset 5980160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 6017024 ++read 4096/4096 bytes at offset 6017024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 6053888 ++read 4096/4096 bytes at offset 6053888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 6090752 ++read 4096/4096 bytes at offset 6090752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 6127616 ++read 4096/4096 bytes at offset 6127616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 6164480 ++read 4096/4096 bytes at offset 6164480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 6201344 ++read 4096/4096 bytes at offset 6201344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 6238208 ++read 4096/4096 bytes at offset 6238208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 6275072 ++read 4096/4096 bytes at offset 6275072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 6311936 ++read 4096/4096 bytes at offset 6311936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 6348800 ++read 4096/4096 bytes at offset 6348800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 6385664 ++read 4096/4096 bytes at offset 6385664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 6422528 ++read 4096/4096 bytes at offset 6422528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 6459392 ++read 4096/4096 bytes at offset 6459392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 6496256 ++read 4096/4096 bytes at offset 6496256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 6533120 ++read 4096/4096 bytes at offset 6533120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 6569984 ++read 4096/4096 bytes at offset 6569984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 6606848 ++read 4096/4096 bytes at offset 6606848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 6643712 ++read 4096/4096 bytes at offset 6643712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 6680576 ++read 4096/4096 bytes at offset 6680576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 6717440 ++read 4096/4096 bytes at offset 6717440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 6754304 ++read 4096/4096 bytes at offset 6754304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 6791168 ++read 4096/4096 bytes at offset 6791168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 6828032 ++read 4096/4096 bytes at offset 6828032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 6864896 ++read 4096/4096 bytes at offset 6864896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 6901760 ++read 4096/4096 bytes at offset 6901760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 6938624 ++read 4096/4096 bytes at offset 6938624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 6975488 ++read 4096/4096 bytes at offset 6975488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 7012352 ++read 4096/4096 bytes at offset 7012352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 7049216 ++read 4096/4096 bytes at offset 7049216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 7086080 ++read 4096/4096 bytes at offset 7086080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 7122944 ++read 4096/4096 bytes at offset 7122944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 7159808 ++read 4096/4096 bytes at offset 7159808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 7196672 ++read 4096/4096 bytes at offset 7196672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 7233536 ++read 4096/4096 bytes at offset 7233536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 7270400 ++read 4096/4096 bytes at offset 7270400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 7307264 ++read 4096/4096 bytes at offset 7307264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 7344128 ++read 4096/4096 bytes at offset 7344128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 7380992 ++read 4096/4096 bytes at offset 7380992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 7417856 ++read 4096/4096 bytes at offset 7417856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 7454720 ++read 4096/4096 bytes at offset 7454720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 7491584 ++read 4096/4096 bytes at offset 7491584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 7528448 ++read 4096/4096 bytes at offset 7528448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 7565312 ++read 4096/4096 bytes at offset 7565312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 7602176 ++read 4096/4096 bytes at offset 7602176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 7639040 ++read 4096/4096 bytes at offset 7639040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 7675904 ++read 4096/4096 bytes at offset 7675904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 7712768 ++read 4096/4096 bytes at offset 7712768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 7749632 ++read 4096/4096 bytes at offset 7749632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 7786496 ++read 4096/4096 bytes at offset 7786496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 7823360 ++read 4096/4096 bytes at offset 7823360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 7860224 ++read 4096/4096 bytes at offset 7860224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 7897088 ++read 4096/4096 bytes at offset 7897088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 7933952 ++read 4096/4096 bytes at offset 7933952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 7970816 ++read 4096/4096 bytes at offset 7970816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 8007680 ++read 4096/4096 bytes at offset 8007680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 8044544 ++read 4096/4096 bytes at offset 8044544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 8081408 ++read 4096/4096 bytes at offset 8081408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 8118272 ++read 4096/4096 bytes at offset 8118272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 8155136 ++read 4096/4096 bytes at offset 8155136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 8192000 ++read 4096/4096 bytes at offset 8192000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 8228864 ++read 4096/4096 bytes at offset 8228864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 8265728 ++read 4096/4096 bytes at offset 8265728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 8302592 ++read 4096/4096 bytes at offset 8302592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 8339456 ++read 4096/4096 bytes at offset 8339456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 8376320 ++read 4096/4096 bytes at offset 8376320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 8413184 ++read 4096/4096 bytes at offset 8413184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 8450048 ++read 4096/4096 bytes at offset 8450048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 8486912 ++read 4096/4096 bytes at offset 8486912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 8523776 ++read 4096/4096 bytes at offset 8523776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 8560640 ++read 4096/4096 bytes at offset 8560640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 8597504 ++read 4096/4096 bytes at offset 8597504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 8634368 ++read 4096/4096 bytes at offset 8634368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 8671232 ++read 4096/4096 bytes at offset 8671232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 8708096 ++read 4096/4096 bytes at offset 8708096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 8744960 ++read 4096/4096 bytes at offset 8744960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 8781824 ++read 4096/4096 bytes at offset 8781824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 8818688 ++read 4096/4096 bytes at offset 8818688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 8855552 ++read 4096/4096 bytes at offset 8855552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 8892416 ++read 4096/4096 bytes at offset 8892416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 8929280 ++read 4096/4096 bytes at offset 8929280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 8966144 ++read 4096/4096 bytes at offset 8966144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 9003008 ++read 4096/4096 bytes at offset 9003008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 9039872 ++read 4096/4096 bytes at offset 9039872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 9076736 ++read 4096/4096 bytes at offset 9076736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 9113600 ++read 4096/4096 bytes at offset 9113600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 9150464 ++read 4096/4096 bytes at offset 9150464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 9187328 ++read 4096/4096 bytes at offset 9187328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 9224192 ++read 4096/4096 bytes at offset 9224192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 9261056 ++read 4096/4096 bytes at offset 9261056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 9297920 ++read 4096/4096 bytes at offset 9297920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 9334784 ++read 4096/4096 bytes at offset 9334784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 9371648 ++read 4096/4096 bytes at offset 9371648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 9408512 ++read 4096/4096 bytes at offset 9408512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> read 8192/8192 bytes at offset 24576 ++=== IO: pattern 0 ++read 8192/8192 bytes at offset 24576 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 61440 ++read 8192/8192 bytes at offset 61440 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 98304 ++read 8192/8192 bytes at offset 98304 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 135168 ++read 8192/8192 bytes at offset 135168 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 172032 ++read 8192/8192 bytes at offset 172032 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 208896 ++read 8192/8192 bytes at offset 208896 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 245760 ++read 8192/8192 bytes at offset 245760 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 282624 ++read 8192/8192 bytes at offset 282624 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 319488 ++read 8192/8192 bytes at offset 319488 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 356352 ++read 8192/8192 bytes at offset 356352 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 393216 ++read 8192/8192 bytes at offset 393216 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 430080 ++read 8192/8192 bytes at offset 430080 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 466944 ++read 8192/8192 bytes at offset 466944 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 503808 ++read 8192/8192 bytes at offset 503808 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 540672 ++read 8192/8192 bytes at offset 540672 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 577536 ++read 8192/8192 bytes at offset 577536 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 614400 ++read 8192/8192 bytes at offset 614400 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 651264 ++read 8192/8192 bytes at offset 651264 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 688128 ++read 8192/8192 bytes at offset 688128 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 724992 ++read 8192/8192 bytes at offset 724992 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 761856 ++read 8192/8192 bytes at offset 761856 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 798720 ++read 8192/8192 bytes at offset 798720 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 835584 ++read 8192/8192 bytes at offset 835584 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 872448 ++read 8192/8192 bytes at offset 872448 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 909312 ++read 8192/8192 bytes at offset 909312 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 946176 ++read 8192/8192 bytes at offset 946176 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 983040 ++read 8192/8192 bytes at offset 983040 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1019904 ++read 8192/8192 bytes at offset 1019904 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1056768 ++read 8192/8192 bytes at offset 1056768 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1093632 ++read 8192/8192 bytes at offset 1093632 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1130496 ++read 8192/8192 bytes at offset 1130496 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1167360 ++read 8192/8192 bytes at offset 1167360 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1204224 ++read 8192/8192 bytes at offset 1204224 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1241088 ++read 8192/8192 bytes at offset 1241088 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1277952 ++read 8192/8192 bytes at offset 1277952 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1314816 ++read 8192/8192 bytes at offset 1314816 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1351680 ++read 8192/8192 bytes at offset 1351680 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1388544 ++read 8192/8192 bytes at offset 1388544 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1425408 ++read 8192/8192 bytes at offset 1425408 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1462272 ++read 8192/8192 bytes at offset 1462272 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1499136 ++read 8192/8192 bytes at offset 1499136 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1536000 ++read 8192/8192 bytes at offset 1536000 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1572864 ++read 8192/8192 bytes at offset 1572864 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1609728 ++read 8192/8192 bytes at offset 1609728 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1646592 ++read 8192/8192 bytes at offset 1646592 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1683456 ++read 8192/8192 bytes at offset 1683456 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1720320 ++read 8192/8192 bytes at offset 1720320 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1757184 ++read 8192/8192 bytes at offset 1757184 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1794048 ++read 8192/8192 bytes at offset 1794048 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1830912 ++read 8192/8192 bytes at offset 1830912 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1867776 ++read 8192/8192 bytes at offset 1867776 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1904640 ++read 8192/8192 bytes at offset 1904640 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1941504 ++read 8192/8192 bytes at offset 1941504 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1978368 ++read 8192/8192 bytes at offset 1978368 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2015232 ++read 8192/8192 bytes at offset 2015232 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2052096 ++read 8192/8192 bytes at offset 2052096 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2088960 ++read 8192/8192 bytes at offset 2088960 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2125824 ++read 8192/8192 bytes at offset 2125824 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2162688 ++read 8192/8192 bytes at offset 2162688 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2199552 ++read 8192/8192 bytes at offset 2199552 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2236416 ++read 8192/8192 bytes at offset 2236416 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2273280 ++read 8192/8192 bytes at offset 2273280 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2310144 ++read 8192/8192 bytes at offset 2310144 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2347008 ++read 8192/8192 bytes at offset 2347008 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2383872 ++read 8192/8192 bytes at offset 2383872 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2420736 ++read 8192/8192 bytes at offset 2420736 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2457600 ++read 8192/8192 bytes at offset 2457600 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2494464 ++read 8192/8192 bytes at offset 2494464 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2531328 ++read 8192/8192 bytes at offset 2531328 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2568192 ++read 8192/8192 bytes at offset 2568192 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2605056 ++read 8192/8192 bytes at offset 2605056 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2641920 ++read 8192/8192 bytes at offset 2641920 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2678784 ++read 8192/8192 bytes at offset 2678784 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2715648 ++read 8192/8192 bytes at offset 2715648 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2752512 ++read 8192/8192 bytes at offset 2752512 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2789376 ++read 8192/8192 bytes at offset 2789376 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2826240 ++read 8192/8192 bytes at offset 2826240 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2863104 ++read 8192/8192 bytes at offset 2863104 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2899968 ++read 8192/8192 bytes at offset 2899968 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2936832 ++read 8192/8192 bytes at offset 2936832 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2973696 ++read 8192/8192 bytes at offset 2973696 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 3010560 ++read 8192/8192 bytes at offset 3010560 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 3047424 ++read 8192/8192 bytes at offset 3047424 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 3084288 ++read 8192/8192 bytes at offset 3084288 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 3121152 ++read 8192/8192 bytes at offset 3121152 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 3158016 ++read 8192/8192 bytes at offset 3158016 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 3194880 ++read 8192/8192 bytes at offset 3194880 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 3231744 ++read 8192/8192 bytes at offset 3231744 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 3268608 ++read 8192/8192 bytes at offset 3268608 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 3305472 ++read 8192/8192 bytes at offset 3305472 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 3342336 ++read 8192/8192 bytes at offset 3342336 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 3379200 ++read 8192/8192 bytes at offset 3379200 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 3416064 ++read 8192/8192 bytes at offset 3416064 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 3452928 ++read 8192/8192 bytes at offset 3452928 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 3489792 ++read 8192/8192 bytes at offset 3489792 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 3526656 ++read 8192/8192 bytes at offset 3526656 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 3563520 ++read 8192/8192 bytes at offset 3563520 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 3600384 ++read 8192/8192 bytes at offset 3600384 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 3637248 ++read 8192/8192 bytes at offset 3637248 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 3674112 ++read 8192/8192 bytes at offset 3674112 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 3710976 ++read 8192/8192 bytes at offset 3710976 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 3747840 ++read 8192/8192 bytes at offset 3747840 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 3784704 ++read 8192/8192 bytes at offset 3784704 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 3821568 ++read 8192/8192 bytes at offset 3821568 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 3858432 ++read 8192/8192 bytes at offset 3858432 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 3895296 ++read 8192/8192 bytes at offset 3895296 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 3932160 ++read 8192/8192 bytes at offset 3932160 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 3969024 ++read 8192/8192 bytes at offset 3969024 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4005888 ++read 8192/8192 bytes at offset 4005888 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4042752 ++read 8192/8192 bytes at offset 4042752 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4079616 ++read 8192/8192 bytes at offset 4079616 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4116480 ++read 8192/8192 bytes at offset 4116480 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4153344 ++read 8192/8192 bytes at offset 4153344 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4190208 ++read 8192/8192 bytes at offset 4190208 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4227072 ++read 8192/8192 bytes at offset 4227072 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4263936 ++read 8192/8192 bytes at offset 4263936 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4300800 ++read 8192/8192 bytes at offset 4300800 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4337664 ++read 8192/8192 bytes at offset 4337664 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4374528 ++read 8192/8192 bytes at offset 4374528 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4411392 ++read 8192/8192 bytes at offset 4411392 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4448256 ++read 8192/8192 bytes at offset 4448256 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4485120 ++read 8192/8192 bytes at offset 4485120 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4521984 ++read 8192/8192 bytes at offset 4521984 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4558848 ++read 8192/8192 bytes at offset 4558848 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4595712 ++read 8192/8192 bytes at offset 4595712 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4632576 ++read 8192/8192 bytes at offset 4632576 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4669440 ++read 8192/8192 bytes at offset 4669440 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4706304 ++read 8192/8192 bytes at offset 4706304 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4743168 ++read 8192/8192 bytes at offset 4743168 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4780032 ++read 8192/8192 bytes at offset 4780032 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4816896 ++read 8192/8192 bytes at offset 4816896 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4853760 ++read 8192/8192 bytes at offset 4853760 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4890624 ++read 8192/8192 bytes at offset 4890624 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4927488 ++read 8192/8192 bytes at offset 4927488 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4964352 ++read 8192/8192 bytes at offset 4964352 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 5001216 ++read 8192/8192 bytes at offset 5001216 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 5038080 ++read 8192/8192 bytes at offset 5038080 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 5074944 ++read 8192/8192 bytes at offset 5074944 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 5111808 ++read 8192/8192 bytes at offset 5111808 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 5148672 ++read 8192/8192 bytes at offset 5148672 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 5185536 ++read 8192/8192 bytes at offset 5185536 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 5222400 ++read 8192/8192 bytes at offset 5222400 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 5259264 ++read 8192/8192 bytes at offset 5259264 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 5296128 ++read 8192/8192 bytes at offset 5296128 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 5332992 ++read 8192/8192 bytes at offset 5332992 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 5369856 ++read 8192/8192 bytes at offset 5369856 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 5406720 ++read 8192/8192 bytes at offset 5406720 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 5443584 ++read 8192/8192 bytes at offset 5443584 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 5480448 ++read 8192/8192 bytes at offset 5480448 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 5517312 ++read 8192/8192 bytes at offset 5517312 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 5554176 ++read 8192/8192 bytes at offset 5554176 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 5591040 ++read 8192/8192 bytes at offset 5591040 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 5627904 ++read 8192/8192 bytes at offset 5627904 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 5664768 ++read 8192/8192 bytes at offset 5664768 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 5701632 ++read 8192/8192 bytes at offset 5701632 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 5738496 ++read 8192/8192 bytes at offset 5738496 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 5775360 ++read 8192/8192 bytes at offset 5775360 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 5812224 ++read 8192/8192 bytes at offset 5812224 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 5849088 ++read 8192/8192 bytes at offset 5849088 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 5885952 ++read 8192/8192 bytes at offset 5885952 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 5922816 ++read 8192/8192 bytes at offset 5922816 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 5959680 ++read 8192/8192 bytes at offset 5959680 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 5996544 ++read 8192/8192 bytes at offset 5996544 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 6033408 ++read 8192/8192 bytes at offset 6033408 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 6070272 ++read 8192/8192 bytes at offset 6070272 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 6107136 ++read 8192/8192 bytes at offset 6107136 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 6144000 ++read 8192/8192 bytes at offset 6144000 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 6180864 ++read 8192/8192 bytes at offset 6180864 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 6217728 ++read 8192/8192 bytes at offset 6217728 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 6254592 ++read 8192/8192 bytes at offset 6254592 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 6291456 ++read 8192/8192 bytes at offset 6291456 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 6328320 ++read 8192/8192 bytes at offset 6328320 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 6365184 ++read 8192/8192 bytes at offset 6365184 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 6402048 ++read 8192/8192 bytes at offset 6402048 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 6438912 ++read 8192/8192 bytes at offset 6438912 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 6475776 ++read 8192/8192 bytes at offset 6475776 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 6512640 ++read 8192/8192 bytes at offset 6512640 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 6549504 ++read 8192/8192 bytes at offset 6549504 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 6586368 ++read 8192/8192 bytes at offset 6586368 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 6623232 ++read 8192/8192 bytes at offset 6623232 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 6660096 ++read 8192/8192 bytes at offset 6660096 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 6696960 ++read 8192/8192 bytes at offset 6696960 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 6733824 ++read 8192/8192 bytes at offset 6733824 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 6770688 ++read 8192/8192 bytes at offset 6770688 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 6807552 ++read 8192/8192 bytes at offset 6807552 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 6844416 ++read 8192/8192 bytes at offset 6844416 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 6881280 ++read 8192/8192 bytes at offset 6881280 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 6918144 ++read 8192/8192 bytes at offset 6918144 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 6955008 ++read 8192/8192 bytes at offset 6955008 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 6991872 ++read 8192/8192 bytes at offset 6991872 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 7028736 ++read 8192/8192 bytes at offset 7028736 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 7065600 ++read 8192/8192 bytes at offset 7065600 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 7102464 ++read 8192/8192 bytes at offset 7102464 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 7139328 ++read 8192/8192 bytes at offset 7139328 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 7176192 ++read 8192/8192 bytes at offset 7176192 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 7213056 ++read 8192/8192 bytes at offset 7213056 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 7249920 ++read 8192/8192 bytes at offset 7249920 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 7286784 ++read 8192/8192 bytes at offset 7286784 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 7323648 ++read 8192/8192 bytes at offset 7323648 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 7360512 ++read 8192/8192 bytes at offset 7360512 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 7397376 ++read 8192/8192 bytes at offset 7397376 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 7434240 ++read 8192/8192 bytes at offset 7434240 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 7471104 ++read 8192/8192 bytes at offset 7471104 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 7507968 ++read 8192/8192 bytes at offset 7507968 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 7544832 ++read 8192/8192 bytes at offset 7544832 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 7581696 ++read 8192/8192 bytes at offset 7581696 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 7618560 ++read 8192/8192 bytes at offset 7618560 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 7655424 ++read 8192/8192 bytes at offset 7655424 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 7692288 ++read 8192/8192 bytes at offset 7692288 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 7729152 ++read 8192/8192 bytes at offset 7729152 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 7766016 ++read 8192/8192 bytes at offset 7766016 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 7802880 ++read 8192/8192 bytes at offset 7802880 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 7839744 ++read 8192/8192 bytes at offset 7839744 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 7876608 ++read 8192/8192 bytes at offset 7876608 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 7913472 ++read 8192/8192 bytes at offset 7913472 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 7950336 ++read 8192/8192 bytes at offset 7950336 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 7987200 ++read 8192/8192 bytes at offset 7987200 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 8024064 ++read 8192/8192 bytes at offset 8024064 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 8060928 ++read 8192/8192 bytes at offset 8060928 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 8097792 ++read 8192/8192 bytes at offset 8097792 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 8134656 ++read 8192/8192 bytes at offset 8134656 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 8171520 ++read 8192/8192 bytes at offset 8171520 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 8208384 ++read 8192/8192 bytes at offset 8208384 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 8245248 ++read 8192/8192 bytes at offset 8245248 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 8282112 ++read 8192/8192 bytes at offset 8282112 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 8318976 ++read 8192/8192 bytes at offset 8318976 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 8355840 ++read 8192/8192 bytes at offset 8355840 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 8392704 ++read 8192/8192 bytes at offset 8392704 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 8429568 ++read 8192/8192 bytes at offset 8429568 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 8466432 ++read 8192/8192 bytes at offset 8466432 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 8503296 ++read 8192/8192 bytes at offset 8503296 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 8540160 ++read 8192/8192 bytes at offset 8540160 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 8577024 ++read 8192/8192 bytes at offset 8577024 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 8613888 ++read 8192/8192 bytes at offset 8613888 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 8650752 ++read 8192/8192 bytes at offset 8650752 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 8687616 ++read 8192/8192 bytes at offset 8687616 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 8724480 ++read 8192/8192 bytes at offset 8724480 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 8761344 ++read 8192/8192 bytes at offset 8761344 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 8798208 ++read 8192/8192 bytes at offset 8798208 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 8835072 ++read 8192/8192 bytes at offset 8835072 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 8871936 ++read 8192/8192 bytes at offset 8871936 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 8908800 ++read 8192/8192 bytes at offset 8908800 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 8945664 ++read 8192/8192 bytes at offset 8945664 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 8982528 ++read 8192/8192 bytes at offset 8982528 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 9019392 ++read 8192/8192 bytes at offset 9019392 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 9056256 ++read 8192/8192 bytes at offset 9056256 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 9093120 ++read 8192/8192 bytes at offset 9093120 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 9129984 ++read 8192/8192 bytes at offset 9129984 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 9166848 ++read 8192/8192 bytes at offset 9166848 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 9203712 ++read 8192/8192 bytes at offset 9203712 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 9240576 ++read 8192/8192 bytes at offset 9240576 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 9277440 ++read 8192/8192 bytes at offset 9277440 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 9314304 ++read 8192/8192 bytes at offset 9314304 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 9351168 ++read 8192/8192 bytes at offset 9351168 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 9388032 ++read 8192/8192 bytes at offset 9388032 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 9424896 ++read 8192/8192 bytes at offset 9424896 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> No errors were found on the image. ++No errors were found on the image. + test2: With offset 4294967296 + === Clusters to be compressed [1] + === IO: pattern 165 +-qemu-io> wrote 4096/4096 bytes at offset 4294983680 ++wrote 4096/4096 bytes at offset 4294983680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295020544 ++wrote 4096/4096 bytes at offset 4295020544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295057408 ++wrote 4096/4096 bytes at offset 4295057408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295094272 ++wrote 4096/4096 bytes at offset 4295094272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295131136 ++wrote 4096/4096 bytes at offset 4295131136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295168000 ++wrote 4096/4096 bytes at offset 4295168000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295204864 ++wrote 4096/4096 bytes at offset 4295204864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295241728 ++wrote 4096/4096 bytes at offset 4295241728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295278592 ++wrote 4096/4096 bytes at offset 4295278592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295315456 ++wrote 4096/4096 bytes at offset 4295315456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295352320 ++wrote 4096/4096 bytes at offset 4295352320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295389184 ++wrote 4096/4096 bytes at offset 4295389184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295426048 ++wrote 4096/4096 bytes at offset 4295426048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295462912 ++wrote 4096/4096 bytes at offset 4295462912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295499776 ++wrote 4096/4096 bytes at offset 4295499776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295536640 ++wrote 4096/4096 bytes at offset 4295536640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295573504 ++wrote 4096/4096 bytes at offset 4295573504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295610368 ++wrote 4096/4096 bytes at offset 4295610368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295647232 ++wrote 4096/4096 bytes at offset 4295647232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295684096 ++wrote 4096/4096 bytes at offset 4295684096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295720960 ++wrote 4096/4096 bytes at offset 4295720960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295757824 ++wrote 4096/4096 bytes at offset 4295757824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295794688 ++wrote 4096/4096 bytes at offset 4295794688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295831552 ++wrote 4096/4096 bytes at offset 4295831552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295868416 ++wrote 4096/4096 bytes at offset 4295868416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295905280 ++wrote 4096/4096 bytes at offset 4295905280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295942144 ++wrote 4096/4096 bytes at offset 4295942144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295979008 ++wrote 4096/4096 bytes at offset 4295979008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296015872 ++wrote 4096/4096 bytes at offset 4296015872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296052736 ++wrote 4096/4096 bytes at offset 4296052736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296089600 ++wrote 4096/4096 bytes at offset 4296089600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296126464 ++wrote 4096/4096 bytes at offset 4296126464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296163328 ++wrote 4096/4096 bytes at offset 4296163328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296200192 ++wrote 4096/4096 bytes at offset 4296200192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296237056 ++wrote 4096/4096 bytes at offset 4296237056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296273920 ++wrote 4096/4096 bytes at offset 4296273920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296310784 ++wrote 4096/4096 bytes at offset 4296310784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296347648 ++wrote 4096/4096 bytes at offset 4296347648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296384512 ++wrote 4096/4096 bytes at offset 4296384512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296421376 ++wrote 4096/4096 bytes at offset 4296421376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296458240 ++wrote 4096/4096 bytes at offset 4296458240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296495104 ++wrote 4096/4096 bytes at offset 4296495104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296531968 ++wrote 4096/4096 bytes at offset 4296531968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296568832 ++wrote 4096/4096 bytes at offset 4296568832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296605696 ++wrote 4096/4096 bytes at offset 4296605696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296642560 ++wrote 4096/4096 bytes at offset 4296642560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296679424 ++wrote 4096/4096 bytes at offset 4296679424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296716288 ++wrote 4096/4096 bytes at offset 4296716288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296753152 ++wrote 4096/4096 bytes at offset 4296753152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296790016 ++wrote 4096/4096 bytes at offset 4296790016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296826880 ++wrote 4096/4096 bytes at offset 4296826880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296863744 ++wrote 4096/4096 bytes at offset 4296863744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296900608 ++wrote 4096/4096 bytes at offset 4296900608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296937472 ++wrote 4096/4096 bytes at offset 4296937472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296974336 ++wrote 4096/4096 bytes at offset 4296974336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297011200 ++wrote 4096/4096 bytes at offset 4297011200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297048064 ++wrote 4096/4096 bytes at offset 4297048064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297084928 ++wrote 4096/4096 bytes at offset 4297084928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297121792 ++wrote 4096/4096 bytes at offset 4297121792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297158656 ++wrote 4096/4096 bytes at offset 4297158656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297195520 ++wrote 4096/4096 bytes at offset 4297195520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297232384 ++wrote 4096/4096 bytes at offset 4297232384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297269248 ++wrote 4096/4096 bytes at offset 4297269248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297306112 ++wrote 4096/4096 bytes at offset 4297306112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297342976 ++wrote 4096/4096 bytes at offset 4297342976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297379840 ++wrote 4096/4096 bytes at offset 4297379840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297416704 ++wrote 4096/4096 bytes at offset 4297416704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297453568 ++wrote 4096/4096 bytes at offset 4297453568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297490432 ++wrote 4096/4096 bytes at offset 4297490432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297527296 ++wrote 4096/4096 bytes at offset 4297527296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297564160 ++wrote 4096/4096 bytes at offset 4297564160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297601024 ++wrote 4096/4096 bytes at offset 4297601024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297637888 ++wrote 4096/4096 bytes at offset 4297637888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297674752 ++wrote 4096/4096 bytes at offset 4297674752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297711616 ++wrote 4096/4096 bytes at offset 4297711616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297748480 ++wrote 4096/4096 bytes at offset 4297748480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297785344 ++wrote 4096/4096 bytes at offset 4297785344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297822208 ++wrote 4096/4096 bytes at offset 4297822208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297859072 ++wrote 4096/4096 bytes at offset 4297859072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297895936 ++wrote 4096/4096 bytes at offset 4297895936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297932800 ++wrote 4096/4096 bytes at offset 4297932800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297969664 ++wrote 4096/4096 bytes at offset 4297969664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298006528 ++wrote 4096/4096 bytes at offset 4298006528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298043392 ++wrote 4096/4096 bytes at offset 4298043392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298080256 ++wrote 4096/4096 bytes at offset 4298080256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298117120 ++wrote 4096/4096 bytes at offset 4298117120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298153984 ++wrote 4096/4096 bytes at offset 4298153984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298190848 ++wrote 4096/4096 bytes at offset 4298190848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298227712 ++wrote 4096/4096 bytes at offset 4298227712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298264576 ++wrote 4096/4096 bytes at offset 4298264576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298301440 ++wrote 4096/4096 bytes at offset 4298301440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298338304 ++wrote 4096/4096 bytes at offset 4298338304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298375168 ++wrote 4096/4096 bytes at offset 4298375168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298412032 ++wrote 4096/4096 bytes at offset 4298412032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298448896 ++wrote 4096/4096 bytes at offset 4298448896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298485760 ++wrote 4096/4096 bytes at offset 4298485760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298522624 ++wrote 4096/4096 bytes at offset 4298522624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298559488 ++wrote 4096/4096 bytes at offset 4298559488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298596352 ++wrote 4096/4096 bytes at offset 4298596352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298633216 ++wrote 4096/4096 bytes at offset 4298633216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298670080 ++wrote 4096/4096 bytes at offset 4298670080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298706944 ++wrote 4096/4096 bytes at offset 4298706944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298743808 ++wrote 4096/4096 bytes at offset 4298743808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298780672 ++wrote 4096/4096 bytes at offset 4298780672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298817536 ++wrote 4096/4096 bytes at offset 4298817536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298854400 ++wrote 4096/4096 bytes at offset 4298854400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298891264 ++wrote 4096/4096 bytes at offset 4298891264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298928128 ++wrote 4096/4096 bytes at offset 4298928128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298964992 ++wrote 4096/4096 bytes at offset 4298964992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299001856 ++wrote 4096/4096 bytes at offset 4299001856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299038720 ++wrote 4096/4096 bytes at offset 4299038720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299075584 ++wrote 4096/4096 bytes at offset 4299075584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299112448 ++wrote 4096/4096 bytes at offset 4299112448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299149312 ++wrote 4096/4096 bytes at offset 4299149312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299186176 ++wrote 4096/4096 bytes at offset 4299186176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299223040 ++wrote 4096/4096 bytes at offset 4299223040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299259904 ++wrote 4096/4096 bytes at offset 4299259904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299296768 ++wrote 4096/4096 bytes at offset 4299296768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299333632 ++wrote 4096/4096 bytes at offset 4299333632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299370496 ++wrote 4096/4096 bytes at offset 4299370496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299407360 ++wrote 4096/4096 bytes at offset 4299407360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299444224 ++wrote 4096/4096 bytes at offset 4299444224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299481088 ++wrote 4096/4096 bytes at offset 4299481088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299517952 ++wrote 4096/4096 bytes at offset 4299517952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299554816 ++wrote 4096/4096 bytes at offset 4299554816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299591680 ++wrote 4096/4096 bytes at offset 4299591680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299628544 ++wrote 4096/4096 bytes at offset 4299628544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299665408 ++wrote 4096/4096 bytes at offset 4299665408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299702272 ++wrote 4096/4096 bytes at offset 4299702272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299739136 ++wrote 4096/4096 bytes at offset 4299739136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299776000 ++wrote 4096/4096 bytes at offset 4299776000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299812864 ++wrote 4096/4096 bytes at offset 4299812864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299849728 ++wrote 4096/4096 bytes at offset 4299849728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299886592 ++wrote 4096/4096 bytes at offset 4299886592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299923456 ++wrote 4096/4096 bytes at offset 4299923456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299960320 ++wrote 4096/4096 bytes at offset 4299960320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299997184 ++wrote 4096/4096 bytes at offset 4299997184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300034048 ++wrote 4096/4096 bytes at offset 4300034048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300070912 ++wrote 4096/4096 bytes at offset 4300070912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300107776 ++wrote 4096/4096 bytes at offset 4300107776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300144640 ++wrote 4096/4096 bytes at offset 4300144640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300181504 ++wrote 4096/4096 bytes at offset 4300181504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300218368 ++wrote 4096/4096 bytes at offset 4300218368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300255232 ++wrote 4096/4096 bytes at offset 4300255232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300292096 ++wrote 4096/4096 bytes at offset 4300292096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300328960 ++wrote 4096/4096 bytes at offset 4300328960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300365824 ++wrote 4096/4096 bytes at offset 4300365824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300402688 ++wrote 4096/4096 bytes at offset 4300402688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300439552 ++wrote 4096/4096 bytes at offset 4300439552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300476416 ++wrote 4096/4096 bytes at offset 4300476416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300513280 ++wrote 4096/4096 bytes at offset 4300513280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300550144 ++wrote 4096/4096 bytes at offset 4300550144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300587008 ++wrote 4096/4096 bytes at offset 4300587008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300623872 ++wrote 4096/4096 bytes at offset 4300623872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300660736 ++wrote 4096/4096 bytes at offset 4300660736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300697600 ++wrote 4096/4096 bytes at offset 4300697600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300734464 ++wrote 4096/4096 bytes at offset 4300734464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300771328 ++wrote 4096/4096 bytes at offset 4300771328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300808192 ++wrote 4096/4096 bytes at offset 4300808192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300845056 ++wrote 4096/4096 bytes at offset 4300845056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300881920 ++wrote 4096/4096 bytes at offset 4300881920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300918784 ++wrote 4096/4096 bytes at offset 4300918784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300955648 ++wrote 4096/4096 bytes at offset 4300955648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300992512 ++wrote 4096/4096 bytes at offset 4300992512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301029376 ++wrote 4096/4096 bytes at offset 4301029376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301066240 ++wrote 4096/4096 bytes at offset 4301066240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301103104 ++wrote 4096/4096 bytes at offset 4301103104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301139968 ++wrote 4096/4096 bytes at offset 4301139968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301176832 ++wrote 4096/4096 bytes at offset 4301176832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301213696 ++wrote 4096/4096 bytes at offset 4301213696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301250560 ++wrote 4096/4096 bytes at offset 4301250560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301287424 ++wrote 4096/4096 bytes at offset 4301287424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301324288 ++wrote 4096/4096 bytes at offset 4301324288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301361152 ++wrote 4096/4096 bytes at offset 4301361152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301398016 ++wrote 4096/4096 bytes at offset 4301398016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301434880 ++wrote 4096/4096 bytes at offset 4301434880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301471744 ++wrote 4096/4096 bytes at offset 4301471744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301508608 ++wrote 4096/4096 bytes at offset 4301508608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301545472 ++wrote 4096/4096 bytes at offset 4301545472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301582336 ++wrote 4096/4096 bytes at offset 4301582336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301619200 ++wrote 4096/4096 bytes at offset 4301619200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301656064 ++wrote 4096/4096 bytes at offset 4301656064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301692928 ++wrote 4096/4096 bytes at offset 4301692928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301729792 ++wrote 4096/4096 bytes at offset 4301729792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301766656 ++wrote 4096/4096 bytes at offset 4301766656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301803520 ++wrote 4096/4096 bytes at offset 4301803520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301840384 ++wrote 4096/4096 bytes at offset 4301840384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301877248 ++wrote 4096/4096 bytes at offset 4301877248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301914112 ++wrote 4096/4096 bytes at offset 4301914112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301950976 ++wrote 4096/4096 bytes at offset 4301950976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301987840 ++wrote 4096/4096 bytes at offset 4301987840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302024704 ++wrote 4096/4096 bytes at offset 4302024704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302061568 ++wrote 4096/4096 bytes at offset 4302061568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302098432 ++wrote 4096/4096 bytes at offset 4302098432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302135296 ++wrote 4096/4096 bytes at offset 4302135296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302172160 ++wrote 4096/4096 bytes at offset 4302172160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302209024 ++wrote 4096/4096 bytes at offset 4302209024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302245888 ++wrote 4096/4096 bytes at offset 4302245888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302282752 ++wrote 4096/4096 bytes at offset 4302282752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302319616 ++wrote 4096/4096 bytes at offset 4302319616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302356480 ++wrote 4096/4096 bytes at offset 4302356480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302393344 ++wrote 4096/4096 bytes at offset 4302393344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302430208 ++wrote 4096/4096 bytes at offset 4302430208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302467072 ++wrote 4096/4096 bytes at offset 4302467072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302503936 ++wrote 4096/4096 bytes at offset 4302503936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302540800 ++wrote 4096/4096 bytes at offset 4302540800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302577664 ++wrote 4096/4096 bytes at offset 4302577664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302614528 ++wrote 4096/4096 bytes at offset 4302614528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302651392 ++wrote 4096/4096 bytes at offset 4302651392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302688256 ++wrote 4096/4096 bytes at offset 4302688256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302725120 ++wrote 4096/4096 bytes at offset 4302725120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302761984 ++wrote 4096/4096 bytes at offset 4302761984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302798848 ++wrote 4096/4096 bytes at offset 4302798848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302835712 ++wrote 4096/4096 bytes at offset 4302835712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302872576 ++wrote 4096/4096 bytes at offset 4302872576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302909440 ++wrote 4096/4096 bytes at offset 4302909440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302946304 ++wrote 4096/4096 bytes at offset 4302946304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302983168 ++wrote 4096/4096 bytes at offset 4302983168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303020032 ++wrote 4096/4096 bytes at offset 4303020032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303056896 ++wrote 4096/4096 bytes at offset 4303056896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303093760 ++wrote 4096/4096 bytes at offset 4303093760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303130624 ++wrote 4096/4096 bytes at offset 4303130624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303167488 ++wrote 4096/4096 bytes at offset 4303167488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303204352 ++wrote 4096/4096 bytes at offset 4303204352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303241216 ++wrote 4096/4096 bytes at offset 4303241216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303278080 ++wrote 4096/4096 bytes at offset 4303278080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303314944 ++wrote 4096/4096 bytes at offset 4303314944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303351808 ++wrote 4096/4096 bytes at offset 4303351808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303388672 ++wrote 4096/4096 bytes at offset 4303388672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303425536 ++wrote 4096/4096 bytes at offset 4303425536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303462400 ++wrote 4096/4096 bytes at offset 4303462400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303499264 ++wrote 4096/4096 bytes at offset 4303499264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303536128 ++wrote 4096/4096 bytes at offset 4303536128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303572992 ++wrote 4096/4096 bytes at offset 4303572992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303609856 ++wrote 4096/4096 bytes at offset 4303609856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303646720 ++wrote 4096/4096 bytes at offset 4303646720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303683584 ++wrote 4096/4096 bytes at offset 4303683584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303720448 ++wrote 4096/4096 bytes at offset 4303720448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303757312 ++wrote 4096/4096 bytes at offset 4303757312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303794176 ++wrote 4096/4096 bytes at offset 4303794176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303831040 ++wrote 4096/4096 bytes at offset 4303831040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303867904 ++wrote 4096/4096 bytes at offset 4303867904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303904768 ++wrote 4096/4096 bytes at offset 4303904768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303941632 ++wrote 4096/4096 bytes at offset 4303941632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303978496 ++wrote 4096/4096 bytes at offset 4303978496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4304015360 ++wrote 4096/4096 bytes at offset 4304015360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4304052224 ++wrote 4096/4096 bytes at offset 4304052224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4304089088 ++wrote 4096/4096 bytes at offset 4304089088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4304125952 ++wrote 4096/4096 bytes at offset 4304125952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4304162816 ++wrote 4096/4096 bytes at offset 4304162816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4304199680 ++wrote 4096/4096 bytes at offset 4304199680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4304236544 ++wrote 4096/4096 bytes at offset 4304236544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4304273408 ++wrote 4096/4096 bytes at offset 4304273408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4304310272 ++wrote 4096/4096 bytes at offset 4304310272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4304347136 ++wrote 4096/4096 bytes at offset 4304347136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4304384000 ++wrote 4096/4096 bytes at offset 4304384000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === Clusters to be compressed [2] ++=== Clusters to be compressed [2] + === IO: pattern 165 +-qemu-io> wrote 4096/4096 bytes at offset 4294987776 ++wrote 4096/4096 bytes at offset 4294987776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295024640 ++wrote 4096/4096 bytes at offset 4295024640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295061504 ++wrote 4096/4096 bytes at offset 4295061504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295098368 ++wrote 4096/4096 bytes at offset 4295098368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295135232 ++wrote 4096/4096 bytes at offset 4295135232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295172096 ++wrote 4096/4096 bytes at offset 4295172096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295208960 ++wrote 4096/4096 bytes at offset 4295208960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295245824 ++wrote 4096/4096 bytes at offset 4295245824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295282688 ++wrote 4096/4096 bytes at offset 4295282688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295319552 ++wrote 4096/4096 bytes at offset 4295319552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295356416 ++wrote 4096/4096 bytes at offset 4295356416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295393280 ++wrote 4096/4096 bytes at offset 4295393280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295430144 ++wrote 4096/4096 bytes at offset 4295430144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295467008 ++wrote 4096/4096 bytes at offset 4295467008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295503872 ++wrote 4096/4096 bytes at offset 4295503872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295540736 ++wrote 4096/4096 bytes at offset 4295540736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295577600 ++wrote 4096/4096 bytes at offset 4295577600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295614464 ++wrote 4096/4096 bytes at offset 4295614464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295651328 ++wrote 4096/4096 bytes at offset 4295651328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295688192 ++wrote 4096/4096 bytes at offset 4295688192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295725056 ++wrote 4096/4096 bytes at offset 4295725056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295761920 ++wrote 4096/4096 bytes at offset 4295761920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295798784 ++wrote 4096/4096 bytes at offset 4295798784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295835648 ++wrote 4096/4096 bytes at offset 4295835648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295872512 ++wrote 4096/4096 bytes at offset 4295872512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295909376 ++wrote 4096/4096 bytes at offset 4295909376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295946240 ++wrote 4096/4096 bytes at offset 4295946240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295983104 ++wrote 4096/4096 bytes at offset 4295983104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296019968 ++wrote 4096/4096 bytes at offset 4296019968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296056832 ++wrote 4096/4096 bytes at offset 4296056832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296093696 ++wrote 4096/4096 bytes at offset 4296093696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296130560 ++wrote 4096/4096 bytes at offset 4296130560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296167424 ++wrote 4096/4096 bytes at offset 4296167424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296204288 ++wrote 4096/4096 bytes at offset 4296204288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296241152 ++wrote 4096/4096 bytes at offset 4296241152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296278016 ++wrote 4096/4096 bytes at offset 4296278016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296314880 ++wrote 4096/4096 bytes at offset 4296314880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296351744 ++wrote 4096/4096 bytes at offset 4296351744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296388608 ++wrote 4096/4096 bytes at offset 4296388608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296425472 ++wrote 4096/4096 bytes at offset 4296425472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296462336 ++wrote 4096/4096 bytes at offset 4296462336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296499200 ++wrote 4096/4096 bytes at offset 4296499200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296536064 ++wrote 4096/4096 bytes at offset 4296536064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296572928 ++wrote 4096/4096 bytes at offset 4296572928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296609792 ++wrote 4096/4096 bytes at offset 4296609792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296646656 ++wrote 4096/4096 bytes at offset 4296646656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296683520 ++wrote 4096/4096 bytes at offset 4296683520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296720384 ++wrote 4096/4096 bytes at offset 4296720384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296757248 ++wrote 4096/4096 bytes at offset 4296757248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296794112 ++wrote 4096/4096 bytes at offset 4296794112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296830976 ++wrote 4096/4096 bytes at offset 4296830976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296867840 ++wrote 4096/4096 bytes at offset 4296867840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296904704 ++wrote 4096/4096 bytes at offset 4296904704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296941568 ++wrote 4096/4096 bytes at offset 4296941568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296978432 ++wrote 4096/4096 bytes at offset 4296978432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297015296 ++wrote 4096/4096 bytes at offset 4297015296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297052160 ++wrote 4096/4096 bytes at offset 4297052160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297089024 ++wrote 4096/4096 bytes at offset 4297089024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297125888 ++wrote 4096/4096 bytes at offset 4297125888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297162752 ++wrote 4096/4096 bytes at offset 4297162752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297199616 ++wrote 4096/4096 bytes at offset 4297199616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297236480 ++wrote 4096/4096 bytes at offset 4297236480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297273344 ++wrote 4096/4096 bytes at offset 4297273344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297310208 ++wrote 4096/4096 bytes at offset 4297310208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297347072 ++wrote 4096/4096 bytes at offset 4297347072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297383936 ++wrote 4096/4096 bytes at offset 4297383936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297420800 ++wrote 4096/4096 bytes at offset 4297420800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297457664 ++wrote 4096/4096 bytes at offset 4297457664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297494528 ++wrote 4096/4096 bytes at offset 4297494528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297531392 ++wrote 4096/4096 bytes at offset 4297531392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297568256 ++wrote 4096/4096 bytes at offset 4297568256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297605120 ++wrote 4096/4096 bytes at offset 4297605120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297641984 ++wrote 4096/4096 bytes at offset 4297641984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297678848 ++wrote 4096/4096 bytes at offset 4297678848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297715712 ++wrote 4096/4096 bytes at offset 4297715712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297752576 ++wrote 4096/4096 bytes at offset 4297752576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297789440 ++wrote 4096/4096 bytes at offset 4297789440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297826304 ++wrote 4096/4096 bytes at offset 4297826304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297863168 ++wrote 4096/4096 bytes at offset 4297863168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297900032 ++wrote 4096/4096 bytes at offset 4297900032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297936896 ++wrote 4096/4096 bytes at offset 4297936896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297973760 ++wrote 4096/4096 bytes at offset 4297973760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298010624 ++wrote 4096/4096 bytes at offset 4298010624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298047488 ++wrote 4096/4096 bytes at offset 4298047488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298084352 ++wrote 4096/4096 bytes at offset 4298084352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298121216 ++wrote 4096/4096 bytes at offset 4298121216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298158080 ++wrote 4096/4096 bytes at offset 4298158080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298194944 ++wrote 4096/4096 bytes at offset 4298194944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298231808 ++wrote 4096/4096 bytes at offset 4298231808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298268672 ++wrote 4096/4096 bytes at offset 4298268672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298305536 ++wrote 4096/4096 bytes at offset 4298305536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298342400 ++wrote 4096/4096 bytes at offset 4298342400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298379264 ++wrote 4096/4096 bytes at offset 4298379264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298416128 ++wrote 4096/4096 bytes at offset 4298416128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298452992 ++wrote 4096/4096 bytes at offset 4298452992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298489856 ++wrote 4096/4096 bytes at offset 4298489856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298526720 ++wrote 4096/4096 bytes at offset 4298526720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298563584 ++wrote 4096/4096 bytes at offset 4298563584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298600448 ++wrote 4096/4096 bytes at offset 4298600448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298637312 ++wrote 4096/4096 bytes at offset 4298637312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298674176 ++wrote 4096/4096 bytes at offset 4298674176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298711040 ++wrote 4096/4096 bytes at offset 4298711040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298747904 ++wrote 4096/4096 bytes at offset 4298747904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298784768 ++wrote 4096/4096 bytes at offset 4298784768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298821632 ++wrote 4096/4096 bytes at offset 4298821632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298858496 ++wrote 4096/4096 bytes at offset 4298858496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298895360 ++wrote 4096/4096 bytes at offset 4298895360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298932224 ++wrote 4096/4096 bytes at offset 4298932224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298969088 ++wrote 4096/4096 bytes at offset 4298969088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299005952 ++wrote 4096/4096 bytes at offset 4299005952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299042816 ++wrote 4096/4096 bytes at offset 4299042816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299079680 ++wrote 4096/4096 bytes at offset 4299079680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299116544 ++wrote 4096/4096 bytes at offset 4299116544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299153408 ++wrote 4096/4096 bytes at offset 4299153408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299190272 ++wrote 4096/4096 bytes at offset 4299190272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299227136 ++wrote 4096/4096 bytes at offset 4299227136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299264000 ++wrote 4096/4096 bytes at offset 4299264000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299300864 ++wrote 4096/4096 bytes at offset 4299300864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299337728 ++wrote 4096/4096 bytes at offset 4299337728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299374592 ++wrote 4096/4096 bytes at offset 4299374592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299411456 ++wrote 4096/4096 bytes at offset 4299411456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299448320 ++wrote 4096/4096 bytes at offset 4299448320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299485184 ++wrote 4096/4096 bytes at offset 4299485184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299522048 ++wrote 4096/4096 bytes at offset 4299522048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299558912 ++wrote 4096/4096 bytes at offset 4299558912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299595776 ++wrote 4096/4096 bytes at offset 4299595776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299632640 ++wrote 4096/4096 bytes at offset 4299632640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299669504 ++wrote 4096/4096 bytes at offset 4299669504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299706368 ++wrote 4096/4096 bytes at offset 4299706368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299743232 ++wrote 4096/4096 bytes at offset 4299743232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299780096 ++wrote 4096/4096 bytes at offset 4299780096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299816960 ++wrote 4096/4096 bytes at offset 4299816960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299853824 ++wrote 4096/4096 bytes at offset 4299853824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299890688 ++wrote 4096/4096 bytes at offset 4299890688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299927552 ++wrote 4096/4096 bytes at offset 4299927552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299964416 ++wrote 4096/4096 bytes at offset 4299964416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300001280 ++wrote 4096/4096 bytes at offset 4300001280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300038144 ++wrote 4096/4096 bytes at offset 4300038144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300075008 ++wrote 4096/4096 bytes at offset 4300075008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300111872 ++wrote 4096/4096 bytes at offset 4300111872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300148736 ++wrote 4096/4096 bytes at offset 4300148736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300185600 ++wrote 4096/4096 bytes at offset 4300185600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300222464 ++wrote 4096/4096 bytes at offset 4300222464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300259328 ++wrote 4096/4096 bytes at offset 4300259328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300296192 ++wrote 4096/4096 bytes at offset 4300296192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300333056 ++wrote 4096/4096 bytes at offset 4300333056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300369920 ++wrote 4096/4096 bytes at offset 4300369920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300406784 ++wrote 4096/4096 bytes at offset 4300406784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300443648 ++wrote 4096/4096 bytes at offset 4300443648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300480512 ++wrote 4096/4096 bytes at offset 4300480512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300517376 ++wrote 4096/4096 bytes at offset 4300517376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300554240 ++wrote 4096/4096 bytes at offset 4300554240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300591104 ++wrote 4096/4096 bytes at offset 4300591104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300627968 ++wrote 4096/4096 bytes at offset 4300627968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300664832 ++wrote 4096/4096 bytes at offset 4300664832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300701696 ++wrote 4096/4096 bytes at offset 4300701696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300738560 ++wrote 4096/4096 bytes at offset 4300738560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300775424 ++wrote 4096/4096 bytes at offset 4300775424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300812288 ++wrote 4096/4096 bytes at offset 4300812288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300849152 ++wrote 4096/4096 bytes at offset 4300849152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300886016 ++wrote 4096/4096 bytes at offset 4300886016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300922880 ++wrote 4096/4096 bytes at offset 4300922880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300959744 ++wrote 4096/4096 bytes at offset 4300959744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300996608 ++wrote 4096/4096 bytes at offset 4300996608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301033472 ++wrote 4096/4096 bytes at offset 4301033472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301070336 ++wrote 4096/4096 bytes at offset 4301070336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301107200 ++wrote 4096/4096 bytes at offset 4301107200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301144064 ++wrote 4096/4096 bytes at offset 4301144064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301180928 ++wrote 4096/4096 bytes at offset 4301180928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301217792 ++wrote 4096/4096 bytes at offset 4301217792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301254656 ++wrote 4096/4096 bytes at offset 4301254656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301291520 ++wrote 4096/4096 bytes at offset 4301291520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301328384 ++wrote 4096/4096 bytes at offset 4301328384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301365248 ++wrote 4096/4096 bytes at offset 4301365248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301402112 ++wrote 4096/4096 bytes at offset 4301402112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301438976 ++wrote 4096/4096 bytes at offset 4301438976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301475840 ++wrote 4096/4096 bytes at offset 4301475840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301512704 ++wrote 4096/4096 bytes at offset 4301512704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301549568 ++wrote 4096/4096 bytes at offset 4301549568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301586432 ++wrote 4096/4096 bytes at offset 4301586432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301623296 ++wrote 4096/4096 bytes at offset 4301623296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301660160 ++wrote 4096/4096 bytes at offset 4301660160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301697024 ++wrote 4096/4096 bytes at offset 4301697024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301733888 ++wrote 4096/4096 bytes at offset 4301733888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301770752 ++wrote 4096/4096 bytes at offset 4301770752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301807616 ++wrote 4096/4096 bytes at offset 4301807616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301844480 ++wrote 4096/4096 bytes at offset 4301844480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301881344 ++wrote 4096/4096 bytes at offset 4301881344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301918208 ++wrote 4096/4096 bytes at offset 4301918208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301955072 ++wrote 4096/4096 bytes at offset 4301955072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301991936 ++wrote 4096/4096 bytes at offset 4301991936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302028800 ++wrote 4096/4096 bytes at offset 4302028800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302065664 ++wrote 4096/4096 bytes at offset 4302065664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302102528 ++wrote 4096/4096 bytes at offset 4302102528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302139392 ++wrote 4096/4096 bytes at offset 4302139392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302176256 ++wrote 4096/4096 bytes at offset 4302176256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302213120 ++wrote 4096/4096 bytes at offset 4302213120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302249984 ++wrote 4096/4096 bytes at offset 4302249984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302286848 ++wrote 4096/4096 bytes at offset 4302286848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302323712 ++wrote 4096/4096 bytes at offset 4302323712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302360576 ++wrote 4096/4096 bytes at offset 4302360576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302397440 ++wrote 4096/4096 bytes at offset 4302397440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302434304 ++wrote 4096/4096 bytes at offset 4302434304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302471168 ++wrote 4096/4096 bytes at offset 4302471168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302508032 ++wrote 4096/4096 bytes at offset 4302508032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302544896 ++wrote 4096/4096 bytes at offset 4302544896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302581760 ++wrote 4096/4096 bytes at offset 4302581760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302618624 ++wrote 4096/4096 bytes at offset 4302618624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302655488 ++wrote 4096/4096 bytes at offset 4302655488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302692352 ++wrote 4096/4096 bytes at offset 4302692352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302729216 ++wrote 4096/4096 bytes at offset 4302729216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302766080 ++wrote 4096/4096 bytes at offset 4302766080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302802944 ++wrote 4096/4096 bytes at offset 4302802944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302839808 ++wrote 4096/4096 bytes at offset 4302839808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302876672 ++wrote 4096/4096 bytes at offset 4302876672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302913536 ++wrote 4096/4096 bytes at offset 4302913536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302950400 ++wrote 4096/4096 bytes at offset 4302950400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302987264 ++wrote 4096/4096 bytes at offset 4302987264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303024128 ++wrote 4096/4096 bytes at offset 4303024128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303060992 ++wrote 4096/4096 bytes at offset 4303060992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303097856 ++wrote 4096/4096 bytes at offset 4303097856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303134720 ++wrote 4096/4096 bytes at offset 4303134720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303171584 ++wrote 4096/4096 bytes at offset 4303171584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303208448 ++wrote 4096/4096 bytes at offset 4303208448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303245312 ++wrote 4096/4096 bytes at offset 4303245312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303282176 ++wrote 4096/4096 bytes at offset 4303282176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303319040 ++wrote 4096/4096 bytes at offset 4303319040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303355904 ++wrote 4096/4096 bytes at offset 4303355904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303392768 ++wrote 4096/4096 bytes at offset 4303392768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303429632 ++wrote 4096/4096 bytes at offset 4303429632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303466496 ++wrote 4096/4096 bytes at offset 4303466496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303503360 ++wrote 4096/4096 bytes at offset 4303503360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303540224 ++wrote 4096/4096 bytes at offset 4303540224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303577088 ++wrote 4096/4096 bytes at offset 4303577088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303613952 ++wrote 4096/4096 bytes at offset 4303613952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303650816 ++wrote 4096/4096 bytes at offset 4303650816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303687680 ++wrote 4096/4096 bytes at offset 4303687680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303724544 ++wrote 4096/4096 bytes at offset 4303724544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303761408 ++wrote 4096/4096 bytes at offset 4303761408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303798272 ++wrote 4096/4096 bytes at offset 4303798272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303835136 ++wrote 4096/4096 bytes at offset 4303835136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303872000 ++wrote 4096/4096 bytes at offset 4303872000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303908864 ++wrote 4096/4096 bytes at offset 4303908864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303945728 ++wrote 4096/4096 bytes at offset 4303945728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303982592 ++wrote 4096/4096 bytes at offset 4303982592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4304019456 ++wrote 4096/4096 bytes at offset 4304019456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4304056320 ++wrote 4096/4096 bytes at offset 4304056320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4304093184 ++wrote 4096/4096 bytes at offset 4304093184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4304130048 ++wrote 4096/4096 bytes at offset 4304130048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4304166912 ++wrote 4096/4096 bytes at offset 4304166912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4304203776 ++wrote 4096/4096 bytes at offset 4304203776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4304240640 ++wrote 4096/4096 bytes at offset 4304240640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4304277504 ++wrote 4096/4096 bytes at offset 4304277504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4304314368 ++wrote 4096/4096 bytes at offset 4304314368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4304351232 ++wrote 4096/4096 bytes at offset 4304351232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4304388096 ++wrote 4096/4096 bytes at offset 4304388096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === Clusters to be compressed [3] ++=== Clusters to be compressed [3] + === IO: pattern 165 +-qemu-io> wrote 4096/4096 bytes at offset 4295000064 ++wrote 4096/4096 bytes at offset 4295000064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295036928 ++wrote 4096/4096 bytes at offset 4295036928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295073792 ++wrote 4096/4096 bytes at offset 4295073792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295110656 ++wrote 4096/4096 bytes at offset 4295110656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295147520 ++wrote 4096/4096 bytes at offset 4295147520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295184384 ++wrote 4096/4096 bytes at offset 4295184384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295221248 ++wrote 4096/4096 bytes at offset 4295221248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295258112 ++wrote 4096/4096 bytes at offset 4295258112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295294976 ++wrote 4096/4096 bytes at offset 4295294976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295331840 ++wrote 4096/4096 bytes at offset 4295331840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295368704 ++wrote 4096/4096 bytes at offset 4295368704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295405568 ++wrote 4096/4096 bytes at offset 4295405568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295442432 ++wrote 4096/4096 bytes at offset 4295442432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295479296 ++wrote 4096/4096 bytes at offset 4295479296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295516160 ++wrote 4096/4096 bytes at offset 4295516160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295553024 ++wrote 4096/4096 bytes at offset 4295553024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295589888 ++wrote 4096/4096 bytes at offset 4295589888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295626752 ++wrote 4096/4096 bytes at offset 4295626752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295663616 ++wrote 4096/4096 bytes at offset 4295663616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295700480 ++wrote 4096/4096 bytes at offset 4295700480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295737344 ++wrote 4096/4096 bytes at offset 4295737344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295774208 ++wrote 4096/4096 bytes at offset 4295774208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295811072 ++wrote 4096/4096 bytes at offset 4295811072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295847936 ++wrote 4096/4096 bytes at offset 4295847936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295884800 ++wrote 4096/4096 bytes at offset 4295884800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295921664 ++wrote 4096/4096 bytes at offset 4295921664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295958528 ++wrote 4096/4096 bytes at offset 4295958528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295995392 ++wrote 4096/4096 bytes at offset 4295995392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296032256 ++wrote 4096/4096 bytes at offset 4296032256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296069120 ++wrote 4096/4096 bytes at offset 4296069120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296105984 ++wrote 4096/4096 bytes at offset 4296105984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296142848 ++wrote 4096/4096 bytes at offset 4296142848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296179712 ++wrote 4096/4096 bytes at offset 4296179712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296216576 ++wrote 4096/4096 bytes at offset 4296216576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296253440 ++wrote 4096/4096 bytes at offset 4296253440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296290304 ++wrote 4096/4096 bytes at offset 4296290304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296327168 ++wrote 4096/4096 bytes at offset 4296327168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296364032 ++wrote 4096/4096 bytes at offset 4296364032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296400896 ++wrote 4096/4096 bytes at offset 4296400896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296437760 ++wrote 4096/4096 bytes at offset 4296437760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296474624 ++wrote 4096/4096 bytes at offset 4296474624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296511488 ++wrote 4096/4096 bytes at offset 4296511488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296548352 ++wrote 4096/4096 bytes at offset 4296548352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296585216 ++wrote 4096/4096 bytes at offset 4296585216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296622080 ++wrote 4096/4096 bytes at offset 4296622080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296658944 ++wrote 4096/4096 bytes at offset 4296658944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296695808 ++wrote 4096/4096 bytes at offset 4296695808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296732672 ++wrote 4096/4096 bytes at offset 4296732672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296769536 ++wrote 4096/4096 bytes at offset 4296769536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296806400 ++wrote 4096/4096 bytes at offset 4296806400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296843264 ++wrote 4096/4096 bytes at offset 4296843264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296880128 ++wrote 4096/4096 bytes at offset 4296880128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296916992 ++wrote 4096/4096 bytes at offset 4296916992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296953856 ++wrote 4096/4096 bytes at offset 4296953856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296990720 ++wrote 4096/4096 bytes at offset 4296990720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297027584 ++wrote 4096/4096 bytes at offset 4297027584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297064448 ++wrote 4096/4096 bytes at offset 4297064448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297101312 ++wrote 4096/4096 bytes at offset 4297101312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297138176 ++wrote 4096/4096 bytes at offset 4297138176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297175040 ++wrote 4096/4096 bytes at offset 4297175040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297211904 ++wrote 4096/4096 bytes at offset 4297211904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297248768 ++wrote 4096/4096 bytes at offset 4297248768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297285632 ++wrote 4096/4096 bytes at offset 4297285632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297322496 ++wrote 4096/4096 bytes at offset 4297322496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297359360 ++wrote 4096/4096 bytes at offset 4297359360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297396224 ++wrote 4096/4096 bytes at offset 4297396224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297433088 ++wrote 4096/4096 bytes at offset 4297433088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297469952 ++wrote 4096/4096 bytes at offset 4297469952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297506816 ++wrote 4096/4096 bytes at offset 4297506816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297543680 ++wrote 4096/4096 bytes at offset 4297543680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297580544 ++wrote 4096/4096 bytes at offset 4297580544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297617408 ++wrote 4096/4096 bytes at offset 4297617408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297654272 ++wrote 4096/4096 bytes at offset 4297654272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297691136 ++wrote 4096/4096 bytes at offset 4297691136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297728000 ++wrote 4096/4096 bytes at offset 4297728000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297764864 ++wrote 4096/4096 bytes at offset 4297764864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297801728 ++wrote 4096/4096 bytes at offset 4297801728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297838592 ++wrote 4096/4096 bytes at offset 4297838592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297875456 ++wrote 4096/4096 bytes at offset 4297875456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297912320 ++wrote 4096/4096 bytes at offset 4297912320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297949184 ++wrote 4096/4096 bytes at offset 4297949184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297986048 ++wrote 4096/4096 bytes at offset 4297986048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298022912 ++wrote 4096/4096 bytes at offset 4298022912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298059776 ++wrote 4096/4096 bytes at offset 4298059776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298096640 ++wrote 4096/4096 bytes at offset 4298096640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298133504 ++wrote 4096/4096 bytes at offset 4298133504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298170368 ++wrote 4096/4096 bytes at offset 4298170368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298207232 ++wrote 4096/4096 bytes at offset 4298207232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298244096 ++wrote 4096/4096 bytes at offset 4298244096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298280960 ++wrote 4096/4096 bytes at offset 4298280960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298317824 ++wrote 4096/4096 bytes at offset 4298317824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298354688 ++wrote 4096/4096 bytes at offset 4298354688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298391552 ++wrote 4096/4096 bytes at offset 4298391552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298428416 ++wrote 4096/4096 bytes at offset 4298428416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298465280 ++wrote 4096/4096 bytes at offset 4298465280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298502144 ++wrote 4096/4096 bytes at offset 4298502144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298539008 ++wrote 4096/4096 bytes at offset 4298539008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298575872 ++wrote 4096/4096 bytes at offset 4298575872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298612736 ++wrote 4096/4096 bytes at offset 4298612736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298649600 ++wrote 4096/4096 bytes at offset 4298649600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298686464 ++wrote 4096/4096 bytes at offset 4298686464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298723328 ++wrote 4096/4096 bytes at offset 4298723328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298760192 ++wrote 4096/4096 bytes at offset 4298760192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298797056 ++wrote 4096/4096 bytes at offset 4298797056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298833920 ++wrote 4096/4096 bytes at offset 4298833920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298870784 ++wrote 4096/4096 bytes at offset 4298870784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298907648 ++wrote 4096/4096 bytes at offset 4298907648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298944512 ++wrote 4096/4096 bytes at offset 4298944512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298981376 ++wrote 4096/4096 bytes at offset 4298981376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299018240 ++wrote 4096/4096 bytes at offset 4299018240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299055104 ++wrote 4096/4096 bytes at offset 4299055104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299091968 ++wrote 4096/4096 bytes at offset 4299091968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299128832 ++wrote 4096/4096 bytes at offset 4299128832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299165696 ++wrote 4096/4096 bytes at offset 4299165696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299202560 ++wrote 4096/4096 bytes at offset 4299202560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299239424 ++wrote 4096/4096 bytes at offset 4299239424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299276288 ++wrote 4096/4096 bytes at offset 4299276288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299313152 ++wrote 4096/4096 bytes at offset 4299313152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299350016 ++wrote 4096/4096 bytes at offset 4299350016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299386880 ++wrote 4096/4096 bytes at offset 4299386880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299423744 ++wrote 4096/4096 bytes at offset 4299423744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299460608 ++wrote 4096/4096 bytes at offset 4299460608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299497472 ++wrote 4096/4096 bytes at offset 4299497472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299534336 ++wrote 4096/4096 bytes at offset 4299534336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299571200 ++wrote 4096/4096 bytes at offset 4299571200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299608064 ++wrote 4096/4096 bytes at offset 4299608064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299644928 ++wrote 4096/4096 bytes at offset 4299644928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299681792 ++wrote 4096/4096 bytes at offset 4299681792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299718656 ++wrote 4096/4096 bytes at offset 4299718656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299755520 ++wrote 4096/4096 bytes at offset 4299755520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299792384 ++wrote 4096/4096 bytes at offset 4299792384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299829248 ++wrote 4096/4096 bytes at offset 4299829248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299866112 ++wrote 4096/4096 bytes at offset 4299866112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299902976 ++wrote 4096/4096 bytes at offset 4299902976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299939840 ++wrote 4096/4096 bytes at offset 4299939840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299976704 ++wrote 4096/4096 bytes at offset 4299976704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300013568 ++wrote 4096/4096 bytes at offset 4300013568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300050432 ++wrote 4096/4096 bytes at offset 4300050432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300087296 ++wrote 4096/4096 bytes at offset 4300087296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300124160 ++wrote 4096/4096 bytes at offset 4300124160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300161024 ++wrote 4096/4096 bytes at offset 4300161024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300197888 ++wrote 4096/4096 bytes at offset 4300197888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300234752 ++wrote 4096/4096 bytes at offset 4300234752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300271616 ++wrote 4096/4096 bytes at offset 4300271616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300308480 ++wrote 4096/4096 bytes at offset 4300308480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300345344 ++wrote 4096/4096 bytes at offset 4300345344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300382208 ++wrote 4096/4096 bytes at offset 4300382208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300419072 ++wrote 4096/4096 bytes at offset 4300419072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300455936 ++wrote 4096/4096 bytes at offset 4300455936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300492800 ++wrote 4096/4096 bytes at offset 4300492800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300529664 ++wrote 4096/4096 bytes at offset 4300529664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300566528 ++wrote 4096/4096 bytes at offset 4300566528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300603392 ++wrote 4096/4096 bytes at offset 4300603392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300640256 ++wrote 4096/4096 bytes at offset 4300640256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300677120 ++wrote 4096/4096 bytes at offset 4300677120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300713984 ++wrote 4096/4096 bytes at offset 4300713984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300750848 ++wrote 4096/4096 bytes at offset 4300750848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300787712 ++wrote 4096/4096 bytes at offset 4300787712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300824576 ++wrote 4096/4096 bytes at offset 4300824576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300861440 ++wrote 4096/4096 bytes at offset 4300861440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300898304 ++wrote 4096/4096 bytes at offset 4300898304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300935168 ++wrote 4096/4096 bytes at offset 4300935168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300972032 ++wrote 4096/4096 bytes at offset 4300972032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301008896 ++wrote 4096/4096 bytes at offset 4301008896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301045760 ++wrote 4096/4096 bytes at offset 4301045760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301082624 ++wrote 4096/4096 bytes at offset 4301082624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301119488 ++wrote 4096/4096 bytes at offset 4301119488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301156352 ++wrote 4096/4096 bytes at offset 4301156352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301193216 ++wrote 4096/4096 bytes at offset 4301193216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301230080 ++wrote 4096/4096 bytes at offset 4301230080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301266944 ++wrote 4096/4096 bytes at offset 4301266944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301303808 ++wrote 4096/4096 bytes at offset 4301303808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301340672 ++wrote 4096/4096 bytes at offset 4301340672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301377536 ++wrote 4096/4096 bytes at offset 4301377536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301414400 ++wrote 4096/4096 bytes at offset 4301414400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301451264 ++wrote 4096/4096 bytes at offset 4301451264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301488128 ++wrote 4096/4096 bytes at offset 4301488128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301524992 ++wrote 4096/4096 bytes at offset 4301524992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301561856 ++wrote 4096/4096 bytes at offset 4301561856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301598720 ++wrote 4096/4096 bytes at offset 4301598720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301635584 ++wrote 4096/4096 bytes at offset 4301635584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301672448 ++wrote 4096/4096 bytes at offset 4301672448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301709312 ++wrote 4096/4096 bytes at offset 4301709312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301746176 ++wrote 4096/4096 bytes at offset 4301746176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301783040 ++wrote 4096/4096 bytes at offset 4301783040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301819904 ++wrote 4096/4096 bytes at offset 4301819904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301856768 ++wrote 4096/4096 bytes at offset 4301856768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301893632 ++wrote 4096/4096 bytes at offset 4301893632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301930496 ++wrote 4096/4096 bytes at offset 4301930496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301967360 ++wrote 4096/4096 bytes at offset 4301967360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302004224 ++wrote 4096/4096 bytes at offset 4302004224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302041088 ++wrote 4096/4096 bytes at offset 4302041088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302077952 ++wrote 4096/4096 bytes at offset 4302077952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302114816 ++wrote 4096/4096 bytes at offset 4302114816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302151680 ++wrote 4096/4096 bytes at offset 4302151680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302188544 ++wrote 4096/4096 bytes at offset 4302188544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302225408 ++wrote 4096/4096 bytes at offset 4302225408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302262272 ++wrote 4096/4096 bytes at offset 4302262272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302299136 ++wrote 4096/4096 bytes at offset 4302299136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302336000 ++wrote 4096/4096 bytes at offset 4302336000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302372864 ++wrote 4096/4096 bytes at offset 4302372864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302409728 ++wrote 4096/4096 bytes at offset 4302409728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302446592 ++wrote 4096/4096 bytes at offset 4302446592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302483456 ++wrote 4096/4096 bytes at offset 4302483456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302520320 ++wrote 4096/4096 bytes at offset 4302520320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302557184 ++wrote 4096/4096 bytes at offset 4302557184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302594048 ++wrote 4096/4096 bytes at offset 4302594048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302630912 ++wrote 4096/4096 bytes at offset 4302630912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302667776 ++wrote 4096/4096 bytes at offset 4302667776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302704640 ++wrote 4096/4096 bytes at offset 4302704640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302741504 ++wrote 4096/4096 bytes at offset 4302741504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302778368 ++wrote 4096/4096 bytes at offset 4302778368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302815232 ++wrote 4096/4096 bytes at offset 4302815232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302852096 ++wrote 4096/4096 bytes at offset 4302852096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302888960 ++wrote 4096/4096 bytes at offset 4302888960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302925824 ++wrote 4096/4096 bytes at offset 4302925824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302962688 ++wrote 4096/4096 bytes at offset 4302962688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302999552 ++wrote 4096/4096 bytes at offset 4302999552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303036416 ++wrote 4096/4096 bytes at offset 4303036416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303073280 ++wrote 4096/4096 bytes at offset 4303073280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303110144 ++wrote 4096/4096 bytes at offset 4303110144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303147008 ++wrote 4096/4096 bytes at offset 4303147008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303183872 ++wrote 4096/4096 bytes at offset 4303183872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303220736 ++wrote 4096/4096 bytes at offset 4303220736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303257600 ++wrote 4096/4096 bytes at offset 4303257600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303294464 ++wrote 4096/4096 bytes at offset 4303294464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303331328 ++wrote 4096/4096 bytes at offset 4303331328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303368192 ++wrote 4096/4096 bytes at offset 4303368192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303405056 ++wrote 4096/4096 bytes at offset 4303405056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303441920 ++wrote 4096/4096 bytes at offset 4303441920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303478784 ++wrote 4096/4096 bytes at offset 4303478784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303515648 ++wrote 4096/4096 bytes at offset 4303515648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303552512 ++wrote 4096/4096 bytes at offset 4303552512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303589376 ++wrote 4096/4096 bytes at offset 4303589376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303626240 ++wrote 4096/4096 bytes at offset 4303626240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303663104 ++wrote 4096/4096 bytes at offset 4303663104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303699968 ++wrote 4096/4096 bytes at offset 4303699968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303736832 ++wrote 4096/4096 bytes at offset 4303736832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303773696 ++wrote 4096/4096 bytes at offset 4303773696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303810560 ++wrote 4096/4096 bytes at offset 4303810560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303847424 ++wrote 4096/4096 bytes at offset 4303847424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303884288 ++wrote 4096/4096 bytes at offset 4303884288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303921152 ++wrote 4096/4096 bytes at offset 4303921152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303958016 ++wrote 4096/4096 bytes at offset 4303958016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303994880 ++wrote 4096/4096 bytes at offset 4303994880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4304031744 ++wrote 4096/4096 bytes at offset 4304031744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4304068608 ++wrote 4096/4096 bytes at offset 4304068608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4304105472 ++wrote 4096/4096 bytes at offset 4304105472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4304142336 ++wrote 4096/4096 bytes at offset 4304142336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4304179200 ++wrote 4096/4096 bytes at offset 4304179200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4304216064 ++wrote 4096/4096 bytes at offset 4304216064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4304252928 ++wrote 4096/4096 bytes at offset 4304252928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4304289792 ++wrote 4096/4096 bytes at offset 4304289792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4304326656 ++wrote 4096/4096 bytes at offset 4304326656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4304363520 ++wrote 4096/4096 bytes at offset 4304363520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4304400384 ++wrote 4096/4096 bytes at offset 4304400384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === Used clusters [1] ++=== Used clusters [1] + === IO: pattern 165 +-qemu-io> wrote 4096/4096 bytes at offset 4294967296 ++wrote 4096/4096 bytes at offset 4294967296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295004160 ++wrote 4096/4096 bytes at offset 4295004160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295041024 ++wrote 4096/4096 bytes at offset 4295041024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295077888 ++wrote 4096/4096 bytes at offset 4295077888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295114752 ++wrote 4096/4096 bytes at offset 4295114752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295151616 ++wrote 4096/4096 bytes at offset 4295151616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295188480 ++wrote 4096/4096 bytes at offset 4295188480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295225344 ++wrote 4096/4096 bytes at offset 4295225344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295262208 ++wrote 4096/4096 bytes at offset 4295262208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295299072 ++wrote 4096/4096 bytes at offset 4295299072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295335936 ++wrote 4096/4096 bytes at offset 4295335936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295372800 ++wrote 4096/4096 bytes at offset 4295372800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295409664 ++wrote 4096/4096 bytes at offset 4295409664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295446528 ++wrote 4096/4096 bytes at offset 4295446528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295483392 ++wrote 4096/4096 bytes at offset 4295483392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295520256 ++wrote 4096/4096 bytes at offset 4295520256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295557120 ++wrote 4096/4096 bytes at offset 4295557120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295593984 ++wrote 4096/4096 bytes at offset 4295593984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295630848 ++wrote 4096/4096 bytes at offset 4295630848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295667712 ++wrote 4096/4096 bytes at offset 4295667712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295704576 ++wrote 4096/4096 bytes at offset 4295704576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295741440 ++wrote 4096/4096 bytes at offset 4295741440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295778304 ++wrote 4096/4096 bytes at offset 4295778304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295815168 ++wrote 4096/4096 bytes at offset 4295815168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295852032 ++wrote 4096/4096 bytes at offset 4295852032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295888896 ++wrote 4096/4096 bytes at offset 4295888896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295925760 ++wrote 4096/4096 bytes at offset 4295925760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295962624 ++wrote 4096/4096 bytes at offset 4295962624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295999488 ++wrote 4096/4096 bytes at offset 4295999488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296036352 ++wrote 4096/4096 bytes at offset 4296036352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296073216 ++wrote 4096/4096 bytes at offset 4296073216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296110080 ++wrote 4096/4096 bytes at offset 4296110080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296146944 ++wrote 4096/4096 bytes at offset 4296146944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296183808 ++wrote 4096/4096 bytes at offset 4296183808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296220672 ++wrote 4096/4096 bytes at offset 4296220672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296257536 ++wrote 4096/4096 bytes at offset 4296257536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296294400 ++wrote 4096/4096 bytes at offset 4296294400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296331264 ++wrote 4096/4096 bytes at offset 4296331264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296368128 ++wrote 4096/4096 bytes at offset 4296368128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296404992 ++wrote 4096/4096 bytes at offset 4296404992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296441856 ++wrote 4096/4096 bytes at offset 4296441856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296478720 ++wrote 4096/4096 bytes at offset 4296478720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296515584 ++wrote 4096/4096 bytes at offset 4296515584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296552448 ++wrote 4096/4096 bytes at offset 4296552448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296589312 ++wrote 4096/4096 bytes at offset 4296589312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296626176 ++wrote 4096/4096 bytes at offset 4296626176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296663040 ++wrote 4096/4096 bytes at offset 4296663040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296699904 ++wrote 4096/4096 bytes at offset 4296699904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296736768 ++wrote 4096/4096 bytes at offset 4296736768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296773632 ++wrote 4096/4096 bytes at offset 4296773632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296810496 ++wrote 4096/4096 bytes at offset 4296810496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296847360 ++wrote 4096/4096 bytes at offset 4296847360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296884224 ++wrote 4096/4096 bytes at offset 4296884224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296921088 ++wrote 4096/4096 bytes at offset 4296921088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296957952 ++wrote 4096/4096 bytes at offset 4296957952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296994816 ++wrote 4096/4096 bytes at offset 4296994816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297031680 ++wrote 4096/4096 bytes at offset 4297031680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297068544 ++wrote 4096/4096 bytes at offset 4297068544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297105408 ++wrote 4096/4096 bytes at offset 4297105408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297142272 ++wrote 4096/4096 bytes at offset 4297142272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297179136 ++wrote 4096/4096 bytes at offset 4297179136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297216000 ++wrote 4096/4096 bytes at offset 4297216000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297252864 ++wrote 4096/4096 bytes at offset 4297252864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297289728 ++wrote 4096/4096 bytes at offset 4297289728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297326592 ++wrote 4096/4096 bytes at offset 4297326592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297363456 ++wrote 4096/4096 bytes at offset 4297363456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297400320 ++wrote 4096/4096 bytes at offset 4297400320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297437184 ++wrote 4096/4096 bytes at offset 4297437184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297474048 ++wrote 4096/4096 bytes at offset 4297474048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297510912 ++wrote 4096/4096 bytes at offset 4297510912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297547776 ++wrote 4096/4096 bytes at offset 4297547776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297584640 ++wrote 4096/4096 bytes at offset 4297584640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297621504 ++wrote 4096/4096 bytes at offset 4297621504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297658368 ++wrote 4096/4096 bytes at offset 4297658368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297695232 ++wrote 4096/4096 bytes at offset 4297695232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297732096 ++wrote 4096/4096 bytes at offset 4297732096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297768960 ++wrote 4096/4096 bytes at offset 4297768960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297805824 ++wrote 4096/4096 bytes at offset 4297805824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297842688 ++wrote 4096/4096 bytes at offset 4297842688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297879552 ++wrote 4096/4096 bytes at offset 4297879552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297916416 ++wrote 4096/4096 bytes at offset 4297916416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297953280 ++wrote 4096/4096 bytes at offset 4297953280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297990144 ++wrote 4096/4096 bytes at offset 4297990144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298027008 ++wrote 4096/4096 bytes at offset 4298027008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298063872 ++wrote 4096/4096 bytes at offset 4298063872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298100736 ++wrote 4096/4096 bytes at offset 4298100736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298137600 ++wrote 4096/4096 bytes at offset 4298137600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298174464 ++wrote 4096/4096 bytes at offset 4298174464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298211328 ++wrote 4096/4096 bytes at offset 4298211328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298248192 ++wrote 4096/4096 bytes at offset 4298248192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298285056 ++wrote 4096/4096 bytes at offset 4298285056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298321920 ++wrote 4096/4096 bytes at offset 4298321920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298358784 ++wrote 4096/4096 bytes at offset 4298358784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298395648 ++wrote 4096/4096 bytes at offset 4298395648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298432512 ++wrote 4096/4096 bytes at offset 4298432512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298469376 ++wrote 4096/4096 bytes at offset 4298469376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298506240 ++wrote 4096/4096 bytes at offset 4298506240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298543104 ++wrote 4096/4096 bytes at offset 4298543104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298579968 ++wrote 4096/4096 bytes at offset 4298579968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298616832 ++wrote 4096/4096 bytes at offset 4298616832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298653696 ++wrote 4096/4096 bytes at offset 4298653696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298690560 ++wrote 4096/4096 bytes at offset 4298690560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298727424 ++wrote 4096/4096 bytes at offset 4298727424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298764288 ++wrote 4096/4096 bytes at offset 4298764288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298801152 ++wrote 4096/4096 bytes at offset 4298801152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298838016 ++wrote 4096/4096 bytes at offset 4298838016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298874880 ++wrote 4096/4096 bytes at offset 4298874880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298911744 ++wrote 4096/4096 bytes at offset 4298911744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298948608 ++wrote 4096/4096 bytes at offset 4298948608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298985472 ++wrote 4096/4096 bytes at offset 4298985472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299022336 ++wrote 4096/4096 bytes at offset 4299022336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299059200 ++wrote 4096/4096 bytes at offset 4299059200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299096064 ++wrote 4096/4096 bytes at offset 4299096064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299132928 ++wrote 4096/4096 bytes at offset 4299132928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299169792 ++wrote 4096/4096 bytes at offset 4299169792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299206656 ++wrote 4096/4096 bytes at offset 4299206656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299243520 ++wrote 4096/4096 bytes at offset 4299243520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299280384 ++wrote 4096/4096 bytes at offset 4299280384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299317248 ++wrote 4096/4096 bytes at offset 4299317248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299354112 ++wrote 4096/4096 bytes at offset 4299354112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299390976 ++wrote 4096/4096 bytes at offset 4299390976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299427840 ++wrote 4096/4096 bytes at offset 4299427840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299464704 ++wrote 4096/4096 bytes at offset 4299464704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299501568 ++wrote 4096/4096 bytes at offset 4299501568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299538432 ++wrote 4096/4096 bytes at offset 4299538432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299575296 ++wrote 4096/4096 bytes at offset 4299575296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299612160 ++wrote 4096/4096 bytes at offset 4299612160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299649024 ++wrote 4096/4096 bytes at offset 4299649024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299685888 ++wrote 4096/4096 bytes at offset 4299685888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299722752 ++wrote 4096/4096 bytes at offset 4299722752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299759616 ++wrote 4096/4096 bytes at offset 4299759616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299796480 ++wrote 4096/4096 bytes at offset 4299796480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299833344 ++wrote 4096/4096 bytes at offset 4299833344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299870208 ++wrote 4096/4096 bytes at offset 4299870208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299907072 ++wrote 4096/4096 bytes at offset 4299907072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299943936 ++wrote 4096/4096 bytes at offset 4299943936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299980800 ++wrote 4096/4096 bytes at offset 4299980800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300017664 ++wrote 4096/4096 bytes at offset 4300017664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300054528 ++wrote 4096/4096 bytes at offset 4300054528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300091392 ++wrote 4096/4096 bytes at offset 4300091392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300128256 ++wrote 4096/4096 bytes at offset 4300128256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300165120 ++wrote 4096/4096 bytes at offset 4300165120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300201984 ++wrote 4096/4096 bytes at offset 4300201984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300238848 ++wrote 4096/4096 bytes at offset 4300238848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300275712 ++wrote 4096/4096 bytes at offset 4300275712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300312576 ++wrote 4096/4096 bytes at offset 4300312576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300349440 ++wrote 4096/4096 bytes at offset 4300349440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300386304 ++wrote 4096/4096 bytes at offset 4300386304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300423168 ++wrote 4096/4096 bytes at offset 4300423168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300460032 ++wrote 4096/4096 bytes at offset 4300460032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300496896 ++wrote 4096/4096 bytes at offset 4300496896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300533760 ++wrote 4096/4096 bytes at offset 4300533760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300570624 ++wrote 4096/4096 bytes at offset 4300570624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300607488 ++wrote 4096/4096 bytes at offset 4300607488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300644352 ++wrote 4096/4096 bytes at offset 4300644352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300681216 ++wrote 4096/4096 bytes at offset 4300681216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300718080 ++wrote 4096/4096 bytes at offset 4300718080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300754944 ++wrote 4096/4096 bytes at offset 4300754944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300791808 ++wrote 4096/4096 bytes at offset 4300791808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300828672 ++wrote 4096/4096 bytes at offset 4300828672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300865536 ++wrote 4096/4096 bytes at offset 4300865536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300902400 ++wrote 4096/4096 bytes at offset 4300902400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300939264 ++wrote 4096/4096 bytes at offset 4300939264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300976128 ++wrote 4096/4096 bytes at offset 4300976128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301012992 ++wrote 4096/4096 bytes at offset 4301012992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301049856 ++wrote 4096/4096 bytes at offset 4301049856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301086720 ++wrote 4096/4096 bytes at offset 4301086720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301123584 ++wrote 4096/4096 bytes at offset 4301123584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301160448 ++wrote 4096/4096 bytes at offset 4301160448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301197312 ++wrote 4096/4096 bytes at offset 4301197312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301234176 ++wrote 4096/4096 bytes at offset 4301234176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301271040 ++wrote 4096/4096 bytes at offset 4301271040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301307904 ++wrote 4096/4096 bytes at offset 4301307904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301344768 ++wrote 4096/4096 bytes at offset 4301344768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301381632 ++wrote 4096/4096 bytes at offset 4301381632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301418496 ++wrote 4096/4096 bytes at offset 4301418496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301455360 ++wrote 4096/4096 bytes at offset 4301455360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301492224 ++wrote 4096/4096 bytes at offset 4301492224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301529088 ++wrote 4096/4096 bytes at offset 4301529088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301565952 ++wrote 4096/4096 bytes at offset 4301565952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301602816 ++wrote 4096/4096 bytes at offset 4301602816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301639680 ++wrote 4096/4096 bytes at offset 4301639680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301676544 ++wrote 4096/4096 bytes at offset 4301676544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301713408 ++wrote 4096/4096 bytes at offset 4301713408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301750272 ++wrote 4096/4096 bytes at offset 4301750272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301787136 ++wrote 4096/4096 bytes at offset 4301787136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301824000 ++wrote 4096/4096 bytes at offset 4301824000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301860864 ++wrote 4096/4096 bytes at offset 4301860864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301897728 ++wrote 4096/4096 bytes at offset 4301897728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301934592 ++wrote 4096/4096 bytes at offset 4301934592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301971456 ++wrote 4096/4096 bytes at offset 4301971456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302008320 ++wrote 4096/4096 bytes at offset 4302008320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302045184 ++wrote 4096/4096 bytes at offset 4302045184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302082048 ++wrote 4096/4096 bytes at offset 4302082048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302118912 ++wrote 4096/4096 bytes at offset 4302118912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302155776 ++wrote 4096/4096 bytes at offset 4302155776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302192640 ++wrote 4096/4096 bytes at offset 4302192640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302229504 ++wrote 4096/4096 bytes at offset 4302229504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302266368 ++wrote 4096/4096 bytes at offset 4302266368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302303232 ++wrote 4096/4096 bytes at offset 4302303232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302340096 ++wrote 4096/4096 bytes at offset 4302340096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302376960 ++wrote 4096/4096 bytes at offset 4302376960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302413824 ++wrote 4096/4096 bytes at offset 4302413824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302450688 ++wrote 4096/4096 bytes at offset 4302450688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302487552 ++wrote 4096/4096 bytes at offset 4302487552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302524416 ++wrote 4096/4096 bytes at offset 4302524416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302561280 ++wrote 4096/4096 bytes at offset 4302561280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302598144 ++wrote 4096/4096 bytes at offset 4302598144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302635008 ++wrote 4096/4096 bytes at offset 4302635008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302671872 ++wrote 4096/4096 bytes at offset 4302671872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302708736 ++wrote 4096/4096 bytes at offset 4302708736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302745600 ++wrote 4096/4096 bytes at offset 4302745600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302782464 ++wrote 4096/4096 bytes at offset 4302782464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302819328 ++wrote 4096/4096 bytes at offset 4302819328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302856192 ++wrote 4096/4096 bytes at offset 4302856192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302893056 ++wrote 4096/4096 bytes at offset 4302893056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302929920 ++wrote 4096/4096 bytes at offset 4302929920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302966784 ++wrote 4096/4096 bytes at offset 4302966784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303003648 ++wrote 4096/4096 bytes at offset 4303003648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303040512 ++wrote 4096/4096 bytes at offset 4303040512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303077376 ++wrote 4096/4096 bytes at offset 4303077376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303114240 ++wrote 4096/4096 bytes at offset 4303114240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303151104 ++wrote 4096/4096 bytes at offset 4303151104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303187968 ++wrote 4096/4096 bytes at offset 4303187968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303224832 ++wrote 4096/4096 bytes at offset 4303224832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303261696 ++wrote 4096/4096 bytes at offset 4303261696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303298560 ++wrote 4096/4096 bytes at offset 4303298560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303335424 ++wrote 4096/4096 bytes at offset 4303335424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303372288 ++wrote 4096/4096 bytes at offset 4303372288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303409152 ++wrote 4096/4096 bytes at offset 4303409152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303446016 ++wrote 4096/4096 bytes at offset 4303446016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303482880 ++wrote 4096/4096 bytes at offset 4303482880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303519744 ++wrote 4096/4096 bytes at offset 4303519744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303556608 ++wrote 4096/4096 bytes at offset 4303556608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303593472 ++wrote 4096/4096 bytes at offset 4303593472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303630336 ++wrote 4096/4096 bytes at offset 4303630336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303667200 ++wrote 4096/4096 bytes at offset 4303667200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303704064 ++wrote 4096/4096 bytes at offset 4303704064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303740928 ++wrote 4096/4096 bytes at offset 4303740928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303777792 ++wrote 4096/4096 bytes at offset 4303777792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303814656 ++wrote 4096/4096 bytes at offset 4303814656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303851520 ++wrote 4096/4096 bytes at offset 4303851520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303888384 ++wrote 4096/4096 bytes at offset 4303888384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303925248 ++wrote 4096/4096 bytes at offset 4303925248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303962112 ++wrote 4096/4096 bytes at offset 4303962112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303998976 ++wrote 4096/4096 bytes at offset 4303998976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4304035840 ++wrote 4096/4096 bytes at offset 4304035840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4304072704 ++wrote 4096/4096 bytes at offset 4304072704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4304109568 ++wrote 4096/4096 bytes at offset 4304109568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4304146432 ++wrote 4096/4096 bytes at offset 4304146432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4304183296 ++wrote 4096/4096 bytes at offset 4304183296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4304220160 ++wrote 4096/4096 bytes at offset 4304220160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4304257024 ++wrote 4096/4096 bytes at offset 4304257024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4304293888 ++wrote 4096/4096 bytes at offset 4304293888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4304330752 ++wrote 4096/4096 bytes at offset 4304330752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4304367616 ++wrote 4096/4096 bytes at offset 4304367616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === Used clusters [2] ++=== Used clusters [2] + === IO: pattern 165 +-qemu-io> wrote 4096/4096 bytes at offset 4294971392 ++wrote 4096/4096 bytes at offset 4294971392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295008256 ++wrote 4096/4096 bytes at offset 4295008256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295045120 ++wrote 4096/4096 bytes at offset 4295045120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295081984 ++wrote 4096/4096 bytes at offset 4295081984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295118848 ++wrote 4096/4096 bytes at offset 4295118848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295155712 ++wrote 4096/4096 bytes at offset 4295155712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295192576 ++wrote 4096/4096 bytes at offset 4295192576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295229440 ++wrote 4096/4096 bytes at offset 4295229440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295266304 ++wrote 4096/4096 bytes at offset 4295266304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295303168 ++wrote 4096/4096 bytes at offset 4295303168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295340032 ++wrote 4096/4096 bytes at offset 4295340032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295376896 ++wrote 4096/4096 bytes at offset 4295376896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295413760 ++wrote 4096/4096 bytes at offset 4295413760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295450624 ++wrote 4096/4096 bytes at offset 4295450624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295487488 ++wrote 4096/4096 bytes at offset 4295487488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295524352 ++wrote 4096/4096 bytes at offset 4295524352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295561216 ++wrote 4096/4096 bytes at offset 4295561216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295598080 ++wrote 4096/4096 bytes at offset 4295598080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295634944 ++wrote 4096/4096 bytes at offset 4295634944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295671808 ++wrote 4096/4096 bytes at offset 4295671808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295708672 ++wrote 4096/4096 bytes at offset 4295708672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295745536 ++wrote 4096/4096 bytes at offset 4295745536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295782400 ++wrote 4096/4096 bytes at offset 4295782400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295819264 ++wrote 4096/4096 bytes at offset 4295819264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295856128 ++wrote 4096/4096 bytes at offset 4295856128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295892992 ++wrote 4096/4096 bytes at offset 4295892992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295929856 ++wrote 4096/4096 bytes at offset 4295929856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295966720 ++wrote 4096/4096 bytes at offset 4295966720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296003584 ++wrote 4096/4096 bytes at offset 4296003584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296040448 ++wrote 4096/4096 bytes at offset 4296040448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296077312 ++wrote 4096/4096 bytes at offset 4296077312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296114176 ++wrote 4096/4096 bytes at offset 4296114176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296151040 ++wrote 4096/4096 bytes at offset 4296151040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296187904 ++wrote 4096/4096 bytes at offset 4296187904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296224768 ++wrote 4096/4096 bytes at offset 4296224768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296261632 ++wrote 4096/4096 bytes at offset 4296261632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296298496 ++wrote 4096/4096 bytes at offset 4296298496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296335360 ++wrote 4096/4096 bytes at offset 4296335360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296372224 ++wrote 4096/4096 bytes at offset 4296372224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296409088 ++wrote 4096/4096 bytes at offset 4296409088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296445952 ++wrote 4096/4096 bytes at offset 4296445952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296482816 ++wrote 4096/4096 bytes at offset 4296482816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296519680 ++wrote 4096/4096 bytes at offset 4296519680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296556544 ++wrote 4096/4096 bytes at offset 4296556544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296593408 ++wrote 4096/4096 bytes at offset 4296593408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296630272 ++wrote 4096/4096 bytes at offset 4296630272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296667136 ++wrote 4096/4096 bytes at offset 4296667136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296704000 ++wrote 4096/4096 bytes at offset 4296704000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296740864 ++wrote 4096/4096 bytes at offset 4296740864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296777728 ++wrote 4096/4096 bytes at offset 4296777728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296814592 ++wrote 4096/4096 bytes at offset 4296814592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296851456 ++wrote 4096/4096 bytes at offset 4296851456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296888320 ++wrote 4096/4096 bytes at offset 4296888320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296925184 ++wrote 4096/4096 bytes at offset 4296925184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296962048 ++wrote 4096/4096 bytes at offset 4296962048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296998912 ++wrote 4096/4096 bytes at offset 4296998912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297035776 ++wrote 4096/4096 bytes at offset 4297035776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297072640 ++wrote 4096/4096 bytes at offset 4297072640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297109504 ++wrote 4096/4096 bytes at offset 4297109504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297146368 ++wrote 4096/4096 bytes at offset 4297146368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297183232 ++wrote 4096/4096 bytes at offset 4297183232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297220096 ++wrote 4096/4096 bytes at offset 4297220096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297256960 ++wrote 4096/4096 bytes at offset 4297256960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297293824 ++wrote 4096/4096 bytes at offset 4297293824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297330688 ++wrote 4096/4096 bytes at offset 4297330688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297367552 ++wrote 4096/4096 bytes at offset 4297367552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297404416 ++wrote 4096/4096 bytes at offset 4297404416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297441280 ++wrote 4096/4096 bytes at offset 4297441280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297478144 ++wrote 4096/4096 bytes at offset 4297478144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297515008 ++wrote 4096/4096 bytes at offset 4297515008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297551872 ++wrote 4096/4096 bytes at offset 4297551872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297588736 ++wrote 4096/4096 bytes at offset 4297588736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297625600 ++wrote 4096/4096 bytes at offset 4297625600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297662464 ++wrote 4096/4096 bytes at offset 4297662464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297699328 ++wrote 4096/4096 bytes at offset 4297699328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297736192 ++wrote 4096/4096 bytes at offset 4297736192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297773056 ++wrote 4096/4096 bytes at offset 4297773056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297809920 ++wrote 4096/4096 bytes at offset 4297809920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297846784 ++wrote 4096/4096 bytes at offset 4297846784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297883648 ++wrote 4096/4096 bytes at offset 4297883648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297920512 ++wrote 4096/4096 bytes at offset 4297920512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297957376 ++wrote 4096/4096 bytes at offset 4297957376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297994240 ++wrote 4096/4096 bytes at offset 4297994240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298031104 ++wrote 4096/4096 bytes at offset 4298031104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298067968 ++wrote 4096/4096 bytes at offset 4298067968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298104832 ++wrote 4096/4096 bytes at offset 4298104832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298141696 ++wrote 4096/4096 bytes at offset 4298141696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298178560 ++wrote 4096/4096 bytes at offset 4298178560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298215424 ++wrote 4096/4096 bytes at offset 4298215424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298252288 ++wrote 4096/4096 bytes at offset 4298252288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298289152 ++wrote 4096/4096 bytes at offset 4298289152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298326016 ++wrote 4096/4096 bytes at offset 4298326016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298362880 ++wrote 4096/4096 bytes at offset 4298362880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298399744 ++wrote 4096/4096 bytes at offset 4298399744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298436608 ++wrote 4096/4096 bytes at offset 4298436608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298473472 ++wrote 4096/4096 bytes at offset 4298473472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298510336 ++wrote 4096/4096 bytes at offset 4298510336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298547200 ++wrote 4096/4096 bytes at offset 4298547200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298584064 ++wrote 4096/4096 bytes at offset 4298584064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298620928 ++wrote 4096/4096 bytes at offset 4298620928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298657792 ++wrote 4096/4096 bytes at offset 4298657792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298694656 ++wrote 4096/4096 bytes at offset 4298694656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298731520 ++wrote 4096/4096 bytes at offset 4298731520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298768384 ++wrote 4096/4096 bytes at offset 4298768384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298805248 ++wrote 4096/4096 bytes at offset 4298805248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298842112 ++wrote 4096/4096 bytes at offset 4298842112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298878976 ++wrote 4096/4096 bytes at offset 4298878976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298915840 ++wrote 4096/4096 bytes at offset 4298915840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298952704 ++wrote 4096/4096 bytes at offset 4298952704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298989568 ++wrote 4096/4096 bytes at offset 4298989568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299026432 ++wrote 4096/4096 bytes at offset 4299026432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299063296 ++wrote 4096/4096 bytes at offset 4299063296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299100160 ++wrote 4096/4096 bytes at offset 4299100160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299137024 ++wrote 4096/4096 bytes at offset 4299137024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299173888 ++wrote 4096/4096 bytes at offset 4299173888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299210752 ++wrote 4096/4096 bytes at offset 4299210752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299247616 ++wrote 4096/4096 bytes at offset 4299247616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299284480 ++wrote 4096/4096 bytes at offset 4299284480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299321344 ++wrote 4096/4096 bytes at offset 4299321344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299358208 ++wrote 4096/4096 bytes at offset 4299358208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299395072 ++wrote 4096/4096 bytes at offset 4299395072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299431936 ++wrote 4096/4096 bytes at offset 4299431936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299468800 ++wrote 4096/4096 bytes at offset 4299468800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299505664 ++wrote 4096/4096 bytes at offset 4299505664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299542528 ++wrote 4096/4096 bytes at offset 4299542528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299579392 ++wrote 4096/4096 bytes at offset 4299579392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299616256 ++wrote 4096/4096 bytes at offset 4299616256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299653120 ++wrote 4096/4096 bytes at offset 4299653120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299689984 ++wrote 4096/4096 bytes at offset 4299689984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299726848 ++wrote 4096/4096 bytes at offset 4299726848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299763712 ++wrote 4096/4096 bytes at offset 4299763712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299800576 ++wrote 4096/4096 bytes at offset 4299800576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299837440 ++wrote 4096/4096 bytes at offset 4299837440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299874304 ++wrote 4096/4096 bytes at offset 4299874304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299911168 ++wrote 4096/4096 bytes at offset 4299911168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299948032 ++wrote 4096/4096 bytes at offset 4299948032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299984896 ++wrote 4096/4096 bytes at offset 4299984896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300021760 ++wrote 4096/4096 bytes at offset 4300021760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300058624 ++wrote 4096/4096 bytes at offset 4300058624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300095488 ++wrote 4096/4096 bytes at offset 4300095488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300132352 ++wrote 4096/4096 bytes at offset 4300132352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300169216 ++wrote 4096/4096 bytes at offset 4300169216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300206080 ++wrote 4096/4096 bytes at offset 4300206080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300242944 ++wrote 4096/4096 bytes at offset 4300242944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300279808 ++wrote 4096/4096 bytes at offset 4300279808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300316672 ++wrote 4096/4096 bytes at offset 4300316672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300353536 ++wrote 4096/4096 bytes at offset 4300353536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300390400 ++wrote 4096/4096 bytes at offset 4300390400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300427264 ++wrote 4096/4096 bytes at offset 4300427264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300464128 ++wrote 4096/4096 bytes at offset 4300464128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300500992 ++wrote 4096/4096 bytes at offset 4300500992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300537856 ++wrote 4096/4096 bytes at offset 4300537856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300574720 ++wrote 4096/4096 bytes at offset 4300574720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300611584 ++wrote 4096/4096 bytes at offset 4300611584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300648448 ++wrote 4096/4096 bytes at offset 4300648448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300685312 ++wrote 4096/4096 bytes at offset 4300685312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300722176 ++wrote 4096/4096 bytes at offset 4300722176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300759040 ++wrote 4096/4096 bytes at offset 4300759040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300795904 ++wrote 4096/4096 bytes at offset 4300795904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300832768 ++wrote 4096/4096 bytes at offset 4300832768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300869632 ++wrote 4096/4096 bytes at offset 4300869632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300906496 ++wrote 4096/4096 bytes at offset 4300906496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300943360 ++wrote 4096/4096 bytes at offset 4300943360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300980224 ++wrote 4096/4096 bytes at offset 4300980224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301017088 ++wrote 4096/4096 bytes at offset 4301017088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301053952 ++wrote 4096/4096 bytes at offset 4301053952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301090816 ++wrote 4096/4096 bytes at offset 4301090816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301127680 ++wrote 4096/4096 bytes at offset 4301127680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301164544 ++wrote 4096/4096 bytes at offset 4301164544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301201408 ++wrote 4096/4096 bytes at offset 4301201408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301238272 ++wrote 4096/4096 bytes at offset 4301238272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301275136 ++wrote 4096/4096 bytes at offset 4301275136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301312000 ++wrote 4096/4096 bytes at offset 4301312000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301348864 ++wrote 4096/4096 bytes at offset 4301348864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301385728 ++wrote 4096/4096 bytes at offset 4301385728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301422592 ++wrote 4096/4096 bytes at offset 4301422592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301459456 ++wrote 4096/4096 bytes at offset 4301459456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301496320 ++wrote 4096/4096 bytes at offset 4301496320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301533184 ++wrote 4096/4096 bytes at offset 4301533184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301570048 ++wrote 4096/4096 bytes at offset 4301570048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301606912 ++wrote 4096/4096 bytes at offset 4301606912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301643776 ++wrote 4096/4096 bytes at offset 4301643776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301680640 ++wrote 4096/4096 bytes at offset 4301680640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301717504 ++wrote 4096/4096 bytes at offset 4301717504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301754368 ++wrote 4096/4096 bytes at offset 4301754368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301791232 ++wrote 4096/4096 bytes at offset 4301791232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301828096 ++wrote 4096/4096 bytes at offset 4301828096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301864960 ++wrote 4096/4096 bytes at offset 4301864960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301901824 ++wrote 4096/4096 bytes at offset 4301901824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301938688 ++wrote 4096/4096 bytes at offset 4301938688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301975552 ++wrote 4096/4096 bytes at offset 4301975552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302012416 ++wrote 4096/4096 bytes at offset 4302012416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302049280 ++wrote 4096/4096 bytes at offset 4302049280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302086144 ++wrote 4096/4096 bytes at offset 4302086144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302123008 ++wrote 4096/4096 bytes at offset 4302123008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302159872 ++wrote 4096/4096 bytes at offset 4302159872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302196736 ++wrote 4096/4096 bytes at offset 4302196736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302233600 ++wrote 4096/4096 bytes at offset 4302233600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302270464 ++wrote 4096/4096 bytes at offset 4302270464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302307328 ++wrote 4096/4096 bytes at offset 4302307328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302344192 ++wrote 4096/4096 bytes at offset 4302344192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302381056 ++wrote 4096/4096 bytes at offset 4302381056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302417920 ++wrote 4096/4096 bytes at offset 4302417920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302454784 ++wrote 4096/4096 bytes at offset 4302454784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302491648 ++wrote 4096/4096 bytes at offset 4302491648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302528512 ++wrote 4096/4096 bytes at offset 4302528512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302565376 ++wrote 4096/4096 bytes at offset 4302565376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302602240 ++wrote 4096/4096 bytes at offset 4302602240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302639104 ++wrote 4096/4096 bytes at offset 4302639104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302675968 ++wrote 4096/4096 bytes at offset 4302675968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302712832 ++wrote 4096/4096 bytes at offset 4302712832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302749696 ++wrote 4096/4096 bytes at offset 4302749696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302786560 ++wrote 4096/4096 bytes at offset 4302786560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302823424 ++wrote 4096/4096 bytes at offset 4302823424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302860288 ++wrote 4096/4096 bytes at offset 4302860288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302897152 ++wrote 4096/4096 bytes at offset 4302897152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302934016 ++wrote 4096/4096 bytes at offset 4302934016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302970880 ++wrote 4096/4096 bytes at offset 4302970880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303007744 ++wrote 4096/4096 bytes at offset 4303007744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303044608 ++wrote 4096/4096 bytes at offset 4303044608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303081472 ++wrote 4096/4096 bytes at offset 4303081472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303118336 ++wrote 4096/4096 bytes at offset 4303118336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303155200 ++wrote 4096/4096 bytes at offset 4303155200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303192064 ++wrote 4096/4096 bytes at offset 4303192064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303228928 ++wrote 4096/4096 bytes at offset 4303228928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303265792 ++wrote 4096/4096 bytes at offset 4303265792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303302656 ++wrote 4096/4096 bytes at offset 4303302656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303339520 ++wrote 4096/4096 bytes at offset 4303339520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303376384 ++wrote 4096/4096 bytes at offset 4303376384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303413248 ++wrote 4096/4096 bytes at offset 4303413248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303450112 ++wrote 4096/4096 bytes at offset 4303450112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303486976 ++wrote 4096/4096 bytes at offset 4303486976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303523840 ++wrote 4096/4096 bytes at offset 4303523840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303560704 ++wrote 4096/4096 bytes at offset 4303560704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303597568 ++wrote 4096/4096 bytes at offset 4303597568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303634432 ++wrote 4096/4096 bytes at offset 4303634432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303671296 ++wrote 4096/4096 bytes at offset 4303671296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303708160 ++wrote 4096/4096 bytes at offset 4303708160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303745024 ++wrote 4096/4096 bytes at offset 4303745024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303781888 ++wrote 4096/4096 bytes at offset 4303781888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303818752 ++wrote 4096/4096 bytes at offset 4303818752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303855616 ++wrote 4096/4096 bytes at offset 4303855616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303892480 ++wrote 4096/4096 bytes at offset 4303892480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303929344 ++wrote 4096/4096 bytes at offset 4303929344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303966208 ++wrote 4096/4096 bytes at offset 4303966208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4304003072 ++wrote 4096/4096 bytes at offset 4304003072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4304039936 ++wrote 4096/4096 bytes at offset 4304039936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4304076800 ++wrote 4096/4096 bytes at offset 4304076800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4304113664 ++wrote 4096/4096 bytes at offset 4304113664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4304150528 ++wrote 4096/4096 bytes at offset 4304150528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4304187392 ++wrote 4096/4096 bytes at offset 4304187392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4304224256 ++wrote 4096/4096 bytes at offset 4304224256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4304261120 ++wrote 4096/4096 bytes at offset 4304261120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4304297984 ++wrote 4096/4096 bytes at offset 4304297984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4304334848 ++wrote 4096/4096 bytes at offset 4304334848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4304371712 ++wrote 4096/4096 bytes at offset 4304371712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === Used clusters [3] ++=== Used clusters [3] + === IO: pattern 165 +-qemu-io> wrote 4096/4096 bytes at offset 4294979584 ++wrote 4096/4096 bytes at offset 4294979584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295016448 ++wrote 4096/4096 bytes at offset 4295016448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295053312 ++wrote 4096/4096 bytes at offset 4295053312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295090176 ++wrote 4096/4096 bytes at offset 4295090176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295127040 ++wrote 4096/4096 bytes at offset 4295127040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295163904 ++wrote 4096/4096 bytes at offset 4295163904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295200768 ++wrote 4096/4096 bytes at offset 4295200768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295237632 ++wrote 4096/4096 bytes at offset 4295237632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295274496 ++wrote 4096/4096 bytes at offset 4295274496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295311360 ++wrote 4096/4096 bytes at offset 4295311360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295348224 ++wrote 4096/4096 bytes at offset 4295348224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295385088 ++wrote 4096/4096 bytes at offset 4295385088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295421952 ++wrote 4096/4096 bytes at offset 4295421952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295458816 ++wrote 4096/4096 bytes at offset 4295458816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295495680 ++wrote 4096/4096 bytes at offset 4295495680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295532544 ++wrote 4096/4096 bytes at offset 4295532544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295569408 ++wrote 4096/4096 bytes at offset 4295569408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295606272 ++wrote 4096/4096 bytes at offset 4295606272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295643136 ++wrote 4096/4096 bytes at offset 4295643136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295680000 ++wrote 4096/4096 bytes at offset 4295680000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295716864 ++wrote 4096/4096 bytes at offset 4295716864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295753728 ++wrote 4096/4096 bytes at offset 4295753728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295790592 ++wrote 4096/4096 bytes at offset 4295790592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295827456 ++wrote 4096/4096 bytes at offset 4295827456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295864320 ++wrote 4096/4096 bytes at offset 4295864320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295901184 ++wrote 4096/4096 bytes at offset 4295901184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295938048 ++wrote 4096/4096 bytes at offset 4295938048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295974912 ++wrote 4096/4096 bytes at offset 4295974912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296011776 ++wrote 4096/4096 bytes at offset 4296011776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296048640 ++wrote 4096/4096 bytes at offset 4296048640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296085504 ++wrote 4096/4096 bytes at offset 4296085504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296122368 ++wrote 4096/4096 bytes at offset 4296122368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296159232 ++wrote 4096/4096 bytes at offset 4296159232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296196096 ++wrote 4096/4096 bytes at offset 4296196096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296232960 ++wrote 4096/4096 bytes at offset 4296232960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296269824 ++wrote 4096/4096 bytes at offset 4296269824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296306688 ++wrote 4096/4096 bytes at offset 4296306688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296343552 ++wrote 4096/4096 bytes at offset 4296343552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296380416 ++wrote 4096/4096 bytes at offset 4296380416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296417280 ++wrote 4096/4096 bytes at offset 4296417280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296454144 ++wrote 4096/4096 bytes at offset 4296454144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296491008 ++wrote 4096/4096 bytes at offset 4296491008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296527872 ++wrote 4096/4096 bytes at offset 4296527872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296564736 ++wrote 4096/4096 bytes at offset 4296564736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296601600 ++wrote 4096/4096 bytes at offset 4296601600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296638464 ++wrote 4096/4096 bytes at offset 4296638464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296675328 ++wrote 4096/4096 bytes at offset 4296675328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296712192 ++wrote 4096/4096 bytes at offset 4296712192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296749056 ++wrote 4096/4096 bytes at offset 4296749056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296785920 ++wrote 4096/4096 bytes at offset 4296785920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296822784 ++wrote 4096/4096 bytes at offset 4296822784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296859648 ++wrote 4096/4096 bytes at offset 4296859648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296896512 ++wrote 4096/4096 bytes at offset 4296896512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296933376 ++wrote 4096/4096 bytes at offset 4296933376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296970240 ++wrote 4096/4096 bytes at offset 4296970240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297007104 ++wrote 4096/4096 bytes at offset 4297007104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297043968 ++wrote 4096/4096 bytes at offset 4297043968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297080832 ++wrote 4096/4096 bytes at offset 4297080832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297117696 ++wrote 4096/4096 bytes at offset 4297117696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297154560 ++wrote 4096/4096 bytes at offset 4297154560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297191424 ++wrote 4096/4096 bytes at offset 4297191424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297228288 ++wrote 4096/4096 bytes at offset 4297228288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297265152 ++wrote 4096/4096 bytes at offset 4297265152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297302016 ++wrote 4096/4096 bytes at offset 4297302016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297338880 ++wrote 4096/4096 bytes at offset 4297338880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297375744 ++wrote 4096/4096 bytes at offset 4297375744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297412608 ++wrote 4096/4096 bytes at offset 4297412608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297449472 ++wrote 4096/4096 bytes at offset 4297449472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297486336 ++wrote 4096/4096 bytes at offset 4297486336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297523200 ++wrote 4096/4096 bytes at offset 4297523200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297560064 ++wrote 4096/4096 bytes at offset 4297560064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297596928 ++wrote 4096/4096 bytes at offset 4297596928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297633792 ++wrote 4096/4096 bytes at offset 4297633792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297670656 ++wrote 4096/4096 bytes at offset 4297670656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297707520 ++wrote 4096/4096 bytes at offset 4297707520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297744384 ++wrote 4096/4096 bytes at offset 4297744384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297781248 ++wrote 4096/4096 bytes at offset 4297781248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297818112 ++wrote 4096/4096 bytes at offset 4297818112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297854976 ++wrote 4096/4096 bytes at offset 4297854976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297891840 ++wrote 4096/4096 bytes at offset 4297891840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297928704 ++wrote 4096/4096 bytes at offset 4297928704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4297965568 ++wrote 4096/4096 bytes at offset 4297965568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298002432 ++wrote 4096/4096 bytes at offset 4298002432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298039296 ++wrote 4096/4096 bytes at offset 4298039296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298076160 ++wrote 4096/4096 bytes at offset 4298076160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298113024 ++wrote 4096/4096 bytes at offset 4298113024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298149888 ++wrote 4096/4096 bytes at offset 4298149888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298186752 ++wrote 4096/4096 bytes at offset 4298186752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298223616 ++wrote 4096/4096 bytes at offset 4298223616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298260480 ++wrote 4096/4096 bytes at offset 4298260480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298297344 ++wrote 4096/4096 bytes at offset 4298297344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298334208 ++wrote 4096/4096 bytes at offset 4298334208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298371072 ++wrote 4096/4096 bytes at offset 4298371072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298407936 ++wrote 4096/4096 bytes at offset 4298407936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298444800 ++wrote 4096/4096 bytes at offset 4298444800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298481664 ++wrote 4096/4096 bytes at offset 4298481664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298518528 ++wrote 4096/4096 bytes at offset 4298518528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298555392 ++wrote 4096/4096 bytes at offset 4298555392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298592256 ++wrote 4096/4096 bytes at offset 4298592256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298629120 ++wrote 4096/4096 bytes at offset 4298629120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298665984 ++wrote 4096/4096 bytes at offset 4298665984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298702848 ++wrote 4096/4096 bytes at offset 4298702848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298739712 ++wrote 4096/4096 bytes at offset 4298739712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298776576 ++wrote 4096/4096 bytes at offset 4298776576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298813440 ++wrote 4096/4096 bytes at offset 4298813440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298850304 ++wrote 4096/4096 bytes at offset 4298850304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298887168 ++wrote 4096/4096 bytes at offset 4298887168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298924032 ++wrote 4096/4096 bytes at offset 4298924032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298960896 ++wrote 4096/4096 bytes at offset 4298960896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4298997760 ++wrote 4096/4096 bytes at offset 4298997760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299034624 ++wrote 4096/4096 bytes at offset 4299034624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299071488 ++wrote 4096/4096 bytes at offset 4299071488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299108352 ++wrote 4096/4096 bytes at offset 4299108352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299145216 ++wrote 4096/4096 bytes at offset 4299145216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299182080 ++wrote 4096/4096 bytes at offset 4299182080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299218944 ++wrote 4096/4096 bytes at offset 4299218944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299255808 ++wrote 4096/4096 bytes at offset 4299255808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299292672 ++wrote 4096/4096 bytes at offset 4299292672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299329536 ++wrote 4096/4096 bytes at offset 4299329536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299366400 ++wrote 4096/4096 bytes at offset 4299366400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299403264 ++wrote 4096/4096 bytes at offset 4299403264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299440128 ++wrote 4096/4096 bytes at offset 4299440128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299476992 ++wrote 4096/4096 bytes at offset 4299476992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299513856 ++wrote 4096/4096 bytes at offset 4299513856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299550720 ++wrote 4096/4096 bytes at offset 4299550720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299587584 ++wrote 4096/4096 bytes at offset 4299587584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299624448 ++wrote 4096/4096 bytes at offset 4299624448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299661312 ++wrote 4096/4096 bytes at offset 4299661312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299698176 ++wrote 4096/4096 bytes at offset 4299698176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299735040 ++wrote 4096/4096 bytes at offset 4299735040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299771904 ++wrote 4096/4096 bytes at offset 4299771904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299808768 ++wrote 4096/4096 bytes at offset 4299808768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299845632 ++wrote 4096/4096 bytes at offset 4299845632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299882496 ++wrote 4096/4096 bytes at offset 4299882496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299919360 ++wrote 4096/4096 bytes at offset 4299919360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299956224 ++wrote 4096/4096 bytes at offset 4299956224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4299993088 ++wrote 4096/4096 bytes at offset 4299993088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300029952 ++wrote 4096/4096 bytes at offset 4300029952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300066816 ++wrote 4096/4096 bytes at offset 4300066816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300103680 ++wrote 4096/4096 bytes at offset 4300103680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300140544 ++wrote 4096/4096 bytes at offset 4300140544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300177408 ++wrote 4096/4096 bytes at offset 4300177408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300214272 ++wrote 4096/4096 bytes at offset 4300214272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300251136 ++wrote 4096/4096 bytes at offset 4300251136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300288000 ++wrote 4096/4096 bytes at offset 4300288000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300324864 ++wrote 4096/4096 bytes at offset 4300324864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300361728 ++wrote 4096/4096 bytes at offset 4300361728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300398592 ++wrote 4096/4096 bytes at offset 4300398592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300435456 ++wrote 4096/4096 bytes at offset 4300435456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300472320 ++wrote 4096/4096 bytes at offset 4300472320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300509184 ++wrote 4096/4096 bytes at offset 4300509184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300546048 ++wrote 4096/4096 bytes at offset 4300546048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300582912 ++wrote 4096/4096 bytes at offset 4300582912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300619776 ++wrote 4096/4096 bytes at offset 4300619776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300656640 ++wrote 4096/4096 bytes at offset 4300656640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300693504 ++wrote 4096/4096 bytes at offset 4300693504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300730368 ++wrote 4096/4096 bytes at offset 4300730368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300767232 ++wrote 4096/4096 bytes at offset 4300767232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300804096 ++wrote 4096/4096 bytes at offset 4300804096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300840960 ++wrote 4096/4096 bytes at offset 4300840960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300877824 ++wrote 4096/4096 bytes at offset 4300877824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300914688 ++wrote 4096/4096 bytes at offset 4300914688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300951552 ++wrote 4096/4096 bytes at offset 4300951552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4300988416 ++wrote 4096/4096 bytes at offset 4300988416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301025280 ++wrote 4096/4096 bytes at offset 4301025280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301062144 ++wrote 4096/4096 bytes at offset 4301062144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301099008 ++wrote 4096/4096 bytes at offset 4301099008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301135872 ++wrote 4096/4096 bytes at offset 4301135872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301172736 ++wrote 4096/4096 bytes at offset 4301172736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301209600 ++wrote 4096/4096 bytes at offset 4301209600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301246464 ++wrote 4096/4096 bytes at offset 4301246464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301283328 ++wrote 4096/4096 bytes at offset 4301283328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301320192 ++wrote 4096/4096 bytes at offset 4301320192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301357056 ++wrote 4096/4096 bytes at offset 4301357056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301393920 ++wrote 4096/4096 bytes at offset 4301393920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301430784 ++wrote 4096/4096 bytes at offset 4301430784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301467648 ++wrote 4096/4096 bytes at offset 4301467648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301504512 ++wrote 4096/4096 bytes at offset 4301504512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301541376 ++wrote 4096/4096 bytes at offset 4301541376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301578240 ++wrote 4096/4096 bytes at offset 4301578240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301615104 ++wrote 4096/4096 bytes at offset 4301615104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301651968 ++wrote 4096/4096 bytes at offset 4301651968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301688832 ++wrote 4096/4096 bytes at offset 4301688832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301725696 ++wrote 4096/4096 bytes at offset 4301725696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301762560 ++wrote 4096/4096 bytes at offset 4301762560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301799424 ++wrote 4096/4096 bytes at offset 4301799424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301836288 ++wrote 4096/4096 bytes at offset 4301836288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301873152 ++wrote 4096/4096 bytes at offset 4301873152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301910016 ++wrote 4096/4096 bytes at offset 4301910016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301946880 ++wrote 4096/4096 bytes at offset 4301946880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4301983744 ++wrote 4096/4096 bytes at offset 4301983744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302020608 ++wrote 4096/4096 bytes at offset 4302020608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302057472 ++wrote 4096/4096 bytes at offset 4302057472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302094336 ++wrote 4096/4096 bytes at offset 4302094336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302131200 ++wrote 4096/4096 bytes at offset 4302131200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302168064 ++wrote 4096/4096 bytes at offset 4302168064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302204928 ++wrote 4096/4096 bytes at offset 4302204928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302241792 ++wrote 4096/4096 bytes at offset 4302241792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302278656 ++wrote 4096/4096 bytes at offset 4302278656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302315520 ++wrote 4096/4096 bytes at offset 4302315520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302352384 ++wrote 4096/4096 bytes at offset 4302352384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302389248 ++wrote 4096/4096 bytes at offset 4302389248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302426112 ++wrote 4096/4096 bytes at offset 4302426112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302462976 ++wrote 4096/4096 bytes at offset 4302462976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302499840 ++wrote 4096/4096 bytes at offset 4302499840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302536704 ++wrote 4096/4096 bytes at offset 4302536704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302573568 ++wrote 4096/4096 bytes at offset 4302573568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302610432 ++wrote 4096/4096 bytes at offset 4302610432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302647296 ++wrote 4096/4096 bytes at offset 4302647296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302684160 ++wrote 4096/4096 bytes at offset 4302684160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302721024 ++wrote 4096/4096 bytes at offset 4302721024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302757888 ++wrote 4096/4096 bytes at offset 4302757888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302794752 ++wrote 4096/4096 bytes at offset 4302794752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302831616 ++wrote 4096/4096 bytes at offset 4302831616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302868480 ++wrote 4096/4096 bytes at offset 4302868480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302905344 ++wrote 4096/4096 bytes at offset 4302905344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302942208 ++wrote 4096/4096 bytes at offset 4302942208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4302979072 ++wrote 4096/4096 bytes at offset 4302979072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303015936 ++wrote 4096/4096 bytes at offset 4303015936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303052800 ++wrote 4096/4096 bytes at offset 4303052800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303089664 ++wrote 4096/4096 bytes at offset 4303089664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303126528 ++wrote 4096/4096 bytes at offset 4303126528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303163392 ++wrote 4096/4096 bytes at offset 4303163392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303200256 ++wrote 4096/4096 bytes at offset 4303200256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303237120 ++wrote 4096/4096 bytes at offset 4303237120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303273984 ++wrote 4096/4096 bytes at offset 4303273984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303310848 ++wrote 4096/4096 bytes at offset 4303310848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303347712 ++wrote 4096/4096 bytes at offset 4303347712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303384576 ++wrote 4096/4096 bytes at offset 4303384576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303421440 ++wrote 4096/4096 bytes at offset 4303421440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303458304 ++wrote 4096/4096 bytes at offset 4303458304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303495168 ++wrote 4096/4096 bytes at offset 4303495168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303532032 ++wrote 4096/4096 bytes at offset 4303532032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303568896 ++wrote 4096/4096 bytes at offset 4303568896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303605760 ++wrote 4096/4096 bytes at offset 4303605760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303642624 ++wrote 4096/4096 bytes at offset 4303642624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303679488 ++wrote 4096/4096 bytes at offset 4303679488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303716352 ++wrote 4096/4096 bytes at offset 4303716352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303753216 ++wrote 4096/4096 bytes at offset 4303753216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303790080 ++wrote 4096/4096 bytes at offset 4303790080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303826944 ++wrote 4096/4096 bytes at offset 4303826944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303863808 ++wrote 4096/4096 bytes at offset 4303863808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303900672 ++wrote 4096/4096 bytes at offset 4303900672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303937536 ++wrote 4096/4096 bytes at offset 4303937536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4303974400 ++wrote 4096/4096 bytes at offset 4303974400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4304011264 ++wrote 4096/4096 bytes at offset 4304011264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4304048128 ++wrote 4096/4096 bytes at offset 4304048128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4304084992 ++wrote 4096/4096 bytes at offset 4304084992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4304121856 ++wrote 4096/4096 bytes at offset 4304121856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4304158720 ++wrote 4096/4096 bytes at offset 4304158720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4304195584 ++wrote 4096/4096 bytes at offset 4304195584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4304232448 ++wrote 4096/4096 bytes at offset 4304232448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4304269312 ++wrote 4096/4096 bytes at offset 4304269312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4304306176 ++wrote 4096/4096 bytes at offset 4304306176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4304343040 ++wrote 4096/4096 bytes at offset 4304343040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4304379904 ++wrote 4096/4096 bytes at offset 4304379904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === Read used/compressed clusters ++=== Read used/compressed clusters + === IO: pattern 165 +-qemu-io> read 8192/8192 bytes at offset 4294967296 ++read 8192/8192 bytes at offset 4294967296 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295004160 ++read 8192/8192 bytes at offset 4295004160 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295041024 ++read 8192/8192 bytes at offset 4295041024 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295077888 ++read 8192/8192 bytes at offset 4295077888 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295114752 ++read 8192/8192 bytes at offset 4295114752 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295151616 ++read 8192/8192 bytes at offset 4295151616 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295188480 ++read 8192/8192 bytes at offset 4295188480 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295225344 ++read 8192/8192 bytes at offset 4295225344 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295262208 ++read 8192/8192 bytes at offset 4295262208 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295299072 ++read 8192/8192 bytes at offset 4295299072 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295335936 ++read 8192/8192 bytes at offset 4295335936 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295372800 ++read 8192/8192 bytes at offset 4295372800 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295409664 ++read 8192/8192 bytes at offset 4295409664 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295446528 ++read 8192/8192 bytes at offset 4295446528 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295483392 ++read 8192/8192 bytes at offset 4295483392 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295520256 ++read 8192/8192 bytes at offset 4295520256 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295557120 ++read 8192/8192 bytes at offset 4295557120 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295593984 ++read 8192/8192 bytes at offset 4295593984 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295630848 ++read 8192/8192 bytes at offset 4295630848 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295667712 ++read 8192/8192 bytes at offset 4295667712 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295704576 ++read 8192/8192 bytes at offset 4295704576 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295741440 ++read 8192/8192 bytes at offset 4295741440 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295778304 ++read 8192/8192 bytes at offset 4295778304 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295815168 ++read 8192/8192 bytes at offset 4295815168 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295852032 ++read 8192/8192 bytes at offset 4295852032 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295888896 ++read 8192/8192 bytes at offset 4295888896 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295925760 ++read 8192/8192 bytes at offset 4295925760 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295962624 ++read 8192/8192 bytes at offset 4295962624 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295999488 ++read 8192/8192 bytes at offset 4295999488 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296036352 ++read 8192/8192 bytes at offset 4296036352 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296073216 ++read 8192/8192 bytes at offset 4296073216 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296110080 ++read 8192/8192 bytes at offset 4296110080 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296146944 ++read 8192/8192 bytes at offset 4296146944 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296183808 ++read 8192/8192 bytes at offset 4296183808 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296220672 ++read 8192/8192 bytes at offset 4296220672 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296257536 ++read 8192/8192 bytes at offset 4296257536 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296294400 ++read 8192/8192 bytes at offset 4296294400 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296331264 ++read 8192/8192 bytes at offset 4296331264 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296368128 ++read 8192/8192 bytes at offset 4296368128 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296404992 ++read 8192/8192 bytes at offset 4296404992 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296441856 ++read 8192/8192 bytes at offset 4296441856 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296478720 ++read 8192/8192 bytes at offset 4296478720 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296515584 ++read 8192/8192 bytes at offset 4296515584 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296552448 ++read 8192/8192 bytes at offset 4296552448 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296589312 ++read 8192/8192 bytes at offset 4296589312 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296626176 ++read 8192/8192 bytes at offset 4296626176 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296663040 ++read 8192/8192 bytes at offset 4296663040 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296699904 ++read 8192/8192 bytes at offset 4296699904 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296736768 ++read 8192/8192 bytes at offset 4296736768 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296773632 ++read 8192/8192 bytes at offset 4296773632 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296810496 ++read 8192/8192 bytes at offset 4296810496 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296847360 ++read 8192/8192 bytes at offset 4296847360 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296884224 ++read 8192/8192 bytes at offset 4296884224 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296921088 ++read 8192/8192 bytes at offset 4296921088 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296957952 ++read 8192/8192 bytes at offset 4296957952 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296994816 ++read 8192/8192 bytes at offset 4296994816 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297031680 ++read 8192/8192 bytes at offset 4297031680 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297068544 ++read 8192/8192 bytes at offset 4297068544 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297105408 ++read 8192/8192 bytes at offset 4297105408 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297142272 ++read 8192/8192 bytes at offset 4297142272 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297179136 ++read 8192/8192 bytes at offset 4297179136 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297216000 ++read 8192/8192 bytes at offset 4297216000 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297252864 ++read 8192/8192 bytes at offset 4297252864 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297289728 ++read 8192/8192 bytes at offset 4297289728 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297326592 ++read 8192/8192 bytes at offset 4297326592 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297363456 ++read 8192/8192 bytes at offset 4297363456 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297400320 ++read 8192/8192 bytes at offset 4297400320 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297437184 ++read 8192/8192 bytes at offset 4297437184 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297474048 ++read 8192/8192 bytes at offset 4297474048 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297510912 ++read 8192/8192 bytes at offset 4297510912 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297547776 ++read 8192/8192 bytes at offset 4297547776 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297584640 ++read 8192/8192 bytes at offset 4297584640 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297621504 ++read 8192/8192 bytes at offset 4297621504 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297658368 ++read 8192/8192 bytes at offset 4297658368 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297695232 ++read 8192/8192 bytes at offset 4297695232 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297732096 ++read 8192/8192 bytes at offset 4297732096 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297768960 ++read 8192/8192 bytes at offset 4297768960 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297805824 ++read 8192/8192 bytes at offset 4297805824 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297842688 ++read 8192/8192 bytes at offset 4297842688 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297879552 ++read 8192/8192 bytes at offset 4297879552 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297916416 ++read 8192/8192 bytes at offset 4297916416 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297953280 ++read 8192/8192 bytes at offset 4297953280 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297990144 ++read 8192/8192 bytes at offset 4297990144 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4298027008 ++read 8192/8192 bytes at offset 4298027008 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4298063872 ++read 8192/8192 bytes at offset 4298063872 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4298100736 ++read 8192/8192 bytes at offset 4298100736 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4298137600 ++read 8192/8192 bytes at offset 4298137600 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4298174464 ++read 8192/8192 bytes at offset 4298174464 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4298211328 ++read 8192/8192 bytes at offset 4298211328 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4298248192 ++read 8192/8192 bytes at offset 4298248192 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4298285056 ++read 8192/8192 bytes at offset 4298285056 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4298321920 ++read 8192/8192 bytes at offset 4298321920 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4298358784 ++read 8192/8192 bytes at offset 4298358784 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4298395648 ++read 8192/8192 bytes at offset 4298395648 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4298432512 ++read 8192/8192 bytes at offset 4298432512 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4298469376 ++read 8192/8192 bytes at offset 4298469376 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4298506240 ++read 8192/8192 bytes at offset 4298506240 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4298543104 ++read 8192/8192 bytes at offset 4298543104 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4298579968 ++read 8192/8192 bytes at offset 4298579968 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4298616832 ++read 8192/8192 bytes at offset 4298616832 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4298653696 ++read 8192/8192 bytes at offset 4298653696 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4298690560 ++read 8192/8192 bytes at offset 4298690560 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4298727424 ++read 8192/8192 bytes at offset 4298727424 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4298764288 ++read 8192/8192 bytes at offset 4298764288 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4298801152 ++read 8192/8192 bytes at offset 4298801152 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4298838016 ++read 8192/8192 bytes at offset 4298838016 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4298874880 ++read 8192/8192 bytes at offset 4298874880 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4298911744 ++read 8192/8192 bytes at offset 4298911744 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4298948608 ++read 8192/8192 bytes at offset 4298948608 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4298985472 ++read 8192/8192 bytes at offset 4298985472 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299022336 ++read 8192/8192 bytes at offset 4299022336 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299059200 ++read 8192/8192 bytes at offset 4299059200 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299096064 ++read 8192/8192 bytes at offset 4299096064 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299132928 ++read 8192/8192 bytes at offset 4299132928 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299169792 ++read 8192/8192 bytes at offset 4299169792 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299206656 ++read 8192/8192 bytes at offset 4299206656 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299243520 ++read 8192/8192 bytes at offset 4299243520 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299280384 ++read 8192/8192 bytes at offset 4299280384 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299317248 ++read 8192/8192 bytes at offset 4299317248 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299354112 ++read 8192/8192 bytes at offset 4299354112 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299390976 ++read 8192/8192 bytes at offset 4299390976 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299427840 ++read 8192/8192 bytes at offset 4299427840 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299464704 ++read 8192/8192 bytes at offset 4299464704 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299501568 ++read 8192/8192 bytes at offset 4299501568 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299538432 ++read 8192/8192 bytes at offset 4299538432 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299575296 ++read 8192/8192 bytes at offset 4299575296 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299612160 ++read 8192/8192 bytes at offset 4299612160 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299649024 ++read 8192/8192 bytes at offset 4299649024 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299685888 ++read 8192/8192 bytes at offset 4299685888 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299722752 ++read 8192/8192 bytes at offset 4299722752 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299759616 ++read 8192/8192 bytes at offset 4299759616 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299796480 ++read 8192/8192 bytes at offset 4299796480 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299833344 ++read 8192/8192 bytes at offset 4299833344 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299870208 ++read 8192/8192 bytes at offset 4299870208 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299907072 ++read 8192/8192 bytes at offset 4299907072 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299943936 ++read 8192/8192 bytes at offset 4299943936 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299980800 ++read 8192/8192 bytes at offset 4299980800 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4300017664 ++read 8192/8192 bytes at offset 4300017664 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4300054528 ++read 8192/8192 bytes at offset 4300054528 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4300091392 ++read 8192/8192 bytes at offset 4300091392 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4300128256 ++read 8192/8192 bytes at offset 4300128256 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4300165120 ++read 8192/8192 bytes at offset 4300165120 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4300201984 ++read 8192/8192 bytes at offset 4300201984 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4300238848 ++read 8192/8192 bytes at offset 4300238848 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4300275712 ++read 8192/8192 bytes at offset 4300275712 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4300312576 ++read 8192/8192 bytes at offset 4300312576 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4300349440 ++read 8192/8192 bytes at offset 4300349440 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4300386304 ++read 8192/8192 bytes at offset 4300386304 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4300423168 ++read 8192/8192 bytes at offset 4300423168 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4300460032 ++read 8192/8192 bytes at offset 4300460032 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4300496896 ++read 8192/8192 bytes at offset 4300496896 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4300533760 ++read 8192/8192 bytes at offset 4300533760 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4300570624 ++read 8192/8192 bytes at offset 4300570624 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4300607488 ++read 8192/8192 bytes at offset 4300607488 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4300644352 ++read 8192/8192 bytes at offset 4300644352 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4300681216 ++read 8192/8192 bytes at offset 4300681216 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4300718080 ++read 8192/8192 bytes at offset 4300718080 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4300754944 ++read 8192/8192 bytes at offset 4300754944 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4300791808 ++read 8192/8192 bytes at offset 4300791808 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4300828672 ++read 8192/8192 bytes at offset 4300828672 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4300865536 ++read 8192/8192 bytes at offset 4300865536 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4300902400 ++read 8192/8192 bytes at offset 4300902400 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4300939264 ++read 8192/8192 bytes at offset 4300939264 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4300976128 ++read 8192/8192 bytes at offset 4300976128 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4301012992 ++read 8192/8192 bytes at offset 4301012992 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4301049856 ++read 8192/8192 bytes at offset 4301049856 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4301086720 ++read 8192/8192 bytes at offset 4301086720 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4301123584 ++read 8192/8192 bytes at offset 4301123584 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4301160448 ++read 8192/8192 bytes at offset 4301160448 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4301197312 ++read 8192/8192 bytes at offset 4301197312 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4301234176 ++read 8192/8192 bytes at offset 4301234176 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4301271040 ++read 8192/8192 bytes at offset 4301271040 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4301307904 ++read 8192/8192 bytes at offset 4301307904 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4301344768 ++read 8192/8192 bytes at offset 4301344768 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4301381632 ++read 8192/8192 bytes at offset 4301381632 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4301418496 ++read 8192/8192 bytes at offset 4301418496 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4301455360 ++read 8192/8192 bytes at offset 4301455360 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4301492224 ++read 8192/8192 bytes at offset 4301492224 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4301529088 ++read 8192/8192 bytes at offset 4301529088 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4301565952 ++read 8192/8192 bytes at offset 4301565952 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4301602816 ++read 8192/8192 bytes at offset 4301602816 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4301639680 ++read 8192/8192 bytes at offset 4301639680 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4301676544 ++read 8192/8192 bytes at offset 4301676544 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4301713408 ++read 8192/8192 bytes at offset 4301713408 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4301750272 ++read 8192/8192 bytes at offset 4301750272 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4301787136 ++read 8192/8192 bytes at offset 4301787136 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4301824000 ++read 8192/8192 bytes at offset 4301824000 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4301860864 ++read 8192/8192 bytes at offset 4301860864 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4301897728 ++read 8192/8192 bytes at offset 4301897728 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4301934592 ++read 8192/8192 bytes at offset 4301934592 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4301971456 ++read 8192/8192 bytes at offset 4301971456 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4302008320 ++read 8192/8192 bytes at offset 4302008320 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4302045184 ++read 8192/8192 bytes at offset 4302045184 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4302082048 ++read 8192/8192 bytes at offset 4302082048 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4302118912 ++read 8192/8192 bytes at offset 4302118912 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4302155776 ++read 8192/8192 bytes at offset 4302155776 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4302192640 ++read 8192/8192 bytes at offset 4302192640 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4302229504 ++read 8192/8192 bytes at offset 4302229504 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4302266368 ++read 8192/8192 bytes at offset 4302266368 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4302303232 ++read 8192/8192 bytes at offset 4302303232 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4302340096 ++read 8192/8192 bytes at offset 4302340096 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4302376960 ++read 8192/8192 bytes at offset 4302376960 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4302413824 ++read 8192/8192 bytes at offset 4302413824 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4302450688 ++read 8192/8192 bytes at offset 4302450688 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4302487552 ++read 8192/8192 bytes at offset 4302487552 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4302524416 ++read 8192/8192 bytes at offset 4302524416 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4302561280 ++read 8192/8192 bytes at offset 4302561280 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4302598144 ++read 8192/8192 bytes at offset 4302598144 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4302635008 ++read 8192/8192 bytes at offset 4302635008 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4302671872 ++read 8192/8192 bytes at offset 4302671872 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4302708736 ++read 8192/8192 bytes at offset 4302708736 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4302745600 ++read 8192/8192 bytes at offset 4302745600 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4302782464 ++read 8192/8192 bytes at offset 4302782464 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4302819328 ++read 8192/8192 bytes at offset 4302819328 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4302856192 ++read 8192/8192 bytes at offset 4302856192 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4302893056 ++read 8192/8192 bytes at offset 4302893056 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4302929920 ++read 8192/8192 bytes at offset 4302929920 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4302966784 ++read 8192/8192 bytes at offset 4302966784 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4303003648 ++read 8192/8192 bytes at offset 4303003648 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4303040512 ++read 8192/8192 bytes at offset 4303040512 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4303077376 ++read 8192/8192 bytes at offset 4303077376 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4303114240 ++read 8192/8192 bytes at offset 4303114240 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4303151104 ++read 8192/8192 bytes at offset 4303151104 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4303187968 ++read 8192/8192 bytes at offset 4303187968 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4303224832 ++read 8192/8192 bytes at offset 4303224832 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4303261696 ++read 8192/8192 bytes at offset 4303261696 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4303298560 ++read 8192/8192 bytes at offset 4303298560 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4303335424 ++read 8192/8192 bytes at offset 4303335424 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4303372288 ++read 8192/8192 bytes at offset 4303372288 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4303409152 ++read 8192/8192 bytes at offset 4303409152 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4303446016 ++read 8192/8192 bytes at offset 4303446016 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4303482880 ++read 8192/8192 bytes at offset 4303482880 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4303519744 ++read 8192/8192 bytes at offset 4303519744 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4303556608 ++read 8192/8192 bytes at offset 4303556608 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4303593472 ++read 8192/8192 bytes at offset 4303593472 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4303630336 ++read 8192/8192 bytes at offset 4303630336 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4303667200 ++read 8192/8192 bytes at offset 4303667200 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4303704064 ++read 8192/8192 bytes at offset 4303704064 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4303740928 ++read 8192/8192 bytes at offset 4303740928 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4303777792 ++read 8192/8192 bytes at offset 4303777792 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4303814656 ++read 8192/8192 bytes at offset 4303814656 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4303851520 ++read 8192/8192 bytes at offset 4303851520 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4303888384 ++read 8192/8192 bytes at offset 4303888384 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4303925248 ++read 8192/8192 bytes at offset 4303925248 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4303962112 ++read 8192/8192 bytes at offset 4303962112 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4303998976 ++read 8192/8192 bytes at offset 4303998976 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4304035840 ++read 8192/8192 bytes at offset 4304035840 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4304072704 ++read 8192/8192 bytes at offset 4304072704 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4304109568 ++read 8192/8192 bytes at offset 4304109568 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4304146432 ++read 8192/8192 bytes at offset 4304146432 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4304183296 ++read 8192/8192 bytes at offset 4304183296 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4304220160 ++read 8192/8192 bytes at offset 4304220160 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4304257024 ++read 8192/8192 bytes at offset 4304257024 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4304293888 ++read 8192/8192 bytes at offset 4304293888 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4304330752 ++read 8192/8192 bytes at offset 4304330752 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4304367616 ++read 8192/8192 bytes at offset 4304367616 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 165 +-qemu-io> read 12288/12288 bytes at offset 4294979584 ++=== IO: pattern 165 ++read 12288/12288 bytes at offset 4294979584 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4295016448 ++read 12288/12288 bytes at offset 4295016448 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4295053312 ++read 12288/12288 bytes at offset 4295053312 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4295090176 ++read 12288/12288 bytes at offset 4295090176 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4295127040 ++read 12288/12288 bytes at offset 4295127040 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4295163904 ++read 12288/12288 bytes at offset 4295163904 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4295200768 ++read 12288/12288 bytes at offset 4295200768 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4295237632 ++read 12288/12288 bytes at offset 4295237632 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4295274496 ++read 12288/12288 bytes at offset 4295274496 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4295311360 ++read 12288/12288 bytes at offset 4295311360 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4295348224 ++read 12288/12288 bytes at offset 4295348224 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4295385088 ++read 12288/12288 bytes at offset 4295385088 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4295421952 ++read 12288/12288 bytes at offset 4295421952 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4295458816 ++read 12288/12288 bytes at offset 4295458816 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4295495680 ++read 12288/12288 bytes at offset 4295495680 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4295532544 ++read 12288/12288 bytes at offset 4295532544 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4295569408 ++read 12288/12288 bytes at offset 4295569408 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4295606272 ++read 12288/12288 bytes at offset 4295606272 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4295643136 ++read 12288/12288 bytes at offset 4295643136 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4295680000 ++read 12288/12288 bytes at offset 4295680000 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4295716864 ++read 12288/12288 bytes at offset 4295716864 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4295753728 ++read 12288/12288 bytes at offset 4295753728 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4295790592 ++read 12288/12288 bytes at offset 4295790592 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4295827456 ++read 12288/12288 bytes at offset 4295827456 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4295864320 ++read 12288/12288 bytes at offset 4295864320 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4295901184 ++read 12288/12288 bytes at offset 4295901184 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4295938048 ++read 12288/12288 bytes at offset 4295938048 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4295974912 ++read 12288/12288 bytes at offset 4295974912 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4296011776 ++read 12288/12288 bytes at offset 4296011776 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4296048640 ++read 12288/12288 bytes at offset 4296048640 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4296085504 ++read 12288/12288 bytes at offset 4296085504 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4296122368 ++read 12288/12288 bytes at offset 4296122368 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4296159232 ++read 12288/12288 bytes at offset 4296159232 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4296196096 ++read 12288/12288 bytes at offset 4296196096 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4296232960 ++read 12288/12288 bytes at offset 4296232960 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4296269824 ++read 12288/12288 bytes at offset 4296269824 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4296306688 ++read 12288/12288 bytes at offset 4296306688 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4296343552 ++read 12288/12288 bytes at offset 4296343552 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4296380416 ++read 12288/12288 bytes at offset 4296380416 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4296417280 ++read 12288/12288 bytes at offset 4296417280 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4296454144 ++read 12288/12288 bytes at offset 4296454144 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4296491008 ++read 12288/12288 bytes at offset 4296491008 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4296527872 ++read 12288/12288 bytes at offset 4296527872 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4296564736 ++read 12288/12288 bytes at offset 4296564736 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4296601600 ++read 12288/12288 bytes at offset 4296601600 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4296638464 ++read 12288/12288 bytes at offset 4296638464 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4296675328 ++read 12288/12288 bytes at offset 4296675328 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4296712192 ++read 12288/12288 bytes at offset 4296712192 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4296749056 ++read 12288/12288 bytes at offset 4296749056 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4296785920 ++read 12288/12288 bytes at offset 4296785920 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4296822784 ++read 12288/12288 bytes at offset 4296822784 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4296859648 ++read 12288/12288 bytes at offset 4296859648 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4296896512 ++read 12288/12288 bytes at offset 4296896512 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4296933376 ++read 12288/12288 bytes at offset 4296933376 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4296970240 ++read 12288/12288 bytes at offset 4296970240 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4297007104 ++read 12288/12288 bytes at offset 4297007104 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4297043968 ++read 12288/12288 bytes at offset 4297043968 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4297080832 ++read 12288/12288 bytes at offset 4297080832 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4297117696 ++read 12288/12288 bytes at offset 4297117696 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4297154560 ++read 12288/12288 bytes at offset 4297154560 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4297191424 ++read 12288/12288 bytes at offset 4297191424 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4297228288 ++read 12288/12288 bytes at offset 4297228288 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4297265152 ++read 12288/12288 bytes at offset 4297265152 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4297302016 ++read 12288/12288 bytes at offset 4297302016 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4297338880 ++read 12288/12288 bytes at offset 4297338880 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4297375744 ++read 12288/12288 bytes at offset 4297375744 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4297412608 ++read 12288/12288 bytes at offset 4297412608 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4297449472 ++read 12288/12288 bytes at offset 4297449472 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4297486336 ++read 12288/12288 bytes at offset 4297486336 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4297523200 ++read 12288/12288 bytes at offset 4297523200 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4297560064 ++read 12288/12288 bytes at offset 4297560064 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4297596928 ++read 12288/12288 bytes at offset 4297596928 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4297633792 ++read 12288/12288 bytes at offset 4297633792 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4297670656 ++read 12288/12288 bytes at offset 4297670656 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4297707520 ++read 12288/12288 bytes at offset 4297707520 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4297744384 ++read 12288/12288 bytes at offset 4297744384 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4297781248 ++read 12288/12288 bytes at offset 4297781248 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4297818112 ++read 12288/12288 bytes at offset 4297818112 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4297854976 ++read 12288/12288 bytes at offset 4297854976 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4297891840 ++read 12288/12288 bytes at offset 4297891840 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4297928704 ++read 12288/12288 bytes at offset 4297928704 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4297965568 ++read 12288/12288 bytes at offset 4297965568 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4298002432 ++read 12288/12288 bytes at offset 4298002432 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4298039296 ++read 12288/12288 bytes at offset 4298039296 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4298076160 ++read 12288/12288 bytes at offset 4298076160 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4298113024 ++read 12288/12288 bytes at offset 4298113024 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4298149888 ++read 12288/12288 bytes at offset 4298149888 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4298186752 ++read 12288/12288 bytes at offset 4298186752 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4298223616 ++read 12288/12288 bytes at offset 4298223616 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4298260480 ++read 12288/12288 bytes at offset 4298260480 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4298297344 ++read 12288/12288 bytes at offset 4298297344 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4298334208 ++read 12288/12288 bytes at offset 4298334208 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4298371072 ++read 12288/12288 bytes at offset 4298371072 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4298407936 ++read 12288/12288 bytes at offset 4298407936 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4298444800 ++read 12288/12288 bytes at offset 4298444800 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4298481664 ++read 12288/12288 bytes at offset 4298481664 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4298518528 ++read 12288/12288 bytes at offset 4298518528 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4298555392 ++read 12288/12288 bytes at offset 4298555392 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4298592256 ++read 12288/12288 bytes at offset 4298592256 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4298629120 ++read 12288/12288 bytes at offset 4298629120 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4298665984 ++read 12288/12288 bytes at offset 4298665984 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4298702848 ++read 12288/12288 bytes at offset 4298702848 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4298739712 ++read 12288/12288 bytes at offset 4298739712 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4298776576 ++read 12288/12288 bytes at offset 4298776576 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4298813440 ++read 12288/12288 bytes at offset 4298813440 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4298850304 ++read 12288/12288 bytes at offset 4298850304 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4298887168 ++read 12288/12288 bytes at offset 4298887168 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4298924032 ++read 12288/12288 bytes at offset 4298924032 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4298960896 ++read 12288/12288 bytes at offset 4298960896 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4298997760 ++read 12288/12288 bytes at offset 4298997760 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4299034624 ++read 12288/12288 bytes at offset 4299034624 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4299071488 ++read 12288/12288 bytes at offset 4299071488 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4299108352 ++read 12288/12288 bytes at offset 4299108352 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4299145216 ++read 12288/12288 bytes at offset 4299145216 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4299182080 ++read 12288/12288 bytes at offset 4299182080 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4299218944 ++read 12288/12288 bytes at offset 4299218944 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4299255808 ++read 12288/12288 bytes at offset 4299255808 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4299292672 ++read 12288/12288 bytes at offset 4299292672 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4299329536 ++read 12288/12288 bytes at offset 4299329536 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4299366400 ++read 12288/12288 bytes at offset 4299366400 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4299403264 ++read 12288/12288 bytes at offset 4299403264 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4299440128 ++read 12288/12288 bytes at offset 4299440128 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4299476992 ++read 12288/12288 bytes at offset 4299476992 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4299513856 ++read 12288/12288 bytes at offset 4299513856 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4299550720 ++read 12288/12288 bytes at offset 4299550720 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4299587584 ++read 12288/12288 bytes at offset 4299587584 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4299624448 ++read 12288/12288 bytes at offset 4299624448 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4299661312 ++read 12288/12288 bytes at offset 4299661312 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4299698176 ++read 12288/12288 bytes at offset 4299698176 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4299735040 ++read 12288/12288 bytes at offset 4299735040 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4299771904 ++read 12288/12288 bytes at offset 4299771904 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4299808768 ++read 12288/12288 bytes at offset 4299808768 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4299845632 ++read 12288/12288 bytes at offset 4299845632 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4299882496 ++read 12288/12288 bytes at offset 4299882496 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4299919360 ++read 12288/12288 bytes at offset 4299919360 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4299956224 ++read 12288/12288 bytes at offset 4299956224 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4299993088 ++read 12288/12288 bytes at offset 4299993088 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4300029952 ++read 12288/12288 bytes at offset 4300029952 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4300066816 ++read 12288/12288 bytes at offset 4300066816 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4300103680 ++read 12288/12288 bytes at offset 4300103680 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4300140544 ++read 12288/12288 bytes at offset 4300140544 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4300177408 ++read 12288/12288 bytes at offset 4300177408 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4300214272 ++read 12288/12288 bytes at offset 4300214272 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4300251136 ++read 12288/12288 bytes at offset 4300251136 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4300288000 ++read 12288/12288 bytes at offset 4300288000 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4300324864 ++read 12288/12288 bytes at offset 4300324864 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4300361728 ++read 12288/12288 bytes at offset 4300361728 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4300398592 ++read 12288/12288 bytes at offset 4300398592 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4300435456 ++read 12288/12288 bytes at offset 4300435456 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4300472320 ++read 12288/12288 bytes at offset 4300472320 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4300509184 ++read 12288/12288 bytes at offset 4300509184 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4300546048 ++read 12288/12288 bytes at offset 4300546048 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4300582912 ++read 12288/12288 bytes at offset 4300582912 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4300619776 ++read 12288/12288 bytes at offset 4300619776 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4300656640 ++read 12288/12288 bytes at offset 4300656640 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4300693504 ++read 12288/12288 bytes at offset 4300693504 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4300730368 ++read 12288/12288 bytes at offset 4300730368 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4300767232 ++read 12288/12288 bytes at offset 4300767232 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4300804096 ++read 12288/12288 bytes at offset 4300804096 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4300840960 ++read 12288/12288 bytes at offset 4300840960 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4300877824 ++read 12288/12288 bytes at offset 4300877824 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4300914688 ++read 12288/12288 bytes at offset 4300914688 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4300951552 ++read 12288/12288 bytes at offset 4300951552 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4300988416 ++read 12288/12288 bytes at offset 4300988416 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4301025280 ++read 12288/12288 bytes at offset 4301025280 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4301062144 ++read 12288/12288 bytes at offset 4301062144 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4301099008 ++read 12288/12288 bytes at offset 4301099008 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4301135872 ++read 12288/12288 bytes at offset 4301135872 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4301172736 ++read 12288/12288 bytes at offset 4301172736 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4301209600 ++read 12288/12288 bytes at offset 4301209600 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4301246464 ++read 12288/12288 bytes at offset 4301246464 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4301283328 ++read 12288/12288 bytes at offset 4301283328 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4301320192 ++read 12288/12288 bytes at offset 4301320192 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4301357056 ++read 12288/12288 bytes at offset 4301357056 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4301393920 ++read 12288/12288 bytes at offset 4301393920 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4301430784 ++read 12288/12288 bytes at offset 4301430784 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4301467648 ++read 12288/12288 bytes at offset 4301467648 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4301504512 ++read 12288/12288 bytes at offset 4301504512 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4301541376 ++read 12288/12288 bytes at offset 4301541376 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4301578240 ++read 12288/12288 bytes at offset 4301578240 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4301615104 ++read 12288/12288 bytes at offset 4301615104 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4301651968 ++read 12288/12288 bytes at offset 4301651968 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4301688832 ++read 12288/12288 bytes at offset 4301688832 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4301725696 ++read 12288/12288 bytes at offset 4301725696 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4301762560 ++read 12288/12288 bytes at offset 4301762560 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4301799424 ++read 12288/12288 bytes at offset 4301799424 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4301836288 ++read 12288/12288 bytes at offset 4301836288 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4301873152 ++read 12288/12288 bytes at offset 4301873152 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4301910016 ++read 12288/12288 bytes at offset 4301910016 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4301946880 ++read 12288/12288 bytes at offset 4301946880 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4301983744 ++read 12288/12288 bytes at offset 4301983744 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4302020608 ++read 12288/12288 bytes at offset 4302020608 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4302057472 ++read 12288/12288 bytes at offset 4302057472 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4302094336 ++read 12288/12288 bytes at offset 4302094336 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4302131200 ++read 12288/12288 bytes at offset 4302131200 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4302168064 ++read 12288/12288 bytes at offset 4302168064 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4302204928 ++read 12288/12288 bytes at offset 4302204928 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4302241792 ++read 12288/12288 bytes at offset 4302241792 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4302278656 ++read 12288/12288 bytes at offset 4302278656 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4302315520 ++read 12288/12288 bytes at offset 4302315520 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4302352384 ++read 12288/12288 bytes at offset 4302352384 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4302389248 ++read 12288/12288 bytes at offset 4302389248 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4302426112 ++read 12288/12288 bytes at offset 4302426112 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4302462976 ++read 12288/12288 bytes at offset 4302462976 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4302499840 ++read 12288/12288 bytes at offset 4302499840 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4302536704 ++read 12288/12288 bytes at offset 4302536704 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4302573568 ++read 12288/12288 bytes at offset 4302573568 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4302610432 ++read 12288/12288 bytes at offset 4302610432 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4302647296 ++read 12288/12288 bytes at offset 4302647296 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4302684160 ++read 12288/12288 bytes at offset 4302684160 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4302721024 ++read 12288/12288 bytes at offset 4302721024 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4302757888 ++read 12288/12288 bytes at offset 4302757888 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4302794752 ++read 12288/12288 bytes at offset 4302794752 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4302831616 ++read 12288/12288 bytes at offset 4302831616 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4302868480 ++read 12288/12288 bytes at offset 4302868480 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4302905344 ++read 12288/12288 bytes at offset 4302905344 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4302942208 ++read 12288/12288 bytes at offset 4302942208 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4302979072 ++read 12288/12288 bytes at offset 4302979072 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4303015936 ++read 12288/12288 bytes at offset 4303015936 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4303052800 ++read 12288/12288 bytes at offset 4303052800 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4303089664 ++read 12288/12288 bytes at offset 4303089664 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4303126528 ++read 12288/12288 bytes at offset 4303126528 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4303163392 ++read 12288/12288 bytes at offset 4303163392 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4303200256 ++read 12288/12288 bytes at offset 4303200256 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4303237120 ++read 12288/12288 bytes at offset 4303237120 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4303273984 ++read 12288/12288 bytes at offset 4303273984 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4303310848 ++read 12288/12288 bytes at offset 4303310848 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4303347712 ++read 12288/12288 bytes at offset 4303347712 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4303384576 ++read 12288/12288 bytes at offset 4303384576 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4303421440 ++read 12288/12288 bytes at offset 4303421440 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4303458304 ++read 12288/12288 bytes at offset 4303458304 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4303495168 ++read 12288/12288 bytes at offset 4303495168 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4303532032 ++read 12288/12288 bytes at offset 4303532032 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4303568896 ++read 12288/12288 bytes at offset 4303568896 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4303605760 ++read 12288/12288 bytes at offset 4303605760 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4303642624 ++read 12288/12288 bytes at offset 4303642624 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4303679488 ++read 12288/12288 bytes at offset 4303679488 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4303716352 ++read 12288/12288 bytes at offset 4303716352 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4303753216 ++read 12288/12288 bytes at offset 4303753216 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4303790080 ++read 12288/12288 bytes at offset 4303790080 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4303826944 ++read 12288/12288 bytes at offset 4303826944 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4303863808 ++read 12288/12288 bytes at offset 4303863808 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4303900672 ++read 12288/12288 bytes at offset 4303900672 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4303937536 ++read 12288/12288 bytes at offset 4303937536 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4303974400 ++read 12288/12288 bytes at offset 4303974400 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4304011264 ++read 12288/12288 bytes at offset 4304011264 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4304048128 ++read 12288/12288 bytes at offset 4304048128 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4304084992 ++read 12288/12288 bytes at offset 4304084992 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4304121856 ++read 12288/12288 bytes at offset 4304121856 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4304158720 ++read 12288/12288 bytes at offset 4304158720 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4304195584 ++read 12288/12288 bytes at offset 4304195584 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4304232448 ++read 12288/12288 bytes at offset 4304232448 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4304269312 ++read 12288/12288 bytes at offset 4304269312 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4304306176 ++read 12288/12288 bytes at offset 4304306176 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4304343040 ++read 12288/12288 bytes at offset 4304343040 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4304379904 ++read 12288/12288 bytes at offset 4304379904 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 165 +-qemu-io> read 4096/4096 bytes at offset 4295000064 ++=== IO: pattern 165 ++read 4096/4096 bytes at offset 4295000064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295036928 ++read 4096/4096 bytes at offset 4295036928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295073792 ++read 4096/4096 bytes at offset 4295073792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295110656 ++read 4096/4096 bytes at offset 4295110656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295147520 ++read 4096/4096 bytes at offset 4295147520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295184384 ++read 4096/4096 bytes at offset 4295184384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295221248 ++read 4096/4096 bytes at offset 4295221248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295258112 ++read 4096/4096 bytes at offset 4295258112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295294976 ++read 4096/4096 bytes at offset 4295294976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295331840 ++read 4096/4096 bytes at offset 4295331840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295368704 ++read 4096/4096 bytes at offset 4295368704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295405568 ++read 4096/4096 bytes at offset 4295405568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295442432 ++read 4096/4096 bytes at offset 4295442432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295479296 ++read 4096/4096 bytes at offset 4295479296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295516160 ++read 4096/4096 bytes at offset 4295516160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295553024 ++read 4096/4096 bytes at offset 4295553024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295589888 ++read 4096/4096 bytes at offset 4295589888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295626752 ++read 4096/4096 bytes at offset 4295626752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295663616 ++read 4096/4096 bytes at offset 4295663616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295700480 ++read 4096/4096 bytes at offset 4295700480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295737344 ++read 4096/4096 bytes at offset 4295737344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295774208 ++read 4096/4096 bytes at offset 4295774208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295811072 ++read 4096/4096 bytes at offset 4295811072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295847936 ++read 4096/4096 bytes at offset 4295847936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295884800 ++read 4096/4096 bytes at offset 4295884800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295921664 ++read 4096/4096 bytes at offset 4295921664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295958528 ++read 4096/4096 bytes at offset 4295958528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295995392 ++read 4096/4096 bytes at offset 4295995392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4296032256 ++read 4096/4096 bytes at offset 4296032256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4296069120 ++read 4096/4096 bytes at offset 4296069120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4296105984 ++read 4096/4096 bytes at offset 4296105984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4296142848 ++read 4096/4096 bytes at offset 4296142848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4296179712 ++read 4096/4096 bytes at offset 4296179712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4296216576 ++read 4096/4096 bytes at offset 4296216576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4296253440 ++read 4096/4096 bytes at offset 4296253440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4296290304 ++read 4096/4096 bytes at offset 4296290304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4296327168 ++read 4096/4096 bytes at offset 4296327168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4296364032 ++read 4096/4096 bytes at offset 4296364032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4296400896 ++read 4096/4096 bytes at offset 4296400896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4296437760 ++read 4096/4096 bytes at offset 4296437760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4296474624 ++read 4096/4096 bytes at offset 4296474624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4296511488 ++read 4096/4096 bytes at offset 4296511488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4296548352 ++read 4096/4096 bytes at offset 4296548352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4296585216 ++read 4096/4096 bytes at offset 4296585216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4296622080 ++read 4096/4096 bytes at offset 4296622080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4296658944 ++read 4096/4096 bytes at offset 4296658944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4296695808 ++read 4096/4096 bytes at offset 4296695808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4296732672 ++read 4096/4096 bytes at offset 4296732672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4296769536 ++read 4096/4096 bytes at offset 4296769536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4296806400 ++read 4096/4096 bytes at offset 4296806400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4296843264 ++read 4096/4096 bytes at offset 4296843264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4296880128 ++read 4096/4096 bytes at offset 4296880128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4296916992 ++read 4096/4096 bytes at offset 4296916992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4296953856 ++read 4096/4096 bytes at offset 4296953856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4296990720 ++read 4096/4096 bytes at offset 4296990720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4297027584 ++read 4096/4096 bytes at offset 4297027584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4297064448 ++read 4096/4096 bytes at offset 4297064448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4297101312 ++read 4096/4096 bytes at offset 4297101312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4297138176 ++read 4096/4096 bytes at offset 4297138176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4297175040 ++read 4096/4096 bytes at offset 4297175040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4297211904 ++read 4096/4096 bytes at offset 4297211904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4297248768 ++read 4096/4096 bytes at offset 4297248768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4297285632 ++read 4096/4096 bytes at offset 4297285632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4297322496 ++read 4096/4096 bytes at offset 4297322496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4297359360 ++read 4096/4096 bytes at offset 4297359360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4297396224 ++read 4096/4096 bytes at offset 4297396224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4297433088 ++read 4096/4096 bytes at offset 4297433088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4297469952 ++read 4096/4096 bytes at offset 4297469952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4297506816 ++read 4096/4096 bytes at offset 4297506816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4297543680 ++read 4096/4096 bytes at offset 4297543680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4297580544 ++read 4096/4096 bytes at offset 4297580544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4297617408 ++read 4096/4096 bytes at offset 4297617408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4297654272 ++read 4096/4096 bytes at offset 4297654272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4297691136 ++read 4096/4096 bytes at offset 4297691136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4297728000 ++read 4096/4096 bytes at offset 4297728000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4297764864 ++read 4096/4096 bytes at offset 4297764864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4297801728 ++read 4096/4096 bytes at offset 4297801728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4297838592 ++read 4096/4096 bytes at offset 4297838592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4297875456 ++read 4096/4096 bytes at offset 4297875456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4297912320 ++read 4096/4096 bytes at offset 4297912320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4297949184 ++read 4096/4096 bytes at offset 4297949184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4297986048 ++read 4096/4096 bytes at offset 4297986048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4298022912 ++read 4096/4096 bytes at offset 4298022912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4298059776 ++read 4096/4096 bytes at offset 4298059776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4298096640 ++read 4096/4096 bytes at offset 4298096640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4298133504 ++read 4096/4096 bytes at offset 4298133504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4298170368 ++read 4096/4096 bytes at offset 4298170368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4298207232 ++read 4096/4096 bytes at offset 4298207232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4298244096 ++read 4096/4096 bytes at offset 4298244096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4298280960 ++read 4096/4096 bytes at offset 4298280960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4298317824 ++read 4096/4096 bytes at offset 4298317824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4298354688 ++read 4096/4096 bytes at offset 4298354688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4298391552 ++read 4096/4096 bytes at offset 4298391552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4298428416 ++read 4096/4096 bytes at offset 4298428416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4298465280 ++read 4096/4096 bytes at offset 4298465280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4298502144 ++read 4096/4096 bytes at offset 4298502144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4298539008 ++read 4096/4096 bytes at offset 4298539008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4298575872 ++read 4096/4096 bytes at offset 4298575872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4298612736 ++read 4096/4096 bytes at offset 4298612736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4298649600 ++read 4096/4096 bytes at offset 4298649600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4298686464 ++read 4096/4096 bytes at offset 4298686464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4298723328 ++read 4096/4096 bytes at offset 4298723328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4298760192 ++read 4096/4096 bytes at offset 4298760192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4298797056 ++read 4096/4096 bytes at offset 4298797056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4298833920 ++read 4096/4096 bytes at offset 4298833920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4298870784 ++read 4096/4096 bytes at offset 4298870784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4298907648 ++read 4096/4096 bytes at offset 4298907648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4298944512 ++read 4096/4096 bytes at offset 4298944512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4298981376 ++read 4096/4096 bytes at offset 4298981376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4299018240 ++read 4096/4096 bytes at offset 4299018240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4299055104 ++read 4096/4096 bytes at offset 4299055104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4299091968 ++read 4096/4096 bytes at offset 4299091968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4299128832 ++read 4096/4096 bytes at offset 4299128832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4299165696 ++read 4096/4096 bytes at offset 4299165696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4299202560 ++read 4096/4096 bytes at offset 4299202560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4299239424 ++read 4096/4096 bytes at offset 4299239424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4299276288 ++read 4096/4096 bytes at offset 4299276288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4299313152 ++read 4096/4096 bytes at offset 4299313152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4299350016 ++read 4096/4096 bytes at offset 4299350016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4299386880 ++read 4096/4096 bytes at offset 4299386880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4299423744 ++read 4096/4096 bytes at offset 4299423744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4299460608 ++read 4096/4096 bytes at offset 4299460608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4299497472 ++read 4096/4096 bytes at offset 4299497472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4299534336 ++read 4096/4096 bytes at offset 4299534336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4299571200 ++read 4096/4096 bytes at offset 4299571200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4299608064 ++read 4096/4096 bytes at offset 4299608064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4299644928 ++read 4096/4096 bytes at offset 4299644928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4299681792 ++read 4096/4096 bytes at offset 4299681792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4299718656 ++read 4096/4096 bytes at offset 4299718656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4299755520 ++read 4096/4096 bytes at offset 4299755520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4299792384 ++read 4096/4096 bytes at offset 4299792384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4299829248 ++read 4096/4096 bytes at offset 4299829248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4299866112 ++read 4096/4096 bytes at offset 4299866112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4299902976 ++read 4096/4096 bytes at offset 4299902976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4299939840 ++read 4096/4096 bytes at offset 4299939840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4299976704 ++read 4096/4096 bytes at offset 4299976704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4300013568 ++read 4096/4096 bytes at offset 4300013568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4300050432 ++read 4096/4096 bytes at offset 4300050432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4300087296 ++read 4096/4096 bytes at offset 4300087296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4300124160 ++read 4096/4096 bytes at offset 4300124160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4300161024 ++read 4096/4096 bytes at offset 4300161024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4300197888 ++read 4096/4096 bytes at offset 4300197888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4300234752 ++read 4096/4096 bytes at offset 4300234752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4300271616 ++read 4096/4096 bytes at offset 4300271616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4300308480 ++read 4096/4096 bytes at offset 4300308480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4300345344 ++read 4096/4096 bytes at offset 4300345344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4300382208 ++read 4096/4096 bytes at offset 4300382208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4300419072 ++read 4096/4096 bytes at offset 4300419072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4300455936 ++read 4096/4096 bytes at offset 4300455936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4300492800 ++read 4096/4096 bytes at offset 4300492800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4300529664 ++read 4096/4096 bytes at offset 4300529664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4300566528 ++read 4096/4096 bytes at offset 4300566528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4300603392 ++read 4096/4096 bytes at offset 4300603392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4300640256 ++read 4096/4096 bytes at offset 4300640256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4300677120 ++read 4096/4096 bytes at offset 4300677120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4300713984 ++read 4096/4096 bytes at offset 4300713984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4300750848 ++read 4096/4096 bytes at offset 4300750848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4300787712 ++read 4096/4096 bytes at offset 4300787712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4300824576 ++read 4096/4096 bytes at offset 4300824576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4300861440 ++read 4096/4096 bytes at offset 4300861440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4300898304 ++read 4096/4096 bytes at offset 4300898304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4300935168 ++read 4096/4096 bytes at offset 4300935168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4300972032 ++read 4096/4096 bytes at offset 4300972032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4301008896 ++read 4096/4096 bytes at offset 4301008896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4301045760 ++read 4096/4096 bytes at offset 4301045760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4301082624 ++read 4096/4096 bytes at offset 4301082624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4301119488 ++read 4096/4096 bytes at offset 4301119488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4301156352 ++read 4096/4096 bytes at offset 4301156352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4301193216 ++read 4096/4096 bytes at offset 4301193216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4301230080 ++read 4096/4096 bytes at offset 4301230080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4301266944 ++read 4096/4096 bytes at offset 4301266944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4301303808 ++read 4096/4096 bytes at offset 4301303808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4301340672 ++read 4096/4096 bytes at offset 4301340672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4301377536 ++read 4096/4096 bytes at offset 4301377536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4301414400 ++read 4096/4096 bytes at offset 4301414400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4301451264 ++read 4096/4096 bytes at offset 4301451264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4301488128 ++read 4096/4096 bytes at offset 4301488128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4301524992 ++read 4096/4096 bytes at offset 4301524992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4301561856 ++read 4096/4096 bytes at offset 4301561856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4301598720 ++read 4096/4096 bytes at offset 4301598720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4301635584 ++read 4096/4096 bytes at offset 4301635584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4301672448 ++read 4096/4096 bytes at offset 4301672448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4301709312 ++read 4096/4096 bytes at offset 4301709312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4301746176 ++read 4096/4096 bytes at offset 4301746176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4301783040 ++read 4096/4096 bytes at offset 4301783040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4301819904 ++read 4096/4096 bytes at offset 4301819904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4301856768 ++read 4096/4096 bytes at offset 4301856768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4301893632 ++read 4096/4096 bytes at offset 4301893632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4301930496 ++read 4096/4096 bytes at offset 4301930496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4301967360 ++read 4096/4096 bytes at offset 4301967360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4302004224 ++read 4096/4096 bytes at offset 4302004224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4302041088 ++read 4096/4096 bytes at offset 4302041088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4302077952 ++read 4096/4096 bytes at offset 4302077952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4302114816 ++read 4096/4096 bytes at offset 4302114816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4302151680 ++read 4096/4096 bytes at offset 4302151680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4302188544 ++read 4096/4096 bytes at offset 4302188544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4302225408 ++read 4096/4096 bytes at offset 4302225408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4302262272 ++read 4096/4096 bytes at offset 4302262272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4302299136 ++read 4096/4096 bytes at offset 4302299136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4302336000 ++read 4096/4096 bytes at offset 4302336000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4302372864 ++read 4096/4096 bytes at offset 4302372864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4302409728 ++read 4096/4096 bytes at offset 4302409728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4302446592 ++read 4096/4096 bytes at offset 4302446592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4302483456 ++read 4096/4096 bytes at offset 4302483456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4302520320 ++read 4096/4096 bytes at offset 4302520320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4302557184 ++read 4096/4096 bytes at offset 4302557184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4302594048 ++read 4096/4096 bytes at offset 4302594048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4302630912 ++read 4096/4096 bytes at offset 4302630912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4302667776 ++read 4096/4096 bytes at offset 4302667776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4302704640 ++read 4096/4096 bytes at offset 4302704640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4302741504 ++read 4096/4096 bytes at offset 4302741504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4302778368 ++read 4096/4096 bytes at offset 4302778368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4302815232 ++read 4096/4096 bytes at offset 4302815232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4302852096 ++read 4096/4096 bytes at offset 4302852096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4302888960 ++read 4096/4096 bytes at offset 4302888960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4302925824 ++read 4096/4096 bytes at offset 4302925824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4302962688 ++read 4096/4096 bytes at offset 4302962688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4302999552 ++read 4096/4096 bytes at offset 4302999552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4303036416 ++read 4096/4096 bytes at offset 4303036416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4303073280 ++read 4096/4096 bytes at offset 4303073280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4303110144 ++read 4096/4096 bytes at offset 4303110144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4303147008 ++read 4096/4096 bytes at offset 4303147008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4303183872 ++read 4096/4096 bytes at offset 4303183872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4303220736 ++read 4096/4096 bytes at offset 4303220736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4303257600 ++read 4096/4096 bytes at offset 4303257600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4303294464 ++read 4096/4096 bytes at offset 4303294464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4303331328 ++read 4096/4096 bytes at offset 4303331328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4303368192 ++read 4096/4096 bytes at offset 4303368192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4303405056 ++read 4096/4096 bytes at offset 4303405056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4303441920 ++read 4096/4096 bytes at offset 4303441920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4303478784 ++read 4096/4096 bytes at offset 4303478784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4303515648 ++read 4096/4096 bytes at offset 4303515648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4303552512 ++read 4096/4096 bytes at offset 4303552512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4303589376 ++read 4096/4096 bytes at offset 4303589376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4303626240 ++read 4096/4096 bytes at offset 4303626240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4303663104 ++read 4096/4096 bytes at offset 4303663104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4303699968 ++read 4096/4096 bytes at offset 4303699968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4303736832 ++read 4096/4096 bytes at offset 4303736832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4303773696 ++read 4096/4096 bytes at offset 4303773696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4303810560 ++read 4096/4096 bytes at offset 4303810560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4303847424 ++read 4096/4096 bytes at offset 4303847424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4303884288 ++read 4096/4096 bytes at offset 4303884288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4303921152 ++read 4096/4096 bytes at offset 4303921152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4303958016 ++read 4096/4096 bytes at offset 4303958016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4303994880 ++read 4096/4096 bytes at offset 4303994880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4304031744 ++read 4096/4096 bytes at offset 4304031744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4304068608 ++read 4096/4096 bytes at offset 4304068608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4304105472 ++read 4096/4096 bytes at offset 4304105472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4304142336 ++read 4096/4096 bytes at offset 4304142336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4304179200 ++read 4096/4096 bytes at offset 4304179200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4304216064 ++read 4096/4096 bytes at offset 4304216064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4304252928 ++read 4096/4096 bytes at offset 4304252928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4304289792 ++read 4096/4096 bytes at offset 4304289792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4304326656 ++read 4096/4096 bytes at offset 4304326656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4304363520 ++read 4096/4096 bytes at offset 4304363520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4304400384 ++read 4096/4096 bytes at offset 4304400384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === Read zeros ++=== Read zeros + === IO: pattern 0 +-qemu-io> read 4096/4096 bytes at offset 4294975488 ++read 4096/4096 bytes at offset 4294975488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295012352 ++read 4096/4096 bytes at offset 4295012352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295049216 ++read 4096/4096 bytes at offset 4295049216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295086080 ++read 4096/4096 bytes at offset 4295086080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295122944 ++read 4096/4096 bytes at offset 4295122944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295159808 ++read 4096/4096 bytes at offset 4295159808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295196672 ++read 4096/4096 bytes at offset 4295196672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295233536 ++read 4096/4096 bytes at offset 4295233536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295270400 ++read 4096/4096 bytes at offset 4295270400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295307264 ++read 4096/4096 bytes at offset 4295307264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295344128 ++read 4096/4096 bytes at offset 4295344128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295380992 ++read 4096/4096 bytes at offset 4295380992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295417856 ++read 4096/4096 bytes at offset 4295417856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295454720 ++read 4096/4096 bytes at offset 4295454720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295491584 ++read 4096/4096 bytes at offset 4295491584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295528448 ++read 4096/4096 bytes at offset 4295528448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295565312 ++read 4096/4096 bytes at offset 4295565312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295602176 ++read 4096/4096 bytes at offset 4295602176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295639040 ++read 4096/4096 bytes at offset 4295639040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295675904 ++read 4096/4096 bytes at offset 4295675904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295712768 ++read 4096/4096 bytes at offset 4295712768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295749632 ++read 4096/4096 bytes at offset 4295749632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295786496 ++read 4096/4096 bytes at offset 4295786496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295823360 ++read 4096/4096 bytes at offset 4295823360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295860224 ++read 4096/4096 bytes at offset 4295860224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295897088 ++read 4096/4096 bytes at offset 4295897088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295933952 ++read 4096/4096 bytes at offset 4295933952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295970816 ++read 4096/4096 bytes at offset 4295970816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4296007680 ++read 4096/4096 bytes at offset 4296007680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4296044544 ++read 4096/4096 bytes at offset 4296044544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4296081408 ++read 4096/4096 bytes at offset 4296081408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4296118272 ++read 4096/4096 bytes at offset 4296118272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4296155136 ++read 4096/4096 bytes at offset 4296155136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4296192000 ++read 4096/4096 bytes at offset 4296192000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4296228864 ++read 4096/4096 bytes at offset 4296228864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4296265728 ++read 4096/4096 bytes at offset 4296265728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4296302592 ++read 4096/4096 bytes at offset 4296302592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4296339456 ++read 4096/4096 bytes at offset 4296339456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4296376320 ++read 4096/4096 bytes at offset 4296376320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4296413184 ++read 4096/4096 bytes at offset 4296413184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4296450048 ++read 4096/4096 bytes at offset 4296450048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4296486912 ++read 4096/4096 bytes at offset 4296486912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4296523776 ++read 4096/4096 bytes at offset 4296523776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4296560640 ++read 4096/4096 bytes at offset 4296560640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4296597504 ++read 4096/4096 bytes at offset 4296597504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4296634368 ++read 4096/4096 bytes at offset 4296634368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4296671232 ++read 4096/4096 bytes at offset 4296671232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4296708096 ++read 4096/4096 bytes at offset 4296708096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4296744960 ++read 4096/4096 bytes at offset 4296744960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4296781824 ++read 4096/4096 bytes at offset 4296781824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4296818688 ++read 4096/4096 bytes at offset 4296818688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4296855552 ++read 4096/4096 bytes at offset 4296855552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4296892416 ++read 4096/4096 bytes at offset 4296892416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4296929280 ++read 4096/4096 bytes at offset 4296929280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4296966144 ++read 4096/4096 bytes at offset 4296966144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4297003008 ++read 4096/4096 bytes at offset 4297003008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4297039872 ++read 4096/4096 bytes at offset 4297039872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4297076736 ++read 4096/4096 bytes at offset 4297076736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4297113600 ++read 4096/4096 bytes at offset 4297113600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4297150464 ++read 4096/4096 bytes at offset 4297150464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4297187328 ++read 4096/4096 bytes at offset 4297187328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4297224192 ++read 4096/4096 bytes at offset 4297224192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4297261056 ++read 4096/4096 bytes at offset 4297261056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4297297920 ++read 4096/4096 bytes at offset 4297297920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4297334784 ++read 4096/4096 bytes at offset 4297334784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4297371648 ++read 4096/4096 bytes at offset 4297371648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4297408512 ++read 4096/4096 bytes at offset 4297408512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4297445376 ++read 4096/4096 bytes at offset 4297445376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4297482240 ++read 4096/4096 bytes at offset 4297482240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4297519104 ++read 4096/4096 bytes at offset 4297519104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4297555968 ++read 4096/4096 bytes at offset 4297555968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4297592832 ++read 4096/4096 bytes at offset 4297592832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4297629696 ++read 4096/4096 bytes at offset 4297629696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4297666560 ++read 4096/4096 bytes at offset 4297666560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4297703424 ++read 4096/4096 bytes at offset 4297703424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4297740288 ++read 4096/4096 bytes at offset 4297740288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4297777152 ++read 4096/4096 bytes at offset 4297777152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4297814016 ++read 4096/4096 bytes at offset 4297814016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4297850880 ++read 4096/4096 bytes at offset 4297850880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4297887744 ++read 4096/4096 bytes at offset 4297887744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4297924608 ++read 4096/4096 bytes at offset 4297924608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4297961472 ++read 4096/4096 bytes at offset 4297961472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4297998336 ++read 4096/4096 bytes at offset 4297998336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4298035200 ++read 4096/4096 bytes at offset 4298035200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4298072064 ++read 4096/4096 bytes at offset 4298072064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4298108928 ++read 4096/4096 bytes at offset 4298108928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4298145792 ++read 4096/4096 bytes at offset 4298145792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4298182656 ++read 4096/4096 bytes at offset 4298182656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4298219520 ++read 4096/4096 bytes at offset 4298219520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4298256384 ++read 4096/4096 bytes at offset 4298256384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4298293248 ++read 4096/4096 bytes at offset 4298293248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4298330112 ++read 4096/4096 bytes at offset 4298330112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4298366976 ++read 4096/4096 bytes at offset 4298366976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4298403840 ++read 4096/4096 bytes at offset 4298403840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4298440704 ++read 4096/4096 bytes at offset 4298440704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4298477568 ++read 4096/4096 bytes at offset 4298477568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4298514432 ++read 4096/4096 bytes at offset 4298514432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4298551296 ++read 4096/4096 bytes at offset 4298551296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4298588160 ++read 4096/4096 bytes at offset 4298588160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4298625024 ++read 4096/4096 bytes at offset 4298625024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4298661888 ++read 4096/4096 bytes at offset 4298661888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4298698752 ++read 4096/4096 bytes at offset 4298698752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4298735616 ++read 4096/4096 bytes at offset 4298735616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4298772480 ++read 4096/4096 bytes at offset 4298772480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4298809344 ++read 4096/4096 bytes at offset 4298809344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4298846208 ++read 4096/4096 bytes at offset 4298846208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4298883072 ++read 4096/4096 bytes at offset 4298883072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4298919936 ++read 4096/4096 bytes at offset 4298919936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4298956800 ++read 4096/4096 bytes at offset 4298956800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4298993664 ++read 4096/4096 bytes at offset 4298993664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4299030528 ++read 4096/4096 bytes at offset 4299030528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4299067392 ++read 4096/4096 bytes at offset 4299067392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4299104256 ++read 4096/4096 bytes at offset 4299104256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4299141120 ++read 4096/4096 bytes at offset 4299141120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4299177984 ++read 4096/4096 bytes at offset 4299177984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4299214848 ++read 4096/4096 bytes at offset 4299214848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4299251712 ++read 4096/4096 bytes at offset 4299251712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4299288576 ++read 4096/4096 bytes at offset 4299288576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4299325440 ++read 4096/4096 bytes at offset 4299325440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4299362304 ++read 4096/4096 bytes at offset 4299362304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4299399168 ++read 4096/4096 bytes at offset 4299399168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4299436032 ++read 4096/4096 bytes at offset 4299436032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4299472896 ++read 4096/4096 bytes at offset 4299472896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4299509760 ++read 4096/4096 bytes at offset 4299509760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4299546624 ++read 4096/4096 bytes at offset 4299546624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4299583488 ++read 4096/4096 bytes at offset 4299583488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4299620352 ++read 4096/4096 bytes at offset 4299620352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4299657216 ++read 4096/4096 bytes at offset 4299657216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4299694080 ++read 4096/4096 bytes at offset 4299694080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4299730944 ++read 4096/4096 bytes at offset 4299730944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4299767808 ++read 4096/4096 bytes at offset 4299767808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4299804672 ++read 4096/4096 bytes at offset 4299804672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4299841536 ++read 4096/4096 bytes at offset 4299841536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4299878400 ++read 4096/4096 bytes at offset 4299878400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4299915264 ++read 4096/4096 bytes at offset 4299915264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4299952128 ++read 4096/4096 bytes at offset 4299952128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4299988992 ++read 4096/4096 bytes at offset 4299988992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4300025856 ++read 4096/4096 bytes at offset 4300025856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4300062720 ++read 4096/4096 bytes at offset 4300062720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4300099584 ++read 4096/4096 bytes at offset 4300099584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4300136448 ++read 4096/4096 bytes at offset 4300136448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4300173312 ++read 4096/4096 bytes at offset 4300173312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4300210176 ++read 4096/4096 bytes at offset 4300210176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4300247040 ++read 4096/4096 bytes at offset 4300247040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4300283904 ++read 4096/4096 bytes at offset 4300283904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4300320768 ++read 4096/4096 bytes at offset 4300320768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4300357632 ++read 4096/4096 bytes at offset 4300357632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4300394496 ++read 4096/4096 bytes at offset 4300394496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4300431360 ++read 4096/4096 bytes at offset 4300431360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4300468224 ++read 4096/4096 bytes at offset 4300468224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4300505088 ++read 4096/4096 bytes at offset 4300505088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4300541952 ++read 4096/4096 bytes at offset 4300541952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4300578816 ++read 4096/4096 bytes at offset 4300578816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4300615680 ++read 4096/4096 bytes at offset 4300615680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4300652544 ++read 4096/4096 bytes at offset 4300652544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4300689408 ++read 4096/4096 bytes at offset 4300689408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4300726272 ++read 4096/4096 bytes at offset 4300726272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4300763136 ++read 4096/4096 bytes at offset 4300763136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4300800000 ++read 4096/4096 bytes at offset 4300800000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4300836864 ++read 4096/4096 bytes at offset 4300836864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4300873728 ++read 4096/4096 bytes at offset 4300873728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4300910592 ++read 4096/4096 bytes at offset 4300910592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4300947456 ++read 4096/4096 bytes at offset 4300947456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4300984320 ++read 4096/4096 bytes at offset 4300984320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4301021184 ++read 4096/4096 bytes at offset 4301021184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4301058048 ++read 4096/4096 bytes at offset 4301058048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4301094912 ++read 4096/4096 bytes at offset 4301094912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4301131776 ++read 4096/4096 bytes at offset 4301131776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4301168640 ++read 4096/4096 bytes at offset 4301168640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4301205504 ++read 4096/4096 bytes at offset 4301205504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4301242368 ++read 4096/4096 bytes at offset 4301242368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4301279232 ++read 4096/4096 bytes at offset 4301279232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4301316096 ++read 4096/4096 bytes at offset 4301316096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4301352960 ++read 4096/4096 bytes at offset 4301352960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4301389824 ++read 4096/4096 bytes at offset 4301389824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4301426688 ++read 4096/4096 bytes at offset 4301426688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4301463552 ++read 4096/4096 bytes at offset 4301463552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4301500416 ++read 4096/4096 bytes at offset 4301500416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4301537280 ++read 4096/4096 bytes at offset 4301537280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4301574144 ++read 4096/4096 bytes at offset 4301574144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4301611008 ++read 4096/4096 bytes at offset 4301611008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4301647872 ++read 4096/4096 bytes at offset 4301647872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4301684736 ++read 4096/4096 bytes at offset 4301684736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4301721600 ++read 4096/4096 bytes at offset 4301721600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4301758464 ++read 4096/4096 bytes at offset 4301758464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4301795328 ++read 4096/4096 bytes at offset 4301795328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4301832192 ++read 4096/4096 bytes at offset 4301832192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4301869056 ++read 4096/4096 bytes at offset 4301869056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4301905920 ++read 4096/4096 bytes at offset 4301905920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4301942784 ++read 4096/4096 bytes at offset 4301942784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4301979648 ++read 4096/4096 bytes at offset 4301979648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4302016512 ++read 4096/4096 bytes at offset 4302016512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4302053376 ++read 4096/4096 bytes at offset 4302053376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4302090240 ++read 4096/4096 bytes at offset 4302090240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4302127104 ++read 4096/4096 bytes at offset 4302127104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4302163968 ++read 4096/4096 bytes at offset 4302163968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4302200832 ++read 4096/4096 bytes at offset 4302200832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4302237696 ++read 4096/4096 bytes at offset 4302237696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4302274560 ++read 4096/4096 bytes at offset 4302274560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4302311424 ++read 4096/4096 bytes at offset 4302311424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4302348288 ++read 4096/4096 bytes at offset 4302348288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4302385152 ++read 4096/4096 bytes at offset 4302385152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4302422016 ++read 4096/4096 bytes at offset 4302422016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4302458880 ++read 4096/4096 bytes at offset 4302458880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4302495744 ++read 4096/4096 bytes at offset 4302495744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4302532608 ++read 4096/4096 bytes at offset 4302532608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4302569472 ++read 4096/4096 bytes at offset 4302569472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4302606336 ++read 4096/4096 bytes at offset 4302606336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4302643200 ++read 4096/4096 bytes at offset 4302643200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4302680064 ++read 4096/4096 bytes at offset 4302680064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4302716928 ++read 4096/4096 bytes at offset 4302716928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4302753792 ++read 4096/4096 bytes at offset 4302753792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4302790656 ++read 4096/4096 bytes at offset 4302790656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4302827520 ++read 4096/4096 bytes at offset 4302827520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4302864384 ++read 4096/4096 bytes at offset 4302864384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4302901248 ++read 4096/4096 bytes at offset 4302901248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4302938112 ++read 4096/4096 bytes at offset 4302938112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4302974976 ++read 4096/4096 bytes at offset 4302974976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4303011840 ++read 4096/4096 bytes at offset 4303011840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4303048704 ++read 4096/4096 bytes at offset 4303048704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4303085568 ++read 4096/4096 bytes at offset 4303085568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4303122432 ++read 4096/4096 bytes at offset 4303122432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4303159296 ++read 4096/4096 bytes at offset 4303159296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4303196160 ++read 4096/4096 bytes at offset 4303196160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4303233024 ++read 4096/4096 bytes at offset 4303233024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4303269888 ++read 4096/4096 bytes at offset 4303269888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4303306752 ++read 4096/4096 bytes at offset 4303306752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4303343616 ++read 4096/4096 bytes at offset 4303343616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4303380480 ++read 4096/4096 bytes at offset 4303380480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4303417344 ++read 4096/4096 bytes at offset 4303417344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4303454208 ++read 4096/4096 bytes at offset 4303454208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4303491072 ++read 4096/4096 bytes at offset 4303491072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4303527936 ++read 4096/4096 bytes at offset 4303527936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4303564800 ++read 4096/4096 bytes at offset 4303564800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4303601664 ++read 4096/4096 bytes at offset 4303601664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4303638528 ++read 4096/4096 bytes at offset 4303638528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4303675392 ++read 4096/4096 bytes at offset 4303675392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4303712256 ++read 4096/4096 bytes at offset 4303712256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4303749120 ++read 4096/4096 bytes at offset 4303749120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4303785984 ++read 4096/4096 bytes at offset 4303785984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4303822848 ++read 4096/4096 bytes at offset 4303822848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4303859712 ++read 4096/4096 bytes at offset 4303859712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4303896576 ++read 4096/4096 bytes at offset 4303896576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4303933440 ++read 4096/4096 bytes at offset 4303933440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4303970304 ++read 4096/4096 bytes at offset 4303970304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4304007168 ++read 4096/4096 bytes at offset 4304007168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4304044032 ++read 4096/4096 bytes at offset 4304044032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4304080896 ++read 4096/4096 bytes at offset 4304080896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4304117760 ++read 4096/4096 bytes at offset 4304117760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4304154624 ++read 4096/4096 bytes at offset 4304154624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4304191488 ++read 4096/4096 bytes at offset 4304191488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4304228352 ++read 4096/4096 bytes at offset 4304228352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4304265216 ++read 4096/4096 bytes at offset 4304265216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4304302080 ++read 4096/4096 bytes at offset 4304302080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4304338944 ++read 4096/4096 bytes at offset 4304338944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4304375808 ++read 4096/4096 bytes at offset 4304375808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> read 8192/8192 bytes at offset 4294991872 ++=== IO: pattern 0 ++read 8192/8192 bytes at offset 4294991872 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295028736 ++read 8192/8192 bytes at offset 4295028736 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295065600 ++read 8192/8192 bytes at offset 4295065600 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295102464 ++read 8192/8192 bytes at offset 4295102464 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295139328 ++read 8192/8192 bytes at offset 4295139328 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295176192 ++read 8192/8192 bytes at offset 4295176192 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295213056 ++read 8192/8192 bytes at offset 4295213056 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295249920 ++read 8192/8192 bytes at offset 4295249920 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295286784 ++read 8192/8192 bytes at offset 4295286784 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295323648 ++read 8192/8192 bytes at offset 4295323648 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295360512 ++read 8192/8192 bytes at offset 4295360512 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295397376 ++read 8192/8192 bytes at offset 4295397376 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295434240 ++read 8192/8192 bytes at offset 4295434240 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295471104 ++read 8192/8192 bytes at offset 4295471104 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295507968 ++read 8192/8192 bytes at offset 4295507968 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295544832 ++read 8192/8192 bytes at offset 4295544832 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295581696 ++read 8192/8192 bytes at offset 4295581696 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295618560 ++read 8192/8192 bytes at offset 4295618560 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295655424 ++read 8192/8192 bytes at offset 4295655424 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295692288 ++read 8192/8192 bytes at offset 4295692288 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295729152 ++read 8192/8192 bytes at offset 4295729152 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295766016 ++read 8192/8192 bytes at offset 4295766016 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295802880 ++read 8192/8192 bytes at offset 4295802880 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295839744 ++read 8192/8192 bytes at offset 4295839744 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295876608 ++read 8192/8192 bytes at offset 4295876608 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295913472 ++read 8192/8192 bytes at offset 4295913472 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295950336 ++read 8192/8192 bytes at offset 4295950336 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295987200 ++read 8192/8192 bytes at offset 4295987200 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296024064 ++read 8192/8192 bytes at offset 4296024064 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296060928 ++read 8192/8192 bytes at offset 4296060928 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296097792 ++read 8192/8192 bytes at offset 4296097792 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296134656 ++read 8192/8192 bytes at offset 4296134656 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296171520 ++read 8192/8192 bytes at offset 4296171520 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296208384 ++read 8192/8192 bytes at offset 4296208384 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296245248 ++read 8192/8192 bytes at offset 4296245248 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296282112 ++read 8192/8192 bytes at offset 4296282112 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296318976 ++read 8192/8192 bytes at offset 4296318976 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296355840 ++read 8192/8192 bytes at offset 4296355840 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296392704 ++read 8192/8192 bytes at offset 4296392704 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296429568 ++read 8192/8192 bytes at offset 4296429568 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296466432 ++read 8192/8192 bytes at offset 4296466432 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296503296 ++read 8192/8192 bytes at offset 4296503296 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296540160 ++read 8192/8192 bytes at offset 4296540160 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296577024 ++read 8192/8192 bytes at offset 4296577024 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296613888 ++read 8192/8192 bytes at offset 4296613888 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296650752 ++read 8192/8192 bytes at offset 4296650752 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296687616 ++read 8192/8192 bytes at offset 4296687616 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296724480 ++read 8192/8192 bytes at offset 4296724480 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296761344 ++read 8192/8192 bytes at offset 4296761344 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296798208 ++read 8192/8192 bytes at offset 4296798208 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296835072 ++read 8192/8192 bytes at offset 4296835072 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296871936 ++read 8192/8192 bytes at offset 4296871936 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296908800 ++read 8192/8192 bytes at offset 4296908800 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296945664 ++read 8192/8192 bytes at offset 4296945664 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296982528 ++read 8192/8192 bytes at offset 4296982528 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297019392 ++read 8192/8192 bytes at offset 4297019392 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297056256 ++read 8192/8192 bytes at offset 4297056256 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297093120 ++read 8192/8192 bytes at offset 4297093120 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297129984 ++read 8192/8192 bytes at offset 4297129984 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297166848 ++read 8192/8192 bytes at offset 4297166848 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297203712 ++read 8192/8192 bytes at offset 4297203712 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297240576 ++read 8192/8192 bytes at offset 4297240576 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297277440 ++read 8192/8192 bytes at offset 4297277440 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297314304 ++read 8192/8192 bytes at offset 4297314304 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297351168 ++read 8192/8192 bytes at offset 4297351168 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297388032 ++read 8192/8192 bytes at offset 4297388032 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297424896 ++read 8192/8192 bytes at offset 4297424896 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297461760 ++read 8192/8192 bytes at offset 4297461760 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297498624 ++read 8192/8192 bytes at offset 4297498624 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297535488 ++read 8192/8192 bytes at offset 4297535488 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297572352 ++read 8192/8192 bytes at offset 4297572352 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297609216 ++read 8192/8192 bytes at offset 4297609216 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297646080 ++read 8192/8192 bytes at offset 4297646080 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297682944 ++read 8192/8192 bytes at offset 4297682944 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297719808 ++read 8192/8192 bytes at offset 4297719808 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297756672 ++read 8192/8192 bytes at offset 4297756672 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297793536 ++read 8192/8192 bytes at offset 4297793536 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297830400 ++read 8192/8192 bytes at offset 4297830400 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297867264 ++read 8192/8192 bytes at offset 4297867264 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297904128 ++read 8192/8192 bytes at offset 4297904128 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297940992 ++read 8192/8192 bytes at offset 4297940992 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297977856 ++read 8192/8192 bytes at offset 4297977856 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4298014720 ++read 8192/8192 bytes at offset 4298014720 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4298051584 ++read 8192/8192 bytes at offset 4298051584 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4298088448 ++read 8192/8192 bytes at offset 4298088448 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4298125312 ++read 8192/8192 bytes at offset 4298125312 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4298162176 ++read 8192/8192 bytes at offset 4298162176 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4298199040 ++read 8192/8192 bytes at offset 4298199040 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4298235904 ++read 8192/8192 bytes at offset 4298235904 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4298272768 ++read 8192/8192 bytes at offset 4298272768 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4298309632 ++read 8192/8192 bytes at offset 4298309632 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4298346496 ++read 8192/8192 bytes at offset 4298346496 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4298383360 ++read 8192/8192 bytes at offset 4298383360 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4298420224 ++read 8192/8192 bytes at offset 4298420224 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4298457088 ++read 8192/8192 bytes at offset 4298457088 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4298493952 ++read 8192/8192 bytes at offset 4298493952 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4298530816 ++read 8192/8192 bytes at offset 4298530816 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4298567680 ++read 8192/8192 bytes at offset 4298567680 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4298604544 ++read 8192/8192 bytes at offset 4298604544 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4298641408 ++read 8192/8192 bytes at offset 4298641408 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4298678272 ++read 8192/8192 bytes at offset 4298678272 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4298715136 ++read 8192/8192 bytes at offset 4298715136 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4298752000 ++read 8192/8192 bytes at offset 4298752000 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4298788864 ++read 8192/8192 bytes at offset 4298788864 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4298825728 ++read 8192/8192 bytes at offset 4298825728 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4298862592 ++read 8192/8192 bytes at offset 4298862592 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4298899456 ++read 8192/8192 bytes at offset 4298899456 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4298936320 ++read 8192/8192 bytes at offset 4298936320 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4298973184 ++read 8192/8192 bytes at offset 4298973184 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299010048 ++read 8192/8192 bytes at offset 4299010048 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299046912 ++read 8192/8192 bytes at offset 4299046912 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299083776 ++read 8192/8192 bytes at offset 4299083776 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299120640 ++read 8192/8192 bytes at offset 4299120640 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299157504 ++read 8192/8192 bytes at offset 4299157504 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299194368 ++read 8192/8192 bytes at offset 4299194368 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299231232 ++read 8192/8192 bytes at offset 4299231232 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299268096 ++read 8192/8192 bytes at offset 4299268096 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299304960 ++read 8192/8192 bytes at offset 4299304960 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299341824 ++read 8192/8192 bytes at offset 4299341824 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299378688 ++read 8192/8192 bytes at offset 4299378688 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299415552 ++read 8192/8192 bytes at offset 4299415552 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299452416 ++read 8192/8192 bytes at offset 4299452416 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299489280 ++read 8192/8192 bytes at offset 4299489280 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299526144 ++read 8192/8192 bytes at offset 4299526144 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299563008 ++read 8192/8192 bytes at offset 4299563008 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299599872 ++read 8192/8192 bytes at offset 4299599872 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299636736 ++read 8192/8192 bytes at offset 4299636736 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299673600 ++read 8192/8192 bytes at offset 4299673600 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299710464 ++read 8192/8192 bytes at offset 4299710464 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299747328 ++read 8192/8192 bytes at offset 4299747328 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299784192 ++read 8192/8192 bytes at offset 4299784192 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299821056 ++read 8192/8192 bytes at offset 4299821056 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299857920 ++read 8192/8192 bytes at offset 4299857920 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299894784 ++read 8192/8192 bytes at offset 4299894784 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299931648 ++read 8192/8192 bytes at offset 4299931648 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299968512 ++read 8192/8192 bytes at offset 4299968512 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4300005376 ++read 8192/8192 bytes at offset 4300005376 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4300042240 ++read 8192/8192 bytes at offset 4300042240 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4300079104 ++read 8192/8192 bytes at offset 4300079104 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4300115968 ++read 8192/8192 bytes at offset 4300115968 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4300152832 ++read 8192/8192 bytes at offset 4300152832 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4300189696 ++read 8192/8192 bytes at offset 4300189696 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4300226560 ++read 8192/8192 bytes at offset 4300226560 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4300263424 ++read 8192/8192 bytes at offset 4300263424 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4300300288 ++read 8192/8192 bytes at offset 4300300288 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4300337152 ++read 8192/8192 bytes at offset 4300337152 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4300374016 ++read 8192/8192 bytes at offset 4300374016 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4300410880 ++read 8192/8192 bytes at offset 4300410880 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4300447744 ++read 8192/8192 bytes at offset 4300447744 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4300484608 ++read 8192/8192 bytes at offset 4300484608 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4300521472 ++read 8192/8192 bytes at offset 4300521472 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4300558336 ++read 8192/8192 bytes at offset 4300558336 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4300595200 ++read 8192/8192 bytes at offset 4300595200 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4300632064 ++read 8192/8192 bytes at offset 4300632064 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4300668928 ++read 8192/8192 bytes at offset 4300668928 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4300705792 ++read 8192/8192 bytes at offset 4300705792 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4300742656 ++read 8192/8192 bytes at offset 4300742656 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4300779520 ++read 8192/8192 bytes at offset 4300779520 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4300816384 ++read 8192/8192 bytes at offset 4300816384 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4300853248 ++read 8192/8192 bytes at offset 4300853248 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4300890112 ++read 8192/8192 bytes at offset 4300890112 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4300926976 ++read 8192/8192 bytes at offset 4300926976 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4300963840 ++read 8192/8192 bytes at offset 4300963840 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4301000704 ++read 8192/8192 bytes at offset 4301000704 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4301037568 ++read 8192/8192 bytes at offset 4301037568 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4301074432 ++read 8192/8192 bytes at offset 4301074432 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4301111296 ++read 8192/8192 bytes at offset 4301111296 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4301148160 ++read 8192/8192 bytes at offset 4301148160 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4301185024 ++read 8192/8192 bytes at offset 4301185024 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4301221888 ++read 8192/8192 bytes at offset 4301221888 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4301258752 ++read 8192/8192 bytes at offset 4301258752 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4301295616 ++read 8192/8192 bytes at offset 4301295616 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4301332480 ++read 8192/8192 bytes at offset 4301332480 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4301369344 ++read 8192/8192 bytes at offset 4301369344 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4301406208 ++read 8192/8192 bytes at offset 4301406208 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4301443072 ++read 8192/8192 bytes at offset 4301443072 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4301479936 ++read 8192/8192 bytes at offset 4301479936 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4301516800 ++read 8192/8192 bytes at offset 4301516800 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4301553664 ++read 8192/8192 bytes at offset 4301553664 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4301590528 ++read 8192/8192 bytes at offset 4301590528 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4301627392 ++read 8192/8192 bytes at offset 4301627392 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4301664256 ++read 8192/8192 bytes at offset 4301664256 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4301701120 ++read 8192/8192 bytes at offset 4301701120 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4301737984 ++read 8192/8192 bytes at offset 4301737984 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4301774848 ++read 8192/8192 bytes at offset 4301774848 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4301811712 ++read 8192/8192 bytes at offset 4301811712 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4301848576 ++read 8192/8192 bytes at offset 4301848576 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4301885440 ++read 8192/8192 bytes at offset 4301885440 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4301922304 ++read 8192/8192 bytes at offset 4301922304 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4301959168 ++read 8192/8192 bytes at offset 4301959168 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4301996032 ++read 8192/8192 bytes at offset 4301996032 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4302032896 ++read 8192/8192 bytes at offset 4302032896 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4302069760 ++read 8192/8192 bytes at offset 4302069760 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4302106624 ++read 8192/8192 bytes at offset 4302106624 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4302143488 ++read 8192/8192 bytes at offset 4302143488 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4302180352 ++read 8192/8192 bytes at offset 4302180352 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4302217216 ++read 8192/8192 bytes at offset 4302217216 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4302254080 ++read 8192/8192 bytes at offset 4302254080 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4302290944 ++read 8192/8192 bytes at offset 4302290944 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4302327808 ++read 8192/8192 bytes at offset 4302327808 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4302364672 ++read 8192/8192 bytes at offset 4302364672 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4302401536 ++read 8192/8192 bytes at offset 4302401536 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4302438400 ++read 8192/8192 bytes at offset 4302438400 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4302475264 ++read 8192/8192 bytes at offset 4302475264 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4302512128 ++read 8192/8192 bytes at offset 4302512128 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4302548992 ++read 8192/8192 bytes at offset 4302548992 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4302585856 ++read 8192/8192 bytes at offset 4302585856 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4302622720 ++read 8192/8192 bytes at offset 4302622720 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4302659584 ++read 8192/8192 bytes at offset 4302659584 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4302696448 ++read 8192/8192 bytes at offset 4302696448 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4302733312 ++read 8192/8192 bytes at offset 4302733312 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4302770176 ++read 8192/8192 bytes at offset 4302770176 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4302807040 ++read 8192/8192 bytes at offset 4302807040 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4302843904 ++read 8192/8192 bytes at offset 4302843904 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4302880768 ++read 8192/8192 bytes at offset 4302880768 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4302917632 ++read 8192/8192 bytes at offset 4302917632 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4302954496 ++read 8192/8192 bytes at offset 4302954496 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4302991360 ++read 8192/8192 bytes at offset 4302991360 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4303028224 ++read 8192/8192 bytes at offset 4303028224 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4303065088 ++read 8192/8192 bytes at offset 4303065088 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4303101952 ++read 8192/8192 bytes at offset 4303101952 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4303138816 ++read 8192/8192 bytes at offset 4303138816 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4303175680 ++read 8192/8192 bytes at offset 4303175680 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4303212544 ++read 8192/8192 bytes at offset 4303212544 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4303249408 ++read 8192/8192 bytes at offset 4303249408 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4303286272 ++read 8192/8192 bytes at offset 4303286272 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4303323136 ++read 8192/8192 bytes at offset 4303323136 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4303360000 ++read 8192/8192 bytes at offset 4303360000 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4303396864 ++read 8192/8192 bytes at offset 4303396864 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4303433728 ++read 8192/8192 bytes at offset 4303433728 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4303470592 ++read 8192/8192 bytes at offset 4303470592 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4303507456 ++read 8192/8192 bytes at offset 4303507456 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4303544320 ++read 8192/8192 bytes at offset 4303544320 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4303581184 ++read 8192/8192 bytes at offset 4303581184 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4303618048 ++read 8192/8192 bytes at offset 4303618048 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4303654912 ++read 8192/8192 bytes at offset 4303654912 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4303691776 ++read 8192/8192 bytes at offset 4303691776 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4303728640 ++read 8192/8192 bytes at offset 4303728640 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4303765504 ++read 8192/8192 bytes at offset 4303765504 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4303802368 ++read 8192/8192 bytes at offset 4303802368 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4303839232 ++read 8192/8192 bytes at offset 4303839232 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4303876096 ++read 8192/8192 bytes at offset 4303876096 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4303912960 ++read 8192/8192 bytes at offset 4303912960 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4303949824 ++read 8192/8192 bytes at offset 4303949824 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4303986688 ++read 8192/8192 bytes at offset 4303986688 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4304023552 ++read 8192/8192 bytes at offset 4304023552 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4304060416 ++read 8192/8192 bytes at offset 4304060416 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4304097280 ++read 8192/8192 bytes at offset 4304097280 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4304134144 ++read 8192/8192 bytes at offset 4304134144 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4304171008 ++read 8192/8192 bytes at offset 4304171008 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4304207872 ++read 8192/8192 bytes at offset 4304207872 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4304244736 ++read 8192/8192 bytes at offset 4304244736 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4304281600 ++read 8192/8192 bytes at offset 4304281600 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4304318464 ++read 8192/8192 bytes at offset 4304318464 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4304355328 ++read 8192/8192 bytes at offset 4304355328 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4304392192 ++read 8192/8192 bytes at offset 4304392192 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> No errors were found on the image. ++No errors were found on the image. + With snapshot test1, offset 0 + === IO: pattern 0 +-qemu-io> wrote 4096/4096 bytes at offset 0 ++wrote 4096/4096 bytes at offset 0 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4096 ++wrote 4096/4096 bytes at offset 4096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8192 ++wrote 4096/4096 bytes at offset 8192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 12288 ++wrote 4096/4096 bytes at offset 12288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 16384 ++wrote 4096/4096 bytes at offset 16384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 20480 ++wrote 4096/4096 bytes at offset 20480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 24576 ++wrote 4096/4096 bytes at offset 24576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 28672 ++wrote 4096/4096 bytes at offset 28672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 32768 ++wrote 4096/4096 bytes at offset 32768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 36864 ++wrote 4096/4096 bytes at offset 36864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 40960 ++wrote 4096/4096 bytes at offset 40960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 45056 ++wrote 4096/4096 bytes at offset 45056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 49152 ++wrote 4096/4096 bytes at offset 49152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 53248 ++wrote 4096/4096 bytes at offset 53248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 57344 ++wrote 4096/4096 bytes at offset 57344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 61440 ++wrote 4096/4096 bytes at offset 61440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 65536 ++wrote 4096/4096 bytes at offset 65536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 69632 ++wrote 4096/4096 bytes at offset 69632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 73728 ++wrote 4096/4096 bytes at offset 73728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 77824 ++wrote 4096/4096 bytes at offset 77824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 81920 ++wrote 4096/4096 bytes at offset 81920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 86016 ++wrote 4096/4096 bytes at offset 86016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 90112 ++wrote 4096/4096 bytes at offset 90112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 94208 ++wrote 4096/4096 bytes at offset 94208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 98304 ++wrote 4096/4096 bytes at offset 98304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 102400 ++wrote 4096/4096 bytes at offset 102400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 106496 ++wrote 4096/4096 bytes at offset 106496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 110592 ++wrote 4096/4096 bytes at offset 110592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 114688 ++wrote 4096/4096 bytes at offset 114688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 118784 ++wrote 4096/4096 bytes at offset 118784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 122880 ++wrote 4096/4096 bytes at offset 122880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 126976 ++wrote 4096/4096 bytes at offset 126976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 131072 ++wrote 4096/4096 bytes at offset 131072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 135168 ++wrote 4096/4096 bytes at offset 135168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 139264 ++wrote 4096/4096 bytes at offset 139264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 143360 ++wrote 4096/4096 bytes at offset 143360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 147456 ++wrote 4096/4096 bytes at offset 147456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 151552 ++wrote 4096/4096 bytes at offset 151552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 155648 ++wrote 4096/4096 bytes at offset 155648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 159744 ++wrote 4096/4096 bytes at offset 159744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 163840 ++wrote 4096/4096 bytes at offset 163840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 167936 ++wrote 4096/4096 bytes at offset 167936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 172032 ++wrote 4096/4096 bytes at offset 172032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 176128 ++wrote 4096/4096 bytes at offset 176128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 180224 ++wrote 4096/4096 bytes at offset 180224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 184320 ++wrote 4096/4096 bytes at offset 184320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 188416 ++wrote 4096/4096 bytes at offset 188416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 192512 ++wrote 4096/4096 bytes at offset 192512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 196608 ++wrote 4096/4096 bytes at offset 196608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 200704 ++wrote 4096/4096 bytes at offset 200704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 204800 ++wrote 4096/4096 bytes at offset 204800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 208896 ++wrote 4096/4096 bytes at offset 208896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 212992 ++wrote 4096/4096 bytes at offset 212992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 217088 ++wrote 4096/4096 bytes at offset 217088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 221184 ++wrote 4096/4096 bytes at offset 221184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 225280 ++wrote 4096/4096 bytes at offset 225280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 229376 ++wrote 4096/4096 bytes at offset 229376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 233472 ++wrote 4096/4096 bytes at offset 233472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 237568 ++wrote 4096/4096 bytes at offset 237568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 241664 ++wrote 4096/4096 bytes at offset 241664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 245760 ++wrote 4096/4096 bytes at offset 245760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 249856 ++wrote 4096/4096 bytes at offset 249856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 253952 ++wrote 4096/4096 bytes at offset 253952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 258048 ++wrote 4096/4096 bytes at offset 258048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 262144 ++wrote 4096/4096 bytes at offset 262144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 266240 ++wrote 4096/4096 bytes at offset 266240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 270336 ++wrote 4096/4096 bytes at offset 270336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 274432 ++wrote 4096/4096 bytes at offset 274432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 278528 ++wrote 4096/4096 bytes at offset 278528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 282624 ++wrote 4096/4096 bytes at offset 282624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 286720 ++wrote 4096/4096 bytes at offset 286720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 290816 ++wrote 4096/4096 bytes at offset 290816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 294912 ++wrote 4096/4096 bytes at offset 294912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 299008 ++wrote 4096/4096 bytes at offset 299008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 303104 ++wrote 4096/4096 bytes at offset 303104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 307200 ++wrote 4096/4096 bytes at offset 307200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 311296 ++wrote 4096/4096 bytes at offset 311296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 315392 ++wrote 4096/4096 bytes at offset 315392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 319488 ++wrote 4096/4096 bytes at offset 319488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 323584 ++wrote 4096/4096 bytes at offset 323584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 327680 ++wrote 4096/4096 bytes at offset 327680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 331776 ++wrote 4096/4096 bytes at offset 331776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 335872 ++wrote 4096/4096 bytes at offset 335872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 339968 ++wrote 4096/4096 bytes at offset 339968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 344064 ++wrote 4096/4096 bytes at offset 344064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 348160 ++wrote 4096/4096 bytes at offset 348160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 352256 ++wrote 4096/4096 bytes at offset 352256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 356352 ++wrote 4096/4096 bytes at offset 356352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 360448 ++wrote 4096/4096 bytes at offset 360448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 364544 ++wrote 4096/4096 bytes at offset 364544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 368640 ++wrote 4096/4096 bytes at offset 368640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 372736 ++wrote 4096/4096 bytes at offset 372736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 376832 ++wrote 4096/4096 bytes at offset 376832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 380928 ++wrote 4096/4096 bytes at offset 380928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 385024 ++wrote 4096/4096 bytes at offset 385024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 389120 ++wrote 4096/4096 bytes at offset 389120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 393216 ++wrote 4096/4096 bytes at offset 393216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 397312 ++wrote 4096/4096 bytes at offset 397312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 401408 ++wrote 4096/4096 bytes at offset 401408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 405504 ++wrote 4096/4096 bytes at offset 405504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 409600 ++wrote 4096/4096 bytes at offset 409600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 413696 ++wrote 4096/4096 bytes at offset 413696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 417792 ++wrote 4096/4096 bytes at offset 417792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 421888 ++wrote 4096/4096 bytes at offset 421888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 425984 ++wrote 4096/4096 bytes at offset 425984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 430080 ++wrote 4096/4096 bytes at offset 430080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 434176 ++wrote 4096/4096 bytes at offset 434176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 438272 ++wrote 4096/4096 bytes at offset 438272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 442368 ++wrote 4096/4096 bytes at offset 442368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 446464 ++wrote 4096/4096 bytes at offset 446464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 450560 ++wrote 4096/4096 bytes at offset 450560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 454656 ++wrote 4096/4096 bytes at offset 454656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 458752 ++wrote 4096/4096 bytes at offset 458752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 462848 ++wrote 4096/4096 bytes at offset 462848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 466944 ++wrote 4096/4096 bytes at offset 466944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 471040 ++wrote 4096/4096 bytes at offset 471040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 475136 ++wrote 4096/4096 bytes at offset 475136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 479232 ++wrote 4096/4096 bytes at offset 479232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 483328 ++wrote 4096/4096 bytes at offset 483328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 487424 ++wrote 4096/4096 bytes at offset 487424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 491520 ++wrote 4096/4096 bytes at offset 491520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 495616 ++wrote 4096/4096 bytes at offset 495616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 499712 ++wrote 4096/4096 bytes at offset 499712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 503808 ++wrote 4096/4096 bytes at offset 503808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 507904 ++wrote 4096/4096 bytes at offset 507904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 512000 ++wrote 4096/4096 bytes at offset 512000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 516096 ++wrote 4096/4096 bytes at offset 516096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 520192 ++wrote 4096/4096 bytes at offset 520192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 524288 ++wrote 4096/4096 bytes at offset 524288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 528384 ++wrote 4096/4096 bytes at offset 528384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 532480 ++wrote 4096/4096 bytes at offset 532480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 536576 ++wrote 4096/4096 bytes at offset 536576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 540672 ++wrote 4096/4096 bytes at offset 540672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 544768 ++wrote 4096/4096 bytes at offset 544768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 548864 ++wrote 4096/4096 bytes at offset 548864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 552960 ++wrote 4096/4096 bytes at offset 552960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 557056 ++wrote 4096/4096 bytes at offset 557056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 561152 ++wrote 4096/4096 bytes at offset 561152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 565248 ++wrote 4096/4096 bytes at offset 565248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 569344 ++wrote 4096/4096 bytes at offset 569344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 573440 ++wrote 4096/4096 bytes at offset 573440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 577536 ++wrote 4096/4096 bytes at offset 577536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 581632 ++wrote 4096/4096 bytes at offset 581632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 585728 ++wrote 4096/4096 bytes at offset 585728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 589824 ++wrote 4096/4096 bytes at offset 589824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 593920 ++wrote 4096/4096 bytes at offset 593920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 598016 ++wrote 4096/4096 bytes at offset 598016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 602112 ++wrote 4096/4096 bytes at offset 602112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 606208 ++wrote 4096/4096 bytes at offset 606208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 610304 ++wrote 4096/4096 bytes at offset 610304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 614400 ++wrote 4096/4096 bytes at offset 614400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 618496 ++wrote 4096/4096 bytes at offset 618496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 622592 ++wrote 4096/4096 bytes at offset 622592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 626688 ++wrote 4096/4096 bytes at offset 626688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 630784 ++wrote 4096/4096 bytes at offset 630784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 634880 ++wrote 4096/4096 bytes at offset 634880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 638976 ++wrote 4096/4096 bytes at offset 638976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 643072 ++wrote 4096/4096 bytes at offset 643072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 647168 ++wrote 4096/4096 bytes at offset 647168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 651264 ++wrote 4096/4096 bytes at offset 651264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 655360 ++wrote 4096/4096 bytes at offset 655360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 659456 ++wrote 4096/4096 bytes at offset 659456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 663552 ++wrote 4096/4096 bytes at offset 663552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 667648 ++wrote 4096/4096 bytes at offset 667648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 671744 ++wrote 4096/4096 bytes at offset 671744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 675840 ++wrote 4096/4096 bytes at offset 675840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 679936 ++wrote 4096/4096 bytes at offset 679936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 684032 ++wrote 4096/4096 bytes at offset 684032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 688128 ++wrote 4096/4096 bytes at offset 688128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 692224 ++wrote 4096/4096 bytes at offset 692224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 696320 ++wrote 4096/4096 bytes at offset 696320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 700416 ++wrote 4096/4096 bytes at offset 700416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 704512 ++wrote 4096/4096 bytes at offset 704512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 708608 ++wrote 4096/4096 bytes at offset 708608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 712704 ++wrote 4096/4096 bytes at offset 712704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 716800 ++wrote 4096/4096 bytes at offset 716800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 720896 ++wrote 4096/4096 bytes at offset 720896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 724992 ++wrote 4096/4096 bytes at offset 724992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 729088 ++wrote 4096/4096 bytes at offset 729088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 733184 ++wrote 4096/4096 bytes at offset 733184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 737280 ++wrote 4096/4096 bytes at offset 737280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 741376 ++wrote 4096/4096 bytes at offset 741376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 745472 ++wrote 4096/4096 bytes at offset 745472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 749568 ++wrote 4096/4096 bytes at offset 749568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 753664 ++wrote 4096/4096 bytes at offset 753664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 757760 ++wrote 4096/4096 bytes at offset 757760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 761856 ++wrote 4096/4096 bytes at offset 761856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 765952 ++wrote 4096/4096 bytes at offset 765952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 770048 ++wrote 4096/4096 bytes at offset 770048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 774144 ++wrote 4096/4096 bytes at offset 774144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 778240 ++wrote 4096/4096 bytes at offset 778240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 782336 ++wrote 4096/4096 bytes at offset 782336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 786432 ++wrote 4096/4096 bytes at offset 786432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 790528 ++wrote 4096/4096 bytes at offset 790528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 794624 ++wrote 4096/4096 bytes at offset 794624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 798720 ++wrote 4096/4096 bytes at offset 798720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 802816 ++wrote 4096/4096 bytes at offset 802816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 806912 ++wrote 4096/4096 bytes at offset 806912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 811008 ++wrote 4096/4096 bytes at offset 811008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 815104 ++wrote 4096/4096 bytes at offset 815104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 819200 ++wrote 4096/4096 bytes at offset 819200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 823296 ++wrote 4096/4096 bytes at offset 823296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 827392 ++wrote 4096/4096 bytes at offset 827392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 831488 ++wrote 4096/4096 bytes at offset 831488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 835584 ++wrote 4096/4096 bytes at offset 835584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 839680 ++wrote 4096/4096 bytes at offset 839680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 843776 ++wrote 4096/4096 bytes at offset 843776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 847872 ++wrote 4096/4096 bytes at offset 847872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 851968 ++wrote 4096/4096 bytes at offset 851968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 856064 ++wrote 4096/4096 bytes at offset 856064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 860160 ++wrote 4096/4096 bytes at offset 860160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 864256 ++wrote 4096/4096 bytes at offset 864256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 868352 ++wrote 4096/4096 bytes at offset 868352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 872448 ++wrote 4096/4096 bytes at offset 872448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 876544 ++wrote 4096/4096 bytes at offset 876544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 880640 ++wrote 4096/4096 bytes at offset 880640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 884736 ++wrote 4096/4096 bytes at offset 884736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 888832 ++wrote 4096/4096 bytes at offset 888832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 892928 ++wrote 4096/4096 bytes at offset 892928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 897024 ++wrote 4096/4096 bytes at offset 897024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 901120 ++wrote 4096/4096 bytes at offset 901120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 905216 ++wrote 4096/4096 bytes at offset 905216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 909312 ++wrote 4096/4096 bytes at offset 909312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 913408 ++wrote 4096/4096 bytes at offset 913408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 917504 ++wrote 4096/4096 bytes at offset 917504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 921600 ++wrote 4096/4096 bytes at offset 921600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 925696 ++wrote 4096/4096 bytes at offset 925696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 929792 ++wrote 4096/4096 bytes at offset 929792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 933888 ++wrote 4096/4096 bytes at offset 933888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 937984 ++wrote 4096/4096 bytes at offset 937984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 942080 ++wrote 4096/4096 bytes at offset 942080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 946176 ++wrote 4096/4096 bytes at offset 946176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 950272 ++wrote 4096/4096 bytes at offset 950272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 954368 ++wrote 4096/4096 bytes at offset 954368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 958464 ++wrote 4096/4096 bytes at offset 958464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 962560 ++wrote 4096/4096 bytes at offset 962560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 966656 ++wrote 4096/4096 bytes at offset 966656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 970752 ++wrote 4096/4096 bytes at offset 970752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 974848 ++wrote 4096/4096 bytes at offset 974848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 978944 ++wrote 4096/4096 bytes at offset 978944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 983040 ++wrote 4096/4096 bytes at offset 983040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 987136 ++wrote 4096/4096 bytes at offset 987136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 991232 ++wrote 4096/4096 bytes at offset 991232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 995328 ++wrote 4096/4096 bytes at offset 995328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 999424 ++wrote 4096/4096 bytes at offset 999424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1003520 ++wrote 4096/4096 bytes at offset 1003520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1007616 ++wrote 4096/4096 bytes at offset 1007616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1011712 ++wrote 4096/4096 bytes at offset 1011712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1015808 ++wrote 4096/4096 bytes at offset 1015808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1019904 ++wrote 4096/4096 bytes at offset 1019904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1024000 ++wrote 4096/4096 bytes at offset 1024000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1028096 ++wrote 4096/4096 bytes at offset 1028096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1032192 ++wrote 4096/4096 bytes at offset 1032192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1036288 ++wrote 4096/4096 bytes at offset 1036288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1040384 ++wrote 4096/4096 bytes at offset 1040384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1044480 ++wrote 4096/4096 bytes at offset 1044480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 4 +-qemu-io> wrote 2048/2048 bytes at offset 1050624 ++=== IO: pattern 4 ++wrote 2048/2048 bytes at offset 1050624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1054720 ++wrote 2048/2048 bytes at offset 1054720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1058816 ++wrote 2048/2048 bytes at offset 1058816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1062912 ++wrote 2048/2048 bytes at offset 1062912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1067008 ++wrote 2048/2048 bytes at offset 1067008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1071104 ++wrote 2048/2048 bytes at offset 1071104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1075200 ++wrote 2048/2048 bytes at offset 1075200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1079296 ++wrote 2048/2048 bytes at offset 1079296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1083392 ++wrote 2048/2048 bytes at offset 1083392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1087488 ++wrote 2048/2048 bytes at offset 1087488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1091584 ++wrote 2048/2048 bytes at offset 1091584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1095680 ++wrote 2048/2048 bytes at offset 1095680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1099776 ++wrote 2048/2048 bytes at offset 1099776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1103872 ++wrote 2048/2048 bytes at offset 1103872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1107968 ++wrote 2048/2048 bytes at offset 1107968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1112064 ++wrote 2048/2048 bytes at offset 1112064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1116160 ++wrote 2048/2048 bytes at offset 1116160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1120256 ++wrote 2048/2048 bytes at offset 1120256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1124352 ++wrote 2048/2048 bytes at offset 1124352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1128448 ++wrote 2048/2048 bytes at offset 1128448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1132544 ++wrote 2048/2048 bytes at offset 1132544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1136640 ++wrote 2048/2048 bytes at offset 1136640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1140736 ++wrote 2048/2048 bytes at offset 1140736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1144832 ++wrote 2048/2048 bytes at offset 1144832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1148928 ++wrote 2048/2048 bytes at offset 1148928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1153024 ++wrote 2048/2048 bytes at offset 1153024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1157120 ++wrote 2048/2048 bytes at offset 1157120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1161216 ++wrote 2048/2048 bytes at offset 1161216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1165312 ++wrote 2048/2048 bytes at offset 1165312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1169408 ++wrote 2048/2048 bytes at offset 1169408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1173504 ++wrote 2048/2048 bytes at offset 1173504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1177600 ++wrote 2048/2048 bytes at offset 1177600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1181696 ++wrote 2048/2048 bytes at offset 1181696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1185792 ++wrote 2048/2048 bytes at offset 1185792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1189888 ++wrote 2048/2048 bytes at offset 1189888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1193984 ++wrote 2048/2048 bytes at offset 1193984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1198080 ++wrote 2048/2048 bytes at offset 1198080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1202176 ++wrote 2048/2048 bytes at offset 1202176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1206272 ++wrote 2048/2048 bytes at offset 1206272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1210368 ++wrote 2048/2048 bytes at offset 1210368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1214464 ++wrote 2048/2048 bytes at offset 1214464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1218560 ++wrote 2048/2048 bytes at offset 1218560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1222656 ++wrote 2048/2048 bytes at offset 1222656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1226752 ++wrote 2048/2048 bytes at offset 1226752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1230848 ++wrote 2048/2048 bytes at offset 1230848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1234944 ++wrote 2048/2048 bytes at offset 1234944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1239040 ++wrote 2048/2048 bytes at offset 1239040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1243136 ++wrote 2048/2048 bytes at offset 1243136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1247232 ++wrote 2048/2048 bytes at offset 1247232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1251328 ++wrote 2048/2048 bytes at offset 1251328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1255424 ++wrote 2048/2048 bytes at offset 1255424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1259520 ++wrote 2048/2048 bytes at offset 1259520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1263616 ++wrote 2048/2048 bytes at offset 1263616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1267712 ++wrote 2048/2048 bytes at offset 1267712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1271808 ++wrote 2048/2048 bytes at offset 1271808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1275904 ++wrote 2048/2048 bytes at offset 1275904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1280000 ++wrote 2048/2048 bytes at offset 1280000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1284096 ++wrote 2048/2048 bytes at offset 1284096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1288192 ++wrote 2048/2048 bytes at offset 1288192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1292288 ++wrote 2048/2048 bytes at offset 1292288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1296384 ++wrote 2048/2048 bytes at offset 1296384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1300480 ++wrote 2048/2048 bytes at offset 1300480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1304576 ++wrote 2048/2048 bytes at offset 1304576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1308672 ++wrote 2048/2048 bytes at offset 1308672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1312768 ++wrote 2048/2048 bytes at offset 1312768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1316864 ++wrote 2048/2048 bytes at offset 1316864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1320960 ++wrote 2048/2048 bytes at offset 1320960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1325056 ++wrote 2048/2048 bytes at offset 1325056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1329152 ++wrote 2048/2048 bytes at offset 1329152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1333248 ++wrote 2048/2048 bytes at offset 1333248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1337344 ++wrote 2048/2048 bytes at offset 1337344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1341440 ++wrote 2048/2048 bytes at offset 1341440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1345536 ++wrote 2048/2048 bytes at offset 1345536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1349632 ++wrote 2048/2048 bytes at offset 1349632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1353728 ++wrote 2048/2048 bytes at offset 1353728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1357824 ++wrote 2048/2048 bytes at offset 1357824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1361920 ++wrote 2048/2048 bytes at offset 1361920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1366016 ++wrote 2048/2048 bytes at offset 1366016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1370112 ++wrote 2048/2048 bytes at offset 1370112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1374208 ++wrote 2048/2048 bytes at offset 1374208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1378304 ++wrote 2048/2048 bytes at offset 1378304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1382400 ++wrote 2048/2048 bytes at offset 1382400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1386496 ++wrote 2048/2048 bytes at offset 1386496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1390592 ++wrote 2048/2048 bytes at offset 1390592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1394688 ++wrote 2048/2048 bytes at offset 1394688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1398784 ++wrote 2048/2048 bytes at offset 1398784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1402880 ++wrote 2048/2048 bytes at offset 1402880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1406976 ++wrote 2048/2048 bytes at offset 1406976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1411072 ++wrote 2048/2048 bytes at offset 1411072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1415168 ++wrote 2048/2048 bytes at offset 1415168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1419264 ++wrote 2048/2048 bytes at offset 1419264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1423360 ++wrote 2048/2048 bytes at offset 1423360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1427456 ++wrote 2048/2048 bytes at offset 1427456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1431552 ++wrote 2048/2048 bytes at offset 1431552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1435648 ++wrote 2048/2048 bytes at offset 1435648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1439744 ++wrote 2048/2048 bytes at offset 1439744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1443840 ++wrote 2048/2048 bytes at offset 1443840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1447936 ++wrote 2048/2048 bytes at offset 1447936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1452032 ++wrote 2048/2048 bytes at offset 1452032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1456128 ++wrote 2048/2048 bytes at offset 1456128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1460224 ++wrote 2048/2048 bytes at offset 1460224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1464320 ++wrote 2048/2048 bytes at offset 1464320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1468416 ++wrote 2048/2048 bytes at offset 1468416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1472512 ++wrote 2048/2048 bytes at offset 1472512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1476608 ++wrote 2048/2048 bytes at offset 1476608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1480704 ++wrote 2048/2048 bytes at offset 1480704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1484800 ++wrote 2048/2048 bytes at offset 1484800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1488896 ++wrote 2048/2048 bytes at offset 1488896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1492992 ++wrote 2048/2048 bytes at offset 1492992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1497088 ++wrote 2048/2048 bytes at offset 1497088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1501184 ++wrote 2048/2048 bytes at offset 1501184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1505280 ++wrote 2048/2048 bytes at offset 1505280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1509376 ++wrote 2048/2048 bytes at offset 1509376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1513472 ++wrote 2048/2048 bytes at offset 1513472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1517568 ++wrote 2048/2048 bytes at offset 1517568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1521664 ++wrote 2048/2048 bytes at offset 1521664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1525760 ++wrote 2048/2048 bytes at offset 1525760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1529856 ++wrote 2048/2048 bytes at offset 1529856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1533952 ++wrote 2048/2048 bytes at offset 1533952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1538048 ++wrote 2048/2048 bytes at offset 1538048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1542144 ++wrote 2048/2048 bytes at offset 1542144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1546240 ++wrote 2048/2048 bytes at offset 1546240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1550336 ++wrote 2048/2048 bytes at offset 1550336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1554432 ++wrote 2048/2048 bytes at offset 1554432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1558528 ++wrote 2048/2048 bytes at offset 1558528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1562624 ++wrote 2048/2048 bytes at offset 1562624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1566720 ++wrote 2048/2048 bytes at offset 1566720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1570816 ++wrote 2048/2048 bytes at offset 1570816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1574912 ++wrote 2048/2048 bytes at offset 1574912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1579008 ++wrote 2048/2048 bytes at offset 1579008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1583104 ++wrote 2048/2048 bytes at offset 1583104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1587200 ++wrote 2048/2048 bytes at offset 1587200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1591296 ++wrote 2048/2048 bytes at offset 1591296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1595392 ++wrote 2048/2048 bytes at offset 1595392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1599488 ++wrote 2048/2048 bytes at offset 1599488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1603584 ++wrote 2048/2048 bytes at offset 1603584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1607680 ++wrote 2048/2048 bytes at offset 1607680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1611776 ++wrote 2048/2048 bytes at offset 1611776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1615872 ++wrote 2048/2048 bytes at offset 1615872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1619968 ++wrote 2048/2048 bytes at offset 1619968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1624064 ++wrote 2048/2048 bytes at offset 1624064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1628160 ++wrote 2048/2048 bytes at offset 1628160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1632256 ++wrote 2048/2048 bytes at offset 1632256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1636352 ++wrote 2048/2048 bytes at offset 1636352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1640448 ++wrote 2048/2048 bytes at offset 1640448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1644544 ++wrote 2048/2048 bytes at offset 1644544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1648640 ++wrote 2048/2048 bytes at offset 1648640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1652736 ++wrote 2048/2048 bytes at offset 1652736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1656832 ++wrote 2048/2048 bytes at offset 1656832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1660928 ++wrote 2048/2048 bytes at offset 1660928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1665024 ++wrote 2048/2048 bytes at offset 1665024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1669120 ++wrote 2048/2048 bytes at offset 1669120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1673216 ++wrote 2048/2048 bytes at offset 1673216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1677312 ++wrote 2048/2048 bytes at offset 1677312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1681408 ++wrote 2048/2048 bytes at offset 1681408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1685504 ++wrote 2048/2048 bytes at offset 1685504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1689600 ++wrote 2048/2048 bytes at offset 1689600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1693696 ++wrote 2048/2048 bytes at offset 1693696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1697792 ++wrote 2048/2048 bytes at offset 1697792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1701888 ++wrote 2048/2048 bytes at offset 1701888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1705984 ++wrote 2048/2048 bytes at offset 1705984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1710080 ++wrote 2048/2048 bytes at offset 1710080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1714176 ++wrote 2048/2048 bytes at offset 1714176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1718272 ++wrote 2048/2048 bytes at offset 1718272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1722368 ++wrote 2048/2048 bytes at offset 1722368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1726464 ++wrote 2048/2048 bytes at offset 1726464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1730560 ++wrote 2048/2048 bytes at offset 1730560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1734656 ++wrote 2048/2048 bytes at offset 1734656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1738752 ++wrote 2048/2048 bytes at offset 1738752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1742848 ++wrote 2048/2048 bytes at offset 1742848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1746944 ++wrote 2048/2048 bytes at offset 1746944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1751040 ++wrote 2048/2048 bytes at offset 1751040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1755136 ++wrote 2048/2048 bytes at offset 1755136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1759232 ++wrote 2048/2048 bytes at offset 1759232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1763328 ++wrote 2048/2048 bytes at offset 1763328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1767424 ++wrote 2048/2048 bytes at offset 1767424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1771520 ++wrote 2048/2048 bytes at offset 1771520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1775616 ++wrote 2048/2048 bytes at offset 1775616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1779712 ++wrote 2048/2048 bytes at offset 1779712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1783808 ++wrote 2048/2048 bytes at offset 1783808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1787904 ++wrote 2048/2048 bytes at offset 1787904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1792000 ++wrote 2048/2048 bytes at offset 1792000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1796096 ++wrote 2048/2048 bytes at offset 1796096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1800192 ++wrote 2048/2048 bytes at offset 1800192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1804288 ++wrote 2048/2048 bytes at offset 1804288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1808384 ++wrote 2048/2048 bytes at offset 1808384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1812480 ++wrote 2048/2048 bytes at offset 1812480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1816576 ++wrote 2048/2048 bytes at offset 1816576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1820672 ++wrote 2048/2048 bytes at offset 1820672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1824768 ++wrote 2048/2048 bytes at offset 1824768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1828864 ++wrote 2048/2048 bytes at offset 1828864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1832960 ++wrote 2048/2048 bytes at offset 1832960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1837056 ++wrote 2048/2048 bytes at offset 1837056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1841152 ++wrote 2048/2048 bytes at offset 1841152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1845248 ++wrote 2048/2048 bytes at offset 1845248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1849344 ++wrote 2048/2048 bytes at offset 1849344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1853440 ++wrote 2048/2048 bytes at offset 1853440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1857536 ++wrote 2048/2048 bytes at offset 1857536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1861632 ++wrote 2048/2048 bytes at offset 1861632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1865728 ++wrote 2048/2048 bytes at offset 1865728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1869824 ++wrote 2048/2048 bytes at offset 1869824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1873920 ++wrote 2048/2048 bytes at offset 1873920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1878016 ++wrote 2048/2048 bytes at offset 1878016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1882112 ++wrote 2048/2048 bytes at offset 1882112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1886208 ++wrote 2048/2048 bytes at offset 1886208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1890304 ++wrote 2048/2048 bytes at offset 1890304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1894400 ++wrote 2048/2048 bytes at offset 1894400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1898496 ++wrote 2048/2048 bytes at offset 1898496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1902592 ++wrote 2048/2048 bytes at offset 1902592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1906688 ++wrote 2048/2048 bytes at offset 1906688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1910784 ++wrote 2048/2048 bytes at offset 1910784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1914880 ++wrote 2048/2048 bytes at offset 1914880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1918976 ++wrote 2048/2048 bytes at offset 1918976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1923072 ++wrote 2048/2048 bytes at offset 1923072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1927168 ++wrote 2048/2048 bytes at offset 1927168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1931264 ++wrote 2048/2048 bytes at offset 1931264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1935360 ++wrote 2048/2048 bytes at offset 1935360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1939456 ++wrote 2048/2048 bytes at offset 1939456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1943552 ++wrote 2048/2048 bytes at offset 1943552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1947648 ++wrote 2048/2048 bytes at offset 1947648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1951744 ++wrote 2048/2048 bytes at offset 1951744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1955840 ++wrote 2048/2048 bytes at offset 1955840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1959936 ++wrote 2048/2048 bytes at offset 1959936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1964032 ++wrote 2048/2048 bytes at offset 1964032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1968128 ++wrote 2048/2048 bytes at offset 1968128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1972224 ++wrote 2048/2048 bytes at offset 1972224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1976320 ++wrote 2048/2048 bytes at offset 1976320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1980416 ++wrote 2048/2048 bytes at offset 1980416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1984512 ++wrote 2048/2048 bytes at offset 1984512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1988608 ++wrote 2048/2048 bytes at offset 1988608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1992704 ++wrote 2048/2048 bytes at offset 1992704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1996800 ++wrote 2048/2048 bytes at offset 1996800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2000896 ++wrote 2048/2048 bytes at offset 2000896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2004992 ++wrote 2048/2048 bytes at offset 2004992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2009088 ++wrote 2048/2048 bytes at offset 2009088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2013184 ++wrote 2048/2048 bytes at offset 2013184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2017280 ++wrote 2048/2048 bytes at offset 2017280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2021376 ++wrote 2048/2048 bytes at offset 2021376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2025472 ++wrote 2048/2048 bytes at offset 2025472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2029568 ++wrote 2048/2048 bytes at offset 2029568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2033664 ++wrote 2048/2048 bytes at offset 2033664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2037760 ++wrote 2048/2048 bytes at offset 2037760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2041856 ++wrote 2048/2048 bytes at offset 2041856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2045952 ++wrote 2048/2048 bytes at offset 2045952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2050048 ++wrote 2048/2048 bytes at offset 2050048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2054144 ++wrote 2048/2048 bytes at offset 2054144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2058240 ++wrote 2048/2048 bytes at offset 2058240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2062336 ++wrote 2048/2048 bytes at offset 2062336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2066432 ++wrote 2048/2048 bytes at offset 2066432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2070528 ++wrote 2048/2048 bytes at offset 2070528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2074624 ++wrote 2048/2048 bytes at offset 2074624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2078720 ++wrote 2048/2048 bytes at offset 2078720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2082816 ++wrote 2048/2048 bytes at offset 2082816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2086912 ++wrote 2048/2048 bytes at offset 2086912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2091008 ++wrote 2048/2048 bytes at offset 2091008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2095104 ++wrote 2048/2048 bytes at offset 2095104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> wrote 2048/2048 bytes at offset 2097152 ++=== IO: pattern 0 ++wrote 2048/2048 bytes at offset 2097152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2101248 ++wrote 2048/2048 bytes at offset 2101248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2105344 ++wrote 2048/2048 bytes at offset 2105344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2109440 ++wrote 2048/2048 bytes at offset 2109440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2113536 ++wrote 2048/2048 bytes at offset 2113536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2117632 ++wrote 2048/2048 bytes at offset 2117632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2121728 ++wrote 2048/2048 bytes at offset 2121728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2125824 ++wrote 2048/2048 bytes at offset 2125824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2129920 ++wrote 2048/2048 bytes at offset 2129920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2134016 ++wrote 2048/2048 bytes at offset 2134016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2138112 ++wrote 2048/2048 bytes at offset 2138112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2142208 ++wrote 2048/2048 bytes at offset 2142208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2146304 ++wrote 2048/2048 bytes at offset 2146304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2150400 ++wrote 2048/2048 bytes at offset 2150400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2154496 ++wrote 2048/2048 bytes at offset 2154496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2158592 ++wrote 2048/2048 bytes at offset 2158592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2162688 ++wrote 2048/2048 bytes at offset 2162688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2166784 ++wrote 2048/2048 bytes at offset 2166784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2170880 ++wrote 2048/2048 bytes at offset 2170880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2174976 ++wrote 2048/2048 bytes at offset 2174976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2179072 ++wrote 2048/2048 bytes at offset 2179072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2183168 ++wrote 2048/2048 bytes at offset 2183168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2187264 ++wrote 2048/2048 bytes at offset 2187264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2191360 ++wrote 2048/2048 bytes at offset 2191360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2195456 ++wrote 2048/2048 bytes at offset 2195456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2199552 ++wrote 2048/2048 bytes at offset 2199552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2203648 ++wrote 2048/2048 bytes at offset 2203648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2207744 ++wrote 2048/2048 bytes at offset 2207744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2211840 ++wrote 2048/2048 bytes at offset 2211840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2215936 ++wrote 2048/2048 bytes at offset 2215936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2220032 ++wrote 2048/2048 bytes at offset 2220032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2224128 ++wrote 2048/2048 bytes at offset 2224128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2228224 ++wrote 2048/2048 bytes at offset 2228224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2232320 ++wrote 2048/2048 bytes at offset 2232320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2236416 ++wrote 2048/2048 bytes at offset 2236416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2240512 ++wrote 2048/2048 bytes at offset 2240512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2244608 ++wrote 2048/2048 bytes at offset 2244608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2248704 ++wrote 2048/2048 bytes at offset 2248704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2252800 ++wrote 2048/2048 bytes at offset 2252800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2256896 ++wrote 2048/2048 bytes at offset 2256896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2260992 ++wrote 2048/2048 bytes at offset 2260992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2265088 ++wrote 2048/2048 bytes at offset 2265088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2269184 ++wrote 2048/2048 bytes at offset 2269184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2273280 ++wrote 2048/2048 bytes at offset 2273280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2277376 ++wrote 2048/2048 bytes at offset 2277376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2281472 ++wrote 2048/2048 bytes at offset 2281472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2285568 ++wrote 2048/2048 bytes at offset 2285568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2289664 ++wrote 2048/2048 bytes at offset 2289664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2293760 ++wrote 2048/2048 bytes at offset 2293760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2297856 ++wrote 2048/2048 bytes at offset 2297856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2301952 ++wrote 2048/2048 bytes at offset 2301952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2306048 ++wrote 2048/2048 bytes at offset 2306048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2310144 ++wrote 2048/2048 bytes at offset 2310144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2314240 ++wrote 2048/2048 bytes at offset 2314240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2318336 ++wrote 2048/2048 bytes at offset 2318336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2322432 ++wrote 2048/2048 bytes at offset 2322432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2326528 ++wrote 2048/2048 bytes at offset 2326528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2330624 ++wrote 2048/2048 bytes at offset 2330624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2334720 ++wrote 2048/2048 bytes at offset 2334720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2338816 ++wrote 2048/2048 bytes at offset 2338816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2342912 ++wrote 2048/2048 bytes at offset 2342912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2347008 ++wrote 2048/2048 bytes at offset 2347008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2351104 ++wrote 2048/2048 bytes at offset 2351104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2355200 ++wrote 2048/2048 bytes at offset 2355200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2359296 ++wrote 2048/2048 bytes at offset 2359296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2363392 ++wrote 2048/2048 bytes at offset 2363392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2367488 ++wrote 2048/2048 bytes at offset 2367488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2371584 ++wrote 2048/2048 bytes at offset 2371584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2375680 ++wrote 2048/2048 bytes at offset 2375680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2379776 ++wrote 2048/2048 bytes at offset 2379776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2383872 ++wrote 2048/2048 bytes at offset 2383872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2387968 ++wrote 2048/2048 bytes at offset 2387968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2392064 ++wrote 2048/2048 bytes at offset 2392064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2396160 ++wrote 2048/2048 bytes at offset 2396160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2400256 ++wrote 2048/2048 bytes at offset 2400256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2404352 ++wrote 2048/2048 bytes at offset 2404352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2408448 ++wrote 2048/2048 bytes at offset 2408448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2412544 ++wrote 2048/2048 bytes at offset 2412544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2416640 ++wrote 2048/2048 bytes at offset 2416640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2420736 ++wrote 2048/2048 bytes at offset 2420736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2424832 ++wrote 2048/2048 bytes at offset 2424832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2428928 ++wrote 2048/2048 bytes at offset 2428928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2433024 ++wrote 2048/2048 bytes at offset 2433024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2437120 ++wrote 2048/2048 bytes at offset 2437120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2441216 ++wrote 2048/2048 bytes at offset 2441216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2445312 ++wrote 2048/2048 bytes at offset 2445312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2449408 ++wrote 2048/2048 bytes at offset 2449408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2453504 ++wrote 2048/2048 bytes at offset 2453504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2457600 ++wrote 2048/2048 bytes at offset 2457600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2461696 ++wrote 2048/2048 bytes at offset 2461696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2465792 ++wrote 2048/2048 bytes at offset 2465792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2469888 ++wrote 2048/2048 bytes at offset 2469888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2473984 ++wrote 2048/2048 bytes at offset 2473984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2478080 ++wrote 2048/2048 bytes at offset 2478080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2482176 ++wrote 2048/2048 bytes at offset 2482176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2486272 ++wrote 2048/2048 bytes at offset 2486272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2490368 ++wrote 2048/2048 bytes at offset 2490368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2494464 ++wrote 2048/2048 bytes at offset 2494464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2498560 ++wrote 2048/2048 bytes at offset 2498560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2502656 ++wrote 2048/2048 bytes at offset 2502656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2506752 ++wrote 2048/2048 bytes at offset 2506752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2510848 ++wrote 2048/2048 bytes at offset 2510848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2514944 ++wrote 2048/2048 bytes at offset 2514944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2519040 ++wrote 2048/2048 bytes at offset 2519040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2523136 ++wrote 2048/2048 bytes at offset 2523136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2527232 ++wrote 2048/2048 bytes at offset 2527232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2531328 ++wrote 2048/2048 bytes at offset 2531328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2535424 ++wrote 2048/2048 bytes at offset 2535424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2539520 ++wrote 2048/2048 bytes at offset 2539520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2543616 ++wrote 2048/2048 bytes at offset 2543616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2547712 ++wrote 2048/2048 bytes at offset 2547712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2551808 ++wrote 2048/2048 bytes at offset 2551808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2555904 ++wrote 2048/2048 bytes at offset 2555904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2560000 ++wrote 2048/2048 bytes at offset 2560000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2564096 ++wrote 2048/2048 bytes at offset 2564096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2568192 ++wrote 2048/2048 bytes at offset 2568192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2572288 ++wrote 2048/2048 bytes at offset 2572288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2576384 ++wrote 2048/2048 bytes at offset 2576384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2580480 ++wrote 2048/2048 bytes at offset 2580480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2584576 ++wrote 2048/2048 bytes at offset 2584576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2588672 ++wrote 2048/2048 bytes at offset 2588672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2592768 ++wrote 2048/2048 bytes at offset 2592768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2596864 ++wrote 2048/2048 bytes at offset 2596864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2600960 ++wrote 2048/2048 bytes at offset 2600960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2605056 ++wrote 2048/2048 bytes at offset 2605056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2609152 ++wrote 2048/2048 bytes at offset 2609152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2613248 ++wrote 2048/2048 bytes at offset 2613248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2617344 ++wrote 2048/2048 bytes at offset 2617344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2621440 ++wrote 2048/2048 bytes at offset 2621440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2625536 ++wrote 2048/2048 bytes at offset 2625536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2629632 ++wrote 2048/2048 bytes at offset 2629632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2633728 ++wrote 2048/2048 bytes at offset 2633728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2637824 ++wrote 2048/2048 bytes at offset 2637824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2641920 ++wrote 2048/2048 bytes at offset 2641920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2646016 ++wrote 2048/2048 bytes at offset 2646016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2650112 ++wrote 2048/2048 bytes at offset 2650112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2654208 ++wrote 2048/2048 bytes at offset 2654208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2658304 ++wrote 2048/2048 bytes at offset 2658304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2662400 ++wrote 2048/2048 bytes at offset 2662400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2666496 ++wrote 2048/2048 bytes at offset 2666496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2670592 ++wrote 2048/2048 bytes at offset 2670592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2674688 ++wrote 2048/2048 bytes at offset 2674688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2678784 ++wrote 2048/2048 bytes at offset 2678784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2682880 ++wrote 2048/2048 bytes at offset 2682880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2686976 ++wrote 2048/2048 bytes at offset 2686976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2691072 ++wrote 2048/2048 bytes at offset 2691072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2695168 ++wrote 2048/2048 bytes at offset 2695168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2699264 ++wrote 2048/2048 bytes at offset 2699264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2703360 ++wrote 2048/2048 bytes at offset 2703360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2707456 ++wrote 2048/2048 bytes at offset 2707456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2711552 ++wrote 2048/2048 bytes at offset 2711552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2715648 ++wrote 2048/2048 bytes at offset 2715648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2719744 ++wrote 2048/2048 bytes at offset 2719744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2723840 ++wrote 2048/2048 bytes at offset 2723840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2727936 ++wrote 2048/2048 bytes at offset 2727936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2732032 ++wrote 2048/2048 bytes at offset 2732032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2736128 ++wrote 2048/2048 bytes at offset 2736128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2740224 ++wrote 2048/2048 bytes at offset 2740224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2744320 ++wrote 2048/2048 bytes at offset 2744320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2748416 ++wrote 2048/2048 bytes at offset 2748416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2752512 ++wrote 2048/2048 bytes at offset 2752512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2756608 ++wrote 2048/2048 bytes at offset 2756608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2760704 ++wrote 2048/2048 bytes at offset 2760704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2764800 ++wrote 2048/2048 bytes at offset 2764800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2768896 ++wrote 2048/2048 bytes at offset 2768896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2772992 ++wrote 2048/2048 bytes at offset 2772992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2777088 ++wrote 2048/2048 bytes at offset 2777088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2781184 ++wrote 2048/2048 bytes at offset 2781184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2785280 ++wrote 2048/2048 bytes at offset 2785280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2789376 ++wrote 2048/2048 bytes at offset 2789376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2793472 ++wrote 2048/2048 bytes at offset 2793472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2797568 ++wrote 2048/2048 bytes at offset 2797568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2801664 ++wrote 2048/2048 bytes at offset 2801664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2805760 ++wrote 2048/2048 bytes at offset 2805760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2809856 ++wrote 2048/2048 bytes at offset 2809856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2813952 ++wrote 2048/2048 bytes at offset 2813952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2818048 ++wrote 2048/2048 bytes at offset 2818048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2822144 ++wrote 2048/2048 bytes at offset 2822144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2826240 ++wrote 2048/2048 bytes at offset 2826240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2830336 ++wrote 2048/2048 bytes at offset 2830336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2834432 ++wrote 2048/2048 bytes at offset 2834432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2838528 ++wrote 2048/2048 bytes at offset 2838528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2842624 ++wrote 2048/2048 bytes at offset 2842624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2846720 ++wrote 2048/2048 bytes at offset 2846720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2850816 ++wrote 2048/2048 bytes at offset 2850816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2854912 ++wrote 2048/2048 bytes at offset 2854912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2859008 ++wrote 2048/2048 bytes at offset 2859008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2863104 ++wrote 2048/2048 bytes at offset 2863104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2867200 ++wrote 2048/2048 bytes at offset 2867200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2871296 ++wrote 2048/2048 bytes at offset 2871296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2875392 ++wrote 2048/2048 bytes at offset 2875392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2879488 ++wrote 2048/2048 bytes at offset 2879488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2883584 ++wrote 2048/2048 bytes at offset 2883584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2887680 ++wrote 2048/2048 bytes at offset 2887680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2891776 ++wrote 2048/2048 bytes at offset 2891776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2895872 ++wrote 2048/2048 bytes at offset 2895872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2899968 ++wrote 2048/2048 bytes at offset 2899968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2904064 ++wrote 2048/2048 bytes at offset 2904064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2908160 ++wrote 2048/2048 bytes at offset 2908160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2912256 ++wrote 2048/2048 bytes at offset 2912256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2916352 ++wrote 2048/2048 bytes at offset 2916352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2920448 ++wrote 2048/2048 bytes at offset 2920448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2924544 ++wrote 2048/2048 bytes at offset 2924544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2928640 ++wrote 2048/2048 bytes at offset 2928640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2932736 ++wrote 2048/2048 bytes at offset 2932736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2936832 ++wrote 2048/2048 bytes at offset 2936832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2940928 ++wrote 2048/2048 bytes at offset 2940928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2945024 ++wrote 2048/2048 bytes at offset 2945024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2949120 ++wrote 2048/2048 bytes at offset 2949120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2953216 ++wrote 2048/2048 bytes at offset 2953216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2957312 ++wrote 2048/2048 bytes at offset 2957312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2961408 ++wrote 2048/2048 bytes at offset 2961408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2965504 ++wrote 2048/2048 bytes at offset 2965504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2969600 ++wrote 2048/2048 bytes at offset 2969600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2973696 ++wrote 2048/2048 bytes at offset 2973696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2977792 ++wrote 2048/2048 bytes at offset 2977792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2981888 ++wrote 2048/2048 bytes at offset 2981888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2985984 ++wrote 2048/2048 bytes at offset 2985984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2990080 ++wrote 2048/2048 bytes at offset 2990080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2994176 ++wrote 2048/2048 bytes at offset 2994176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2998272 ++wrote 2048/2048 bytes at offset 2998272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3002368 ++wrote 2048/2048 bytes at offset 3002368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3006464 ++wrote 2048/2048 bytes at offset 3006464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3010560 ++wrote 2048/2048 bytes at offset 3010560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3014656 ++wrote 2048/2048 bytes at offset 3014656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3018752 ++wrote 2048/2048 bytes at offset 3018752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3022848 ++wrote 2048/2048 bytes at offset 3022848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3026944 ++wrote 2048/2048 bytes at offset 3026944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3031040 ++wrote 2048/2048 bytes at offset 3031040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3035136 ++wrote 2048/2048 bytes at offset 3035136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3039232 ++wrote 2048/2048 bytes at offset 3039232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3043328 ++wrote 2048/2048 bytes at offset 3043328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3047424 ++wrote 2048/2048 bytes at offset 3047424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3051520 ++wrote 2048/2048 bytes at offset 3051520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3055616 ++wrote 2048/2048 bytes at offset 3055616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3059712 ++wrote 2048/2048 bytes at offset 3059712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3063808 ++wrote 2048/2048 bytes at offset 3063808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3067904 ++wrote 2048/2048 bytes at offset 3067904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3072000 ++wrote 2048/2048 bytes at offset 3072000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3076096 ++wrote 2048/2048 bytes at offset 3076096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3080192 ++wrote 2048/2048 bytes at offset 3080192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3084288 ++wrote 2048/2048 bytes at offset 3084288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3088384 ++wrote 2048/2048 bytes at offset 3088384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3092480 ++wrote 2048/2048 bytes at offset 3092480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3096576 ++wrote 2048/2048 bytes at offset 3096576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3100672 ++wrote 2048/2048 bytes at offset 3100672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3104768 ++wrote 2048/2048 bytes at offset 3104768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3108864 ++wrote 2048/2048 bytes at offset 3108864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3112960 ++wrote 2048/2048 bytes at offset 3112960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3117056 ++wrote 2048/2048 bytes at offset 3117056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3121152 ++wrote 2048/2048 bytes at offset 3121152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3125248 ++wrote 2048/2048 bytes at offset 3125248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3129344 ++wrote 2048/2048 bytes at offset 3129344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3133440 ++wrote 2048/2048 bytes at offset 3133440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3137536 ++wrote 2048/2048 bytes at offset 3137536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3141632 ++wrote 2048/2048 bytes at offset 3141632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 2 +-qemu-io> wrote 2048/2048 bytes at offset 3146752 ++=== IO: pattern 2 ++wrote 2048/2048 bytes at offset 3146752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3150848 ++wrote 2048/2048 bytes at offset 3150848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3154944 ++wrote 2048/2048 bytes at offset 3154944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3159040 ++wrote 2048/2048 bytes at offset 3159040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3163136 ++wrote 2048/2048 bytes at offset 3163136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3167232 ++wrote 2048/2048 bytes at offset 3167232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3171328 ++wrote 2048/2048 bytes at offset 3171328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3175424 ++wrote 2048/2048 bytes at offset 3175424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3179520 ++wrote 2048/2048 bytes at offset 3179520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3183616 ++wrote 2048/2048 bytes at offset 3183616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3187712 ++wrote 2048/2048 bytes at offset 3187712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3191808 ++wrote 2048/2048 bytes at offset 3191808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3195904 ++wrote 2048/2048 bytes at offset 3195904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3200000 ++wrote 2048/2048 bytes at offset 3200000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3204096 ++wrote 2048/2048 bytes at offset 3204096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3208192 ++wrote 2048/2048 bytes at offset 3208192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3212288 ++wrote 2048/2048 bytes at offset 3212288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3216384 ++wrote 2048/2048 bytes at offset 3216384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3220480 ++wrote 2048/2048 bytes at offset 3220480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3224576 ++wrote 2048/2048 bytes at offset 3224576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3228672 ++wrote 2048/2048 bytes at offset 3228672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3232768 ++wrote 2048/2048 bytes at offset 3232768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3236864 ++wrote 2048/2048 bytes at offset 3236864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3240960 ++wrote 2048/2048 bytes at offset 3240960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3245056 ++wrote 2048/2048 bytes at offset 3245056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3249152 ++wrote 2048/2048 bytes at offset 3249152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3253248 ++wrote 2048/2048 bytes at offset 3253248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3257344 ++wrote 2048/2048 bytes at offset 3257344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3261440 ++wrote 2048/2048 bytes at offset 3261440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3265536 ++wrote 2048/2048 bytes at offset 3265536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3269632 ++wrote 2048/2048 bytes at offset 3269632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3273728 ++wrote 2048/2048 bytes at offset 3273728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3277824 ++wrote 2048/2048 bytes at offset 3277824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3281920 ++wrote 2048/2048 bytes at offset 3281920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3286016 ++wrote 2048/2048 bytes at offset 3286016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3290112 ++wrote 2048/2048 bytes at offset 3290112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3294208 ++wrote 2048/2048 bytes at offset 3294208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3298304 ++wrote 2048/2048 bytes at offset 3298304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3302400 ++wrote 2048/2048 bytes at offset 3302400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3306496 ++wrote 2048/2048 bytes at offset 3306496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3310592 ++wrote 2048/2048 bytes at offset 3310592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3314688 ++wrote 2048/2048 bytes at offset 3314688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3318784 ++wrote 2048/2048 bytes at offset 3318784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3322880 ++wrote 2048/2048 bytes at offset 3322880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3326976 ++wrote 2048/2048 bytes at offset 3326976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3331072 ++wrote 2048/2048 bytes at offset 3331072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3335168 ++wrote 2048/2048 bytes at offset 3335168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3339264 ++wrote 2048/2048 bytes at offset 3339264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3343360 ++wrote 2048/2048 bytes at offset 3343360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3347456 ++wrote 2048/2048 bytes at offset 3347456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3351552 ++wrote 2048/2048 bytes at offset 3351552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3355648 ++wrote 2048/2048 bytes at offset 3355648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3359744 ++wrote 2048/2048 bytes at offset 3359744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3363840 ++wrote 2048/2048 bytes at offset 3363840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3367936 ++wrote 2048/2048 bytes at offset 3367936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3372032 ++wrote 2048/2048 bytes at offset 3372032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3376128 ++wrote 2048/2048 bytes at offset 3376128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3380224 ++wrote 2048/2048 bytes at offset 3380224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3384320 ++wrote 2048/2048 bytes at offset 3384320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3388416 ++wrote 2048/2048 bytes at offset 3388416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3392512 ++wrote 2048/2048 bytes at offset 3392512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3396608 ++wrote 2048/2048 bytes at offset 3396608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3400704 ++wrote 2048/2048 bytes at offset 3400704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3404800 ++wrote 2048/2048 bytes at offset 3404800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3408896 ++wrote 2048/2048 bytes at offset 3408896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3412992 ++wrote 2048/2048 bytes at offset 3412992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3417088 ++wrote 2048/2048 bytes at offset 3417088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3421184 ++wrote 2048/2048 bytes at offset 3421184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3425280 ++wrote 2048/2048 bytes at offset 3425280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3429376 ++wrote 2048/2048 bytes at offset 3429376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3433472 ++wrote 2048/2048 bytes at offset 3433472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3437568 ++wrote 2048/2048 bytes at offset 3437568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3441664 ++wrote 2048/2048 bytes at offset 3441664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3445760 ++wrote 2048/2048 bytes at offset 3445760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3449856 ++wrote 2048/2048 bytes at offset 3449856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3453952 ++wrote 2048/2048 bytes at offset 3453952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3458048 ++wrote 2048/2048 bytes at offset 3458048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3462144 ++wrote 2048/2048 bytes at offset 3462144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3466240 ++wrote 2048/2048 bytes at offset 3466240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3470336 ++wrote 2048/2048 bytes at offset 3470336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3474432 ++wrote 2048/2048 bytes at offset 3474432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3478528 ++wrote 2048/2048 bytes at offset 3478528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3482624 ++wrote 2048/2048 bytes at offset 3482624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3486720 ++wrote 2048/2048 bytes at offset 3486720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3490816 ++wrote 2048/2048 bytes at offset 3490816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3494912 ++wrote 2048/2048 bytes at offset 3494912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3499008 ++wrote 2048/2048 bytes at offset 3499008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3503104 ++wrote 2048/2048 bytes at offset 3503104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3507200 ++wrote 2048/2048 bytes at offset 3507200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3511296 ++wrote 2048/2048 bytes at offset 3511296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3515392 ++wrote 2048/2048 bytes at offset 3515392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3519488 ++wrote 2048/2048 bytes at offset 3519488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3523584 ++wrote 2048/2048 bytes at offset 3523584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3527680 ++wrote 2048/2048 bytes at offset 3527680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3531776 ++wrote 2048/2048 bytes at offset 3531776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3535872 ++wrote 2048/2048 bytes at offset 3535872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3539968 ++wrote 2048/2048 bytes at offset 3539968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3544064 ++wrote 2048/2048 bytes at offset 3544064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3548160 ++wrote 2048/2048 bytes at offset 3548160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3552256 ++wrote 2048/2048 bytes at offset 3552256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3556352 ++wrote 2048/2048 bytes at offset 3556352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3560448 ++wrote 2048/2048 bytes at offset 3560448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3564544 ++wrote 2048/2048 bytes at offset 3564544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3568640 ++wrote 2048/2048 bytes at offset 3568640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3572736 ++wrote 2048/2048 bytes at offset 3572736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3576832 ++wrote 2048/2048 bytes at offset 3576832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3580928 ++wrote 2048/2048 bytes at offset 3580928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3585024 ++wrote 2048/2048 bytes at offset 3585024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3589120 ++wrote 2048/2048 bytes at offset 3589120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3593216 ++wrote 2048/2048 bytes at offset 3593216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3597312 ++wrote 2048/2048 bytes at offset 3597312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3601408 ++wrote 2048/2048 bytes at offset 3601408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3605504 ++wrote 2048/2048 bytes at offset 3605504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3609600 ++wrote 2048/2048 bytes at offset 3609600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3613696 ++wrote 2048/2048 bytes at offset 3613696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3617792 ++wrote 2048/2048 bytes at offset 3617792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3621888 ++wrote 2048/2048 bytes at offset 3621888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3625984 ++wrote 2048/2048 bytes at offset 3625984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3630080 ++wrote 2048/2048 bytes at offset 3630080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3634176 ++wrote 2048/2048 bytes at offset 3634176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3638272 ++wrote 2048/2048 bytes at offset 3638272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3642368 ++wrote 2048/2048 bytes at offset 3642368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3646464 ++wrote 2048/2048 bytes at offset 3646464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3650560 ++wrote 2048/2048 bytes at offset 3650560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3654656 ++wrote 2048/2048 bytes at offset 3654656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3658752 ++wrote 2048/2048 bytes at offset 3658752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3662848 ++wrote 2048/2048 bytes at offset 3662848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3666944 ++wrote 2048/2048 bytes at offset 3666944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3671040 ++wrote 2048/2048 bytes at offset 3671040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3675136 ++wrote 2048/2048 bytes at offset 3675136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3679232 ++wrote 2048/2048 bytes at offset 3679232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3683328 ++wrote 2048/2048 bytes at offset 3683328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3687424 ++wrote 2048/2048 bytes at offset 3687424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3691520 ++wrote 2048/2048 bytes at offset 3691520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3695616 ++wrote 2048/2048 bytes at offset 3695616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3699712 ++wrote 2048/2048 bytes at offset 3699712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3703808 ++wrote 2048/2048 bytes at offset 3703808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3707904 ++wrote 2048/2048 bytes at offset 3707904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3712000 ++wrote 2048/2048 bytes at offset 3712000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3716096 ++wrote 2048/2048 bytes at offset 3716096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3720192 ++wrote 2048/2048 bytes at offset 3720192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3724288 ++wrote 2048/2048 bytes at offset 3724288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3728384 ++wrote 2048/2048 bytes at offset 3728384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3732480 ++wrote 2048/2048 bytes at offset 3732480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3736576 ++wrote 2048/2048 bytes at offset 3736576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3740672 ++wrote 2048/2048 bytes at offset 3740672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3744768 ++wrote 2048/2048 bytes at offset 3744768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3748864 ++wrote 2048/2048 bytes at offset 3748864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3752960 ++wrote 2048/2048 bytes at offset 3752960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3757056 ++wrote 2048/2048 bytes at offset 3757056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3761152 ++wrote 2048/2048 bytes at offset 3761152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3765248 ++wrote 2048/2048 bytes at offset 3765248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3769344 ++wrote 2048/2048 bytes at offset 3769344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3773440 ++wrote 2048/2048 bytes at offset 3773440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3777536 ++wrote 2048/2048 bytes at offset 3777536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3781632 ++wrote 2048/2048 bytes at offset 3781632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3785728 ++wrote 2048/2048 bytes at offset 3785728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3789824 ++wrote 2048/2048 bytes at offset 3789824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3793920 ++wrote 2048/2048 bytes at offset 3793920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3798016 ++wrote 2048/2048 bytes at offset 3798016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3802112 ++wrote 2048/2048 bytes at offset 3802112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3806208 ++wrote 2048/2048 bytes at offset 3806208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3810304 ++wrote 2048/2048 bytes at offset 3810304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3814400 ++wrote 2048/2048 bytes at offset 3814400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3818496 ++wrote 2048/2048 bytes at offset 3818496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3822592 ++wrote 2048/2048 bytes at offset 3822592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3826688 ++wrote 2048/2048 bytes at offset 3826688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3830784 ++wrote 2048/2048 bytes at offset 3830784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3834880 ++wrote 2048/2048 bytes at offset 3834880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3838976 ++wrote 2048/2048 bytes at offset 3838976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3843072 ++wrote 2048/2048 bytes at offset 3843072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3847168 ++wrote 2048/2048 bytes at offset 3847168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3851264 ++wrote 2048/2048 bytes at offset 3851264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3855360 ++wrote 2048/2048 bytes at offset 3855360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3859456 ++wrote 2048/2048 bytes at offset 3859456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3863552 ++wrote 2048/2048 bytes at offset 3863552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3867648 ++wrote 2048/2048 bytes at offset 3867648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3871744 ++wrote 2048/2048 bytes at offset 3871744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3875840 ++wrote 2048/2048 bytes at offset 3875840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3879936 ++wrote 2048/2048 bytes at offset 3879936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3884032 ++wrote 2048/2048 bytes at offset 3884032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3888128 ++wrote 2048/2048 bytes at offset 3888128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3892224 ++wrote 2048/2048 bytes at offset 3892224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3896320 ++wrote 2048/2048 bytes at offset 3896320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3900416 ++wrote 2048/2048 bytes at offset 3900416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3904512 ++wrote 2048/2048 bytes at offset 3904512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3908608 ++wrote 2048/2048 bytes at offset 3908608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3912704 ++wrote 2048/2048 bytes at offset 3912704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3916800 ++wrote 2048/2048 bytes at offset 3916800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3920896 ++wrote 2048/2048 bytes at offset 3920896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3924992 ++wrote 2048/2048 bytes at offset 3924992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3929088 ++wrote 2048/2048 bytes at offset 3929088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3933184 ++wrote 2048/2048 bytes at offset 3933184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3937280 ++wrote 2048/2048 bytes at offset 3937280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3941376 ++wrote 2048/2048 bytes at offset 3941376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3945472 ++wrote 2048/2048 bytes at offset 3945472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3949568 ++wrote 2048/2048 bytes at offset 3949568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3953664 ++wrote 2048/2048 bytes at offset 3953664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3957760 ++wrote 2048/2048 bytes at offset 3957760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3961856 ++wrote 2048/2048 bytes at offset 3961856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3965952 ++wrote 2048/2048 bytes at offset 3965952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3970048 ++wrote 2048/2048 bytes at offset 3970048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3974144 ++wrote 2048/2048 bytes at offset 3974144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3978240 ++wrote 2048/2048 bytes at offset 3978240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3982336 ++wrote 2048/2048 bytes at offset 3982336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3986432 ++wrote 2048/2048 bytes at offset 3986432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3990528 ++wrote 2048/2048 bytes at offset 3990528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3994624 ++wrote 2048/2048 bytes at offset 3994624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3998720 ++wrote 2048/2048 bytes at offset 3998720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4002816 ++wrote 2048/2048 bytes at offset 4002816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4006912 ++wrote 2048/2048 bytes at offset 4006912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4011008 ++wrote 2048/2048 bytes at offset 4011008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4015104 ++wrote 2048/2048 bytes at offset 4015104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4019200 ++wrote 2048/2048 bytes at offset 4019200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4023296 ++wrote 2048/2048 bytes at offset 4023296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4027392 ++wrote 2048/2048 bytes at offset 4027392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4031488 ++wrote 2048/2048 bytes at offset 4031488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4035584 ++wrote 2048/2048 bytes at offset 4035584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4039680 ++wrote 2048/2048 bytes at offset 4039680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4043776 ++wrote 2048/2048 bytes at offset 4043776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4047872 ++wrote 2048/2048 bytes at offset 4047872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4051968 ++wrote 2048/2048 bytes at offset 4051968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4056064 ++wrote 2048/2048 bytes at offset 4056064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4060160 ++wrote 2048/2048 bytes at offset 4060160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4064256 ++wrote 2048/2048 bytes at offset 4064256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4068352 ++wrote 2048/2048 bytes at offset 4068352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4072448 ++wrote 2048/2048 bytes at offset 4072448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4076544 ++wrote 2048/2048 bytes at offset 4076544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4080640 ++wrote 2048/2048 bytes at offset 4080640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4084736 ++wrote 2048/2048 bytes at offset 4084736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4088832 ++wrote 2048/2048 bytes at offset 4088832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4092928 ++wrote 2048/2048 bytes at offset 4092928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4097024 ++wrote 2048/2048 bytes at offset 4097024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4101120 ++wrote 2048/2048 bytes at offset 4101120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4105216 ++wrote 2048/2048 bytes at offset 4105216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4109312 ++wrote 2048/2048 bytes at offset 4109312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4113408 ++wrote 2048/2048 bytes at offset 4113408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4117504 ++wrote 2048/2048 bytes at offset 4117504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4121600 ++wrote 2048/2048 bytes at offset 4121600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4125696 ++wrote 2048/2048 bytes at offset 4125696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4129792 ++wrote 2048/2048 bytes at offset 4129792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4133888 ++wrote 2048/2048 bytes at offset 4133888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4137984 ++wrote 2048/2048 bytes at offset 4137984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4142080 ++wrote 2048/2048 bytes at offset 4142080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4146176 ++wrote 2048/2048 bytes at offset 4146176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4150272 ++wrote 2048/2048 bytes at offset 4150272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4154368 ++wrote 2048/2048 bytes at offset 4154368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4158464 ++wrote 2048/2048 bytes at offset 4158464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4162560 ++wrote 2048/2048 bytes at offset 4162560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4166656 ++wrote 2048/2048 bytes at offset 4166656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4170752 ++wrote 2048/2048 bytes at offset 4170752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4174848 ++wrote 2048/2048 bytes at offset 4174848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4178944 ++wrote 2048/2048 bytes at offset 4178944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4183040 ++wrote 2048/2048 bytes at offset 4183040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4187136 ++wrote 2048/2048 bytes at offset 4187136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4191232 ++wrote 2048/2048 bytes at offset 4191232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 4 +-qemu-io> wrote 8192/8192 bytes at offset 4196352 ++=== IO: pattern 4 ++wrote 8192/8192 bytes at offset 4196352 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4208640 ++wrote 8192/8192 bytes at offset 4208640 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4220928 ++wrote 8192/8192 bytes at offset 4220928 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4233216 ++wrote 8192/8192 bytes at offset 4233216 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4245504 ++wrote 8192/8192 bytes at offset 4245504 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4257792 ++wrote 8192/8192 bytes at offset 4257792 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4270080 ++wrote 8192/8192 bytes at offset 4270080 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4282368 ++wrote 8192/8192 bytes at offset 4282368 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4294656 ++wrote 8192/8192 bytes at offset 4294656 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4306944 ++wrote 8192/8192 bytes at offset 4306944 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4319232 ++wrote 8192/8192 bytes at offset 4319232 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4331520 ++wrote 8192/8192 bytes at offset 4331520 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4343808 ++wrote 8192/8192 bytes at offset 4343808 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4356096 ++wrote 8192/8192 bytes at offset 4356096 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4368384 ++wrote 8192/8192 bytes at offset 4368384 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4380672 ++wrote 8192/8192 bytes at offset 4380672 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4392960 ++wrote 8192/8192 bytes at offset 4392960 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4405248 ++wrote 8192/8192 bytes at offset 4405248 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4417536 ++wrote 8192/8192 bytes at offset 4417536 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4429824 ++wrote 8192/8192 bytes at offset 4429824 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4442112 ++wrote 8192/8192 bytes at offset 4442112 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4454400 ++wrote 8192/8192 bytes at offset 4454400 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4466688 ++wrote 8192/8192 bytes at offset 4466688 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4478976 ++wrote 8192/8192 bytes at offset 4478976 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4491264 ++wrote 8192/8192 bytes at offset 4491264 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4503552 ++wrote 8192/8192 bytes at offset 4503552 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4515840 ++wrote 8192/8192 bytes at offset 4515840 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4528128 ++wrote 8192/8192 bytes at offset 4528128 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4540416 ++wrote 8192/8192 bytes at offset 4540416 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4552704 ++wrote 8192/8192 bytes at offset 4552704 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4564992 ++wrote 8192/8192 bytes at offset 4564992 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4577280 ++wrote 8192/8192 bytes at offset 4577280 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4589568 ++wrote 8192/8192 bytes at offset 4589568 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4601856 ++wrote 8192/8192 bytes at offset 4601856 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4614144 ++wrote 8192/8192 bytes at offset 4614144 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4626432 ++wrote 8192/8192 bytes at offset 4626432 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4638720 ++wrote 8192/8192 bytes at offset 4638720 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4651008 ++wrote 8192/8192 bytes at offset 4651008 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4663296 ++wrote 8192/8192 bytes at offset 4663296 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4675584 ++wrote 8192/8192 bytes at offset 4675584 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4687872 ++wrote 8192/8192 bytes at offset 4687872 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4700160 ++wrote 8192/8192 bytes at offset 4700160 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4712448 ++wrote 8192/8192 bytes at offset 4712448 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4724736 ++wrote 8192/8192 bytes at offset 4724736 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4737024 ++wrote 8192/8192 bytes at offset 4737024 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4749312 ++wrote 8192/8192 bytes at offset 4749312 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4761600 ++wrote 8192/8192 bytes at offset 4761600 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4773888 ++wrote 8192/8192 bytes at offset 4773888 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4786176 ++wrote 8192/8192 bytes at offset 4786176 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4798464 ++wrote 8192/8192 bytes at offset 4798464 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4810752 ++wrote 8192/8192 bytes at offset 4810752 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4823040 ++wrote 8192/8192 bytes at offset 4823040 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4835328 ++wrote 8192/8192 bytes at offset 4835328 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4847616 ++wrote 8192/8192 bytes at offset 4847616 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4859904 ++wrote 8192/8192 bytes at offset 4859904 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4872192 ++wrote 8192/8192 bytes at offset 4872192 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4884480 ++wrote 8192/8192 bytes at offset 4884480 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4896768 ++wrote 8192/8192 bytes at offset 4896768 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4909056 ++wrote 8192/8192 bytes at offset 4909056 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4921344 ++wrote 8192/8192 bytes at offset 4921344 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4933632 ++wrote 8192/8192 bytes at offset 4933632 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4945920 ++wrote 8192/8192 bytes at offset 4945920 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4958208 ++wrote 8192/8192 bytes at offset 4958208 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4970496 ++wrote 8192/8192 bytes at offset 4970496 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 244 +-qemu-io> wrote 12288/12288 bytes at offset 6285312 ++=== IO: pattern 244 ++wrote 12288/12288 bytes at offset 6285312 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 8384512 ++wrote 12288/12288 bytes at offset 8384512 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 10483712 ++wrote 12288/12288 bytes at offset 10483712 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 12582912 ++wrote 12288/12288 bytes at offset 12582912 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 14682112 ++wrote 12288/12288 bytes at offset 14682112 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 16781312 ++wrote 12288/12288 bytes at offset 16781312 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 18880512 ++wrote 12288/12288 bytes at offset 18880512 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 20979712 ++wrote 12288/12288 bytes at offset 20979712 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> read 4096/4096 bytes at offset 0 ++=== IO: pattern 0 ++read 4096/4096 bytes at offset 0 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4096 ++read 4096/4096 bytes at offset 4096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 8192 ++read 4096/4096 bytes at offset 8192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 12288 ++read 4096/4096 bytes at offset 12288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 16384 ++read 4096/4096 bytes at offset 16384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 20480 ++read 4096/4096 bytes at offset 20480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 24576 ++read 4096/4096 bytes at offset 24576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 28672 ++read 4096/4096 bytes at offset 28672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 32768 ++read 4096/4096 bytes at offset 32768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 36864 ++read 4096/4096 bytes at offset 36864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 40960 ++read 4096/4096 bytes at offset 40960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 45056 ++read 4096/4096 bytes at offset 45056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 49152 ++read 4096/4096 bytes at offset 49152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 53248 ++read 4096/4096 bytes at offset 53248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 57344 ++read 4096/4096 bytes at offset 57344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 61440 ++read 4096/4096 bytes at offset 61440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 65536 ++read 4096/4096 bytes at offset 65536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 69632 ++read 4096/4096 bytes at offset 69632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 73728 ++read 4096/4096 bytes at offset 73728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 77824 ++read 4096/4096 bytes at offset 77824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 81920 ++read 4096/4096 bytes at offset 81920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 86016 ++read 4096/4096 bytes at offset 86016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 90112 ++read 4096/4096 bytes at offset 90112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 94208 ++read 4096/4096 bytes at offset 94208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 98304 ++read 4096/4096 bytes at offset 98304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 102400 ++read 4096/4096 bytes at offset 102400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 106496 ++read 4096/4096 bytes at offset 106496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 110592 ++read 4096/4096 bytes at offset 110592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 114688 ++read 4096/4096 bytes at offset 114688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 118784 ++read 4096/4096 bytes at offset 118784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 122880 ++read 4096/4096 bytes at offset 122880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 126976 ++read 4096/4096 bytes at offset 126976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 131072 ++read 4096/4096 bytes at offset 131072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 135168 ++read 4096/4096 bytes at offset 135168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 139264 ++read 4096/4096 bytes at offset 139264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 143360 ++read 4096/4096 bytes at offset 143360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 147456 ++read 4096/4096 bytes at offset 147456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 151552 ++read 4096/4096 bytes at offset 151552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 155648 ++read 4096/4096 bytes at offset 155648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 159744 ++read 4096/4096 bytes at offset 159744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 163840 ++read 4096/4096 bytes at offset 163840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 167936 ++read 4096/4096 bytes at offset 167936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 172032 ++read 4096/4096 bytes at offset 172032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 176128 ++read 4096/4096 bytes at offset 176128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 180224 ++read 4096/4096 bytes at offset 180224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 184320 ++read 4096/4096 bytes at offset 184320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 188416 ++read 4096/4096 bytes at offset 188416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 192512 ++read 4096/4096 bytes at offset 192512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 196608 ++read 4096/4096 bytes at offset 196608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 200704 ++read 4096/4096 bytes at offset 200704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 204800 ++read 4096/4096 bytes at offset 204800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 208896 ++read 4096/4096 bytes at offset 208896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 212992 ++read 4096/4096 bytes at offset 212992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 217088 ++read 4096/4096 bytes at offset 217088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 221184 ++read 4096/4096 bytes at offset 221184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 225280 ++read 4096/4096 bytes at offset 225280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 229376 ++read 4096/4096 bytes at offset 229376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 233472 ++read 4096/4096 bytes at offset 233472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 237568 ++read 4096/4096 bytes at offset 237568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 241664 ++read 4096/4096 bytes at offset 241664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 245760 ++read 4096/4096 bytes at offset 245760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 249856 ++read 4096/4096 bytes at offset 249856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 253952 ++read 4096/4096 bytes at offset 253952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 258048 ++read 4096/4096 bytes at offset 258048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 262144 ++read 4096/4096 bytes at offset 262144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 266240 ++read 4096/4096 bytes at offset 266240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 270336 ++read 4096/4096 bytes at offset 270336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 274432 ++read 4096/4096 bytes at offset 274432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 278528 ++read 4096/4096 bytes at offset 278528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 282624 ++read 4096/4096 bytes at offset 282624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 286720 ++read 4096/4096 bytes at offset 286720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 290816 ++read 4096/4096 bytes at offset 290816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 294912 ++read 4096/4096 bytes at offset 294912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 299008 ++read 4096/4096 bytes at offset 299008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 303104 ++read 4096/4096 bytes at offset 303104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 307200 ++read 4096/4096 bytes at offset 307200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 311296 ++read 4096/4096 bytes at offset 311296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 315392 ++read 4096/4096 bytes at offset 315392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 319488 ++read 4096/4096 bytes at offset 319488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 323584 ++read 4096/4096 bytes at offset 323584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 327680 ++read 4096/4096 bytes at offset 327680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 331776 ++read 4096/4096 bytes at offset 331776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 335872 ++read 4096/4096 bytes at offset 335872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 339968 ++read 4096/4096 bytes at offset 339968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 344064 ++read 4096/4096 bytes at offset 344064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 348160 ++read 4096/4096 bytes at offset 348160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 352256 ++read 4096/4096 bytes at offset 352256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 356352 ++read 4096/4096 bytes at offset 356352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 360448 ++read 4096/4096 bytes at offset 360448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 364544 ++read 4096/4096 bytes at offset 364544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 368640 ++read 4096/4096 bytes at offset 368640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 372736 ++read 4096/4096 bytes at offset 372736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 376832 ++read 4096/4096 bytes at offset 376832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 380928 ++read 4096/4096 bytes at offset 380928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 385024 ++read 4096/4096 bytes at offset 385024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 389120 ++read 4096/4096 bytes at offset 389120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 393216 ++read 4096/4096 bytes at offset 393216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 397312 ++read 4096/4096 bytes at offset 397312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 401408 ++read 4096/4096 bytes at offset 401408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 405504 ++read 4096/4096 bytes at offset 405504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 409600 ++read 4096/4096 bytes at offset 409600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 413696 ++read 4096/4096 bytes at offset 413696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 417792 ++read 4096/4096 bytes at offset 417792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 421888 ++read 4096/4096 bytes at offset 421888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 425984 ++read 4096/4096 bytes at offset 425984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 430080 ++read 4096/4096 bytes at offset 430080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 434176 ++read 4096/4096 bytes at offset 434176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 438272 ++read 4096/4096 bytes at offset 438272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 442368 ++read 4096/4096 bytes at offset 442368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 446464 ++read 4096/4096 bytes at offset 446464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 450560 ++read 4096/4096 bytes at offset 450560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 454656 ++read 4096/4096 bytes at offset 454656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 458752 ++read 4096/4096 bytes at offset 458752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 462848 ++read 4096/4096 bytes at offset 462848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 466944 ++read 4096/4096 bytes at offset 466944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 471040 ++read 4096/4096 bytes at offset 471040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 475136 ++read 4096/4096 bytes at offset 475136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 479232 ++read 4096/4096 bytes at offset 479232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 483328 ++read 4096/4096 bytes at offset 483328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 487424 ++read 4096/4096 bytes at offset 487424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 491520 ++read 4096/4096 bytes at offset 491520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 495616 ++read 4096/4096 bytes at offset 495616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 499712 ++read 4096/4096 bytes at offset 499712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 503808 ++read 4096/4096 bytes at offset 503808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 507904 ++read 4096/4096 bytes at offset 507904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 512000 ++read 4096/4096 bytes at offset 512000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 516096 ++read 4096/4096 bytes at offset 516096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 520192 ++read 4096/4096 bytes at offset 520192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 524288 ++read 4096/4096 bytes at offset 524288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 528384 ++read 4096/4096 bytes at offset 528384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 532480 ++read 4096/4096 bytes at offset 532480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 536576 ++read 4096/4096 bytes at offset 536576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 540672 ++read 4096/4096 bytes at offset 540672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 544768 ++read 4096/4096 bytes at offset 544768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 548864 ++read 4096/4096 bytes at offset 548864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 552960 ++read 4096/4096 bytes at offset 552960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 557056 ++read 4096/4096 bytes at offset 557056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 561152 ++read 4096/4096 bytes at offset 561152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 565248 ++read 4096/4096 bytes at offset 565248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 569344 ++read 4096/4096 bytes at offset 569344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 573440 ++read 4096/4096 bytes at offset 573440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 577536 ++read 4096/4096 bytes at offset 577536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 581632 ++read 4096/4096 bytes at offset 581632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 585728 ++read 4096/4096 bytes at offset 585728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 589824 ++read 4096/4096 bytes at offset 589824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 593920 ++read 4096/4096 bytes at offset 593920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 598016 ++read 4096/4096 bytes at offset 598016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 602112 ++read 4096/4096 bytes at offset 602112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 606208 ++read 4096/4096 bytes at offset 606208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 610304 ++read 4096/4096 bytes at offset 610304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 614400 ++read 4096/4096 bytes at offset 614400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 618496 ++read 4096/4096 bytes at offset 618496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 622592 ++read 4096/4096 bytes at offset 622592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 626688 ++read 4096/4096 bytes at offset 626688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 630784 ++read 4096/4096 bytes at offset 630784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 634880 ++read 4096/4096 bytes at offset 634880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 638976 ++read 4096/4096 bytes at offset 638976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 643072 ++read 4096/4096 bytes at offset 643072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 647168 ++read 4096/4096 bytes at offset 647168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 651264 ++read 4096/4096 bytes at offset 651264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 655360 ++read 4096/4096 bytes at offset 655360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 659456 ++read 4096/4096 bytes at offset 659456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 663552 ++read 4096/4096 bytes at offset 663552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 667648 ++read 4096/4096 bytes at offset 667648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 671744 ++read 4096/4096 bytes at offset 671744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 675840 ++read 4096/4096 bytes at offset 675840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 679936 ++read 4096/4096 bytes at offset 679936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 684032 ++read 4096/4096 bytes at offset 684032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 688128 ++read 4096/4096 bytes at offset 688128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 692224 ++read 4096/4096 bytes at offset 692224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 696320 ++read 4096/4096 bytes at offset 696320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 700416 ++read 4096/4096 bytes at offset 700416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 704512 ++read 4096/4096 bytes at offset 704512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 708608 ++read 4096/4096 bytes at offset 708608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 712704 ++read 4096/4096 bytes at offset 712704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 716800 ++read 4096/4096 bytes at offset 716800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 720896 ++read 4096/4096 bytes at offset 720896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 724992 ++read 4096/4096 bytes at offset 724992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 729088 ++read 4096/4096 bytes at offset 729088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 733184 ++read 4096/4096 bytes at offset 733184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 737280 ++read 4096/4096 bytes at offset 737280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 741376 ++read 4096/4096 bytes at offset 741376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 745472 ++read 4096/4096 bytes at offset 745472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 749568 ++read 4096/4096 bytes at offset 749568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 753664 ++read 4096/4096 bytes at offset 753664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 757760 ++read 4096/4096 bytes at offset 757760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 761856 ++read 4096/4096 bytes at offset 761856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 765952 ++read 4096/4096 bytes at offset 765952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 770048 ++read 4096/4096 bytes at offset 770048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 774144 ++read 4096/4096 bytes at offset 774144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 778240 ++read 4096/4096 bytes at offset 778240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 782336 ++read 4096/4096 bytes at offset 782336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 786432 ++read 4096/4096 bytes at offset 786432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 790528 ++read 4096/4096 bytes at offset 790528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 794624 ++read 4096/4096 bytes at offset 794624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 798720 ++read 4096/4096 bytes at offset 798720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 802816 ++read 4096/4096 bytes at offset 802816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 806912 ++read 4096/4096 bytes at offset 806912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 811008 ++read 4096/4096 bytes at offset 811008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 815104 ++read 4096/4096 bytes at offset 815104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 819200 ++read 4096/4096 bytes at offset 819200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 823296 ++read 4096/4096 bytes at offset 823296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 827392 ++read 4096/4096 bytes at offset 827392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 831488 ++read 4096/4096 bytes at offset 831488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 835584 ++read 4096/4096 bytes at offset 835584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 839680 ++read 4096/4096 bytes at offset 839680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 843776 ++read 4096/4096 bytes at offset 843776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 847872 ++read 4096/4096 bytes at offset 847872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 851968 ++read 4096/4096 bytes at offset 851968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 856064 ++read 4096/4096 bytes at offset 856064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 860160 ++read 4096/4096 bytes at offset 860160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 864256 ++read 4096/4096 bytes at offset 864256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 868352 ++read 4096/4096 bytes at offset 868352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 872448 ++read 4096/4096 bytes at offset 872448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 876544 ++read 4096/4096 bytes at offset 876544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 880640 ++read 4096/4096 bytes at offset 880640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 884736 ++read 4096/4096 bytes at offset 884736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 888832 ++read 4096/4096 bytes at offset 888832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 892928 ++read 4096/4096 bytes at offset 892928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 897024 ++read 4096/4096 bytes at offset 897024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 901120 ++read 4096/4096 bytes at offset 901120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 905216 ++read 4096/4096 bytes at offset 905216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 909312 ++read 4096/4096 bytes at offset 909312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 913408 ++read 4096/4096 bytes at offset 913408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 917504 ++read 4096/4096 bytes at offset 917504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 921600 ++read 4096/4096 bytes at offset 921600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 925696 ++read 4096/4096 bytes at offset 925696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 929792 ++read 4096/4096 bytes at offset 929792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 933888 ++read 4096/4096 bytes at offset 933888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 937984 ++read 4096/4096 bytes at offset 937984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 942080 ++read 4096/4096 bytes at offset 942080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 946176 ++read 4096/4096 bytes at offset 946176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 950272 ++read 4096/4096 bytes at offset 950272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 954368 ++read 4096/4096 bytes at offset 954368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 958464 ++read 4096/4096 bytes at offset 958464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 962560 ++read 4096/4096 bytes at offset 962560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 966656 ++read 4096/4096 bytes at offset 966656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 970752 ++read 4096/4096 bytes at offset 970752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 974848 ++read 4096/4096 bytes at offset 974848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 978944 ++read 4096/4096 bytes at offset 978944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 983040 ++read 4096/4096 bytes at offset 983040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 987136 ++read 4096/4096 bytes at offset 987136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 991232 ++read 4096/4096 bytes at offset 991232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 995328 ++read 4096/4096 bytes at offset 995328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 999424 ++read 4096/4096 bytes at offset 999424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1003520 ++read 4096/4096 bytes at offset 1003520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1007616 ++read 4096/4096 bytes at offset 1007616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1011712 ++read 4096/4096 bytes at offset 1011712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1015808 ++read 4096/4096 bytes at offset 1015808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1019904 ++read 4096/4096 bytes at offset 1019904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1024000 ++read 4096/4096 bytes at offset 1024000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1028096 ++read 4096/4096 bytes at offset 1028096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1032192 ++read 4096/4096 bytes at offset 1032192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1036288 ++read 4096/4096 bytes at offset 1036288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1040384 ++read 4096/4096 bytes at offset 1040384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1044480 ++read 4096/4096 bytes at offset 1044480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 4 +-qemu-io> read 2048/2048 bytes at offset 1050624 ++=== IO: pattern 4 ++read 2048/2048 bytes at offset 1050624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1054720 ++read 2048/2048 bytes at offset 1054720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1058816 ++read 2048/2048 bytes at offset 1058816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1062912 ++read 2048/2048 bytes at offset 1062912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1067008 ++read 2048/2048 bytes at offset 1067008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1071104 ++read 2048/2048 bytes at offset 1071104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1075200 ++read 2048/2048 bytes at offset 1075200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1079296 ++read 2048/2048 bytes at offset 1079296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1083392 ++read 2048/2048 bytes at offset 1083392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1087488 ++read 2048/2048 bytes at offset 1087488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1091584 ++read 2048/2048 bytes at offset 1091584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1095680 ++read 2048/2048 bytes at offset 1095680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1099776 ++read 2048/2048 bytes at offset 1099776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1103872 ++read 2048/2048 bytes at offset 1103872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1107968 ++read 2048/2048 bytes at offset 1107968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1112064 ++read 2048/2048 bytes at offset 1112064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1116160 ++read 2048/2048 bytes at offset 1116160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1120256 ++read 2048/2048 bytes at offset 1120256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1124352 ++read 2048/2048 bytes at offset 1124352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1128448 ++read 2048/2048 bytes at offset 1128448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1132544 ++read 2048/2048 bytes at offset 1132544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1136640 ++read 2048/2048 bytes at offset 1136640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1140736 ++read 2048/2048 bytes at offset 1140736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1144832 ++read 2048/2048 bytes at offset 1144832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1148928 ++read 2048/2048 bytes at offset 1148928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1153024 ++read 2048/2048 bytes at offset 1153024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1157120 ++read 2048/2048 bytes at offset 1157120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1161216 ++read 2048/2048 bytes at offset 1161216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1165312 ++read 2048/2048 bytes at offset 1165312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1169408 ++read 2048/2048 bytes at offset 1169408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1173504 ++read 2048/2048 bytes at offset 1173504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1177600 ++read 2048/2048 bytes at offset 1177600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1181696 ++read 2048/2048 bytes at offset 1181696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1185792 ++read 2048/2048 bytes at offset 1185792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1189888 ++read 2048/2048 bytes at offset 1189888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1193984 ++read 2048/2048 bytes at offset 1193984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1198080 ++read 2048/2048 bytes at offset 1198080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1202176 ++read 2048/2048 bytes at offset 1202176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1206272 ++read 2048/2048 bytes at offset 1206272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1210368 ++read 2048/2048 bytes at offset 1210368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1214464 ++read 2048/2048 bytes at offset 1214464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1218560 ++read 2048/2048 bytes at offset 1218560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1222656 ++read 2048/2048 bytes at offset 1222656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1226752 ++read 2048/2048 bytes at offset 1226752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1230848 ++read 2048/2048 bytes at offset 1230848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1234944 ++read 2048/2048 bytes at offset 1234944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1239040 ++read 2048/2048 bytes at offset 1239040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1243136 ++read 2048/2048 bytes at offset 1243136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1247232 ++read 2048/2048 bytes at offset 1247232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1251328 ++read 2048/2048 bytes at offset 1251328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1255424 ++read 2048/2048 bytes at offset 1255424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1259520 ++read 2048/2048 bytes at offset 1259520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1263616 ++read 2048/2048 bytes at offset 1263616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1267712 ++read 2048/2048 bytes at offset 1267712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1271808 ++read 2048/2048 bytes at offset 1271808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1275904 ++read 2048/2048 bytes at offset 1275904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1280000 ++read 2048/2048 bytes at offset 1280000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1284096 ++read 2048/2048 bytes at offset 1284096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1288192 ++read 2048/2048 bytes at offset 1288192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1292288 ++read 2048/2048 bytes at offset 1292288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1296384 ++read 2048/2048 bytes at offset 1296384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1300480 ++read 2048/2048 bytes at offset 1300480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1304576 ++read 2048/2048 bytes at offset 1304576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1308672 ++read 2048/2048 bytes at offset 1308672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1312768 ++read 2048/2048 bytes at offset 1312768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1316864 ++read 2048/2048 bytes at offset 1316864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1320960 ++read 2048/2048 bytes at offset 1320960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1325056 ++read 2048/2048 bytes at offset 1325056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1329152 ++read 2048/2048 bytes at offset 1329152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1333248 ++read 2048/2048 bytes at offset 1333248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1337344 ++read 2048/2048 bytes at offset 1337344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1341440 ++read 2048/2048 bytes at offset 1341440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1345536 ++read 2048/2048 bytes at offset 1345536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1349632 ++read 2048/2048 bytes at offset 1349632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1353728 ++read 2048/2048 bytes at offset 1353728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1357824 ++read 2048/2048 bytes at offset 1357824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1361920 ++read 2048/2048 bytes at offset 1361920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1366016 ++read 2048/2048 bytes at offset 1366016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1370112 ++read 2048/2048 bytes at offset 1370112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1374208 ++read 2048/2048 bytes at offset 1374208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1378304 ++read 2048/2048 bytes at offset 1378304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1382400 ++read 2048/2048 bytes at offset 1382400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1386496 ++read 2048/2048 bytes at offset 1386496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1390592 ++read 2048/2048 bytes at offset 1390592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1394688 ++read 2048/2048 bytes at offset 1394688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1398784 ++read 2048/2048 bytes at offset 1398784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1402880 ++read 2048/2048 bytes at offset 1402880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1406976 ++read 2048/2048 bytes at offset 1406976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1411072 ++read 2048/2048 bytes at offset 1411072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1415168 ++read 2048/2048 bytes at offset 1415168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1419264 ++read 2048/2048 bytes at offset 1419264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1423360 ++read 2048/2048 bytes at offset 1423360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1427456 ++read 2048/2048 bytes at offset 1427456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1431552 ++read 2048/2048 bytes at offset 1431552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1435648 ++read 2048/2048 bytes at offset 1435648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1439744 ++read 2048/2048 bytes at offset 1439744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1443840 ++read 2048/2048 bytes at offset 1443840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1447936 ++read 2048/2048 bytes at offset 1447936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1452032 ++read 2048/2048 bytes at offset 1452032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1456128 ++read 2048/2048 bytes at offset 1456128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1460224 ++read 2048/2048 bytes at offset 1460224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1464320 ++read 2048/2048 bytes at offset 1464320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1468416 ++read 2048/2048 bytes at offset 1468416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1472512 ++read 2048/2048 bytes at offset 1472512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1476608 ++read 2048/2048 bytes at offset 1476608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1480704 ++read 2048/2048 bytes at offset 1480704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1484800 ++read 2048/2048 bytes at offset 1484800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1488896 ++read 2048/2048 bytes at offset 1488896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1492992 ++read 2048/2048 bytes at offset 1492992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1497088 ++read 2048/2048 bytes at offset 1497088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1501184 ++read 2048/2048 bytes at offset 1501184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1505280 ++read 2048/2048 bytes at offset 1505280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1509376 ++read 2048/2048 bytes at offset 1509376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1513472 ++read 2048/2048 bytes at offset 1513472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1517568 ++read 2048/2048 bytes at offset 1517568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1521664 ++read 2048/2048 bytes at offset 1521664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1525760 ++read 2048/2048 bytes at offset 1525760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1529856 ++read 2048/2048 bytes at offset 1529856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1533952 ++read 2048/2048 bytes at offset 1533952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1538048 ++read 2048/2048 bytes at offset 1538048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1542144 ++read 2048/2048 bytes at offset 1542144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1546240 ++read 2048/2048 bytes at offset 1546240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1550336 ++read 2048/2048 bytes at offset 1550336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1554432 ++read 2048/2048 bytes at offset 1554432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1558528 ++read 2048/2048 bytes at offset 1558528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1562624 ++read 2048/2048 bytes at offset 1562624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1566720 ++read 2048/2048 bytes at offset 1566720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1570816 ++read 2048/2048 bytes at offset 1570816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1574912 ++read 2048/2048 bytes at offset 1574912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1579008 ++read 2048/2048 bytes at offset 1579008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1583104 ++read 2048/2048 bytes at offset 1583104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1587200 ++read 2048/2048 bytes at offset 1587200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1591296 ++read 2048/2048 bytes at offset 1591296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1595392 ++read 2048/2048 bytes at offset 1595392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1599488 ++read 2048/2048 bytes at offset 1599488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1603584 ++read 2048/2048 bytes at offset 1603584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1607680 ++read 2048/2048 bytes at offset 1607680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1611776 ++read 2048/2048 bytes at offset 1611776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1615872 ++read 2048/2048 bytes at offset 1615872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1619968 ++read 2048/2048 bytes at offset 1619968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1624064 ++read 2048/2048 bytes at offset 1624064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1628160 ++read 2048/2048 bytes at offset 1628160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1632256 ++read 2048/2048 bytes at offset 1632256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1636352 ++read 2048/2048 bytes at offset 1636352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1640448 ++read 2048/2048 bytes at offset 1640448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1644544 ++read 2048/2048 bytes at offset 1644544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1648640 ++read 2048/2048 bytes at offset 1648640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1652736 ++read 2048/2048 bytes at offset 1652736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1656832 ++read 2048/2048 bytes at offset 1656832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1660928 ++read 2048/2048 bytes at offset 1660928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1665024 ++read 2048/2048 bytes at offset 1665024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1669120 ++read 2048/2048 bytes at offset 1669120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1673216 ++read 2048/2048 bytes at offset 1673216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1677312 ++read 2048/2048 bytes at offset 1677312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1681408 ++read 2048/2048 bytes at offset 1681408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1685504 ++read 2048/2048 bytes at offset 1685504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1689600 ++read 2048/2048 bytes at offset 1689600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1693696 ++read 2048/2048 bytes at offset 1693696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1697792 ++read 2048/2048 bytes at offset 1697792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1701888 ++read 2048/2048 bytes at offset 1701888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1705984 ++read 2048/2048 bytes at offset 1705984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1710080 ++read 2048/2048 bytes at offset 1710080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1714176 ++read 2048/2048 bytes at offset 1714176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1718272 ++read 2048/2048 bytes at offset 1718272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1722368 ++read 2048/2048 bytes at offset 1722368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1726464 ++read 2048/2048 bytes at offset 1726464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1730560 ++read 2048/2048 bytes at offset 1730560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1734656 ++read 2048/2048 bytes at offset 1734656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1738752 ++read 2048/2048 bytes at offset 1738752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1742848 ++read 2048/2048 bytes at offset 1742848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1746944 ++read 2048/2048 bytes at offset 1746944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1751040 ++read 2048/2048 bytes at offset 1751040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1755136 ++read 2048/2048 bytes at offset 1755136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1759232 ++read 2048/2048 bytes at offset 1759232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1763328 ++read 2048/2048 bytes at offset 1763328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1767424 ++read 2048/2048 bytes at offset 1767424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1771520 ++read 2048/2048 bytes at offset 1771520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1775616 ++read 2048/2048 bytes at offset 1775616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1779712 ++read 2048/2048 bytes at offset 1779712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1783808 ++read 2048/2048 bytes at offset 1783808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1787904 ++read 2048/2048 bytes at offset 1787904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1792000 ++read 2048/2048 bytes at offset 1792000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1796096 ++read 2048/2048 bytes at offset 1796096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1800192 ++read 2048/2048 bytes at offset 1800192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1804288 ++read 2048/2048 bytes at offset 1804288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1808384 ++read 2048/2048 bytes at offset 1808384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1812480 ++read 2048/2048 bytes at offset 1812480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1816576 ++read 2048/2048 bytes at offset 1816576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1820672 ++read 2048/2048 bytes at offset 1820672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1824768 ++read 2048/2048 bytes at offset 1824768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1828864 ++read 2048/2048 bytes at offset 1828864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1832960 ++read 2048/2048 bytes at offset 1832960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1837056 ++read 2048/2048 bytes at offset 1837056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1841152 ++read 2048/2048 bytes at offset 1841152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1845248 ++read 2048/2048 bytes at offset 1845248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1849344 ++read 2048/2048 bytes at offset 1849344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1853440 ++read 2048/2048 bytes at offset 1853440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1857536 ++read 2048/2048 bytes at offset 1857536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1861632 ++read 2048/2048 bytes at offset 1861632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1865728 ++read 2048/2048 bytes at offset 1865728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1869824 ++read 2048/2048 bytes at offset 1869824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1873920 ++read 2048/2048 bytes at offset 1873920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1878016 ++read 2048/2048 bytes at offset 1878016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1882112 ++read 2048/2048 bytes at offset 1882112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1886208 ++read 2048/2048 bytes at offset 1886208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1890304 ++read 2048/2048 bytes at offset 1890304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1894400 ++read 2048/2048 bytes at offset 1894400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1898496 ++read 2048/2048 bytes at offset 1898496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1902592 ++read 2048/2048 bytes at offset 1902592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1906688 ++read 2048/2048 bytes at offset 1906688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1910784 ++read 2048/2048 bytes at offset 1910784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1914880 ++read 2048/2048 bytes at offset 1914880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1918976 ++read 2048/2048 bytes at offset 1918976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1923072 ++read 2048/2048 bytes at offset 1923072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1927168 ++read 2048/2048 bytes at offset 1927168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1931264 ++read 2048/2048 bytes at offset 1931264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1935360 ++read 2048/2048 bytes at offset 1935360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1939456 ++read 2048/2048 bytes at offset 1939456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1943552 ++read 2048/2048 bytes at offset 1943552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1947648 ++read 2048/2048 bytes at offset 1947648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1951744 ++read 2048/2048 bytes at offset 1951744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1955840 ++read 2048/2048 bytes at offset 1955840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1959936 ++read 2048/2048 bytes at offset 1959936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1964032 ++read 2048/2048 bytes at offset 1964032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1968128 ++read 2048/2048 bytes at offset 1968128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1972224 ++read 2048/2048 bytes at offset 1972224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1976320 ++read 2048/2048 bytes at offset 1976320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1980416 ++read 2048/2048 bytes at offset 1980416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1984512 ++read 2048/2048 bytes at offset 1984512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1988608 ++read 2048/2048 bytes at offset 1988608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1992704 ++read 2048/2048 bytes at offset 1992704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1996800 ++read 2048/2048 bytes at offset 1996800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2000896 ++read 2048/2048 bytes at offset 2000896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2004992 ++read 2048/2048 bytes at offset 2004992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2009088 ++read 2048/2048 bytes at offset 2009088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2013184 ++read 2048/2048 bytes at offset 2013184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2017280 ++read 2048/2048 bytes at offset 2017280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2021376 ++read 2048/2048 bytes at offset 2021376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2025472 ++read 2048/2048 bytes at offset 2025472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2029568 ++read 2048/2048 bytes at offset 2029568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2033664 ++read 2048/2048 bytes at offset 2033664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2037760 ++read 2048/2048 bytes at offset 2037760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2041856 ++read 2048/2048 bytes at offset 2041856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2045952 ++read 2048/2048 bytes at offset 2045952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2050048 ++read 2048/2048 bytes at offset 2050048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2054144 ++read 2048/2048 bytes at offset 2054144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2058240 ++read 2048/2048 bytes at offset 2058240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2062336 ++read 2048/2048 bytes at offset 2062336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2066432 ++read 2048/2048 bytes at offset 2066432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2070528 ++read 2048/2048 bytes at offset 2070528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2074624 ++read 2048/2048 bytes at offset 2074624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2078720 ++read 2048/2048 bytes at offset 2078720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2082816 ++read 2048/2048 bytes at offset 2082816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2086912 ++read 2048/2048 bytes at offset 2086912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2091008 ++read 2048/2048 bytes at offset 2091008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2095104 ++read 2048/2048 bytes at offset 2095104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> read 2048/2048 bytes at offset 2097152 ++=== IO: pattern 0 ++read 2048/2048 bytes at offset 2097152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2101248 ++read 2048/2048 bytes at offset 2101248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2105344 ++read 2048/2048 bytes at offset 2105344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2109440 ++read 2048/2048 bytes at offset 2109440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2113536 ++read 2048/2048 bytes at offset 2113536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2117632 ++read 2048/2048 bytes at offset 2117632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2121728 ++read 2048/2048 bytes at offset 2121728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2125824 ++read 2048/2048 bytes at offset 2125824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2129920 ++read 2048/2048 bytes at offset 2129920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2134016 ++read 2048/2048 bytes at offset 2134016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2138112 ++read 2048/2048 bytes at offset 2138112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2142208 ++read 2048/2048 bytes at offset 2142208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2146304 ++read 2048/2048 bytes at offset 2146304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2150400 ++read 2048/2048 bytes at offset 2150400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2154496 ++read 2048/2048 bytes at offset 2154496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2158592 ++read 2048/2048 bytes at offset 2158592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2162688 ++read 2048/2048 bytes at offset 2162688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2166784 ++read 2048/2048 bytes at offset 2166784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2170880 ++read 2048/2048 bytes at offset 2170880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2174976 ++read 2048/2048 bytes at offset 2174976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2179072 ++read 2048/2048 bytes at offset 2179072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2183168 ++read 2048/2048 bytes at offset 2183168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2187264 ++read 2048/2048 bytes at offset 2187264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2191360 ++read 2048/2048 bytes at offset 2191360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2195456 ++read 2048/2048 bytes at offset 2195456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2199552 ++read 2048/2048 bytes at offset 2199552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2203648 ++read 2048/2048 bytes at offset 2203648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2207744 ++read 2048/2048 bytes at offset 2207744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2211840 ++read 2048/2048 bytes at offset 2211840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2215936 ++read 2048/2048 bytes at offset 2215936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2220032 ++read 2048/2048 bytes at offset 2220032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2224128 ++read 2048/2048 bytes at offset 2224128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2228224 ++read 2048/2048 bytes at offset 2228224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2232320 ++read 2048/2048 bytes at offset 2232320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2236416 ++read 2048/2048 bytes at offset 2236416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2240512 ++read 2048/2048 bytes at offset 2240512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2244608 ++read 2048/2048 bytes at offset 2244608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2248704 ++read 2048/2048 bytes at offset 2248704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2252800 ++read 2048/2048 bytes at offset 2252800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2256896 ++read 2048/2048 bytes at offset 2256896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2260992 ++read 2048/2048 bytes at offset 2260992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2265088 ++read 2048/2048 bytes at offset 2265088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2269184 ++read 2048/2048 bytes at offset 2269184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2273280 ++read 2048/2048 bytes at offset 2273280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2277376 ++read 2048/2048 bytes at offset 2277376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2281472 ++read 2048/2048 bytes at offset 2281472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2285568 ++read 2048/2048 bytes at offset 2285568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2289664 ++read 2048/2048 bytes at offset 2289664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2293760 ++read 2048/2048 bytes at offset 2293760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2297856 ++read 2048/2048 bytes at offset 2297856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2301952 ++read 2048/2048 bytes at offset 2301952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2306048 ++read 2048/2048 bytes at offset 2306048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2310144 ++read 2048/2048 bytes at offset 2310144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2314240 ++read 2048/2048 bytes at offset 2314240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2318336 ++read 2048/2048 bytes at offset 2318336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2322432 ++read 2048/2048 bytes at offset 2322432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2326528 ++read 2048/2048 bytes at offset 2326528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2330624 ++read 2048/2048 bytes at offset 2330624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2334720 ++read 2048/2048 bytes at offset 2334720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2338816 ++read 2048/2048 bytes at offset 2338816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2342912 ++read 2048/2048 bytes at offset 2342912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2347008 ++read 2048/2048 bytes at offset 2347008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2351104 ++read 2048/2048 bytes at offset 2351104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2355200 ++read 2048/2048 bytes at offset 2355200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2359296 ++read 2048/2048 bytes at offset 2359296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2363392 ++read 2048/2048 bytes at offset 2363392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2367488 ++read 2048/2048 bytes at offset 2367488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2371584 ++read 2048/2048 bytes at offset 2371584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2375680 ++read 2048/2048 bytes at offset 2375680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2379776 ++read 2048/2048 bytes at offset 2379776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2383872 ++read 2048/2048 bytes at offset 2383872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2387968 ++read 2048/2048 bytes at offset 2387968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2392064 ++read 2048/2048 bytes at offset 2392064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2396160 ++read 2048/2048 bytes at offset 2396160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2400256 ++read 2048/2048 bytes at offset 2400256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2404352 ++read 2048/2048 bytes at offset 2404352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2408448 ++read 2048/2048 bytes at offset 2408448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2412544 ++read 2048/2048 bytes at offset 2412544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2416640 ++read 2048/2048 bytes at offset 2416640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2420736 ++read 2048/2048 bytes at offset 2420736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2424832 ++read 2048/2048 bytes at offset 2424832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2428928 ++read 2048/2048 bytes at offset 2428928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2433024 ++read 2048/2048 bytes at offset 2433024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2437120 ++read 2048/2048 bytes at offset 2437120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2441216 ++read 2048/2048 bytes at offset 2441216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2445312 ++read 2048/2048 bytes at offset 2445312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2449408 ++read 2048/2048 bytes at offset 2449408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2453504 ++read 2048/2048 bytes at offset 2453504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2457600 ++read 2048/2048 bytes at offset 2457600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2461696 ++read 2048/2048 bytes at offset 2461696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2465792 ++read 2048/2048 bytes at offset 2465792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2469888 ++read 2048/2048 bytes at offset 2469888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2473984 ++read 2048/2048 bytes at offset 2473984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2478080 ++read 2048/2048 bytes at offset 2478080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2482176 ++read 2048/2048 bytes at offset 2482176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2486272 ++read 2048/2048 bytes at offset 2486272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2490368 ++read 2048/2048 bytes at offset 2490368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2494464 ++read 2048/2048 bytes at offset 2494464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2498560 ++read 2048/2048 bytes at offset 2498560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2502656 ++read 2048/2048 bytes at offset 2502656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2506752 ++read 2048/2048 bytes at offset 2506752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2510848 ++read 2048/2048 bytes at offset 2510848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2514944 ++read 2048/2048 bytes at offset 2514944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2519040 ++read 2048/2048 bytes at offset 2519040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2523136 ++read 2048/2048 bytes at offset 2523136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2527232 ++read 2048/2048 bytes at offset 2527232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2531328 ++read 2048/2048 bytes at offset 2531328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2535424 ++read 2048/2048 bytes at offset 2535424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2539520 ++read 2048/2048 bytes at offset 2539520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2543616 ++read 2048/2048 bytes at offset 2543616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2547712 ++read 2048/2048 bytes at offset 2547712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2551808 ++read 2048/2048 bytes at offset 2551808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2555904 ++read 2048/2048 bytes at offset 2555904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2560000 ++read 2048/2048 bytes at offset 2560000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2564096 ++read 2048/2048 bytes at offset 2564096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2568192 ++read 2048/2048 bytes at offset 2568192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2572288 ++read 2048/2048 bytes at offset 2572288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2576384 ++read 2048/2048 bytes at offset 2576384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2580480 ++read 2048/2048 bytes at offset 2580480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2584576 ++read 2048/2048 bytes at offset 2584576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2588672 ++read 2048/2048 bytes at offset 2588672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2592768 ++read 2048/2048 bytes at offset 2592768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2596864 ++read 2048/2048 bytes at offset 2596864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2600960 ++read 2048/2048 bytes at offset 2600960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2605056 ++read 2048/2048 bytes at offset 2605056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2609152 ++read 2048/2048 bytes at offset 2609152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2613248 ++read 2048/2048 bytes at offset 2613248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2617344 ++read 2048/2048 bytes at offset 2617344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2621440 ++read 2048/2048 bytes at offset 2621440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2625536 ++read 2048/2048 bytes at offset 2625536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2629632 ++read 2048/2048 bytes at offset 2629632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2633728 ++read 2048/2048 bytes at offset 2633728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2637824 ++read 2048/2048 bytes at offset 2637824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2641920 ++read 2048/2048 bytes at offset 2641920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2646016 ++read 2048/2048 bytes at offset 2646016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2650112 ++read 2048/2048 bytes at offset 2650112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2654208 ++read 2048/2048 bytes at offset 2654208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2658304 ++read 2048/2048 bytes at offset 2658304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2662400 ++read 2048/2048 bytes at offset 2662400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2666496 ++read 2048/2048 bytes at offset 2666496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2670592 ++read 2048/2048 bytes at offset 2670592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2674688 ++read 2048/2048 bytes at offset 2674688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2678784 ++read 2048/2048 bytes at offset 2678784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2682880 ++read 2048/2048 bytes at offset 2682880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2686976 ++read 2048/2048 bytes at offset 2686976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2691072 ++read 2048/2048 bytes at offset 2691072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2695168 ++read 2048/2048 bytes at offset 2695168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2699264 ++read 2048/2048 bytes at offset 2699264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2703360 ++read 2048/2048 bytes at offset 2703360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2707456 ++read 2048/2048 bytes at offset 2707456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2711552 ++read 2048/2048 bytes at offset 2711552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2715648 ++read 2048/2048 bytes at offset 2715648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2719744 ++read 2048/2048 bytes at offset 2719744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2723840 ++read 2048/2048 bytes at offset 2723840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2727936 ++read 2048/2048 bytes at offset 2727936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2732032 ++read 2048/2048 bytes at offset 2732032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2736128 ++read 2048/2048 bytes at offset 2736128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2740224 ++read 2048/2048 bytes at offset 2740224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2744320 ++read 2048/2048 bytes at offset 2744320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2748416 ++read 2048/2048 bytes at offset 2748416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2752512 ++read 2048/2048 bytes at offset 2752512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2756608 ++read 2048/2048 bytes at offset 2756608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2760704 ++read 2048/2048 bytes at offset 2760704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2764800 ++read 2048/2048 bytes at offset 2764800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2768896 ++read 2048/2048 bytes at offset 2768896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2772992 ++read 2048/2048 bytes at offset 2772992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2777088 ++read 2048/2048 bytes at offset 2777088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2781184 ++read 2048/2048 bytes at offset 2781184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2785280 ++read 2048/2048 bytes at offset 2785280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2789376 ++read 2048/2048 bytes at offset 2789376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2793472 ++read 2048/2048 bytes at offset 2793472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2797568 ++read 2048/2048 bytes at offset 2797568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2801664 ++read 2048/2048 bytes at offset 2801664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2805760 ++read 2048/2048 bytes at offset 2805760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2809856 ++read 2048/2048 bytes at offset 2809856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2813952 ++read 2048/2048 bytes at offset 2813952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2818048 ++read 2048/2048 bytes at offset 2818048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2822144 ++read 2048/2048 bytes at offset 2822144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2826240 ++read 2048/2048 bytes at offset 2826240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2830336 ++read 2048/2048 bytes at offset 2830336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2834432 ++read 2048/2048 bytes at offset 2834432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2838528 ++read 2048/2048 bytes at offset 2838528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2842624 ++read 2048/2048 bytes at offset 2842624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2846720 ++read 2048/2048 bytes at offset 2846720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2850816 ++read 2048/2048 bytes at offset 2850816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2854912 ++read 2048/2048 bytes at offset 2854912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2859008 ++read 2048/2048 bytes at offset 2859008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2863104 ++read 2048/2048 bytes at offset 2863104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2867200 ++read 2048/2048 bytes at offset 2867200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2871296 ++read 2048/2048 bytes at offset 2871296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2875392 ++read 2048/2048 bytes at offset 2875392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2879488 ++read 2048/2048 bytes at offset 2879488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2883584 ++read 2048/2048 bytes at offset 2883584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2887680 ++read 2048/2048 bytes at offset 2887680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2891776 ++read 2048/2048 bytes at offset 2891776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2895872 ++read 2048/2048 bytes at offset 2895872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2899968 ++read 2048/2048 bytes at offset 2899968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2904064 ++read 2048/2048 bytes at offset 2904064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2908160 ++read 2048/2048 bytes at offset 2908160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2912256 ++read 2048/2048 bytes at offset 2912256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2916352 ++read 2048/2048 bytes at offset 2916352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2920448 ++read 2048/2048 bytes at offset 2920448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2924544 ++read 2048/2048 bytes at offset 2924544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2928640 ++read 2048/2048 bytes at offset 2928640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2932736 ++read 2048/2048 bytes at offset 2932736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2936832 ++read 2048/2048 bytes at offset 2936832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2940928 ++read 2048/2048 bytes at offset 2940928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2945024 ++read 2048/2048 bytes at offset 2945024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2949120 ++read 2048/2048 bytes at offset 2949120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2953216 ++read 2048/2048 bytes at offset 2953216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2957312 ++read 2048/2048 bytes at offset 2957312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2961408 ++read 2048/2048 bytes at offset 2961408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2965504 ++read 2048/2048 bytes at offset 2965504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2969600 ++read 2048/2048 bytes at offset 2969600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2973696 ++read 2048/2048 bytes at offset 2973696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2977792 ++read 2048/2048 bytes at offset 2977792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2981888 ++read 2048/2048 bytes at offset 2981888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2985984 ++read 2048/2048 bytes at offset 2985984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2990080 ++read 2048/2048 bytes at offset 2990080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2994176 ++read 2048/2048 bytes at offset 2994176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2998272 ++read 2048/2048 bytes at offset 2998272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3002368 ++read 2048/2048 bytes at offset 3002368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3006464 ++read 2048/2048 bytes at offset 3006464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3010560 ++read 2048/2048 bytes at offset 3010560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3014656 ++read 2048/2048 bytes at offset 3014656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3018752 ++read 2048/2048 bytes at offset 3018752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3022848 ++read 2048/2048 bytes at offset 3022848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3026944 ++read 2048/2048 bytes at offset 3026944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3031040 ++read 2048/2048 bytes at offset 3031040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3035136 ++read 2048/2048 bytes at offset 3035136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3039232 ++read 2048/2048 bytes at offset 3039232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3043328 ++read 2048/2048 bytes at offset 3043328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3047424 ++read 2048/2048 bytes at offset 3047424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3051520 ++read 2048/2048 bytes at offset 3051520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3055616 ++read 2048/2048 bytes at offset 3055616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3059712 ++read 2048/2048 bytes at offset 3059712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3063808 ++read 2048/2048 bytes at offset 3063808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3067904 ++read 2048/2048 bytes at offset 3067904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3072000 ++read 2048/2048 bytes at offset 3072000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3076096 ++read 2048/2048 bytes at offset 3076096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3080192 ++read 2048/2048 bytes at offset 3080192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3084288 ++read 2048/2048 bytes at offset 3084288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3088384 ++read 2048/2048 bytes at offset 3088384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3092480 ++read 2048/2048 bytes at offset 3092480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3096576 ++read 2048/2048 bytes at offset 3096576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3100672 ++read 2048/2048 bytes at offset 3100672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3104768 ++read 2048/2048 bytes at offset 3104768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3108864 ++read 2048/2048 bytes at offset 3108864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3112960 ++read 2048/2048 bytes at offset 3112960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3117056 ++read 2048/2048 bytes at offset 3117056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3121152 ++read 2048/2048 bytes at offset 3121152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3125248 ++read 2048/2048 bytes at offset 3125248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3129344 ++read 2048/2048 bytes at offset 3129344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3133440 ++read 2048/2048 bytes at offset 3133440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3137536 ++read 2048/2048 bytes at offset 3137536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3141632 ++read 2048/2048 bytes at offset 3141632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 2 +-qemu-io> read 2048/2048 bytes at offset 3146752 ++=== IO: pattern 2 ++read 2048/2048 bytes at offset 3146752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3150848 ++read 2048/2048 bytes at offset 3150848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3154944 ++read 2048/2048 bytes at offset 3154944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3159040 ++read 2048/2048 bytes at offset 3159040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3163136 ++read 2048/2048 bytes at offset 3163136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3167232 ++read 2048/2048 bytes at offset 3167232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3171328 ++read 2048/2048 bytes at offset 3171328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3175424 ++read 2048/2048 bytes at offset 3175424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3179520 ++read 2048/2048 bytes at offset 3179520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3183616 ++read 2048/2048 bytes at offset 3183616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3187712 ++read 2048/2048 bytes at offset 3187712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3191808 ++read 2048/2048 bytes at offset 3191808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3195904 ++read 2048/2048 bytes at offset 3195904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3200000 ++read 2048/2048 bytes at offset 3200000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3204096 ++read 2048/2048 bytes at offset 3204096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3208192 ++read 2048/2048 bytes at offset 3208192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3212288 ++read 2048/2048 bytes at offset 3212288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3216384 ++read 2048/2048 bytes at offset 3216384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3220480 ++read 2048/2048 bytes at offset 3220480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3224576 ++read 2048/2048 bytes at offset 3224576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3228672 ++read 2048/2048 bytes at offset 3228672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3232768 ++read 2048/2048 bytes at offset 3232768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3236864 ++read 2048/2048 bytes at offset 3236864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3240960 ++read 2048/2048 bytes at offset 3240960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3245056 ++read 2048/2048 bytes at offset 3245056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3249152 ++read 2048/2048 bytes at offset 3249152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3253248 ++read 2048/2048 bytes at offset 3253248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3257344 ++read 2048/2048 bytes at offset 3257344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3261440 ++read 2048/2048 bytes at offset 3261440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3265536 ++read 2048/2048 bytes at offset 3265536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3269632 ++read 2048/2048 bytes at offset 3269632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3273728 ++read 2048/2048 bytes at offset 3273728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3277824 ++read 2048/2048 bytes at offset 3277824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3281920 ++read 2048/2048 bytes at offset 3281920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3286016 ++read 2048/2048 bytes at offset 3286016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3290112 ++read 2048/2048 bytes at offset 3290112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3294208 ++read 2048/2048 bytes at offset 3294208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3298304 ++read 2048/2048 bytes at offset 3298304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3302400 ++read 2048/2048 bytes at offset 3302400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3306496 ++read 2048/2048 bytes at offset 3306496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3310592 ++read 2048/2048 bytes at offset 3310592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3314688 ++read 2048/2048 bytes at offset 3314688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3318784 ++read 2048/2048 bytes at offset 3318784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3322880 ++read 2048/2048 bytes at offset 3322880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3326976 ++read 2048/2048 bytes at offset 3326976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3331072 ++read 2048/2048 bytes at offset 3331072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3335168 ++read 2048/2048 bytes at offset 3335168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3339264 ++read 2048/2048 bytes at offset 3339264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3343360 ++read 2048/2048 bytes at offset 3343360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3347456 ++read 2048/2048 bytes at offset 3347456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3351552 ++read 2048/2048 bytes at offset 3351552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3355648 ++read 2048/2048 bytes at offset 3355648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3359744 ++read 2048/2048 bytes at offset 3359744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3363840 ++read 2048/2048 bytes at offset 3363840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3367936 ++read 2048/2048 bytes at offset 3367936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3372032 ++read 2048/2048 bytes at offset 3372032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3376128 ++read 2048/2048 bytes at offset 3376128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3380224 ++read 2048/2048 bytes at offset 3380224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3384320 ++read 2048/2048 bytes at offset 3384320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3388416 ++read 2048/2048 bytes at offset 3388416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3392512 ++read 2048/2048 bytes at offset 3392512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3396608 ++read 2048/2048 bytes at offset 3396608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3400704 ++read 2048/2048 bytes at offset 3400704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3404800 ++read 2048/2048 bytes at offset 3404800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3408896 ++read 2048/2048 bytes at offset 3408896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3412992 ++read 2048/2048 bytes at offset 3412992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3417088 ++read 2048/2048 bytes at offset 3417088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3421184 ++read 2048/2048 bytes at offset 3421184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3425280 ++read 2048/2048 bytes at offset 3425280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3429376 ++read 2048/2048 bytes at offset 3429376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3433472 ++read 2048/2048 bytes at offset 3433472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3437568 ++read 2048/2048 bytes at offset 3437568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3441664 ++read 2048/2048 bytes at offset 3441664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3445760 ++read 2048/2048 bytes at offset 3445760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3449856 ++read 2048/2048 bytes at offset 3449856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3453952 ++read 2048/2048 bytes at offset 3453952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3458048 ++read 2048/2048 bytes at offset 3458048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3462144 ++read 2048/2048 bytes at offset 3462144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3466240 ++read 2048/2048 bytes at offset 3466240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3470336 ++read 2048/2048 bytes at offset 3470336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3474432 ++read 2048/2048 bytes at offset 3474432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3478528 ++read 2048/2048 bytes at offset 3478528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3482624 ++read 2048/2048 bytes at offset 3482624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3486720 ++read 2048/2048 bytes at offset 3486720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3490816 ++read 2048/2048 bytes at offset 3490816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3494912 ++read 2048/2048 bytes at offset 3494912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3499008 ++read 2048/2048 bytes at offset 3499008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3503104 ++read 2048/2048 bytes at offset 3503104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3507200 ++read 2048/2048 bytes at offset 3507200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3511296 ++read 2048/2048 bytes at offset 3511296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3515392 ++read 2048/2048 bytes at offset 3515392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3519488 ++read 2048/2048 bytes at offset 3519488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3523584 ++read 2048/2048 bytes at offset 3523584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3527680 ++read 2048/2048 bytes at offset 3527680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3531776 ++read 2048/2048 bytes at offset 3531776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3535872 ++read 2048/2048 bytes at offset 3535872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3539968 ++read 2048/2048 bytes at offset 3539968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3544064 ++read 2048/2048 bytes at offset 3544064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3548160 ++read 2048/2048 bytes at offset 3548160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3552256 ++read 2048/2048 bytes at offset 3552256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3556352 ++read 2048/2048 bytes at offset 3556352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3560448 ++read 2048/2048 bytes at offset 3560448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3564544 ++read 2048/2048 bytes at offset 3564544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3568640 ++read 2048/2048 bytes at offset 3568640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3572736 ++read 2048/2048 bytes at offset 3572736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3576832 ++read 2048/2048 bytes at offset 3576832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3580928 ++read 2048/2048 bytes at offset 3580928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3585024 ++read 2048/2048 bytes at offset 3585024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3589120 ++read 2048/2048 bytes at offset 3589120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3593216 ++read 2048/2048 bytes at offset 3593216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3597312 ++read 2048/2048 bytes at offset 3597312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3601408 ++read 2048/2048 bytes at offset 3601408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3605504 ++read 2048/2048 bytes at offset 3605504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3609600 ++read 2048/2048 bytes at offset 3609600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3613696 ++read 2048/2048 bytes at offset 3613696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3617792 ++read 2048/2048 bytes at offset 3617792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3621888 ++read 2048/2048 bytes at offset 3621888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3625984 ++read 2048/2048 bytes at offset 3625984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3630080 ++read 2048/2048 bytes at offset 3630080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3634176 ++read 2048/2048 bytes at offset 3634176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3638272 ++read 2048/2048 bytes at offset 3638272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3642368 ++read 2048/2048 bytes at offset 3642368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3646464 ++read 2048/2048 bytes at offset 3646464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3650560 ++read 2048/2048 bytes at offset 3650560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3654656 ++read 2048/2048 bytes at offset 3654656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3658752 ++read 2048/2048 bytes at offset 3658752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3662848 ++read 2048/2048 bytes at offset 3662848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3666944 ++read 2048/2048 bytes at offset 3666944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3671040 ++read 2048/2048 bytes at offset 3671040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3675136 ++read 2048/2048 bytes at offset 3675136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3679232 ++read 2048/2048 bytes at offset 3679232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3683328 ++read 2048/2048 bytes at offset 3683328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3687424 ++read 2048/2048 bytes at offset 3687424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3691520 ++read 2048/2048 bytes at offset 3691520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3695616 ++read 2048/2048 bytes at offset 3695616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3699712 ++read 2048/2048 bytes at offset 3699712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3703808 ++read 2048/2048 bytes at offset 3703808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3707904 ++read 2048/2048 bytes at offset 3707904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3712000 ++read 2048/2048 bytes at offset 3712000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3716096 ++read 2048/2048 bytes at offset 3716096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3720192 ++read 2048/2048 bytes at offset 3720192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3724288 ++read 2048/2048 bytes at offset 3724288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3728384 ++read 2048/2048 bytes at offset 3728384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3732480 ++read 2048/2048 bytes at offset 3732480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3736576 ++read 2048/2048 bytes at offset 3736576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3740672 ++read 2048/2048 bytes at offset 3740672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3744768 ++read 2048/2048 bytes at offset 3744768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3748864 ++read 2048/2048 bytes at offset 3748864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3752960 ++read 2048/2048 bytes at offset 3752960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3757056 ++read 2048/2048 bytes at offset 3757056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3761152 ++read 2048/2048 bytes at offset 3761152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3765248 ++read 2048/2048 bytes at offset 3765248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3769344 ++read 2048/2048 bytes at offset 3769344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3773440 ++read 2048/2048 bytes at offset 3773440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3777536 ++read 2048/2048 bytes at offset 3777536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3781632 ++read 2048/2048 bytes at offset 3781632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3785728 ++read 2048/2048 bytes at offset 3785728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3789824 ++read 2048/2048 bytes at offset 3789824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3793920 ++read 2048/2048 bytes at offset 3793920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3798016 ++read 2048/2048 bytes at offset 3798016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3802112 ++read 2048/2048 bytes at offset 3802112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3806208 ++read 2048/2048 bytes at offset 3806208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3810304 ++read 2048/2048 bytes at offset 3810304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3814400 ++read 2048/2048 bytes at offset 3814400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3818496 ++read 2048/2048 bytes at offset 3818496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3822592 ++read 2048/2048 bytes at offset 3822592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3826688 ++read 2048/2048 bytes at offset 3826688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3830784 ++read 2048/2048 bytes at offset 3830784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3834880 ++read 2048/2048 bytes at offset 3834880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3838976 ++read 2048/2048 bytes at offset 3838976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3843072 ++read 2048/2048 bytes at offset 3843072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3847168 ++read 2048/2048 bytes at offset 3847168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3851264 ++read 2048/2048 bytes at offset 3851264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3855360 ++read 2048/2048 bytes at offset 3855360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3859456 ++read 2048/2048 bytes at offset 3859456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3863552 ++read 2048/2048 bytes at offset 3863552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3867648 ++read 2048/2048 bytes at offset 3867648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3871744 ++read 2048/2048 bytes at offset 3871744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3875840 ++read 2048/2048 bytes at offset 3875840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3879936 ++read 2048/2048 bytes at offset 3879936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3884032 ++read 2048/2048 bytes at offset 3884032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3888128 ++read 2048/2048 bytes at offset 3888128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3892224 ++read 2048/2048 bytes at offset 3892224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3896320 ++read 2048/2048 bytes at offset 3896320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3900416 ++read 2048/2048 bytes at offset 3900416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3904512 ++read 2048/2048 bytes at offset 3904512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3908608 ++read 2048/2048 bytes at offset 3908608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3912704 ++read 2048/2048 bytes at offset 3912704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3916800 ++read 2048/2048 bytes at offset 3916800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3920896 ++read 2048/2048 bytes at offset 3920896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3924992 ++read 2048/2048 bytes at offset 3924992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3929088 ++read 2048/2048 bytes at offset 3929088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3933184 ++read 2048/2048 bytes at offset 3933184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3937280 ++read 2048/2048 bytes at offset 3937280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3941376 ++read 2048/2048 bytes at offset 3941376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3945472 ++read 2048/2048 bytes at offset 3945472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3949568 ++read 2048/2048 bytes at offset 3949568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3953664 ++read 2048/2048 bytes at offset 3953664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3957760 ++read 2048/2048 bytes at offset 3957760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3961856 ++read 2048/2048 bytes at offset 3961856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3965952 ++read 2048/2048 bytes at offset 3965952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3970048 ++read 2048/2048 bytes at offset 3970048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3974144 ++read 2048/2048 bytes at offset 3974144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3978240 ++read 2048/2048 bytes at offset 3978240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3982336 ++read 2048/2048 bytes at offset 3982336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3986432 ++read 2048/2048 bytes at offset 3986432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3990528 ++read 2048/2048 bytes at offset 3990528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3994624 ++read 2048/2048 bytes at offset 3994624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3998720 ++read 2048/2048 bytes at offset 3998720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4002816 ++read 2048/2048 bytes at offset 4002816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4006912 ++read 2048/2048 bytes at offset 4006912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4011008 ++read 2048/2048 bytes at offset 4011008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4015104 ++read 2048/2048 bytes at offset 4015104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4019200 ++read 2048/2048 bytes at offset 4019200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4023296 ++read 2048/2048 bytes at offset 4023296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4027392 ++read 2048/2048 bytes at offset 4027392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4031488 ++read 2048/2048 bytes at offset 4031488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4035584 ++read 2048/2048 bytes at offset 4035584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4039680 ++read 2048/2048 bytes at offset 4039680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4043776 ++read 2048/2048 bytes at offset 4043776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4047872 ++read 2048/2048 bytes at offset 4047872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4051968 ++read 2048/2048 bytes at offset 4051968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4056064 ++read 2048/2048 bytes at offset 4056064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4060160 ++read 2048/2048 bytes at offset 4060160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4064256 ++read 2048/2048 bytes at offset 4064256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4068352 ++read 2048/2048 bytes at offset 4068352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4072448 ++read 2048/2048 bytes at offset 4072448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4076544 ++read 2048/2048 bytes at offset 4076544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4080640 ++read 2048/2048 bytes at offset 4080640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4084736 ++read 2048/2048 bytes at offset 4084736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4088832 ++read 2048/2048 bytes at offset 4088832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4092928 ++read 2048/2048 bytes at offset 4092928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4097024 ++read 2048/2048 bytes at offset 4097024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4101120 ++read 2048/2048 bytes at offset 4101120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4105216 ++read 2048/2048 bytes at offset 4105216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4109312 ++read 2048/2048 bytes at offset 4109312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4113408 ++read 2048/2048 bytes at offset 4113408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4117504 ++read 2048/2048 bytes at offset 4117504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4121600 ++read 2048/2048 bytes at offset 4121600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4125696 ++read 2048/2048 bytes at offset 4125696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4129792 ++read 2048/2048 bytes at offset 4129792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4133888 ++read 2048/2048 bytes at offset 4133888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4137984 ++read 2048/2048 bytes at offset 4137984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4142080 ++read 2048/2048 bytes at offset 4142080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4146176 ++read 2048/2048 bytes at offset 4146176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4150272 ++read 2048/2048 bytes at offset 4150272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4154368 ++read 2048/2048 bytes at offset 4154368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4158464 ++read 2048/2048 bytes at offset 4158464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4162560 ++read 2048/2048 bytes at offset 4162560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4166656 ++read 2048/2048 bytes at offset 4166656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4170752 ++read 2048/2048 bytes at offset 4170752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4174848 ++read 2048/2048 bytes at offset 4174848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4178944 ++read 2048/2048 bytes at offset 4178944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4183040 ++read 2048/2048 bytes at offset 4183040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4187136 ++read 2048/2048 bytes at offset 4187136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4191232 ++read 2048/2048 bytes at offset 4191232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 4 +-qemu-io> read 8192/8192 bytes at offset 4196352 ++=== IO: pattern 4 ++read 8192/8192 bytes at offset 4196352 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4208640 ++read 8192/8192 bytes at offset 4208640 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4220928 ++read 8192/8192 bytes at offset 4220928 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4233216 ++read 8192/8192 bytes at offset 4233216 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4245504 ++read 8192/8192 bytes at offset 4245504 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4257792 ++read 8192/8192 bytes at offset 4257792 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4270080 ++read 8192/8192 bytes at offset 4270080 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4282368 ++read 8192/8192 bytes at offset 4282368 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4294656 ++read 8192/8192 bytes at offset 4294656 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4306944 ++read 8192/8192 bytes at offset 4306944 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4319232 ++read 8192/8192 bytes at offset 4319232 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4331520 ++read 8192/8192 bytes at offset 4331520 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4343808 ++read 8192/8192 bytes at offset 4343808 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4356096 ++read 8192/8192 bytes at offset 4356096 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4368384 ++read 8192/8192 bytes at offset 4368384 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4380672 ++read 8192/8192 bytes at offset 4380672 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4392960 ++read 8192/8192 bytes at offset 4392960 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4405248 ++read 8192/8192 bytes at offset 4405248 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4417536 ++read 8192/8192 bytes at offset 4417536 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4429824 ++read 8192/8192 bytes at offset 4429824 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4442112 ++read 8192/8192 bytes at offset 4442112 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4454400 ++read 8192/8192 bytes at offset 4454400 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4466688 ++read 8192/8192 bytes at offset 4466688 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4478976 ++read 8192/8192 bytes at offset 4478976 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4491264 ++read 8192/8192 bytes at offset 4491264 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4503552 ++read 8192/8192 bytes at offset 4503552 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4515840 ++read 8192/8192 bytes at offset 4515840 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4528128 ++read 8192/8192 bytes at offset 4528128 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4540416 ++read 8192/8192 bytes at offset 4540416 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4552704 ++read 8192/8192 bytes at offset 4552704 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4564992 ++read 8192/8192 bytes at offset 4564992 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4577280 ++read 8192/8192 bytes at offset 4577280 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4589568 ++read 8192/8192 bytes at offset 4589568 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4601856 ++read 8192/8192 bytes at offset 4601856 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4614144 ++read 8192/8192 bytes at offset 4614144 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4626432 ++read 8192/8192 bytes at offset 4626432 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4638720 ++read 8192/8192 bytes at offset 4638720 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4651008 ++read 8192/8192 bytes at offset 4651008 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4663296 ++read 8192/8192 bytes at offset 4663296 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4675584 ++read 8192/8192 bytes at offset 4675584 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4687872 ++read 8192/8192 bytes at offset 4687872 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4700160 ++read 8192/8192 bytes at offset 4700160 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4712448 ++read 8192/8192 bytes at offset 4712448 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4724736 ++read 8192/8192 bytes at offset 4724736 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4737024 ++read 8192/8192 bytes at offset 4737024 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4749312 ++read 8192/8192 bytes at offset 4749312 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4761600 ++read 8192/8192 bytes at offset 4761600 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4773888 ++read 8192/8192 bytes at offset 4773888 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4786176 ++read 8192/8192 bytes at offset 4786176 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4798464 ++read 8192/8192 bytes at offset 4798464 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4810752 ++read 8192/8192 bytes at offset 4810752 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4823040 ++read 8192/8192 bytes at offset 4823040 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4835328 ++read 8192/8192 bytes at offset 4835328 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4847616 ++read 8192/8192 bytes at offset 4847616 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4859904 ++read 8192/8192 bytes at offset 4859904 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4872192 ++read 8192/8192 bytes at offset 4872192 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4884480 ++read 8192/8192 bytes at offset 4884480 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4896768 ++read 8192/8192 bytes at offset 4896768 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4909056 ++read 8192/8192 bytes at offset 4909056 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4921344 ++read 8192/8192 bytes at offset 4921344 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4933632 ++read 8192/8192 bytes at offset 4933632 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4945920 ++read 8192/8192 bytes at offset 4945920 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4958208 ++read 8192/8192 bytes at offset 4958208 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4970496 ++read 8192/8192 bytes at offset 4970496 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 244 +-qemu-io> read 12288/12288 bytes at offset 6285312 ++=== IO: pattern 244 ++read 12288/12288 bytes at offset 6285312 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 8384512 ++read 12288/12288 bytes at offset 8384512 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 10483712 ++read 12288/12288 bytes at offset 10483712 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 12582912 ++read 12288/12288 bytes at offset 12582912 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 14682112 ++read 12288/12288 bytes at offset 14682112 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 16781312 ++read 12288/12288 bytes at offset 16781312 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 18880512 ++read 12288/12288 bytes at offset 18880512 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 20979712 ++read 12288/12288 bytes at offset 20979712 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> wrote 4096/4096 bytes at offset 0 ++=== IO: pattern 0 ++wrote 4096/4096 bytes at offset 0 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4096 ++wrote 4096/4096 bytes at offset 4096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8192 ++wrote 4096/4096 bytes at offset 8192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 12288 ++wrote 4096/4096 bytes at offset 12288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 16384 ++wrote 4096/4096 bytes at offset 16384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 20480 ++wrote 4096/4096 bytes at offset 20480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 24576 ++wrote 4096/4096 bytes at offset 24576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 28672 ++wrote 4096/4096 bytes at offset 28672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 32768 ++wrote 4096/4096 bytes at offset 32768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 36864 ++wrote 4096/4096 bytes at offset 36864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 40960 ++wrote 4096/4096 bytes at offset 40960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 45056 ++wrote 4096/4096 bytes at offset 45056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 49152 ++wrote 4096/4096 bytes at offset 49152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 53248 ++wrote 4096/4096 bytes at offset 53248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 57344 ++wrote 4096/4096 bytes at offset 57344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 61440 ++wrote 4096/4096 bytes at offset 61440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 65536 ++wrote 4096/4096 bytes at offset 65536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 69632 ++wrote 4096/4096 bytes at offset 69632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 73728 ++wrote 4096/4096 bytes at offset 73728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 77824 ++wrote 4096/4096 bytes at offset 77824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 81920 ++wrote 4096/4096 bytes at offset 81920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 86016 ++wrote 4096/4096 bytes at offset 86016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 90112 ++wrote 4096/4096 bytes at offset 90112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 94208 ++wrote 4096/4096 bytes at offset 94208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 98304 ++wrote 4096/4096 bytes at offset 98304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 102400 ++wrote 4096/4096 bytes at offset 102400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 106496 ++wrote 4096/4096 bytes at offset 106496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 110592 ++wrote 4096/4096 bytes at offset 110592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 114688 ++wrote 4096/4096 bytes at offset 114688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 118784 ++wrote 4096/4096 bytes at offset 118784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 122880 ++wrote 4096/4096 bytes at offset 122880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 126976 ++wrote 4096/4096 bytes at offset 126976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 131072 ++wrote 4096/4096 bytes at offset 131072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 135168 ++wrote 4096/4096 bytes at offset 135168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 139264 ++wrote 4096/4096 bytes at offset 139264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 143360 ++wrote 4096/4096 bytes at offset 143360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 147456 ++wrote 4096/4096 bytes at offset 147456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 151552 ++wrote 4096/4096 bytes at offset 151552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 155648 ++wrote 4096/4096 bytes at offset 155648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 159744 ++wrote 4096/4096 bytes at offset 159744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 163840 ++wrote 4096/4096 bytes at offset 163840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 167936 ++wrote 4096/4096 bytes at offset 167936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 172032 ++wrote 4096/4096 bytes at offset 172032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 176128 ++wrote 4096/4096 bytes at offset 176128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 180224 ++wrote 4096/4096 bytes at offset 180224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 184320 ++wrote 4096/4096 bytes at offset 184320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 188416 ++wrote 4096/4096 bytes at offset 188416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 192512 ++wrote 4096/4096 bytes at offset 192512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 196608 ++wrote 4096/4096 bytes at offset 196608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 200704 ++wrote 4096/4096 bytes at offset 200704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 204800 ++wrote 4096/4096 bytes at offset 204800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 208896 ++wrote 4096/4096 bytes at offset 208896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 212992 ++wrote 4096/4096 bytes at offset 212992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 217088 ++wrote 4096/4096 bytes at offset 217088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 221184 ++wrote 4096/4096 bytes at offset 221184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 225280 ++wrote 4096/4096 bytes at offset 225280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 229376 ++wrote 4096/4096 bytes at offset 229376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 233472 ++wrote 4096/4096 bytes at offset 233472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 237568 ++wrote 4096/4096 bytes at offset 237568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 241664 ++wrote 4096/4096 bytes at offset 241664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 245760 ++wrote 4096/4096 bytes at offset 245760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 249856 ++wrote 4096/4096 bytes at offset 249856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 253952 ++wrote 4096/4096 bytes at offset 253952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 258048 ++wrote 4096/4096 bytes at offset 258048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 262144 ++wrote 4096/4096 bytes at offset 262144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 266240 ++wrote 4096/4096 bytes at offset 266240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 270336 ++wrote 4096/4096 bytes at offset 270336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 274432 ++wrote 4096/4096 bytes at offset 274432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 278528 ++wrote 4096/4096 bytes at offset 278528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 282624 ++wrote 4096/4096 bytes at offset 282624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 286720 ++wrote 4096/4096 bytes at offset 286720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 290816 ++wrote 4096/4096 bytes at offset 290816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 294912 ++wrote 4096/4096 bytes at offset 294912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 299008 ++wrote 4096/4096 bytes at offset 299008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 303104 ++wrote 4096/4096 bytes at offset 303104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 307200 ++wrote 4096/4096 bytes at offset 307200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 311296 ++wrote 4096/4096 bytes at offset 311296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 315392 ++wrote 4096/4096 bytes at offset 315392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 319488 ++wrote 4096/4096 bytes at offset 319488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 323584 ++wrote 4096/4096 bytes at offset 323584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 327680 ++wrote 4096/4096 bytes at offset 327680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 331776 ++wrote 4096/4096 bytes at offset 331776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 335872 ++wrote 4096/4096 bytes at offset 335872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 339968 ++wrote 4096/4096 bytes at offset 339968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 344064 ++wrote 4096/4096 bytes at offset 344064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 348160 ++wrote 4096/4096 bytes at offset 348160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 352256 ++wrote 4096/4096 bytes at offset 352256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 356352 ++wrote 4096/4096 bytes at offset 356352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 360448 ++wrote 4096/4096 bytes at offset 360448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 364544 ++wrote 4096/4096 bytes at offset 364544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 368640 ++wrote 4096/4096 bytes at offset 368640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 372736 ++wrote 4096/4096 bytes at offset 372736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 376832 ++wrote 4096/4096 bytes at offset 376832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 380928 ++wrote 4096/4096 bytes at offset 380928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 385024 ++wrote 4096/4096 bytes at offset 385024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 389120 ++wrote 4096/4096 bytes at offset 389120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 393216 ++wrote 4096/4096 bytes at offset 393216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 397312 ++wrote 4096/4096 bytes at offset 397312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 401408 ++wrote 4096/4096 bytes at offset 401408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 405504 ++wrote 4096/4096 bytes at offset 405504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 409600 ++wrote 4096/4096 bytes at offset 409600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 413696 ++wrote 4096/4096 bytes at offset 413696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 417792 ++wrote 4096/4096 bytes at offset 417792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 421888 ++wrote 4096/4096 bytes at offset 421888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 425984 ++wrote 4096/4096 bytes at offset 425984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 430080 ++wrote 4096/4096 bytes at offset 430080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 434176 ++wrote 4096/4096 bytes at offset 434176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 438272 ++wrote 4096/4096 bytes at offset 438272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 442368 ++wrote 4096/4096 bytes at offset 442368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 446464 ++wrote 4096/4096 bytes at offset 446464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 450560 ++wrote 4096/4096 bytes at offset 450560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 454656 ++wrote 4096/4096 bytes at offset 454656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 458752 ++wrote 4096/4096 bytes at offset 458752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 462848 ++wrote 4096/4096 bytes at offset 462848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 466944 ++wrote 4096/4096 bytes at offset 466944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 471040 ++wrote 4096/4096 bytes at offset 471040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 475136 ++wrote 4096/4096 bytes at offset 475136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 479232 ++wrote 4096/4096 bytes at offset 479232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 483328 ++wrote 4096/4096 bytes at offset 483328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 487424 ++wrote 4096/4096 bytes at offset 487424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 491520 ++wrote 4096/4096 bytes at offset 491520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 495616 ++wrote 4096/4096 bytes at offset 495616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 499712 ++wrote 4096/4096 bytes at offset 499712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 503808 ++wrote 4096/4096 bytes at offset 503808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 507904 ++wrote 4096/4096 bytes at offset 507904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 512000 ++wrote 4096/4096 bytes at offset 512000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 516096 ++wrote 4096/4096 bytes at offset 516096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 520192 ++wrote 4096/4096 bytes at offset 520192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 524288 ++wrote 4096/4096 bytes at offset 524288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 528384 ++wrote 4096/4096 bytes at offset 528384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 532480 ++wrote 4096/4096 bytes at offset 532480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 536576 ++wrote 4096/4096 bytes at offset 536576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 540672 ++wrote 4096/4096 bytes at offset 540672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 544768 ++wrote 4096/4096 bytes at offset 544768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 548864 ++wrote 4096/4096 bytes at offset 548864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 552960 ++wrote 4096/4096 bytes at offset 552960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 557056 ++wrote 4096/4096 bytes at offset 557056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 561152 ++wrote 4096/4096 bytes at offset 561152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 565248 ++wrote 4096/4096 bytes at offset 565248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 569344 ++wrote 4096/4096 bytes at offset 569344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 573440 ++wrote 4096/4096 bytes at offset 573440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 577536 ++wrote 4096/4096 bytes at offset 577536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 581632 ++wrote 4096/4096 bytes at offset 581632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 585728 ++wrote 4096/4096 bytes at offset 585728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 589824 ++wrote 4096/4096 bytes at offset 589824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 593920 ++wrote 4096/4096 bytes at offset 593920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 598016 ++wrote 4096/4096 bytes at offset 598016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 602112 ++wrote 4096/4096 bytes at offset 602112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 606208 ++wrote 4096/4096 bytes at offset 606208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 610304 ++wrote 4096/4096 bytes at offset 610304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 614400 ++wrote 4096/4096 bytes at offset 614400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 618496 ++wrote 4096/4096 bytes at offset 618496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 622592 ++wrote 4096/4096 bytes at offset 622592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 626688 ++wrote 4096/4096 bytes at offset 626688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 630784 ++wrote 4096/4096 bytes at offset 630784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 634880 ++wrote 4096/4096 bytes at offset 634880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 638976 ++wrote 4096/4096 bytes at offset 638976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 643072 ++wrote 4096/4096 bytes at offset 643072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 647168 ++wrote 4096/4096 bytes at offset 647168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 651264 ++wrote 4096/4096 bytes at offset 651264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 655360 ++wrote 4096/4096 bytes at offset 655360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 659456 ++wrote 4096/4096 bytes at offset 659456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 663552 ++wrote 4096/4096 bytes at offset 663552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 667648 ++wrote 4096/4096 bytes at offset 667648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 671744 ++wrote 4096/4096 bytes at offset 671744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 675840 ++wrote 4096/4096 bytes at offset 675840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 679936 ++wrote 4096/4096 bytes at offset 679936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 684032 ++wrote 4096/4096 bytes at offset 684032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 688128 ++wrote 4096/4096 bytes at offset 688128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 692224 ++wrote 4096/4096 bytes at offset 692224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 696320 ++wrote 4096/4096 bytes at offset 696320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 700416 ++wrote 4096/4096 bytes at offset 700416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 704512 ++wrote 4096/4096 bytes at offset 704512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 708608 ++wrote 4096/4096 bytes at offset 708608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 712704 ++wrote 4096/4096 bytes at offset 712704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 716800 ++wrote 4096/4096 bytes at offset 716800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 720896 ++wrote 4096/4096 bytes at offset 720896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 724992 ++wrote 4096/4096 bytes at offset 724992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 729088 ++wrote 4096/4096 bytes at offset 729088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 733184 ++wrote 4096/4096 bytes at offset 733184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 737280 ++wrote 4096/4096 bytes at offset 737280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 741376 ++wrote 4096/4096 bytes at offset 741376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 745472 ++wrote 4096/4096 bytes at offset 745472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 749568 ++wrote 4096/4096 bytes at offset 749568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 753664 ++wrote 4096/4096 bytes at offset 753664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 757760 ++wrote 4096/4096 bytes at offset 757760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 761856 ++wrote 4096/4096 bytes at offset 761856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 765952 ++wrote 4096/4096 bytes at offset 765952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 770048 ++wrote 4096/4096 bytes at offset 770048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 774144 ++wrote 4096/4096 bytes at offset 774144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 778240 ++wrote 4096/4096 bytes at offset 778240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 782336 ++wrote 4096/4096 bytes at offset 782336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 786432 ++wrote 4096/4096 bytes at offset 786432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 790528 ++wrote 4096/4096 bytes at offset 790528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 794624 ++wrote 4096/4096 bytes at offset 794624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 798720 ++wrote 4096/4096 bytes at offset 798720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 802816 ++wrote 4096/4096 bytes at offset 802816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 806912 ++wrote 4096/4096 bytes at offset 806912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 811008 ++wrote 4096/4096 bytes at offset 811008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 815104 ++wrote 4096/4096 bytes at offset 815104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 819200 ++wrote 4096/4096 bytes at offset 819200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 823296 ++wrote 4096/4096 bytes at offset 823296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 827392 ++wrote 4096/4096 bytes at offset 827392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 831488 ++wrote 4096/4096 bytes at offset 831488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 835584 ++wrote 4096/4096 bytes at offset 835584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 839680 ++wrote 4096/4096 bytes at offset 839680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 843776 ++wrote 4096/4096 bytes at offset 843776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 847872 ++wrote 4096/4096 bytes at offset 847872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 851968 ++wrote 4096/4096 bytes at offset 851968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 856064 ++wrote 4096/4096 bytes at offset 856064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 860160 ++wrote 4096/4096 bytes at offset 860160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 864256 ++wrote 4096/4096 bytes at offset 864256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 868352 ++wrote 4096/4096 bytes at offset 868352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 872448 ++wrote 4096/4096 bytes at offset 872448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 876544 ++wrote 4096/4096 bytes at offset 876544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 880640 ++wrote 4096/4096 bytes at offset 880640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 884736 ++wrote 4096/4096 bytes at offset 884736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 888832 ++wrote 4096/4096 bytes at offset 888832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 892928 ++wrote 4096/4096 bytes at offset 892928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 897024 ++wrote 4096/4096 bytes at offset 897024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 901120 ++wrote 4096/4096 bytes at offset 901120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 905216 ++wrote 4096/4096 bytes at offset 905216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 909312 ++wrote 4096/4096 bytes at offset 909312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 913408 ++wrote 4096/4096 bytes at offset 913408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 917504 ++wrote 4096/4096 bytes at offset 917504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 921600 ++wrote 4096/4096 bytes at offset 921600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 925696 ++wrote 4096/4096 bytes at offset 925696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 929792 ++wrote 4096/4096 bytes at offset 929792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 933888 ++wrote 4096/4096 bytes at offset 933888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 937984 ++wrote 4096/4096 bytes at offset 937984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 942080 ++wrote 4096/4096 bytes at offset 942080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 946176 ++wrote 4096/4096 bytes at offset 946176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 950272 ++wrote 4096/4096 bytes at offset 950272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 954368 ++wrote 4096/4096 bytes at offset 954368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 958464 ++wrote 4096/4096 bytes at offset 958464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 962560 ++wrote 4096/4096 bytes at offset 962560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 966656 ++wrote 4096/4096 bytes at offset 966656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 970752 ++wrote 4096/4096 bytes at offset 970752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 974848 ++wrote 4096/4096 bytes at offset 974848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 978944 ++wrote 4096/4096 bytes at offset 978944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 983040 ++wrote 4096/4096 bytes at offset 983040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 987136 ++wrote 4096/4096 bytes at offset 987136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 991232 ++wrote 4096/4096 bytes at offset 991232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 995328 ++wrote 4096/4096 bytes at offset 995328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 999424 ++wrote 4096/4096 bytes at offset 999424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1003520 ++wrote 4096/4096 bytes at offset 1003520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1007616 ++wrote 4096/4096 bytes at offset 1007616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1011712 ++wrote 4096/4096 bytes at offset 1011712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1015808 ++wrote 4096/4096 bytes at offset 1015808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1019904 ++wrote 4096/4096 bytes at offset 1019904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1024000 ++wrote 4096/4096 bytes at offset 1024000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1028096 ++wrote 4096/4096 bytes at offset 1028096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1032192 ++wrote 4096/4096 bytes at offset 1032192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1036288 ++wrote 4096/4096 bytes at offset 1036288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1040384 ++wrote 4096/4096 bytes at offset 1040384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1044480 ++wrote 4096/4096 bytes at offset 1044480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 4 +-qemu-io> wrote 2048/2048 bytes at offset 1050624 ++=== IO: pattern 4 ++wrote 2048/2048 bytes at offset 1050624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1054720 ++wrote 2048/2048 bytes at offset 1054720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1058816 ++wrote 2048/2048 bytes at offset 1058816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1062912 ++wrote 2048/2048 bytes at offset 1062912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1067008 ++wrote 2048/2048 bytes at offset 1067008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1071104 ++wrote 2048/2048 bytes at offset 1071104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1075200 ++wrote 2048/2048 bytes at offset 1075200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1079296 ++wrote 2048/2048 bytes at offset 1079296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1083392 ++wrote 2048/2048 bytes at offset 1083392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1087488 ++wrote 2048/2048 bytes at offset 1087488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1091584 ++wrote 2048/2048 bytes at offset 1091584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1095680 ++wrote 2048/2048 bytes at offset 1095680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1099776 ++wrote 2048/2048 bytes at offset 1099776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1103872 ++wrote 2048/2048 bytes at offset 1103872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1107968 ++wrote 2048/2048 bytes at offset 1107968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1112064 ++wrote 2048/2048 bytes at offset 1112064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1116160 ++wrote 2048/2048 bytes at offset 1116160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1120256 ++wrote 2048/2048 bytes at offset 1120256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1124352 ++wrote 2048/2048 bytes at offset 1124352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1128448 ++wrote 2048/2048 bytes at offset 1128448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1132544 ++wrote 2048/2048 bytes at offset 1132544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1136640 ++wrote 2048/2048 bytes at offset 1136640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1140736 ++wrote 2048/2048 bytes at offset 1140736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1144832 ++wrote 2048/2048 bytes at offset 1144832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1148928 ++wrote 2048/2048 bytes at offset 1148928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1153024 ++wrote 2048/2048 bytes at offset 1153024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1157120 ++wrote 2048/2048 bytes at offset 1157120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1161216 ++wrote 2048/2048 bytes at offset 1161216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1165312 ++wrote 2048/2048 bytes at offset 1165312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1169408 ++wrote 2048/2048 bytes at offset 1169408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1173504 ++wrote 2048/2048 bytes at offset 1173504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1177600 ++wrote 2048/2048 bytes at offset 1177600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1181696 ++wrote 2048/2048 bytes at offset 1181696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1185792 ++wrote 2048/2048 bytes at offset 1185792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1189888 ++wrote 2048/2048 bytes at offset 1189888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1193984 ++wrote 2048/2048 bytes at offset 1193984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1198080 ++wrote 2048/2048 bytes at offset 1198080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1202176 ++wrote 2048/2048 bytes at offset 1202176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1206272 ++wrote 2048/2048 bytes at offset 1206272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1210368 ++wrote 2048/2048 bytes at offset 1210368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1214464 ++wrote 2048/2048 bytes at offset 1214464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1218560 ++wrote 2048/2048 bytes at offset 1218560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1222656 ++wrote 2048/2048 bytes at offset 1222656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1226752 ++wrote 2048/2048 bytes at offset 1226752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1230848 ++wrote 2048/2048 bytes at offset 1230848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1234944 ++wrote 2048/2048 bytes at offset 1234944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1239040 ++wrote 2048/2048 bytes at offset 1239040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1243136 ++wrote 2048/2048 bytes at offset 1243136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1247232 ++wrote 2048/2048 bytes at offset 1247232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1251328 ++wrote 2048/2048 bytes at offset 1251328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1255424 ++wrote 2048/2048 bytes at offset 1255424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1259520 ++wrote 2048/2048 bytes at offset 1259520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1263616 ++wrote 2048/2048 bytes at offset 1263616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1267712 ++wrote 2048/2048 bytes at offset 1267712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1271808 ++wrote 2048/2048 bytes at offset 1271808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1275904 ++wrote 2048/2048 bytes at offset 1275904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1280000 ++wrote 2048/2048 bytes at offset 1280000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1284096 ++wrote 2048/2048 bytes at offset 1284096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1288192 ++wrote 2048/2048 bytes at offset 1288192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1292288 ++wrote 2048/2048 bytes at offset 1292288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1296384 ++wrote 2048/2048 bytes at offset 1296384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1300480 ++wrote 2048/2048 bytes at offset 1300480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1304576 ++wrote 2048/2048 bytes at offset 1304576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1308672 ++wrote 2048/2048 bytes at offset 1308672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1312768 ++wrote 2048/2048 bytes at offset 1312768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1316864 ++wrote 2048/2048 bytes at offset 1316864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1320960 ++wrote 2048/2048 bytes at offset 1320960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1325056 ++wrote 2048/2048 bytes at offset 1325056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1329152 ++wrote 2048/2048 bytes at offset 1329152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1333248 ++wrote 2048/2048 bytes at offset 1333248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1337344 ++wrote 2048/2048 bytes at offset 1337344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1341440 ++wrote 2048/2048 bytes at offset 1341440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1345536 ++wrote 2048/2048 bytes at offset 1345536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1349632 ++wrote 2048/2048 bytes at offset 1349632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1353728 ++wrote 2048/2048 bytes at offset 1353728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1357824 ++wrote 2048/2048 bytes at offset 1357824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1361920 ++wrote 2048/2048 bytes at offset 1361920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1366016 ++wrote 2048/2048 bytes at offset 1366016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1370112 ++wrote 2048/2048 bytes at offset 1370112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1374208 ++wrote 2048/2048 bytes at offset 1374208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1378304 ++wrote 2048/2048 bytes at offset 1378304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1382400 ++wrote 2048/2048 bytes at offset 1382400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1386496 ++wrote 2048/2048 bytes at offset 1386496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1390592 ++wrote 2048/2048 bytes at offset 1390592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1394688 ++wrote 2048/2048 bytes at offset 1394688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1398784 ++wrote 2048/2048 bytes at offset 1398784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1402880 ++wrote 2048/2048 bytes at offset 1402880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1406976 ++wrote 2048/2048 bytes at offset 1406976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1411072 ++wrote 2048/2048 bytes at offset 1411072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1415168 ++wrote 2048/2048 bytes at offset 1415168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1419264 ++wrote 2048/2048 bytes at offset 1419264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1423360 ++wrote 2048/2048 bytes at offset 1423360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1427456 ++wrote 2048/2048 bytes at offset 1427456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1431552 ++wrote 2048/2048 bytes at offset 1431552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1435648 ++wrote 2048/2048 bytes at offset 1435648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1439744 ++wrote 2048/2048 bytes at offset 1439744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1443840 ++wrote 2048/2048 bytes at offset 1443840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1447936 ++wrote 2048/2048 bytes at offset 1447936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1452032 ++wrote 2048/2048 bytes at offset 1452032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1456128 ++wrote 2048/2048 bytes at offset 1456128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1460224 ++wrote 2048/2048 bytes at offset 1460224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1464320 ++wrote 2048/2048 bytes at offset 1464320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1468416 ++wrote 2048/2048 bytes at offset 1468416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1472512 ++wrote 2048/2048 bytes at offset 1472512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1476608 ++wrote 2048/2048 bytes at offset 1476608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1480704 ++wrote 2048/2048 bytes at offset 1480704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1484800 ++wrote 2048/2048 bytes at offset 1484800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1488896 ++wrote 2048/2048 bytes at offset 1488896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1492992 ++wrote 2048/2048 bytes at offset 1492992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1497088 ++wrote 2048/2048 bytes at offset 1497088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1501184 ++wrote 2048/2048 bytes at offset 1501184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1505280 ++wrote 2048/2048 bytes at offset 1505280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1509376 ++wrote 2048/2048 bytes at offset 1509376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1513472 ++wrote 2048/2048 bytes at offset 1513472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1517568 ++wrote 2048/2048 bytes at offset 1517568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1521664 ++wrote 2048/2048 bytes at offset 1521664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1525760 ++wrote 2048/2048 bytes at offset 1525760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1529856 ++wrote 2048/2048 bytes at offset 1529856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1533952 ++wrote 2048/2048 bytes at offset 1533952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1538048 ++wrote 2048/2048 bytes at offset 1538048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1542144 ++wrote 2048/2048 bytes at offset 1542144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1546240 ++wrote 2048/2048 bytes at offset 1546240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1550336 ++wrote 2048/2048 bytes at offset 1550336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1554432 ++wrote 2048/2048 bytes at offset 1554432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1558528 ++wrote 2048/2048 bytes at offset 1558528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1562624 ++wrote 2048/2048 bytes at offset 1562624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1566720 ++wrote 2048/2048 bytes at offset 1566720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1570816 ++wrote 2048/2048 bytes at offset 1570816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1574912 ++wrote 2048/2048 bytes at offset 1574912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1579008 ++wrote 2048/2048 bytes at offset 1579008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1583104 ++wrote 2048/2048 bytes at offset 1583104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1587200 ++wrote 2048/2048 bytes at offset 1587200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1591296 ++wrote 2048/2048 bytes at offset 1591296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1595392 ++wrote 2048/2048 bytes at offset 1595392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1599488 ++wrote 2048/2048 bytes at offset 1599488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1603584 ++wrote 2048/2048 bytes at offset 1603584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1607680 ++wrote 2048/2048 bytes at offset 1607680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1611776 ++wrote 2048/2048 bytes at offset 1611776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1615872 ++wrote 2048/2048 bytes at offset 1615872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1619968 ++wrote 2048/2048 bytes at offset 1619968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1624064 ++wrote 2048/2048 bytes at offset 1624064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1628160 ++wrote 2048/2048 bytes at offset 1628160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1632256 ++wrote 2048/2048 bytes at offset 1632256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1636352 ++wrote 2048/2048 bytes at offset 1636352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1640448 ++wrote 2048/2048 bytes at offset 1640448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1644544 ++wrote 2048/2048 bytes at offset 1644544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1648640 ++wrote 2048/2048 bytes at offset 1648640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1652736 ++wrote 2048/2048 bytes at offset 1652736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1656832 ++wrote 2048/2048 bytes at offset 1656832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1660928 ++wrote 2048/2048 bytes at offset 1660928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1665024 ++wrote 2048/2048 bytes at offset 1665024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1669120 ++wrote 2048/2048 bytes at offset 1669120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1673216 ++wrote 2048/2048 bytes at offset 1673216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1677312 ++wrote 2048/2048 bytes at offset 1677312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1681408 ++wrote 2048/2048 bytes at offset 1681408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1685504 ++wrote 2048/2048 bytes at offset 1685504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1689600 ++wrote 2048/2048 bytes at offset 1689600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1693696 ++wrote 2048/2048 bytes at offset 1693696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1697792 ++wrote 2048/2048 bytes at offset 1697792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1701888 ++wrote 2048/2048 bytes at offset 1701888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1705984 ++wrote 2048/2048 bytes at offset 1705984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1710080 ++wrote 2048/2048 bytes at offset 1710080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1714176 ++wrote 2048/2048 bytes at offset 1714176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1718272 ++wrote 2048/2048 bytes at offset 1718272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1722368 ++wrote 2048/2048 bytes at offset 1722368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1726464 ++wrote 2048/2048 bytes at offset 1726464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1730560 ++wrote 2048/2048 bytes at offset 1730560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1734656 ++wrote 2048/2048 bytes at offset 1734656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1738752 ++wrote 2048/2048 bytes at offset 1738752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1742848 ++wrote 2048/2048 bytes at offset 1742848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1746944 ++wrote 2048/2048 bytes at offset 1746944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1751040 ++wrote 2048/2048 bytes at offset 1751040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1755136 ++wrote 2048/2048 bytes at offset 1755136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1759232 ++wrote 2048/2048 bytes at offset 1759232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1763328 ++wrote 2048/2048 bytes at offset 1763328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1767424 ++wrote 2048/2048 bytes at offset 1767424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1771520 ++wrote 2048/2048 bytes at offset 1771520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1775616 ++wrote 2048/2048 bytes at offset 1775616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1779712 ++wrote 2048/2048 bytes at offset 1779712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1783808 ++wrote 2048/2048 bytes at offset 1783808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1787904 ++wrote 2048/2048 bytes at offset 1787904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1792000 ++wrote 2048/2048 bytes at offset 1792000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1796096 ++wrote 2048/2048 bytes at offset 1796096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1800192 ++wrote 2048/2048 bytes at offset 1800192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1804288 ++wrote 2048/2048 bytes at offset 1804288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1808384 ++wrote 2048/2048 bytes at offset 1808384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1812480 ++wrote 2048/2048 bytes at offset 1812480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1816576 ++wrote 2048/2048 bytes at offset 1816576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1820672 ++wrote 2048/2048 bytes at offset 1820672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1824768 ++wrote 2048/2048 bytes at offset 1824768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1828864 ++wrote 2048/2048 bytes at offset 1828864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1832960 ++wrote 2048/2048 bytes at offset 1832960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1837056 ++wrote 2048/2048 bytes at offset 1837056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1841152 ++wrote 2048/2048 bytes at offset 1841152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1845248 ++wrote 2048/2048 bytes at offset 1845248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1849344 ++wrote 2048/2048 bytes at offset 1849344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1853440 ++wrote 2048/2048 bytes at offset 1853440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1857536 ++wrote 2048/2048 bytes at offset 1857536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1861632 ++wrote 2048/2048 bytes at offset 1861632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1865728 ++wrote 2048/2048 bytes at offset 1865728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1869824 ++wrote 2048/2048 bytes at offset 1869824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1873920 ++wrote 2048/2048 bytes at offset 1873920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1878016 ++wrote 2048/2048 bytes at offset 1878016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1882112 ++wrote 2048/2048 bytes at offset 1882112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1886208 ++wrote 2048/2048 bytes at offset 1886208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1890304 ++wrote 2048/2048 bytes at offset 1890304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1894400 ++wrote 2048/2048 bytes at offset 1894400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1898496 ++wrote 2048/2048 bytes at offset 1898496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1902592 ++wrote 2048/2048 bytes at offset 1902592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1906688 ++wrote 2048/2048 bytes at offset 1906688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1910784 ++wrote 2048/2048 bytes at offset 1910784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1914880 ++wrote 2048/2048 bytes at offset 1914880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1918976 ++wrote 2048/2048 bytes at offset 1918976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1923072 ++wrote 2048/2048 bytes at offset 1923072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1927168 ++wrote 2048/2048 bytes at offset 1927168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1931264 ++wrote 2048/2048 bytes at offset 1931264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1935360 ++wrote 2048/2048 bytes at offset 1935360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1939456 ++wrote 2048/2048 bytes at offset 1939456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1943552 ++wrote 2048/2048 bytes at offset 1943552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1947648 ++wrote 2048/2048 bytes at offset 1947648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1951744 ++wrote 2048/2048 bytes at offset 1951744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1955840 ++wrote 2048/2048 bytes at offset 1955840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1959936 ++wrote 2048/2048 bytes at offset 1959936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1964032 ++wrote 2048/2048 bytes at offset 1964032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1968128 ++wrote 2048/2048 bytes at offset 1968128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1972224 ++wrote 2048/2048 bytes at offset 1972224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1976320 ++wrote 2048/2048 bytes at offset 1976320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1980416 ++wrote 2048/2048 bytes at offset 1980416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1984512 ++wrote 2048/2048 bytes at offset 1984512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1988608 ++wrote 2048/2048 bytes at offset 1988608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1992704 ++wrote 2048/2048 bytes at offset 1992704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1996800 ++wrote 2048/2048 bytes at offset 1996800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2000896 ++wrote 2048/2048 bytes at offset 2000896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2004992 ++wrote 2048/2048 bytes at offset 2004992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2009088 ++wrote 2048/2048 bytes at offset 2009088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2013184 ++wrote 2048/2048 bytes at offset 2013184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2017280 ++wrote 2048/2048 bytes at offset 2017280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2021376 ++wrote 2048/2048 bytes at offset 2021376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2025472 ++wrote 2048/2048 bytes at offset 2025472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2029568 ++wrote 2048/2048 bytes at offset 2029568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2033664 ++wrote 2048/2048 bytes at offset 2033664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2037760 ++wrote 2048/2048 bytes at offset 2037760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2041856 ++wrote 2048/2048 bytes at offset 2041856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2045952 ++wrote 2048/2048 bytes at offset 2045952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2050048 ++wrote 2048/2048 bytes at offset 2050048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2054144 ++wrote 2048/2048 bytes at offset 2054144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2058240 ++wrote 2048/2048 bytes at offset 2058240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2062336 ++wrote 2048/2048 bytes at offset 2062336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2066432 ++wrote 2048/2048 bytes at offset 2066432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2070528 ++wrote 2048/2048 bytes at offset 2070528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2074624 ++wrote 2048/2048 bytes at offset 2074624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2078720 ++wrote 2048/2048 bytes at offset 2078720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2082816 ++wrote 2048/2048 bytes at offset 2082816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2086912 ++wrote 2048/2048 bytes at offset 2086912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2091008 ++wrote 2048/2048 bytes at offset 2091008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2095104 ++wrote 2048/2048 bytes at offset 2095104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> wrote 2048/2048 bytes at offset 2097152 ++=== IO: pattern 0 ++wrote 2048/2048 bytes at offset 2097152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2101248 ++wrote 2048/2048 bytes at offset 2101248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2105344 ++wrote 2048/2048 bytes at offset 2105344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2109440 ++wrote 2048/2048 bytes at offset 2109440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2113536 ++wrote 2048/2048 bytes at offset 2113536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2117632 ++wrote 2048/2048 bytes at offset 2117632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2121728 ++wrote 2048/2048 bytes at offset 2121728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2125824 ++wrote 2048/2048 bytes at offset 2125824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2129920 ++wrote 2048/2048 bytes at offset 2129920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2134016 ++wrote 2048/2048 bytes at offset 2134016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2138112 ++wrote 2048/2048 bytes at offset 2138112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2142208 ++wrote 2048/2048 bytes at offset 2142208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2146304 ++wrote 2048/2048 bytes at offset 2146304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2150400 ++wrote 2048/2048 bytes at offset 2150400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2154496 ++wrote 2048/2048 bytes at offset 2154496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2158592 ++wrote 2048/2048 bytes at offset 2158592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2162688 ++wrote 2048/2048 bytes at offset 2162688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2166784 ++wrote 2048/2048 bytes at offset 2166784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2170880 ++wrote 2048/2048 bytes at offset 2170880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2174976 ++wrote 2048/2048 bytes at offset 2174976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2179072 ++wrote 2048/2048 bytes at offset 2179072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2183168 ++wrote 2048/2048 bytes at offset 2183168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2187264 ++wrote 2048/2048 bytes at offset 2187264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2191360 ++wrote 2048/2048 bytes at offset 2191360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2195456 ++wrote 2048/2048 bytes at offset 2195456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2199552 ++wrote 2048/2048 bytes at offset 2199552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2203648 ++wrote 2048/2048 bytes at offset 2203648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2207744 ++wrote 2048/2048 bytes at offset 2207744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2211840 ++wrote 2048/2048 bytes at offset 2211840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2215936 ++wrote 2048/2048 bytes at offset 2215936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2220032 ++wrote 2048/2048 bytes at offset 2220032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2224128 ++wrote 2048/2048 bytes at offset 2224128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2228224 ++wrote 2048/2048 bytes at offset 2228224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2232320 ++wrote 2048/2048 bytes at offset 2232320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2236416 ++wrote 2048/2048 bytes at offset 2236416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2240512 ++wrote 2048/2048 bytes at offset 2240512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2244608 ++wrote 2048/2048 bytes at offset 2244608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2248704 ++wrote 2048/2048 bytes at offset 2248704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2252800 ++wrote 2048/2048 bytes at offset 2252800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2256896 ++wrote 2048/2048 bytes at offset 2256896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2260992 ++wrote 2048/2048 bytes at offset 2260992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2265088 ++wrote 2048/2048 bytes at offset 2265088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2269184 ++wrote 2048/2048 bytes at offset 2269184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2273280 ++wrote 2048/2048 bytes at offset 2273280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2277376 ++wrote 2048/2048 bytes at offset 2277376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2281472 ++wrote 2048/2048 bytes at offset 2281472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2285568 ++wrote 2048/2048 bytes at offset 2285568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2289664 ++wrote 2048/2048 bytes at offset 2289664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2293760 ++wrote 2048/2048 bytes at offset 2293760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2297856 ++wrote 2048/2048 bytes at offset 2297856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2301952 ++wrote 2048/2048 bytes at offset 2301952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2306048 ++wrote 2048/2048 bytes at offset 2306048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2310144 ++wrote 2048/2048 bytes at offset 2310144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2314240 ++wrote 2048/2048 bytes at offset 2314240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2318336 ++wrote 2048/2048 bytes at offset 2318336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2322432 ++wrote 2048/2048 bytes at offset 2322432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2326528 ++wrote 2048/2048 bytes at offset 2326528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2330624 ++wrote 2048/2048 bytes at offset 2330624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2334720 ++wrote 2048/2048 bytes at offset 2334720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2338816 ++wrote 2048/2048 bytes at offset 2338816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2342912 ++wrote 2048/2048 bytes at offset 2342912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2347008 ++wrote 2048/2048 bytes at offset 2347008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2351104 ++wrote 2048/2048 bytes at offset 2351104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2355200 ++wrote 2048/2048 bytes at offset 2355200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2359296 ++wrote 2048/2048 bytes at offset 2359296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2363392 ++wrote 2048/2048 bytes at offset 2363392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2367488 ++wrote 2048/2048 bytes at offset 2367488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2371584 ++wrote 2048/2048 bytes at offset 2371584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2375680 ++wrote 2048/2048 bytes at offset 2375680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2379776 ++wrote 2048/2048 bytes at offset 2379776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2383872 ++wrote 2048/2048 bytes at offset 2383872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2387968 ++wrote 2048/2048 bytes at offset 2387968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2392064 ++wrote 2048/2048 bytes at offset 2392064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2396160 ++wrote 2048/2048 bytes at offset 2396160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2400256 ++wrote 2048/2048 bytes at offset 2400256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2404352 ++wrote 2048/2048 bytes at offset 2404352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2408448 ++wrote 2048/2048 bytes at offset 2408448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2412544 ++wrote 2048/2048 bytes at offset 2412544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2416640 ++wrote 2048/2048 bytes at offset 2416640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2420736 ++wrote 2048/2048 bytes at offset 2420736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2424832 ++wrote 2048/2048 bytes at offset 2424832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2428928 ++wrote 2048/2048 bytes at offset 2428928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2433024 ++wrote 2048/2048 bytes at offset 2433024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2437120 ++wrote 2048/2048 bytes at offset 2437120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2441216 ++wrote 2048/2048 bytes at offset 2441216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2445312 ++wrote 2048/2048 bytes at offset 2445312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2449408 ++wrote 2048/2048 bytes at offset 2449408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2453504 ++wrote 2048/2048 bytes at offset 2453504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2457600 ++wrote 2048/2048 bytes at offset 2457600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2461696 ++wrote 2048/2048 bytes at offset 2461696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2465792 ++wrote 2048/2048 bytes at offset 2465792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2469888 ++wrote 2048/2048 bytes at offset 2469888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2473984 ++wrote 2048/2048 bytes at offset 2473984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2478080 ++wrote 2048/2048 bytes at offset 2478080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2482176 ++wrote 2048/2048 bytes at offset 2482176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2486272 ++wrote 2048/2048 bytes at offset 2486272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2490368 ++wrote 2048/2048 bytes at offset 2490368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2494464 ++wrote 2048/2048 bytes at offset 2494464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2498560 ++wrote 2048/2048 bytes at offset 2498560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2502656 ++wrote 2048/2048 bytes at offset 2502656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2506752 ++wrote 2048/2048 bytes at offset 2506752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2510848 ++wrote 2048/2048 bytes at offset 2510848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2514944 ++wrote 2048/2048 bytes at offset 2514944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2519040 ++wrote 2048/2048 bytes at offset 2519040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2523136 ++wrote 2048/2048 bytes at offset 2523136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2527232 ++wrote 2048/2048 bytes at offset 2527232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2531328 ++wrote 2048/2048 bytes at offset 2531328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2535424 ++wrote 2048/2048 bytes at offset 2535424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2539520 ++wrote 2048/2048 bytes at offset 2539520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2543616 ++wrote 2048/2048 bytes at offset 2543616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2547712 ++wrote 2048/2048 bytes at offset 2547712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2551808 ++wrote 2048/2048 bytes at offset 2551808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2555904 ++wrote 2048/2048 bytes at offset 2555904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2560000 ++wrote 2048/2048 bytes at offset 2560000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2564096 ++wrote 2048/2048 bytes at offset 2564096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2568192 ++wrote 2048/2048 bytes at offset 2568192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2572288 ++wrote 2048/2048 bytes at offset 2572288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2576384 ++wrote 2048/2048 bytes at offset 2576384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2580480 ++wrote 2048/2048 bytes at offset 2580480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2584576 ++wrote 2048/2048 bytes at offset 2584576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2588672 ++wrote 2048/2048 bytes at offset 2588672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2592768 ++wrote 2048/2048 bytes at offset 2592768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2596864 ++wrote 2048/2048 bytes at offset 2596864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2600960 ++wrote 2048/2048 bytes at offset 2600960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2605056 ++wrote 2048/2048 bytes at offset 2605056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2609152 ++wrote 2048/2048 bytes at offset 2609152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2613248 ++wrote 2048/2048 bytes at offset 2613248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2617344 ++wrote 2048/2048 bytes at offset 2617344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2621440 ++wrote 2048/2048 bytes at offset 2621440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2625536 ++wrote 2048/2048 bytes at offset 2625536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2629632 ++wrote 2048/2048 bytes at offset 2629632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2633728 ++wrote 2048/2048 bytes at offset 2633728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2637824 ++wrote 2048/2048 bytes at offset 2637824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2641920 ++wrote 2048/2048 bytes at offset 2641920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2646016 ++wrote 2048/2048 bytes at offset 2646016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2650112 ++wrote 2048/2048 bytes at offset 2650112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2654208 ++wrote 2048/2048 bytes at offset 2654208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2658304 ++wrote 2048/2048 bytes at offset 2658304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2662400 ++wrote 2048/2048 bytes at offset 2662400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2666496 ++wrote 2048/2048 bytes at offset 2666496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2670592 ++wrote 2048/2048 bytes at offset 2670592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2674688 ++wrote 2048/2048 bytes at offset 2674688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2678784 ++wrote 2048/2048 bytes at offset 2678784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2682880 ++wrote 2048/2048 bytes at offset 2682880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2686976 ++wrote 2048/2048 bytes at offset 2686976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2691072 ++wrote 2048/2048 bytes at offset 2691072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2695168 ++wrote 2048/2048 bytes at offset 2695168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2699264 ++wrote 2048/2048 bytes at offset 2699264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2703360 ++wrote 2048/2048 bytes at offset 2703360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2707456 ++wrote 2048/2048 bytes at offset 2707456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2711552 ++wrote 2048/2048 bytes at offset 2711552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2715648 ++wrote 2048/2048 bytes at offset 2715648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2719744 ++wrote 2048/2048 bytes at offset 2719744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2723840 ++wrote 2048/2048 bytes at offset 2723840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2727936 ++wrote 2048/2048 bytes at offset 2727936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2732032 ++wrote 2048/2048 bytes at offset 2732032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2736128 ++wrote 2048/2048 bytes at offset 2736128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2740224 ++wrote 2048/2048 bytes at offset 2740224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2744320 ++wrote 2048/2048 bytes at offset 2744320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2748416 ++wrote 2048/2048 bytes at offset 2748416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2752512 ++wrote 2048/2048 bytes at offset 2752512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2756608 ++wrote 2048/2048 bytes at offset 2756608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2760704 ++wrote 2048/2048 bytes at offset 2760704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2764800 ++wrote 2048/2048 bytes at offset 2764800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2768896 ++wrote 2048/2048 bytes at offset 2768896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2772992 ++wrote 2048/2048 bytes at offset 2772992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2777088 ++wrote 2048/2048 bytes at offset 2777088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2781184 ++wrote 2048/2048 bytes at offset 2781184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2785280 ++wrote 2048/2048 bytes at offset 2785280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2789376 ++wrote 2048/2048 bytes at offset 2789376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2793472 ++wrote 2048/2048 bytes at offset 2793472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2797568 ++wrote 2048/2048 bytes at offset 2797568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2801664 ++wrote 2048/2048 bytes at offset 2801664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2805760 ++wrote 2048/2048 bytes at offset 2805760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2809856 ++wrote 2048/2048 bytes at offset 2809856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2813952 ++wrote 2048/2048 bytes at offset 2813952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2818048 ++wrote 2048/2048 bytes at offset 2818048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2822144 ++wrote 2048/2048 bytes at offset 2822144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2826240 ++wrote 2048/2048 bytes at offset 2826240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2830336 ++wrote 2048/2048 bytes at offset 2830336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2834432 ++wrote 2048/2048 bytes at offset 2834432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2838528 ++wrote 2048/2048 bytes at offset 2838528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2842624 ++wrote 2048/2048 bytes at offset 2842624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2846720 ++wrote 2048/2048 bytes at offset 2846720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2850816 ++wrote 2048/2048 bytes at offset 2850816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2854912 ++wrote 2048/2048 bytes at offset 2854912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2859008 ++wrote 2048/2048 bytes at offset 2859008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2863104 ++wrote 2048/2048 bytes at offset 2863104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2867200 ++wrote 2048/2048 bytes at offset 2867200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2871296 ++wrote 2048/2048 bytes at offset 2871296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2875392 ++wrote 2048/2048 bytes at offset 2875392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2879488 ++wrote 2048/2048 bytes at offset 2879488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2883584 ++wrote 2048/2048 bytes at offset 2883584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2887680 ++wrote 2048/2048 bytes at offset 2887680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2891776 ++wrote 2048/2048 bytes at offset 2891776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2895872 ++wrote 2048/2048 bytes at offset 2895872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2899968 ++wrote 2048/2048 bytes at offset 2899968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2904064 ++wrote 2048/2048 bytes at offset 2904064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2908160 ++wrote 2048/2048 bytes at offset 2908160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2912256 ++wrote 2048/2048 bytes at offset 2912256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2916352 ++wrote 2048/2048 bytes at offset 2916352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2920448 ++wrote 2048/2048 bytes at offset 2920448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2924544 ++wrote 2048/2048 bytes at offset 2924544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2928640 ++wrote 2048/2048 bytes at offset 2928640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2932736 ++wrote 2048/2048 bytes at offset 2932736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2936832 ++wrote 2048/2048 bytes at offset 2936832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2940928 ++wrote 2048/2048 bytes at offset 2940928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2945024 ++wrote 2048/2048 bytes at offset 2945024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2949120 ++wrote 2048/2048 bytes at offset 2949120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2953216 ++wrote 2048/2048 bytes at offset 2953216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2957312 ++wrote 2048/2048 bytes at offset 2957312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2961408 ++wrote 2048/2048 bytes at offset 2961408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2965504 ++wrote 2048/2048 bytes at offset 2965504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2969600 ++wrote 2048/2048 bytes at offset 2969600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2973696 ++wrote 2048/2048 bytes at offset 2973696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2977792 ++wrote 2048/2048 bytes at offset 2977792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2981888 ++wrote 2048/2048 bytes at offset 2981888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2985984 ++wrote 2048/2048 bytes at offset 2985984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2990080 ++wrote 2048/2048 bytes at offset 2990080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2994176 ++wrote 2048/2048 bytes at offset 2994176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2998272 ++wrote 2048/2048 bytes at offset 2998272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3002368 ++wrote 2048/2048 bytes at offset 3002368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3006464 ++wrote 2048/2048 bytes at offset 3006464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3010560 ++wrote 2048/2048 bytes at offset 3010560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3014656 ++wrote 2048/2048 bytes at offset 3014656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3018752 ++wrote 2048/2048 bytes at offset 3018752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3022848 ++wrote 2048/2048 bytes at offset 3022848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3026944 ++wrote 2048/2048 bytes at offset 3026944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3031040 ++wrote 2048/2048 bytes at offset 3031040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3035136 ++wrote 2048/2048 bytes at offset 3035136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3039232 ++wrote 2048/2048 bytes at offset 3039232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3043328 ++wrote 2048/2048 bytes at offset 3043328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3047424 ++wrote 2048/2048 bytes at offset 3047424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3051520 ++wrote 2048/2048 bytes at offset 3051520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3055616 ++wrote 2048/2048 bytes at offset 3055616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3059712 ++wrote 2048/2048 bytes at offset 3059712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3063808 ++wrote 2048/2048 bytes at offset 3063808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3067904 ++wrote 2048/2048 bytes at offset 3067904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3072000 ++wrote 2048/2048 bytes at offset 3072000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3076096 ++wrote 2048/2048 bytes at offset 3076096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3080192 ++wrote 2048/2048 bytes at offset 3080192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3084288 ++wrote 2048/2048 bytes at offset 3084288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3088384 ++wrote 2048/2048 bytes at offset 3088384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3092480 ++wrote 2048/2048 bytes at offset 3092480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3096576 ++wrote 2048/2048 bytes at offset 3096576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3100672 ++wrote 2048/2048 bytes at offset 3100672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3104768 ++wrote 2048/2048 bytes at offset 3104768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3108864 ++wrote 2048/2048 bytes at offset 3108864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3112960 ++wrote 2048/2048 bytes at offset 3112960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3117056 ++wrote 2048/2048 bytes at offset 3117056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3121152 ++wrote 2048/2048 bytes at offset 3121152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3125248 ++wrote 2048/2048 bytes at offset 3125248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3129344 ++wrote 2048/2048 bytes at offset 3129344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3133440 ++wrote 2048/2048 bytes at offset 3133440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3137536 ++wrote 2048/2048 bytes at offset 3137536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3141632 ++wrote 2048/2048 bytes at offset 3141632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 2 +-qemu-io> wrote 2048/2048 bytes at offset 3146752 ++=== IO: pattern 2 ++wrote 2048/2048 bytes at offset 3146752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3150848 ++wrote 2048/2048 bytes at offset 3150848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3154944 ++wrote 2048/2048 bytes at offset 3154944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3159040 ++wrote 2048/2048 bytes at offset 3159040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3163136 ++wrote 2048/2048 bytes at offset 3163136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3167232 ++wrote 2048/2048 bytes at offset 3167232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3171328 ++wrote 2048/2048 bytes at offset 3171328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3175424 ++wrote 2048/2048 bytes at offset 3175424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3179520 ++wrote 2048/2048 bytes at offset 3179520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3183616 ++wrote 2048/2048 bytes at offset 3183616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3187712 ++wrote 2048/2048 bytes at offset 3187712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3191808 ++wrote 2048/2048 bytes at offset 3191808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3195904 ++wrote 2048/2048 bytes at offset 3195904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3200000 ++wrote 2048/2048 bytes at offset 3200000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3204096 ++wrote 2048/2048 bytes at offset 3204096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3208192 ++wrote 2048/2048 bytes at offset 3208192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3212288 ++wrote 2048/2048 bytes at offset 3212288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3216384 ++wrote 2048/2048 bytes at offset 3216384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3220480 ++wrote 2048/2048 bytes at offset 3220480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3224576 ++wrote 2048/2048 bytes at offset 3224576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3228672 ++wrote 2048/2048 bytes at offset 3228672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3232768 ++wrote 2048/2048 bytes at offset 3232768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3236864 ++wrote 2048/2048 bytes at offset 3236864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3240960 ++wrote 2048/2048 bytes at offset 3240960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3245056 ++wrote 2048/2048 bytes at offset 3245056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3249152 ++wrote 2048/2048 bytes at offset 3249152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3253248 ++wrote 2048/2048 bytes at offset 3253248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3257344 ++wrote 2048/2048 bytes at offset 3257344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3261440 ++wrote 2048/2048 bytes at offset 3261440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3265536 ++wrote 2048/2048 bytes at offset 3265536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3269632 ++wrote 2048/2048 bytes at offset 3269632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3273728 ++wrote 2048/2048 bytes at offset 3273728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3277824 ++wrote 2048/2048 bytes at offset 3277824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3281920 ++wrote 2048/2048 bytes at offset 3281920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3286016 ++wrote 2048/2048 bytes at offset 3286016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3290112 ++wrote 2048/2048 bytes at offset 3290112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3294208 ++wrote 2048/2048 bytes at offset 3294208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3298304 ++wrote 2048/2048 bytes at offset 3298304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3302400 ++wrote 2048/2048 bytes at offset 3302400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3306496 ++wrote 2048/2048 bytes at offset 3306496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3310592 ++wrote 2048/2048 bytes at offset 3310592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3314688 ++wrote 2048/2048 bytes at offset 3314688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3318784 ++wrote 2048/2048 bytes at offset 3318784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3322880 ++wrote 2048/2048 bytes at offset 3322880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3326976 ++wrote 2048/2048 bytes at offset 3326976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3331072 ++wrote 2048/2048 bytes at offset 3331072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3335168 ++wrote 2048/2048 bytes at offset 3335168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3339264 ++wrote 2048/2048 bytes at offset 3339264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3343360 ++wrote 2048/2048 bytes at offset 3343360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3347456 ++wrote 2048/2048 bytes at offset 3347456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3351552 ++wrote 2048/2048 bytes at offset 3351552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3355648 ++wrote 2048/2048 bytes at offset 3355648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3359744 ++wrote 2048/2048 bytes at offset 3359744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3363840 ++wrote 2048/2048 bytes at offset 3363840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3367936 ++wrote 2048/2048 bytes at offset 3367936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3372032 ++wrote 2048/2048 bytes at offset 3372032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3376128 ++wrote 2048/2048 bytes at offset 3376128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3380224 ++wrote 2048/2048 bytes at offset 3380224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3384320 ++wrote 2048/2048 bytes at offset 3384320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3388416 ++wrote 2048/2048 bytes at offset 3388416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3392512 ++wrote 2048/2048 bytes at offset 3392512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3396608 ++wrote 2048/2048 bytes at offset 3396608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3400704 ++wrote 2048/2048 bytes at offset 3400704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3404800 ++wrote 2048/2048 bytes at offset 3404800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3408896 ++wrote 2048/2048 bytes at offset 3408896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3412992 ++wrote 2048/2048 bytes at offset 3412992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3417088 ++wrote 2048/2048 bytes at offset 3417088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3421184 ++wrote 2048/2048 bytes at offset 3421184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3425280 ++wrote 2048/2048 bytes at offset 3425280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3429376 ++wrote 2048/2048 bytes at offset 3429376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3433472 ++wrote 2048/2048 bytes at offset 3433472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3437568 ++wrote 2048/2048 bytes at offset 3437568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3441664 ++wrote 2048/2048 bytes at offset 3441664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3445760 ++wrote 2048/2048 bytes at offset 3445760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3449856 ++wrote 2048/2048 bytes at offset 3449856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3453952 ++wrote 2048/2048 bytes at offset 3453952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3458048 ++wrote 2048/2048 bytes at offset 3458048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3462144 ++wrote 2048/2048 bytes at offset 3462144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3466240 ++wrote 2048/2048 bytes at offset 3466240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3470336 ++wrote 2048/2048 bytes at offset 3470336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3474432 ++wrote 2048/2048 bytes at offset 3474432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3478528 ++wrote 2048/2048 bytes at offset 3478528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3482624 ++wrote 2048/2048 bytes at offset 3482624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3486720 ++wrote 2048/2048 bytes at offset 3486720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3490816 ++wrote 2048/2048 bytes at offset 3490816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3494912 ++wrote 2048/2048 bytes at offset 3494912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3499008 ++wrote 2048/2048 bytes at offset 3499008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3503104 ++wrote 2048/2048 bytes at offset 3503104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3507200 ++wrote 2048/2048 bytes at offset 3507200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3511296 ++wrote 2048/2048 bytes at offset 3511296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3515392 ++wrote 2048/2048 bytes at offset 3515392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3519488 ++wrote 2048/2048 bytes at offset 3519488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3523584 ++wrote 2048/2048 bytes at offset 3523584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3527680 ++wrote 2048/2048 bytes at offset 3527680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3531776 ++wrote 2048/2048 bytes at offset 3531776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3535872 ++wrote 2048/2048 bytes at offset 3535872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3539968 ++wrote 2048/2048 bytes at offset 3539968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3544064 ++wrote 2048/2048 bytes at offset 3544064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3548160 ++wrote 2048/2048 bytes at offset 3548160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3552256 ++wrote 2048/2048 bytes at offset 3552256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3556352 ++wrote 2048/2048 bytes at offset 3556352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3560448 ++wrote 2048/2048 bytes at offset 3560448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3564544 ++wrote 2048/2048 bytes at offset 3564544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3568640 ++wrote 2048/2048 bytes at offset 3568640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3572736 ++wrote 2048/2048 bytes at offset 3572736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3576832 ++wrote 2048/2048 bytes at offset 3576832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3580928 ++wrote 2048/2048 bytes at offset 3580928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3585024 ++wrote 2048/2048 bytes at offset 3585024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3589120 ++wrote 2048/2048 bytes at offset 3589120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3593216 ++wrote 2048/2048 bytes at offset 3593216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3597312 ++wrote 2048/2048 bytes at offset 3597312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3601408 ++wrote 2048/2048 bytes at offset 3601408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3605504 ++wrote 2048/2048 bytes at offset 3605504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3609600 ++wrote 2048/2048 bytes at offset 3609600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3613696 ++wrote 2048/2048 bytes at offset 3613696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3617792 ++wrote 2048/2048 bytes at offset 3617792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3621888 ++wrote 2048/2048 bytes at offset 3621888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3625984 ++wrote 2048/2048 bytes at offset 3625984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3630080 ++wrote 2048/2048 bytes at offset 3630080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3634176 ++wrote 2048/2048 bytes at offset 3634176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3638272 ++wrote 2048/2048 bytes at offset 3638272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3642368 ++wrote 2048/2048 bytes at offset 3642368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3646464 ++wrote 2048/2048 bytes at offset 3646464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3650560 ++wrote 2048/2048 bytes at offset 3650560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3654656 ++wrote 2048/2048 bytes at offset 3654656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3658752 ++wrote 2048/2048 bytes at offset 3658752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3662848 ++wrote 2048/2048 bytes at offset 3662848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3666944 ++wrote 2048/2048 bytes at offset 3666944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3671040 ++wrote 2048/2048 bytes at offset 3671040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3675136 ++wrote 2048/2048 bytes at offset 3675136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3679232 ++wrote 2048/2048 bytes at offset 3679232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3683328 ++wrote 2048/2048 bytes at offset 3683328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3687424 ++wrote 2048/2048 bytes at offset 3687424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3691520 ++wrote 2048/2048 bytes at offset 3691520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3695616 ++wrote 2048/2048 bytes at offset 3695616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3699712 ++wrote 2048/2048 bytes at offset 3699712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3703808 ++wrote 2048/2048 bytes at offset 3703808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3707904 ++wrote 2048/2048 bytes at offset 3707904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3712000 ++wrote 2048/2048 bytes at offset 3712000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3716096 ++wrote 2048/2048 bytes at offset 3716096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3720192 ++wrote 2048/2048 bytes at offset 3720192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3724288 ++wrote 2048/2048 bytes at offset 3724288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3728384 ++wrote 2048/2048 bytes at offset 3728384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3732480 ++wrote 2048/2048 bytes at offset 3732480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3736576 ++wrote 2048/2048 bytes at offset 3736576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3740672 ++wrote 2048/2048 bytes at offset 3740672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3744768 ++wrote 2048/2048 bytes at offset 3744768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3748864 ++wrote 2048/2048 bytes at offset 3748864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3752960 ++wrote 2048/2048 bytes at offset 3752960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3757056 ++wrote 2048/2048 bytes at offset 3757056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3761152 ++wrote 2048/2048 bytes at offset 3761152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3765248 ++wrote 2048/2048 bytes at offset 3765248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3769344 ++wrote 2048/2048 bytes at offset 3769344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3773440 ++wrote 2048/2048 bytes at offset 3773440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3777536 ++wrote 2048/2048 bytes at offset 3777536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3781632 ++wrote 2048/2048 bytes at offset 3781632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3785728 ++wrote 2048/2048 bytes at offset 3785728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3789824 ++wrote 2048/2048 bytes at offset 3789824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3793920 ++wrote 2048/2048 bytes at offset 3793920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3798016 ++wrote 2048/2048 bytes at offset 3798016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3802112 ++wrote 2048/2048 bytes at offset 3802112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3806208 ++wrote 2048/2048 bytes at offset 3806208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3810304 ++wrote 2048/2048 bytes at offset 3810304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3814400 ++wrote 2048/2048 bytes at offset 3814400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3818496 ++wrote 2048/2048 bytes at offset 3818496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3822592 ++wrote 2048/2048 bytes at offset 3822592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3826688 ++wrote 2048/2048 bytes at offset 3826688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3830784 ++wrote 2048/2048 bytes at offset 3830784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3834880 ++wrote 2048/2048 bytes at offset 3834880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3838976 ++wrote 2048/2048 bytes at offset 3838976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3843072 ++wrote 2048/2048 bytes at offset 3843072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3847168 ++wrote 2048/2048 bytes at offset 3847168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3851264 ++wrote 2048/2048 bytes at offset 3851264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3855360 ++wrote 2048/2048 bytes at offset 3855360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3859456 ++wrote 2048/2048 bytes at offset 3859456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3863552 ++wrote 2048/2048 bytes at offset 3863552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3867648 ++wrote 2048/2048 bytes at offset 3867648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3871744 ++wrote 2048/2048 bytes at offset 3871744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3875840 ++wrote 2048/2048 bytes at offset 3875840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3879936 ++wrote 2048/2048 bytes at offset 3879936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3884032 ++wrote 2048/2048 bytes at offset 3884032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3888128 ++wrote 2048/2048 bytes at offset 3888128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3892224 ++wrote 2048/2048 bytes at offset 3892224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3896320 ++wrote 2048/2048 bytes at offset 3896320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3900416 ++wrote 2048/2048 bytes at offset 3900416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3904512 ++wrote 2048/2048 bytes at offset 3904512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3908608 ++wrote 2048/2048 bytes at offset 3908608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3912704 ++wrote 2048/2048 bytes at offset 3912704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3916800 ++wrote 2048/2048 bytes at offset 3916800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3920896 ++wrote 2048/2048 bytes at offset 3920896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3924992 ++wrote 2048/2048 bytes at offset 3924992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3929088 ++wrote 2048/2048 bytes at offset 3929088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3933184 ++wrote 2048/2048 bytes at offset 3933184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3937280 ++wrote 2048/2048 bytes at offset 3937280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3941376 ++wrote 2048/2048 bytes at offset 3941376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3945472 ++wrote 2048/2048 bytes at offset 3945472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3949568 ++wrote 2048/2048 bytes at offset 3949568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3953664 ++wrote 2048/2048 bytes at offset 3953664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3957760 ++wrote 2048/2048 bytes at offset 3957760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3961856 ++wrote 2048/2048 bytes at offset 3961856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3965952 ++wrote 2048/2048 bytes at offset 3965952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3970048 ++wrote 2048/2048 bytes at offset 3970048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3974144 ++wrote 2048/2048 bytes at offset 3974144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3978240 ++wrote 2048/2048 bytes at offset 3978240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3982336 ++wrote 2048/2048 bytes at offset 3982336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3986432 ++wrote 2048/2048 bytes at offset 3986432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3990528 ++wrote 2048/2048 bytes at offset 3990528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3994624 ++wrote 2048/2048 bytes at offset 3994624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3998720 ++wrote 2048/2048 bytes at offset 3998720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4002816 ++wrote 2048/2048 bytes at offset 4002816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4006912 ++wrote 2048/2048 bytes at offset 4006912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4011008 ++wrote 2048/2048 bytes at offset 4011008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4015104 ++wrote 2048/2048 bytes at offset 4015104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4019200 ++wrote 2048/2048 bytes at offset 4019200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4023296 ++wrote 2048/2048 bytes at offset 4023296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4027392 ++wrote 2048/2048 bytes at offset 4027392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4031488 ++wrote 2048/2048 bytes at offset 4031488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4035584 ++wrote 2048/2048 bytes at offset 4035584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4039680 ++wrote 2048/2048 bytes at offset 4039680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4043776 ++wrote 2048/2048 bytes at offset 4043776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4047872 ++wrote 2048/2048 bytes at offset 4047872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4051968 ++wrote 2048/2048 bytes at offset 4051968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4056064 ++wrote 2048/2048 bytes at offset 4056064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4060160 ++wrote 2048/2048 bytes at offset 4060160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4064256 ++wrote 2048/2048 bytes at offset 4064256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4068352 ++wrote 2048/2048 bytes at offset 4068352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4072448 ++wrote 2048/2048 bytes at offset 4072448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4076544 ++wrote 2048/2048 bytes at offset 4076544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4080640 ++wrote 2048/2048 bytes at offset 4080640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4084736 ++wrote 2048/2048 bytes at offset 4084736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4088832 ++wrote 2048/2048 bytes at offset 4088832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4092928 ++wrote 2048/2048 bytes at offset 4092928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4097024 ++wrote 2048/2048 bytes at offset 4097024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4101120 ++wrote 2048/2048 bytes at offset 4101120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4105216 ++wrote 2048/2048 bytes at offset 4105216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4109312 ++wrote 2048/2048 bytes at offset 4109312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4113408 ++wrote 2048/2048 bytes at offset 4113408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4117504 ++wrote 2048/2048 bytes at offset 4117504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4121600 ++wrote 2048/2048 bytes at offset 4121600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4125696 ++wrote 2048/2048 bytes at offset 4125696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4129792 ++wrote 2048/2048 bytes at offset 4129792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4133888 ++wrote 2048/2048 bytes at offset 4133888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4137984 ++wrote 2048/2048 bytes at offset 4137984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4142080 ++wrote 2048/2048 bytes at offset 4142080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4146176 ++wrote 2048/2048 bytes at offset 4146176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4150272 ++wrote 2048/2048 bytes at offset 4150272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4154368 ++wrote 2048/2048 bytes at offset 4154368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4158464 ++wrote 2048/2048 bytes at offset 4158464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4162560 ++wrote 2048/2048 bytes at offset 4162560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4166656 ++wrote 2048/2048 bytes at offset 4166656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4170752 ++wrote 2048/2048 bytes at offset 4170752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4174848 ++wrote 2048/2048 bytes at offset 4174848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4178944 ++wrote 2048/2048 bytes at offset 4178944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4183040 ++wrote 2048/2048 bytes at offset 4183040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4187136 ++wrote 2048/2048 bytes at offset 4187136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4191232 ++wrote 2048/2048 bytes at offset 4191232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 4 +-qemu-io> wrote 8192/8192 bytes at offset 4196352 ++=== IO: pattern 4 ++wrote 8192/8192 bytes at offset 4196352 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4208640 ++wrote 8192/8192 bytes at offset 4208640 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4220928 ++wrote 8192/8192 bytes at offset 4220928 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4233216 ++wrote 8192/8192 bytes at offset 4233216 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4245504 ++wrote 8192/8192 bytes at offset 4245504 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4257792 ++wrote 8192/8192 bytes at offset 4257792 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4270080 ++wrote 8192/8192 bytes at offset 4270080 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4282368 ++wrote 8192/8192 bytes at offset 4282368 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4294656 ++wrote 8192/8192 bytes at offset 4294656 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4306944 ++wrote 8192/8192 bytes at offset 4306944 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4319232 ++wrote 8192/8192 bytes at offset 4319232 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4331520 ++wrote 8192/8192 bytes at offset 4331520 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4343808 ++wrote 8192/8192 bytes at offset 4343808 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4356096 ++wrote 8192/8192 bytes at offset 4356096 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4368384 ++wrote 8192/8192 bytes at offset 4368384 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4380672 ++wrote 8192/8192 bytes at offset 4380672 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4392960 ++wrote 8192/8192 bytes at offset 4392960 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4405248 ++wrote 8192/8192 bytes at offset 4405248 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4417536 ++wrote 8192/8192 bytes at offset 4417536 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4429824 ++wrote 8192/8192 bytes at offset 4429824 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4442112 ++wrote 8192/8192 bytes at offset 4442112 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4454400 ++wrote 8192/8192 bytes at offset 4454400 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4466688 ++wrote 8192/8192 bytes at offset 4466688 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4478976 ++wrote 8192/8192 bytes at offset 4478976 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4491264 ++wrote 8192/8192 bytes at offset 4491264 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4503552 ++wrote 8192/8192 bytes at offset 4503552 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4515840 ++wrote 8192/8192 bytes at offset 4515840 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4528128 ++wrote 8192/8192 bytes at offset 4528128 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4540416 ++wrote 8192/8192 bytes at offset 4540416 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4552704 ++wrote 8192/8192 bytes at offset 4552704 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4564992 ++wrote 8192/8192 bytes at offset 4564992 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4577280 ++wrote 8192/8192 bytes at offset 4577280 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4589568 ++wrote 8192/8192 bytes at offset 4589568 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4601856 ++wrote 8192/8192 bytes at offset 4601856 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4614144 ++wrote 8192/8192 bytes at offset 4614144 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4626432 ++wrote 8192/8192 bytes at offset 4626432 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4638720 ++wrote 8192/8192 bytes at offset 4638720 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4651008 ++wrote 8192/8192 bytes at offset 4651008 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4663296 ++wrote 8192/8192 bytes at offset 4663296 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4675584 ++wrote 8192/8192 bytes at offset 4675584 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4687872 ++wrote 8192/8192 bytes at offset 4687872 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4700160 ++wrote 8192/8192 bytes at offset 4700160 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4712448 ++wrote 8192/8192 bytes at offset 4712448 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4724736 ++wrote 8192/8192 bytes at offset 4724736 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4737024 ++wrote 8192/8192 bytes at offset 4737024 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4749312 ++wrote 8192/8192 bytes at offset 4749312 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4761600 ++wrote 8192/8192 bytes at offset 4761600 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4773888 ++wrote 8192/8192 bytes at offset 4773888 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4786176 ++wrote 8192/8192 bytes at offset 4786176 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4798464 ++wrote 8192/8192 bytes at offset 4798464 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4810752 ++wrote 8192/8192 bytes at offset 4810752 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4823040 ++wrote 8192/8192 bytes at offset 4823040 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4835328 ++wrote 8192/8192 bytes at offset 4835328 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4847616 ++wrote 8192/8192 bytes at offset 4847616 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4859904 ++wrote 8192/8192 bytes at offset 4859904 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4872192 ++wrote 8192/8192 bytes at offset 4872192 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4884480 ++wrote 8192/8192 bytes at offset 4884480 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4896768 ++wrote 8192/8192 bytes at offset 4896768 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4909056 ++wrote 8192/8192 bytes at offset 4909056 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4921344 ++wrote 8192/8192 bytes at offset 4921344 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4933632 ++wrote 8192/8192 bytes at offset 4933632 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4945920 ++wrote 8192/8192 bytes at offset 4945920 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4958208 ++wrote 8192/8192 bytes at offset 4958208 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4970496 ++wrote 8192/8192 bytes at offset 4970496 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 244 +-qemu-io> wrote 12288/12288 bytes at offset 6285312 ++=== IO: pattern 244 ++wrote 12288/12288 bytes at offset 6285312 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 8384512 ++wrote 12288/12288 bytes at offset 8384512 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 10483712 ++wrote 12288/12288 bytes at offset 10483712 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 12582912 ++wrote 12288/12288 bytes at offset 12582912 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 14682112 ++wrote 12288/12288 bytes at offset 14682112 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 16781312 ++wrote 12288/12288 bytes at offset 16781312 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 18880512 ++wrote 12288/12288 bytes at offset 18880512 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 20979712 ++wrote 12288/12288 bytes at offset 20979712 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> read 4096/4096 bytes at offset 0 ++=== IO: pattern 0 ++read 4096/4096 bytes at offset 0 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4096 ++read 4096/4096 bytes at offset 4096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 8192 ++read 4096/4096 bytes at offset 8192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 12288 ++read 4096/4096 bytes at offset 12288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 16384 ++read 4096/4096 bytes at offset 16384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 20480 ++read 4096/4096 bytes at offset 20480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 24576 ++read 4096/4096 bytes at offset 24576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 28672 ++read 4096/4096 bytes at offset 28672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 32768 ++read 4096/4096 bytes at offset 32768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 36864 ++read 4096/4096 bytes at offset 36864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 40960 ++read 4096/4096 bytes at offset 40960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 45056 ++read 4096/4096 bytes at offset 45056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 49152 ++read 4096/4096 bytes at offset 49152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 53248 ++read 4096/4096 bytes at offset 53248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 57344 ++read 4096/4096 bytes at offset 57344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 61440 ++read 4096/4096 bytes at offset 61440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 65536 ++read 4096/4096 bytes at offset 65536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 69632 ++read 4096/4096 bytes at offset 69632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 73728 ++read 4096/4096 bytes at offset 73728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 77824 ++read 4096/4096 bytes at offset 77824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 81920 ++read 4096/4096 bytes at offset 81920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 86016 ++read 4096/4096 bytes at offset 86016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 90112 ++read 4096/4096 bytes at offset 90112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 94208 ++read 4096/4096 bytes at offset 94208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 98304 ++read 4096/4096 bytes at offset 98304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 102400 ++read 4096/4096 bytes at offset 102400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 106496 ++read 4096/4096 bytes at offset 106496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 110592 ++read 4096/4096 bytes at offset 110592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 114688 ++read 4096/4096 bytes at offset 114688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 118784 ++read 4096/4096 bytes at offset 118784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 122880 ++read 4096/4096 bytes at offset 122880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 126976 ++read 4096/4096 bytes at offset 126976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 131072 ++read 4096/4096 bytes at offset 131072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 135168 ++read 4096/4096 bytes at offset 135168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 139264 ++read 4096/4096 bytes at offset 139264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 143360 ++read 4096/4096 bytes at offset 143360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 147456 ++read 4096/4096 bytes at offset 147456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 151552 ++read 4096/4096 bytes at offset 151552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 155648 ++read 4096/4096 bytes at offset 155648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 159744 ++read 4096/4096 bytes at offset 159744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 163840 ++read 4096/4096 bytes at offset 163840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 167936 ++read 4096/4096 bytes at offset 167936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 172032 ++read 4096/4096 bytes at offset 172032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 176128 ++read 4096/4096 bytes at offset 176128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 180224 ++read 4096/4096 bytes at offset 180224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 184320 ++read 4096/4096 bytes at offset 184320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 188416 ++read 4096/4096 bytes at offset 188416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 192512 ++read 4096/4096 bytes at offset 192512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 196608 ++read 4096/4096 bytes at offset 196608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 200704 ++read 4096/4096 bytes at offset 200704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 204800 ++read 4096/4096 bytes at offset 204800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 208896 ++read 4096/4096 bytes at offset 208896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 212992 ++read 4096/4096 bytes at offset 212992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 217088 ++read 4096/4096 bytes at offset 217088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 221184 ++read 4096/4096 bytes at offset 221184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 225280 ++read 4096/4096 bytes at offset 225280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 229376 ++read 4096/4096 bytes at offset 229376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 233472 ++read 4096/4096 bytes at offset 233472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 237568 ++read 4096/4096 bytes at offset 237568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 241664 ++read 4096/4096 bytes at offset 241664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 245760 ++read 4096/4096 bytes at offset 245760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 249856 ++read 4096/4096 bytes at offset 249856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 253952 ++read 4096/4096 bytes at offset 253952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 258048 ++read 4096/4096 bytes at offset 258048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 262144 ++read 4096/4096 bytes at offset 262144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 266240 ++read 4096/4096 bytes at offset 266240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 270336 ++read 4096/4096 bytes at offset 270336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 274432 ++read 4096/4096 bytes at offset 274432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 278528 ++read 4096/4096 bytes at offset 278528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 282624 ++read 4096/4096 bytes at offset 282624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 286720 ++read 4096/4096 bytes at offset 286720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 290816 ++read 4096/4096 bytes at offset 290816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 294912 ++read 4096/4096 bytes at offset 294912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 299008 ++read 4096/4096 bytes at offset 299008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 303104 ++read 4096/4096 bytes at offset 303104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 307200 ++read 4096/4096 bytes at offset 307200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 311296 ++read 4096/4096 bytes at offset 311296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 315392 ++read 4096/4096 bytes at offset 315392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 319488 ++read 4096/4096 bytes at offset 319488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 323584 ++read 4096/4096 bytes at offset 323584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 327680 ++read 4096/4096 bytes at offset 327680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 331776 ++read 4096/4096 bytes at offset 331776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 335872 ++read 4096/4096 bytes at offset 335872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 339968 ++read 4096/4096 bytes at offset 339968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 344064 ++read 4096/4096 bytes at offset 344064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 348160 ++read 4096/4096 bytes at offset 348160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 352256 ++read 4096/4096 bytes at offset 352256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 356352 ++read 4096/4096 bytes at offset 356352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 360448 ++read 4096/4096 bytes at offset 360448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 364544 ++read 4096/4096 bytes at offset 364544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 368640 ++read 4096/4096 bytes at offset 368640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 372736 ++read 4096/4096 bytes at offset 372736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 376832 ++read 4096/4096 bytes at offset 376832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 380928 ++read 4096/4096 bytes at offset 380928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 385024 ++read 4096/4096 bytes at offset 385024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 389120 ++read 4096/4096 bytes at offset 389120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 393216 ++read 4096/4096 bytes at offset 393216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 397312 ++read 4096/4096 bytes at offset 397312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 401408 ++read 4096/4096 bytes at offset 401408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 405504 ++read 4096/4096 bytes at offset 405504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 409600 ++read 4096/4096 bytes at offset 409600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 413696 ++read 4096/4096 bytes at offset 413696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 417792 ++read 4096/4096 bytes at offset 417792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 421888 ++read 4096/4096 bytes at offset 421888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 425984 ++read 4096/4096 bytes at offset 425984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 430080 ++read 4096/4096 bytes at offset 430080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 434176 ++read 4096/4096 bytes at offset 434176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 438272 ++read 4096/4096 bytes at offset 438272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 442368 ++read 4096/4096 bytes at offset 442368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 446464 ++read 4096/4096 bytes at offset 446464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 450560 ++read 4096/4096 bytes at offset 450560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 454656 ++read 4096/4096 bytes at offset 454656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 458752 ++read 4096/4096 bytes at offset 458752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 462848 ++read 4096/4096 bytes at offset 462848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 466944 ++read 4096/4096 bytes at offset 466944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 471040 ++read 4096/4096 bytes at offset 471040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 475136 ++read 4096/4096 bytes at offset 475136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 479232 ++read 4096/4096 bytes at offset 479232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 483328 ++read 4096/4096 bytes at offset 483328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 487424 ++read 4096/4096 bytes at offset 487424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 491520 ++read 4096/4096 bytes at offset 491520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 495616 ++read 4096/4096 bytes at offset 495616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 499712 ++read 4096/4096 bytes at offset 499712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 503808 ++read 4096/4096 bytes at offset 503808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 507904 ++read 4096/4096 bytes at offset 507904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 512000 ++read 4096/4096 bytes at offset 512000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 516096 ++read 4096/4096 bytes at offset 516096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 520192 ++read 4096/4096 bytes at offset 520192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 524288 ++read 4096/4096 bytes at offset 524288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 528384 ++read 4096/4096 bytes at offset 528384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 532480 ++read 4096/4096 bytes at offset 532480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 536576 ++read 4096/4096 bytes at offset 536576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 540672 ++read 4096/4096 bytes at offset 540672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 544768 ++read 4096/4096 bytes at offset 544768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 548864 ++read 4096/4096 bytes at offset 548864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 552960 ++read 4096/4096 bytes at offset 552960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 557056 ++read 4096/4096 bytes at offset 557056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 561152 ++read 4096/4096 bytes at offset 561152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 565248 ++read 4096/4096 bytes at offset 565248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 569344 ++read 4096/4096 bytes at offset 569344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 573440 ++read 4096/4096 bytes at offset 573440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 577536 ++read 4096/4096 bytes at offset 577536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 581632 ++read 4096/4096 bytes at offset 581632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 585728 ++read 4096/4096 bytes at offset 585728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 589824 ++read 4096/4096 bytes at offset 589824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 593920 ++read 4096/4096 bytes at offset 593920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 598016 ++read 4096/4096 bytes at offset 598016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 602112 ++read 4096/4096 bytes at offset 602112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 606208 ++read 4096/4096 bytes at offset 606208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 610304 ++read 4096/4096 bytes at offset 610304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 614400 ++read 4096/4096 bytes at offset 614400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 618496 ++read 4096/4096 bytes at offset 618496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 622592 ++read 4096/4096 bytes at offset 622592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 626688 ++read 4096/4096 bytes at offset 626688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 630784 ++read 4096/4096 bytes at offset 630784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 634880 ++read 4096/4096 bytes at offset 634880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 638976 ++read 4096/4096 bytes at offset 638976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 643072 ++read 4096/4096 bytes at offset 643072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 647168 ++read 4096/4096 bytes at offset 647168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 651264 ++read 4096/4096 bytes at offset 651264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 655360 ++read 4096/4096 bytes at offset 655360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 659456 ++read 4096/4096 bytes at offset 659456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 663552 ++read 4096/4096 bytes at offset 663552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 667648 ++read 4096/4096 bytes at offset 667648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 671744 ++read 4096/4096 bytes at offset 671744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 675840 ++read 4096/4096 bytes at offset 675840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 679936 ++read 4096/4096 bytes at offset 679936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 684032 ++read 4096/4096 bytes at offset 684032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 688128 ++read 4096/4096 bytes at offset 688128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 692224 ++read 4096/4096 bytes at offset 692224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 696320 ++read 4096/4096 bytes at offset 696320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 700416 ++read 4096/4096 bytes at offset 700416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 704512 ++read 4096/4096 bytes at offset 704512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 708608 ++read 4096/4096 bytes at offset 708608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 712704 ++read 4096/4096 bytes at offset 712704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 716800 ++read 4096/4096 bytes at offset 716800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 720896 ++read 4096/4096 bytes at offset 720896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 724992 ++read 4096/4096 bytes at offset 724992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 729088 ++read 4096/4096 bytes at offset 729088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 733184 ++read 4096/4096 bytes at offset 733184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 737280 ++read 4096/4096 bytes at offset 737280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 741376 ++read 4096/4096 bytes at offset 741376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 745472 ++read 4096/4096 bytes at offset 745472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 749568 ++read 4096/4096 bytes at offset 749568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 753664 ++read 4096/4096 bytes at offset 753664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 757760 ++read 4096/4096 bytes at offset 757760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 761856 ++read 4096/4096 bytes at offset 761856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 765952 ++read 4096/4096 bytes at offset 765952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 770048 ++read 4096/4096 bytes at offset 770048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 774144 ++read 4096/4096 bytes at offset 774144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 778240 ++read 4096/4096 bytes at offset 778240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 782336 ++read 4096/4096 bytes at offset 782336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 786432 ++read 4096/4096 bytes at offset 786432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 790528 ++read 4096/4096 bytes at offset 790528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 794624 ++read 4096/4096 bytes at offset 794624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 798720 ++read 4096/4096 bytes at offset 798720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 802816 ++read 4096/4096 bytes at offset 802816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 806912 ++read 4096/4096 bytes at offset 806912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 811008 ++read 4096/4096 bytes at offset 811008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 815104 ++read 4096/4096 bytes at offset 815104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 819200 ++read 4096/4096 bytes at offset 819200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 823296 ++read 4096/4096 bytes at offset 823296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 827392 ++read 4096/4096 bytes at offset 827392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 831488 ++read 4096/4096 bytes at offset 831488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 835584 ++read 4096/4096 bytes at offset 835584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 839680 ++read 4096/4096 bytes at offset 839680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 843776 ++read 4096/4096 bytes at offset 843776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 847872 ++read 4096/4096 bytes at offset 847872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 851968 ++read 4096/4096 bytes at offset 851968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 856064 ++read 4096/4096 bytes at offset 856064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 860160 ++read 4096/4096 bytes at offset 860160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 864256 ++read 4096/4096 bytes at offset 864256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 868352 ++read 4096/4096 bytes at offset 868352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 872448 ++read 4096/4096 bytes at offset 872448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 876544 ++read 4096/4096 bytes at offset 876544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 880640 ++read 4096/4096 bytes at offset 880640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 884736 ++read 4096/4096 bytes at offset 884736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 888832 ++read 4096/4096 bytes at offset 888832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 892928 ++read 4096/4096 bytes at offset 892928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 897024 ++read 4096/4096 bytes at offset 897024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 901120 ++read 4096/4096 bytes at offset 901120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 905216 ++read 4096/4096 bytes at offset 905216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 909312 ++read 4096/4096 bytes at offset 909312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 913408 ++read 4096/4096 bytes at offset 913408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 917504 ++read 4096/4096 bytes at offset 917504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 921600 ++read 4096/4096 bytes at offset 921600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 925696 ++read 4096/4096 bytes at offset 925696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 929792 ++read 4096/4096 bytes at offset 929792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 933888 ++read 4096/4096 bytes at offset 933888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 937984 ++read 4096/4096 bytes at offset 937984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 942080 ++read 4096/4096 bytes at offset 942080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 946176 ++read 4096/4096 bytes at offset 946176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 950272 ++read 4096/4096 bytes at offset 950272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 954368 ++read 4096/4096 bytes at offset 954368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 958464 ++read 4096/4096 bytes at offset 958464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 962560 ++read 4096/4096 bytes at offset 962560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 966656 ++read 4096/4096 bytes at offset 966656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 970752 ++read 4096/4096 bytes at offset 970752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 974848 ++read 4096/4096 bytes at offset 974848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 978944 ++read 4096/4096 bytes at offset 978944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 983040 ++read 4096/4096 bytes at offset 983040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 987136 ++read 4096/4096 bytes at offset 987136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 991232 ++read 4096/4096 bytes at offset 991232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 995328 ++read 4096/4096 bytes at offset 995328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 999424 ++read 4096/4096 bytes at offset 999424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1003520 ++read 4096/4096 bytes at offset 1003520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1007616 ++read 4096/4096 bytes at offset 1007616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1011712 ++read 4096/4096 bytes at offset 1011712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1015808 ++read 4096/4096 bytes at offset 1015808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1019904 ++read 4096/4096 bytes at offset 1019904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1024000 ++read 4096/4096 bytes at offset 1024000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1028096 ++read 4096/4096 bytes at offset 1028096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1032192 ++read 4096/4096 bytes at offset 1032192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1036288 ++read 4096/4096 bytes at offset 1036288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1040384 ++read 4096/4096 bytes at offset 1040384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1044480 ++read 4096/4096 bytes at offset 1044480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 4 +-qemu-io> read 2048/2048 bytes at offset 1050624 ++=== IO: pattern 4 ++read 2048/2048 bytes at offset 1050624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1054720 ++read 2048/2048 bytes at offset 1054720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1058816 ++read 2048/2048 bytes at offset 1058816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1062912 ++read 2048/2048 bytes at offset 1062912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1067008 ++read 2048/2048 bytes at offset 1067008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1071104 ++read 2048/2048 bytes at offset 1071104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1075200 ++read 2048/2048 bytes at offset 1075200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1079296 ++read 2048/2048 bytes at offset 1079296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1083392 ++read 2048/2048 bytes at offset 1083392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1087488 ++read 2048/2048 bytes at offset 1087488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1091584 ++read 2048/2048 bytes at offset 1091584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1095680 ++read 2048/2048 bytes at offset 1095680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1099776 ++read 2048/2048 bytes at offset 1099776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1103872 ++read 2048/2048 bytes at offset 1103872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1107968 ++read 2048/2048 bytes at offset 1107968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1112064 ++read 2048/2048 bytes at offset 1112064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1116160 ++read 2048/2048 bytes at offset 1116160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1120256 ++read 2048/2048 bytes at offset 1120256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1124352 ++read 2048/2048 bytes at offset 1124352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1128448 ++read 2048/2048 bytes at offset 1128448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1132544 ++read 2048/2048 bytes at offset 1132544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1136640 ++read 2048/2048 bytes at offset 1136640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1140736 ++read 2048/2048 bytes at offset 1140736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1144832 ++read 2048/2048 bytes at offset 1144832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1148928 ++read 2048/2048 bytes at offset 1148928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1153024 ++read 2048/2048 bytes at offset 1153024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1157120 ++read 2048/2048 bytes at offset 1157120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1161216 ++read 2048/2048 bytes at offset 1161216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1165312 ++read 2048/2048 bytes at offset 1165312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1169408 ++read 2048/2048 bytes at offset 1169408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1173504 ++read 2048/2048 bytes at offset 1173504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1177600 ++read 2048/2048 bytes at offset 1177600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1181696 ++read 2048/2048 bytes at offset 1181696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1185792 ++read 2048/2048 bytes at offset 1185792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1189888 ++read 2048/2048 bytes at offset 1189888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1193984 ++read 2048/2048 bytes at offset 1193984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1198080 ++read 2048/2048 bytes at offset 1198080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1202176 ++read 2048/2048 bytes at offset 1202176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1206272 ++read 2048/2048 bytes at offset 1206272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1210368 ++read 2048/2048 bytes at offset 1210368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1214464 ++read 2048/2048 bytes at offset 1214464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1218560 ++read 2048/2048 bytes at offset 1218560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1222656 ++read 2048/2048 bytes at offset 1222656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1226752 ++read 2048/2048 bytes at offset 1226752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1230848 ++read 2048/2048 bytes at offset 1230848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1234944 ++read 2048/2048 bytes at offset 1234944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1239040 ++read 2048/2048 bytes at offset 1239040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1243136 ++read 2048/2048 bytes at offset 1243136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1247232 ++read 2048/2048 bytes at offset 1247232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1251328 ++read 2048/2048 bytes at offset 1251328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1255424 ++read 2048/2048 bytes at offset 1255424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1259520 ++read 2048/2048 bytes at offset 1259520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1263616 ++read 2048/2048 bytes at offset 1263616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1267712 ++read 2048/2048 bytes at offset 1267712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1271808 ++read 2048/2048 bytes at offset 1271808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1275904 ++read 2048/2048 bytes at offset 1275904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1280000 ++read 2048/2048 bytes at offset 1280000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1284096 ++read 2048/2048 bytes at offset 1284096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1288192 ++read 2048/2048 bytes at offset 1288192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1292288 ++read 2048/2048 bytes at offset 1292288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1296384 ++read 2048/2048 bytes at offset 1296384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1300480 ++read 2048/2048 bytes at offset 1300480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1304576 ++read 2048/2048 bytes at offset 1304576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1308672 ++read 2048/2048 bytes at offset 1308672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1312768 ++read 2048/2048 bytes at offset 1312768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1316864 ++read 2048/2048 bytes at offset 1316864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1320960 ++read 2048/2048 bytes at offset 1320960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1325056 ++read 2048/2048 bytes at offset 1325056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1329152 ++read 2048/2048 bytes at offset 1329152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1333248 ++read 2048/2048 bytes at offset 1333248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1337344 ++read 2048/2048 bytes at offset 1337344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1341440 ++read 2048/2048 bytes at offset 1341440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1345536 ++read 2048/2048 bytes at offset 1345536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1349632 ++read 2048/2048 bytes at offset 1349632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1353728 ++read 2048/2048 bytes at offset 1353728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1357824 ++read 2048/2048 bytes at offset 1357824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1361920 ++read 2048/2048 bytes at offset 1361920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1366016 ++read 2048/2048 bytes at offset 1366016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1370112 ++read 2048/2048 bytes at offset 1370112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1374208 ++read 2048/2048 bytes at offset 1374208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1378304 ++read 2048/2048 bytes at offset 1378304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1382400 ++read 2048/2048 bytes at offset 1382400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1386496 ++read 2048/2048 bytes at offset 1386496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1390592 ++read 2048/2048 bytes at offset 1390592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1394688 ++read 2048/2048 bytes at offset 1394688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1398784 ++read 2048/2048 bytes at offset 1398784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1402880 ++read 2048/2048 bytes at offset 1402880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1406976 ++read 2048/2048 bytes at offset 1406976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1411072 ++read 2048/2048 bytes at offset 1411072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1415168 ++read 2048/2048 bytes at offset 1415168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1419264 ++read 2048/2048 bytes at offset 1419264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1423360 ++read 2048/2048 bytes at offset 1423360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1427456 ++read 2048/2048 bytes at offset 1427456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1431552 ++read 2048/2048 bytes at offset 1431552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1435648 ++read 2048/2048 bytes at offset 1435648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1439744 ++read 2048/2048 bytes at offset 1439744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1443840 ++read 2048/2048 bytes at offset 1443840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1447936 ++read 2048/2048 bytes at offset 1447936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1452032 ++read 2048/2048 bytes at offset 1452032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1456128 ++read 2048/2048 bytes at offset 1456128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1460224 ++read 2048/2048 bytes at offset 1460224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1464320 ++read 2048/2048 bytes at offset 1464320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1468416 ++read 2048/2048 bytes at offset 1468416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1472512 ++read 2048/2048 bytes at offset 1472512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1476608 ++read 2048/2048 bytes at offset 1476608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1480704 ++read 2048/2048 bytes at offset 1480704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1484800 ++read 2048/2048 bytes at offset 1484800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1488896 ++read 2048/2048 bytes at offset 1488896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1492992 ++read 2048/2048 bytes at offset 1492992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1497088 ++read 2048/2048 bytes at offset 1497088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1501184 ++read 2048/2048 bytes at offset 1501184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1505280 ++read 2048/2048 bytes at offset 1505280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1509376 ++read 2048/2048 bytes at offset 1509376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1513472 ++read 2048/2048 bytes at offset 1513472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1517568 ++read 2048/2048 bytes at offset 1517568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1521664 ++read 2048/2048 bytes at offset 1521664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1525760 ++read 2048/2048 bytes at offset 1525760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1529856 ++read 2048/2048 bytes at offset 1529856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1533952 ++read 2048/2048 bytes at offset 1533952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1538048 ++read 2048/2048 bytes at offset 1538048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1542144 ++read 2048/2048 bytes at offset 1542144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1546240 ++read 2048/2048 bytes at offset 1546240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1550336 ++read 2048/2048 bytes at offset 1550336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1554432 ++read 2048/2048 bytes at offset 1554432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1558528 ++read 2048/2048 bytes at offset 1558528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1562624 ++read 2048/2048 bytes at offset 1562624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1566720 ++read 2048/2048 bytes at offset 1566720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1570816 ++read 2048/2048 bytes at offset 1570816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1574912 ++read 2048/2048 bytes at offset 1574912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1579008 ++read 2048/2048 bytes at offset 1579008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1583104 ++read 2048/2048 bytes at offset 1583104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1587200 ++read 2048/2048 bytes at offset 1587200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1591296 ++read 2048/2048 bytes at offset 1591296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1595392 ++read 2048/2048 bytes at offset 1595392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1599488 ++read 2048/2048 bytes at offset 1599488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1603584 ++read 2048/2048 bytes at offset 1603584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1607680 ++read 2048/2048 bytes at offset 1607680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1611776 ++read 2048/2048 bytes at offset 1611776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1615872 ++read 2048/2048 bytes at offset 1615872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1619968 ++read 2048/2048 bytes at offset 1619968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1624064 ++read 2048/2048 bytes at offset 1624064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1628160 ++read 2048/2048 bytes at offset 1628160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1632256 ++read 2048/2048 bytes at offset 1632256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1636352 ++read 2048/2048 bytes at offset 1636352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1640448 ++read 2048/2048 bytes at offset 1640448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1644544 ++read 2048/2048 bytes at offset 1644544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1648640 ++read 2048/2048 bytes at offset 1648640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1652736 ++read 2048/2048 bytes at offset 1652736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1656832 ++read 2048/2048 bytes at offset 1656832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1660928 ++read 2048/2048 bytes at offset 1660928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1665024 ++read 2048/2048 bytes at offset 1665024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1669120 ++read 2048/2048 bytes at offset 1669120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1673216 ++read 2048/2048 bytes at offset 1673216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1677312 ++read 2048/2048 bytes at offset 1677312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1681408 ++read 2048/2048 bytes at offset 1681408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1685504 ++read 2048/2048 bytes at offset 1685504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1689600 ++read 2048/2048 bytes at offset 1689600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1693696 ++read 2048/2048 bytes at offset 1693696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1697792 ++read 2048/2048 bytes at offset 1697792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1701888 ++read 2048/2048 bytes at offset 1701888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1705984 ++read 2048/2048 bytes at offset 1705984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1710080 ++read 2048/2048 bytes at offset 1710080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1714176 ++read 2048/2048 bytes at offset 1714176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1718272 ++read 2048/2048 bytes at offset 1718272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1722368 ++read 2048/2048 bytes at offset 1722368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1726464 ++read 2048/2048 bytes at offset 1726464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1730560 ++read 2048/2048 bytes at offset 1730560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1734656 ++read 2048/2048 bytes at offset 1734656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1738752 ++read 2048/2048 bytes at offset 1738752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1742848 ++read 2048/2048 bytes at offset 1742848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1746944 ++read 2048/2048 bytes at offset 1746944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1751040 ++read 2048/2048 bytes at offset 1751040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1755136 ++read 2048/2048 bytes at offset 1755136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1759232 ++read 2048/2048 bytes at offset 1759232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1763328 ++read 2048/2048 bytes at offset 1763328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1767424 ++read 2048/2048 bytes at offset 1767424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1771520 ++read 2048/2048 bytes at offset 1771520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1775616 ++read 2048/2048 bytes at offset 1775616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1779712 ++read 2048/2048 bytes at offset 1779712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1783808 ++read 2048/2048 bytes at offset 1783808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1787904 ++read 2048/2048 bytes at offset 1787904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1792000 ++read 2048/2048 bytes at offset 1792000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1796096 ++read 2048/2048 bytes at offset 1796096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1800192 ++read 2048/2048 bytes at offset 1800192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1804288 ++read 2048/2048 bytes at offset 1804288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1808384 ++read 2048/2048 bytes at offset 1808384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1812480 ++read 2048/2048 bytes at offset 1812480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1816576 ++read 2048/2048 bytes at offset 1816576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1820672 ++read 2048/2048 bytes at offset 1820672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1824768 ++read 2048/2048 bytes at offset 1824768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1828864 ++read 2048/2048 bytes at offset 1828864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1832960 ++read 2048/2048 bytes at offset 1832960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1837056 ++read 2048/2048 bytes at offset 1837056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1841152 ++read 2048/2048 bytes at offset 1841152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1845248 ++read 2048/2048 bytes at offset 1845248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1849344 ++read 2048/2048 bytes at offset 1849344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1853440 ++read 2048/2048 bytes at offset 1853440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1857536 ++read 2048/2048 bytes at offset 1857536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1861632 ++read 2048/2048 bytes at offset 1861632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1865728 ++read 2048/2048 bytes at offset 1865728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1869824 ++read 2048/2048 bytes at offset 1869824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1873920 ++read 2048/2048 bytes at offset 1873920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1878016 ++read 2048/2048 bytes at offset 1878016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1882112 ++read 2048/2048 bytes at offset 1882112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1886208 ++read 2048/2048 bytes at offset 1886208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1890304 ++read 2048/2048 bytes at offset 1890304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1894400 ++read 2048/2048 bytes at offset 1894400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1898496 ++read 2048/2048 bytes at offset 1898496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1902592 ++read 2048/2048 bytes at offset 1902592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1906688 ++read 2048/2048 bytes at offset 1906688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1910784 ++read 2048/2048 bytes at offset 1910784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1914880 ++read 2048/2048 bytes at offset 1914880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1918976 ++read 2048/2048 bytes at offset 1918976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1923072 ++read 2048/2048 bytes at offset 1923072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1927168 ++read 2048/2048 bytes at offset 1927168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1931264 ++read 2048/2048 bytes at offset 1931264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1935360 ++read 2048/2048 bytes at offset 1935360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1939456 ++read 2048/2048 bytes at offset 1939456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1943552 ++read 2048/2048 bytes at offset 1943552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1947648 ++read 2048/2048 bytes at offset 1947648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1951744 ++read 2048/2048 bytes at offset 1951744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1955840 ++read 2048/2048 bytes at offset 1955840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1959936 ++read 2048/2048 bytes at offset 1959936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1964032 ++read 2048/2048 bytes at offset 1964032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1968128 ++read 2048/2048 bytes at offset 1968128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1972224 ++read 2048/2048 bytes at offset 1972224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1976320 ++read 2048/2048 bytes at offset 1976320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1980416 ++read 2048/2048 bytes at offset 1980416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1984512 ++read 2048/2048 bytes at offset 1984512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1988608 ++read 2048/2048 bytes at offset 1988608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1992704 ++read 2048/2048 bytes at offset 1992704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1996800 ++read 2048/2048 bytes at offset 1996800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2000896 ++read 2048/2048 bytes at offset 2000896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2004992 ++read 2048/2048 bytes at offset 2004992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2009088 ++read 2048/2048 bytes at offset 2009088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2013184 ++read 2048/2048 bytes at offset 2013184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2017280 ++read 2048/2048 bytes at offset 2017280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2021376 ++read 2048/2048 bytes at offset 2021376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2025472 ++read 2048/2048 bytes at offset 2025472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2029568 ++read 2048/2048 bytes at offset 2029568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2033664 ++read 2048/2048 bytes at offset 2033664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2037760 ++read 2048/2048 bytes at offset 2037760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2041856 ++read 2048/2048 bytes at offset 2041856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2045952 ++read 2048/2048 bytes at offset 2045952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2050048 ++read 2048/2048 bytes at offset 2050048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2054144 ++read 2048/2048 bytes at offset 2054144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2058240 ++read 2048/2048 bytes at offset 2058240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2062336 ++read 2048/2048 bytes at offset 2062336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2066432 ++read 2048/2048 bytes at offset 2066432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2070528 ++read 2048/2048 bytes at offset 2070528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2074624 ++read 2048/2048 bytes at offset 2074624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2078720 ++read 2048/2048 bytes at offset 2078720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2082816 ++read 2048/2048 bytes at offset 2082816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2086912 ++read 2048/2048 bytes at offset 2086912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2091008 ++read 2048/2048 bytes at offset 2091008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2095104 ++read 2048/2048 bytes at offset 2095104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> read 2048/2048 bytes at offset 2097152 ++=== IO: pattern 0 ++read 2048/2048 bytes at offset 2097152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2101248 ++read 2048/2048 bytes at offset 2101248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2105344 ++read 2048/2048 bytes at offset 2105344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2109440 ++read 2048/2048 bytes at offset 2109440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2113536 ++read 2048/2048 bytes at offset 2113536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2117632 ++read 2048/2048 bytes at offset 2117632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2121728 ++read 2048/2048 bytes at offset 2121728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2125824 ++read 2048/2048 bytes at offset 2125824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2129920 ++read 2048/2048 bytes at offset 2129920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2134016 ++read 2048/2048 bytes at offset 2134016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2138112 ++read 2048/2048 bytes at offset 2138112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2142208 ++read 2048/2048 bytes at offset 2142208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2146304 ++read 2048/2048 bytes at offset 2146304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2150400 ++read 2048/2048 bytes at offset 2150400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2154496 ++read 2048/2048 bytes at offset 2154496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2158592 ++read 2048/2048 bytes at offset 2158592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2162688 ++read 2048/2048 bytes at offset 2162688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2166784 ++read 2048/2048 bytes at offset 2166784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2170880 ++read 2048/2048 bytes at offset 2170880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2174976 ++read 2048/2048 bytes at offset 2174976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2179072 ++read 2048/2048 bytes at offset 2179072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2183168 ++read 2048/2048 bytes at offset 2183168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2187264 ++read 2048/2048 bytes at offset 2187264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2191360 ++read 2048/2048 bytes at offset 2191360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2195456 ++read 2048/2048 bytes at offset 2195456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2199552 ++read 2048/2048 bytes at offset 2199552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2203648 ++read 2048/2048 bytes at offset 2203648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2207744 ++read 2048/2048 bytes at offset 2207744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2211840 ++read 2048/2048 bytes at offset 2211840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2215936 ++read 2048/2048 bytes at offset 2215936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2220032 ++read 2048/2048 bytes at offset 2220032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2224128 ++read 2048/2048 bytes at offset 2224128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2228224 ++read 2048/2048 bytes at offset 2228224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2232320 ++read 2048/2048 bytes at offset 2232320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2236416 ++read 2048/2048 bytes at offset 2236416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2240512 ++read 2048/2048 bytes at offset 2240512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2244608 ++read 2048/2048 bytes at offset 2244608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2248704 ++read 2048/2048 bytes at offset 2248704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2252800 ++read 2048/2048 bytes at offset 2252800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2256896 ++read 2048/2048 bytes at offset 2256896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2260992 ++read 2048/2048 bytes at offset 2260992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2265088 ++read 2048/2048 bytes at offset 2265088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2269184 ++read 2048/2048 bytes at offset 2269184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2273280 ++read 2048/2048 bytes at offset 2273280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2277376 ++read 2048/2048 bytes at offset 2277376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2281472 ++read 2048/2048 bytes at offset 2281472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2285568 ++read 2048/2048 bytes at offset 2285568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2289664 ++read 2048/2048 bytes at offset 2289664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2293760 ++read 2048/2048 bytes at offset 2293760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2297856 ++read 2048/2048 bytes at offset 2297856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2301952 ++read 2048/2048 bytes at offset 2301952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2306048 ++read 2048/2048 bytes at offset 2306048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2310144 ++read 2048/2048 bytes at offset 2310144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2314240 ++read 2048/2048 bytes at offset 2314240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2318336 ++read 2048/2048 bytes at offset 2318336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2322432 ++read 2048/2048 bytes at offset 2322432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2326528 ++read 2048/2048 bytes at offset 2326528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2330624 ++read 2048/2048 bytes at offset 2330624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2334720 ++read 2048/2048 bytes at offset 2334720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2338816 ++read 2048/2048 bytes at offset 2338816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2342912 ++read 2048/2048 bytes at offset 2342912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2347008 ++read 2048/2048 bytes at offset 2347008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2351104 ++read 2048/2048 bytes at offset 2351104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2355200 ++read 2048/2048 bytes at offset 2355200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2359296 ++read 2048/2048 bytes at offset 2359296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2363392 ++read 2048/2048 bytes at offset 2363392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2367488 ++read 2048/2048 bytes at offset 2367488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2371584 ++read 2048/2048 bytes at offset 2371584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2375680 ++read 2048/2048 bytes at offset 2375680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2379776 ++read 2048/2048 bytes at offset 2379776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2383872 ++read 2048/2048 bytes at offset 2383872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2387968 ++read 2048/2048 bytes at offset 2387968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2392064 ++read 2048/2048 bytes at offset 2392064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2396160 ++read 2048/2048 bytes at offset 2396160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2400256 ++read 2048/2048 bytes at offset 2400256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2404352 ++read 2048/2048 bytes at offset 2404352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2408448 ++read 2048/2048 bytes at offset 2408448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2412544 ++read 2048/2048 bytes at offset 2412544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2416640 ++read 2048/2048 bytes at offset 2416640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2420736 ++read 2048/2048 bytes at offset 2420736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2424832 ++read 2048/2048 bytes at offset 2424832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2428928 ++read 2048/2048 bytes at offset 2428928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2433024 ++read 2048/2048 bytes at offset 2433024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2437120 ++read 2048/2048 bytes at offset 2437120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2441216 ++read 2048/2048 bytes at offset 2441216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2445312 ++read 2048/2048 bytes at offset 2445312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2449408 ++read 2048/2048 bytes at offset 2449408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2453504 ++read 2048/2048 bytes at offset 2453504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2457600 ++read 2048/2048 bytes at offset 2457600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2461696 ++read 2048/2048 bytes at offset 2461696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2465792 ++read 2048/2048 bytes at offset 2465792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2469888 ++read 2048/2048 bytes at offset 2469888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2473984 ++read 2048/2048 bytes at offset 2473984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2478080 ++read 2048/2048 bytes at offset 2478080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2482176 ++read 2048/2048 bytes at offset 2482176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2486272 ++read 2048/2048 bytes at offset 2486272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2490368 ++read 2048/2048 bytes at offset 2490368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2494464 ++read 2048/2048 bytes at offset 2494464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2498560 ++read 2048/2048 bytes at offset 2498560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2502656 ++read 2048/2048 bytes at offset 2502656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2506752 ++read 2048/2048 bytes at offset 2506752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2510848 ++read 2048/2048 bytes at offset 2510848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2514944 ++read 2048/2048 bytes at offset 2514944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2519040 ++read 2048/2048 bytes at offset 2519040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2523136 ++read 2048/2048 bytes at offset 2523136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2527232 ++read 2048/2048 bytes at offset 2527232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2531328 ++read 2048/2048 bytes at offset 2531328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2535424 ++read 2048/2048 bytes at offset 2535424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2539520 ++read 2048/2048 bytes at offset 2539520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2543616 ++read 2048/2048 bytes at offset 2543616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2547712 ++read 2048/2048 bytes at offset 2547712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2551808 ++read 2048/2048 bytes at offset 2551808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2555904 ++read 2048/2048 bytes at offset 2555904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2560000 ++read 2048/2048 bytes at offset 2560000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2564096 ++read 2048/2048 bytes at offset 2564096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2568192 ++read 2048/2048 bytes at offset 2568192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2572288 ++read 2048/2048 bytes at offset 2572288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2576384 ++read 2048/2048 bytes at offset 2576384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2580480 ++read 2048/2048 bytes at offset 2580480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2584576 ++read 2048/2048 bytes at offset 2584576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2588672 ++read 2048/2048 bytes at offset 2588672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2592768 ++read 2048/2048 bytes at offset 2592768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2596864 ++read 2048/2048 bytes at offset 2596864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2600960 ++read 2048/2048 bytes at offset 2600960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2605056 ++read 2048/2048 bytes at offset 2605056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2609152 ++read 2048/2048 bytes at offset 2609152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2613248 ++read 2048/2048 bytes at offset 2613248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2617344 ++read 2048/2048 bytes at offset 2617344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2621440 ++read 2048/2048 bytes at offset 2621440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2625536 ++read 2048/2048 bytes at offset 2625536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2629632 ++read 2048/2048 bytes at offset 2629632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2633728 ++read 2048/2048 bytes at offset 2633728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2637824 ++read 2048/2048 bytes at offset 2637824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2641920 ++read 2048/2048 bytes at offset 2641920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2646016 ++read 2048/2048 bytes at offset 2646016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2650112 ++read 2048/2048 bytes at offset 2650112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2654208 ++read 2048/2048 bytes at offset 2654208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2658304 ++read 2048/2048 bytes at offset 2658304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2662400 ++read 2048/2048 bytes at offset 2662400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2666496 ++read 2048/2048 bytes at offset 2666496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2670592 ++read 2048/2048 bytes at offset 2670592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2674688 ++read 2048/2048 bytes at offset 2674688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2678784 ++read 2048/2048 bytes at offset 2678784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2682880 ++read 2048/2048 bytes at offset 2682880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2686976 ++read 2048/2048 bytes at offset 2686976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2691072 ++read 2048/2048 bytes at offset 2691072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2695168 ++read 2048/2048 bytes at offset 2695168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2699264 ++read 2048/2048 bytes at offset 2699264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2703360 ++read 2048/2048 bytes at offset 2703360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2707456 ++read 2048/2048 bytes at offset 2707456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2711552 ++read 2048/2048 bytes at offset 2711552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2715648 ++read 2048/2048 bytes at offset 2715648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2719744 ++read 2048/2048 bytes at offset 2719744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2723840 ++read 2048/2048 bytes at offset 2723840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2727936 ++read 2048/2048 bytes at offset 2727936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2732032 ++read 2048/2048 bytes at offset 2732032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2736128 ++read 2048/2048 bytes at offset 2736128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2740224 ++read 2048/2048 bytes at offset 2740224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2744320 ++read 2048/2048 bytes at offset 2744320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2748416 ++read 2048/2048 bytes at offset 2748416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2752512 ++read 2048/2048 bytes at offset 2752512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2756608 ++read 2048/2048 bytes at offset 2756608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2760704 ++read 2048/2048 bytes at offset 2760704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2764800 ++read 2048/2048 bytes at offset 2764800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2768896 ++read 2048/2048 bytes at offset 2768896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2772992 ++read 2048/2048 bytes at offset 2772992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2777088 ++read 2048/2048 bytes at offset 2777088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2781184 ++read 2048/2048 bytes at offset 2781184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2785280 ++read 2048/2048 bytes at offset 2785280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2789376 ++read 2048/2048 bytes at offset 2789376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2793472 ++read 2048/2048 bytes at offset 2793472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2797568 ++read 2048/2048 bytes at offset 2797568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2801664 ++read 2048/2048 bytes at offset 2801664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2805760 ++read 2048/2048 bytes at offset 2805760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2809856 ++read 2048/2048 bytes at offset 2809856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2813952 ++read 2048/2048 bytes at offset 2813952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2818048 ++read 2048/2048 bytes at offset 2818048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2822144 ++read 2048/2048 bytes at offset 2822144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2826240 ++read 2048/2048 bytes at offset 2826240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2830336 ++read 2048/2048 bytes at offset 2830336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2834432 ++read 2048/2048 bytes at offset 2834432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2838528 ++read 2048/2048 bytes at offset 2838528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2842624 ++read 2048/2048 bytes at offset 2842624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2846720 ++read 2048/2048 bytes at offset 2846720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2850816 ++read 2048/2048 bytes at offset 2850816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2854912 ++read 2048/2048 bytes at offset 2854912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2859008 ++read 2048/2048 bytes at offset 2859008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2863104 ++read 2048/2048 bytes at offset 2863104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2867200 ++read 2048/2048 bytes at offset 2867200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2871296 ++read 2048/2048 bytes at offset 2871296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2875392 ++read 2048/2048 bytes at offset 2875392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2879488 ++read 2048/2048 bytes at offset 2879488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2883584 ++read 2048/2048 bytes at offset 2883584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2887680 ++read 2048/2048 bytes at offset 2887680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2891776 ++read 2048/2048 bytes at offset 2891776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2895872 ++read 2048/2048 bytes at offset 2895872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2899968 ++read 2048/2048 bytes at offset 2899968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2904064 ++read 2048/2048 bytes at offset 2904064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2908160 ++read 2048/2048 bytes at offset 2908160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2912256 ++read 2048/2048 bytes at offset 2912256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2916352 ++read 2048/2048 bytes at offset 2916352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2920448 ++read 2048/2048 bytes at offset 2920448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2924544 ++read 2048/2048 bytes at offset 2924544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2928640 ++read 2048/2048 bytes at offset 2928640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2932736 ++read 2048/2048 bytes at offset 2932736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2936832 ++read 2048/2048 bytes at offset 2936832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2940928 ++read 2048/2048 bytes at offset 2940928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2945024 ++read 2048/2048 bytes at offset 2945024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2949120 ++read 2048/2048 bytes at offset 2949120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2953216 ++read 2048/2048 bytes at offset 2953216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2957312 ++read 2048/2048 bytes at offset 2957312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2961408 ++read 2048/2048 bytes at offset 2961408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2965504 ++read 2048/2048 bytes at offset 2965504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2969600 ++read 2048/2048 bytes at offset 2969600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2973696 ++read 2048/2048 bytes at offset 2973696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2977792 ++read 2048/2048 bytes at offset 2977792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2981888 ++read 2048/2048 bytes at offset 2981888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2985984 ++read 2048/2048 bytes at offset 2985984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2990080 ++read 2048/2048 bytes at offset 2990080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2994176 ++read 2048/2048 bytes at offset 2994176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2998272 ++read 2048/2048 bytes at offset 2998272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3002368 ++read 2048/2048 bytes at offset 3002368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3006464 ++read 2048/2048 bytes at offset 3006464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3010560 ++read 2048/2048 bytes at offset 3010560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3014656 ++read 2048/2048 bytes at offset 3014656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3018752 ++read 2048/2048 bytes at offset 3018752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3022848 ++read 2048/2048 bytes at offset 3022848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3026944 ++read 2048/2048 bytes at offset 3026944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3031040 ++read 2048/2048 bytes at offset 3031040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3035136 ++read 2048/2048 bytes at offset 3035136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3039232 ++read 2048/2048 bytes at offset 3039232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3043328 ++read 2048/2048 bytes at offset 3043328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3047424 ++read 2048/2048 bytes at offset 3047424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3051520 ++read 2048/2048 bytes at offset 3051520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3055616 ++read 2048/2048 bytes at offset 3055616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3059712 ++read 2048/2048 bytes at offset 3059712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3063808 ++read 2048/2048 bytes at offset 3063808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3067904 ++read 2048/2048 bytes at offset 3067904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3072000 ++read 2048/2048 bytes at offset 3072000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3076096 ++read 2048/2048 bytes at offset 3076096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3080192 ++read 2048/2048 bytes at offset 3080192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3084288 ++read 2048/2048 bytes at offset 3084288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3088384 ++read 2048/2048 bytes at offset 3088384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3092480 ++read 2048/2048 bytes at offset 3092480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3096576 ++read 2048/2048 bytes at offset 3096576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3100672 ++read 2048/2048 bytes at offset 3100672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3104768 ++read 2048/2048 bytes at offset 3104768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3108864 ++read 2048/2048 bytes at offset 3108864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3112960 ++read 2048/2048 bytes at offset 3112960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3117056 ++read 2048/2048 bytes at offset 3117056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3121152 ++read 2048/2048 bytes at offset 3121152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3125248 ++read 2048/2048 bytes at offset 3125248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3129344 ++read 2048/2048 bytes at offset 3129344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3133440 ++read 2048/2048 bytes at offset 3133440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3137536 ++read 2048/2048 bytes at offset 3137536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3141632 ++read 2048/2048 bytes at offset 3141632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 2 +-qemu-io> read 2048/2048 bytes at offset 3146752 ++=== IO: pattern 2 ++read 2048/2048 bytes at offset 3146752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3150848 ++read 2048/2048 bytes at offset 3150848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3154944 ++read 2048/2048 bytes at offset 3154944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3159040 ++read 2048/2048 bytes at offset 3159040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3163136 ++read 2048/2048 bytes at offset 3163136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3167232 ++read 2048/2048 bytes at offset 3167232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3171328 ++read 2048/2048 bytes at offset 3171328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3175424 ++read 2048/2048 bytes at offset 3175424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3179520 ++read 2048/2048 bytes at offset 3179520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3183616 ++read 2048/2048 bytes at offset 3183616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3187712 ++read 2048/2048 bytes at offset 3187712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3191808 ++read 2048/2048 bytes at offset 3191808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3195904 ++read 2048/2048 bytes at offset 3195904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3200000 ++read 2048/2048 bytes at offset 3200000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3204096 ++read 2048/2048 bytes at offset 3204096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3208192 ++read 2048/2048 bytes at offset 3208192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3212288 ++read 2048/2048 bytes at offset 3212288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3216384 ++read 2048/2048 bytes at offset 3216384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3220480 ++read 2048/2048 bytes at offset 3220480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3224576 ++read 2048/2048 bytes at offset 3224576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3228672 ++read 2048/2048 bytes at offset 3228672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3232768 ++read 2048/2048 bytes at offset 3232768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3236864 ++read 2048/2048 bytes at offset 3236864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3240960 ++read 2048/2048 bytes at offset 3240960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3245056 ++read 2048/2048 bytes at offset 3245056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3249152 ++read 2048/2048 bytes at offset 3249152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3253248 ++read 2048/2048 bytes at offset 3253248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3257344 ++read 2048/2048 bytes at offset 3257344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3261440 ++read 2048/2048 bytes at offset 3261440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3265536 ++read 2048/2048 bytes at offset 3265536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3269632 ++read 2048/2048 bytes at offset 3269632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3273728 ++read 2048/2048 bytes at offset 3273728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3277824 ++read 2048/2048 bytes at offset 3277824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3281920 ++read 2048/2048 bytes at offset 3281920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3286016 ++read 2048/2048 bytes at offset 3286016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3290112 ++read 2048/2048 bytes at offset 3290112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3294208 ++read 2048/2048 bytes at offset 3294208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3298304 ++read 2048/2048 bytes at offset 3298304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3302400 ++read 2048/2048 bytes at offset 3302400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3306496 ++read 2048/2048 bytes at offset 3306496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3310592 ++read 2048/2048 bytes at offset 3310592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3314688 ++read 2048/2048 bytes at offset 3314688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3318784 ++read 2048/2048 bytes at offset 3318784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3322880 ++read 2048/2048 bytes at offset 3322880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3326976 ++read 2048/2048 bytes at offset 3326976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3331072 ++read 2048/2048 bytes at offset 3331072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3335168 ++read 2048/2048 bytes at offset 3335168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3339264 ++read 2048/2048 bytes at offset 3339264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3343360 ++read 2048/2048 bytes at offset 3343360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3347456 ++read 2048/2048 bytes at offset 3347456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3351552 ++read 2048/2048 bytes at offset 3351552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3355648 ++read 2048/2048 bytes at offset 3355648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3359744 ++read 2048/2048 bytes at offset 3359744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3363840 ++read 2048/2048 bytes at offset 3363840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3367936 ++read 2048/2048 bytes at offset 3367936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3372032 ++read 2048/2048 bytes at offset 3372032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3376128 ++read 2048/2048 bytes at offset 3376128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3380224 ++read 2048/2048 bytes at offset 3380224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3384320 ++read 2048/2048 bytes at offset 3384320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3388416 ++read 2048/2048 bytes at offset 3388416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3392512 ++read 2048/2048 bytes at offset 3392512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3396608 ++read 2048/2048 bytes at offset 3396608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3400704 ++read 2048/2048 bytes at offset 3400704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3404800 ++read 2048/2048 bytes at offset 3404800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3408896 ++read 2048/2048 bytes at offset 3408896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3412992 ++read 2048/2048 bytes at offset 3412992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3417088 ++read 2048/2048 bytes at offset 3417088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3421184 ++read 2048/2048 bytes at offset 3421184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3425280 ++read 2048/2048 bytes at offset 3425280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3429376 ++read 2048/2048 bytes at offset 3429376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3433472 ++read 2048/2048 bytes at offset 3433472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3437568 ++read 2048/2048 bytes at offset 3437568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3441664 ++read 2048/2048 bytes at offset 3441664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3445760 ++read 2048/2048 bytes at offset 3445760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3449856 ++read 2048/2048 bytes at offset 3449856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3453952 ++read 2048/2048 bytes at offset 3453952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3458048 ++read 2048/2048 bytes at offset 3458048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3462144 ++read 2048/2048 bytes at offset 3462144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3466240 ++read 2048/2048 bytes at offset 3466240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3470336 ++read 2048/2048 bytes at offset 3470336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3474432 ++read 2048/2048 bytes at offset 3474432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3478528 ++read 2048/2048 bytes at offset 3478528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3482624 ++read 2048/2048 bytes at offset 3482624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3486720 ++read 2048/2048 bytes at offset 3486720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3490816 ++read 2048/2048 bytes at offset 3490816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3494912 ++read 2048/2048 bytes at offset 3494912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3499008 ++read 2048/2048 bytes at offset 3499008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3503104 ++read 2048/2048 bytes at offset 3503104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3507200 ++read 2048/2048 bytes at offset 3507200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3511296 ++read 2048/2048 bytes at offset 3511296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3515392 ++read 2048/2048 bytes at offset 3515392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3519488 ++read 2048/2048 bytes at offset 3519488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3523584 ++read 2048/2048 bytes at offset 3523584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3527680 ++read 2048/2048 bytes at offset 3527680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3531776 ++read 2048/2048 bytes at offset 3531776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3535872 ++read 2048/2048 bytes at offset 3535872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3539968 ++read 2048/2048 bytes at offset 3539968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3544064 ++read 2048/2048 bytes at offset 3544064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3548160 ++read 2048/2048 bytes at offset 3548160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3552256 ++read 2048/2048 bytes at offset 3552256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3556352 ++read 2048/2048 bytes at offset 3556352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3560448 ++read 2048/2048 bytes at offset 3560448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3564544 ++read 2048/2048 bytes at offset 3564544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3568640 ++read 2048/2048 bytes at offset 3568640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3572736 ++read 2048/2048 bytes at offset 3572736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3576832 ++read 2048/2048 bytes at offset 3576832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3580928 ++read 2048/2048 bytes at offset 3580928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3585024 ++read 2048/2048 bytes at offset 3585024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3589120 ++read 2048/2048 bytes at offset 3589120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3593216 ++read 2048/2048 bytes at offset 3593216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3597312 ++read 2048/2048 bytes at offset 3597312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3601408 ++read 2048/2048 bytes at offset 3601408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3605504 ++read 2048/2048 bytes at offset 3605504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3609600 ++read 2048/2048 bytes at offset 3609600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3613696 ++read 2048/2048 bytes at offset 3613696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3617792 ++read 2048/2048 bytes at offset 3617792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3621888 ++read 2048/2048 bytes at offset 3621888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3625984 ++read 2048/2048 bytes at offset 3625984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3630080 ++read 2048/2048 bytes at offset 3630080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3634176 ++read 2048/2048 bytes at offset 3634176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3638272 ++read 2048/2048 bytes at offset 3638272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3642368 ++read 2048/2048 bytes at offset 3642368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3646464 ++read 2048/2048 bytes at offset 3646464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3650560 ++read 2048/2048 bytes at offset 3650560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3654656 ++read 2048/2048 bytes at offset 3654656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3658752 ++read 2048/2048 bytes at offset 3658752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3662848 ++read 2048/2048 bytes at offset 3662848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3666944 ++read 2048/2048 bytes at offset 3666944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3671040 ++read 2048/2048 bytes at offset 3671040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3675136 ++read 2048/2048 bytes at offset 3675136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3679232 ++read 2048/2048 bytes at offset 3679232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3683328 ++read 2048/2048 bytes at offset 3683328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3687424 ++read 2048/2048 bytes at offset 3687424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3691520 ++read 2048/2048 bytes at offset 3691520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3695616 ++read 2048/2048 bytes at offset 3695616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3699712 ++read 2048/2048 bytes at offset 3699712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3703808 ++read 2048/2048 bytes at offset 3703808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3707904 ++read 2048/2048 bytes at offset 3707904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3712000 ++read 2048/2048 bytes at offset 3712000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3716096 ++read 2048/2048 bytes at offset 3716096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3720192 ++read 2048/2048 bytes at offset 3720192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3724288 ++read 2048/2048 bytes at offset 3724288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3728384 ++read 2048/2048 bytes at offset 3728384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3732480 ++read 2048/2048 bytes at offset 3732480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3736576 ++read 2048/2048 bytes at offset 3736576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3740672 ++read 2048/2048 bytes at offset 3740672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3744768 ++read 2048/2048 bytes at offset 3744768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3748864 ++read 2048/2048 bytes at offset 3748864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3752960 ++read 2048/2048 bytes at offset 3752960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3757056 ++read 2048/2048 bytes at offset 3757056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3761152 ++read 2048/2048 bytes at offset 3761152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3765248 ++read 2048/2048 bytes at offset 3765248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3769344 ++read 2048/2048 bytes at offset 3769344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3773440 ++read 2048/2048 bytes at offset 3773440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3777536 ++read 2048/2048 bytes at offset 3777536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3781632 ++read 2048/2048 bytes at offset 3781632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3785728 ++read 2048/2048 bytes at offset 3785728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3789824 ++read 2048/2048 bytes at offset 3789824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3793920 ++read 2048/2048 bytes at offset 3793920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3798016 ++read 2048/2048 bytes at offset 3798016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3802112 ++read 2048/2048 bytes at offset 3802112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3806208 ++read 2048/2048 bytes at offset 3806208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3810304 ++read 2048/2048 bytes at offset 3810304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3814400 ++read 2048/2048 bytes at offset 3814400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3818496 ++read 2048/2048 bytes at offset 3818496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3822592 ++read 2048/2048 bytes at offset 3822592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3826688 ++read 2048/2048 bytes at offset 3826688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3830784 ++read 2048/2048 bytes at offset 3830784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3834880 ++read 2048/2048 bytes at offset 3834880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3838976 ++read 2048/2048 bytes at offset 3838976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3843072 ++read 2048/2048 bytes at offset 3843072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3847168 ++read 2048/2048 bytes at offset 3847168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3851264 ++read 2048/2048 bytes at offset 3851264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3855360 ++read 2048/2048 bytes at offset 3855360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3859456 ++read 2048/2048 bytes at offset 3859456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3863552 ++read 2048/2048 bytes at offset 3863552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3867648 ++read 2048/2048 bytes at offset 3867648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3871744 ++read 2048/2048 bytes at offset 3871744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3875840 ++read 2048/2048 bytes at offset 3875840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3879936 ++read 2048/2048 bytes at offset 3879936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3884032 ++read 2048/2048 bytes at offset 3884032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3888128 ++read 2048/2048 bytes at offset 3888128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3892224 ++read 2048/2048 bytes at offset 3892224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3896320 ++read 2048/2048 bytes at offset 3896320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3900416 ++read 2048/2048 bytes at offset 3900416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3904512 ++read 2048/2048 bytes at offset 3904512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3908608 ++read 2048/2048 bytes at offset 3908608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3912704 ++read 2048/2048 bytes at offset 3912704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3916800 ++read 2048/2048 bytes at offset 3916800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3920896 ++read 2048/2048 bytes at offset 3920896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3924992 ++read 2048/2048 bytes at offset 3924992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3929088 ++read 2048/2048 bytes at offset 3929088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3933184 ++read 2048/2048 bytes at offset 3933184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3937280 ++read 2048/2048 bytes at offset 3937280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3941376 ++read 2048/2048 bytes at offset 3941376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3945472 ++read 2048/2048 bytes at offset 3945472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3949568 ++read 2048/2048 bytes at offset 3949568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3953664 ++read 2048/2048 bytes at offset 3953664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3957760 ++read 2048/2048 bytes at offset 3957760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3961856 ++read 2048/2048 bytes at offset 3961856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3965952 ++read 2048/2048 bytes at offset 3965952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3970048 ++read 2048/2048 bytes at offset 3970048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3974144 ++read 2048/2048 bytes at offset 3974144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3978240 ++read 2048/2048 bytes at offset 3978240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3982336 ++read 2048/2048 bytes at offset 3982336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3986432 ++read 2048/2048 bytes at offset 3986432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3990528 ++read 2048/2048 bytes at offset 3990528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3994624 ++read 2048/2048 bytes at offset 3994624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3998720 ++read 2048/2048 bytes at offset 3998720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4002816 ++read 2048/2048 bytes at offset 4002816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4006912 ++read 2048/2048 bytes at offset 4006912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4011008 ++read 2048/2048 bytes at offset 4011008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4015104 ++read 2048/2048 bytes at offset 4015104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4019200 ++read 2048/2048 bytes at offset 4019200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4023296 ++read 2048/2048 bytes at offset 4023296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4027392 ++read 2048/2048 bytes at offset 4027392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4031488 ++read 2048/2048 bytes at offset 4031488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4035584 ++read 2048/2048 bytes at offset 4035584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4039680 ++read 2048/2048 bytes at offset 4039680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4043776 ++read 2048/2048 bytes at offset 4043776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4047872 ++read 2048/2048 bytes at offset 4047872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4051968 ++read 2048/2048 bytes at offset 4051968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4056064 ++read 2048/2048 bytes at offset 4056064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4060160 ++read 2048/2048 bytes at offset 4060160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4064256 ++read 2048/2048 bytes at offset 4064256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4068352 ++read 2048/2048 bytes at offset 4068352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4072448 ++read 2048/2048 bytes at offset 4072448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4076544 ++read 2048/2048 bytes at offset 4076544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4080640 ++read 2048/2048 bytes at offset 4080640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4084736 ++read 2048/2048 bytes at offset 4084736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4088832 ++read 2048/2048 bytes at offset 4088832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4092928 ++read 2048/2048 bytes at offset 4092928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4097024 ++read 2048/2048 bytes at offset 4097024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4101120 ++read 2048/2048 bytes at offset 4101120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4105216 ++read 2048/2048 bytes at offset 4105216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4109312 ++read 2048/2048 bytes at offset 4109312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4113408 ++read 2048/2048 bytes at offset 4113408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4117504 ++read 2048/2048 bytes at offset 4117504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4121600 ++read 2048/2048 bytes at offset 4121600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4125696 ++read 2048/2048 bytes at offset 4125696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4129792 ++read 2048/2048 bytes at offset 4129792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4133888 ++read 2048/2048 bytes at offset 4133888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4137984 ++read 2048/2048 bytes at offset 4137984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4142080 ++read 2048/2048 bytes at offset 4142080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4146176 ++read 2048/2048 bytes at offset 4146176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4150272 ++read 2048/2048 bytes at offset 4150272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4154368 ++read 2048/2048 bytes at offset 4154368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4158464 ++read 2048/2048 bytes at offset 4158464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4162560 ++read 2048/2048 bytes at offset 4162560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4166656 ++read 2048/2048 bytes at offset 4166656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4170752 ++read 2048/2048 bytes at offset 4170752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4174848 ++read 2048/2048 bytes at offset 4174848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4178944 ++read 2048/2048 bytes at offset 4178944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4183040 ++read 2048/2048 bytes at offset 4183040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4187136 ++read 2048/2048 bytes at offset 4187136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4191232 ++read 2048/2048 bytes at offset 4191232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 4 +-qemu-io> read 8192/8192 bytes at offset 4196352 ++=== IO: pattern 4 ++read 8192/8192 bytes at offset 4196352 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4208640 ++read 8192/8192 bytes at offset 4208640 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4220928 ++read 8192/8192 bytes at offset 4220928 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4233216 ++read 8192/8192 bytes at offset 4233216 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4245504 ++read 8192/8192 bytes at offset 4245504 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4257792 ++read 8192/8192 bytes at offset 4257792 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4270080 ++read 8192/8192 bytes at offset 4270080 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4282368 ++read 8192/8192 bytes at offset 4282368 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4294656 ++read 8192/8192 bytes at offset 4294656 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4306944 ++read 8192/8192 bytes at offset 4306944 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4319232 ++read 8192/8192 bytes at offset 4319232 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4331520 ++read 8192/8192 bytes at offset 4331520 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4343808 ++read 8192/8192 bytes at offset 4343808 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4356096 ++read 8192/8192 bytes at offset 4356096 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4368384 ++read 8192/8192 bytes at offset 4368384 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4380672 ++read 8192/8192 bytes at offset 4380672 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4392960 ++read 8192/8192 bytes at offset 4392960 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4405248 ++read 8192/8192 bytes at offset 4405248 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4417536 ++read 8192/8192 bytes at offset 4417536 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4429824 ++read 8192/8192 bytes at offset 4429824 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4442112 ++read 8192/8192 bytes at offset 4442112 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4454400 ++read 8192/8192 bytes at offset 4454400 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4466688 ++read 8192/8192 bytes at offset 4466688 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4478976 ++read 8192/8192 bytes at offset 4478976 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4491264 ++read 8192/8192 bytes at offset 4491264 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4503552 ++read 8192/8192 bytes at offset 4503552 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4515840 ++read 8192/8192 bytes at offset 4515840 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4528128 ++read 8192/8192 bytes at offset 4528128 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4540416 ++read 8192/8192 bytes at offset 4540416 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4552704 ++read 8192/8192 bytes at offset 4552704 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4564992 ++read 8192/8192 bytes at offset 4564992 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4577280 ++read 8192/8192 bytes at offset 4577280 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4589568 ++read 8192/8192 bytes at offset 4589568 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4601856 ++read 8192/8192 bytes at offset 4601856 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4614144 ++read 8192/8192 bytes at offset 4614144 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4626432 ++read 8192/8192 bytes at offset 4626432 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4638720 ++read 8192/8192 bytes at offset 4638720 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4651008 ++read 8192/8192 bytes at offset 4651008 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4663296 ++read 8192/8192 bytes at offset 4663296 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4675584 ++read 8192/8192 bytes at offset 4675584 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4687872 ++read 8192/8192 bytes at offset 4687872 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4700160 ++read 8192/8192 bytes at offset 4700160 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4712448 ++read 8192/8192 bytes at offset 4712448 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4724736 ++read 8192/8192 bytes at offset 4724736 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4737024 ++read 8192/8192 bytes at offset 4737024 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4749312 ++read 8192/8192 bytes at offset 4749312 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4761600 ++read 8192/8192 bytes at offset 4761600 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4773888 ++read 8192/8192 bytes at offset 4773888 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4786176 ++read 8192/8192 bytes at offset 4786176 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4798464 ++read 8192/8192 bytes at offset 4798464 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4810752 ++read 8192/8192 bytes at offset 4810752 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4823040 ++read 8192/8192 bytes at offset 4823040 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4835328 ++read 8192/8192 bytes at offset 4835328 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4847616 ++read 8192/8192 bytes at offset 4847616 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4859904 ++read 8192/8192 bytes at offset 4859904 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4872192 ++read 8192/8192 bytes at offset 4872192 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4884480 ++read 8192/8192 bytes at offset 4884480 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4896768 ++read 8192/8192 bytes at offset 4896768 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4909056 ++read 8192/8192 bytes at offset 4909056 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4921344 ++read 8192/8192 bytes at offset 4921344 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4933632 ++read 8192/8192 bytes at offset 4933632 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4945920 ++read 8192/8192 bytes at offset 4945920 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4958208 ++read 8192/8192 bytes at offset 4958208 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4970496 ++read 8192/8192 bytes at offset 4970496 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 244 +-qemu-io> read 12288/12288 bytes at offset 6285312 ++=== IO: pattern 244 ++read 12288/12288 bytes at offset 6285312 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 8384512 ++read 12288/12288 bytes at offset 8384512 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 10483712 ++read 12288/12288 bytes at offset 10483712 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 12582912 ++read 12288/12288 bytes at offset 12582912 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 14682112 ++read 12288/12288 bytes at offset 14682112 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 16781312 ++read 12288/12288 bytes at offset 16781312 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 18880512 ++read 12288/12288 bytes at offset 18880512 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 20979712 ++read 12288/12288 bytes at offset 20979712 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> No errors were found on the image. ++No errors were found on the image. + With snapshot test1, offset 4294967296 + === IO: pattern 0 +-qemu-io> wrote 4096/4096 bytes at offset 4294967296 ++wrote 4096/4096 bytes at offset 4294967296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4294971392 ++wrote 4096/4096 bytes at offset 4294971392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4294975488 ++wrote 4096/4096 bytes at offset 4294975488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4294979584 ++wrote 4096/4096 bytes at offset 4294979584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4294983680 ++wrote 4096/4096 bytes at offset 4294983680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4294987776 ++wrote 4096/4096 bytes at offset 4294987776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4294991872 ++wrote 4096/4096 bytes at offset 4294991872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4294995968 ++wrote 4096/4096 bytes at offset 4294995968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295000064 ++wrote 4096/4096 bytes at offset 4295000064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295004160 ++wrote 4096/4096 bytes at offset 4295004160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295008256 ++wrote 4096/4096 bytes at offset 4295008256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295012352 ++wrote 4096/4096 bytes at offset 4295012352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295016448 ++wrote 4096/4096 bytes at offset 4295016448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295020544 ++wrote 4096/4096 bytes at offset 4295020544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295024640 ++wrote 4096/4096 bytes at offset 4295024640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295028736 ++wrote 4096/4096 bytes at offset 4295028736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295032832 ++wrote 4096/4096 bytes at offset 4295032832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295036928 ++wrote 4096/4096 bytes at offset 4295036928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295041024 ++wrote 4096/4096 bytes at offset 4295041024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295045120 ++wrote 4096/4096 bytes at offset 4295045120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295049216 ++wrote 4096/4096 bytes at offset 4295049216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295053312 ++wrote 4096/4096 bytes at offset 4295053312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295057408 ++wrote 4096/4096 bytes at offset 4295057408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295061504 ++wrote 4096/4096 bytes at offset 4295061504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295065600 ++wrote 4096/4096 bytes at offset 4295065600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295069696 ++wrote 4096/4096 bytes at offset 4295069696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295073792 ++wrote 4096/4096 bytes at offset 4295073792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295077888 ++wrote 4096/4096 bytes at offset 4295077888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295081984 ++wrote 4096/4096 bytes at offset 4295081984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295086080 ++wrote 4096/4096 bytes at offset 4295086080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295090176 ++wrote 4096/4096 bytes at offset 4295090176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295094272 ++wrote 4096/4096 bytes at offset 4295094272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295098368 ++wrote 4096/4096 bytes at offset 4295098368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295102464 ++wrote 4096/4096 bytes at offset 4295102464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295106560 ++wrote 4096/4096 bytes at offset 4295106560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295110656 ++wrote 4096/4096 bytes at offset 4295110656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295114752 ++wrote 4096/4096 bytes at offset 4295114752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295118848 ++wrote 4096/4096 bytes at offset 4295118848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295122944 ++wrote 4096/4096 bytes at offset 4295122944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295127040 ++wrote 4096/4096 bytes at offset 4295127040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295131136 ++wrote 4096/4096 bytes at offset 4295131136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295135232 ++wrote 4096/4096 bytes at offset 4295135232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295139328 ++wrote 4096/4096 bytes at offset 4295139328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295143424 ++wrote 4096/4096 bytes at offset 4295143424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295147520 ++wrote 4096/4096 bytes at offset 4295147520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295151616 ++wrote 4096/4096 bytes at offset 4295151616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295155712 ++wrote 4096/4096 bytes at offset 4295155712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295159808 ++wrote 4096/4096 bytes at offset 4295159808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295163904 ++wrote 4096/4096 bytes at offset 4295163904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295168000 ++wrote 4096/4096 bytes at offset 4295168000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295172096 ++wrote 4096/4096 bytes at offset 4295172096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295176192 ++wrote 4096/4096 bytes at offset 4295176192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295180288 ++wrote 4096/4096 bytes at offset 4295180288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295184384 ++wrote 4096/4096 bytes at offset 4295184384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295188480 ++wrote 4096/4096 bytes at offset 4295188480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295192576 ++wrote 4096/4096 bytes at offset 4295192576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295196672 ++wrote 4096/4096 bytes at offset 4295196672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295200768 ++wrote 4096/4096 bytes at offset 4295200768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295204864 ++wrote 4096/4096 bytes at offset 4295204864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295208960 ++wrote 4096/4096 bytes at offset 4295208960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295213056 ++wrote 4096/4096 bytes at offset 4295213056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295217152 ++wrote 4096/4096 bytes at offset 4295217152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295221248 ++wrote 4096/4096 bytes at offset 4295221248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295225344 ++wrote 4096/4096 bytes at offset 4295225344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295229440 ++wrote 4096/4096 bytes at offset 4295229440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295233536 ++wrote 4096/4096 bytes at offset 4295233536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295237632 ++wrote 4096/4096 bytes at offset 4295237632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295241728 ++wrote 4096/4096 bytes at offset 4295241728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295245824 ++wrote 4096/4096 bytes at offset 4295245824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295249920 ++wrote 4096/4096 bytes at offset 4295249920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295254016 ++wrote 4096/4096 bytes at offset 4295254016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295258112 ++wrote 4096/4096 bytes at offset 4295258112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295262208 ++wrote 4096/4096 bytes at offset 4295262208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295266304 ++wrote 4096/4096 bytes at offset 4295266304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295270400 ++wrote 4096/4096 bytes at offset 4295270400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295274496 ++wrote 4096/4096 bytes at offset 4295274496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295278592 ++wrote 4096/4096 bytes at offset 4295278592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295282688 ++wrote 4096/4096 bytes at offset 4295282688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295286784 ++wrote 4096/4096 bytes at offset 4295286784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295290880 ++wrote 4096/4096 bytes at offset 4295290880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295294976 ++wrote 4096/4096 bytes at offset 4295294976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295299072 ++wrote 4096/4096 bytes at offset 4295299072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295303168 ++wrote 4096/4096 bytes at offset 4295303168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295307264 ++wrote 4096/4096 bytes at offset 4295307264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295311360 ++wrote 4096/4096 bytes at offset 4295311360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295315456 ++wrote 4096/4096 bytes at offset 4295315456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295319552 ++wrote 4096/4096 bytes at offset 4295319552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295323648 ++wrote 4096/4096 bytes at offset 4295323648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295327744 ++wrote 4096/4096 bytes at offset 4295327744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295331840 ++wrote 4096/4096 bytes at offset 4295331840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295335936 ++wrote 4096/4096 bytes at offset 4295335936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295340032 ++wrote 4096/4096 bytes at offset 4295340032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295344128 ++wrote 4096/4096 bytes at offset 4295344128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295348224 ++wrote 4096/4096 bytes at offset 4295348224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295352320 ++wrote 4096/4096 bytes at offset 4295352320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295356416 ++wrote 4096/4096 bytes at offset 4295356416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295360512 ++wrote 4096/4096 bytes at offset 4295360512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295364608 ++wrote 4096/4096 bytes at offset 4295364608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295368704 ++wrote 4096/4096 bytes at offset 4295368704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295372800 ++wrote 4096/4096 bytes at offset 4295372800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295376896 ++wrote 4096/4096 bytes at offset 4295376896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295380992 ++wrote 4096/4096 bytes at offset 4295380992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295385088 ++wrote 4096/4096 bytes at offset 4295385088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295389184 ++wrote 4096/4096 bytes at offset 4295389184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295393280 ++wrote 4096/4096 bytes at offset 4295393280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295397376 ++wrote 4096/4096 bytes at offset 4295397376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295401472 ++wrote 4096/4096 bytes at offset 4295401472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295405568 ++wrote 4096/4096 bytes at offset 4295405568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295409664 ++wrote 4096/4096 bytes at offset 4295409664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295413760 ++wrote 4096/4096 bytes at offset 4295413760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295417856 ++wrote 4096/4096 bytes at offset 4295417856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295421952 ++wrote 4096/4096 bytes at offset 4295421952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295426048 ++wrote 4096/4096 bytes at offset 4295426048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295430144 ++wrote 4096/4096 bytes at offset 4295430144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295434240 ++wrote 4096/4096 bytes at offset 4295434240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295438336 ++wrote 4096/4096 bytes at offset 4295438336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295442432 ++wrote 4096/4096 bytes at offset 4295442432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295446528 ++wrote 4096/4096 bytes at offset 4295446528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295450624 ++wrote 4096/4096 bytes at offset 4295450624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295454720 ++wrote 4096/4096 bytes at offset 4295454720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295458816 ++wrote 4096/4096 bytes at offset 4295458816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295462912 ++wrote 4096/4096 bytes at offset 4295462912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295467008 ++wrote 4096/4096 bytes at offset 4295467008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295471104 ++wrote 4096/4096 bytes at offset 4295471104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295475200 ++wrote 4096/4096 bytes at offset 4295475200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295479296 ++wrote 4096/4096 bytes at offset 4295479296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295483392 ++wrote 4096/4096 bytes at offset 4295483392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295487488 ++wrote 4096/4096 bytes at offset 4295487488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295491584 ++wrote 4096/4096 bytes at offset 4295491584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295495680 ++wrote 4096/4096 bytes at offset 4295495680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295499776 ++wrote 4096/4096 bytes at offset 4295499776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295503872 ++wrote 4096/4096 bytes at offset 4295503872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295507968 ++wrote 4096/4096 bytes at offset 4295507968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295512064 ++wrote 4096/4096 bytes at offset 4295512064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295516160 ++wrote 4096/4096 bytes at offset 4295516160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295520256 ++wrote 4096/4096 bytes at offset 4295520256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295524352 ++wrote 4096/4096 bytes at offset 4295524352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295528448 ++wrote 4096/4096 bytes at offset 4295528448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295532544 ++wrote 4096/4096 bytes at offset 4295532544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295536640 ++wrote 4096/4096 bytes at offset 4295536640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295540736 ++wrote 4096/4096 bytes at offset 4295540736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295544832 ++wrote 4096/4096 bytes at offset 4295544832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295548928 ++wrote 4096/4096 bytes at offset 4295548928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295553024 ++wrote 4096/4096 bytes at offset 4295553024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295557120 ++wrote 4096/4096 bytes at offset 4295557120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295561216 ++wrote 4096/4096 bytes at offset 4295561216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295565312 ++wrote 4096/4096 bytes at offset 4295565312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295569408 ++wrote 4096/4096 bytes at offset 4295569408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295573504 ++wrote 4096/4096 bytes at offset 4295573504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295577600 ++wrote 4096/4096 bytes at offset 4295577600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295581696 ++wrote 4096/4096 bytes at offset 4295581696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295585792 ++wrote 4096/4096 bytes at offset 4295585792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295589888 ++wrote 4096/4096 bytes at offset 4295589888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295593984 ++wrote 4096/4096 bytes at offset 4295593984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295598080 ++wrote 4096/4096 bytes at offset 4295598080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295602176 ++wrote 4096/4096 bytes at offset 4295602176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295606272 ++wrote 4096/4096 bytes at offset 4295606272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295610368 ++wrote 4096/4096 bytes at offset 4295610368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295614464 ++wrote 4096/4096 bytes at offset 4295614464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295618560 ++wrote 4096/4096 bytes at offset 4295618560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295622656 ++wrote 4096/4096 bytes at offset 4295622656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295626752 ++wrote 4096/4096 bytes at offset 4295626752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295630848 ++wrote 4096/4096 bytes at offset 4295630848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295634944 ++wrote 4096/4096 bytes at offset 4295634944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295639040 ++wrote 4096/4096 bytes at offset 4295639040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295643136 ++wrote 4096/4096 bytes at offset 4295643136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295647232 ++wrote 4096/4096 bytes at offset 4295647232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295651328 ++wrote 4096/4096 bytes at offset 4295651328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295655424 ++wrote 4096/4096 bytes at offset 4295655424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295659520 ++wrote 4096/4096 bytes at offset 4295659520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295663616 ++wrote 4096/4096 bytes at offset 4295663616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295667712 ++wrote 4096/4096 bytes at offset 4295667712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295671808 ++wrote 4096/4096 bytes at offset 4295671808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295675904 ++wrote 4096/4096 bytes at offset 4295675904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295680000 ++wrote 4096/4096 bytes at offset 4295680000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295684096 ++wrote 4096/4096 bytes at offset 4295684096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295688192 ++wrote 4096/4096 bytes at offset 4295688192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295692288 ++wrote 4096/4096 bytes at offset 4295692288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295696384 ++wrote 4096/4096 bytes at offset 4295696384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295700480 ++wrote 4096/4096 bytes at offset 4295700480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295704576 ++wrote 4096/4096 bytes at offset 4295704576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295708672 ++wrote 4096/4096 bytes at offset 4295708672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295712768 ++wrote 4096/4096 bytes at offset 4295712768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295716864 ++wrote 4096/4096 bytes at offset 4295716864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295720960 ++wrote 4096/4096 bytes at offset 4295720960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295725056 ++wrote 4096/4096 bytes at offset 4295725056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295729152 ++wrote 4096/4096 bytes at offset 4295729152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295733248 ++wrote 4096/4096 bytes at offset 4295733248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295737344 ++wrote 4096/4096 bytes at offset 4295737344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295741440 ++wrote 4096/4096 bytes at offset 4295741440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295745536 ++wrote 4096/4096 bytes at offset 4295745536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295749632 ++wrote 4096/4096 bytes at offset 4295749632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295753728 ++wrote 4096/4096 bytes at offset 4295753728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295757824 ++wrote 4096/4096 bytes at offset 4295757824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295761920 ++wrote 4096/4096 bytes at offset 4295761920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295766016 ++wrote 4096/4096 bytes at offset 4295766016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295770112 ++wrote 4096/4096 bytes at offset 4295770112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295774208 ++wrote 4096/4096 bytes at offset 4295774208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295778304 ++wrote 4096/4096 bytes at offset 4295778304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295782400 ++wrote 4096/4096 bytes at offset 4295782400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295786496 ++wrote 4096/4096 bytes at offset 4295786496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295790592 ++wrote 4096/4096 bytes at offset 4295790592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295794688 ++wrote 4096/4096 bytes at offset 4295794688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295798784 ++wrote 4096/4096 bytes at offset 4295798784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295802880 ++wrote 4096/4096 bytes at offset 4295802880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295806976 ++wrote 4096/4096 bytes at offset 4295806976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295811072 ++wrote 4096/4096 bytes at offset 4295811072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295815168 ++wrote 4096/4096 bytes at offset 4295815168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295819264 ++wrote 4096/4096 bytes at offset 4295819264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295823360 ++wrote 4096/4096 bytes at offset 4295823360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295827456 ++wrote 4096/4096 bytes at offset 4295827456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295831552 ++wrote 4096/4096 bytes at offset 4295831552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295835648 ++wrote 4096/4096 bytes at offset 4295835648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295839744 ++wrote 4096/4096 bytes at offset 4295839744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295843840 ++wrote 4096/4096 bytes at offset 4295843840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295847936 ++wrote 4096/4096 bytes at offset 4295847936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295852032 ++wrote 4096/4096 bytes at offset 4295852032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295856128 ++wrote 4096/4096 bytes at offset 4295856128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295860224 ++wrote 4096/4096 bytes at offset 4295860224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295864320 ++wrote 4096/4096 bytes at offset 4295864320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295868416 ++wrote 4096/4096 bytes at offset 4295868416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295872512 ++wrote 4096/4096 bytes at offset 4295872512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295876608 ++wrote 4096/4096 bytes at offset 4295876608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295880704 ++wrote 4096/4096 bytes at offset 4295880704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295884800 ++wrote 4096/4096 bytes at offset 4295884800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295888896 ++wrote 4096/4096 bytes at offset 4295888896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295892992 ++wrote 4096/4096 bytes at offset 4295892992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295897088 ++wrote 4096/4096 bytes at offset 4295897088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295901184 ++wrote 4096/4096 bytes at offset 4295901184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295905280 ++wrote 4096/4096 bytes at offset 4295905280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295909376 ++wrote 4096/4096 bytes at offset 4295909376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295913472 ++wrote 4096/4096 bytes at offset 4295913472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295917568 ++wrote 4096/4096 bytes at offset 4295917568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295921664 ++wrote 4096/4096 bytes at offset 4295921664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295925760 ++wrote 4096/4096 bytes at offset 4295925760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295929856 ++wrote 4096/4096 bytes at offset 4295929856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295933952 ++wrote 4096/4096 bytes at offset 4295933952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295938048 ++wrote 4096/4096 bytes at offset 4295938048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295942144 ++wrote 4096/4096 bytes at offset 4295942144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295946240 ++wrote 4096/4096 bytes at offset 4295946240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295950336 ++wrote 4096/4096 bytes at offset 4295950336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295954432 ++wrote 4096/4096 bytes at offset 4295954432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295958528 ++wrote 4096/4096 bytes at offset 4295958528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295962624 ++wrote 4096/4096 bytes at offset 4295962624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295966720 ++wrote 4096/4096 bytes at offset 4295966720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295970816 ++wrote 4096/4096 bytes at offset 4295970816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295974912 ++wrote 4096/4096 bytes at offset 4295974912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295979008 ++wrote 4096/4096 bytes at offset 4295979008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295983104 ++wrote 4096/4096 bytes at offset 4295983104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295987200 ++wrote 4096/4096 bytes at offset 4295987200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295991296 ++wrote 4096/4096 bytes at offset 4295991296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295995392 ++wrote 4096/4096 bytes at offset 4295995392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295999488 ++wrote 4096/4096 bytes at offset 4295999488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296003584 ++wrote 4096/4096 bytes at offset 4296003584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296007680 ++wrote 4096/4096 bytes at offset 4296007680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296011776 ++wrote 4096/4096 bytes at offset 4296011776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 4 +-qemu-io> wrote 2048/2048 bytes at offset 4296017920 ++=== IO: pattern 4 ++wrote 2048/2048 bytes at offset 4296017920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296022016 ++wrote 2048/2048 bytes at offset 4296022016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296026112 ++wrote 2048/2048 bytes at offset 4296026112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296030208 ++wrote 2048/2048 bytes at offset 4296030208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296034304 ++wrote 2048/2048 bytes at offset 4296034304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296038400 ++wrote 2048/2048 bytes at offset 4296038400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296042496 ++wrote 2048/2048 bytes at offset 4296042496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296046592 ++wrote 2048/2048 bytes at offset 4296046592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296050688 ++wrote 2048/2048 bytes at offset 4296050688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296054784 ++wrote 2048/2048 bytes at offset 4296054784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296058880 ++wrote 2048/2048 bytes at offset 4296058880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296062976 ++wrote 2048/2048 bytes at offset 4296062976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296067072 ++wrote 2048/2048 bytes at offset 4296067072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296071168 ++wrote 2048/2048 bytes at offset 4296071168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296075264 ++wrote 2048/2048 bytes at offset 4296075264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296079360 ++wrote 2048/2048 bytes at offset 4296079360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296083456 ++wrote 2048/2048 bytes at offset 4296083456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296087552 ++wrote 2048/2048 bytes at offset 4296087552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296091648 ++wrote 2048/2048 bytes at offset 4296091648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296095744 ++wrote 2048/2048 bytes at offset 4296095744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296099840 ++wrote 2048/2048 bytes at offset 4296099840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296103936 ++wrote 2048/2048 bytes at offset 4296103936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296108032 ++wrote 2048/2048 bytes at offset 4296108032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296112128 ++wrote 2048/2048 bytes at offset 4296112128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296116224 ++wrote 2048/2048 bytes at offset 4296116224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296120320 ++wrote 2048/2048 bytes at offset 4296120320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296124416 ++wrote 2048/2048 bytes at offset 4296124416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296128512 ++wrote 2048/2048 bytes at offset 4296128512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296132608 ++wrote 2048/2048 bytes at offset 4296132608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296136704 ++wrote 2048/2048 bytes at offset 4296136704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296140800 ++wrote 2048/2048 bytes at offset 4296140800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296144896 ++wrote 2048/2048 bytes at offset 4296144896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296148992 ++wrote 2048/2048 bytes at offset 4296148992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296153088 ++wrote 2048/2048 bytes at offset 4296153088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296157184 ++wrote 2048/2048 bytes at offset 4296157184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296161280 ++wrote 2048/2048 bytes at offset 4296161280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296165376 ++wrote 2048/2048 bytes at offset 4296165376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296169472 ++wrote 2048/2048 bytes at offset 4296169472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296173568 ++wrote 2048/2048 bytes at offset 4296173568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296177664 ++wrote 2048/2048 bytes at offset 4296177664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296181760 ++wrote 2048/2048 bytes at offset 4296181760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296185856 ++wrote 2048/2048 bytes at offset 4296185856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296189952 ++wrote 2048/2048 bytes at offset 4296189952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296194048 ++wrote 2048/2048 bytes at offset 4296194048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296198144 ++wrote 2048/2048 bytes at offset 4296198144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296202240 ++wrote 2048/2048 bytes at offset 4296202240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296206336 ++wrote 2048/2048 bytes at offset 4296206336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296210432 ++wrote 2048/2048 bytes at offset 4296210432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296214528 ++wrote 2048/2048 bytes at offset 4296214528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296218624 ++wrote 2048/2048 bytes at offset 4296218624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296222720 ++wrote 2048/2048 bytes at offset 4296222720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296226816 ++wrote 2048/2048 bytes at offset 4296226816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296230912 ++wrote 2048/2048 bytes at offset 4296230912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296235008 ++wrote 2048/2048 bytes at offset 4296235008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296239104 ++wrote 2048/2048 bytes at offset 4296239104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296243200 ++wrote 2048/2048 bytes at offset 4296243200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296247296 ++wrote 2048/2048 bytes at offset 4296247296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296251392 ++wrote 2048/2048 bytes at offset 4296251392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296255488 ++wrote 2048/2048 bytes at offset 4296255488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296259584 ++wrote 2048/2048 bytes at offset 4296259584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296263680 ++wrote 2048/2048 bytes at offset 4296263680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296267776 ++wrote 2048/2048 bytes at offset 4296267776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296271872 ++wrote 2048/2048 bytes at offset 4296271872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296275968 ++wrote 2048/2048 bytes at offset 4296275968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296280064 ++wrote 2048/2048 bytes at offset 4296280064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296284160 ++wrote 2048/2048 bytes at offset 4296284160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296288256 ++wrote 2048/2048 bytes at offset 4296288256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296292352 ++wrote 2048/2048 bytes at offset 4296292352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296296448 ++wrote 2048/2048 bytes at offset 4296296448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296300544 ++wrote 2048/2048 bytes at offset 4296300544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296304640 ++wrote 2048/2048 bytes at offset 4296304640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296308736 ++wrote 2048/2048 bytes at offset 4296308736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296312832 ++wrote 2048/2048 bytes at offset 4296312832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296316928 ++wrote 2048/2048 bytes at offset 4296316928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296321024 ++wrote 2048/2048 bytes at offset 4296321024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296325120 ++wrote 2048/2048 bytes at offset 4296325120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296329216 ++wrote 2048/2048 bytes at offset 4296329216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296333312 ++wrote 2048/2048 bytes at offset 4296333312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296337408 ++wrote 2048/2048 bytes at offset 4296337408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296341504 ++wrote 2048/2048 bytes at offset 4296341504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296345600 ++wrote 2048/2048 bytes at offset 4296345600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296349696 ++wrote 2048/2048 bytes at offset 4296349696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296353792 ++wrote 2048/2048 bytes at offset 4296353792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296357888 ++wrote 2048/2048 bytes at offset 4296357888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296361984 ++wrote 2048/2048 bytes at offset 4296361984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296366080 ++wrote 2048/2048 bytes at offset 4296366080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296370176 ++wrote 2048/2048 bytes at offset 4296370176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296374272 ++wrote 2048/2048 bytes at offset 4296374272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296378368 ++wrote 2048/2048 bytes at offset 4296378368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296382464 ++wrote 2048/2048 bytes at offset 4296382464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296386560 ++wrote 2048/2048 bytes at offset 4296386560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296390656 ++wrote 2048/2048 bytes at offset 4296390656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296394752 ++wrote 2048/2048 bytes at offset 4296394752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296398848 ++wrote 2048/2048 bytes at offset 4296398848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296402944 ++wrote 2048/2048 bytes at offset 4296402944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296407040 ++wrote 2048/2048 bytes at offset 4296407040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296411136 ++wrote 2048/2048 bytes at offset 4296411136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296415232 ++wrote 2048/2048 bytes at offset 4296415232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296419328 ++wrote 2048/2048 bytes at offset 4296419328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296423424 ++wrote 2048/2048 bytes at offset 4296423424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296427520 ++wrote 2048/2048 bytes at offset 4296427520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296431616 ++wrote 2048/2048 bytes at offset 4296431616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296435712 ++wrote 2048/2048 bytes at offset 4296435712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296439808 ++wrote 2048/2048 bytes at offset 4296439808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296443904 ++wrote 2048/2048 bytes at offset 4296443904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296448000 ++wrote 2048/2048 bytes at offset 4296448000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296452096 ++wrote 2048/2048 bytes at offset 4296452096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296456192 ++wrote 2048/2048 bytes at offset 4296456192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296460288 ++wrote 2048/2048 bytes at offset 4296460288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296464384 ++wrote 2048/2048 bytes at offset 4296464384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296468480 ++wrote 2048/2048 bytes at offset 4296468480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296472576 ++wrote 2048/2048 bytes at offset 4296472576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296476672 ++wrote 2048/2048 bytes at offset 4296476672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296480768 ++wrote 2048/2048 bytes at offset 4296480768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296484864 ++wrote 2048/2048 bytes at offset 4296484864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296488960 ++wrote 2048/2048 bytes at offset 4296488960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296493056 ++wrote 2048/2048 bytes at offset 4296493056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296497152 ++wrote 2048/2048 bytes at offset 4296497152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296501248 ++wrote 2048/2048 bytes at offset 4296501248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296505344 ++wrote 2048/2048 bytes at offset 4296505344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296509440 ++wrote 2048/2048 bytes at offset 4296509440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296513536 ++wrote 2048/2048 bytes at offset 4296513536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296517632 ++wrote 2048/2048 bytes at offset 4296517632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296521728 ++wrote 2048/2048 bytes at offset 4296521728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296525824 ++wrote 2048/2048 bytes at offset 4296525824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296529920 ++wrote 2048/2048 bytes at offset 4296529920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296534016 ++wrote 2048/2048 bytes at offset 4296534016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296538112 ++wrote 2048/2048 bytes at offset 4296538112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296542208 ++wrote 2048/2048 bytes at offset 4296542208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296546304 ++wrote 2048/2048 bytes at offset 4296546304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296550400 ++wrote 2048/2048 bytes at offset 4296550400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296554496 ++wrote 2048/2048 bytes at offset 4296554496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296558592 ++wrote 2048/2048 bytes at offset 4296558592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296562688 ++wrote 2048/2048 bytes at offset 4296562688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296566784 ++wrote 2048/2048 bytes at offset 4296566784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296570880 ++wrote 2048/2048 bytes at offset 4296570880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296574976 ++wrote 2048/2048 bytes at offset 4296574976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296579072 ++wrote 2048/2048 bytes at offset 4296579072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296583168 ++wrote 2048/2048 bytes at offset 4296583168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296587264 ++wrote 2048/2048 bytes at offset 4296587264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296591360 ++wrote 2048/2048 bytes at offset 4296591360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296595456 ++wrote 2048/2048 bytes at offset 4296595456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296599552 ++wrote 2048/2048 bytes at offset 4296599552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296603648 ++wrote 2048/2048 bytes at offset 4296603648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296607744 ++wrote 2048/2048 bytes at offset 4296607744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296611840 ++wrote 2048/2048 bytes at offset 4296611840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296615936 ++wrote 2048/2048 bytes at offset 4296615936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296620032 ++wrote 2048/2048 bytes at offset 4296620032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296624128 ++wrote 2048/2048 bytes at offset 4296624128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296628224 ++wrote 2048/2048 bytes at offset 4296628224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296632320 ++wrote 2048/2048 bytes at offset 4296632320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296636416 ++wrote 2048/2048 bytes at offset 4296636416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296640512 ++wrote 2048/2048 bytes at offset 4296640512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296644608 ++wrote 2048/2048 bytes at offset 4296644608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296648704 ++wrote 2048/2048 bytes at offset 4296648704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296652800 ++wrote 2048/2048 bytes at offset 4296652800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296656896 ++wrote 2048/2048 bytes at offset 4296656896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296660992 ++wrote 2048/2048 bytes at offset 4296660992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296665088 ++wrote 2048/2048 bytes at offset 4296665088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296669184 ++wrote 2048/2048 bytes at offset 4296669184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296673280 ++wrote 2048/2048 bytes at offset 4296673280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296677376 ++wrote 2048/2048 bytes at offset 4296677376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296681472 ++wrote 2048/2048 bytes at offset 4296681472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296685568 ++wrote 2048/2048 bytes at offset 4296685568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296689664 ++wrote 2048/2048 bytes at offset 4296689664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296693760 ++wrote 2048/2048 bytes at offset 4296693760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296697856 ++wrote 2048/2048 bytes at offset 4296697856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296701952 ++wrote 2048/2048 bytes at offset 4296701952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296706048 ++wrote 2048/2048 bytes at offset 4296706048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296710144 ++wrote 2048/2048 bytes at offset 4296710144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296714240 ++wrote 2048/2048 bytes at offset 4296714240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296718336 ++wrote 2048/2048 bytes at offset 4296718336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296722432 ++wrote 2048/2048 bytes at offset 4296722432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296726528 ++wrote 2048/2048 bytes at offset 4296726528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296730624 ++wrote 2048/2048 bytes at offset 4296730624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296734720 ++wrote 2048/2048 bytes at offset 4296734720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296738816 ++wrote 2048/2048 bytes at offset 4296738816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296742912 ++wrote 2048/2048 bytes at offset 4296742912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296747008 ++wrote 2048/2048 bytes at offset 4296747008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296751104 ++wrote 2048/2048 bytes at offset 4296751104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296755200 ++wrote 2048/2048 bytes at offset 4296755200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296759296 ++wrote 2048/2048 bytes at offset 4296759296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296763392 ++wrote 2048/2048 bytes at offset 4296763392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296767488 ++wrote 2048/2048 bytes at offset 4296767488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296771584 ++wrote 2048/2048 bytes at offset 4296771584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296775680 ++wrote 2048/2048 bytes at offset 4296775680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296779776 ++wrote 2048/2048 bytes at offset 4296779776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296783872 ++wrote 2048/2048 bytes at offset 4296783872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296787968 ++wrote 2048/2048 bytes at offset 4296787968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296792064 ++wrote 2048/2048 bytes at offset 4296792064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296796160 ++wrote 2048/2048 bytes at offset 4296796160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296800256 ++wrote 2048/2048 bytes at offset 4296800256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296804352 ++wrote 2048/2048 bytes at offset 4296804352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296808448 ++wrote 2048/2048 bytes at offset 4296808448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296812544 ++wrote 2048/2048 bytes at offset 4296812544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296816640 ++wrote 2048/2048 bytes at offset 4296816640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296820736 ++wrote 2048/2048 bytes at offset 4296820736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296824832 ++wrote 2048/2048 bytes at offset 4296824832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296828928 ++wrote 2048/2048 bytes at offset 4296828928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296833024 ++wrote 2048/2048 bytes at offset 4296833024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296837120 ++wrote 2048/2048 bytes at offset 4296837120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296841216 ++wrote 2048/2048 bytes at offset 4296841216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296845312 ++wrote 2048/2048 bytes at offset 4296845312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296849408 ++wrote 2048/2048 bytes at offset 4296849408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296853504 ++wrote 2048/2048 bytes at offset 4296853504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296857600 ++wrote 2048/2048 bytes at offset 4296857600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296861696 ++wrote 2048/2048 bytes at offset 4296861696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296865792 ++wrote 2048/2048 bytes at offset 4296865792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296869888 ++wrote 2048/2048 bytes at offset 4296869888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296873984 ++wrote 2048/2048 bytes at offset 4296873984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296878080 ++wrote 2048/2048 bytes at offset 4296878080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296882176 ++wrote 2048/2048 bytes at offset 4296882176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296886272 ++wrote 2048/2048 bytes at offset 4296886272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296890368 ++wrote 2048/2048 bytes at offset 4296890368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296894464 ++wrote 2048/2048 bytes at offset 4296894464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296898560 ++wrote 2048/2048 bytes at offset 4296898560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296902656 ++wrote 2048/2048 bytes at offset 4296902656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296906752 ++wrote 2048/2048 bytes at offset 4296906752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296910848 ++wrote 2048/2048 bytes at offset 4296910848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296914944 ++wrote 2048/2048 bytes at offset 4296914944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296919040 ++wrote 2048/2048 bytes at offset 4296919040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296923136 ++wrote 2048/2048 bytes at offset 4296923136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296927232 ++wrote 2048/2048 bytes at offset 4296927232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296931328 ++wrote 2048/2048 bytes at offset 4296931328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296935424 ++wrote 2048/2048 bytes at offset 4296935424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296939520 ++wrote 2048/2048 bytes at offset 4296939520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296943616 ++wrote 2048/2048 bytes at offset 4296943616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296947712 ++wrote 2048/2048 bytes at offset 4296947712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296951808 ++wrote 2048/2048 bytes at offset 4296951808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296955904 ++wrote 2048/2048 bytes at offset 4296955904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296960000 ++wrote 2048/2048 bytes at offset 4296960000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296964096 ++wrote 2048/2048 bytes at offset 4296964096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296968192 ++wrote 2048/2048 bytes at offset 4296968192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296972288 ++wrote 2048/2048 bytes at offset 4296972288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296976384 ++wrote 2048/2048 bytes at offset 4296976384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296980480 ++wrote 2048/2048 bytes at offset 4296980480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296984576 ++wrote 2048/2048 bytes at offset 4296984576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296988672 ++wrote 2048/2048 bytes at offset 4296988672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296992768 ++wrote 2048/2048 bytes at offset 4296992768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296996864 ++wrote 2048/2048 bytes at offset 4296996864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297000960 ++wrote 2048/2048 bytes at offset 4297000960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297005056 ++wrote 2048/2048 bytes at offset 4297005056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297009152 ++wrote 2048/2048 bytes at offset 4297009152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297013248 ++wrote 2048/2048 bytes at offset 4297013248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297017344 ++wrote 2048/2048 bytes at offset 4297017344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297021440 ++wrote 2048/2048 bytes at offset 4297021440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297025536 ++wrote 2048/2048 bytes at offset 4297025536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297029632 ++wrote 2048/2048 bytes at offset 4297029632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297033728 ++wrote 2048/2048 bytes at offset 4297033728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297037824 ++wrote 2048/2048 bytes at offset 4297037824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297041920 ++wrote 2048/2048 bytes at offset 4297041920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297046016 ++wrote 2048/2048 bytes at offset 4297046016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297050112 ++wrote 2048/2048 bytes at offset 4297050112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297054208 ++wrote 2048/2048 bytes at offset 4297054208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297058304 ++wrote 2048/2048 bytes at offset 4297058304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297062400 ++wrote 2048/2048 bytes at offset 4297062400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> wrote 2048/2048 bytes at offset 4297064448 ++=== IO: pattern 0 ++wrote 2048/2048 bytes at offset 4297064448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297068544 ++wrote 2048/2048 bytes at offset 4297068544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297072640 ++wrote 2048/2048 bytes at offset 4297072640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297076736 ++wrote 2048/2048 bytes at offset 4297076736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297080832 ++wrote 2048/2048 bytes at offset 4297080832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297084928 ++wrote 2048/2048 bytes at offset 4297084928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297089024 ++wrote 2048/2048 bytes at offset 4297089024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297093120 ++wrote 2048/2048 bytes at offset 4297093120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297097216 ++wrote 2048/2048 bytes at offset 4297097216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297101312 ++wrote 2048/2048 bytes at offset 4297101312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297105408 ++wrote 2048/2048 bytes at offset 4297105408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297109504 ++wrote 2048/2048 bytes at offset 4297109504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297113600 ++wrote 2048/2048 bytes at offset 4297113600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297117696 ++wrote 2048/2048 bytes at offset 4297117696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297121792 ++wrote 2048/2048 bytes at offset 4297121792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297125888 ++wrote 2048/2048 bytes at offset 4297125888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297129984 ++wrote 2048/2048 bytes at offset 4297129984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297134080 ++wrote 2048/2048 bytes at offset 4297134080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297138176 ++wrote 2048/2048 bytes at offset 4297138176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297142272 ++wrote 2048/2048 bytes at offset 4297142272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297146368 ++wrote 2048/2048 bytes at offset 4297146368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297150464 ++wrote 2048/2048 bytes at offset 4297150464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297154560 ++wrote 2048/2048 bytes at offset 4297154560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297158656 ++wrote 2048/2048 bytes at offset 4297158656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297162752 ++wrote 2048/2048 bytes at offset 4297162752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297166848 ++wrote 2048/2048 bytes at offset 4297166848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297170944 ++wrote 2048/2048 bytes at offset 4297170944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297175040 ++wrote 2048/2048 bytes at offset 4297175040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297179136 ++wrote 2048/2048 bytes at offset 4297179136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297183232 ++wrote 2048/2048 bytes at offset 4297183232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297187328 ++wrote 2048/2048 bytes at offset 4297187328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297191424 ++wrote 2048/2048 bytes at offset 4297191424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297195520 ++wrote 2048/2048 bytes at offset 4297195520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297199616 ++wrote 2048/2048 bytes at offset 4297199616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297203712 ++wrote 2048/2048 bytes at offset 4297203712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297207808 ++wrote 2048/2048 bytes at offset 4297207808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297211904 ++wrote 2048/2048 bytes at offset 4297211904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297216000 ++wrote 2048/2048 bytes at offset 4297216000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297220096 ++wrote 2048/2048 bytes at offset 4297220096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297224192 ++wrote 2048/2048 bytes at offset 4297224192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297228288 ++wrote 2048/2048 bytes at offset 4297228288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297232384 ++wrote 2048/2048 bytes at offset 4297232384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297236480 ++wrote 2048/2048 bytes at offset 4297236480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297240576 ++wrote 2048/2048 bytes at offset 4297240576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297244672 ++wrote 2048/2048 bytes at offset 4297244672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297248768 ++wrote 2048/2048 bytes at offset 4297248768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297252864 ++wrote 2048/2048 bytes at offset 4297252864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297256960 ++wrote 2048/2048 bytes at offset 4297256960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297261056 ++wrote 2048/2048 bytes at offset 4297261056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297265152 ++wrote 2048/2048 bytes at offset 4297265152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297269248 ++wrote 2048/2048 bytes at offset 4297269248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297273344 ++wrote 2048/2048 bytes at offset 4297273344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297277440 ++wrote 2048/2048 bytes at offset 4297277440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297281536 ++wrote 2048/2048 bytes at offset 4297281536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297285632 ++wrote 2048/2048 bytes at offset 4297285632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297289728 ++wrote 2048/2048 bytes at offset 4297289728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297293824 ++wrote 2048/2048 bytes at offset 4297293824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297297920 ++wrote 2048/2048 bytes at offset 4297297920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297302016 ++wrote 2048/2048 bytes at offset 4297302016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297306112 ++wrote 2048/2048 bytes at offset 4297306112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297310208 ++wrote 2048/2048 bytes at offset 4297310208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297314304 ++wrote 2048/2048 bytes at offset 4297314304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297318400 ++wrote 2048/2048 bytes at offset 4297318400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297322496 ++wrote 2048/2048 bytes at offset 4297322496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297326592 ++wrote 2048/2048 bytes at offset 4297326592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297330688 ++wrote 2048/2048 bytes at offset 4297330688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297334784 ++wrote 2048/2048 bytes at offset 4297334784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297338880 ++wrote 2048/2048 bytes at offset 4297338880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297342976 ++wrote 2048/2048 bytes at offset 4297342976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297347072 ++wrote 2048/2048 bytes at offset 4297347072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297351168 ++wrote 2048/2048 bytes at offset 4297351168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297355264 ++wrote 2048/2048 bytes at offset 4297355264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297359360 ++wrote 2048/2048 bytes at offset 4297359360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297363456 ++wrote 2048/2048 bytes at offset 4297363456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297367552 ++wrote 2048/2048 bytes at offset 4297367552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297371648 ++wrote 2048/2048 bytes at offset 4297371648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297375744 ++wrote 2048/2048 bytes at offset 4297375744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297379840 ++wrote 2048/2048 bytes at offset 4297379840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297383936 ++wrote 2048/2048 bytes at offset 4297383936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297388032 ++wrote 2048/2048 bytes at offset 4297388032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297392128 ++wrote 2048/2048 bytes at offset 4297392128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297396224 ++wrote 2048/2048 bytes at offset 4297396224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297400320 ++wrote 2048/2048 bytes at offset 4297400320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297404416 ++wrote 2048/2048 bytes at offset 4297404416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297408512 ++wrote 2048/2048 bytes at offset 4297408512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297412608 ++wrote 2048/2048 bytes at offset 4297412608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297416704 ++wrote 2048/2048 bytes at offset 4297416704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297420800 ++wrote 2048/2048 bytes at offset 4297420800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297424896 ++wrote 2048/2048 bytes at offset 4297424896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297428992 ++wrote 2048/2048 bytes at offset 4297428992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297433088 ++wrote 2048/2048 bytes at offset 4297433088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297437184 ++wrote 2048/2048 bytes at offset 4297437184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297441280 ++wrote 2048/2048 bytes at offset 4297441280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297445376 ++wrote 2048/2048 bytes at offset 4297445376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297449472 ++wrote 2048/2048 bytes at offset 4297449472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297453568 ++wrote 2048/2048 bytes at offset 4297453568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297457664 ++wrote 2048/2048 bytes at offset 4297457664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297461760 ++wrote 2048/2048 bytes at offset 4297461760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297465856 ++wrote 2048/2048 bytes at offset 4297465856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297469952 ++wrote 2048/2048 bytes at offset 4297469952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297474048 ++wrote 2048/2048 bytes at offset 4297474048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297478144 ++wrote 2048/2048 bytes at offset 4297478144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297482240 ++wrote 2048/2048 bytes at offset 4297482240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297486336 ++wrote 2048/2048 bytes at offset 4297486336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297490432 ++wrote 2048/2048 bytes at offset 4297490432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297494528 ++wrote 2048/2048 bytes at offset 4297494528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297498624 ++wrote 2048/2048 bytes at offset 4297498624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297502720 ++wrote 2048/2048 bytes at offset 4297502720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297506816 ++wrote 2048/2048 bytes at offset 4297506816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297510912 ++wrote 2048/2048 bytes at offset 4297510912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297515008 ++wrote 2048/2048 bytes at offset 4297515008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297519104 ++wrote 2048/2048 bytes at offset 4297519104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297523200 ++wrote 2048/2048 bytes at offset 4297523200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297527296 ++wrote 2048/2048 bytes at offset 4297527296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297531392 ++wrote 2048/2048 bytes at offset 4297531392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297535488 ++wrote 2048/2048 bytes at offset 4297535488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297539584 ++wrote 2048/2048 bytes at offset 4297539584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297543680 ++wrote 2048/2048 bytes at offset 4297543680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297547776 ++wrote 2048/2048 bytes at offset 4297547776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297551872 ++wrote 2048/2048 bytes at offset 4297551872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297555968 ++wrote 2048/2048 bytes at offset 4297555968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297560064 ++wrote 2048/2048 bytes at offset 4297560064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297564160 ++wrote 2048/2048 bytes at offset 4297564160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297568256 ++wrote 2048/2048 bytes at offset 4297568256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297572352 ++wrote 2048/2048 bytes at offset 4297572352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297576448 ++wrote 2048/2048 bytes at offset 4297576448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297580544 ++wrote 2048/2048 bytes at offset 4297580544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297584640 ++wrote 2048/2048 bytes at offset 4297584640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297588736 ++wrote 2048/2048 bytes at offset 4297588736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297592832 ++wrote 2048/2048 bytes at offset 4297592832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297596928 ++wrote 2048/2048 bytes at offset 4297596928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297601024 ++wrote 2048/2048 bytes at offset 4297601024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297605120 ++wrote 2048/2048 bytes at offset 4297605120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297609216 ++wrote 2048/2048 bytes at offset 4297609216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297613312 ++wrote 2048/2048 bytes at offset 4297613312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297617408 ++wrote 2048/2048 bytes at offset 4297617408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297621504 ++wrote 2048/2048 bytes at offset 4297621504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297625600 ++wrote 2048/2048 bytes at offset 4297625600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297629696 ++wrote 2048/2048 bytes at offset 4297629696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297633792 ++wrote 2048/2048 bytes at offset 4297633792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297637888 ++wrote 2048/2048 bytes at offset 4297637888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297641984 ++wrote 2048/2048 bytes at offset 4297641984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297646080 ++wrote 2048/2048 bytes at offset 4297646080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297650176 ++wrote 2048/2048 bytes at offset 4297650176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297654272 ++wrote 2048/2048 bytes at offset 4297654272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297658368 ++wrote 2048/2048 bytes at offset 4297658368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297662464 ++wrote 2048/2048 bytes at offset 4297662464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297666560 ++wrote 2048/2048 bytes at offset 4297666560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297670656 ++wrote 2048/2048 bytes at offset 4297670656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297674752 ++wrote 2048/2048 bytes at offset 4297674752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297678848 ++wrote 2048/2048 bytes at offset 4297678848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297682944 ++wrote 2048/2048 bytes at offset 4297682944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297687040 ++wrote 2048/2048 bytes at offset 4297687040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297691136 ++wrote 2048/2048 bytes at offset 4297691136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297695232 ++wrote 2048/2048 bytes at offset 4297695232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297699328 ++wrote 2048/2048 bytes at offset 4297699328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297703424 ++wrote 2048/2048 bytes at offset 4297703424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297707520 ++wrote 2048/2048 bytes at offset 4297707520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297711616 ++wrote 2048/2048 bytes at offset 4297711616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297715712 ++wrote 2048/2048 bytes at offset 4297715712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297719808 ++wrote 2048/2048 bytes at offset 4297719808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297723904 ++wrote 2048/2048 bytes at offset 4297723904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297728000 ++wrote 2048/2048 bytes at offset 4297728000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297732096 ++wrote 2048/2048 bytes at offset 4297732096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297736192 ++wrote 2048/2048 bytes at offset 4297736192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297740288 ++wrote 2048/2048 bytes at offset 4297740288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297744384 ++wrote 2048/2048 bytes at offset 4297744384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297748480 ++wrote 2048/2048 bytes at offset 4297748480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297752576 ++wrote 2048/2048 bytes at offset 4297752576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297756672 ++wrote 2048/2048 bytes at offset 4297756672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297760768 ++wrote 2048/2048 bytes at offset 4297760768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297764864 ++wrote 2048/2048 bytes at offset 4297764864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297768960 ++wrote 2048/2048 bytes at offset 4297768960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297773056 ++wrote 2048/2048 bytes at offset 4297773056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297777152 ++wrote 2048/2048 bytes at offset 4297777152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297781248 ++wrote 2048/2048 bytes at offset 4297781248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297785344 ++wrote 2048/2048 bytes at offset 4297785344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297789440 ++wrote 2048/2048 bytes at offset 4297789440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297793536 ++wrote 2048/2048 bytes at offset 4297793536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297797632 ++wrote 2048/2048 bytes at offset 4297797632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297801728 ++wrote 2048/2048 bytes at offset 4297801728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297805824 ++wrote 2048/2048 bytes at offset 4297805824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297809920 ++wrote 2048/2048 bytes at offset 4297809920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297814016 ++wrote 2048/2048 bytes at offset 4297814016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297818112 ++wrote 2048/2048 bytes at offset 4297818112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297822208 ++wrote 2048/2048 bytes at offset 4297822208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297826304 ++wrote 2048/2048 bytes at offset 4297826304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297830400 ++wrote 2048/2048 bytes at offset 4297830400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297834496 ++wrote 2048/2048 bytes at offset 4297834496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297838592 ++wrote 2048/2048 bytes at offset 4297838592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297842688 ++wrote 2048/2048 bytes at offset 4297842688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297846784 ++wrote 2048/2048 bytes at offset 4297846784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297850880 ++wrote 2048/2048 bytes at offset 4297850880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297854976 ++wrote 2048/2048 bytes at offset 4297854976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297859072 ++wrote 2048/2048 bytes at offset 4297859072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297863168 ++wrote 2048/2048 bytes at offset 4297863168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297867264 ++wrote 2048/2048 bytes at offset 4297867264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297871360 ++wrote 2048/2048 bytes at offset 4297871360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297875456 ++wrote 2048/2048 bytes at offset 4297875456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297879552 ++wrote 2048/2048 bytes at offset 4297879552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297883648 ++wrote 2048/2048 bytes at offset 4297883648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297887744 ++wrote 2048/2048 bytes at offset 4297887744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297891840 ++wrote 2048/2048 bytes at offset 4297891840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297895936 ++wrote 2048/2048 bytes at offset 4297895936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297900032 ++wrote 2048/2048 bytes at offset 4297900032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297904128 ++wrote 2048/2048 bytes at offset 4297904128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297908224 ++wrote 2048/2048 bytes at offset 4297908224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297912320 ++wrote 2048/2048 bytes at offset 4297912320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297916416 ++wrote 2048/2048 bytes at offset 4297916416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297920512 ++wrote 2048/2048 bytes at offset 4297920512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297924608 ++wrote 2048/2048 bytes at offset 4297924608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297928704 ++wrote 2048/2048 bytes at offset 4297928704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297932800 ++wrote 2048/2048 bytes at offset 4297932800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297936896 ++wrote 2048/2048 bytes at offset 4297936896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297940992 ++wrote 2048/2048 bytes at offset 4297940992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297945088 ++wrote 2048/2048 bytes at offset 4297945088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297949184 ++wrote 2048/2048 bytes at offset 4297949184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297953280 ++wrote 2048/2048 bytes at offset 4297953280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297957376 ++wrote 2048/2048 bytes at offset 4297957376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297961472 ++wrote 2048/2048 bytes at offset 4297961472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297965568 ++wrote 2048/2048 bytes at offset 4297965568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297969664 ++wrote 2048/2048 bytes at offset 4297969664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297973760 ++wrote 2048/2048 bytes at offset 4297973760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297977856 ++wrote 2048/2048 bytes at offset 4297977856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297981952 ++wrote 2048/2048 bytes at offset 4297981952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297986048 ++wrote 2048/2048 bytes at offset 4297986048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297990144 ++wrote 2048/2048 bytes at offset 4297990144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297994240 ++wrote 2048/2048 bytes at offset 4297994240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297998336 ++wrote 2048/2048 bytes at offset 4297998336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298002432 ++wrote 2048/2048 bytes at offset 4298002432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298006528 ++wrote 2048/2048 bytes at offset 4298006528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298010624 ++wrote 2048/2048 bytes at offset 4298010624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298014720 ++wrote 2048/2048 bytes at offset 4298014720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298018816 ++wrote 2048/2048 bytes at offset 4298018816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298022912 ++wrote 2048/2048 bytes at offset 4298022912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298027008 ++wrote 2048/2048 bytes at offset 4298027008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298031104 ++wrote 2048/2048 bytes at offset 4298031104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298035200 ++wrote 2048/2048 bytes at offset 4298035200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298039296 ++wrote 2048/2048 bytes at offset 4298039296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298043392 ++wrote 2048/2048 bytes at offset 4298043392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298047488 ++wrote 2048/2048 bytes at offset 4298047488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298051584 ++wrote 2048/2048 bytes at offset 4298051584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298055680 ++wrote 2048/2048 bytes at offset 4298055680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298059776 ++wrote 2048/2048 bytes at offset 4298059776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298063872 ++wrote 2048/2048 bytes at offset 4298063872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298067968 ++wrote 2048/2048 bytes at offset 4298067968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298072064 ++wrote 2048/2048 bytes at offset 4298072064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298076160 ++wrote 2048/2048 bytes at offset 4298076160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298080256 ++wrote 2048/2048 bytes at offset 4298080256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298084352 ++wrote 2048/2048 bytes at offset 4298084352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298088448 ++wrote 2048/2048 bytes at offset 4298088448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298092544 ++wrote 2048/2048 bytes at offset 4298092544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298096640 ++wrote 2048/2048 bytes at offset 4298096640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298100736 ++wrote 2048/2048 bytes at offset 4298100736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298104832 ++wrote 2048/2048 bytes at offset 4298104832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298108928 ++wrote 2048/2048 bytes at offset 4298108928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 2 +-qemu-io> wrote 2048/2048 bytes at offset 4298114048 ++=== IO: pattern 2 ++wrote 2048/2048 bytes at offset 4298114048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298118144 ++wrote 2048/2048 bytes at offset 4298118144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298122240 ++wrote 2048/2048 bytes at offset 4298122240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298126336 ++wrote 2048/2048 bytes at offset 4298126336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298130432 ++wrote 2048/2048 bytes at offset 4298130432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298134528 ++wrote 2048/2048 bytes at offset 4298134528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298138624 ++wrote 2048/2048 bytes at offset 4298138624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298142720 ++wrote 2048/2048 bytes at offset 4298142720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298146816 ++wrote 2048/2048 bytes at offset 4298146816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298150912 ++wrote 2048/2048 bytes at offset 4298150912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298155008 ++wrote 2048/2048 bytes at offset 4298155008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298159104 ++wrote 2048/2048 bytes at offset 4298159104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298163200 ++wrote 2048/2048 bytes at offset 4298163200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298167296 ++wrote 2048/2048 bytes at offset 4298167296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298171392 ++wrote 2048/2048 bytes at offset 4298171392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298175488 ++wrote 2048/2048 bytes at offset 4298175488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298179584 ++wrote 2048/2048 bytes at offset 4298179584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298183680 ++wrote 2048/2048 bytes at offset 4298183680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298187776 ++wrote 2048/2048 bytes at offset 4298187776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298191872 ++wrote 2048/2048 bytes at offset 4298191872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298195968 ++wrote 2048/2048 bytes at offset 4298195968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298200064 ++wrote 2048/2048 bytes at offset 4298200064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298204160 ++wrote 2048/2048 bytes at offset 4298204160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298208256 ++wrote 2048/2048 bytes at offset 4298208256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298212352 ++wrote 2048/2048 bytes at offset 4298212352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298216448 ++wrote 2048/2048 bytes at offset 4298216448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298220544 ++wrote 2048/2048 bytes at offset 4298220544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298224640 ++wrote 2048/2048 bytes at offset 4298224640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298228736 ++wrote 2048/2048 bytes at offset 4298228736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298232832 ++wrote 2048/2048 bytes at offset 4298232832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298236928 ++wrote 2048/2048 bytes at offset 4298236928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298241024 ++wrote 2048/2048 bytes at offset 4298241024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298245120 ++wrote 2048/2048 bytes at offset 4298245120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298249216 ++wrote 2048/2048 bytes at offset 4298249216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298253312 ++wrote 2048/2048 bytes at offset 4298253312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298257408 ++wrote 2048/2048 bytes at offset 4298257408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298261504 ++wrote 2048/2048 bytes at offset 4298261504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298265600 ++wrote 2048/2048 bytes at offset 4298265600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298269696 ++wrote 2048/2048 bytes at offset 4298269696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298273792 ++wrote 2048/2048 bytes at offset 4298273792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298277888 ++wrote 2048/2048 bytes at offset 4298277888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298281984 ++wrote 2048/2048 bytes at offset 4298281984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298286080 ++wrote 2048/2048 bytes at offset 4298286080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298290176 ++wrote 2048/2048 bytes at offset 4298290176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298294272 ++wrote 2048/2048 bytes at offset 4298294272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298298368 ++wrote 2048/2048 bytes at offset 4298298368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298302464 ++wrote 2048/2048 bytes at offset 4298302464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298306560 ++wrote 2048/2048 bytes at offset 4298306560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298310656 ++wrote 2048/2048 bytes at offset 4298310656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298314752 ++wrote 2048/2048 bytes at offset 4298314752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298318848 ++wrote 2048/2048 bytes at offset 4298318848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298322944 ++wrote 2048/2048 bytes at offset 4298322944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298327040 ++wrote 2048/2048 bytes at offset 4298327040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298331136 ++wrote 2048/2048 bytes at offset 4298331136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298335232 ++wrote 2048/2048 bytes at offset 4298335232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298339328 ++wrote 2048/2048 bytes at offset 4298339328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298343424 ++wrote 2048/2048 bytes at offset 4298343424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298347520 ++wrote 2048/2048 bytes at offset 4298347520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298351616 ++wrote 2048/2048 bytes at offset 4298351616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298355712 ++wrote 2048/2048 bytes at offset 4298355712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298359808 ++wrote 2048/2048 bytes at offset 4298359808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298363904 ++wrote 2048/2048 bytes at offset 4298363904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298368000 ++wrote 2048/2048 bytes at offset 4298368000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298372096 ++wrote 2048/2048 bytes at offset 4298372096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298376192 ++wrote 2048/2048 bytes at offset 4298376192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298380288 ++wrote 2048/2048 bytes at offset 4298380288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298384384 ++wrote 2048/2048 bytes at offset 4298384384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298388480 ++wrote 2048/2048 bytes at offset 4298388480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298392576 ++wrote 2048/2048 bytes at offset 4298392576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298396672 ++wrote 2048/2048 bytes at offset 4298396672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298400768 ++wrote 2048/2048 bytes at offset 4298400768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298404864 ++wrote 2048/2048 bytes at offset 4298404864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298408960 ++wrote 2048/2048 bytes at offset 4298408960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298413056 ++wrote 2048/2048 bytes at offset 4298413056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298417152 ++wrote 2048/2048 bytes at offset 4298417152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298421248 ++wrote 2048/2048 bytes at offset 4298421248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298425344 ++wrote 2048/2048 bytes at offset 4298425344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298429440 ++wrote 2048/2048 bytes at offset 4298429440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298433536 ++wrote 2048/2048 bytes at offset 4298433536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298437632 ++wrote 2048/2048 bytes at offset 4298437632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298441728 ++wrote 2048/2048 bytes at offset 4298441728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298445824 ++wrote 2048/2048 bytes at offset 4298445824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298449920 ++wrote 2048/2048 bytes at offset 4298449920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298454016 ++wrote 2048/2048 bytes at offset 4298454016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298458112 ++wrote 2048/2048 bytes at offset 4298458112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298462208 ++wrote 2048/2048 bytes at offset 4298462208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298466304 ++wrote 2048/2048 bytes at offset 4298466304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298470400 ++wrote 2048/2048 bytes at offset 4298470400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298474496 ++wrote 2048/2048 bytes at offset 4298474496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298478592 ++wrote 2048/2048 bytes at offset 4298478592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298482688 ++wrote 2048/2048 bytes at offset 4298482688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298486784 ++wrote 2048/2048 bytes at offset 4298486784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298490880 ++wrote 2048/2048 bytes at offset 4298490880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298494976 ++wrote 2048/2048 bytes at offset 4298494976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298499072 ++wrote 2048/2048 bytes at offset 4298499072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298503168 ++wrote 2048/2048 bytes at offset 4298503168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298507264 ++wrote 2048/2048 bytes at offset 4298507264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298511360 ++wrote 2048/2048 bytes at offset 4298511360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298515456 ++wrote 2048/2048 bytes at offset 4298515456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298519552 ++wrote 2048/2048 bytes at offset 4298519552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298523648 ++wrote 2048/2048 bytes at offset 4298523648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298527744 ++wrote 2048/2048 bytes at offset 4298527744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298531840 ++wrote 2048/2048 bytes at offset 4298531840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298535936 ++wrote 2048/2048 bytes at offset 4298535936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298540032 ++wrote 2048/2048 bytes at offset 4298540032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298544128 ++wrote 2048/2048 bytes at offset 4298544128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298548224 ++wrote 2048/2048 bytes at offset 4298548224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298552320 ++wrote 2048/2048 bytes at offset 4298552320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298556416 ++wrote 2048/2048 bytes at offset 4298556416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298560512 ++wrote 2048/2048 bytes at offset 4298560512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298564608 ++wrote 2048/2048 bytes at offset 4298564608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298568704 ++wrote 2048/2048 bytes at offset 4298568704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298572800 ++wrote 2048/2048 bytes at offset 4298572800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298576896 ++wrote 2048/2048 bytes at offset 4298576896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298580992 ++wrote 2048/2048 bytes at offset 4298580992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298585088 ++wrote 2048/2048 bytes at offset 4298585088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298589184 ++wrote 2048/2048 bytes at offset 4298589184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298593280 ++wrote 2048/2048 bytes at offset 4298593280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298597376 ++wrote 2048/2048 bytes at offset 4298597376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298601472 ++wrote 2048/2048 bytes at offset 4298601472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298605568 ++wrote 2048/2048 bytes at offset 4298605568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298609664 ++wrote 2048/2048 bytes at offset 4298609664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298613760 ++wrote 2048/2048 bytes at offset 4298613760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298617856 ++wrote 2048/2048 bytes at offset 4298617856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298621952 ++wrote 2048/2048 bytes at offset 4298621952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298626048 ++wrote 2048/2048 bytes at offset 4298626048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298630144 ++wrote 2048/2048 bytes at offset 4298630144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298634240 ++wrote 2048/2048 bytes at offset 4298634240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298638336 ++wrote 2048/2048 bytes at offset 4298638336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298642432 ++wrote 2048/2048 bytes at offset 4298642432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298646528 ++wrote 2048/2048 bytes at offset 4298646528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298650624 ++wrote 2048/2048 bytes at offset 4298650624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298654720 ++wrote 2048/2048 bytes at offset 4298654720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298658816 ++wrote 2048/2048 bytes at offset 4298658816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298662912 ++wrote 2048/2048 bytes at offset 4298662912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298667008 ++wrote 2048/2048 bytes at offset 4298667008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298671104 ++wrote 2048/2048 bytes at offset 4298671104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298675200 ++wrote 2048/2048 bytes at offset 4298675200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298679296 ++wrote 2048/2048 bytes at offset 4298679296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298683392 ++wrote 2048/2048 bytes at offset 4298683392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298687488 ++wrote 2048/2048 bytes at offset 4298687488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298691584 ++wrote 2048/2048 bytes at offset 4298691584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298695680 ++wrote 2048/2048 bytes at offset 4298695680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298699776 ++wrote 2048/2048 bytes at offset 4298699776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298703872 ++wrote 2048/2048 bytes at offset 4298703872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298707968 ++wrote 2048/2048 bytes at offset 4298707968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298712064 ++wrote 2048/2048 bytes at offset 4298712064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298716160 ++wrote 2048/2048 bytes at offset 4298716160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298720256 ++wrote 2048/2048 bytes at offset 4298720256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298724352 ++wrote 2048/2048 bytes at offset 4298724352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298728448 ++wrote 2048/2048 bytes at offset 4298728448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298732544 ++wrote 2048/2048 bytes at offset 4298732544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298736640 ++wrote 2048/2048 bytes at offset 4298736640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298740736 ++wrote 2048/2048 bytes at offset 4298740736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298744832 ++wrote 2048/2048 bytes at offset 4298744832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298748928 ++wrote 2048/2048 bytes at offset 4298748928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298753024 ++wrote 2048/2048 bytes at offset 4298753024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298757120 ++wrote 2048/2048 bytes at offset 4298757120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298761216 ++wrote 2048/2048 bytes at offset 4298761216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298765312 ++wrote 2048/2048 bytes at offset 4298765312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298769408 ++wrote 2048/2048 bytes at offset 4298769408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298773504 ++wrote 2048/2048 bytes at offset 4298773504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298777600 ++wrote 2048/2048 bytes at offset 4298777600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298781696 ++wrote 2048/2048 bytes at offset 4298781696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298785792 ++wrote 2048/2048 bytes at offset 4298785792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298789888 ++wrote 2048/2048 bytes at offset 4298789888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298793984 ++wrote 2048/2048 bytes at offset 4298793984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298798080 ++wrote 2048/2048 bytes at offset 4298798080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298802176 ++wrote 2048/2048 bytes at offset 4298802176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298806272 ++wrote 2048/2048 bytes at offset 4298806272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298810368 ++wrote 2048/2048 bytes at offset 4298810368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298814464 ++wrote 2048/2048 bytes at offset 4298814464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298818560 ++wrote 2048/2048 bytes at offset 4298818560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298822656 ++wrote 2048/2048 bytes at offset 4298822656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298826752 ++wrote 2048/2048 bytes at offset 4298826752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298830848 ++wrote 2048/2048 bytes at offset 4298830848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298834944 ++wrote 2048/2048 bytes at offset 4298834944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298839040 ++wrote 2048/2048 bytes at offset 4298839040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298843136 ++wrote 2048/2048 bytes at offset 4298843136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298847232 ++wrote 2048/2048 bytes at offset 4298847232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298851328 ++wrote 2048/2048 bytes at offset 4298851328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298855424 ++wrote 2048/2048 bytes at offset 4298855424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298859520 ++wrote 2048/2048 bytes at offset 4298859520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298863616 ++wrote 2048/2048 bytes at offset 4298863616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298867712 ++wrote 2048/2048 bytes at offset 4298867712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298871808 ++wrote 2048/2048 bytes at offset 4298871808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298875904 ++wrote 2048/2048 bytes at offset 4298875904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298880000 ++wrote 2048/2048 bytes at offset 4298880000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298884096 ++wrote 2048/2048 bytes at offset 4298884096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298888192 ++wrote 2048/2048 bytes at offset 4298888192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298892288 ++wrote 2048/2048 bytes at offset 4298892288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298896384 ++wrote 2048/2048 bytes at offset 4298896384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298900480 ++wrote 2048/2048 bytes at offset 4298900480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298904576 ++wrote 2048/2048 bytes at offset 4298904576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298908672 ++wrote 2048/2048 bytes at offset 4298908672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298912768 ++wrote 2048/2048 bytes at offset 4298912768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298916864 ++wrote 2048/2048 bytes at offset 4298916864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298920960 ++wrote 2048/2048 bytes at offset 4298920960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298925056 ++wrote 2048/2048 bytes at offset 4298925056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298929152 ++wrote 2048/2048 bytes at offset 4298929152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298933248 ++wrote 2048/2048 bytes at offset 4298933248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298937344 ++wrote 2048/2048 bytes at offset 4298937344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298941440 ++wrote 2048/2048 bytes at offset 4298941440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298945536 ++wrote 2048/2048 bytes at offset 4298945536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298949632 ++wrote 2048/2048 bytes at offset 4298949632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298953728 ++wrote 2048/2048 bytes at offset 4298953728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298957824 ++wrote 2048/2048 bytes at offset 4298957824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298961920 ++wrote 2048/2048 bytes at offset 4298961920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298966016 ++wrote 2048/2048 bytes at offset 4298966016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298970112 ++wrote 2048/2048 bytes at offset 4298970112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298974208 ++wrote 2048/2048 bytes at offset 4298974208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298978304 ++wrote 2048/2048 bytes at offset 4298978304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298982400 ++wrote 2048/2048 bytes at offset 4298982400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298986496 ++wrote 2048/2048 bytes at offset 4298986496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298990592 ++wrote 2048/2048 bytes at offset 4298990592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298994688 ++wrote 2048/2048 bytes at offset 4298994688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298998784 ++wrote 2048/2048 bytes at offset 4298998784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299002880 ++wrote 2048/2048 bytes at offset 4299002880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299006976 ++wrote 2048/2048 bytes at offset 4299006976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299011072 ++wrote 2048/2048 bytes at offset 4299011072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299015168 ++wrote 2048/2048 bytes at offset 4299015168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299019264 ++wrote 2048/2048 bytes at offset 4299019264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299023360 ++wrote 2048/2048 bytes at offset 4299023360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299027456 ++wrote 2048/2048 bytes at offset 4299027456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299031552 ++wrote 2048/2048 bytes at offset 4299031552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299035648 ++wrote 2048/2048 bytes at offset 4299035648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299039744 ++wrote 2048/2048 bytes at offset 4299039744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299043840 ++wrote 2048/2048 bytes at offset 4299043840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299047936 ++wrote 2048/2048 bytes at offset 4299047936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299052032 ++wrote 2048/2048 bytes at offset 4299052032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299056128 ++wrote 2048/2048 bytes at offset 4299056128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299060224 ++wrote 2048/2048 bytes at offset 4299060224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299064320 ++wrote 2048/2048 bytes at offset 4299064320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299068416 ++wrote 2048/2048 bytes at offset 4299068416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299072512 ++wrote 2048/2048 bytes at offset 4299072512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299076608 ++wrote 2048/2048 bytes at offset 4299076608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299080704 ++wrote 2048/2048 bytes at offset 4299080704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299084800 ++wrote 2048/2048 bytes at offset 4299084800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299088896 ++wrote 2048/2048 bytes at offset 4299088896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299092992 ++wrote 2048/2048 bytes at offset 4299092992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299097088 ++wrote 2048/2048 bytes at offset 4299097088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299101184 ++wrote 2048/2048 bytes at offset 4299101184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299105280 ++wrote 2048/2048 bytes at offset 4299105280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299109376 ++wrote 2048/2048 bytes at offset 4299109376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299113472 ++wrote 2048/2048 bytes at offset 4299113472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299117568 ++wrote 2048/2048 bytes at offset 4299117568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299121664 ++wrote 2048/2048 bytes at offset 4299121664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299125760 ++wrote 2048/2048 bytes at offset 4299125760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299129856 ++wrote 2048/2048 bytes at offset 4299129856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299133952 ++wrote 2048/2048 bytes at offset 4299133952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299138048 ++wrote 2048/2048 bytes at offset 4299138048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299142144 ++wrote 2048/2048 bytes at offset 4299142144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299146240 ++wrote 2048/2048 bytes at offset 4299146240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299150336 ++wrote 2048/2048 bytes at offset 4299150336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299154432 ++wrote 2048/2048 bytes at offset 4299154432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299158528 ++wrote 2048/2048 bytes at offset 4299158528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 4 +-qemu-io> wrote 8192/8192 bytes at offset 4299163648 ++=== IO: pattern 4 ++wrote 8192/8192 bytes at offset 4299163648 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299175936 ++wrote 8192/8192 bytes at offset 4299175936 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299188224 ++wrote 8192/8192 bytes at offset 4299188224 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299200512 ++wrote 8192/8192 bytes at offset 4299200512 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299212800 ++wrote 8192/8192 bytes at offset 4299212800 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299225088 ++wrote 8192/8192 bytes at offset 4299225088 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299237376 ++wrote 8192/8192 bytes at offset 4299237376 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299249664 ++wrote 8192/8192 bytes at offset 4299249664 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299261952 ++wrote 8192/8192 bytes at offset 4299261952 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299274240 ++wrote 8192/8192 bytes at offset 4299274240 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299286528 ++wrote 8192/8192 bytes at offset 4299286528 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299298816 ++wrote 8192/8192 bytes at offset 4299298816 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299311104 ++wrote 8192/8192 bytes at offset 4299311104 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299323392 ++wrote 8192/8192 bytes at offset 4299323392 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299335680 ++wrote 8192/8192 bytes at offset 4299335680 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299347968 ++wrote 8192/8192 bytes at offset 4299347968 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299360256 ++wrote 8192/8192 bytes at offset 4299360256 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299372544 ++wrote 8192/8192 bytes at offset 4299372544 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299384832 ++wrote 8192/8192 bytes at offset 4299384832 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299397120 ++wrote 8192/8192 bytes at offset 4299397120 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299409408 ++wrote 8192/8192 bytes at offset 4299409408 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299421696 ++wrote 8192/8192 bytes at offset 4299421696 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299433984 ++wrote 8192/8192 bytes at offset 4299433984 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299446272 ++wrote 8192/8192 bytes at offset 4299446272 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299458560 ++wrote 8192/8192 bytes at offset 4299458560 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299470848 ++wrote 8192/8192 bytes at offset 4299470848 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299483136 ++wrote 8192/8192 bytes at offset 4299483136 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299495424 ++wrote 8192/8192 bytes at offset 4299495424 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299507712 ++wrote 8192/8192 bytes at offset 4299507712 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299520000 ++wrote 8192/8192 bytes at offset 4299520000 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299532288 ++wrote 8192/8192 bytes at offset 4299532288 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299544576 ++wrote 8192/8192 bytes at offset 4299544576 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299556864 ++wrote 8192/8192 bytes at offset 4299556864 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299569152 ++wrote 8192/8192 bytes at offset 4299569152 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299581440 ++wrote 8192/8192 bytes at offset 4299581440 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299593728 ++wrote 8192/8192 bytes at offset 4299593728 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299606016 ++wrote 8192/8192 bytes at offset 4299606016 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299618304 ++wrote 8192/8192 bytes at offset 4299618304 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299630592 ++wrote 8192/8192 bytes at offset 4299630592 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299642880 ++wrote 8192/8192 bytes at offset 4299642880 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299655168 ++wrote 8192/8192 bytes at offset 4299655168 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299667456 ++wrote 8192/8192 bytes at offset 4299667456 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299679744 ++wrote 8192/8192 bytes at offset 4299679744 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299692032 ++wrote 8192/8192 bytes at offset 4299692032 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299704320 ++wrote 8192/8192 bytes at offset 4299704320 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299716608 ++wrote 8192/8192 bytes at offset 4299716608 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299728896 ++wrote 8192/8192 bytes at offset 4299728896 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299741184 ++wrote 8192/8192 bytes at offset 4299741184 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299753472 ++wrote 8192/8192 bytes at offset 4299753472 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299765760 ++wrote 8192/8192 bytes at offset 4299765760 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299778048 ++wrote 8192/8192 bytes at offset 4299778048 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299790336 ++wrote 8192/8192 bytes at offset 4299790336 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299802624 ++wrote 8192/8192 bytes at offset 4299802624 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299814912 ++wrote 8192/8192 bytes at offset 4299814912 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299827200 ++wrote 8192/8192 bytes at offset 4299827200 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299839488 ++wrote 8192/8192 bytes at offset 4299839488 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299851776 ++wrote 8192/8192 bytes at offset 4299851776 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299864064 ++wrote 8192/8192 bytes at offset 4299864064 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299876352 ++wrote 8192/8192 bytes at offset 4299876352 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299888640 ++wrote 8192/8192 bytes at offset 4299888640 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299900928 ++wrote 8192/8192 bytes at offset 4299900928 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299913216 ++wrote 8192/8192 bytes at offset 4299913216 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299925504 ++wrote 8192/8192 bytes at offset 4299925504 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299937792 ++wrote 8192/8192 bytes at offset 4299937792 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 244 +-qemu-io> wrote 12288/12288 bytes at offset 4301252608 ++=== IO: pattern 244 ++wrote 12288/12288 bytes at offset 4301252608 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 4303351808 ++wrote 12288/12288 bytes at offset 4303351808 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 4305451008 ++wrote 12288/12288 bytes at offset 4305451008 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 4307550208 ++wrote 12288/12288 bytes at offset 4307550208 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 4309649408 ++wrote 12288/12288 bytes at offset 4309649408 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 4311748608 ++wrote 12288/12288 bytes at offset 4311748608 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 4313847808 ++wrote 12288/12288 bytes at offset 4313847808 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 4315947008 ++wrote 12288/12288 bytes at offset 4315947008 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> read 4096/4096 bytes at offset 4294967296 ++=== IO: pattern 0 ++read 4096/4096 bytes at offset 4294967296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294971392 ++read 4096/4096 bytes at offset 4294971392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294975488 ++read 4096/4096 bytes at offset 4294975488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294979584 ++read 4096/4096 bytes at offset 4294979584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294983680 ++read 4096/4096 bytes at offset 4294983680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294987776 ++read 4096/4096 bytes at offset 4294987776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294991872 ++read 4096/4096 bytes at offset 4294991872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294995968 ++read 4096/4096 bytes at offset 4294995968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295000064 ++read 4096/4096 bytes at offset 4295000064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295004160 ++read 4096/4096 bytes at offset 4295004160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295008256 ++read 4096/4096 bytes at offset 4295008256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295012352 ++read 4096/4096 bytes at offset 4295012352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295016448 ++read 4096/4096 bytes at offset 4295016448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295020544 ++read 4096/4096 bytes at offset 4295020544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295024640 ++read 4096/4096 bytes at offset 4295024640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295028736 ++read 4096/4096 bytes at offset 4295028736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295032832 ++read 4096/4096 bytes at offset 4295032832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295036928 ++read 4096/4096 bytes at offset 4295036928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295041024 ++read 4096/4096 bytes at offset 4295041024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295045120 ++read 4096/4096 bytes at offset 4295045120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295049216 ++read 4096/4096 bytes at offset 4295049216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295053312 ++read 4096/4096 bytes at offset 4295053312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295057408 ++read 4096/4096 bytes at offset 4295057408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295061504 ++read 4096/4096 bytes at offset 4295061504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295065600 ++read 4096/4096 bytes at offset 4295065600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295069696 ++read 4096/4096 bytes at offset 4295069696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295073792 ++read 4096/4096 bytes at offset 4295073792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295077888 ++read 4096/4096 bytes at offset 4295077888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295081984 ++read 4096/4096 bytes at offset 4295081984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295086080 ++read 4096/4096 bytes at offset 4295086080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295090176 ++read 4096/4096 bytes at offset 4295090176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295094272 ++read 4096/4096 bytes at offset 4295094272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295098368 ++read 4096/4096 bytes at offset 4295098368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295102464 ++read 4096/4096 bytes at offset 4295102464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295106560 ++read 4096/4096 bytes at offset 4295106560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295110656 ++read 4096/4096 bytes at offset 4295110656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295114752 ++read 4096/4096 bytes at offset 4295114752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295118848 ++read 4096/4096 bytes at offset 4295118848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295122944 ++read 4096/4096 bytes at offset 4295122944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295127040 ++read 4096/4096 bytes at offset 4295127040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295131136 ++read 4096/4096 bytes at offset 4295131136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295135232 ++read 4096/4096 bytes at offset 4295135232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295139328 ++read 4096/4096 bytes at offset 4295139328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295143424 ++read 4096/4096 bytes at offset 4295143424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295147520 ++read 4096/4096 bytes at offset 4295147520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295151616 ++read 4096/4096 bytes at offset 4295151616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295155712 ++read 4096/4096 bytes at offset 4295155712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295159808 ++read 4096/4096 bytes at offset 4295159808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295163904 ++read 4096/4096 bytes at offset 4295163904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295168000 ++read 4096/4096 bytes at offset 4295168000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295172096 ++read 4096/4096 bytes at offset 4295172096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295176192 ++read 4096/4096 bytes at offset 4295176192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295180288 ++read 4096/4096 bytes at offset 4295180288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295184384 ++read 4096/4096 bytes at offset 4295184384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295188480 ++read 4096/4096 bytes at offset 4295188480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295192576 ++read 4096/4096 bytes at offset 4295192576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295196672 ++read 4096/4096 bytes at offset 4295196672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295200768 ++read 4096/4096 bytes at offset 4295200768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295204864 ++read 4096/4096 bytes at offset 4295204864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295208960 ++read 4096/4096 bytes at offset 4295208960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295213056 ++read 4096/4096 bytes at offset 4295213056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295217152 ++read 4096/4096 bytes at offset 4295217152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295221248 ++read 4096/4096 bytes at offset 4295221248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295225344 ++read 4096/4096 bytes at offset 4295225344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295229440 ++read 4096/4096 bytes at offset 4295229440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295233536 ++read 4096/4096 bytes at offset 4295233536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295237632 ++read 4096/4096 bytes at offset 4295237632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295241728 ++read 4096/4096 bytes at offset 4295241728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295245824 ++read 4096/4096 bytes at offset 4295245824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295249920 ++read 4096/4096 bytes at offset 4295249920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295254016 ++read 4096/4096 bytes at offset 4295254016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295258112 ++read 4096/4096 bytes at offset 4295258112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295262208 ++read 4096/4096 bytes at offset 4295262208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295266304 ++read 4096/4096 bytes at offset 4295266304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295270400 ++read 4096/4096 bytes at offset 4295270400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295274496 ++read 4096/4096 bytes at offset 4295274496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295278592 ++read 4096/4096 bytes at offset 4295278592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295282688 ++read 4096/4096 bytes at offset 4295282688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295286784 ++read 4096/4096 bytes at offset 4295286784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295290880 ++read 4096/4096 bytes at offset 4295290880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295294976 ++read 4096/4096 bytes at offset 4295294976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295299072 ++read 4096/4096 bytes at offset 4295299072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295303168 ++read 4096/4096 bytes at offset 4295303168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295307264 ++read 4096/4096 bytes at offset 4295307264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295311360 ++read 4096/4096 bytes at offset 4295311360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295315456 ++read 4096/4096 bytes at offset 4295315456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295319552 ++read 4096/4096 bytes at offset 4295319552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295323648 ++read 4096/4096 bytes at offset 4295323648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295327744 ++read 4096/4096 bytes at offset 4295327744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295331840 ++read 4096/4096 bytes at offset 4295331840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295335936 ++read 4096/4096 bytes at offset 4295335936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295340032 ++read 4096/4096 bytes at offset 4295340032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295344128 ++read 4096/4096 bytes at offset 4295344128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295348224 ++read 4096/4096 bytes at offset 4295348224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295352320 ++read 4096/4096 bytes at offset 4295352320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295356416 ++read 4096/4096 bytes at offset 4295356416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295360512 ++read 4096/4096 bytes at offset 4295360512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295364608 ++read 4096/4096 bytes at offset 4295364608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295368704 ++read 4096/4096 bytes at offset 4295368704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295372800 ++read 4096/4096 bytes at offset 4295372800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295376896 ++read 4096/4096 bytes at offset 4295376896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295380992 ++read 4096/4096 bytes at offset 4295380992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295385088 ++read 4096/4096 bytes at offset 4295385088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295389184 ++read 4096/4096 bytes at offset 4295389184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295393280 ++read 4096/4096 bytes at offset 4295393280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295397376 ++read 4096/4096 bytes at offset 4295397376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295401472 ++read 4096/4096 bytes at offset 4295401472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295405568 ++read 4096/4096 bytes at offset 4295405568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295409664 ++read 4096/4096 bytes at offset 4295409664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295413760 ++read 4096/4096 bytes at offset 4295413760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295417856 ++read 4096/4096 bytes at offset 4295417856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295421952 ++read 4096/4096 bytes at offset 4295421952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295426048 ++read 4096/4096 bytes at offset 4295426048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295430144 ++read 4096/4096 bytes at offset 4295430144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295434240 ++read 4096/4096 bytes at offset 4295434240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295438336 ++read 4096/4096 bytes at offset 4295438336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295442432 ++read 4096/4096 bytes at offset 4295442432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295446528 ++read 4096/4096 bytes at offset 4295446528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295450624 ++read 4096/4096 bytes at offset 4295450624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295454720 ++read 4096/4096 bytes at offset 4295454720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295458816 ++read 4096/4096 bytes at offset 4295458816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295462912 ++read 4096/4096 bytes at offset 4295462912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295467008 ++read 4096/4096 bytes at offset 4295467008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295471104 ++read 4096/4096 bytes at offset 4295471104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295475200 ++read 4096/4096 bytes at offset 4295475200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295479296 ++read 4096/4096 bytes at offset 4295479296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295483392 ++read 4096/4096 bytes at offset 4295483392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295487488 ++read 4096/4096 bytes at offset 4295487488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295491584 ++read 4096/4096 bytes at offset 4295491584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295495680 ++read 4096/4096 bytes at offset 4295495680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295499776 ++read 4096/4096 bytes at offset 4295499776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295503872 ++read 4096/4096 bytes at offset 4295503872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295507968 ++read 4096/4096 bytes at offset 4295507968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295512064 ++read 4096/4096 bytes at offset 4295512064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295516160 ++read 4096/4096 bytes at offset 4295516160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295520256 ++read 4096/4096 bytes at offset 4295520256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295524352 ++read 4096/4096 bytes at offset 4295524352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295528448 ++read 4096/4096 bytes at offset 4295528448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295532544 ++read 4096/4096 bytes at offset 4295532544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295536640 ++read 4096/4096 bytes at offset 4295536640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295540736 ++read 4096/4096 bytes at offset 4295540736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295544832 ++read 4096/4096 bytes at offset 4295544832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295548928 ++read 4096/4096 bytes at offset 4295548928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295553024 ++read 4096/4096 bytes at offset 4295553024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295557120 ++read 4096/4096 bytes at offset 4295557120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295561216 ++read 4096/4096 bytes at offset 4295561216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295565312 ++read 4096/4096 bytes at offset 4295565312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295569408 ++read 4096/4096 bytes at offset 4295569408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295573504 ++read 4096/4096 bytes at offset 4295573504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295577600 ++read 4096/4096 bytes at offset 4295577600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295581696 ++read 4096/4096 bytes at offset 4295581696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295585792 ++read 4096/4096 bytes at offset 4295585792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295589888 ++read 4096/4096 bytes at offset 4295589888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295593984 ++read 4096/4096 bytes at offset 4295593984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295598080 ++read 4096/4096 bytes at offset 4295598080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295602176 ++read 4096/4096 bytes at offset 4295602176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295606272 ++read 4096/4096 bytes at offset 4295606272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295610368 ++read 4096/4096 bytes at offset 4295610368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295614464 ++read 4096/4096 bytes at offset 4295614464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295618560 ++read 4096/4096 bytes at offset 4295618560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295622656 ++read 4096/4096 bytes at offset 4295622656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295626752 ++read 4096/4096 bytes at offset 4295626752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295630848 ++read 4096/4096 bytes at offset 4295630848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295634944 ++read 4096/4096 bytes at offset 4295634944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295639040 ++read 4096/4096 bytes at offset 4295639040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295643136 ++read 4096/4096 bytes at offset 4295643136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295647232 ++read 4096/4096 bytes at offset 4295647232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295651328 ++read 4096/4096 bytes at offset 4295651328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295655424 ++read 4096/4096 bytes at offset 4295655424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295659520 ++read 4096/4096 bytes at offset 4295659520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295663616 ++read 4096/4096 bytes at offset 4295663616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295667712 ++read 4096/4096 bytes at offset 4295667712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295671808 ++read 4096/4096 bytes at offset 4295671808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295675904 ++read 4096/4096 bytes at offset 4295675904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295680000 ++read 4096/4096 bytes at offset 4295680000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295684096 ++read 4096/4096 bytes at offset 4295684096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295688192 ++read 4096/4096 bytes at offset 4295688192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295692288 ++read 4096/4096 bytes at offset 4295692288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295696384 ++read 4096/4096 bytes at offset 4295696384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295700480 ++read 4096/4096 bytes at offset 4295700480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295704576 ++read 4096/4096 bytes at offset 4295704576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295708672 ++read 4096/4096 bytes at offset 4295708672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295712768 ++read 4096/4096 bytes at offset 4295712768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295716864 ++read 4096/4096 bytes at offset 4295716864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295720960 ++read 4096/4096 bytes at offset 4295720960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295725056 ++read 4096/4096 bytes at offset 4295725056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295729152 ++read 4096/4096 bytes at offset 4295729152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295733248 ++read 4096/4096 bytes at offset 4295733248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295737344 ++read 4096/4096 bytes at offset 4295737344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295741440 ++read 4096/4096 bytes at offset 4295741440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295745536 ++read 4096/4096 bytes at offset 4295745536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295749632 ++read 4096/4096 bytes at offset 4295749632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295753728 ++read 4096/4096 bytes at offset 4295753728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295757824 ++read 4096/4096 bytes at offset 4295757824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295761920 ++read 4096/4096 bytes at offset 4295761920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295766016 ++read 4096/4096 bytes at offset 4295766016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295770112 ++read 4096/4096 bytes at offset 4295770112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295774208 ++read 4096/4096 bytes at offset 4295774208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295778304 ++read 4096/4096 bytes at offset 4295778304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295782400 ++read 4096/4096 bytes at offset 4295782400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295786496 ++read 4096/4096 bytes at offset 4295786496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295790592 ++read 4096/4096 bytes at offset 4295790592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295794688 ++read 4096/4096 bytes at offset 4295794688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295798784 ++read 4096/4096 bytes at offset 4295798784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295802880 ++read 4096/4096 bytes at offset 4295802880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295806976 ++read 4096/4096 bytes at offset 4295806976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295811072 ++read 4096/4096 bytes at offset 4295811072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295815168 ++read 4096/4096 bytes at offset 4295815168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295819264 ++read 4096/4096 bytes at offset 4295819264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295823360 ++read 4096/4096 bytes at offset 4295823360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295827456 ++read 4096/4096 bytes at offset 4295827456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295831552 ++read 4096/4096 bytes at offset 4295831552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295835648 ++read 4096/4096 bytes at offset 4295835648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295839744 ++read 4096/4096 bytes at offset 4295839744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295843840 ++read 4096/4096 bytes at offset 4295843840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295847936 ++read 4096/4096 bytes at offset 4295847936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295852032 ++read 4096/4096 bytes at offset 4295852032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295856128 ++read 4096/4096 bytes at offset 4295856128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295860224 ++read 4096/4096 bytes at offset 4295860224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295864320 ++read 4096/4096 bytes at offset 4295864320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295868416 ++read 4096/4096 bytes at offset 4295868416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295872512 ++read 4096/4096 bytes at offset 4295872512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295876608 ++read 4096/4096 bytes at offset 4295876608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295880704 ++read 4096/4096 bytes at offset 4295880704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295884800 ++read 4096/4096 bytes at offset 4295884800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295888896 ++read 4096/4096 bytes at offset 4295888896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295892992 ++read 4096/4096 bytes at offset 4295892992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295897088 ++read 4096/4096 bytes at offset 4295897088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295901184 ++read 4096/4096 bytes at offset 4295901184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295905280 ++read 4096/4096 bytes at offset 4295905280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295909376 ++read 4096/4096 bytes at offset 4295909376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295913472 ++read 4096/4096 bytes at offset 4295913472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295917568 ++read 4096/4096 bytes at offset 4295917568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295921664 ++read 4096/4096 bytes at offset 4295921664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295925760 ++read 4096/4096 bytes at offset 4295925760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295929856 ++read 4096/4096 bytes at offset 4295929856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295933952 ++read 4096/4096 bytes at offset 4295933952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295938048 ++read 4096/4096 bytes at offset 4295938048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295942144 ++read 4096/4096 bytes at offset 4295942144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295946240 ++read 4096/4096 bytes at offset 4295946240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295950336 ++read 4096/4096 bytes at offset 4295950336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295954432 ++read 4096/4096 bytes at offset 4295954432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295958528 ++read 4096/4096 bytes at offset 4295958528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295962624 ++read 4096/4096 bytes at offset 4295962624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295966720 ++read 4096/4096 bytes at offset 4295966720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295970816 ++read 4096/4096 bytes at offset 4295970816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295974912 ++read 4096/4096 bytes at offset 4295974912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295979008 ++read 4096/4096 bytes at offset 4295979008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295983104 ++read 4096/4096 bytes at offset 4295983104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295987200 ++read 4096/4096 bytes at offset 4295987200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295991296 ++read 4096/4096 bytes at offset 4295991296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295995392 ++read 4096/4096 bytes at offset 4295995392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295999488 ++read 4096/4096 bytes at offset 4295999488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4296003584 ++read 4096/4096 bytes at offset 4296003584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4296007680 ++read 4096/4096 bytes at offset 4296007680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4296011776 ++read 4096/4096 bytes at offset 4296011776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 4 +-qemu-io> read 2048/2048 bytes at offset 4296017920 ++=== IO: pattern 4 ++read 2048/2048 bytes at offset 4296017920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296022016 ++read 2048/2048 bytes at offset 4296022016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296026112 ++read 2048/2048 bytes at offset 4296026112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296030208 ++read 2048/2048 bytes at offset 4296030208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296034304 ++read 2048/2048 bytes at offset 4296034304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296038400 ++read 2048/2048 bytes at offset 4296038400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296042496 ++read 2048/2048 bytes at offset 4296042496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296046592 ++read 2048/2048 bytes at offset 4296046592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296050688 ++read 2048/2048 bytes at offset 4296050688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296054784 ++read 2048/2048 bytes at offset 4296054784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296058880 ++read 2048/2048 bytes at offset 4296058880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296062976 ++read 2048/2048 bytes at offset 4296062976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296067072 ++read 2048/2048 bytes at offset 4296067072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296071168 ++read 2048/2048 bytes at offset 4296071168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296075264 ++read 2048/2048 bytes at offset 4296075264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296079360 ++read 2048/2048 bytes at offset 4296079360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296083456 ++read 2048/2048 bytes at offset 4296083456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296087552 ++read 2048/2048 bytes at offset 4296087552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296091648 ++read 2048/2048 bytes at offset 4296091648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296095744 ++read 2048/2048 bytes at offset 4296095744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296099840 ++read 2048/2048 bytes at offset 4296099840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296103936 ++read 2048/2048 bytes at offset 4296103936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296108032 ++read 2048/2048 bytes at offset 4296108032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296112128 ++read 2048/2048 bytes at offset 4296112128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296116224 ++read 2048/2048 bytes at offset 4296116224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296120320 ++read 2048/2048 bytes at offset 4296120320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296124416 ++read 2048/2048 bytes at offset 4296124416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296128512 ++read 2048/2048 bytes at offset 4296128512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296132608 ++read 2048/2048 bytes at offset 4296132608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296136704 ++read 2048/2048 bytes at offset 4296136704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296140800 ++read 2048/2048 bytes at offset 4296140800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296144896 ++read 2048/2048 bytes at offset 4296144896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296148992 ++read 2048/2048 bytes at offset 4296148992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296153088 ++read 2048/2048 bytes at offset 4296153088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296157184 ++read 2048/2048 bytes at offset 4296157184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296161280 ++read 2048/2048 bytes at offset 4296161280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296165376 ++read 2048/2048 bytes at offset 4296165376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296169472 ++read 2048/2048 bytes at offset 4296169472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296173568 ++read 2048/2048 bytes at offset 4296173568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296177664 ++read 2048/2048 bytes at offset 4296177664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296181760 ++read 2048/2048 bytes at offset 4296181760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296185856 ++read 2048/2048 bytes at offset 4296185856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296189952 ++read 2048/2048 bytes at offset 4296189952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296194048 ++read 2048/2048 bytes at offset 4296194048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296198144 ++read 2048/2048 bytes at offset 4296198144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296202240 ++read 2048/2048 bytes at offset 4296202240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296206336 ++read 2048/2048 bytes at offset 4296206336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296210432 ++read 2048/2048 bytes at offset 4296210432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296214528 ++read 2048/2048 bytes at offset 4296214528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296218624 ++read 2048/2048 bytes at offset 4296218624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296222720 ++read 2048/2048 bytes at offset 4296222720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296226816 ++read 2048/2048 bytes at offset 4296226816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296230912 ++read 2048/2048 bytes at offset 4296230912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296235008 ++read 2048/2048 bytes at offset 4296235008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296239104 ++read 2048/2048 bytes at offset 4296239104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296243200 ++read 2048/2048 bytes at offset 4296243200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296247296 ++read 2048/2048 bytes at offset 4296247296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296251392 ++read 2048/2048 bytes at offset 4296251392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296255488 ++read 2048/2048 bytes at offset 4296255488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296259584 ++read 2048/2048 bytes at offset 4296259584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296263680 ++read 2048/2048 bytes at offset 4296263680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296267776 ++read 2048/2048 bytes at offset 4296267776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296271872 ++read 2048/2048 bytes at offset 4296271872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296275968 ++read 2048/2048 bytes at offset 4296275968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296280064 ++read 2048/2048 bytes at offset 4296280064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296284160 ++read 2048/2048 bytes at offset 4296284160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296288256 ++read 2048/2048 bytes at offset 4296288256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296292352 ++read 2048/2048 bytes at offset 4296292352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296296448 ++read 2048/2048 bytes at offset 4296296448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296300544 ++read 2048/2048 bytes at offset 4296300544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296304640 ++read 2048/2048 bytes at offset 4296304640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296308736 ++read 2048/2048 bytes at offset 4296308736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296312832 ++read 2048/2048 bytes at offset 4296312832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296316928 ++read 2048/2048 bytes at offset 4296316928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296321024 ++read 2048/2048 bytes at offset 4296321024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296325120 ++read 2048/2048 bytes at offset 4296325120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296329216 ++read 2048/2048 bytes at offset 4296329216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296333312 ++read 2048/2048 bytes at offset 4296333312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296337408 ++read 2048/2048 bytes at offset 4296337408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296341504 ++read 2048/2048 bytes at offset 4296341504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296345600 ++read 2048/2048 bytes at offset 4296345600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296349696 ++read 2048/2048 bytes at offset 4296349696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296353792 ++read 2048/2048 bytes at offset 4296353792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296357888 ++read 2048/2048 bytes at offset 4296357888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296361984 ++read 2048/2048 bytes at offset 4296361984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296366080 ++read 2048/2048 bytes at offset 4296366080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296370176 ++read 2048/2048 bytes at offset 4296370176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296374272 ++read 2048/2048 bytes at offset 4296374272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296378368 ++read 2048/2048 bytes at offset 4296378368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296382464 ++read 2048/2048 bytes at offset 4296382464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296386560 ++read 2048/2048 bytes at offset 4296386560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296390656 ++read 2048/2048 bytes at offset 4296390656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296394752 ++read 2048/2048 bytes at offset 4296394752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296398848 ++read 2048/2048 bytes at offset 4296398848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296402944 ++read 2048/2048 bytes at offset 4296402944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296407040 ++read 2048/2048 bytes at offset 4296407040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296411136 ++read 2048/2048 bytes at offset 4296411136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296415232 ++read 2048/2048 bytes at offset 4296415232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296419328 ++read 2048/2048 bytes at offset 4296419328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296423424 ++read 2048/2048 bytes at offset 4296423424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296427520 ++read 2048/2048 bytes at offset 4296427520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296431616 ++read 2048/2048 bytes at offset 4296431616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296435712 ++read 2048/2048 bytes at offset 4296435712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296439808 ++read 2048/2048 bytes at offset 4296439808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296443904 ++read 2048/2048 bytes at offset 4296443904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296448000 ++read 2048/2048 bytes at offset 4296448000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296452096 ++read 2048/2048 bytes at offset 4296452096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296456192 ++read 2048/2048 bytes at offset 4296456192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296460288 ++read 2048/2048 bytes at offset 4296460288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296464384 ++read 2048/2048 bytes at offset 4296464384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296468480 ++read 2048/2048 bytes at offset 4296468480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296472576 ++read 2048/2048 bytes at offset 4296472576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296476672 ++read 2048/2048 bytes at offset 4296476672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296480768 ++read 2048/2048 bytes at offset 4296480768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296484864 ++read 2048/2048 bytes at offset 4296484864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296488960 ++read 2048/2048 bytes at offset 4296488960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296493056 ++read 2048/2048 bytes at offset 4296493056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296497152 ++read 2048/2048 bytes at offset 4296497152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296501248 ++read 2048/2048 bytes at offset 4296501248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296505344 ++read 2048/2048 bytes at offset 4296505344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296509440 ++read 2048/2048 bytes at offset 4296509440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296513536 ++read 2048/2048 bytes at offset 4296513536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296517632 ++read 2048/2048 bytes at offset 4296517632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296521728 ++read 2048/2048 bytes at offset 4296521728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296525824 ++read 2048/2048 bytes at offset 4296525824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296529920 ++read 2048/2048 bytes at offset 4296529920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296534016 ++read 2048/2048 bytes at offset 4296534016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296538112 ++read 2048/2048 bytes at offset 4296538112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296542208 ++read 2048/2048 bytes at offset 4296542208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296546304 ++read 2048/2048 bytes at offset 4296546304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296550400 ++read 2048/2048 bytes at offset 4296550400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296554496 ++read 2048/2048 bytes at offset 4296554496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296558592 ++read 2048/2048 bytes at offset 4296558592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296562688 ++read 2048/2048 bytes at offset 4296562688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296566784 ++read 2048/2048 bytes at offset 4296566784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296570880 ++read 2048/2048 bytes at offset 4296570880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296574976 ++read 2048/2048 bytes at offset 4296574976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296579072 ++read 2048/2048 bytes at offset 4296579072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296583168 ++read 2048/2048 bytes at offset 4296583168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296587264 ++read 2048/2048 bytes at offset 4296587264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296591360 ++read 2048/2048 bytes at offset 4296591360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296595456 ++read 2048/2048 bytes at offset 4296595456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296599552 ++read 2048/2048 bytes at offset 4296599552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296603648 ++read 2048/2048 bytes at offset 4296603648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296607744 ++read 2048/2048 bytes at offset 4296607744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296611840 ++read 2048/2048 bytes at offset 4296611840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296615936 ++read 2048/2048 bytes at offset 4296615936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296620032 ++read 2048/2048 bytes at offset 4296620032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296624128 ++read 2048/2048 bytes at offset 4296624128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296628224 ++read 2048/2048 bytes at offset 4296628224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296632320 ++read 2048/2048 bytes at offset 4296632320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296636416 ++read 2048/2048 bytes at offset 4296636416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296640512 ++read 2048/2048 bytes at offset 4296640512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296644608 ++read 2048/2048 bytes at offset 4296644608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296648704 ++read 2048/2048 bytes at offset 4296648704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296652800 ++read 2048/2048 bytes at offset 4296652800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296656896 ++read 2048/2048 bytes at offset 4296656896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296660992 ++read 2048/2048 bytes at offset 4296660992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296665088 ++read 2048/2048 bytes at offset 4296665088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296669184 ++read 2048/2048 bytes at offset 4296669184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296673280 ++read 2048/2048 bytes at offset 4296673280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296677376 ++read 2048/2048 bytes at offset 4296677376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296681472 ++read 2048/2048 bytes at offset 4296681472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296685568 ++read 2048/2048 bytes at offset 4296685568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296689664 ++read 2048/2048 bytes at offset 4296689664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296693760 ++read 2048/2048 bytes at offset 4296693760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296697856 ++read 2048/2048 bytes at offset 4296697856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296701952 ++read 2048/2048 bytes at offset 4296701952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296706048 ++read 2048/2048 bytes at offset 4296706048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296710144 ++read 2048/2048 bytes at offset 4296710144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296714240 ++read 2048/2048 bytes at offset 4296714240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296718336 ++read 2048/2048 bytes at offset 4296718336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296722432 ++read 2048/2048 bytes at offset 4296722432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296726528 ++read 2048/2048 bytes at offset 4296726528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296730624 ++read 2048/2048 bytes at offset 4296730624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296734720 ++read 2048/2048 bytes at offset 4296734720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296738816 ++read 2048/2048 bytes at offset 4296738816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296742912 ++read 2048/2048 bytes at offset 4296742912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296747008 ++read 2048/2048 bytes at offset 4296747008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296751104 ++read 2048/2048 bytes at offset 4296751104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296755200 ++read 2048/2048 bytes at offset 4296755200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296759296 ++read 2048/2048 bytes at offset 4296759296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296763392 ++read 2048/2048 bytes at offset 4296763392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296767488 ++read 2048/2048 bytes at offset 4296767488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296771584 ++read 2048/2048 bytes at offset 4296771584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296775680 ++read 2048/2048 bytes at offset 4296775680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296779776 ++read 2048/2048 bytes at offset 4296779776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296783872 ++read 2048/2048 bytes at offset 4296783872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296787968 ++read 2048/2048 bytes at offset 4296787968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296792064 ++read 2048/2048 bytes at offset 4296792064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296796160 ++read 2048/2048 bytes at offset 4296796160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296800256 ++read 2048/2048 bytes at offset 4296800256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296804352 ++read 2048/2048 bytes at offset 4296804352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296808448 ++read 2048/2048 bytes at offset 4296808448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296812544 ++read 2048/2048 bytes at offset 4296812544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296816640 ++read 2048/2048 bytes at offset 4296816640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296820736 ++read 2048/2048 bytes at offset 4296820736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296824832 ++read 2048/2048 bytes at offset 4296824832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296828928 ++read 2048/2048 bytes at offset 4296828928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296833024 ++read 2048/2048 bytes at offset 4296833024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296837120 ++read 2048/2048 bytes at offset 4296837120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296841216 ++read 2048/2048 bytes at offset 4296841216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296845312 ++read 2048/2048 bytes at offset 4296845312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296849408 ++read 2048/2048 bytes at offset 4296849408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296853504 ++read 2048/2048 bytes at offset 4296853504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296857600 ++read 2048/2048 bytes at offset 4296857600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296861696 ++read 2048/2048 bytes at offset 4296861696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296865792 ++read 2048/2048 bytes at offset 4296865792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296869888 ++read 2048/2048 bytes at offset 4296869888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296873984 ++read 2048/2048 bytes at offset 4296873984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296878080 ++read 2048/2048 bytes at offset 4296878080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296882176 ++read 2048/2048 bytes at offset 4296882176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296886272 ++read 2048/2048 bytes at offset 4296886272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296890368 ++read 2048/2048 bytes at offset 4296890368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296894464 ++read 2048/2048 bytes at offset 4296894464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296898560 ++read 2048/2048 bytes at offset 4296898560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296902656 ++read 2048/2048 bytes at offset 4296902656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296906752 ++read 2048/2048 bytes at offset 4296906752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296910848 ++read 2048/2048 bytes at offset 4296910848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296914944 ++read 2048/2048 bytes at offset 4296914944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296919040 ++read 2048/2048 bytes at offset 4296919040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296923136 ++read 2048/2048 bytes at offset 4296923136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296927232 ++read 2048/2048 bytes at offset 4296927232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296931328 ++read 2048/2048 bytes at offset 4296931328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296935424 ++read 2048/2048 bytes at offset 4296935424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296939520 ++read 2048/2048 bytes at offset 4296939520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296943616 ++read 2048/2048 bytes at offset 4296943616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296947712 ++read 2048/2048 bytes at offset 4296947712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296951808 ++read 2048/2048 bytes at offset 4296951808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296955904 ++read 2048/2048 bytes at offset 4296955904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296960000 ++read 2048/2048 bytes at offset 4296960000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296964096 ++read 2048/2048 bytes at offset 4296964096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296968192 ++read 2048/2048 bytes at offset 4296968192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296972288 ++read 2048/2048 bytes at offset 4296972288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296976384 ++read 2048/2048 bytes at offset 4296976384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296980480 ++read 2048/2048 bytes at offset 4296980480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296984576 ++read 2048/2048 bytes at offset 4296984576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296988672 ++read 2048/2048 bytes at offset 4296988672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296992768 ++read 2048/2048 bytes at offset 4296992768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296996864 ++read 2048/2048 bytes at offset 4296996864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297000960 ++read 2048/2048 bytes at offset 4297000960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297005056 ++read 2048/2048 bytes at offset 4297005056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297009152 ++read 2048/2048 bytes at offset 4297009152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297013248 ++read 2048/2048 bytes at offset 4297013248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297017344 ++read 2048/2048 bytes at offset 4297017344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297021440 ++read 2048/2048 bytes at offset 4297021440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297025536 ++read 2048/2048 bytes at offset 4297025536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297029632 ++read 2048/2048 bytes at offset 4297029632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297033728 ++read 2048/2048 bytes at offset 4297033728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297037824 ++read 2048/2048 bytes at offset 4297037824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297041920 ++read 2048/2048 bytes at offset 4297041920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297046016 ++read 2048/2048 bytes at offset 4297046016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297050112 ++read 2048/2048 bytes at offset 4297050112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297054208 ++read 2048/2048 bytes at offset 4297054208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297058304 ++read 2048/2048 bytes at offset 4297058304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297062400 ++read 2048/2048 bytes at offset 4297062400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> read 2048/2048 bytes at offset 4297064448 ++=== IO: pattern 0 ++read 2048/2048 bytes at offset 4297064448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297068544 ++read 2048/2048 bytes at offset 4297068544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297072640 ++read 2048/2048 bytes at offset 4297072640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297076736 ++read 2048/2048 bytes at offset 4297076736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297080832 ++read 2048/2048 bytes at offset 4297080832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297084928 ++read 2048/2048 bytes at offset 4297084928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297089024 ++read 2048/2048 bytes at offset 4297089024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297093120 ++read 2048/2048 bytes at offset 4297093120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297097216 ++read 2048/2048 bytes at offset 4297097216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297101312 ++read 2048/2048 bytes at offset 4297101312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297105408 ++read 2048/2048 bytes at offset 4297105408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297109504 ++read 2048/2048 bytes at offset 4297109504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297113600 ++read 2048/2048 bytes at offset 4297113600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297117696 ++read 2048/2048 bytes at offset 4297117696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297121792 ++read 2048/2048 bytes at offset 4297121792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297125888 ++read 2048/2048 bytes at offset 4297125888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297129984 ++read 2048/2048 bytes at offset 4297129984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297134080 ++read 2048/2048 bytes at offset 4297134080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297138176 ++read 2048/2048 bytes at offset 4297138176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297142272 ++read 2048/2048 bytes at offset 4297142272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297146368 ++read 2048/2048 bytes at offset 4297146368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297150464 ++read 2048/2048 bytes at offset 4297150464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297154560 ++read 2048/2048 bytes at offset 4297154560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297158656 ++read 2048/2048 bytes at offset 4297158656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297162752 ++read 2048/2048 bytes at offset 4297162752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297166848 ++read 2048/2048 bytes at offset 4297166848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297170944 ++read 2048/2048 bytes at offset 4297170944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297175040 ++read 2048/2048 bytes at offset 4297175040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297179136 ++read 2048/2048 bytes at offset 4297179136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297183232 ++read 2048/2048 bytes at offset 4297183232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297187328 ++read 2048/2048 bytes at offset 4297187328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297191424 ++read 2048/2048 bytes at offset 4297191424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297195520 ++read 2048/2048 bytes at offset 4297195520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297199616 ++read 2048/2048 bytes at offset 4297199616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297203712 ++read 2048/2048 bytes at offset 4297203712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297207808 ++read 2048/2048 bytes at offset 4297207808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297211904 ++read 2048/2048 bytes at offset 4297211904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297216000 ++read 2048/2048 bytes at offset 4297216000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297220096 ++read 2048/2048 bytes at offset 4297220096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297224192 ++read 2048/2048 bytes at offset 4297224192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297228288 ++read 2048/2048 bytes at offset 4297228288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297232384 ++read 2048/2048 bytes at offset 4297232384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297236480 ++read 2048/2048 bytes at offset 4297236480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297240576 ++read 2048/2048 bytes at offset 4297240576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297244672 ++read 2048/2048 bytes at offset 4297244672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297248768 ++read 2048/2048 bytes at offset 4297248768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297252864 ++read 2048/2048 bytes at offset 4297252864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297256960 ++read 2048/2048 bytes at offset 4297256960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297261056 ++read 2048/2048 bytes at offset 4297261056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297265152 ++read 2048/2048 bytes at offset 4297265152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297269248 ++read 2048/2048 bytes at offset 4297269248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297273344 ++read 2048/2048 bytes at offset 4297273344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297277440 ++read 2048/2048 bytes at offset 4297277440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297281536 ++read 2048/2048 bytes at offset 4297281536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297285632 ++read 2048/2048 bytes at offset 4297285632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297289728 ++read 2048/2048 bytes at offset 4297289728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297293824 ++read 2048/2048 bytes at offset 4297293824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297297920 ++read 2048/2048 bytes at offset 4297297920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297302016 ++read 2048/2048 bytes at offset 4297302016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297306112 ++read 2048/2048 bytes at offset 4297306112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297310208 ++read 2048/2048 bytes at offset 4297310208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297314304 ++read 2048/2048 bytes at offset 4297314304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297318400 ++read 2048/2048 bytes at offset 4297318400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297322496 ++read 2048/2048 bytes at offset 4297322496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297326592 ++read 2048/2048 bytes at offset 4297326592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297330688 ++read 2048/2048 bytes at offset 4297330688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297334784 ++read 2048/2048 bytes at offset 4297334784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297338880 ++read 2048/2048 bytes at offset 4297338880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297342976 ++read 2048/2048 bytes at offset 4297342976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297347072 ++read 2048/2048 bytes at offset 4297347072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297351168 ++read 2048/2048 bytes at offset 4297351168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297355264 ++read 2048/2048 bytes at offset 4297355264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297359360 ++read 2048/2048 bytes at offset 4297359360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297363456 ++read 2048/2048 bytes at offset 4297363456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297367552 ++read 2048/2048 bytes at offset 4297367552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297371648 ++read 2048/2048 bytes at offset 4297371648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297375744 ++read 2048/2048 bytes at offset 4297375744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297379840 ++read 2048/2048 bytes at offset 4297379840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297383936 ++read 2048/2048 bytes at offset 4297383936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297388032 ++read 2048/2048 bytes at offset 4297388032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297392128 ++read 2048/2048 bytes at offset 4297392128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297396224 ++read 2048/2048 bytes at offset 4297396224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297400320 ++read 2048/2048 bytes at offset 4297400320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297404416 ++read 2048/2048 bytes at offset 4297404416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297408512 ++read 2048/2048 bytes at offset 4297408512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297412608 ++read 2048/2048 bytes at offset 4297412608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297416704 ++read 2048/2048 bytes at offset 4297416704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297420800 ++read 2048/2048 bytes at offset 4297420800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297424896 ++read 2048/2048 bytes at offset 4297424896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297428992 ++read 2048/2048 bytes at offset 4297428992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297433088 ++read 2048/2048 bytes at offset 4297433088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297437184 ++read 2048/2048 bytes at offset 4297437184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297441280 ++read 2048/2048 bytes at offset 4297441280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297445376 ++read 2048/2048 bytes at offset 4297445376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297449472 ++read 2048/2048 bytes at offset 4297449472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297453568 ++read 2048/2048 bytes at offset 4297453568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297457664 ++read 2048/2048 bytes at offset 4297457664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297461760 ++read 2048/2048 bytes at offset 4297461760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297465856 ++read 2048/2048 bytes at offset 4297465856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297469952 ++read 2048/2048 bytes at offset 4297469952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297474048 ++read 2048/2048 bytes at offset 4297474048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297478144 ++read 2048/2048 bytes at offset 4297478144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297482240 ++read 2048/2048 bytes at offset 4297482240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297486336 ++read 2048/2048 bytes at offset 4297486336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297490432 ++read 2048/2048 bytes at offset 4297490432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297494528 ++read 2048/2048 bytes at offset 4297494528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297498624 ++read 2048/2048 bytes at offset 4297498624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297502720 ++read 2048/2048 bytes at offset 4297502720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297506816 ++read 2048/2048 bytes at offset 4297506816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297510912 ++read 2048/2048 bytes at offset 4297510912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297515008 ++read 2048/2048 bytes at offset 4297515008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297519104 ++read 2048/2048 bytes at offset 4297519104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297523200 ++read 2048/2048 bytes at offset 4297523200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297527296 ++read 2048/2048 bytes at offset 4297527296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297531392 ++read 2048/2048 bytes at offset 4297531392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297535488 ++read 2048/2048 bytes at offset 4297535488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297539584 ++read 2048/2048 bytes at offset 4297539584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297543680 ++read 2048/2048 bytes at offset 4297543680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297547776 ++read 2048/2048 bytes at offset 4297547776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297551872 ++read 2048/2048 bytes at offset 4297551872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297555968 ++read 2048/2048 bytes at offset 4297555968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297560064 ++read 2048/2048 bytes at offset 4297560064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297564160 ++read 2048/2048 bytes at offset 4297564160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297568256 ++read 2048/2048 bytes at offset 4297568256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297572352 ++read 2048/2048 bytes at offset 4297572352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297576448 ++read 2048/2048 bytes at offset 4297576448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297580544 ++read 2048/2048 bytes at offset 4297580544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297584640 ++read 2048/2048 bytes at offset 4297584640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297588736 ++read 2048/2048 bytes at offset 4297588736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297592832 ++read 2048/2048 bytes at offset 4297592832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297596928 ++read 2048/2048 bytes at offset 4297596928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297601024 ++read 2048/2048 bytes at offset 4297601024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297605120 ++read 2048/2048 bytes at offset 4297605120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297609216 ++read 2048/2048 bytes at offset 4297609216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297613312 ++read 2048/2048 bytes at offset 4297613312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297617408 ++read 2048/2048 bytes at offset 4297617408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297621504 ++read 2048/2048 bytes at offset 4297621504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297625600 ++read 2048/2048 bytes at offset 4297625600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297629696 ++read 2048/2048 bytes at offset 4297629696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297633792 ++read 2048/2048 bytes at offset 4297633792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297637888 ++read 2048/2048 bytes at offset 4297637888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297641984 ++read 2048/2048 bytes at offset 4297641984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297646080 ++read 2048/2048 bytes at offset 4297646080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297650176 ++read 2048/2048 bytes at offset 4297650176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297654272 ++read 2048/2048 bytes at offset 4297654272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297658368 ++read 2048/2048 bytes at offset 4297658368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297662464 ++read 2048/2048 bytes at offset 4297662464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297666560 ++read 2048/2048 bytes at offset 4297666560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297670656 ++read 2048/2048 bytes at offset 4297670656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297674752 ++read 2048/2048 bytes at offset 4297674752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297678848 ++read 2048/2048 bytes at offset 4297678848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297682944 ++read 2048/2048 bytes at offset 4297682944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297687040 ++read 2048/2048 bytes at offset 4297687040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297691136 ++read 2048/2048 bytes at offset 4297691136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297695232 ++read 2048/2048 bytes at offset 4297695232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297699328 ++read 2048/2048 bytes at offset 4297699328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297703424 ++read 2048/2048 bytes at offset 4297703424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297707520 ++read 2048/2048 bytes at offset 4297707520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297711616 ++read 2048/2048 bytes at offset 4297711616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297715712 ++read 2048/2048 bytes at offset 4297715712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297719808 ++read 2048/2048 bytes at offset 4297719808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297723904 ++read 2048/2048 bytes at offset 4297723904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297728000 ++read 2048/2048 bytes at offset 4297728000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297732096 ++read 2048/2048 bytes at offset 4297732096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297736192 ++read 2048/2048 bytes at offset 4297736192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297740288 ++read 2048/2048 bytes at offset 4297740288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297744384 ++read 2048/2048 bytes at offset 4297744384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297748480 ++read 2048/2048 bytes at offset 4297748480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297752576 ++read 2048/2048 bytes at offset 4297752576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297756672 ++read 2048/2048 bytes at offset 4297756672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297760768 ++read 2048/2048 bytes at offset 4297760768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297764864 ++read 2048/2048 bytes at offset 4297764864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297768960 ++read 2048/2048 bytes at offset 4297768960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297773056 ++read 2048/2048 bytes at offset 4297773056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297777152 ++read 2048/2048 bytes at offset 4297777152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297781248 ++read 2048/2048 bytes at offset 4297781248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297785344 ++read 2048/2048 bytes at offset 4297785344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297789440 ++read 2048/2048 bytes at offset 4297789440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297793536 ++read 2048/2048 bytes at offset 4297793536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297797632 ++read 2048/2048 bytes at offset 4297797632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297801728 ++read 2048/2048 bytes at offset 4297801728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297805824 ++read 2048/2048 bytes at offset 4297805824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297809920 ++read 2048/2048 bytes at offset 4297809920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297814016 ++read 2048/2048 bytes at offset 4297814016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297818112 ++read 2048/2048 bytes at offset 4297818112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297822208 ++read 2048/2048 bytes at offset 4297822208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297826304 ++read 2048/2048 bytes at offset 4297826304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297830400 ++read 2048/2048 bytes at offset 4297830400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297834496 ++read 2048/2048 bytes at offset 4297834496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297838592 ++read 2048/2048 bytes at offset 4297838592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297842688 ++read 2048/2048 bytes at offset 4297842688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297846784 ++read 2048/2048 bytes at offset 4297846784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297850880 ++read 2048/2048 bytes at offset 4297850880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297854976 ++read 2048/2048 bytes at offset 4297854976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297859072 ++read 2048/2048 bytes at offset 4297859072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297863168 ++read 2048/2048 bytes at offset 4297863168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297867264 ++read 2048/2048 bytes at offset 4297867264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297871360 ++read 2048/2048 bytes at offset 4297871360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297875456 ++read 2048/2048 bytes at offset 4297875456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297879552 ++read 2048/2048 bytes at offset 4297879552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297883648 ++read 2048/2048 bytes at offset 4297883648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297887744 ++read 2048/2048 bytes at offset 4297887744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297891840 ++read 2048/2048 bytes at offset 4297891840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297895936 ++read 2048/2048 bytes at offset 4297895936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297900032 ++read 2048/2048 bytes at offset 4297900032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297904128 ++read 2048/2048 bytes at offset 4297904128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297908224 ++read 2048/2048 bytes at offset 4297908224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297912320 ++read 2048/2048 bytes at offset 4297912320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297916416 ++read 2048/2048 bytes at offset 4297916416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297920512 ++read 2048/2048 bytes at offset 4297920512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297924608 ++read 2048/2048 bytes at offset 4297924608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297928704 ++read 2048/2048 bytes at offset 4297928704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297932800 ++read 2048/2048 bytes at offset 4297932800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297936896 ++read 2048/2048 bytes at offset 4297936896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297940992 ++read 2048/2048 bytes at offset 4297940992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297945088 ++read 2048/2048 bytes at offset 4297945088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297949184 ++read 2048/2048 bytes at offset 4297949184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297953280 ++read 2048/2048 bytes at offset 4297953280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297957376 ++read 2048/2048 bytes at offset 4297957376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297961472 ++read 2048/2048 bytes at offset 4297961472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297965568 ++read 2048/2048 bytes at offset 4297965568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297969664 ++read 2048/2048 bytes at offset 4297969664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297973760 ++read 2048/2048 bytes at offset 4297973760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297977856 ++read 2048/2048 bytes at offset 4297977856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297981952 ++read 2048/2048 bytes at offset 4297981952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297986048 ++read 2048/2048 bytes at offset 4297986048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297990144 ++read 2048/2048 bytes at offset 4297990144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297994240 ++read 2048/2048 bytes at offset 4297994240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297998336 ++read 2048/2048 bytes at offset 4297998336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298002432 ++read 2048/2048 bytes at offset 4298002432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298006528 ++read 2048/2048 bytes at offset 4298006528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298010624 ++read 2048/2048 bytes at offset 4298010624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298014720 ++read 2048/2048 bytes at offset 4298014720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298018816 ++read 2048/2048 bytes at offset 4298018816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298022912 ++read 2048/2048 bytes at offset 4298022912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298027008 ++read 2048/2048 bytes at offset 4298027008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298031104 ++read 2048/2048 bytes at offset 4298031104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298035200 ++read 2048/2048 bytes at offset 4298035200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298039296 ++read 2048/2048 bytes at offset 4298039296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298043392 ++read 2048/2048 bytes at offset 4298043392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298047488 ++read 2048/2048 bytes at offset 4298047488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298051584 ++read 2048/2048 bytes at offset 4298051584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298055680 ++read 2048/2048 bytes at offset 4298055680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298059776 ++read 2048/2048 bytes at offset 4298059776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298063872 ++read 2048/2048 bytes at offset 4298063872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298067968 ++read 2048/2048 bytes at offset 4298067968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298072064 ++read 2048/2048 bytes at offset 4298072064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298076160 ++read 2048/2048 bytes at offset 4298076160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298080256 ++read 2048/2048 bytes at offset 4298080256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298084352 ++read 2048/2048 bytes at offset 4298084352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298088448 ++read 2048/2048 bytes at offset 4298088448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298092544 ++read 2048/2048 bytes at offset 4298092544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298096640 ++read 2048/2048 bytes at offset 4298096640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298100736 ++read 2048/2048 bytes at offset 4298100736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298104832 ++read 2048/2048 bytes at offset 4298104832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298108928 ++read 2048/2048 bytes at offset 4298108928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 2 +-qemu-io> read 2048/2048 bytes at offset 4298114048 ++=== IO: pattern 2 ++read 2048/2048 bytes at offset 4298114048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298118144 ++read 2048/2048 bytes at offset 4298118144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298122240 ++read 2048/2048 bytes at offset 4298122240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298126336 ++read 2048/2048 bytes at offset 4298126336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298130432 ++read 2048/2048 bytes at offset 4298130432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298134528 ++read 2048/2048 bytes at offset 4298134528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298138624 ++read 2048/2048 bytes at offset 4298138624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298142720 ++read 2048/2048 bytes at offset 4298142720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298146816 ++read 2048/2048 bytes at offset 4298146816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298150912 ++read 2048/2048 bytes at offset 4298150912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298155008 ++read 2048/2048 bytes at offset 4298155008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298159104 ++read 2048/2048 bytes at offset 4298159104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298163200 ++read 2048/2048 bytes at offset 4298163200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298167296 ++read 2048/2048 bytes at offset 4298167296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298171392 ++read 2048/2048 bytes at offset 4298171392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298175488 ++read 2048/2048 bytes at offset 4298175488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298179584 ++read 2048/2048 bytes at offset 4298179584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298183680 ++read 2048/2048 bytes at offset 4298183680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298187776 ++read 2048/2048 bytes at offset 4298187776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298191872 ++read 2048/2048 bytes at offset 4298191872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298195968 ++read 2048/2048 bytes at offset 4298195968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298200064 ++read 2048/2048 bytes at offset 4298200064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298204160 ++read 2048/2048 bytes at offset 4298204160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298208256 ++read 2048/2048 bytes at offset 4298208256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298212352 ++read 2048/2048 bytes at offset 4298212352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298216448 ++read 2048/2048 bytes at offset 4298216448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298220544 ++read 2048/2048 bytes at offset 4298220544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298224640 ++read 2048/2048 bytes at offset 4298224640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298228736 ++read 2048/2048 bytes at offset 4298228736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298232832 ++read 2048/2048 bytes at offset 4298232832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298236928 ++read 2048/2048 bytes at offset 4298236928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298241024 ++read 2048/2048 bytes at offset 4298241024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298245120 ++read 2048/2048 bytes at offset 4298245120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298249216 ++read 2048/2048 bytes at offset 4298249216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298253312 ++read 2048/2048 bytes at offset 4298253312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298257408 ++read 2048/2048 bytes at offset 4298257408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298261504 ++read 2048/2048 bytes at offset 4298261504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298265600 ++read 2048/2048 bytes at offset 4298265600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298269696 ++read 2048/2048 bytes at offset 4298269696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298273792 ++read 2048/2048 bytes at offset 4298273792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298277888 ++read 2048/2048 bytes at offset 4298277888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298281984 ++read 2048/2048 bytes at offset 4298281984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298286080 ++read 2048/2048 bytes at offset 4298286080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298290176 ++read 2048/2048 bytes at offset 4298290176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298294272 ++read 2048/2048 bytes at offset 4298294272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298298368 ++read 2048/2048 bytes at offset 4298298368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298302464 ++read 2048/2048 bytes at offset 4298302464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298306560 ++read 2048/2048 bytes at offset 4298306560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298310656 ++read 2048/2048 bytes at offset 4298310656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298314752 ++read 2048/2048 bytes at offset 4298314752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298318848 ++read 2048/2048 bytes at offset 4298318848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298322944 ++read 2048/2048 bytes at offset 4298322944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298327040 ++read 2048/2048 bytes at offset 4298327040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298331136 ++read 2048/2048 bytes at offset 4298331136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298335232 ++read 2048/2048 bytes at offset 4298335232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298339328 ++read 2048/2048 bytes at offset 4298339328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298343424 ++read 2048/2048 bytes at offset 4298343424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298347520 ++read 2048/2048 bytes at offset 4298347520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298351616 ++read 2048/2048 bytes at offset 4298351616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298355712 ++read 2048/2048 bytes at offset 4298355712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298359808 ++read 2048/2048 bytes at offset 4298359808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298363904 ++read 2048/2048 bytes at offset 4298363904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298368000 ++read 2048/2048 bytes at offset 4298368000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298372096 ++read 2048/2048 bytes at offset 4298372096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298376192 ++read 2048/2048 bytes at offset 4298376192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298380288 ++read 2048/2048 bytes at offset 4298380288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298384384 ++read 2048/2048 bytes at offset 4298384384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298388480 ++read 2048/2048 bytes at offset 4298388480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298392576 ++read 2048/2048 bytes at offset 4298392576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298396672 ++read 2048/2048 bytes at offset 4298396672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298400768 ++read 2048/2048 bytes at offset 4298400768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298404864 ++read 2048/2048 bytes at offset 4298404864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298408960 ++read 2048/2048 bytes at offset 4298408960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298413056 ++read 2048/2048 bytes at offset 4298413056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298417152 ++read 2048/2048 bytes at offset 4298417152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298421248 ++read 2048/2048 bytes at offset 4298421248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298425344 ++read 2048/2048 bytes at offset 4298425344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298429440 ++read 2048/2048 bytes at offset 4298429440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298433536 ++read 2048/2048 bytes at offset 4298433536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298437632 ++read 2048/2048 bytes at offset 4298437632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298441728 ++read 2048/2048 bytes at offset 4298441728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298445824 ++read 2048/2048 bytes at offset 4298445824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298449920 ++read 2048/2048 bytes at offset 4298449920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298454016 ++read 2048/2048 bytes at offset 4298454016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298458112 ++read 2048/2048 bytes at offset 4298458112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298462208 ++read 2048/2048 bytes at offset 4298462208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298466304 ++read 2048/2048 bytes at offset 4298466304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298470400 ++read 2048/2048 bytes at offset 4298470400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298474496 ++read 2048/2048 bytes at offset 4298474496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298478592 ++read 2048/2048 bytes at offset 4298478592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298482688 ++read 2048/2048 bytes at offset 4298482688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298486784 ++read 2048/2048 bytes at offset 4298486784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298490880 ++read 2048/2048 bytes at offset 4298490880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298494976 ++read 2048/2048 bytes at offset 4298494976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298499072 ++read 2048/2048 bytes at offset 4298499072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298503168 ++read 2048/2048 bytes at offset 4298503168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298507264 ++read 2048/2048 bytes at offset 4298507264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298511360 ++read 2048/2048 bytes at offset 4298511360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298515456 ++read 2048/2048 bytes at offset 4298515456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298519552 ++read 2048/2048 bytes at offset 4298519552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298523648 ++read 2048/2048 bytes at offset 4298523648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298527744 ++read 2048/2048 bytes at offset 4298527744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298531840 ++read 2048/2048 bytes at offset 4298531840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298535936 ++read 2048/2048 bytes at offset 4298535936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298540032 ++read 2048/2048 bytes at offset 4298540032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298544128 ++read 2048/2048 bytes at offset 4298544128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298548224 ++read 2048/2048 bytes at offset 4298548224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298552320 ++read 2048/2048 bytes at offset 4298552320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298556416 ++read 2048/2048 bytes at offset 4298556416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298560512 ++read 2048/2048 bytes at offset 4298560512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298564608 ++read 2048/2048 bytes at offset 4298564608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298568704 ++read 2048/2048 bytes at offset 4298568704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298572800 ++read 2048/2048 bytes at offset 4298572800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298576896 ++read 2048/2048 bytes at offset 4298576896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298580992 ++read 2048/2048 bytes at offset 4298580992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298585088 ++read 2048/2048 bytes at offset 4298585088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298589184 ++read 2048/2048 bytes at offset 4298589184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298593280 ++read 2048/2048 bytes at offset 4298593280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298597376 ++read 2048/2048 bytes at offset 4298597376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298601472 ++read 2048/2048 bytes at offset 4298601472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298605568 ++read 2048/2048 bytes at offset 4298605568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298609664 ++read 2048/2048 bytes at offset 4298609664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298613760 ++read 2048/2048 bytes at offset 4298613760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298617856 ++read 2048/2048 bytes at offset 4298617856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298621952 ++read 2048/2048 bytes at offset 4298621952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298626048 ++read 2048/2048 bytes at offset 4298626048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298630144 ++read 2048/2048 bytes at offset 4298630144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298634240 ++read 2048/2048 bytes at offset 4298634240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298638336 ++read 2048/2048 bytes at offset 4298638336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298642432 ++read 2048/2048 bytes at offset 4298642432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298646528 ++read 2048/2048 bytes at offset 4298646528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298650624 ++read 2048/2048 bytes at offset 4298650624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298654720 ++read 2048/2048 bytes at offset 4298654720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298658816 ++read 2048/2048 bytes at offset 4298658816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298662912 ++read 2048/2048 bytes at offset 4298662912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298667008 ++read 2048/2048 bytes at offset 4298667008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298671104 ++read 2048/2048 bytes at offset 4298671104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298675200 ++read 2048/2048 bytes at offset 4298675200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298679296 ++read 2048/2048 bytes at offset 4298679296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298683392 ++read 2048/2048 bytes at offset 4298683392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298687488 ++read 2048/2048 bytes at offset 4298687488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298691584 ++read 2048/2048 bytes at offset 4298691584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298695680 ++read 2048/2048 bytes at offset 4298695680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298699776 ++read 2048/2048 bytes at offset 4298699776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298703872 ++read 2048/2048 bytes at offset 4298703872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298707968 ++read 2048/2048 bytes at offset 4298707968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298712064 ++read 2048/2048 bytes at offset 4298712064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298716160 ++read 2048/2048 bytes at offset 4298716160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298720256 ++read 2048/2048 bytes at offset 4298720256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298724352 ++read 2048/2048 bytes at offset 4298724352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298728448 ++read 2048/2048 bytes at offset 4298728448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298732544 ++read 2048/2048 bytes at offset 4298732544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298736640 ++read 2048/2048 bytes at offset 4298736640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298740736 ++read 2048/2048 bytes at offset 4298740736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298744832 ++read 2048/2048 bytes at offset 4298744832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298748928 ++read 2048/2048 bytes at offset 4298748928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298753024 ++read 2048/2048 bytes at offset 4298753024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298757120 ++read 2048/2048 bytes at offset 4298757120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298761216 ++read 2048/2048 bytes at offset 4298761216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298765312 ++read 2048/2048 bytes at offset 4298765312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298769408 ++read 2048/2048 bytes at offset 4298769408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298773504 ++read 2048/2048 bytes at offset 4298773504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298777600 ++read 2048/2048 bytes at offset 4298777600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298781696 ++read 2048/2048 bytes at offset 4298781696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298785792 ++read 2048/2048 bytes at offset 4298785792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298789888 ++read 2048/2048 bytes at offset 4298789888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298793984 ++read 2048/2048 bytes at offset 4298793984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298798080 ++read 2048/2048 bytes at offset 4298798080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298802176 ++read 2048/2048 bytes at offset 4298802176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298806272 ++read 2048/2048 bytes at offset 4298806272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298810368 ++read 2048/2048 bytes at offset 4298810368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298814464 ++read 2048/2048 bytes at offset 4298814464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298818560 ++read 2048/2048 bytes at offset 4298818560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298822656 ++read 2048/2048 bytes at offset 4298822656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298826752 ++read 2048/2048 bytes at offset 4298826752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298830848 ++read 2048/2048 bytes at offset 4298830848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298834944 ++read 2048/2048 bytes at offset 4298834944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298839040 ++read 2048/2048 bytes at offset 4298839040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298843136 ++read 2048/2048 bytes at offset 4298843136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298847232 ++read 2048/2048 bytes at offset 4298847232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298851328 ++read 2048/2048 bytes at offset 4298851328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298855424 ++read 2048/2048 bytes at offset 4298855424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298859520 ++read 2048/2048 bytes at offset 4298859520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298863616 ++read 2048/2048 bytes at offset 4298863616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298867712 ++read 2048/2048 bytes at offset 4298867712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298871808 ++read 2048/2048 bytes at offset 4298871808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298875904 ++read 2048/2048 bytes at offset 4298875904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298880000 ++read 2048/2048 bytes at offset 4298880000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298884096 ++read 2048/2048 bytes at offset 4298884096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298888192 ++read 2048/2048 bytes at offset 4298888192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298892288 ++read 2048/2048 bytes at offset 4298892288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298896384 ++read 2048/2048 bytes at offset 4298896384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298900480 ++read 2048/2048 bytes at offset 4298900480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298904576 ++read 2048/2048 bytes at offset 4298904576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298908672 ++read 2048/2048 bytes at offset 4298908672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298912768 ++read 2048/2048 bytes at offset 4298912768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298916864 ++read 2048/2048 bytes at offset 4298916864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298920960 ++read 2048/2048 bytes at offset 4298920960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298925056 ++read 2048/2048 bytes at offset 4298925056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298929152 ++read 2048/2048 bytes at offset 4298929152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298933248 ++read 2048/2048 bytes at offset 4298933248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298937344 ++read 2048/2048 bytes at offset 4298937344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298941440 ++read 2048/2048 bytes at offset 4298941440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298945536 ++read 2048/2048 bytes at offset 4298945536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298949632 ++read 2048/2048 bytes at offset 4298949632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298953728 ++read 2048/2048 bytes at offset 4298953728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298957824 ++read 2048/2048 bytes at offset 4298957824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298961920 ++read 2048/2048 bytes at offset 4298961920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298966016 ++read 2048/2048 bytes at offset 4298966016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298970112 ++read 2048/2048 bytes at offset 4298970112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298974208 ++read 2048/2048 bytes at offset 4298974208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298978304 ++read 2048/2048 bytes at offset 4298978304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298982400 ++read 2048/2048 bytes at offset 4298982400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298986496 ++read 2048/2048 bytes at offset 4298986496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298990592 ++read 2048/2048 bytes at offset 4298990592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298994688 ++read 2048/2048 bytes at offset 4298994688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298998784 ++read 2048/2048 bytes at offset 4298998784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299002880 ++read 2048/2048 bytes at offset 4299002880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299006976 ++read 2048/2048 bytes at offset 4299006976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299011072 ++read 2048/2048 bytes at offset 4299011072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299015168 ++read 2048/2048 bytes at offset 4299015168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299019264 ++read 2048/2048 bytes at offset 4299019264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299023360 ++read 2048/2048 bytes at offset 4299023360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299027456 ++read 2048/2048 bytes at offset 4299027456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299031552 ++read 2048/2048 bytes at offset 4299031552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299035648 ++read 2048/2048 bytes at offset 4299035648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299039744 ++read 2048/2048 bytes at offset 4299039744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299043840 ++read 2048/2048 bytes at offset 4299043840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299047936 ++read 2048/2048 bytes at offset 4299047936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299052032 ++read 2048/2048 bytes at offset 4299052032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299056128 ++read 2048/2048 bytes at offset 4299056128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299060224 ++read 2048/2048 bytes at offset 4299060224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299064320 ++read 2048/2048 bytes at offset 4299064320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299068416 ++read 2048/2048 bytes at offset 4299068416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299072512 ++read 2048/2048 bytes at offset 4299072512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299076608 ++read 2048/2048 bytes at offset 4299076608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299080704 ++read 2048/2048 bytes at offset 4299080704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299084800 ++read 2048/2048 bytes at offset 4299084800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299088896 ++read 2048/2048 bytes at offset 4299088896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299092992 ++read 2048/2048 bytes at offset 4299092992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299097088 ++read 2048/2048 bytes at offset 4299097088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299101184 ++read 2048/2048 bytes at offset 4299101184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299105280 ++read 2048/2048 bytes at offset 4299105280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299109376 ++read 2048/2048 bytes at offset 4299109376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299113472 ++read 2048/2048 bytes at offset 4299113472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299117568 ++read 2048/2048 bytes at offset 4299117568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299121664 ++read 2048/2048 bytes at offset 4299121664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299125760 ++read 2048/2048 bytes at offset 4299125760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299129856 ++read 2048/2048 bytes at offset 4299129856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299133952 ++read 2048/2048 bytes at offset 4299133952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299138048 ++read 2048/2048 bytes at offset 4299138048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299142144 ++read 2048/2048 bytes at offset 4299142144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299146240 ++read 2048/2048 bytes at offset 4299146240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299150336 ++read 2048/2048 bytes at offset 4299150336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299154432 ++read 2048/2048 bytes at offset 4299154432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299158528 ++read 2048/2048 bytes at offset 4299158528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 4 +-qemu-io> read 8192/8192 bytes at offset 4299163648 ++=== IO: pattern 4 ++read 8192/8192 bytes at offset 4299163648 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299175936 ++read 8192/8192 bytes at offset 4299175936 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299188224 ++read 8192/8192 bytes at offset 4299188224 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299200512 ++read 8192/8192 bytes at offset 4299200512 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299212800 ++read 8192/8192 bytes at offset 4299212800 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299225088 ++read 8192/8192 bytes at offset 4299225088 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299237376 ++read 8192/8192 bytes at offset 4299237376 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299249664 ++read 8192/8192 bytes at offset 4299249664 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299261952 ++read 8192/8192 bytes at offset 4299261952 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299274240 ++read 8192/8192 bytes at offset 4299274240 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299286528 ++read 8192/8192 bytes at offset 4299286528 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299298816 ++read 8192/8192 bytes at offset 4299298816 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299311104 ++read 8192/8192 bytes at offset 4299311104 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299323392 ++read 8192/8192 bytes at offset 4299323392 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299335680 ++read 8192/8192 bytes at offset 4299335680 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299347968 ++read 8192/8192 bytes at offset 4299347968 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299360256 ++read 8192/8192 bytes at offset 4299360256 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299372544 ++read 8192/8192 bytes at offset 4299372544 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299384832 ++read 8192/8192 bytes at offset 4299384832 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299397120 ++read 8192/8192 bytes at offset 4299397120 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299409408 ++read 8192/8192 bytes at offset 4299409408 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299421696 ++read 8192/8192 bytes at offset 4299421696 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299433984 ++read 8192/8192 bytes at offset 4299433984 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299446272 ++read 8192/8192 bytes at offset 4299446272 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299458560 ++read 8192/8192 bytes at offset 4299458560 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299470848 ++read 8192/8192 bytes at offset 4299470848 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299483136 ++read 8192/8192 bytes at offset 4299483136 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299495424 ++read 8192/8192 bytes at offset 4299495424 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299507712 ++read 8192/8192 bytes at offset 4299507712 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299520000 ++read 8192/8192 bytes at offset 4299520000 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299532288 ++read 8192/8192 bytes at offset 4299532288 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299544576 ++read 8192/8192 bytes at offset 4299544576 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299556864 ++read 8192/8192 bytes at offset 4299556864 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299569152 ++read 8192/8192 bytes at offset 4299569152 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299581440 ++read 8192/8192 bytes at offset 4299581440 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299593728 ++read 8192/8192 bytes at offset 4299593728 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299606016 ++read 8192/8192 bytes at offset 4299606016 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299618304 ++read 8192/8192 bytes at offset 4299618304 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299630592 ++read 8192/8192 bytes at offset 4299630592 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299642880 ++read 8192/8192 bytes at offset 4299642880 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299655168 ++read 8192/8192 bytes at offset 4299655168 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299667456 ++read 8192/8192 bytes at offset 4299667456 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299679744 ++read 8192/8192 bytes at offset 4299679744 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299692032 ++read 8192/8192 bytes at offset 4299692032 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299704320 ++read 8192/8192 bytes at offset 4299704320 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299716608 ++read 8192/8192 bytes at offset 4299716608 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299728896 ++read 8192/8192 bytes at offset 4299728896 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299741184 ++read 8192/8192 bytes at offset 4299741184 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299753472 ++read 8192/8192 bytes at offset 4299753472 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299765760 ++read 8192/8192 bytes at offset 4299765760 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299778048 ++read 8192/8192 bytes at offset 4299778048 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299790336 ++read 8192/8192 bytes at offset 4299790336 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299802624 ++read 8192/8192 bytes at offset 4299802624 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299814912 ++read 8192/8192 bytes at offset 4299814912 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299827200 ++read 8192/8192 bytes at offset 4299827200 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299839488 ++read 8192/8192 bytes at offset 4299839488 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299851776 ++read 8192/8192 bytes at offset 4299851776 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299864064 ++read 8192/8192 bytes at offset 4299864064 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299876352 ++read 8192/8192 bytes at offset 4299876352 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299888640 ++read 8192/8192 bytes at offset 4299888640 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299900928 ++read 8192/8192 bytes at offset 4299900928 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299913216 ++read 8192/8192 bytes at offset 4299913216 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299925504 ++read 8192/8192 bytes at offset 4299925504 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299937792 ++read 8192/8192 bytes at offset 4299937792 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 244 +-qemu-io> read 12288/12288 bytes at offset 4301252608 ++=== IO: pattern 244 ++read 12288/12288 bytes at offset 4301252608 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4303351808 ++read 12288/12288 bytes at offset 4303351808 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4305451008 ++read 12288/12288 bytes at offset 4305451008 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4307550208 ++read 12288/12288 bytes at offset 4307550208 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4309649408 ++read 12288/12288 bytes at offset 4309649408 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4311748608 ++read 12288/12288 bytes at offset 4311748608 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4313847808 ++read 12288/12288 bytes at offset 4313847808 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4315947008 ++read 12288/12288 bytes at offset 4315947008 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> wrote 4096/4096 bytes at offset 4294967296 ++=== IO: pattern 0 ++wrote 4096/4096 bytes at offset 4294967296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4294971392 ++wrote 4096/4096 bytes at offset 4294971392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4294975488 ++wrote 4096/4096 bytes at offset 4294975488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4294979584 ++wrote 4096/4096 bytes at offset 4294979584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4294983680 ++wrote 4096/4096 bytes at offset 4294983680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4294987776 ++wrote 4096/4096 bytes at offset 4294987776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4294991872 ++wrote 4096/4096 bytes at offset 4294991872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4294995968 ++wrote 4096/4096 bytes at offset 4294995968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295000064 ++wrote 4096/4096 bytes at offset 4295000064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295004160 ++wrote 4096/4096 bytes at offset 4295004160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295008256 ++wrote 4096/4096 bytes at offset 4295008256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295012352 ++wrote 4096/4096 bytes at offset 4295012352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295016448 ++wrote 4096/4096 bytes at offset 4295016448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295020544 ++wrote 4096/4096 bytes at offset 4295020544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295024640 ++wrote 4096/4096 bytes at offset 4295024640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295028736 ++wrote 4096/4096 bytes at offset 4295028736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295032832 ++wrote 4096/4096 bytes at offset 4295032832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295036928 ++wrote 4096/4096 bytes at offset 4295036928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295041024 ++wrote 4096/4096 bytes at offset 4295041024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295045120 ++wrote 4096/4096 bytes at offset 4295045120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295049216 ++wrote 4096/4096 bytes at offset 4295049216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295053312 ++wrote 4096/4096 bytes at offset 4295053312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295057408 ++wrote 4096/4096 bytes at offset 4295057408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295061504 ++wrote 4096/4096 bytes at offset 4295061504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295065600 ++wrote 4096/4096 bytes at offset 4295065600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295069696 ++wrote 4096/4096 bytes at offset 4295069696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295073792 ++wrote 4096/4096 bytes at offset 4295073792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295077888 ++wrote 4096/4096 bytes at offset 4295077888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295081984 ++wrote 4096/4096 bytes at offset 4295081984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295086080 ++wrote 4096/4096 bytes at offset 4295086080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295090176 ++wrote 4096/4096 bytes at offset 4295090176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295094272 ++wrote 4096/4096 bytes at offset 4295094272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295098368 ++wrote 4096/4096 bytes at offset 4295098368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295102464 ++wrote 4096/4096 bytes at offset 4295102464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295106560 ++wrote 4096/4096 bytes at offset 4295106560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295110656 ++wrote 4096/4096 bytes at offset 4295110656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295114752 ++wrote 4096/4096 bytes at offset 4295114752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295118848 ++wrote 4096/4096 bytes at offset 4295118848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295122944 ++wrote 4096/4096 bytes at offset 4295122944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295127040 ++wrote 4096/4096 bytes at offset 4295127040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295131136 ++wrote 4096/4096 bytes at offset 4295131136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295135232 ++wrote 4096/4096 bytes at offset 4295135232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295139328 ++wrote 4096/4096 bytes at offset 4295139328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295143424 ++wrote 4096/4096 bytes at offset 4295143424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295147520 ++wrote 4096/4096 bytes at offset 4295147520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295151616 ++wrote 4096/4096 bytes at offset 4295151616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295155712 ++wrote 4096/4096 bytes at offset 4295155712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295159808 ++wrote 4096/4096 bytes at offset 4295159808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295163904 ++wrote 4096/4096 bytes at offset 4295163904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295168000 ++wrote 4096/4096 bytes at offset 4295168000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295172096 ++wrote 4096/4096 bytes at offset 4295172096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295176192 ++wrote 4096/4096 bytes at offset 4295176192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295180288 ++wrote 4096/4096 bytes at offset 4295180288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295184384 ++wrote 4096/4096 bytes at offset 4295184384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295188480 ++wrote 4096/4096 bytes at offset 4295188480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295192576 ++wrote 4096/4096 bytes at offset 4295192576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295196672 ++wrote 4096/4096 bytes at offset 4295196672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295200768 ++wrote 4096/4096 bytes at offset 4295200768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295204864 ++wrote 4096/4096 bytes at offset 4295204864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295208960 ++wrote 4096/4096 bytes at offset 4295208960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295213056 ++wrote 4096/4096 bytes at offset 4295213056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295217152 ++wrote 4096/4096 bytes at offset 4295217152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295221248 ++wrote 4096/4096 bytes at offset 4295221248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295225344 ++wrote 4096/4096 bytes at offset 4295225344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295229440 ++wrote 4096/4096 bytes at offset 4295229440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295233536 ++wrote 4096/4096 bytes at offset 4295233536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295237632 ++wrote 4096/4096 bytes at offset 4295237632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295241728 ++wrote 4096/4096 bytes at offset 4295241728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295245824 ++wrote 4096/4096 bytes at offset 4295245824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295249920 ++wrote 4096/4096 bytes at offset 4295249920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295254016 ++wrote 4096/4096 bytes at offset 4295254016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295258112 ++wrote 4096/4096 bytes at offset 4295258112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295262208 ++wrote 4096/4096 bytes at offset 4295262208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295266304 ++wrote 4096/4096 bytes at offset 4295266304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295270400 ++wrote 4096/4096 bytes at offset 4295270400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295274496 ++wrote 4096/4096 bytes at offset 4295274496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295278592 ++wrote 4096/4096 bytes at offset 4295278592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295282688 ++wrote 4096/4096 bytes at offset 4295282688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295286784 ++wrote 4096/4096 bytes at offset 4295286784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295290880 ++wrote 4096/4096 bytes at offset 4295290880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295294976 ++wrote 4096/4096 bytes at offset 4295294976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295299072 ++wrote 4096/4096 bytes at offset 4295299072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295303168 ++wrote 4096/4096 bytes at offset 4295303168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295307264 ++wrote 4096/4096 bytes at offset 4295307264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295311360 ++wrote 4096/4096 bytes at offset 4295311360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295315456 ++wrote 4096/4096 bytes at offset 4295315456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295319552 ++wrote 4096/4096 bytes at offset 4295319552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295323648 ++wrote 4096/4096 bytes at offset 4295323648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295327744 ++wrote 4096/4096 bytes at offset 4295327744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295331840 ++wrote 4096/4096 bytes at offset 4295331840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295335936 ++wrote 4096/4096 bytes at offset 4295335936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295340032 ++wrote 4096/4096 bytes at offset 4295340032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295344128 ++wrote 4096/4096 bytes at offset 4295344128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295348224 ++wrote 4096/4096 bytes at offset 4295348224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295352320 ++wrote 4096/4096 bytes at offset 4295352320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295356416 ++wrote 4096/4096 bytes at offset 4295356416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295360512 ++wrote 4096/4096 bytes at offset 4295360512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295364608 ++wrote 4096/4096 bytes at offset 4295364608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295368704 ++wrote 4096/4096 bytes at offset 4295368704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295372800 ++wrote 4096/4096 bytes at offset 4295372800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295376896 ++wrote 4096/4096 bytes at offset 4295376896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295380992 ++wrote 4096/4096 bytes at offset 4295380992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295385088 ++wrote 4096/4096 bytes at offset 4295385088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295389184 ++wrote 4096/4096 bytes at offset 4295389184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295393280 ++wrote 4096/4096 bytes at offset 4295393280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295397376 ++wrote 4096/4096 bytes at offset 4295397376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295401472 ++wrote 4096/4096 bytes at offset 4295401472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295405568 ++wrote 4096/4096 bytes at offset 4295405568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295409664 ++wrote 4096/4096 bytes at offset 4295409664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295413760 ++wrote 4096/4096 bytes at offset 4295413760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295417856 ++wrote 4096/4096 bytes at offset 4295417856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295421952 ++wrote 4096/4096 bytes at offset 4295421952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295426048 ++wrote 4096/4096 bytes at offset 4295426048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295430144 ++wrote 4096/4096 bytes at offset 4295430144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295434240 ++wrote 4096/4096 bytes at offset 4295434240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295438336 ++wrote 4096/4096 bytes at offset 4295438336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295442432 ++wrote 4096/4096 bytes at offset 4295442432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295446528 ++wrote 4096/4096 bytes at offset 4295446528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295450624 ++wrote 4096/4096 bytes at offset 4295450624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295454720 ++wrote 4096/4096 bytes at offset 4295454720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295458816 ++wrote 4096/4096 bytes at offset 4295458816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295462912 ++wrote 4096/4096 bytes at offset 4295462912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295467008 ++wrote 4096/4096 bytes at offset 4295467008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295471104 ++wrote 4096/4096 bytes at offset 4295471104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295475200 ++wrote 4096/4096 bytes at offset 4295475200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295479296 ++wrote 4096/4096 bytes at offset 4295479296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295483392 ++wrote 4096/4096 bytes at offset 4295483392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295487488 ++wrote 4096/4096 bytes at offset 4295487488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295491584 ++wrote 4096/4096 bytes at offset 4295491584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295495680 ++wrote 4096/4096 bytes at offset 4295495680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295499776 ++wrote 4096/4096 bytes at offset 4295499776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295503872 ++wrote 4096/4096 bytes at offset 4295503872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295507968 ++wrote 4096/4096 bytes at offset 4295507968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295512064 ++wrote 4096/4096 bytes at offset 4295512064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295516160 ++wrote 4096/4096 bytes at offset 4295516160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295520256 ++wrote 4096/4096 bytes at offset 4295520256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295524352 ++wrote 4096/4096 bytes at offset 4295524352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295528448 ++wrote 4096/4096 bytes at offset 4295528448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295532544 ++wrote 4096/4096 bytes at offset 4295532544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295536640 ++wrote 4096/4096 bytes at offset 4295536640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295540736 ++wrote 4096/4096 bytes at offset 4295540736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295544832 ++wrote 4096/4096 bytes at offset 4295544832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295548928 ++wrote 4096/4096 bytes at offset 4295548928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295553024 ++wrote 4096/4096 bytes at offset 4295553024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295557120 ++wrote 4096/4096 bytes at offset 4295557120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295561216 ++wrote 4096/4096 bytes at offset 4295561216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295565312 ++wrote 4096/4096 bytes at offset 4295565312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295569408 ++wrote 4096/4096 bytes at offset 4295569408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295573504 ++wrote 4096/4096 bytes at offset 4295573504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295577600 ++wrote 4096/4096 bytes at offset 4295577600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295581696 ++wrote 4096/4096 bytes at offset 4295581696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295585792 ++wrote 4096/4096 bytes at offset 4295585792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295589888 ++wrote 4096/4096 bytes at offset 4295589888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295593984 ++wrote 4096/4096 bytes at offset 4295593984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295598080 ++wrote 4096/4096 bytes at offset 4295598080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295602176 ++wrote 4096/4096 bytes at offset 4295602176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295606272 ++wrote 4096/4096 bytes at offset 4295606272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295610368 ++wrote 4096/4096 bytes at offset 4295610368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295614464 ++wrote 4096/4096 bytes at offset 4295614464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295618560 ++wrote 4096/4096 bytes at offset 4295618560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295622656 ++wrote 4096/4096 bytes at offset 4295622656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295626752 ++wrote 4096/4096 bytes at offset 4295626752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295630848 ++wrote 4096/4096 bytes at offset 4295630848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295634944 ++wrote 4096/4096 bytes at offset 4295634944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295639040 ++wrote 4096/4096 bytes at offset 4295639040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295643136 ++wrote 4096/4096 bytes at offset 4295643136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295647232 ++wrote 4096/4096 bytes at offset 4295647232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295651328 ++wrote 4096/4096 bytes at offset 4295651328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295655424 ++wrote 4096/4096 bytes at offset 4295655424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295659520 ++wrote 4096/4096 bytes at offset 4295659520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295663616 ++wrote 4096/4096 bytes at offset 4295663616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295667712 ++wrote 4096/4096 bytes at offset 4295667712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295671808 ++wrote 4096/4096 bytes at offset 4295671808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295675904 ++wrote 4096/4096 bytes at offset 4295675904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295680000 ++wrote 4096/4096 bytes at offset 4295680000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295684096 ++wrote 4096/4096 bytes at offset 4295684096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295688192 ++wrote 4096/4096 bytes at offset 4295688192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295692288 ++wrote 4096/4096 bytes at offset 4295692288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295696384 ++wrote 4096/4096 bytes at offset 4295696384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295700480 ++wrote 4096/4096 bytes at offset 4295700480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295704576 ++wrote 4096/4096 bytes at offset 4295704576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295708672 ++wrote 4096/4096 bytes at offset 4295708672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295712768 ++wrote 4096/4096 bytes at offset 4295712768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295716864 ++wrote 4096/4096 bytes at offset 4295716864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295720960 ++wrote 4096/4096 bytes at offset 4295720960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295725056 ++wrote 4096/4096 bytes at offset 4295725056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295729152 ++wrote 4096/4096 bytes at offset 4295729152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295733248 ++wrote 4096/4096 bytes at offset 4295733248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295737344 ++wrote 4096/4096 bytes at offset 4295737344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295741440 ++wrote 4096/4096 bytes at offset 4295741440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295745536 ++wrote 4096/4096 bytes at offset 4295745536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295749632 ++wrote 4096/4096 bytes at offset 4295749632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295753728 ++wrote 4096/4096 bytes at offset 4295753728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295757824 ++wrote 4096/4096 bytes at offset 4295757824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295761920 ++wrote 4096/4096 bytes at offset 4295761920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295766016 ++wrote 4096/4096 bytes at offset 4295766016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295770112 ++wrote 4096/4096 bytes at offset 4295770112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295774208 ++wrote 4096/4096 bytes at offset 4295774208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295778304 ++wrote 4096/4096 bytes at offset 4295778304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295782400 ++wrote 4096/4096 bytes at offset 4295782400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295786496 ++wrote 4096/4096 bytes at offset 4295786496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295790592 ++wrote 4096/4096 bytes at offset 4295790592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295794688 ++wrote 4096/4096 bytes at offset 4295794688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295798784 ++wrote 4096/4096 bytes at offset 4295798784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295802880 ++wrote 4096/4096 bytes at offset 4295802880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295806976 ++wrote 4096/4096 bytes at offset 4295806976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295811072 ++wrote 4096/4096 bytes at offset 4295811072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295815168 ++wrote 4096/4096 bytes at offset 4295815168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295819264 ++wrote 4096/4096 bytes at offset 4295819264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295823360 ++wrote 4096/4096 bytes at offset 4295823360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295827456 ++wrote 4096/4096 bytes at offset 4295827456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295831552 ++wrote 4096/4096 bytes at offset 4295831552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295835648 ++wrote 4096/4096 bytes at offset 4295835648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295839744 ++wrote 4096/4096 bytes at offset 4295839744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295843840 ++wrote 4096/4096 bytes at offset 4295843840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295847936 ++wrote 4096/4096 bytes at offset 4295847936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295852032 ++wrote 4096/4096 bytes at offset 4295852032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295856128 ++wrote 4096/4096 bytes at offset 4295856128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295860224 ++wrote 4096/4096 bytes at offset 4295860224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295864320 ++wrote 4096/4096 bytes at offset 4295864320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295868416 ++wrote 4096/4096 bytes at offset 4295868416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295872512 ++wrote 4096/4096 bytes at offset 4295872512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295876608 ++wrote 4096/4096 bytes at offset 4295876608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295880704 ++wrote 4096/4096 bytes at offset 4295880704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295884800 ++wrote 4096/4096 bytes at offset 4295884800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295888896 ++wrote 4096/4096 bytes at offset 4295888896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295892992 ++wrote 4096/4096 bytes at offset 4295892992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295897088 ++wrote 4096/4096 bytes at offset 4295897088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295901184 ++wrote 4096/4096 bytes at offset 4295901184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295905280 ++wrote 4096/4096 bytes at offset 4295905280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295909376 ++wrote 4096/4096 bytes at offset 4295909376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295913472 ++wrote 4096/4096 bytes at offset 4295913472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295917568 ++wrote 4096/4096 bytes at offset 4295917568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295921664 ++wrote 4096/4096 bytes at offset 4295921664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295925760 ++wrote 4096/4096 bytes at offset 4295925760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295929856 ++wrote 4096/4096 bytes at offset 4295929856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295933952 ++wrote 4096/4096 bytes at offset 4295933952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295938048 ++wrote 4096/4096 bytes at offset 4295938048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295942144 ++wrote 4096/4096 bytes at offset 4295942144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295946240 ++wrote 4096/4096 bytes at offset 4295946240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295950336 ++wrote 4096/4096 bytes at offset 4295950336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295954432 ++wrote 4096/4096 bytes at offset 4295954432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295958528 ++wrote 4096/4096 bytes at offset 4295958528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295962624 ++wrote 4096/4096 bytes at offset 4295962624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295966720 ++wrote 4096/4096 bytes at offset 4295966720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295970816 ++wrote 4096/4096 bytes at offset 4295970816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295974912 ++wrote 4096/4096 bytes at offset 4295974912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295979008 ++wrote 4096/4096 bytes at offset 4295979008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295983104 ++wrote 4096/4096 bytes at offset 4295983104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295987200 ++wrote 4096/4096 bytes at offset 4295987200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295991296 ++wrote 4096/4096 bytes at offset 4295991296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295995392 ++wrote 4096/4096 bytes at offset 4295995392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295999488 ++wrote 4096/4096 bytes at offset 4295999488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296003584 ++wrote 4096/4096 bytes at offset 4296003584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296007680 ++wrote 4096/4096 bytes at offset 4296007680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296011776 ++wrote 4096/4096 bytes at offset 4296011776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 4 +-qemu-io> wrote 2048/2048 bytes at offset 4296017920 ++=== IO: pattern 4 ++wrote 2048/2048 bytes at offset 4296017920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296022016 ++wrote 2048/2048 bytes at offset 4296022016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296026112 ++wrote 2048/2048 bytes at offset 4296026112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296030208 ++wrote 2048/2048 bytes at offset 4296030208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296034304 ++wrote 2048/2048 bytes at offset 4296034304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296038400 ++wrote 2048/2048 bytes at offset 4296038400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296042496 ++wrote 2048/2048 bytes at offset 4296042496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296046592 ++wrote 2048/2048 bytes at offset 4296046592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296050688 ++wrote 2048/2048 bytes at offset 4296050688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296054784 ++wrote 2048/2048 bytes at offset 4296054784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296058880 ++wrote 2048/2048 bytes at offset 4296058880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296062976 ++wrote 2048/2048 bytes at offset 4296062976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296067072 ++wrote 2048/2048 bytes at offset 4296067072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296071168 ++wrote 2048/2048 bytes at offset 4296071168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296075264 ++wrote 2048/2048 bytes at offset 4296075264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296079360 ++wrote 2048/2048 bytes at offset 4296079360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296083456 ++wrote 2048/2048 bytes at offset 4296083456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296087552 ++wrote 2048/2048 bytes at offset 4296087552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296091648 ++wrote 2048/2048 bytes at offset 4296091648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296095744 ++wrote 2048/2048 bytes at offset 4296095744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296099840 ++wrote 2048/2048 bytes at offset 4296099840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296103936 ++wrote 2048/2048 bytes at offset 4296103936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296108032 ++wrote 2048/2048 bytes at offset 4296108032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296112128 ++wrote 2048/2048 bytes at offset 4296112128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296116224 ++wrote 2048/2048 bytes at offset 4296116224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296120320 ++wrote 2048/2048 bytes at offset 4296120320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296124416 ++wrote 2048/2048 bytes at offset 4296124416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296128512 ++wrote 2048/2048 bytes at offset 4296128512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296132608 ++wrote 2048/2048 bytes at offset 4296132608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296136704 ++wrote 2048/2048 bytes at offset 4296136704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296140800 ++wrote 2048/2048 bytes at offset 4296140800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296144896 ++wrote 2048/2048 bytes at offset 4296144896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296148992 ++wrote 2048/2048 bytes at offset 4296148992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296153088 ++wrote 2048/2048 bytes at offset 4296153088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296157184 ++wrote 2048/2048 bytes at offset 4296157184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296161280 ++wrote 2048/2048 bytes at offset 4296161280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296165376 ++wrote 2048/2048 bytes at offset 4296165376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296169472 ++wrote 2048/2048 bytes at offset 4296169472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296173568 ++wrote 2048/2048 bytes at offset 4296173568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296177664 ++wrote 2048/2048 bytes at offset 4296177664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296181760 ++wrote 2048/2048 bytes at offset 4296181760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296185856 ++wrote 2048/2048 bytes at offset 4296185856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296189952 ++wrote 2048/2048 bytes at offset 4296189952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296194048 ++wrote 2048/2048 bytes at offset 4296194048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296198144 ++wrote 2048/2048 bytes at offset 4296198144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296202240 ++wrote 2048/2048 bytes at offset 4296202240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296206336 ++wrote 2048/2048 bytes at offset 4296206336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296210432 ++wrote 2048/2048 bytes at offset 4296210432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296214528 ++wrote 2048/2048 bytes at offset 4296214528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296218624 ++wrote 2048/2048 bytes at offset 4296218624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296222720 ++wrote 2048/2048 bytes at offset 4296222720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296226816 ++wrote 2048/2048 bytes at offset 4296226816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296230912 ++wrote 2048/2048 bytes at offset 4296230912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296235008 ++wrote 2048/2048 bytes at offset 4296235008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296239104 ++wrote 2048/2048 bytes at offset 4296239104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296243200 ++wrote 2048/2048 bytes at offset 4296243200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296247296 ++wrote 2048/2048 bytes at offset 4296247296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296251392 ++wrote 2048/2048 bytes at offset 4296251392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296255488 ++wrote 2048/2048 bytes at offset 4296255488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296259584 ++wrote 2048/2048 bytes at offset 4296259584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296263680 ++wrote 2048/2048 bytes at offset 4296263680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296267776 ++wrote 2048/2048 bytes at offset 4296267776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296271872 ++wrote 2048/2048 bytes at offset 4296271872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296275968 ++wrote 2048/2048 bytes at offset 4296275968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296280064 ++wrote 2048/2048 bytes at offset 4296280064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296284160 ++wrote 2048/2048 bytes at offset 4296284160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296288256 ++wrote 2048/2048 bytes at offset 4296288256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296292352 ++wrote 2048/2048 bytes at offset 4296292352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296296448 ++wrote 2048/2048 bytes at offset 4296296448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296300544 ++wrote 2048/2048 bytes at offset 4296300544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296304640 ++wrote 2048/2048 bytes at offset 4296304640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296308736 ++wrote 2048/2048 bytes at offset 4296308736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296312832 ++wrote 2048/2048 bytes at offset 4296312832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296316928 ++wrote 2048/2048 bytes at offset 4296316928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296321024 ++wrote 2048/2048 bytes at offset 4296321024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296325120 ++wrote 2048/2048 bytes at offset 4296325120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296329216 ++wrote 2048/2048 bytes at offset 4296329216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296333312 ++wrote 2048/2048 bytes at offset 4296333312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296337408 ++wrote 2048/2048 bytes at offset 4296337408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296341504 ++wrote 2048/2048 bytes at offset 4296341504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296345600 ++wrote 2048/2048 bytes at offset 4296345600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296349696 ++wrote 2048/2048 bytes at offset 4296349696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296353792 ++wrote 2048/2048 bytes at offset 4296353792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296357888 ++wrote 2048/2048 bytes at offset 4296357888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296361984 ++wrote 2048/2048 bytes at offset 4296361984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296366080 ++wrote 2048/2048 bytes at offset 4296366080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296370176 ++wrote 2048/2048 bytes at offset 4296370176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296374272 ++wrote 2048/2048 bytes at offset 4296374272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296378368 ++wrote 2048/2048 bytes at offset 4296378368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296382464 ++wrote 2048/2048 bytes at offset 4296382464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296386560 ++wrote 2048/2048 bytes at offset 4296386560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296390656 ++wrote 2048/2048 bytes at offset 4296390656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296394752 ++wrote 2048/2048 bytes at offset 4296394752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296398848 ++wrote 2048/2048 bytes at offset 4296398848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296402944 ++wrote 2048/2048 bytes at offset 4296402944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296407040 ++wrote 2048/2048 bytes at offset 4296407040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296411136 ++wrote 2048/2048 bytes at offset 4296411136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296415232 ++wrote 2048/2048 bytes at offset 4296415232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296419328 ++wrote 2048/2048 bytes at offset 4296419328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296423424 ++wrote 2048/2048 bytes at offset 4296423424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296427520 ++wrote 2048/2048 bytes at offset 4296427520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296431616 ++wrote 2048/2048 bytes at offset 4296431616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296435712 ++wrote 2048/2048 bytes at offset 4296435712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296439808 ++wrote 2048/2048 bytes at offset 4296439808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296443904 ++wrote 2048/2048 bytes at offset 4296443904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296448000 ++wrote 2048/2048 bytes at offset 4296448000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296452096 ++wrote 2048/2048 bytes at offset 4296452096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296456192 ++wrote 2048/2048 bytes at offset 4296456192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296460288 ++wrote 2048/2048 bytes at offset 4296460288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296464384 ++wrote 2048/2048 bytes at offset 4296464384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296468480 ++wrote 2048/2048 bytes at offset 4296468480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296472576 ++wrote 2048/2048 bytes at offset 4296472576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296476672 ++wrote 2048/2048 bytes at offset 4296476672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296480768 ++wrote 2048/2048 bytes at offset 4296480768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296484864 ++wrote 2048/2048 bytes at offset 4296484864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296488960 ++wrote 2048/2048 bytes at offset 4296488960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296493056 ++wrote 2048/2048 bytes at offset 4296493056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296497152 ++wrote 2048/2048 bytes at offset 4296497152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296501248 ++wrote 2048/2048 bytes at offset 4296501248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296505344 ++wrote 2048/2048 bytes at offset 4296505344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296509440 ++wrote 2048/2048 bytes at offset 4296509440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296513536 ++wrote 2048/2048 bytes at offset 4296513536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296517632 ++wrote 2048/2048 bytes at offset 4296517632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296521728 ++wrote 2048/2048 bytes at offset 4296521728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296525824 ++wrote 2048/2048 bytes at offset 4296525824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296529920 ++wrote 2048/2048 bytes at offset 4296529920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296534016 ++wrote 2048/2048 bytes at offset 4296534016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296538112 ++wrote 2048/2048 bytes at offset 4296538112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296542208 ++wrote 2048/2048 bytes at offset 4296542208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296546304 ++wrote 2048/2048 bytes at offset 4296546304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296550400 ++wrote 2048/2048 bytes at offset 4296550400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296554496 ++wrote 2048/2048 bytes at offset 4296554496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296558592 ++wrote 2048/2048 bytes at offset 4296558592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296562688 ++wrote 2048/2048 bytes at offset 4296562688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296566784 ++wrote 2048/2048 bytes at offset 4296566784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296570880 ++wrote 2048/2048 bytes at offset 4296570880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296574976 ++wrote 2048/2048 bytes at offset 4296574976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296579072 ++wrote 2048/2048 bytes at offset 4296579072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296583168 ++wrote 2048/2048 bytes at offset 4296583168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296587264 ++wrote 2048/2048 bytes at offset 4296587264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296591360 ++wrote 2048/2048 bytes at offset 4296591360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296595456 ++wrote 2048/2048 bytes at offset 4296595456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296599552 ++wrote 2048/2048 bytes at offset 4296599552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296603648 ++wrote 2048/2048 bytes at offset 4296603648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296607744 ++wrote 2048/2048 bytes at offset 4296607744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296611840 ++wrote 2048/2048 bytes at offset 4296611840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296615936 ++wrote 2048/2048 bytes at offset 4296615936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296620032 ++wrote 2048/2048 bytes at offset 4296620032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296624128 ++wrote 2048/2048 bytes at offset 4296624128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296628224 ++wrote 2048/2048 bytes at offset 4296628224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296632320 ++wrote 2048/2048 bytes at offset 4296632320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296636416 ++wrote 2048/2048 bytes at offset 4296636416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296640512 ++wrote 2048/2048 bytes at offset 4296640512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296644608 ++wrote 2048/2048 bytes at offset 4296644608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296648704 ++wrote 2048/2048 bytes at offset 4296648704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296652800 ++wrote 2048/2048 bytes at offset 4296652800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296656896 ++wrote 2048/2048 bytes at offset 4296656896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296660992 ++wrote 2048/2048 bytes at offset 4296660992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296665088 ++wrote 2048/2048 bytes at offset 4296665088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296669184 ++wrote 2048/2048 bytes at offset 4296669184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296673280 ++wrote 2048/2048 bytes at offset 4296673280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296677376 ++wrote 2048/2048 bytes at offset 4296677376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296681472 ++wrote 2048/2048 bytes at offset 4296681472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296685568 ++wrote 2048/2048 bytes at offset 4296685568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296689664 ++wrote 2048/2048 bytes at offset 4296689664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296693760 ++wrote 2048/2048 bytes at offset 4296693760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296697856 ++wrote 2048/2048 bytes at offset 4296697856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296701952 ++wrote 2048/2048 bytes at offset 4296701952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296706048 ++wrote 2048/2048 bytes at offset 4296706048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296710144 ++wrote 2048/2048 bytes at offset 4296710144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296714240 ++wrote 2048/2048 bytes at offset 4296714240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296718336 ++wrote 2048/2048 bytes at offset 4296718336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296722432 ++wrote 2048/2048 bytes at offset 4296722432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296726528 ++wrote 2048/2048 bytes at offset 4296726528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296730624 ++wrote 2048/2048 bytes at offset 4296730624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296734720 ++wrote 2048/2048 bytes at offset 4296734720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296738816 ++wrote 2048/2048 bytes at offset 4296738816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296742912 ++wrote 2048/2048 bytes at offset 4296742912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296747008 ++wrote 2048/2048 bytes at offset 4296747008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296751104 ++wrote 2048/2048 bytes at offset 4296751104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296755200 ++wrote 2048/2048 bytes at offset 4296755200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296759296 ++wrote 2048/2048 bytes at offset 4296759296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296763392 ++wrote 2048/2048 bytes at offset 4296763392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296767488 ++wrote 2048/2048 bytes at offset 4296767488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296771584 ++wrote 2048/2048 bytes at offset 4296771584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296775680 ++wrote 2048/2048 bytes at offset 4296775680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296779776 ++wrote 2048/2048 bytes at offset 4296779776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296783872 ++wrote 2048/2048 bytes at offset 4296783872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296787968 ++wrote 2048/2048 bytes at offset 4296787968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296792064 ++wrote 2048/2048 bytes at offset 4296792064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296796160 ++wrote 2048/2048 bytes at offset 4296796160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296800256 ++wrote 2048/2048 bytes at offset 4296800256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296804352 ++wrote 2048/2048 bytes at offset 4296804352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296808448 ++wrote 2048/2048 bytes at offset 4296808448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296812544 ++wrote 2048/2048 bytes at offset 4296812544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296816640 ++wrote 2048/2048 bytes at offset 4296816640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296820736 ++wrote 2048/2048 bytes at offset 4296820736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296824832 ++wrote 2048/2048 bytes at offset 4296824832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296828928 ++wrote 2048/2048 bytes at offset 4296828928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296833024 ++wrote 2048/2048 bytes at offset 4296833024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296837120 ++wrote 2048/2048 bytes at offset 4296837120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296841216 ++wrote 2048/2048 bytes at offset 4296841216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296845312 ++wrote 2048/2048 bytes at offset 4296845312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296849408 ++wrote 2048/2048 bytes at offset 4296849408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296853504 ++wrote 2048/2048 bytes at offset 4296853504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296857600 ++wrote 2048/2048 bytes at offset 4296857600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296861696 ++wrote 2048/2048 bytes at offset 4296861696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296865792 ++wrote 2048/2048 bytes at offset 4296865792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296869888 ++wrote 2048/2048 bytes at offset 4296869888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296873984 ++wrote 2048/2048 bytes at offset 4296873984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296878080 ++wrote 2048/2048 bytes at offset 4296878080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296882176 ++wrote 2048/2048 bytes at offset 4296882176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296886272 ++wrote 2048/2048 bytes at offset 4296886272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296890368 ++wrote 2048/2048 bytes at offset 4296890368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296894464 ++wrote 2048/2048 bytes at offset 4296894464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296898560 ++wrote 2048/2048 bytes at offset 4296898560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296902656 ++wrote 2048/2048 bytes at offset 4296902656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296906752 ++wrote 2048/2048 bytes at offset 4296906752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296910848 ++wrote 2048/2048 bytes at offset 4296910848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296914944 ++wrote 2048/2048 bytes at offset 4296914944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296919040 ++wrote 2048/2048 bytes at offset 4296919040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296923136 ++wrote 2048/2048 bytes at offset 4296923136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296927232 ++wrote 2048/2048 bytes at offset 4296927232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296931328 ++wrote 2048/2048 bytes at offset 4296931328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296935424 ++wrote 2048/2048 bytes at offset 4296935424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296939520 ++wrote 2048/2048 bytes at offset 4296939520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296943616 ++wrote 2048/2048 bytes at offset 4296943616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296947712 ++wrote 2048/2048 bytes at offset 4296947712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296951808 ++wrote 2048/2048 bytes at offset 4296951808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296955904 ++wrote 2048/2048 bytes at offset 4296955904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296960000 ++wrote 2048/2048 bytes at offset 4296960000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296964096 ++wrote 2048/2048 bytes at offset 4296964096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296968192 ++wrote 2048/2048 bytes at offset 4296968192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296972288 ++wrote 2048/2048 bytes at offset 4296972288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296976384 ++wrote 2048/2048 bytes at offset 4296976384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296980480 ++wrote 2048/2048 bytes at offset 4296980480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296984576 ++wrote 2048/2048 bytes at offset 4296984576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296988672 ++wrote 2048/2048 bytes at offset 4296988672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296992768 ++wrote 2048/2048 bytes at offset 4296992768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296996864 ++wrote 2048/2048 bytes at offset 4296996864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297000960 ++wrote 2048/2048 bytes at offset 4297000960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297005056 ++wrote 2048/2048 bytes at offset 4297005056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297009152 ++wrote 2048/2048 bytes at offset 4297009152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297013248 ++wrote 2048/2048 bytes at offset 4297013248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297017344 ++wrote 2048/2048 bytes at offset 4297017344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297021440 ++wrote 2048/2048 bytes at offset 4297021440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297025536 ++wrote 2048/2048 bytes at offset 4297025536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297029632 ++wrote 2048/2048 bytes at offset 4297029632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297033728 ++wrote 2048/2048 bytes at offset 4297033728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297037824 ++wrote 2048/2048 bytes at offset 4297037824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297041920 ++wrote 2048/2048 bytes at offset 4297041920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297046016 ++wrote 2048/2048 bytes at offset 4297046016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297050112 ++wrote 2048/2048 bytes at offset 4297050112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297054208 ++wrote 2048/2048 bytes at offset 4297054208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297058304 ++wrote 2048/2048 bytes at offset 4297058304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297062400 ++wrote 2048/2048 bytes at offset 4297062400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> wrote 2048/2048 bytes at offset 4297064448 ++=== IO: pattern 0 ++wrote 2048/2048 bytes at offset 4297064448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297068544 ++wrote 2048/2048 bytes at offset 4297068544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297072640 ++wrote 2048/2048 bytes at offset 4297072640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297076736 ++wrote 2048/2048 bytes at offset 4297076736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297080832 ++wrote 2048/2048 bytes at offset 4297080832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297084928 ++wrote 2048/2048 bytes at offset 4297084928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297089024 ++wrote 2048/2048 bytes at offset 4297089024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297093120 ++wrote 2048/2048 bytes at offset 4297093120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297097216 ++wrote 2048/2048 bytes at offset 4297097216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297101312 ++wrote 2048/2048 bytes at offset 4297101312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297105408 ++wrote 2048/2048 bytes at offset 4297105408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297109504 ++wrote 2048/2048 bytes at offset 4297109504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297113600 ++wrote 2048/2048 bytes at offset 4297113600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297117696 ++wrote 2048/2048 bytes at offset 4297117696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297121792 ++wrote 2048/2048 bytes at offset 4297121792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297125888 ++wrote 2048/2048 bytes at offset 4297125888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297129984 ++wrote 2048/2048 bytes at offset 4297129984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297134080 ++wrote 2048/2048 bytes at offset 4297134080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297138176 ++wrote 2048/2048 bytes at offset 4297138176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297142272 ++wrote 2048/2048 bytes at offset 4297142272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297146368 ++wrote 2048/2048 bytes at offset 4297146368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297150464 ++wrote 2048/2048 bytes at offset 4297150464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297154560 ++wrote 2048/2048 bytes at offset 4297154560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297158656 ++wrote 2048/2048 bytes at offset 4297158656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297162752 ++wrote 2048/2048 bytes at offset 4297162752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297166848 ++wrote 2048/2048 bytes at offset 4297166848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297170944 ++wrote 2048/2048 bytes at offset 4297170944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297175040 ++wrote 2048/2048 bytes at offset 4297175040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297179136 ++wrote 2048/2048 bytes at offset 4297179136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297183232 ++wrote 2048/2048 bytes at offset 4297183232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297187328 ++wrote 2048/2048 bytes at offset 4297187328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297191424 ++wrote 2048/2048 bytes at offset 4297191424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297195520 ++wrote 2048/2048 bytes at offset 4297195520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297199616 ++wrote 2048/2048 bytes at offset 4297199616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297203712 ++wrote 2048/2048 bytes at offset 4297203712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297207808 ++wrote 2048/2048 bytes at offset 4297207808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297211904 ++wrote 2048/2048 bytes at offset 4297211904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297216000 ++wrote 2048/2048 bytes at offset 4297216000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297220096 ++wrote 2048/2048 bytes at offset 4297220096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297224192 ++wrote 2048/2048 bytes at offset 4297224192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297228288 ++wrote 2048/2048 bytes at offset 4297228288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297232384 ++wrote 2048/2048 bytes at offset 4297232384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297236480 ++wrote 2048/2048 bytes at offset 4297236480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297240576 ++wrote 2048/2048 bytes at offset 4297240576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297244672 ++wrote 2048/2048 bytes at offset 4297244672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297248768 ++wrote 2048/2048 bytes at offset 4297248768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297252864 ++wrote 2048/2048 bytes at offset 4297252864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297256960 ++wrote 2048/2048 bytes at offset 4297256960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297261056 ++wrote 2048/2048 bytes at offset 4297261056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297265152 ++wrote 2048/2048 bytes at offset 4297265152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297269248 ++wrote 2048/2048 bytes at offset 4297269248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297273344 ++wrote 2048/2048 bytes at offset 4297273344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297277440 ++wrote 2048/2048 bytes at offset 4297277440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297281536 ++wrote 2048/2048 bytes at offset 4297281536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297285632 ++wrote 2048/2048 bytes at offset 4297285632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297289728 ++wrote 2048/2048 bytes at offset 4297289728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297293824 ++wrote 2048/2048 bytes at offset 4297293824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297297920 ++wrote 2048/2048 bytes at offset 4297297920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297302016 ++wrote 2048/2048 bytes at offset 4297302016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297306112 ++wrote 2048/2048 bytes at offset 4297306112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297310208 ++wrote 2048/2048 bytes at offset 4297310208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297314304 ++wrote 2048/2048 bytes at offset 4297314304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297318400 ++wrote 2048/2048 bytes at offset 4297318400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297322496 ++wrote 2048/2048 bytes at offset 4297322496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297326592 ++wrote 2048/2048 bytes at offset 4297326592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297330688 ++wrote 2048/2048 bytes at offset 4297330688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297334784 ++wrote 2048/2048 bytes at offset 4297334784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297338880 ++wrote 2048/2048 bytes at offset 4297338880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297342976 ++wrote 2048/2048 bytes at offset 4297342976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297347072 ++wrote 2048/2048 bytes at offset 4297347072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297351168 ++wrote 2048/2048 bytes at offset 4297351168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297355264 ++wrote 2048/2048 bytes at offset 4297355264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297359360 ++wrote 2048/2048 bytes at offset 4297359360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297363456 ++wrote 2048/2048 bytes at offset 4297363456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297367552 ++wrote 2048/2048 bytes at offset 4297367552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297371648 ++wrote 2048/2048 bytes at offset 4297371648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297375744 ++wrote 2048/2048 bytes at offset 4297375744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297379840 ++wrote 2048/2048 bytes at offset 4297379840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297383936 ++wrote 2048/2048 bytes at offset 4297383936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297388032 ++wrote 2048/2048 bytes at offset 4297388032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297392128 ++wrote 2048/2048 bytes at offset 4297392128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297396224 ++wrote 2048/2048 bytes at offset 4297396224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297400320 ++wrote 2048/2048 bytes at offset 4297400320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297404416 ++wrote 2048/2048 bytes at offset 4297404416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297408512 ++wrote 2048/2048 bytes at offset 4297408512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297412608 ++wrote 2048/2048 bytes at offset 4297412608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297416704 ++wrote 2048/2048 bytes at offset 4297416704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297420800 ++wrote 2048/2048 bytes at offset 4297420800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297424896 ++wrote 2048/2048 bytes at offset 4297424896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297428992 ++wrote 2048/2048 bytes at offset 4297428992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297433088 ++wrote 2048/2048 bytes at offset 4297433088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297437184 ++wrote 2048/2048 bytes at offset 4297437184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297441280 ++wrote 2048/2048 bytes at offset 4297441280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297445376 ++wrote 2048/2048 bytes at offset 4297445376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297449472 ++wrote 2048/2048 bytes at offset 4297449472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297453568 ++wrote 2048/2048 bytes at offset 4297453568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297457664 ++wrote 2048/2048 bytes at offset 4297457664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297461760 ++wrote 2048/2048 bytes at offset 4297461760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297465856 ++wrote 2048/2048 bytes at offset 4297465856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297469952 ++wrote 2048/2048 bytes at offset 4297469952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297474048 ++wrote 2048/2048 bytes at offset 4297474048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297478144 ++wrote 2048/2048 bytes at offset 4297478144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297482240 ++wrote 2048/2048 bytes at offset 4297482240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297486336 ++wrote 2048/2048 bytes at offset 4297486336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297490432 ++wrote 2048/2048 bytes at offset 4297490432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297494528 ++wrote 2048/2048 bytes at offset 4297494528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297498624 ++wrote 2048/2048 bytes at offset 4297498624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297502720 ++wrote 2048/2048 bytes at offset 4297502720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297506816 ++wrote 2048/2048 bytes at offset 4297506816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297510912 ++wrote 2048/2048 bytes at offset 4297510912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297515008 ++wrote 2048/2048 bytes at offset 4297515008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297519104 ++wrote 2048/2048 bytes at offset 4297519104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297523200 ++wrote 2048/2048 bytes at offset 4297523200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297527296 ++wrote 2048/2048 bytes at offset 4297527296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297531392 ++wrote 2048/2048 bytes at offset 4297531392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297535488 ++wrote 2048/2048 bytes at offset 4297535488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297539584 ++wrote 2048/2048 bytes at offset 4297539584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297543680 ++wrote 2048/2048 bytes at offset 4297543680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297547776 ++wrote 2048/2048 bytes at offset 4297547776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297551872 ++wrote 2048/2048 bytes at offset 4297551872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297555968 ++wrote 2048/2048 bytes at offset 4297555968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297560064 ++wrote 2048/2048 bytes at offset 4297560064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297564160 ++wrote 2048/2048 bytes at offset 4297564160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297568256 ++wrote 2048/2048 bytes at offset 4297568256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297572352 ++wrote 2048/2048 bytes at offset 4297572352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297576448 ++wrote 2048/2048 bytes at offset 4297576448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297580544 ++wrote 2048/2048 bytes at offset 4297580544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297584640 ++wrote 2048/2048 bytes at offset 4297584640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297588736 ++wrote 2048/2048 bytes at offset 4297588736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297592832 ++wrote 2048/2048 bytes at offset 4297592832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297596928 ++wrote 2048/2048 bytes at offset 4297596928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297601024 ++wrote 2048/2048 bytes at offset 4297601024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297605120 ++wrote 2048/2048 bytes at offset 4297605120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297609216 ++wrote 2048/2048 bytes at offset 4297609216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297613312 ++wrote 2048/2048 bytes at offset 4297613312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297617408 ++wrote 2048/2048 bytes at offset 4297617408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297621504 ++wrote 2048/2048 bytes at offset 4297621504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297625600 ++wrote 2048/2048 bytes at offset 4297625600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297629696 ++wrote 2048/2048 bytes at offset 4297629696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297633792 ++wrote 2048/2048 bytes at offset 4297633792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297637888 ++wrote 2048/2048 bytes at offset 4297637888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297641984 ++wrote 2048/2048 bytes at offset 4297641984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297646080 ++wrote 2048/2048 bytes at offset 4297646080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297650176 ++wrote 2048/2048 bytes at offset 4297650176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297654272 ++wrote 2048/2048 bytes at offset 4297654272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297658368 ++wrote 2048/2048 bytes at offset 4297658368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297662464 ++wrote 2048/2048 bytes at offset 4297662464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297666560 ++wrote 2048/2048 bytes at offset 4297666560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297670656 ++wrote 2048/2048 bytes at offset 4297670656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297674752 ++wrote 2048/2048 bytes at offset 4297674752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297678848 ++wrote 2048/2048 bytes at offset 4297678848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297682944 ++wrote 2048/2048 bytes at offset 4297682944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297687040 ++wrote 2048/2048 bytes at offset 4297687040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297691136 ++wrote 2048/2048 bytes at offset 4297691136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297695232 ++wrote 2048/2048 bytes at offset 4297695232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297699328 ++wrote 2048/2048 bytes at offset 4297699328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297703424 ++wrote 2048/2048 bytes at offset 4297703424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297707520 ++wrote 2048/2048 bytes at offset 4297707520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297711616 ++wrote 2048/2048 bytes at offset 4297711616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297715712 ++wrote 2048/2048 bytes at offset 4297715712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297719808 ++wrote 2048/2048 bytes at offset 4297719808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297723904 ++wrote 2048/2048 bytes at offset 4297723904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297728000 ++wrote 2048/2048 bytes at offset 4297728000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297732096 ++wrote 2048/2048 bytes at offset 4297732096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297736192 ++wrote 2048/2048 bytes at offset 4297736192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297740288 ++wrote 2048/2048 bytes at offset 4297740288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297744384 ++wrote 2048/2048 bytes at offset 4297744384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297748480 ++wrote 2048/2048 bytes at offset 4297748480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297752576 ++wrote 2048/2048 bytes at offset 4297752576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297756672 ++wrote 2048/2048 bytes at offset 4297756672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297760768 ++wrote 2048/2048 bytes at offset 4297760768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297764864 ++wrote 2048/2048 bytes at offset 4297764864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297768960 ++wrote 2048/2048 bytes at offset 4297768960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297773056 ++wrote 2048/2048 bytes at offset 4297773056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297777152 ++wrote 2048/2048 bytes at offset 4297777152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297781248 ++wrote 2048/2048 bytes at offset 4297781248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297785344 ++wrote 2048/2048 bytes at offset 4297785344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297789440 ++wrote 2048/2048 bytes at offset 4297789440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297793536 ++wrote 2048/2048 bytes at offset 4297793536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297797632 ++wrote 2048/2048 bytes at offset 4297797632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297801728 ++wrote 2048/2048 bytes at offset 4297801728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297805824 ++wrote 2048/2048 bytes at offset 4297805824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297809920 ++wrote 2048/2048 bytes at offset 4297809920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297814016 ++wrote 2048/2048 bytes at offset 4297814016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297818112 ++wrote 2048/2048 bytes at offset 4297818112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297822208 ++wrote 2048/2048 bytes at offset 4297822208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297826304 ++wrote 2048/2048 bytes at offset 4297826304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297830400 ++wrote 2048/2048 bytes at offset 4297830400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297834496 ++wrote 2048/2048 bytes at offset 4297834496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297838592 ++wrote 2048/2048 bytes at offset 4297838592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297842688 ++wrote 2048/2048 bytes at offset 4297842688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297846784 ++wrote 2048/2048 bytes at offset 4297846784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297850880 ++wrote 2048/2048 bytes at offset 4297850880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297854976 ++wrote 2048/2048 bytes at offset 4297854976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297859072 ++wrote 2048/2048 bytes at offset 4297859072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297863168 ++wrote 2048/2048 bytes at offset 4297863168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297867264 ++wrote 2048/2048 bytes at offset 4297867264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297871360 ++wrote 2048/2048 bytes at offset 4297871360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297875456 ++wrote 2048/2048 bytes at offset 4297875456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297879552 ++wrote 2048/2048 bytes at offset 4297879552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297883648 ++wrote 2048/2048 bytes at offset 4297883648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297887744 ++wrote 2048/2048 bytes at offset 4297887744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297891840 ++wrote 2048/2048 bytes at offset 4297891840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297895936 ++wrote 2048/2048 bytes at offset 4297895936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297900032 ++wrote 2048/2048 bytes at offset 4297900032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297904128 ++wrote 2048/2048 bytes at offset 4297904128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297908224 ++wrote 2048/2048 bytes at offset 4297908224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297912320 ++wrote 2048/2048 bytes at offset 4297912320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297916416 ++wrote 2048/2048 bytes at offset 4297916416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297920512 ++wrote 2048/2048 bytes at offset 4297920512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297924608 ++wrote 2048/2048 bytes at offset 4297924608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297928704 ++wrote 2048/2048 bytes at offset 4297928704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297932800 ++wrote 2048/2048 bytes at offset 4297932800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297936896 ++wrote 2048/2048 bytes at offset 4297936896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297940992 ++wrote 2048/2048 bytes at offset 4297940992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297945088 ++wrote 2048/2048 bytes at offset 4297945088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297949184 ++wrote 2048/2048 bytes at offset 4297949184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297953280 ++wrote 2048/2048 bytes at offset 4297953280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297957376 ++wrote 2048/2048 bytes at offset 4297957376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297961472 ++wrote 2048/2048 bytes at offset 4297961472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297965568 ++wrote 2048/2048 bytes at offset 4297965568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297969664 ++wrote 2048/2048 bytes at offset 4297969664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297973760 ++wrote 2048/2048 bytes at offset 4297973760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297977856 ++wrote 2048/2048 bytes at offset 4297977856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297981952 ++wrote 2048/2048 bytes at offset 4297981952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297986048 ++wrote 2048/2048 bytes at offset 4297986048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297990144 ++wrote 2048/2048 bytes at offset 4297990144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297994240 ++wrote 2048/2048 bytes at offset 4297994240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297998336 ++wrote 2048/2048 bytes at offset 4297998336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298002432 ++wrote 2048/2048 bytes at offset 4298002432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298006528 ++wrote 2048/2048 bytes at offset 4298006528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298010624 ++wrote 2048/2048 bytes at offset 4298010624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298014720 ++wrote 2048/2048 bytes at offset 4298014720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298018816 ++wrote 2048/2048 bytes at offset 4298018816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298022912 ++wrote 2048/2048 bytes at offset 4298022912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298027008 ++wrote 2048/2048 bytes at offset 4298027008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298031104 ++wrote 2048/2048 bytes at offset 4298031104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298035200 ++wrote 2048/2048 bytes at offset 4298035200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298039296 ++wrote 2048/2048 bytes at offset 4298039296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298043392 ++wrote 2048/2048 bytes at offset 4298043392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298047488 ++wrote 2048/2048 bytes at offset 4298047488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298051584 ++wrote 2048/2048 bytes at offset 4298051584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298055680 ++wrote 2048/2048 bytes at offset 4298055680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298059776 ++wrote 2048/2048 bytes at offset 4298059776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298063872 ++wrote 2048/2048 bytes at offset 4298063872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298067968 ++wrote 2048/2048 bytes at offset 4298067968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298072064 ++wrote 2048/2048 bytes at offset 4298072064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298076160 ++wrote 2048/2048 bytes at offset 4298076160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298080256 ++wrote 2048/2048 bytes at offset 4298080256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298084352 ++wrote 2048/2048 bytes at offset 4298084352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298088448 ++wrote 2048/2048 bytes at offset 4298088448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298092544 ++wrote 2048/2048 bytes at offset 4298092544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298096640 ++wrote 2048/2048 bytes at offset 4298096640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298100736 ++wrote 2048/2048 bytes at offset 4298100736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298104832 ++wrote 2048/2048 bytes at offset 4298104832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298108928 ++wrote 2048/2048 bytes at offset 4298108928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 2 +-qemu-io> wrote 2048/2048 bytes at offset 4298114048 ++=== IO: pattern 2 ++wrote 2048/2048 bytes at offset 4298114048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298118144 ++wrote 2048/2048 bytes at offset 4298118144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298122240 ++wrote 2048/2048 bytes at offset 4298122240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298126336 ++wrote 2048/2048 bytes at offset 4298126336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298130432 ++wrote 2048/2048 bytes at offset 4298130432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298134528 ++wrote 2048/2048 bytes at offset 4298134528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298138624 ++wrote 2048/2048 bytes at offset 4298138624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298142720 ++wrote 2048/2048 bytes at offset 4298142720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298146816 ++wrote 2048/2048 bytes at offset 4298146816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298150912 ++wrote 2048/2048 bytes at offset 4298150912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298155008 ++wrote 2048/2048 bytes at offset 4298155008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298159104 ++wrote 2048/2048 bytes at offset 4298159104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298163200 ++wrote 2048/2048 bytes at offset 4298163200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298167296 ++wrote 2048/2048 bytes at offset 4298167296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298171392 ++wrote 2048/2048 bytes at offset 4298171392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298175488 ++wrote 2048/2048 bytes at offset 4298175488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298179584 ++wrote 2048/2048 bytes at offset 4298179584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298183680 ++wrote 2048/2048 bytes at offset 4298183680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298187776 ++wrote 2048/2048 bytes at offset 4298187776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298191872 ++wrote 2048/2048 bytes at offset 4298191872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298195968 ++wrote 2048/2048 bytes at offset 4298195968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298200064 ++wrote 2048/2048 bytes at offset 4298200064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298204160 ++wrote 2048/2048 bytes at offset 4298204160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298208256 ++wrote 2048/2048 bytes at offset 4298208256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298212352 ++wrote 2048/2048 bytes at offset 4298212352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298216448 ++wrote 2048/2048 bytes at offset 4298216448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298220544 ++wrote 2048/2048 bytes at offset 4298220544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298224640 ++wrote 2048/2048 bytes at offset 4298224640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298228736 ++wrote 2048/2048 bytes at offset 4298228736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298232832 ++wrote 2048/2048 bytes at offset 4298232832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298236928 ++wrote 2048/2048 bytes at offset 4298236928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298241024 ++wrote 2048/2048 bytes at offset 4298241024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298245120 ++wrote 2048/2048 bytes at offset 4298245120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298249216 ++wrote 2048/2048 bytes at offset 4298249216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298253312 ++wrote 2048/2048 bytes at offset 4298253312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298257408 ++wrote 2048/2048 bytes at offset 4298257408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298261504 ++wrote 2048/2048 bytes at offset 4298261504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298265600 ++wrote 2048/2048 bytes at offset 4298265600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298269696 ++wrote 2048/2048 bytes at offset 4298269696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298273792 ++wrote 2048/2048 bytes at offset 4298273792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298277888 ++wrote 2048/2048 bytes at offset 4298277888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298281984 ++wrote 2048/2048 bytes at offset 4298281984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298286080 ++wrote 2048/2048 bytes at offset 4298286080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298290176 ++wrote 2048/2048 bytes at offset 4298290176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298294272 ++wrote 2048/2048 bytes at offset 4298294272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298298368 ++wrote 2048/2048 bytes at offset 4298298368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298302464 ++wrote 2048/2048 bytes at offset 4298302464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298306560 ++wrote 2048/2048 bytes at offset 4298306560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298310656 ++wrote 2048/2048 bytes at offset 4298310656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298314752 ++wrote 2048/2048 bytes at offset 4298314752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298318848 ++wrote 2048/2048 bytes at offset 4298318848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298322944 ++wrote 2048/2048 bytes at offset 4298322944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298327040 ++wrote 2048/2048 bytes at offset 4298327040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298331136 ++wrote 2048/2048 bytes at offset 4298331136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298335232 ++wrote 2048/2048 bytes at offset 4298335232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298339328 ++wrote 2048/2048 bytes at offset 4298339328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298343424 ++wrote 2048/2048 bytes at offset 4298343424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298347520 ++wrote 2048/2048 bytes at offset 4298347520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298351616 ++wrote 2048/2048 bytes at offset 4298351616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298355712 ++wrote 2048/2048 bytes at offset 4298355712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298359808 ++wrote 2048/2048 bytes at offset 4298359808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298363904 ++wrote 2048/2048 bytes at offset 4298363904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298368000 ++wrote 2048/2048 bytes at offset 4298368000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298372096 ++wrote 2048/2048 bytes at offset 4298372096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298376192 ++wrote 2048/2048 bytes at offset 4298376192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298380288 ++wrote 2048/2048 bytes at offset 4298380288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298384384 ++wrote 2048/2048 bytes at offset 4298384384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298388480 ++wrote 2048/2048 bytes at offset 4298388480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298392576 ++wrote 2048/2048 bytes at offset 4298392576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298396672 ++wrote 2048/2048 bytes at offset 4298396672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298400768 ++wrote 2048/2048 bytes at offset 4298400768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298404864 ++wrote 2048/2048 bytes at offset 4298404864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298408960 ++wrote 2048/2048 bytes at offset 4298408960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298413056 ++wrote 2048/2048 bytes at offset 4298413056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298417152 ++wrote 2048/2048 bytes at offset 4298417152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298421248 ++wrote 2048/2048 bytes at offset 4298421248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298425344 ++wrote 2048/2048 bytes at offset 4298425344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298429440 ++wrote 2048/2048 bytes at offset 4298429440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298433536 ++wrote 2048/2048 bytes at offset 4298433536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298437632 ++wrote 2048/2048 bytes at offset 4298437632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298441728 ++wrote 2048/2048 bytes at offset 4298441728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298445824 ++wrote 2048/2048 bytes at offset 4298445824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298449920 ++wrote 2048/2048 bytes at offset 4298449920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298454016 ++wrote 2048/2048 bytes at offset 4298454016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298458112 ++wrote 2048/2048 bytes at offset 4298458112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298462208 ++wrote 2048/2048 bytes at offset 4298462208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298466304 ++wrote 2048/2048 bytes at offset 4298466304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298470400 ++wrote 2048/2048 bytes at offset 4298470400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298474496 ++wrote 2048/2048 bytes at offset 4298474496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298478592 ++wrote 2048/2048 bytes at offset 4298478592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298482688 ++wrote 2048/2048 bytes at offset 4298482688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298486784 ++wrote 2048/2048 bytes at offset 4298486784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298490880 ++wrote 2048/2048 bytes at offset 4298490880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298494976 ++wrote 2048/2048 bytes at offset 4298494976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298499072 ++wrote 2048/2048 bytes at offset 4298499072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298503168 ++wrote 2048/2048 bytes at offset 4298503168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298507264 ++wrote 2048/2048 bytes at offset 4298507264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298511360 ++wrote 2048/2048 bytes at offset 4298511360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298515456 ++wrote 2048/2048 bytes at offset 4298515456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298519552 ++wrote 2048/2048 bytes at offset 4298519552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298523648 ++wrote 2048/2048 bytes at offset 4298523648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298527744 ++wrote 2048/2048 bytes at offset 4298527744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298531840 ++wrote 2048/2048 bytes at offset 4298531840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298535936 ++wrote 2048/2048 bytes at offset 4298535936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298540032 ++wrote 2048/2048 bytes at offset 4298540032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298544128 ++wrote 2048/2048 bytes at offset 4298544128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298548224 ++wrote 2048/2048 bytes at offset 4298548224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298552320 ++wrote 2048/2048 bytes at offset 4298552320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298556416 ++wrote 2048/2048 bytes at offset 4298556416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298560512 ++wrote 2048/2048 bytes at offset 4298560512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298564608 ++wrote 2048/2048 bytes at offset 4298564608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298568704 ++wrote 2048/2048 bytes at offset 4298568704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298572800 ++wrote 2048/2048 bytes at offset 4298572800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298576896 ++wrote 2048/2048 bytes at offset 4298576896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298580992 ++wrote 2048/2048 bytes at offset 4298580992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298585088 ++wrote 2048/2048 bytes at offset 4298585088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298589184 ++wrote 2048/2048 bytes at offset 4298589184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298593280 ++wrote 2048/2048 bytes at offset 4298593280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298597376 ++wrote 2048/2048 bytes at offset 4298597376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298601472 ++wrote 2048/2048 bytes at offset 4298601472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298605568 ++wrote 2048/2048 bytes at offset 4298605568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298609664 ++wrote 2048/2048 bytes at offset 4298609664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298613760 ++wrote 2048/2048 bytes at offset 4298613760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298617856 ++wrote 2048/2048 bytes at offset 4298617856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298621952 ++wrote 2048/2048 bytes at offset 4298621952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298626048 ++wrote 2048/2048 bytes at offset 4298626048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298630144 ++wrote 2048/2048 bytes at offset 4298630144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298634240 ++wrote 2048/2048 bytes at offset 4298634240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298638336 ++wrote 2048/2048 bytes at offset 4298638336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298642432 ++wrote 2048/2048 bytes at offset 4298642432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298646528 ++wrote 2048/2048 bytes at offset 4298646528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298650624 ++wrote 2048/2048 bytes at offset 4298650624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298654720 ++wrote 2048/2048 bytes at offset 4298654720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298658816 ++wrote 2048/2048 bytes at offset 4298658816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298662912 ++wrote 2048/2048 bytes at offset 4298662912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298667008 ++wrote 2048/2048 bytes at offset 4298667008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298671104 ++wrote 2048/2048 bytes at offset 4298671104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298675200 ++wrote 2048/2048 bytes at offset 4298675200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298679296 ++wrote 2048/2048 bytes at offset 4298679296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298683392 ++wrote 2048/2048 bytes at offset 4298683392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298687488 ++wrote 2048/2048 bytes at offset 4298687488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298691584 ++wrote 2048/2048 bytes at offset 4298691584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298695680 ++wrote 2048/2048 bytes at offset 4298695680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298699776 ++wrote 2048/2048 bytes at offset 4298699776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298703872 ++wrote 2048/2048 bytes at offset 4298703872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298707968 ++wrote 2048/2048 bytes at offset 4298707968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298712064 ++wrote 2048/2048 bytes at offset 4298712064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298716160 ++wrote 2048/2048 bytes at offset 4298716160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298720256 ++wrote 2048/2048 bytes at offset 4298720256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298724352 ++wrote 2048/2048 bytes at offset 4298724352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298728448 ++wrote 2048/2048 bytes at offset 4298728448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298732544 ++wrote 2048/2048 bytes at offset 4298732544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298736640 ++wrote 2048/2048 bytes at offset 4298736640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298740736 ++wrote 2048/2048 bytes at offset 4298740736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298744832 ++wrote 2048/2048 bytes at offset 4298744832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298748928 ++wrote 2048/2048 bytes at offset 4298748928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298753024 ++wrote 2048/2048 bytes at offset 4298753024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298757120 ++wrote 2048/2048 bytes at offset 4298757120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298761216 ++wrote 2048/2048 bytes at offset 4298761216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298765312 ++wrote 2048/2048 bytes at offset 4298765312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298769408 ++wrote 2048/2048 bytes at offset 4298769408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298773504 ++wrote 2048/2048 bytes at offset 4298773504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298777600 ++wrote 2048/2048 bytes at offset 4298777600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298781696 ++wrote 2048/2048 bytes at offset 4298781696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298785792 ++wrote 2048/2048 bytes at offset 4298785792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298789888 ++wrote 2048/2048 bytes at offset 4298789888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298793984 ++wrote 2048/2048 bytes at offset 4298793984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298798080 ++wrote 2048/2048 bytes at offset 4298798080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298802176 ++wrote 2048/2048 bytes at offset 4298802176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298806272 ++wrote 2048/2048 bytes at offset 4298806272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298810368 ++wrote 2048/2048 bytes at offset 4298810368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298814464 ++wrote 2048/2048 bytes at offset 4298814464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298818560 ++wrote 2048/2048 bytes at offset 4298818560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298822656 ++wrote 2048/2048 bytes at offset 4298822656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298826752 ++wrote 2048/2048 bytes at offset 4298826752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298830848 ++wrote 2048/2048 bytes at offset 4298830848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298834944 ++wrote 2048/2048 bytes at offset 4298834944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298839040 ++wrote 2048/2048 bytes at offset 4298839040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298843136 ++wrote 2048/2048 bytes at offset 4298843136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298847232 ++wrote 2048/2048 bytes at offset 4298847232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298851328 ++wrote 2048/2048 bytes at offset 4298851328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298855424 ++wrote 2048/2048 bytes at offset 4298855424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298859520 ++wrote 2048/2048 bytes at offset 4298859520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298863616 ++wrote 2048/2048 bytes at offset 4298863616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298867712 ++wrote 2048/2048 bytes at offset 4298867712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298871808 ++wrote 2048/2048 bytes at offset 4298871808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298875904 ++wrote 2048/2048 bytes at offset 4298875904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298880000 ++wrote 2048/2048 bytes at offset 4298880000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298884096 ++wrote 2048/2048 bytes at offset 4298884096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298888192 ++wrote 2048/2048 bytes at offset 4298888192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298892288 ++wrote 2048/2048 bytes at offset 4298892288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298896384 ++wrote 2048/2048 bytes at offset 4298896384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298900480 ++wrote 2048/2048 bytes at offset 4298900480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298904576 ++wrote 2048/2048 bytes at offset 4298904576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298908672 ++wrote 2048/2048 bytes at offset 4298908672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298912768 ++wrote 2048/2048 bytes at offset 4298912768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298916864 ++wrote 2048/2048 bytes at offset 4298916864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298920960 ++wrote 2048/2048 bytes at offset 4298920960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298925056 ++wrote 2048/2048 bytes at offset 4298925056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298929152 ++wrote 2048/2048 bytes at offset 4298929152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298933248 ++wrote 2048/2048 bytes at offset 4298933248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298937344 ++wrote 2048/2048 bytes at offset 4298937344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298941440 ++wrote 2048/2048 bytes at offset 4298941440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298945536 ++wrote 2048/2048 bytes at offset 4298945536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298949632 ++wrote 2048/2048 bytes at offset 4298949632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298953728 ++wrote 2048/2048 bytes at offset 4298953728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298957824 ++wrote 2048/2048 bytes at offset 4298957824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298961920 ++wrote 2048/2048 bytes at offset 4298961920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298966016 ++wrote 2048/2048 bytes at offset 4298966016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298970112 ++wrote 2048/2048 bytes at offset 4298970112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298974208 ++wrote 2048/2048 bytes at offset 4298974208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298978304 ++wrote 2048/2048 bytes at offset 4298978304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298982400 ++wrote 2048/2048 bytes at offset 4298982400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298986496 ++wrote 2048/2048 bytes at offset 4298986496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298990592 ++wrote 2048/2048 bytes at offset 4298990592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298994688 ++wrote 2048/2048 bytes at offset 4298994688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298998784 ++wrote 2048/2048 bytes at offset 4298998784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299002880 ++wrote 2048/2048 bytes at offset 4299002880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299006976 ++wrote 2048/2048 bytes at offset 4299006976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299011072 ++wrote 2048/2048 bytes at offset 4299011072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299015168 ++wrote 2048/2048 bytes at offset 4299015168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299019264 ++wrote 2048/2048 bytes at offset 4299019264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299023360 ++wrote 2048/2048 bytes at offset 4299023360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299027456 ++wrote 2048/2048 bytes at offset 4299027456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299031552 ++wrote 2048/2048 bytes at offset 4299031552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299035648 ++wrote 2048/2048 bytes at offset 4299035648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299039744 ++wrote 2048/2048 bytes at offset 4299039744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299043840 ++wrote 2048/2048 bytes at offset 4299043840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299047936 ++wrote 2048/2048 bytes at offset 4299047936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299052032 ++wrote 2048/2048 bytes at offset 4299052032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299056128 ++wrote 2048/2048 bytes at offset 4299056128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299060224 ++wrote 2048/2048 bytes at offset 4299060224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299064320 ++wrote 2048/2048 bytes at offset 4299064320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299068416 ++wrote 2048/2048 bytes at offset 4299068416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299072512 ++wrote 2048/2048 bytes at offset 4299072512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299076608 ++wrote 2048/2048 bytes at offset 4299076608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299080704 ++wrote 2048/2048 bytes at offset 4299080704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299084800 ++wrote 2048/2048 bytes at offset 4299084800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299088896 ++wrote 2048/2048 bytes at offset 4299088896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299092992 ++wrote 2048/2048 bytes at offset 4299092992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299097088 ++wrote 2048/2048 bytes at offset 4299097088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299101184 ++wrote 2048/2048 bytes at offset 4299101184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299105280 ++wrote 2048/2048 bytes at offset 4299105280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299109376 ++wrote 2048/2048 bytes at offset 4299109376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299113472 ++wrote 2048/2048 bytes at offset 4299113472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299117568 ++wrote 2048/2048 bytes at offset 4299117568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299121664 ++wrote 2048/2048 bytes at offset 4299121664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299125760 ++wrote 2048/2048 bytes at offset 4299125760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299129856 ++wrote 2048/2048 bytes at offset 4299129856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299133952 ++wrote 2048/2048 bytes at offset 4299133952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299138048 ++wrote 2048/2048 bytes at offset 4299138048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299142144 ++wrote 2048/2048 bytes at offset 4299142144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299146240 ++wrote 2048/2048 bytes at offset 4299146240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299150336 ++wrote 2048/2048 bytes at offset 4299150336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299154432 ++wrote 2048/2048 bytes at offset 4299154432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299158528 ++wrote 2048/2048 bytes at offset 4299158528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 4 +-qemu-io> wrote 8192/8192 bytes at offset 4299163648 ++=== IO: pattern 4 ++wrote 8192/8192 bytes at offset 4299163648 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299175936 ++wrote 8192/8192 bytes at offset 4299175936 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299188224 ++wrote 8192/8192 bytes at offset 4299188224 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299200512 ++wrote 8192/8192 bytes at offset 4299200512 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299212800 ++wrote 8192/8192 bytes at offset 4299212800 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299225088 ++wrote 8192/8192 bytes at offset 4299225088 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299237376 ++wrote 8192/8192 bytes at offset 4299237376 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299249664 ++wrote 8192/8192 bytes at offset 4299249664 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299261952 ++wrote 8192/8192 bytes at offset 4299261952 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299274240 ++wrote 8192/8192 bytes at offset 4299274240 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299286528 ++wrote 8192/8192 bytes at offset 4299286528 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299298816 ++wrote 8192/8192 bytes at offset 4299298816 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299311104 ++wrote 8192/8192 bytes at offset 4299311104 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299323392 ++wrote 8192/8192 bytes at offset 4299323392 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299335680 ++wrote 8192/8192 bytes at offset 4299335680 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299347968 ++wrote 8192/8192 bytes at offset 4299347968 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299360256 ++wrote 8192/8192 bytes at offset 4299360256 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299372544 ++wrote 8192/8192 bytes at offset 4299372544 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299384832 ++wrote 8192/8192 bytes at offset 4299384832 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299397120 ++wrote 8192/8192 bytes at offset 4299397120 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299409408 ++wrote 8192/8192 bytes at offset 4299409408 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299421696 ++wrote 8192/8192 bytes at offset 4299421696 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299433984 ++wrote 8192/8192 bytes at offset 4299433984 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299446272 ++wrote 8192/8192 bytes at offset 4299446272 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299458560 ++wrote 8192/8192 bytes at offset 4299458560 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299470848 ++wrote 8192/8192 bytes at offset 4299470848 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299483136 ++wrote 8192/8192 bytes at offset 4299483136 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299495424 ++wrote 8192/8192 bytes at offset 4299495424 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299507712 ++wrote 8192/8192 bytes at offset 4299507712 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299520000 ++wrote 8192/8192 bytes at offset 4299520000 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299532288 ++wrote 8192/8192 bytes at offset 4299532288 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299544576 ++wrote 8192/8192 bytes at offset 4299544576 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299556864 ++wrote 8192/8192 bytes at offset 4299556864 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299569152 ++wrote 8192/8192 bytes at offset 4299569152 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299581440 ++wrote 8192/8192 bytes at offset 4299581440 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299593728 ++wrote 8192/8192 bytes at offset 4299593728 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299606016 ++wrote 8192/8192 bytes at offset 4299606016 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299618304 ++wrote 8192/8192 bytes at offset 4299618304 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299630592 ++wrote 8192/8192 bytes at offset 4299630592 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299642880 ++wrote 8192/8192 bytes at offset 4299642880 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299655168 ++wrote 8192/8192 bytes at offset 4299655168 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299667456 ++wrote 8192/8192 bytes at offset 4299667456 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299679744 ++wrote 8192/8192 bytes at offset 4299679744 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299692032 ++wrote 8192/8192 bytes at offset 4299692032 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299704320 ++wrote 8192/8192 bytes at offset 4299704320 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299716608 ++wrote 8192/8192 bytes at offset 4299716608 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299728896 ++wrote 8192/8192 bytes at offset 4299728896 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299741184 ++wrote 8192/8192 bytes at offset 4299741184 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299753472 ++wrote 8192/8192 bytes at offset 4299753472 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299765760 ++wrote 8192/8192 bytes at offset 4299765760 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299778048 ++wrote 8192/8192 bytes at offset 4299778048 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299790336 ++wrote 8192/8192 bytes at offset 4299790336 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299802624 ++wrote 8192/8192 bytes at offset 4299802624 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299814912 ++wrote 8192/8192 bytes at offset 4299814912 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299827200 ++wrote 8192/8192 bytes at offset 4299827200 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299839488 ++wrote 8192/8192 bytes at offset 4299839488 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299851776 ++wrote 8192/8192 bytes at offset 4299851776 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299864064 ++wrote 8192/8192 bytes at offset 4299864064 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299876352 ++wrote 8192/8192 bytes at offset 4299876352 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299888640 ++wrote 8192/8192 bytes at offset 4299888640 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299900928 ++wrote 8192/8192 bytes at offset 4299900928 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299913216 ++wrote 8192/8192 bytes at offset 4299913216 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299925504 ++wrote 8192/8192 bytes at offset 4299925504 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299937792 ++wrote 8192/8192 bytes at offset 4299937792 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 244 +-qemu-io> wrote 12288/12288 bytes at offset 4301252608 ++=== IO: pattern 244 ++wrote 12288/12288 bytes at offset 4301252608 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 4303351808 ++wrote 12288/12288 bytes at offset 4303351808 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 4305451008 ++wrote 12288/12288 bytes at offset 4305451008 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 4307550208 ++wrote 12288/12288 bytes at offset 4307550208 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 4309649408 ++wrote 12288/12288 bytes at offset 4309649408 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 4311748608 ++wrote 12288/12288 bytes at offset 4311748608 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 4313847808 ++wrote 12288/12288 bytes at offset 4313847808 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 4315947008 ++wrote 12288/12288 bytes at offset 4315947008 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> read 4096/4096 bytes at offset 4294967296 ++=== IO: pattern 0 ++read 4096/4096 bytes at offset 4294967296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294971392 ++read 4096/4096 bytes at offset 4294971392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294975488 ++read 4096/4096 bytes at offset 4294975488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294979584 ++read 4096/4096 bytes at offset 4294979584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294983680 ++read 4096/4096 bytes at offset 4294983680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294987776 ++read 4096/4096 bytes at offset 4294987776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294991872 ++read 4096/4096 bytes at offset 4294991872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294995968 ++read 4096/4096 bytes at offset 4294995968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295000064 ++read 4096/4096 bytes at offset 4295000064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295004160 ++read 4096/4096 bytes at offset 4295004160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295008256 ++read 4096/4096 bytes at offset 4295008256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295012352 ++read 4096/4096 bytes at offset 4295012352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295016448 ++read 4096/4096 bytes at offset 4295016448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295020544 ++read 4096/4096 bytes at offset 4295020544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295024640 ++read 4096/4096 bytes at offset 4295024640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295028736 ++read 4096/4096 bytes at offset 4295028736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295032832 ++read 4096/4096 bytes at offset 4295032832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295036928 ++read 4096/4096 bytes at offset 4295036928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295041024 ++read 4096/4096 bytes at offset 4295041024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295045120 ++read 4096/4096 bytes at offset 4295045120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295049216 ++read 4096/4096 bytes at offset 4295049216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295053312 ++read 4096/4096 bytes at offset 4295053312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295057408 ++read 4096/4096 bytes at offset 4295057408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295061504 ++read 4096/4096 bytes at offset 4295061504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295065600 ++read 4096/4096 bytes at offset 4295065600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295069696 ++read 4096/4096 bytes at offset 4295069696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295073792 ++read 4096/4096 bytes at offset 4295073792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295077888 ++read 4096/4096 bytes at offset 4295077888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295081984 ++read 4096/4096 bytes at offset 4295081984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295086080 ++read 4096/4096 bytes at offset 4295086080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295090176 ++read 4096/4096 bytes at offset 4295090176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295094272 ++read 4096/4096 bytes at offset 4295094272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295098368 ++read 4096/4096 bytes at offset 4295098368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295102464 ++read 4096/4096 bytes at offset 4295102464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295106560 ++read 4096/4096 bytes at offset 4295106560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295110656 ++read 4096/4096 bytes at offset 4295110656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295114752 ++read 4096/4096 bytes at offset 4295114752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295118848 ++read 4096/4096 bytes at offset 4295118848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295122944 ++read 4096/4096 bytes at offset 4295122944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295127040 ++read 4096/4096 bytes at offset 4295127040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295131136 ++read 4096/4096 bytes at offset 4295131136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295135232 ++read 4096/4096 bytes at offset 4295135232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295139328 ++read 4096/4096 bytes at offset 4295139328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295143424 ++read 4096/4096 bytes at offset 4295143424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295147520 ++read 4096/4096 bytes at offset 4295147520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295151616 ++read 4096/4096 bytes at offset 4295151616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295155712 ++read 4096/4096 bytes at offset 4295155712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295159808 ++read 4096/4096 bytes at offset 4295159808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295163904 ++read 4096/4096 bytes at offset 4295163904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295168000 ++read 4096/4096 bytes at offset 4295168000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295172096 ++read 4096/4096 bytes at offset 4295172096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295176192 ++read 4096/4096 bytes at offset 4295176192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295180288 ++read 4096/4096 bytes at offset 4295180288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295184384 ++read 4096/4096 bytes at offset 4295184384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295188480 ++read 4096/4096 bytes at offset 4295188480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295192576 ++read 4096/4096 bytes at offset 4295192576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295196672 ++read 4096/4096 bytes at offset 4295196672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295200768 ++read 4096/4096 bytes at offset 4295200768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295204864 ++read 4096/4096 bytes at offset 4295204864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295208960 ++read 4096/4096 bytes at offset 4295208960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295213056 ++read 4096/4096 bytes at offset 4295213056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295217152 ++read 4096/4096 bytes at offset 4295217152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295221248 ++read 4096/4096 bytes at offset 4295221248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295225344 ++read 4096/4096 bytes at offset 4295225344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295229440 ++read 4096/4096 bytes at offset 4295229440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295233536 ++read 4096/4096 bytes at offset 4295233536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295237632 ++read 4096/4096 bytes at offset 4295237632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295241728 ++read 4096/4096 bytes at offset 4295241728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295245824 ++read 4096/4096 bytes at offset 4295245824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295249920 ++read 4096/4096 bytes at offset 4295249920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295254016 ++read 4096/4096 bytes at offset 4295254016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295258112 ++read 4096/4096 bytes at offset 4295258112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295262208 ++read 4096/4096 bytes at offset 4295262208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295266304 ++read 4096/4096 bytes at offset 4295266304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295270400 ++read 4096/4096 bytes at offset 4295270400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295274496 ++read 4096/4096 bytes at offset 4295274496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295278592 ++read 4096/4096 bytes at offset 4295278592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295282688 ++read 4096/4096 bytes at offset 4295282688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295286784 ++read 4096/4096 bytes at offset 4295286784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295290880 ++read 4096/4096 bytes at offset 4295290880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295294976 ++read 4096/4096 bytes at offset 4295294976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295299072 ++read 4096/4096 bytes at offset 4295299072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295303168 ++read 4096/4096 bytes at offset 4295303168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295307264 ++read 4096/4096 bytes at offset 4295307264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295311360 ++read 4096/4096 bytes at offset 4295311360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295315456 ++read 4096/4096 bytes at offset 4295315456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295319552 ++read 4096/4096 bytes at offset 4295319552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295323648 ++read 4096/4096 bytes at offset 4295323648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295327744 ++read 4096/4096 bytes at offset 4295327744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295331840 ++read 4096/4096 bytes at offset 4295331840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295335936 ++read 4096/4096 bytes at offset 4295335936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295340032 ++read 4096/4096 bytes at offset 4295340032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295344128 ++read 4096/4096 bytes at offset 4295344128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295348224 ++read 4096/4096 bytes at offset 4295348224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295352320 ++read 4096/4096 bytes at offset 4295352320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295356416 ++read 4096/4096 bytes at offset 4295356416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295360512 ++read 4096/4096 bytes at offset 4295360512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295364608 ++read 4096/4096 bytes at offset 4295364608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295368704 ++read 4096/4096 bytes at offset 4295368704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295372800 ++read 4096/4096 bytes at offset 4295372800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295376896 ++read 4096/4096 bytes at offset 4295376896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295380992 ++read 4096/4096 bytes at offset 4295380992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295385088 ++read 4096/4096 bytes at offset 4295385088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295389184 ++read 4096/4096 bytes at offset 4295389184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295393280 ++read 4096/4096 bytes at offset 4295393280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295397376 ++read 4096/4096 bytes at offset 4295397376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295401472 ++read 4096/4096 bytes at offset 4295401472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295405568 ++read 4096/4096 bytes at offset 4295405568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295409664 ++read 4096/4096 bytes at offset 4295409664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295413760 ++read 4096/4096 bytes at offset 4295413760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295417856 ++read 4096/4096 bytes at offset 4295417856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295421952 ++read 4096/4096 bytes at offset 4295421952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295426048 ++read 4096/4096 bytes at offset 4295426048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295430144 ++read 4096/4096 bytes at offset 4295430144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295434240 ++read 4096/4096 bytes at offset 4295434240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295438336 ++read 4096/4096 bytes at offset 4295438336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295442432 ++read 4096/4096 bytes at offset 4295442432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295446528 ++read 4096/4096 bytes at offset 4295446528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295450624 ++read 4096/4096 bytes at offset 4295450624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295454720 ++read 4096/4096 bytes at offset 4295454720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295458816 ++read 4096/4096 bytes at offset 4295458816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295462912 ++read 4096/4096 bytes at offset 4295462912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295467008 ++read 4096/4096 bytes at offset 4295467008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295471104 ++read 4096/4096 bytes at offset 4295471104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295475200 ++read 4096/4096 bytes at offset 4295475200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295479296 ++read 4096/4096 bytes at offset 4295479296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295483392 ++read 4096/4096 bytes at offset 4295483392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295487488 ++read 4096/4096 bytes at offset 4295487488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295491584 ++read 4096/4096 bytes at offset 4295491584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295495680 ++read 4096/4096 bytes at offset 4295495680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295499776 ++read 4096/4096 bytes at offset 4295499776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295503872 ++read 4096/4096 bytes at offset 4295503872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295507968 ++read 4096/4096 bytes at offset 4295507968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295512064 ++read 4096/4096 bytes at offset 4295512064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295516160 ++read 4096/4096 bytes at offset 4295516160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295520256 ++read 4096/4096 bytes at offset 4295520256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295524352 ++read 4096/4096 bytes at offset 4295524352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295528448 ++read 4096/4096 bytes at offset 4295528448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295532544 ++read 4096/4096 bytes at offset 4295532544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295536640 ++read 4096/4096 bytes at offset 4295536640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295540736 ++read 4096/4096 bytes at offset 4295540736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295544832 ++read 4096/4096 bytes at offset 4295544832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295548928 ++read 4096/4096 bytes at offset 4295548928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295553024 ++read 4096/4096 bytes at offset 4295553024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295557120 ++read 4096/4096 bytes at offset 4295557120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295561216 ++read 4096/4096 bytes at offset 4295561216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295565312 ++read 4096/4096 bytes at offset 4295565312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295569408 ++read 4096/4096 bytes at offset 4295569408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295573504 ++read 4096/4096 bytes at offset 4295573504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295577600 ++read 4096/4096 bytes at offset 4295577600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295581696 ++read 4096/4096 bytes at offset 4295581696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295585792 ++read 4096/4096 bytes at offset 4295585792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295589888 ++read 4096/4096 bytes at offset 4295589888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295593984 ++read 4096/4096 bytes at offset 4295593984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295598080 ++read 4096/4096 bytes at offset 4295598080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295602176 ++read 4096/4096 bytes at offset 4295602176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295606272 ++read 4096/4096 bytes at offset 4295606272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295610368 ++read 4096/4096 bytes at offset 4295610368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295614464 ++read 4096/4096 bytes at offset 4295614464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295618560 ++read 4096/4096 bytes at offset 4295618560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295622656 ++read 4096/4096 bytes at offset 4295622656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295626752 ++read 4096/4096 bytes at offset 4295626752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295630848 ++read 4096/4096 bytes at offset 4295630848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295634944 ++read 4096/4096 bytes at offset 4295634944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295639040 ++read 4096/4096 bytes at offset 4295639040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295643136 ++read 4096/4096 bytes at offset 4295643136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295647232 ++read 4096/4096 bytes at offset 4295647232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295651328 ++read 4096/4096 bytes at offset 4295651328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295655424 ++read 4096/4096 bytes at offset 4295655424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295659520 ++read 4096/4096 bytes at offset 4295659520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295663616 ++read 4096/4096 bytes at offset 4295663616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295667712 ++read 4096/4096 bytes at offset 4295667712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295671808 ++read 4096/4096 bytes at offset 4295671808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295675904 ++read 4096/4096 bytes at offset 4295675904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295680000 ++read 4096/4096 bytes at offset 4295680000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295684096 ++read 4096/4096 bytes at offset 4295684096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295688192 ++read 4096/4096 bytes at offset 4295688192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295692288 ++read 4096/4096 bytes at offset 4295692288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295696384 ++read 4096/4096 bytes at offset 4295696384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295700480 ++read 4096/4096 bytes at offset 4295700480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295704576 ++read 4096/4096 bytes at offset 4295704576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295708672 ++read 4096/4096 bytes at offset 4295708672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295712768 ++read 4096/4096 bytes at offset 4295712768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295716864 ++read 4096/4096 bytes at offset 4295716864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295720960 ++read 4096/4096 bytes at offset 4295720960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295725056 ++read 4096/4096 bytes at offset 4295725056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295729152 ++read 4096/4096 bytes at offset 4295729152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295733248 ++read 4096/4096 bytes at offset 4295733248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295737344 ++read 4096/4096 bytes at offset 4295737344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295741440 ++read 4096/4096 bytes at offset 4295741440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295745536 ++read 4096/4096 bytes at offset 4295745536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295749632 ++read 4096/4096 bytes at offset 4295749632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295753728 ++read 4096/4096 bytes at offset 4295753728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295757824 ++read 4096/4096 bytes at offset 4295757824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295761920 ++read 4096/4096 bytes at offset 4295761920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295766016 ++read 4096/4096 bytes at offset 4295766016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295770112 ++read 4096/4096 bytes at offset 4295770112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295774208 ++read 4096/4096 bytes at offset 4295774208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295778304 ++read 4096/4096 bytes at offset 4295778304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295782400 ++read 4096/4096 bytes at offset 4295782400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295786496 ++read 4096/4096 bytes at offset 4295786496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295790592 ++read 4096/4096 bytes at offset 4295790592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295794688 ++read 4096/4096 bytes at offset 4295794688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295798784 ++read 4096/4096 bytes at offset 4295798784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295802880 ++read 4096/4096 bytes at offset 4295802880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295806976 ++read 4096/4096 bytes at offset 4295806976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295811072 ++read 4096/4096 bytes at offset 4295811072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295815168 ++read 4096/4096 bytes at offset 4295815168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295819264 ++read 4096/4096 bytes at offset 4295819264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295823360 ++read 4096/4096 bytes at offset 4295823360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295827456 ++read 4096/4096 bytes at offset 4295827456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295831552 ++read 4096/4096 bytes at offset 4295831552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295835648 ++read 4096/4096 bytes at offset 4295835648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295839744 ++read 4096/4096 bytes at offset 4295839744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295843840 ++read 4096/4096 bytes at offset 4295843840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295847936 ++read 4096/4096 bytes at offset 4295847936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295852032 ++read 4096/4096 bytes at offset 4295852032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295856128 ++read 4096/4096 bytes at offset 4295856128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295860224 ++read 4096/4096 bytes at offset 4295860224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295864320 ++read 4096/4096 bytes at offset 4295864320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295868416 ++read 4096/4096 bytes at offset 4295868416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295872512 ++read 4096/4096 bytes at offset 4295872512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295876608 ++read 4096/4096 bytes at offset 4295876608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295880704 ++read 4096/4096 bytes at offset 4295880704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295884800 ++read 4096/4096 bytes at offset 4295884800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295888896 ++read 4096/4096 bytes at offset 4295888896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295892992 ++read 4096/4096 bytes at offset 4295892992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295897088 ++read 4096/4096 bytes at offset 4295897088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295901184 ++read 4096/4096 bytes at offset 4295901184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295905280 ++read 4096/4096 bytes at offset 4295905280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295909376 ++read 4096/4096 bytes at offset 4295909376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295913472 ++read 4096/4096 bytes at offset 4295913472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295917568 ++read 4096/4096 bytes at offset 4295917568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295921664 ++read 4096/4096 bytes at offset 4295921664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295925760 ++read 4096/4096 bytes at offset 4295925760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295929856 ++read 4096/4096 bytes at offset 4295929856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295933952 ++read 4096/4096 bytes at offset 4295933952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295938048 ++read 4096/4096 bytes at offset 4295938048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295942144 ++read 4096/4096 bytes at offset 4295942144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295946240 ++read 4096/4096 bytes at offset 4295946240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295950336 ++read 4096/4096 bytes at offset 4295950336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295954432 ++read 4096/4096 bytes at offset 4295954432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295958528 ++read 4096/4096 bytes at offset 4295958528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295962624 ++read 4096/4096 bytes at offset 4295962624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295966720 ++read 4096/4096 bytes at offset 4295966720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295970816 ++read 4096/4096 bytes at offset 4295970816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295974912 ++read 4096/4096 bytes at offset 4295974912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295979008 ++read 4096/4096 bytes at offset 4295979008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295983104 ++read 4096/4096 bytes at offset 4295983104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295987200 ++read 4096/4096 bytes at offset 4295987200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295991296 ++read 4096/4096 bytes at offset 4295991296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295995392 ++read 4096/4096 bytes at offset 4295995392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295999488 ++read 4096/4096 bytes at offset 4295999488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4296003584 ++read 4096/4096 bytes at offset 4296003584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4296007680 ++read 4096/4096 bytes at offset 4296007680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4296011776 ++read 4096/4096 bytes at offset 4296011776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 4 +-qemu-io> read 2048/2048 bytes at offset 4296017920 ++=== IO: pattern 4 ++read 2048/2048 bytes at offset 4296017920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296022016 ++read 2048/2048 bytes at offset 4296022016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296026112 ++read 2048/2048 bytes at offset 4296026112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296030208 ++read 2048/2048 bytes at offset 4296030208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296034304 ++read 2048/2048 bytes at offset 4296034304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296038400 ++read 2048/2048 bytes at offset 4296038400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296042496 ++read 2048/2048 bytes at offset 4296042496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296046592 ++read 2048/2048 bytes at offset 4296046592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296050688 ++read 2048/2048 bytes at offset 4296050688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296054784 ++read 2048/2048 bytes at offset 4296054784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296058880 ++read 2048/2048 bytes at offset 4296058880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296062976 ++read 2048/2048 bytes at offset 4296062976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296067072 ++read 2048/2048 bytes at offset 4296067072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296071168 ++read 2048/2048 bytes at offset 4296071168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296075264 ++read 2048/2048 bytes at offset 4296075264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296079360 ++read 2048/2048 bytes at offset 4296079360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296083456 ++read 2048/2048 bytes at offset 4296083456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296087552 ++read 2048/2048 bytes at offset 4296087552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296091648 ++read 2048/2048 bytes at offset 4296091648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296095744 ++read 2048/2048 bytes at offset 4296095744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296099840 ++read 2048/2048 bytes at offset 4296099840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296103936 ++read 2048/2048 bytes at offset 4296103936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296108032 ++read 2048/2048 bytes at offset 4296108032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296112128 ++read 2048/2048 bytes at offset 4296112128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296116224 ++read 2048/2048 bytes at offset 4296116224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296120320 ++read 2048/2048 bytes at offset 4296120320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296124416 ++read 2048/2048 bytes at offset 4296124416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296128512 ++read 2048/2048 bytes at offset 4296128512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296132608 ++read 2048/2048 bytes at offset 4296132608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296136704 ++read 2048/2048 bytes at offset 4296136704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296140800 ++read 2048/2048 bytes at offset 4296140800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296144896 ++read 2048/2048 bytes at offset 4296144896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296148992 ++read 2048/2048 bytes at offset 4296148992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296153088 ++read 2048/2048 bytes at offset 4296153088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296157184 ++read 2048/2048 bytes at offset 4296157184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296161280 ++read 2048/2048 bytes at offset 4296161280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296165376 ++read 2048/2048 bytes at offset 4296165376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296169472 ++read 2048/2048 bytes at offset 4296169472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296173568 ++read 2048/2048 bytes at offset 4296173568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296177664 ++read 2048/2048 bytes at offset 4296177664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296181760 ++read 2048/2048 bytes at offset 4296181760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296185856 ++read 2048/2048 bytes at offset 4296185856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296189952 ++read 2048/2048 bytes at offset 4296189952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296194048 ++read 2048/2048 bytes at offset 4296194048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296198144 ++read 2048/2048 bytes at offset 4296198144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296202240 ++read 2048/2048 bytes at offset 4296202240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296206336 ++read 2048/2048 bytes at offset 4296206336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296210432 ++read 2048/2048 bytes at offset 4296210432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296214528 ++read 2048/2048 bytes at offset 4296214528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296218624 ++read 2048/2048 bytes at offset 4296218624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296222720 ++read 2048/2048 bytes at offset 4296222720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296226816 ++read 2048/2048 bytes at offset 4296226816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296230912 ++read 2048/2048 bytes at offset 4296230912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296235008 ++read 2048/2048 bytes at offset 4296235008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296239104 ++read 2048/2048 bytes at offset 4296239104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296243200 ++read 2048/2048 bytes at offset 4296243200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296247296 ++read 2048/2048 bytes at offset 4296247296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296251392 ++read 2048/2048 bytes at offset 4296251392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296255488 ++read 2048/2048 bytes at offset 4296255488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296259584 ++read 2048/2048 bytes at offset 4296259584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296263680 ++read 2048/2048 bytes at offset 4296263680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296267776 ++read 2048/2048 bytes at offset 4296267776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296271872 ++read 2048/2048 bytes at offset 4296271872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296275968 ++read 2048/2048 bytes at offset 4296275968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296280064 ++read 2048/2048 bytes at offset 4296280064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296284160 ++read 2048/2048 bytes at offset 4296284160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296288256 ++read 2048/2048 bytes at offset 4296288256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296292352 ++read 2048/2048 bytes at offset 4296292352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296296448 ++read 2048/2048 bytes at offset 4296296448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296300544 ++read 2048/2048 bytes at offset 4296300544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296304640 ++read 2048/2048 bytes at offset 4296304640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296308736 ++read 2048/2048 bytes at offset 4296308736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296312832 ++read 2048/2048 bytes at offset 4296312832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296316928 ++read 2048/2048 bytes at offset 4296316928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296321024 ++read 2048/2048 bytes at offset 4296321024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296325120 ++read 2048/2048 bytes at offset 4296325120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296329216 ++read 2048/2048 bytes at offset 4296329216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296333312 ++read 2048/2048 bytes at offset 4296333312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296337408 ++read 2048/2048 bytes at offset 4296337408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296341504 ++read 2048/2048 bytes at offset 4296341504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296345600 ++read 2048/2048 bytes at offset 4296345600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296349696 ++read 2048/2048 bytes at offset 4296349696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296353792 ++read 2048/2048 bytes at offset 4296353792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296357888 ++read 2048/2048 bytes at offset 4296357888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296361984 ++read 2048/2048 bytes at offset 4296361984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296366080 ++read 2048/2048 bytes at offset 4296366080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296370176 ++read 2048/2048 bytes at offset 4296370176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296374272 ++read 2048/2048 bytes at offset 4296374272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296378368 ++read 2048/2048 bytes at offset 4296378368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296382464 ++read 2048/2048 bytes at offset 4296382464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296386560 ++read 2048/2048 bytes at offset 4296386560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296390656 ++read 2048/2048 bytes at offset 4296390656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296394752 ++read 2048/2048 bytes at offset 4296394752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296398848 ++read 2048/2048 bytes at offset 4296398848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296402944 ++read 2048/2048 bytes at offset 4296402944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296407040 ++read 2048/2048 bytes at offset 4296407040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296411136 ++read 2048/2048 bytes at offset 4296411136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296415232 ++read 2048/2048 bytes at offset 4296415232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296419328 ++read 2048/2048 bytes at offset 4296419328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296423424 ++read 2048/2048 bytes at offset 4296423424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296427520 ++read 2048/2048 bytes at offset 4296427520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296431616 ++read 2048/2048 bytes at offset 4296431616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296435712 ++read 2048/2048 bytes at offset 4296435712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296439808 ++read 2048/2048 bytes at offset 4296439808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296443904 ++read 2048/2048 bytes at offset 4296443904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296448000 ++read 2048/2048 bytes at offset 4296448000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296452096 ++read 2048/2048 bytes at offset 4296452096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296456192 ++read 2048/2048 bytes at offset 4296456192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296460288 ++read 2048/2048 bytes at offset 4296460288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296464384 ++read 2048/2048 bytes at offset 4296464384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296468480 ++read 2048/2048 bytes at offset 4296468480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296472576 ++read 2048/2048 bytes at offset 4296472576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296476672 ++read 2048/2048 bytes at offset 4296476672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296480768 ++read 2048/2048 bytes at offset 4296480768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296484864 ++read 2048/2048 bytes at offset 4296484864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296488960 ++read 2048/2048 bytes at offset 4296488960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296493056 ++read 2048/2048 bytes at offset 4296493056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296497152 ++read 2048/2048 bytes at offset 4296497152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296501248 ++read 2048/2048 bytes at offset 4296501248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296505344 ++read 2048/2048 bytes at offset 4296505344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296509440 ++read 2048/2048 bytes at offset 4296509440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296513536 ++read 2048/2048 bytes at offset 4296513536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296517632 ++read 2048/2048 bytes at offset 4296517632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296521728 ++read 2048/2048 bytes at offset 4296521728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296525824 ++read 2048/2048 bytes at offset 4296525824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296529920 ++read 2048/2048 bytes at offset 4296529920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296534016 ++read 2048/2048 bytes at offset 4296534016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296538112 ++read 2048/2048 bytes at offset 4296538112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296542208 ++read 2048/2048 bytes at offset 4296542208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296546304 ++read 2048/2048 bytes at offset 4296546304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296550400 ++read 2048/2048 bytes at offset 4296550400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296554496 ++read 2048/2048 bytes at offset 4296554496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296558592 ++read 2048/2048 bytes at offset 4296558592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296562688 ++read 2048/2048 bytes at offset 4296562688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296566784 ++read 2048/2048 bytes at offset 4296566784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296570880 ++read 2048/2048 bytes at offset 4296570880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296574976 ++read 2048/2048 bytes at offset 4296574976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296579072 ++read 2048/2048 bytes at offset 4296579072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296583168 ++read 2048/2048 bytes at offset 4296583168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296587264 ++read 2048/2048 bytes at offset 4296587264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296591360 ++read 2048/2048 bytes at offset 4296591360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296595456 ++read 2048/2048 bytes at offset 4296595456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296599552 ++read 2048/2048 bytes at offset 4296599552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296603648 ++read 2048/2048 bytes at offset 4296603648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296607744 ++read 2048/2048 bytes at offset 4296607744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296611840 ++read 2048/2048 bytes at offset 4296611840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296615936 ++read 2048/2048 bytes at offset 4296615936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296620032 ++read 2048/2048 bytes at offset 4296620032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296624128 ++read 2048/2048 bytes at offset 4296624128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296628224 ++read 2048/2048 bytes at offset 4296628224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296632320 ++read 2048/2048 bytes at offset 4296632320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296636416 ++read 2048/2048 bytes at offset 4296636416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296640512 ++read 2048/2048 bytes at offset 4296640512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296644608 ++read 2048/2048 bytes at offset 4296644608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296648704 ++read 2048/2048 bytes at offset 4296648704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296652800 ++read 2048/2048 bytes at offset 4296652800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296656896 ++read 2048/2048 bytes at offset 4296656896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296660992 ++read 2048/2048 bytes at offset 4296660992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296665088 ++read 2048/2048 bytes at offset 4296665088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296669184 ++read 2048/2048 bytes at offset 4296669184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296673280 ++read 2048/2048 bytes at offset 4296673280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296677376 ++read 2048/2048 bytes at offset 4296677376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296681472 ++read 2048/2048 bytes at offset 4296681472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296685568 ++read 2048/2048 bytes at offset 4296685568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296689664 ++read 2048/2048 bytes at offset 4296689664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296693760 ++read 2048/2048 bytes at offset 4296693760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296697856 ++read 2048/2048 bytes at offset 4296697856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296701952 ++read 2048/2048 bytes at offset 4296701952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296706048 ++read 2048/2048 bytes at offset 4296706048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296710144 ++read 2048/2048 bytes at offset 4296710144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296714240 ++read 2048/2048 bytes at offset 4296714240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296718336 ++read 2048/2048 bytes at offset 4296718336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296722432 ++read 2048/2048 bytes at offset 4296722432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296726528 ++read 2048/2048 bytes at offset 4296726528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296730624 ++read 2048/2048 bytes at offset 4296730624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296734720 ++read 2048/2048 bytes at offset 4296734720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296738816 ++read 2048/2048 bytes at offset 4296738816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296742912 ++read 2048/2048 bytes at offset 4296742912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296747008 ++read 2048/2048 bytes at offset 4296747008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296751104 ++read 2048/2048 bytes at offset 4296751104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296755200 ++read 2048/2048 bytes at offset 4296755200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296759296 ++read 2048/2048 bytes at offset 4296759296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296763392 ++read 2048/2048 bytes at offset 4296763392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296767488 ++read 2048/2048 bytes at offset 4296767488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296771584 ++read 2048/2048 bytes at offset 4296771584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296775680 ++read 2048/2048 bytes at offset 4296775680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296779776 ++read 2048/2048 bytes at offset 4296779776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296783872 ++read 2048/2048 bytes at offset 4296783872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296787968 ++read 2048/2048 bytes at offset 4296787968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296792064 ++read 2048/2048 bytes at offset 4296792064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296796160 ++read 2048/2048 bytes at offset 4296796160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296800256 ++read 2048/2048 bytes at offset 4296800256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296804352 ++read 2048/2048 bytes at offset 4296804352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296808448 ++read 2048/2048 bytes at offset 4296808448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296812544 ++read 2048/2048 bytes at offset 4296812544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296816640 ++read 2048/2048 bytes at offset 4296816640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296820736 ++read 2048/2048 bytes at offset 4296820736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296824832 ++read 2048/2048 bytes at offset 4296824832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296828928 ++read 2048/2048 bytes at offset 4296828928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296833024 ++read 2048/2048 bytes at offset 4296833024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296837120 ++read 2048/2048 bytes at offset 4296837120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296841216 ++read 2048/2048 bytes at offset 4296841216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296845312 ++read 2048/2048 bytes at offset 4296845312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296849408 ++read 2048/2048 bytes at offset 4296849408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296853504 ++read 2048/2048 bytes at offset 4296853504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296857600 ++read 2048/2048 bytes at offset 4296857600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296861696 ++read 2048/2048 bytes at offset 4296861696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296865792 ++read 2048/2048 bytes at offset 4296865792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296869888 ++read 2048/2048 bytes at offset 4296869888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296873984 ++read 2048/2048 bytes at offset 4296873984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296878080 ++read 2048/2048 bytes at offset 4296878080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296882176 ++read 2048/2048 bytes at offset 4296882176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296886272 ++read 2048/2048 bytes at offset 4296886272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296890368 ++read 2048/2048 bytes at offset 4296890368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296894464 ++read 2048/2048 bytes at offset 4296894464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296898560 ++read 2048/2048 bytes at offset 4296898560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296902656 ++read 2048/2048 bytes at offset 4296902656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296906752 ++read 2048/2048 bytes at offset 4296906752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296910848 ++read 2048/2048 bytes at offset 4296910848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296914944 ++read 2048/2048 bytes at offset 4296914944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296919040 ++read 2048/2048 bytes at offset 4296919040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296923136 ++read 2048/2048 bytes at offset 4296923136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296927232 ++read 2048/2048 bytes at offset 4296927232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296931328 ++read 2048/2048 bytes at offset 4296931328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296935424 ++read 2048/2048 bytes at offset 4296935424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296939520 ++read 2048/2048 bytes at offset 4296939520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296943616 ++read 2048/2048 bytes at offset 4296943616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296947712 ++read 2048/2048 bytes at offset 4296947712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296951808 ++read 2048/2048 bytes at offset 4296951808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296955904 ++read 2048/2048 bytes at offset 4296955904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296960000 ++read 2048/2048 bytes at offset 4296960000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296964096 ++read 2048/2048 bytes at offset 4296964096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296968192 ++read 2048/2048 bytes at offset 4296968192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296972288 ++read 2048/2048 bytes at offset 4296972288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296976384 ++read 2048/2048 bytes at offset 4296976384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296980480 ++read 2048/2048 bytes at offset 4296980480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296984576 ++read 2048/2048 bytes at offset 4296984576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296988672 ++read 2048/2048 bytes at offset 4296988672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296992768 ++read 2048/2048 bytes at offset 4296992768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296996864 ++read 2048/2048 bytes at offset 4296996864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297000960 ++read 2048/2048 bytes at offset 4297000960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297005056 ++read 2048/2048 bytes at offset 4297005056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297009152 ++read 2048/2048 bytes at offset 4297009152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297013248 ++read 2048/2048 bytes at offset 4297013248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297017344 ++read 2048/2048 bytes at offset 4297017344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297021440 ++read 2048/2048 bytes at offset 4297021440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297025536 ++read 2048/2048 bytes at offset 4297025536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297029632 ++read 2048/2048 bytes at offset 4297029632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297033728 ++read 2048/2048 bytes at offset 4297033728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297037824 ++read 2048/2048 bytes at offset 4297037824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297041920 ++read 2048/2048 bytes at offset 4297041920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297046016 ++read 2048/2048 bytes at offset 4297046016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297050112 ++read 2048/2048 bytes at offset 4297050112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297054208 ++read 2048/2048 bytes at offset 4297054208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297058304 ++read 2048/2048 bytes at offset 4297058304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297062400 ++read 2048/2048 bytes at offset 4297062400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> read 2048/2048 bytes at offset 4297064448 ++=== IO: pattern 0 ++read 2048/2048 bytes at offset 4297064448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297068544 ++read 2048/2048 bytes at offset 4297068544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297072640 ++read 2048/2048 bytes at offset 4297072640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297076736 ++read 2048/2048 bytes at offset 4297076736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297080832 ++read 2048/2048 bytes at offset 4297080832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297084928 ++read 2048/2048 bytes at offset 4297084928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297089024 ++read 2048/2048 bytes at offset 4297089024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297093120 ++read 2048/2048 bytes at offset 4297093120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297097216 ++read 2048/2048 bytes at offset 4297097216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297101312 ++read 2048/2048 bytes at offset 4297101312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297105408 ++read 2048/2048 bytes at offset 4297105408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297109504 ++read 2048/2048 bytes at offset 4297109504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297113600 ++read 2048/2048 bytes at offset 4297113600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297117696 ++read 2048/2048 bytes at offset 4297117696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297121792 ++read 2048/2048 bytes at offset 4297121792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297125888 ++read 2048/2048 bytes at offset 4297125888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297129984 ++read 2048/2048 bytes at offset 4297129984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297134080 ++read 2048/2048 bytes at offset 4297134080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297138176 ++read 2048/2048 bytes at offset 4297138176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297142272 ++read 2048/2048 bytes at offset 4297142272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297146368 ++read 2048/2048 bytes at offset 4297146368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297150464 ++read 2048/2048 bytes at offset 4297150464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297154560 ++read 2048/2048 bytes at offset 4297154560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297158656 ++read 2048/2048 bytes at offset 4297158656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297162752 ++read 2048/2048 bytes at offset 4297162752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297166848 ++read 2048/2048 bytes at offset 4297166848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297170944 ++read 2048/2048 bytes at offset 4297170944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297175040 ++read 2048/2048 bytes at offset 4297175040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297179136 ++read 2048/2048 bytes at offset 4297179136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297183232 ++read 2048/2048 bytes at offset 4297183232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297187328 ++read 2048/2048 bytes at offset 4297187328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297191424 ++read 2048/2048 bytes at offset 4297191424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297195520 ++read 2048/2048 bytes at offset 4297195520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297199616 ++read 2048/2048 bytes at offset 4297199616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297203712 ++read 2048/2048 bytes at offset 4297203712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297207808 ++read 2048/2048 bytes at offset 4297207808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297211904 ++read 2048/2048 bytes at offset 4297211904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297216000 ++read 2048/2048 bytes at offset 4297216000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297220096 ++read 2048/2048 bytes at offset 4297220096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297224192 ++read 2048/2048 bytes at offset 4297224192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297228288 ++read 2048/2048 bytes at offset 4297228288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297232384 ++read 2048/2048 bytes at offset 4297232384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297236480 ++read 2048/2048 bytes at offset 4297236480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297240576 ++read 2048/2048 bytes at offset 4297240576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297244672 ++read 2048/2048 bytes at offset 4297244672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297248768 ++read 2048/2048 bytes at offset 4297248768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297252864 ++read 2048/2048 bytes at offset 4297252864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297256960 ++read 2048/2048 bytes at offset 4297256960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297261056 ++read 2048/2048 bytes at offset 4297261056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297265152 ++read 2048/2048 bytes at offset 4297265152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297269248 ++read 2048/2048 bytes at offset 4297269248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297273344 ++read 2048/2048 bytes at offset 4297273344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297277440 ++read 2048/2048 bytes at offset 4297277440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297281536 ++read 2048/2048 bytes at offset 4297281536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297285632 ++read 2048/2048 bytes at offset 4297285632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297289728 ++read 2048/2048 bytes at offset 4297289728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297293824 ++read 2048/2048 bytes at offset 4297293824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297297920 ++read 2048/2048 bytes at offset 4297297920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297302016 ++read 2048/2048 bytes at offset 4297302016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297306112 ++read 2048/2048 bytes at offset 4297306112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297310208 ++read 2048/2048 bytes at offset 4297310208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297314304 ++read 2048/2048 bytes at offset 4297314304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297318400 ++read 2048/2048 bytes at offset 4297318400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297322496 ++read 2048/2048 bytes at offset 4297322496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297326592 ++read 2048/2048 bytes at offset 4297326592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297330688 ++read 2048/2048 bytes at offset 4297330688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297334784 ++read 2048/2048 bytes at offset 4297334784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297338880 ++read 2048/2048 bytes at offset 4297338880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297342976 ++read 2048/2048 bytes at offset 4297342976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297347072 ++read 2048/2048 bytes at offset 4297347072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297351168 ++read 2048/2048 bytes at offset 4297351168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297355264 ++read 2048/2048 bytes at offset 4297355264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297359360 ++read 2048/2048 bytes at offset 4297359360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297363456 ++read 2048/2048 bytes at offset 4297363456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297367552 ++read 2048/2048 bytes at offset 4297367552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297371648 ++read 2048/2048 bytes at offset 4297371648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297375744 ++read 2048/2048 bytes at offset 4297375744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297379840 ++read 2048/2048 bytes at offset 4297379840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297383936 ++read 2048/2048 bytes at offset 4297383936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297388032 ++read 2048/2048 bytes at offset 4297388032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297392128 ++read 2048/2048 bytes at offset 4297392128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297396224 ++read 2048/2048 bytes at offset 4297396224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297400320 ++read 2048/2048 bytes at offset 4297400320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297404416 ++read 2048/2048 bytes at offset 4297404416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297408512 ++read 2048/2048 bytes at offset 4297408512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297412608 ++read 2048/2048 bytes at offset 4297412608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297416704 ++read 2048/2048 bytes at offset 4297416704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297420800 ++read 2048/2048 bytes at offset 4297420800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297424896 ++read 2048/2048 bytes at offset 4297424896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297428992 ++read 2048/2048 bytes at offset 4297428992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297433088 ++read 2048/2048 bytes at offset 4297433088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297437184 ++read 2048/2048 bytes at offset 4297437184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297441280 ++read 2048/2048 bytes at offset 4297441280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297445376 ++read 2048/2048 bytes at offset 4297445376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297449472 ++read 2048/2048 bytes at offset 4297449472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297453568 ++read 2048/2048 bytes at offset 4297453568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297457664 ++read 2048/2048 bytes at offset 4297457664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297461760 ++read 2048/2048 bytes at offset 4297461760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297465856 ++read 2048/2048 bytes at offset 4297465856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297469952 ++read 2048/2048 bytes at offset 4297469952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297474048 ++read 2048/2048 bytes at offset 4297474048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297478144 ++read 2048/2048 bytes at offset 4297478144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297482240 ++read 2048/2048 bytes at offset 4297482240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297486336 ++read 2048/2048 bytes at offset 4297486336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297490432 ++read 2048/2048 bytes at offset 4297490432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297494528 ++read 2048/2048 bytes at offset 4297494528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297498624 ++read 2048/2048 bytes at offset 4297498624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297502720 ++read 2048/2048 bytes at offset 4297502720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297506816 ++read 2048/2048 bytes at offset 4297506816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297510912 ++read 2048/2048 bytes at offset 4297510912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297515008 ++read 2048/2048 bytes at offset 4297515008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297519104 ++read 2048/2048 bytes at offset 4297519104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297523200 ++read 2048/2048 bytes at offset 4297523200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297527296 ++read 2048/2048 bytes at offset 4297527296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297531392 ++read 2048/2048 bytes at offset 4297531392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297535488 ++read 2048/2048 bytes at offset 4297535488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297539584 ++read 2048/2048 bytes at offset 4297539584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297543680 ++read 2048/2048 bytes at offset 4297543680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297547776 ++read 2048/2048 bytes at offset 4297547776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297551872 ++read 2048/2048 bytes at offset 4297551872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297555968 ++read 2048/2048 bytes at offset 4297555968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297560064 ++read 2048/2048 bytes at offset 4297560064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297564160 ++read 2048/2048 bytes at offset 4297564160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297568256 ++read 2048/2048 bytes at offset 4297568256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297572352 ++read 2048/2048 bytes at offset 4297572352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297576448 ++read 2048/2048 bytes at offset 4297576448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297580544 ++read 2048/2048 bytes at offset 4297580544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297584640 ++read 2048/2048 bytes at offset 4297584640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297588736 ++read 2048/2048 bytes at offset 4297588736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297592832 ++read 2048/2048 bytes at offset 4297592832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297596928 ++read 2048/2048 bytes at offset 4297596928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297601024 ++read 2048/2048 bytes at offset 4297601024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297605120 ++read 2048/2048 bytes at offset 4297605120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297609216 ++read 2048/2048 bytes at offset 4297609216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297613312 ++read 2048/2048 bytes at offset 4297613312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297617408 ++read 2048/2048 bytes at offset 4297617408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297621504 ++read 2048/2048 bytes at offset 4297621504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297625600 ++read 2048/2048 bytes at offset 4297625600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297629696 ++read 2048/2048 bytes at offset 4297629696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297633792 ++read 2048/2048 bytes at offset 4297633792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297637888 ++read 2048/2048 bytes at offset 4297637888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297641984 ++read 2048/2048 bytes at offset 4297641984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297646080 ++read 2048/2048 bytes at offset 4297646080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297650176 ++read 2048/2048 bytes at offset 4297650176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297654272 ++read 2048/2048 bytes at offset 4297654272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297658368 ++read 2048/2048 bytes at offset 4297658368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297662464 ++read 2048/2048 bytes at offset 4297662464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297666560 ++read 2048/2048 bytes at offset 4297666560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297670656 ++read 2048/2048 bytes at offset 4297670656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297674752 ++read 2048/2048 bytes at offset 4297674752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297678848 ++read 2048/2048 bytes at offset 4297678848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297682944 ++read 2048/2048 bytes at offset 4297682944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297687040 ++read 2048/2048 bytes at offset 4297687040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297691136 ++read 2048/2048 bytes at offset 4297691136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297695232 ++read 2048/2048 bytes at offset 4297695232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297699328 ++read 2048/2048 bytes at offset 4297699328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297703424 ++read 2048/2048 bytes at offset 4297703424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297707520 ++read 2048/2048 bytes at offset 4297707520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297711616 ++read 2048/2048 bytes at offset 4297711616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297715712 ++read 2048/2048 bytes at offset 4297715712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297719808 ++read 2048/2048 bytes at offset 4297719808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297723904 ++read 2048/2048 bytes at offset 4297723904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297728000 ++read 2048/2048 bytes at offset 4297728000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297732096 ++read 2048/2048 bytes at offset 4297732096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297736192 ++read 2048/2048 bytes at offset 4297736192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297740288 ++read 2048/2048 bytes at offset 4297740288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297744384 ++read 2048/2048 bytes at offset 4297744384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297748480 ++read 2048/2048 bytes at offset 4297748480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297752576 ++read 2048/2048 bytes at offset 4297752576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297756672 ++read 2048/2048 bytes at offset 4297756672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297760768 ++read 2048/2048 bytes at offset 4297760768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297764864 ++read 2048/2048 bytes at offset 4297764864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297768960 ++read 2048/2048 bytes at offset 4297768960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297773056 ++read 2048/2048 bytes at offset 4297773056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297777152 ++read 2048/2048 bytes at offset 4297777152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297781248 ++read 2048/2048 bytes at offset 4297781248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297785344 ++read 2048/2048 bytes at offset 4297785344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297789440 ++read 2048/2048 bytes at offset 4297789440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297793536 ++read 2048/2048 bytes at offset 4297793536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297797632 ++read 2048/2048 bytes at offset 4297797632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297801728 ++read 2048/2048 bytes at offset 4297801728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297805824 ++read 2048/2048 bytes at offset 4297805824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297809920 ++read 2048/2048 bytes at offset 4297809920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297814016 ++read 2048/2048 bytes at offset 4297814016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297818112 ++read 2048/2048 bytes at offset 4297818112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297822208 ++read 2048/2048 bytes at offset 4297822208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297826304 ++read 2048/2048 bytes at offset 4297826304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297830400 ++read 2048/2048 bytes at offset 4297830400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297834496 ++read 2048/2048 bytes at offset 4297834496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297838592 ++read 2048/2048 bytes at offset 4297838592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297842688 ++read 2048/2048 bytes at offset 4297842688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297846784 ++read 2048/2048 bytes at offset 4297846784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297850880 ++read 2048/2048 bytes at offset 4297850880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297854976 ++read 2048/2048 bytes at offset 4297854976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297859072 ++read 2048/2048 bytes at offset 4297859072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297863168 ++read 2048/2048 bytes at offset 4297863168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297867264 ++read 2048/2048 bytes at offset 4297867264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297871360 ++read 2048/2048 bytes at offset 4297871360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297875456 ++read 2048/2048 bytes at offset 4297875456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297879552 ++read 2048/2048 bytes at offset 4297879552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297883648 ++read 2048/2048 bytes at offset 4297883648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297887744 ++read 2048/2048 bytes at offset 4297887744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297891840 ++read 2048/2048 bytes at offset 4297891840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297895936 ++read 2048/2048 bytes at offset 4297895936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297900032 ++read 2048/2048 bytes at offset 4297900032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297904128 ++read 2048/2048 bytes at offset 4297904128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297908224 ++read 2048/2048 bytes at offset 4297908224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297912320 ++read 2048/2048 bytes at offset 4297912320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297916416 ++read 2048/2048 bytes at offset 4297916416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297920512 ++read 2048/2048 bytes at offset 4297920512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297924608 ++read 2048/2048 bytes at offset 4297924608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297928704 ++read 2048/2048 bytes at offset 4297928704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297932800 ++read 2048/2048 bytes at offset 4297932800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297936896 ++read 2048/2048 bytes at offset 4297936896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297940992 ++read 2048/2048 bytes at offset 4297940992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297945088 ++read 2048/2048 bytes at offset 4297945088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297949184 ++read 2048/2048 bytes at offset 4297949184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297953280 ++read 2048/2048 bytes at offset 4297953280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297957376 ++read 2048/2048 bytes at offset 4297957376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297961472 ++read 2048/2048 bytes at offset 4297961472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297965568 ++read 2048/2048 bytes at offset 4297965568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297969664 ++read 2048/2048 bytes at offset 4297969664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297973760 ++read 2048/2048 bytes at offset 4297973760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297977856 ++read 2048/2048 bytes at offset 4297977856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297981952 ++read 2048/2048 bytes at offset 4297981952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297986048 ++read 2048/2048 bytes at offset 4297986048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297990144 ++read 2048/2048 bytes at offset 4297990144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297994240 ++read 2048/2048 bytes at offset 4297994240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297998336 ++read 2048/2048 bytes at offset 4297998336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298002432 ++read 2048/2048 bytes at offset 4298002432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298006528 ++read 2048/2048 bytes at offset 4298006528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298010624 ++read 2048/2048 bytes at offset 4298010624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298014720 ++read 2048/2048 bytes at offset 4298014720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298018816 ++read 2048/2048 bytes at offset 4298018816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298022912 ++read 2048/2048 bytes at offset 4298022912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298027008 ++read 2048/2048 bytes at offset 4298027008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298031104 ++read 2048/2048 bytes at offset 4298031104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298035200 ++read 2048/2048 bytes at offset 4298035200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298039296 ++read 2048/2048 bytes at offset 4298039296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298043392 ++read 2048/2048 bytes at offset 4298043392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298047488 ++read 2048/2048 bytes at offset 4298047488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298051584 ++read 2048/2048 bytes at offset 4298051584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298055680 ++read 2048/2048 bytes at offset 4298055680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298059776 ++read 2048/2048 bytes at offset 4298059776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298063872 ++read 2048/2048 bytes at offset 4298063872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298067968 ++read 2048/2048 bytes at offset 4298067968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298072064 ++read 2048/2048 bytes at offset 4298072064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298076160 ++read 2048/2048 bytes at offset 4298076160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298080256 ++read 2048/2048 bytes at offset 4298080256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298084352 ++read 2048/2048 bytes at offset 4298084352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298088448 ++read 2048/2048 bytes at offset 4298088448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298092544 ++read 2048/2048 bytes at offset 4298092544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298096640 ++read 2048/2048 bytes at offset 4298096640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298100736 ++read 2048/2048 bytes at offset 4298100736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298104832 ++read 2048/2048 bytes at offset 4298104832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298108928 ++read 2048/2048 bytes at offset 4298108928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 2 +-qemu-io> read 2048/2048 bytes at offset 4298114048 ++=== IO: pattern 2 ++read 2048/2048 bytes at offset 4298114048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298118144 ++read 2048/2048 bytes at offset 4298118144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298122240 ++read 2048/2048 bytes at offset 4298122240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298126336 ++read 2048/2048 bytes at offset 4298126336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298130432 ++read 2048/2048 bytes at offset 4298130432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298134528 ++read 2048/2048 bytes at offset 4298134528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298138624 ++read 2048/2048 bytes at offset 4298138624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298142720 ++read 2048/2048 bytes at offset 4298142720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298146816 ++read 2048/2048 bytes at offset 4298146816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298150912 ++read 2048/2048 bytes at offset 4298150912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298155008 ++read 2048/2048 bytes at offset 4298155008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298159104 ++read 2048/2048 bytes at offset 4298159104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298163200 ++read 2048/2048 bytes at offset 4298163200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298167296 ++read 2048/2048 bytes at offset 4298167296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298171392 ++read 2048/2048 bytes at offset 4298171392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298175488 ++read 2048/2048 bytes at offset 4298175488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298179584 ++read 2048/2048 bytes at offset 4298179584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298183680 ++read 2048/2048 bytes at offset 4298183680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298187776 ++read 2048/2048 bytes at offset 4298187776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298191872 ++read 2048/2048 bytes at offset 4298191872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298195968 ++read 2048/2048 bytes at offset 4298195968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298200064 ++read 2048/2048 bytes at offset 4298200064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298204160 ++read 2048/2048 bytes at offset 4298204160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298208256 ++read 2048/2048 bytes at offset 4298208256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298212352 ++read 2048/2048 bytes at offset 4298212352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298216448 ++read 2048/2048 bytes at offset 4298216448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298220544 ++read 2048/2048 bytes at offset 4298220544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298224640 ++read 2048/2048 bytes at offset 4298224640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298228736 ++read 2048/2048 bytes at offset 4298228736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298232832 ++read 2048/2048 bytes at offset 4298232832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298236928 ++read 2048/2048 bytes at offset 4298236928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298241024 ++read 2048/2048 bytes at offset 4298241024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298245120 ++read 2048/2048 bytes at offset 4298245120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298249216 ++read 2048/2048 bytes at offset 4298249216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298253312 ++read 2048/2048 bytes at offset 4298253312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298257408 ++read 2048/2048 bytes at offset 4298257408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298261504 ++read 2048/2048 bytes at offset 4298261504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298265600 ++read 2048/2048 bytes at offset 4298265600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298269696 ++read 2048/2048 bytes at offset 4298269696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298273792 ++read 2048/2048 bytes at offset 4298273792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298277888 ++read 2048/2048 bytes at offset 4298277888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298281984 ++read 2048/2048 bytes at offset 4298281984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298286080 ++read 2048/2048 bytes at offset 4298286080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298290176 ++read 2048/2048 bytes at offset 4298290176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298294272 ++read 2048/2048 bytes at offset 4298294272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298298368 ++read 2048/2048 bytes at offset 4298298368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298302464 ++read 2048/2048 bytes at offset 4298302464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298306560 ++read 2048/2048 bytes at offset 4298306560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298310656 ++read 2048/2048 bytes at offset 4298310656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298314752 ++read 2048/2048 bytes at offset 4298314752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298318848 ++read 2048/2048 bytes at offset 4298318848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298322944 ++read 2048/2048 bytes at offset 4298322944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298327040 ++read 2048/2048 bytes at offset 4298327040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298331136 ++read 2048/2048 bytes at offset 4298331136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298335232 ++read 2048/2048 bytes at offset 4298335232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298339328 ++read 2048/2048 bytes at offset 4298339328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298343424 ++read 2048/2048 bytes at offset 4298343424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298347520 ++read 2048/2048 bytes at offset 4298347520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298351616 ++read 2048/2048 bytes at offset 4298351616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298355712 ++read 2048/2048 bytes at offset 4298355712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298359808 ++read 2048/2048 bytes at offset 4298359808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298363904 ++read 2048/2048 bytes at offset 4298363904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298368000 ++read 2048/2048 bytes at offset 4298368000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298372096 ++read 2048/2048 bytes at offset 4298372096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298376192 ++read 2048/2048 bytes at offset 4298376192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298380288 ++read 2048/2048 bytes at offset 4298380288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298384384 ++read 2048/2048 bytes at offset 4298384384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298388480 ++read 2048/2048 bytes at offset 4298388480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298392576 ++read 2048/2048 bytes at offset 4298392576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298396672 ++read 2048/2048 bytes at offset 4298396672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298400768 ++read 2048/2048 bytes at offset 4298400768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298404864 ++read 2048/2048 bytes at offset 4298404864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298408960 ++read 2048/2048 bytes at offset 4298408960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298413056 ++read 2048/2048 bytes at offset 4298413056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298417152 ++read 2048/2048 bytes at offset 4298417152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298421248 ++read 2048/2048 bytes at offset 4298421248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298425344 ++read 2048/2048 bytes at offset 4298425344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298429440 ++read 2048/2048 bytes at offset 4298429440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298433536 ++read 2048/2048 bytes at offset 4298433536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298437632 ++read 2048/2048 bytes at offset 4298437632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298441728 ++read 2048/2048 bytes at offset 4298441728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298445824 ++read 2048/2048 bytes at offset 4298445824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298449920 ++read 2048/2048 bytes at offset 4298449920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298454016 ++read 2048/2048 bytes at offset 4298454016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298458112 ++read 2048/2048 bytes at offset 4298458112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298462208 ++read 2048/2048 bytes at offset 4298462208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298466304 ++read 2048/2048 bytes at offset 4298466304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298470400 ++read 2048/2048 bytes at offset 4298470400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298474496 ++read 2048/2048 bytes at offset 4298474496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298478592 ++read 2048/2048 bytes at offset 4298478592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298482688 ++read 2048/2048 bytes at offset 4298482688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298486784 ++read 2048/2048 bytes at offset 4298486784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298490880 ++read 2048/2048 bytes at offset 4298490880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298494976 ++read 2048/2048 bytes at offset 4298494976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298499072 ++read 2048/2048 bytes at offset 4298499072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298503168 ++read 2048/2048 bytes at offset 4298503168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298507264 ++read 2048/2048 bytes at offset 4298507264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298511360 ++read 2048/2048 bytes at offset 4298511360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298515456 ++read 2048/2048 bytes at offset 4298515456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298519552 ++read 2048/2048 bytes at offset 4298519552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298523648 ++read 2048/2048 bytes at offset 4298523648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298527744 ++read 2048/2048 bytes at offset 4298527744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298531840 ++read 2048/2048 bytes at offset 4298531840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298535936 ++read 2048/2048 bytes at offset 4298535936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298540032 ++read 2048/2048 bytes at offset 4298540032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298544128 ++read 2048/2048 bytes at offset 4298544128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298548224 ++read 2048/2048 bytes at offset 4298548224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298552320 ++read 2048/2048 bytes at offset 4298552320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298556416 ++read 2048/2048 bytes at offset 4298556416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298560512 ++read 2048/2048 bytes at offset 4298560512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298564608 ++read 2048/2048 bytes at offset 4298564608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298568704 ++read 2048/2048 bytes at offset 4298568704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298572800 ++read 2048/2048 bytes at offset 4298572800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298576896 ++read 2048/2048 bytes at offset 4298576896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298580992 ++read 2048/2048 bytes at offset 4298580992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298585088 ++read 2048/2048 bytes at offset 4298585088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298589184 ++read 2048/2048 bytes at offset 4298589184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298593280 ++read 2048/2048 bytes at offset 4298593280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298597376 ++read 2048/2048 bytes at offset 4298597376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298601472 ++read 2048/2048 bytes at offset 4298601472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298605568 ++read 2048/2048 bytes at offset 4298605568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298609664 ++read 2048/2048 bytes at offset 4298609664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298613760 ++read 2048/2048 bytes at offset 4298613760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298617856 ++read 2048/2048 bytes at offset 4298617856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298621952 ++read 2048/2048 bytes at offset 4298621952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298626048 ++read 2048/2048 bytes at offset 4298626048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298630144 ++read 2048/2048 bytes at offset 4298630144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298634240 ++read 2048/2048 bytes at offset 4298634240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298638336 ++read 2048/2048 bytes at offset 4298638336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298642432 ++read 2048/2048 bytes at offset 4298642432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298646528 ++read 2048/2048 bytes at offset 4298646528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298650624 ++read 2048/2048 bytes at offset 4298650624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298654720 ++read 2048/2048 bytes at offset 4298654720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298658816 ++read 2048/2048 bytes at offset 4298658816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298662912 ++read 2048/2048 bytes at offset 4298662912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298667008 ++read 2048/2048 bytes at offset 4298667008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298671104 ++read 2048/2048 bytes at offset 4298671104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298675200 ++read 2048/2048 bytes at offset 4298675200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298679296 ++read 2048/2048 bytes at offset 4298679296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298683392 ++read 2048/2048 bytes at offset 4298683392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298687488 ++read 2048/2048 bytes at offset 4298687488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298691584 ++read 2048/2048 bytes at offset 4298691584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298695680 ++read 2048/2048 bytes at offset 4298695680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298699776 ++read 2048/2048 bytes at offset 4298699776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298703872 ++read 2048/2048 bytes at offset 4298703872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298707968 ++read 2048/2048 bytes at offset 4298707968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298712064 ++read 2048/2048 bytes at offset 4298712064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298716160 ++read 2048/2048 bytes at offset 4298716160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298720256 ++read 2048/2048 bytes at offset 4298720256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298724352 ++read 2048/2048 bytes at offset 4298724352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298728448 ++read 2048/2048 bytes at offset 4298728448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298732544 ++read 2048/2048 bytes at offset 4298732544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298736640 ++read 2048/2048 bytes at offset 4298736640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298740736 ++read 2048/2048 bytes at offset 4298740736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298744832 ++read 2048/2048 bytes at offset 4298744832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298748928 ++read 2048/2048 bytes at offset 4298748928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298753024 ++read 2048/2048 bytes at offset 4298753024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298757120 ++read 2048/2048 bytes at offset 4298757120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298761216 ++read 2048/2048 bytes at offset 4298761216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298765312 ++read 2048/2048 bytes at offset 4298765312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298769408 ++read 2048/2048 bytes at offset 4298769408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298773504 ++read 2048/2048 bytes at offset 4298773504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298777600 ++read 2048/2048 bytes at offset 4298777600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298781696 ++read 2048/2048 bytes at offset 4298781696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298785792 ++read 2048/2048 bytes at offset 4298785792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298789888 ++read 2048/2048 bytes at offset 4298789888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298793984 ++read 2048/2048 bytes at offset 4298793984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298798080 ++read 2048/2048 bytes at offset 4298798080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298802176 ++read 2048/2048 bytes at offset 4298802176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298806272 ++read 2048/2048 bytes at offset 4298806272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298810368 ++read 2048/2048 bytes at offset 4298810368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298814464 ++read 2048/2048 bytes at offset 4298814464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298818560 ++read 2048/2048 bytes at offset 4298818560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298822656 ++read 2048/2048 bytes at offset 4298822656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298826752 ++read 2048/2048 bytes at offset 4298826752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298830848 ++read 2048/2048 bytes at offset 4298830848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298834944 ++read 2048/2048 bytes at offset 4298834944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298839040 ++read 2048/2048 bytes at offset 4298839040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298843136 ++read 2048/2048 bytes at offset 4298843136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298847232 ++read 2048/2048 bytes at offset 4298847232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298851328 ++read 2048/2048 bytes at offset 4298851328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298855424 ++read 2048/2048 bytes at offset 4298855424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298859520 ++read 2048/2048 bytes at offset 4298859520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298863616 ++read 2048/2048 bytes at offset 4298863616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298867712 ++read 2048/2048 bytes at offset 4298867712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298871808 ++read 2048/2048 bytes at offset 4298871808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298875904 ++read 2048/2048 bytes at offset 4298875904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298880000 ++read 2048/2048 bytes at offset 4298880000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298884096 ++read 2048/2048 bytes at offset 4298884096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298888192 ++read 2048/2048 bytes at offset 4298888192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298892288 ++read 2048/2048 bytes at offset 4298892288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298896384 ++read 2048/2048 bytes at offset 4298896384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298900480 ++read 2048/2048 bytes at offset 4298900480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298904576 ++read 2048/2048 bytes at offset 4298904576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298908672 ++read 2048/2048 bytes at offset 4298908672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298912768 ++read 2048/2048 bytes at offset 4298912768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298916864 ++read 2048/2048 bytes at offset 4298916864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298920960 ++read 2048/2048 bytes at offset 4298920960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298925056 ++read 2048/2048 bytes at offset 4298925056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298929152 ++read 2048/2048 bytes at offset 4298929152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298933248 ++read 2048/2048 bytes at offset 4298933248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298937344 ++read 2048/2048 bytes at offset 4298937344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298941440 ++read 2048/2048 bytes at offset 4298941440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298945536 ++read 2048/2048 bytes at offset 4298945536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298949632 ++read 2048/2048 bytes at offset 4298949632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298953728 ++read 2048/2048 bytes at offset 4298953728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298957824 ++read 2048/2048 bytes at offset 4298957824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298961920 ++read 2048/2048 bytes at offset 4298961920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298966016 ++read 2048/2048 bytes at offset 4298966016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298970112 ++read 2048/2048 bytes at offset 4298970112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298974208 ++read 2048/2048 bytes at offset 4298974208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298978304 ++read 2048/2048 bytes at offset 4298978304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298982400 ++read 2048/2048 bytes at offset 4298982400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298986496 ++read 2048/2048 bytes at offset 4298986496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298990592 ++read 2048/2048 bytes at offset 4298990592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298994688 ++read 2048/2048 bytes at offset 4298994688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298998784 ++read 2048/2048 bytes at offset 4298998784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299002880 ++read 2048/2048 bytes at offset 4299002880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299006976 ++read 2048/2048 bytes at offset 4299006976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299011072 ++read 2048/2048 bytes at offset 4299011072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299015168 ++read 2048/2048 bytes at offset 4299015168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299019264 ++read 2048/2048 bytes at offset 4299019264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299023360 ++read 2048/2048 bytes at offset 4299023360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299027456 ++read 2048/2048 bytes at offset 4299027456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299031552 ++read 2048/2048 bytes at offset 4299031552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299035648 ++read 2048/2048 bytes at offset 4299035648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299039744 ++read 2048/2048 bytes at offset 4299039744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299043840 ++read 2048/2048 bytes at offset 4299043840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299047936 ++read 2048/2048 bytes at offset 4299047936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299052032 ++read 2048/2048 bytes at offset 4299052032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299056128 ++read 2048/2048 bytes at offset 4299056128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299060224 ++read 2048/2048 bytes at offset 4299060224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299064320 ++read 2048/2048 bytes at offset 4299064320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299068416 ++read 2048/2048 bytes at offset 4299068416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299072512 ++read 2048/2048 bytes at offset 4299072512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299076608 ++read 2048/2048 bytes at offset 4299076608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299080704 ++read 2048/2048 bytes at offset 4299080704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299084800 ++read 2048/2048 bytes at offset 4299084800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299088896 ++read 2048/2048 bytes at offset 4299088896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299092992 ++read 2048/2048 bytes at offset 4299092992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299097088 ++read 2048/2048 bytes at offset 4299097088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299101184 ++read 2048/2048 bytes at offset 4299101184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299105280 ++read 2048/2048 bytes at offset 4299105280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299109376 ++read 2048/2048 bytes at offset 4299109376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299113472 ++read 2048/2048 bytes at offset 4299113472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299117568 ++read 2048/2048 bytes at offset 4299117568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299121664 ++read 2048/2048 bytes at offset 4299121664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299125760 ++read 2048/2048 bytes at offset 4299125760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299129856 ++read 2048/2048 bytes at offset 4299129856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299133952 ++read 2048/2048 bytes at offset 4299133952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299138048 ++read 2048/2048 bytes at offset 4299138048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299142144 ++read 2048/2048 bytes at offset 4299142144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299146240 ++read 2048/2048 bytes at offset 4299146240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299150336 ++read 2048/2048 bytes at offset 4299150336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299154432 ++read 2048/2048 bytes at offset 4299154432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299158528 ++read 2048/2048 bytes at offset 4299158528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 4 +-qemu-io> read 8192/8192 bytes at offset 4299163648 ++=== IO: pattern 4 ++read 8192/8192 bytes at offset 4299163648 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299175936 ++read 8192/8192 bytes at offset 4299175936 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299188224 ++read 8192/8192 bytes at offset 4299188224 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299200512 ++read 8192/8192 bytes at offset 4299200512 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299212800 ++read 8192/8192 bytes at offset 4299212800 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299225088 ++read 8192/8192 bytes at offset 4299225088 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299237376 ++read 8192/8192 bytes at offset 4299237376 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299249664 ++read 8192/8192 bytes at offset 4299249664 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299261952 ++read 8192/8192 bytes at offset 4299261952 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299274240 ++read 8192/8192 bytes at offset 4299274240 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299286528 ++read 8192/8192 bytes at offset 4299286528 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299298816 ++read 8192/8192 bytes at offset 4299298816 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299311104 ++read 8192/8192 bytes at offset 4299311104 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299323392 ++read 8192/8192 bytes at offset 4299323392 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299335680 ++read 8192/8192 bytes at offset 4299335680 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299347968 ++read 8192/8192 bytes at offset 4299347968 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299360256 ++read 8192/8192 bytes at offset 4299360256 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299372544 ++read 8192/8192 bytes at offset 4299372544 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299384832 ++read 8192/8192 bytes at offset 4299384832 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299397120 ++read 8192/8192 bytes at offset 4299397120 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299409408 ++read 8192/8192 bytes at offset 4299409408 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299421696 ++read 8192/8192 bytes at offset 4299421696 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299433984 ++read 8192/8192 bytes at offset 4299433984 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299446272 ++read 8192/8192 bytes at offset 4299446272 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299458560 ++read 8192/8192 bytes at offset 4299458560 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299470848 ++read 8192/8192 bytes at offset 4299470848 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299483136 ++read 8192/8192 bytes at offset 4299483136 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299495424 ++read 8192/8192 bytes at offset 4299495424 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299507712 ++read 8192/8192 bytes at offset 4299507712 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299520000 ++read 8192/8192 bytes at offset 4299520000 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299532288 ++read 8192/8192 bytes at offset 4299532288 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299544576 ++read 8192/8192 bytes at offset 4299544576 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299556864 ++read 8192/8192 bytes at offset 4299556864 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299569152 ++read 8192/8192 bytes at offset 4299569152 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299581440 ++read 8192/8192 bytes at offset 4299581440 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299593728 ++read 8192/8192 bytes at offset 4299593728 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299606016 ++read 8192/8192 bytes at offset 4299606016 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299618304 ++read 8192/8192 bytes at offset 4299618304 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299630592 ++read 8192/8192 bytes at offset 4299630592 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299642880 ++read 8192/8192 bytes at offset 4299642880 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299655168 ++read 8192/8192 bytes at offset 4299655168 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299667456 ++read 8192/8192 bytes at offset 4299667456 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299679744 ++read 8192/8192 bytes at offset 4299679744 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299692032 ++read 8192/8192 bytes at offset 4299692032 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299704320 ++read 8192/8192 bytes at offset 4299704320 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299716608 ++read 8192/8192 bytes at offset 4299716608 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299728896 ++read 8192/8192 bytes at offset 4299728896 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299741184 ++read 8192/8192 bytes at offset 4299741184 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299753472 ++read 8192/8192 bytes at offset 4299753472 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299765760 ++read 8192/8192 bytes at offset 4299765760 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299778048 ++read 8192/8192 bytes at offset 4299778048 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299790336 ++read 8192/8192 bytes at offset 4299790336 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299802624 ++read 8192/8192 bytes at offset 4299802624 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299814912 ++read 8192/8192 bytes at offset 4299814912 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299827200 ++read 8192/8192 bytes at offset 4299827200 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299839488 ++read 8192/8192 bytes at offset 4299839488 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299851776 ++read 8192/8192 bytes at offset 4299851776 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299864064 ++read 8192/8192 bytes at offset 4299864064 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299876352 ++read 8192/8192 bytes at offset 4299876352 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299888640 ++read 8192/8192 bytes at offset 4299888640 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299900928 ++read 8192/8192 bytes at offset 4299900928 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299913216 ++read 8192/8192 bytes at offset 4299913216 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299925504 ++read 8192/8192 bytes at offset 4299925504 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299937792 ++read 8192/8192 bytes at offset 4299937792 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 244 +-qemu-io> read 12288/12288 bytes at offset 4301252608 ++=== IO: pattern 244 ++read 12288/12288 bytes at offset 4301252608 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4303351808 ++read 12288/12288 bytes at offset 4303351808 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4305451008 ++read 12288/12288 bytes at offset 4305451008 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4307550208 ++read 12288/12288 bytes at offset 4307550208 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4309649408 ++read 12288/12288 bytes at offset 4309649408 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4311748608 ++read 12288/12288 bytes at offset 4311748608 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4313847808 ++read 12288/12288 bytes at offset 4313847808 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4315947008 ++read 12288/12288 bytes at offset 4315947008 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> No errors were found on the image. ++No errors were found on the image. + With snapshot test2, offset 0 + === IO: pattern 0 +-qemu-io> wrote 4096/4096 bytes at offset 0 ++wrote 4096/4096 bytes at offset 0 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4096 ++wrote 4096/4096 bytes at offset 4096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8192 ++wrote 4096/4096 bytes at offset 8192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 12288 ++wrote 4096/4096 bytes at offset 12288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 16384 ++wrote 4096/4096 bytes at offset 16384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 20480 ++wrote 4096/4096 bytes at offset 20480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 24576 ++wrote 4096/4096 bytes at offset 24576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 28672 ++wrote 4096/4096 bytes at offset 28672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 32768 ++wrote 4096/4096 bytes at offset 32768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 36864 ++wrote 4096/4096 bytes at offset 36864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 40960 ++wrote 4096/4096 bytes at offset 40960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 45056 ++wrote 4096/4096 bytes at offset 45056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 49152 ++wrote 4096/4096 bytes at offset 49152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 53248 ++wrote 4096/4096 bytes at offset 53248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 57344 ++wrote 4096/4096 bytes at offset 57344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 61440 ++wrote 4096/4096 bytes at offset 61440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 65536 ++wrote 4096/4096 bytes at offset 65536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 69632 ++wrote 4096/4096 bytes at offset 69632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 73728 ++wrote 4096/4096 bytes at offset 73728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 77824 ++wrote 4096/4096 bytes at offset 77824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 81920 ++wrote 4096/4096 bytes at offset 81920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 86016 ++wrote 4096/4096 bytes at offset 86016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 90112 ++wrote 4096/4096 bytes at offset 90112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 94208 ++wrote 4096/4096 bytes at offset 94208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 98304 ++wrote 4096/4096 bytes at offset 98304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 102400 ++wrote 4096/4096 bytes at offset 102400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 106496 ++wrote 4096/4096 bytes at offset 106496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 110592 ++wrote 4096/4096 bytes at offset 110592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 114688 ++wrote 4096/4096 bytes at offset 114688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 118784 ++wrote 4096/4096 bytes at offset 118784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 122880 ++wrote 4096/4096 bytes at offset 122880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 126976 ++wrote 4096/4096 bytes at offset 126976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 131072 ++wrote 4096/4096 bytes at offset 131072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 135168 ++wrote 4096/4096 bytes at offset 135168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 139264 ++wrote 4096/4096 bytes at offset 139264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 143360 ++wrote 4096/4096 bytes at offset 143360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 147456 ++wrote 4096/4096 bytes at offset 147456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 151552 ++wrote 4096/4096 bytes at offset 151552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 155648 ++wrote 4096/4096 bytes at offset 155648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 159744 ++wrote 4096/4096 bytes at offset 159744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 163840 ++wrote 4096/4096 bytes at offset 163840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 167936 ++wrote 4096/4096 bytes at offset 167936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 172032 ++wrote 4096/4096 bytes at offset 172032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 176128 ++wrote 4096/4096 bytes at offset 176128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 180224 ++wrote 4096/4096 bytes at offset 180224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 184320 ++wrote 4096/4096 bytes at offset 184320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 188416 ++wrote 4096/4096 bytes at offset 188416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 192512 ++wrote 4096/4096 bytes at offset 192512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 196608 ++wrote 4096/4096 bytes at offset 196608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 200704 ++wrote 4096/4096 bytes at offset 200704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 204800 ++wrote 4096/4096 bytes at offset 204800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 208896 ++wrote 4096/4096 bytes at offset 208896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 212992 ++wrote 4096/4096 bytes at offset 212992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 217088 ++wrote 4096/4096 bytes at offset 217088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 221184 ++wrote 4096/4096 bytes at offset 221184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 225280 ++wrote 4096/4096 bytes at offset 225280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 229376 ++wrote 4096/4096 bytes at offset 229376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 233472 ++wrote 4096/4096 bytes at offset 233472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 237568 ++wrote 4096/4096 bytes at offset 237568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 241664 ++wrote 4096/4096 bytes at offset 241664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 245760 ++wrote 4096/4096 bytes at offset 245760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 249856 ++wrote 4096/4096 bytes at offset 249856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 253952 ++wrote 4096/4096 bytes at offset 253952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 258048 ++wrote 4096/4096 bytes at offset 258048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 262144 ++wrote 4096/4096 bytes at offset 262144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 266240 ++wrote 4096/4096 bytes at offset 266240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 270336 ++wrote 4096/4096 bytes at offset 270336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 274432 ++wrote 4096/4096 bytes at offset 274432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 278528 ++wrote 4096/4096 bytes at offset 278528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 282624 ++wrote 4096/4096 bytes at offset 282624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 286720 ++wrote 4096/4096 bytes at offset 286720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 290816 ++wrote 4096/4096 bytes at offset 290816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 294912 ++wrote 4096/4096 bytes at offset 294912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 299008 ++wrote 4096/4096 bytes at offset 299008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 303104 ++wrote 4096/4096 bytes at offset 303104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 307200 ++wrote 4096/4096 bytes at offset 307200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 311296 ++wrote 4096/4096 bytes at offset 311296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 315392 ++wrote 4096/4096 bytes at offset 315392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 319488 ++wrote 4096/4096 bytes at offset 319488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 323584 ++wrote 4096/4096 bytes at offset 323584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 327680 ++wrote 4096/4096 bytes at offset 327680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 331776 ++wrote 4096/4096 bytes at offset 331776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 335872 ++wrote 4096/4096 bytes at offset 335872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 339968 ++wrote 4096/4096 bytes at offset 339968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 344064 ++wrote 4096/4096 bytes at offset 344064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 348160 ++wrote 4096/4096 bytes at offset 348160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 352256 ++wrote 4096/4096 bytes at offset 352256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 356352 ++wrote 4096/4096 bytes at offset 356352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 360448 ++wrote 4096/4096 bytes at offset 360448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 364544 ++wrote 4096/4096 bytes at offset 364544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 368640 ++wrote 4096/4096 bytes at offset 368640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 372736 ++wrote 4096/4096 bytes at offset 372736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 376832 ++wrote 4096/4096 bytes at offset 376832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 380928 ++wrote 4096/4096 bytes at offset 380928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 385024 ++wrote 4096/4096 bytes at offset 385024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 389120 ++wrote 4096/4096 bytes at offset 389120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 393216 ++wrote 4096/4096 bytes at offset 393216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 397312 ++wrote 4096/4096 bytes at offset 397312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 401408 ++wrote 4096/4096 bytes at offset 401408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 405504 ++wrote 4096/4096 bytes at offset 405504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 409600 ++wrote 4096/4096 bytes at offset 409600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 413696 ++wrote 4096/4096 bytes at offset 413696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 417792 ++wrote 4096/4096 bytes at offset 417792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 421888 ++wrote 4096/4096 bytes at offset 421888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 425984 ++wrote 4096/4096 bytes at offset 425984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 430080 ++wrote 4096/4096 bytes at offset 430080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 434176 ++wrote 4096/4096 bytes at offset 434176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 438272 ++wrote 4096/4096 bytes at offset 438272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 442368 ++wrote 4096/4096 bytes at offset 442368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 446464 ++wrote 4096/4096 bytes at offset 446464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 450560 ++wrote 4096/4096 bytes at offset 450560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 454656 ++wrote 4096/4096 bytes at offset 454656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 458752 ++wrote 4096/4096 bytes at offset 458752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 462848 ++wrote 4096/4096 bytes at offset 462848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 466944 ++wrote 4096/4096 bytes at offset 466944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 471040 ++wrote 4096/4096 bytes at offset 471040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 475136 ++wrote 4096/4096 bytes at offset 475136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 479232 ++wrote 4096/4096 bytes at offset 479232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 483328 ++wrote 4096/4096 bytes at offset 483328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 487424 ++wrote 4096/4096 bytes at offset 487424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 491520 ++wrote 4096/4096 bytes at offset 491520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 495616 ++wrote 4096/4096 bytes at offset 495616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 499712 ++wrote 4096/4096 bytes at offset 499712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 503808 ++wrote 4096/4096 bytes at offset 503808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 507904 ++wrote 4096/4096 bytes at offset 507904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 512000 ++wrote 4096/4096 bytes at offset 512000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 516096 ++wrote 4096/4096 bytes at offset 516096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 520192 ++wrote 4096/4096 bytes at offset 520192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 524288 ++wrote 4096/4096 bytes at offset 524288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 528384 ++wrote 4096/4096 bytes at offset 528384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 532480 ++wrote 4096/4096 bytes at offset 532480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 536576 ++wrote 4096/4096 bytes at offset 536576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 540672 ++wrote 4096/4096 bytes at offset 540672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 544768 ++wrote 4096/4096 bytes at offset 544768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 548864 ++wrote 4096/4096 bytes at offset 548864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 552960 ++wrote 4096/4096 bytes at offset 552960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 557056 ++wrote 4096/4096 bytes at offset 557056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 561152 ++wrote 4096/4096 bytes at offset 561152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 565248 ++wrote 4096/4096 bytes at offset 565248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 569344 ++wrote 4096/4096 bytes at offset 569344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 573440 ++wrote 4096/4096 bytes at offset 573440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 577536 ++wrote 4096/4096 bytes at offset 577536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 581632 ++wrote 4096/4096 bytes at offset 581632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 585728 ++wrote 4096/4096 bytes at offset 585728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 589824 ++wrote 4096/4096 bytes at offset 589824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 593920 ++wrote 4096/4096 bytes at offset 593920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 598016 ++wrote 4096/4096 bytes at offset 598016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 602112 ++wrote 4096/4096 bytes at offset 602112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 606208 ++wrote 4096/4096 bytes at offset 606208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 610304 ++wrote 4096/4096 bytes at offset 610304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 614400 ++wrote 4096/4096 bytes at offset 614400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 618496 ++wrote 4096/4096 bytes at offset 618496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 622592 ++wrote 4096/4096 bytes at offset 622592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 626688 ++wrote 4096/4096 bytes at offset 626688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 630784 ++wrote 4096/4096 bytes at offset 630784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 634880 ++wrote 4096/4096 bytes at offset 634880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 638976 ++wrote 4096/4096 bytes at offset 638976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 643072 ++wrote 4096/4096 bytes at offset 643072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 647168 ++wrote 4096/4096 bytes at offset 647168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 651264 ++wrote 4096/4096 bytes at offset 651264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 655360 ++wrote 4096/4096 bytes at offset 655360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 659456 ++wrote 4096/4096 bytes at offset 659456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 663552 ++wrote 4096/4096 bytes at offset 663552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 667648 ++wrote 4096/4096 bytes at offset 667648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 671744 ++wrote 4096/4096 bytes at offset 671744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 675840 ++wrote 4096/4096 bytes at offset 675840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 679936 ++wrote 4096/4096 bytes at offset 679936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 684032 ++wrote 4096/4096 bytes at offset 684032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 688128 ++wrote 4096/4096 bytes at offset 688128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 692224 ++wrote 4096/4096 bytes at offset 692224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 696320 ++wrote 4096/4096 bytes at offset 696320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 700416 ++wrote 4096/4096 bytes at offset 700416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 704512 ++wrote 4096/4096 bytes at offset 704512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 708608 ++wrote 4096/4096 bytes at offset 708608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 712704 ++wrote 4096/4096 bytes at offset 712704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 716800 ++wrote 4096/4096 bytes at offset 716800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 720896 ++wrote 4096/4096 bytes at offset 720896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 724992 ++wrote 4096/4096 bytes at offset 724992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 729088 ++wrote 4096/4096 bytes at offset 729088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 733184 ++wrote 4096/4096 bytes at offset 733184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 737280 ++wrote 4096/4096 bytes at offset 737280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 741376 ++wrote 4096/4096 bytes at offset 741376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 745472 ++wrote 4096/4096 bytes at offset 745472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 749568 ++wrote 4096/4096 bytes at offset 749568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 753664 ++wrote 4096/4096 bytes at offset 753664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 757760 ++wrote 4096/4096 bytes at offset 757760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 761856 ++wrote 4096/4096 bytes at offset 761856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 765952 ++wrote 4096/4096 bytes at offset 765952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 770048 ++wrote 4096/4096 bytes at offset 770048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 774144 ++wrote 4096/4096 bytes at offset 774144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 778240 ++wrote 4096/4096 bytes at offset 778240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 782336 ++wrote 4096/4096 bytes at offset 782336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 786432 ++wrote 4096/4096 bytes at offset 786432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 790528 ++wrote 4096/4096 bytes at offset 790528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 794624 ++wrote 4096/4096 bytes at offset 794624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 798720 ++wrote 4096/4096 bytes at offset 798720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 802816 ++wrote 4096/4096 bytes at offset 802816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 806912 ++wrote 4096/4096 bytes at offset 806912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 811008 ++wrote 4096/4096 bytes at offset 811008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 815104 ++wrote 4096/4096 bytes at offset 815104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 819200 ++wrote 4096/4096 bytes at offset 819200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 823296 ++wrote 4096/4096 bytes at offset 823296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 827392 ++wrote 4096/4096 bytes at offset 827392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 831488 ++wrote 4096/4096 bytes at offset 831488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 835584 ++wrote 4096/4096 bytes at offset 835584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 839680 ++wrote 4096/4096 bytes at offset 839680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 843776 ++wrote 4096/4096 bytes at offset 843776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 847872 ++wrote 4096/4096 bytes at offset 847872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 851968 ++wrote 4096/4096 bytes at offset 851968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 856064 ++wrote 4096/4096 bytes at offset 856064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 860160 ++wrote 4096/4096 bytes at offset 860160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 864256 ++wrote 4096/4096 bytes at offset 864256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 868352 ++wrote 4096/4096 bytes at offset 868352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 872448 ++wrote 4096/4096 bytes at offset 872448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 876544 ++wrote 4096/4096 bytes at offset 876544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 880640 ++wrote 4096/4096 bytes at offset 880640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 884736 ++wrote 4096/4096 bytes at offset 884736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 888832 ++wrote 4096/4096 bytes at offset 888832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 892928 ++wrote 4096/4096 bytes at offset 892928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 897024 ++wrote 4096/4096 bytes at offset 897024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 901120 ++wrote 4096/4096 bytes at offset 901120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 905216 ++wrote 4096/4096 bytes at offset 905216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 909312 ++wrote 4096/4096 bytes at offset 909312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 913408 ++wrote 4096/4096 bytes at offset 913408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 917504 ++wrote 4096/4096 bytes at offset 917504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 921600 ++wrote 4096/4096 bytes at offset 921600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 925696 ++wrote 4096/4096 bytes at offset 925696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 929792 ++wrote 4096/4096 bytes at offset 929792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 933888 ++wrote 4096/4096 bytes at offset 933888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 937984 ++wrote 4096/4096 bytes at offset 937984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 942080 ++wrote 4096/4096 bytes at offset 942080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 946176 ++wrote 4096/4096 bytes at offset 946176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 950272 ++wrote 4096/4096 bytes at offset 950272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 954368 ++wrote 4096/4096 bytes at offset 954368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 958464 ++wrote 4096/4096 bytes at offset 958464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 962560 ++wrote 4096/4096 bytes at offset 962560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 966656 ++wrote 4096/4096 bytes at offset 966656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 970752 ++wrote 4096/4096 bytes at offset 970752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 974848 ++wrote 4096/4096 bytes at offset 974848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 978944 ++wrote 4096/4096 bytes at offset 978944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 983040 ++wrote 4096/4096 bytes at offset 983040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 987136 ++wrote 4096/4096 bytes at offset 987136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 991232 ++wrote 4096/4096 bytes at offset 991232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 995328 ++wrote 4096/4096 bytes at offset 995328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 999424 ++wrote 4096/4096 bytes at offset 999424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1003520 ++wrote 4096/4096 bytes at offset 1003520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1007616 ++wrote 4096/4096 bytes at offset 1007616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1011712 ++wrote 4096/4096 bytes at offset 1011712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1015808 ++wrote 4096/4096 bytes at offset 1015808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1019904 ++wrote 4096/4096 bytes at offset 1019904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1024000 ++wrote 4096/4096 bytes at offset 1024000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1028096 ++wrote 4096/4096 bytes at offset 1028096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1032192 ++wrote 4096/4096 bytes at offset 1032192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1036288 ++wrote 4096/4096 bytes at offset 1036288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1040384 ++wrote 4096/4096 bytes at offset 1040384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1044480 ++wrote 4096/4096 bytes at offset 1044480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 4 +-qemu-io> wrote 2048/2048 bytes at offset 1050624 ++=== IO: pattern 4 ++wrote 2048/2048 bytes at offset 1050624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1054720 ++wrote 2048/2048 bytes at offset 1054720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1058816 ++wrote 2048/2048 bytes at offset 1058816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1062912 ++wrote 2048/2048 bytes at offset 1062912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1067008 ++wrote 2048/2048 bytes at offset 1067008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1071104 ++wrote 2048/2048 bytes at offset 1071104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1075200 ++wrote 2048/2048 bytes at offset 1075200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1079296 ++wrote 2048/2048 bytes at offset 1079296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1083392 ++wrote 2048/2048 bytes at offset 1083392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1087488 ++wrote 2048/2048 bytes at offset 1087488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1091584 ++wrote 2048/2048 bytes at offset 1091584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1095680 ++wrote 2048/2048 bytes at offset 1095680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1099776 ++wrote 2048/2048 bytes at offset 1099776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1103872 ++wrote 2048/2048 bytes at offset 1103872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1107968 ++wrote 2048/2048 bytes at offset 1107968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1112064 ++wrote 2048/2048 bytes at offset 1112064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1116160 ++wrote 2048/2048 bytes at offset 1116160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1120256 ++wrote 2048/2048 bytes at offset 1120256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1124352 ++wrote 2048/2048 bytes at offset 1124352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1128448 ++wrote 2048/2048 bytes at offset 1128448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1132544 ++wrote 2048/2048 bytes at offset 1132544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1136640 ++wrote 2048/2048 bytes at offset 1136640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1140736 ++wrote 2048/2048 bytes at offset 1140736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1144832 ++wrote 2048/2048 bytes at offset 1144832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1148928 ++wrote 2048/2048 bytes at offset 1148928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1153024 ++wrote 2048/2048 bytes at offset 1153024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1157120 ++wrote 2048/2048 bytes at offset 1157120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1161216 ++wrote 2048/2048 bytes at offset 1161216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1165312 ++wrote 2048/2048 bytes at offset 1165312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1169408 ++wrote 2048/2048 bytes at offset 1169408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1173504 ++wrote 2048/2048 bytes at offset 1173504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1177600 ++wrote 2048/2048 bytes at offset 1177600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1181696 ++wrote 2048/2048 bytes at offset 1181696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1185792 ++wrote 2048/2048 bytes at offset 1185792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1189888 ++wrote 2048/2048 bytes at offset 1189888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1193984 ++wrote 2048/2048 bytes at offset 1193984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1198080 ++wrote 2048/2048 bytes at offset 1198080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1202176 ++wrote 2048/2048 bytes at offset 1202176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1206272 ++wrote 2048/2048 bytes at offset 1206272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1210368 ++wrote 2048/2048 bytes at offset 1210368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1214464 ++wrote 2048/2048 bytes at offset 1214464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1218560 ++wrote 2048/2048 bytes at offset 1218560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1222656 ++wrote 2048/2048 bytes at offset 1222656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1226752 ++wrote 2048/2048 bytes at offset 1226752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1230848 ++wrote 2048/2048 bytes at offset 1230848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1234944 ++wrote 2048/2048 bytes at offset 1234944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1239040 ++wrote 2048/2048 bytes at offset 1239040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1243136 ++wrote 2048/2048 bytes at offset 1243136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1247232 ++wrote 2048/2048 bytes at offset 1247232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1251328 ++wrote 2048/2048 bytes at offset 1251328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1255424 ++wrote 2048/2048 bytes at offset 1255424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1259520 ++wrote 2048/2048 bytes at offset 1259520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1263616 ++wrote 2048/2048 bytes at offset 1263616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1267712 ++wrote 2048/2048 bytes at offset 1267712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1271808 ++wrote 2048/2048 bytes at offset 1271808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1275904 ++wrote 2048/2048 bytes at offset 1275904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1280000 ++wrote 2048/2048 bytes at offset 1280000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1284096 ++wrote 2048/2048 bytes at offset 1284096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1288192 ++wrote 2048/2048 bytes at offset 1288192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1292288 ++wrote 2048/2048 bytes at offset 1292288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1296384 ++wrote 2048/2048 bytes at offset 1296384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1300480 ++wrote 2048/2048 bytes at offset 1300480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1304576 ++wrote 2048/2048 bytes at offset 1304576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1308672 ++wrote 2048/2048 bytes at offset 1308672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1312768 ++wrote 2048/2048 bytes at offset 1312768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1316864 ++wrote 2048/2048 bytes at offset 1316864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1320960 ++wrote 2048/2048 bytes at offset 1320960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1325056 ++wrote 2048/2048 bytes at offset 1325056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1329152 ++wrote 2048/2048 bytes at offset 1329152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1333248 ++wrote 2048/2048 bytes at offset 1333248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1337344 ++wrote 2048/2048 bytes at offset 1337344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1341440 ++wrote 2048/2048 bytes at offset 1341440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1345536 ++wrote 2048/2048 bytes at offset 1345536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1349632 ++wrote 2048/2048 bytes at offset 1349632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1353728 ++wrote 2048/2048 bytes at offset 1353728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1357824 ++wrote 2048/2048 bytes at offset 1357824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1361920 ++wrote 2048/2048 bytes at offset 1361920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1366016 ++wrote 2048/2048 bytes at offset 1366016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1370112 ++wrote 2048/2048 bytes at offset 1370112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1374208 ++wrote 2048/2048 bytes at offset 1374208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1378304 ++wrote 2048/2048 bytes at offset 1378304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1382400 ++wrote 2048/2048 bytes at offset 1382400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1386496 ++wrote 2048/2048 bytes at offset 1386496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1390592 ++wrote 2048/2048 bytes at offset 1390592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1394688 ++wrote 2048/2048 bytes at offset 1394688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1398784 ++wrote 2048/2048 bytes at offset 1398784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1402880 ++wrote 2048/2048 bytes at offset 1402880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1406976 ++wrote 2048/2048 bytes at offset 1406976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1411072 ++wrote 2048/2048 bytes at offset 1411072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1415168 ++wrote 2048/2048 bytes at offset 1415168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1419264 ++wrote 2048/2048 bytes at offset 1419264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1423360 ++wrote 2048/2048 bytes at offset 1423360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1427456 ++wrote 2048/2048 bytes at offset 1427456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1431552 ++wrote 2048/2048 bytes at offset 1431552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1435648 ++wrote 2048/2048 bytes at offset 1435648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1439744 ++wrote 2048/2048 bytes at offset 1439744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1443840 ++wrote 2048/2048 bytes at offset 1443840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1447936 ++wrote 2048/2048 bytes at offset 1447936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1452032 ++wrote 2048/2048 bytes at offset 1452032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1456128 ++wrote 2048/2048 bytes at offset 1456128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1460224 ++wrote 2048/2048 bytes at offset 1460224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1464320 ++wrote 2048/2048 bytes at offset 1464320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1468416 ++wrote 2048/2048 bytes at offset 1468416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1472512 ++wrote 2048/2048 bytes at offset 1472512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1476608 ++wrote 2048/2048 bytes at offset 1476608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1480704 ++wrote 2048/2048 bytes at offset 1480704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1484800 ++wrote 2048/2048 bytes at offset 1484800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1488896 ++wrote 2048/2048 bytes at offset 1488896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1492992 ++wrote 2048/2048 bytes at offset 1492992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1497088 ++wrote 2048/2048 bytes at offset 1497088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1501184 ++wrote 2048/2048 bytes at offset 1501184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1505280 ++wrote 2048/2048 bytes at offset 1505280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1509376 ++wrote 2048/2048 bytes at offset 1509376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1513472 ++wrote 2048/2048 bytes at offset 1513472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1517568 ++wrote 2048/2048 bytes at offset 1517568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1521664 ++wrote 2048/2048 bytes at offset 1521664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1525760 ++wrote 2048/2048 bytes at offset 1525760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1529856 ++wrote 2048/2048 bytes at offset 1529856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1533952 ++wrote 2048/2048 bytes at offset 1533952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1538048 ++wrote 2048/2048 bytes at offset 1538048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1542144 ++wrote 2048/2048 bytes at offset 1542144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1546240 ++wrote 2048/2048 bytes at offset 1546240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1550336 ++wrote 2048/2048 bytes at offset 1550336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1554432 ++wrote 2048/2048 bytes at offset 1554432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1558528 ++wrote 2048/2048 bytes at offset 1558528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1562624 ++wrote 2048/2048 bytes at offset 1562624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1566720 ++wrote 2048/2048 bytes at offset 1566720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1570816 ++wrote 2048/2048 bytes at offset 1570816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1574912 ++wrote 2048/2048 bytes at offset 1574912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1579008 ++wrote 2048/2048 bytes at offset 1579008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1583104 ++wrote 2048/2048 bytes at offset 1583104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1587200 ++wrote 2048/2048 bytes at offset 1587200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1591296 ++wrote 2048/2048 bytes at offset 1591296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1595392 ++wrote 2048/2048 bytes at offset 1595392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1599488 ++wrote 2048/2048 bytes at offset 1599488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1603584 ++wrote 2048/2048 bytes at offset 1603584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1607680 ++wrote 2048/2048 bytes at offset 1607680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1611776 ++wrote 2048/2048 bytes at offset 1611776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1615872 ++wrote 2048/2048 bytes at offset 1615872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1619968 ++wrote 2048/2048 bytes at offset 1619968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1624064 ++wrote 2048/2048 bytes at offset 1624064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1628160 ++wrote 2048/2048 bytes at offset 1628160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1632256 ++wrote 2048/2048 bytes at offset 1632256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1636352 ++wrote 2048/2048 bytes at offset 1636352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1640448 ++wrote 2048/2048 bytes at offset 1640448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1644544 ++wrote 2048/2048 bytes at offset 1644544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1648640 ++wrote 2048/2048 bytes at offset 1648640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1652736 ++wrote 2048/2048 bytes at offset 1652736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1656832 ++wrote 2048/2048 bytes at offset 1656832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1660928 ++wrote 2048/2048 bytes at offset 1660928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1665024 ++wrote 2048/2048 bytes at offset 1665024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1669120 ++wrote 2048/2048 bytes at offset 1669120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1673216 ++wrote 2048/2048 bytes at offset 1673216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1677312 ++wrote 2048/2048 bytes at offset 1677312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1681408 ++wrote 2048/2048 bytes at offset 1681408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1685504 ++wrote 2048/2048 bytes at offset 1685504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1689600 ++wrote 2048/2048 bytes at offset 1689600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1693696 ++wrote 2048/2048 bytes at offset 1693696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1697792 ++wrote 2048/2048 bytes at offset 1697792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1701888 ++wrote 2048/2048 bytes at offset 1701888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1705984 ++wrote 2048/2048 bytes at offset 1705984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1710080 ++wrote 2048/2048 bytes at offset 1710080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1714176 ++wrote 2048/2048 bytes at offset 1714176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1718272 ++wrote 2048/2048 bytes at offset 1718272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1722368 ++wrote 2048/2048 bytes at offset 1722368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1726464 ++wrote 2048/2048 bytes at offset 1726464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1730560 ++wrote 2048/2048 bytes at offset 1730560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1734656 ++wrote 2048/2048 bytes at offset 1734656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1738752 ++wrote 2048/2048 bytes at offset 1738752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1742848 ++wrote 2048/2048 bytes at offset 1742848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1746944 ++wrote 2048/2048 bytes at offset 1746944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1751040 ++wrote 2048/2048 bytes at offset 1751040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1755136 ++wrote 2048/2048 bytes at offset 1755136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1759232 ++wrote 2048/2048 bytes at offset 1759232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1763328 ++wrote 2048/2048 bytes at offset 1763328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1767424 ++wrote 2048/2048 bytes at offset 1767424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1771520 ++wrote 2048/2048 bytes at offset 1771520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1775616 ++wrote 2048/2048 bytes at offset 1775616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1779712 ++wrote 2048/2048 bytes at offset 1779712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1783808 ++wrote 2048/2048 bytes at offset 1783808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1787904 ++wrote 2048/2048 bytes at offset 1787904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1792000 ++wrote 2048/2048 bytes at offset 1792000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1796096 ++wrote 2048/2048 bytes at offset 1796096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1800192 ++wrote 2048/2048 bytes at offset 1800192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1804288 ++wrote 2048/2048 bytes at offset 1804288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1808384 ++wrote 2048/2048 bytes at offset 1808384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1812480 ++wrote 2048/2048 bytes at offset 1812480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1816576 ++wrote 2048/2048 bytes at offset 1816576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1820672 ++wrote 2048/2048 bytes at offset 1820672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1824768 ++wrote 2048/2048 bytes at offset 1824768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1828864 ++wrote 2048/2048 bytes at offset 1828864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1832960 ++wrote 2048/2048 bytes at offset 1832960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1837056 ++wrote 2048/2048 bytes at offset 1837056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1841152 ++wrote 2048/2048 bytes at offset 1841152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1845248 ++wrote 2048/2048 bytes at offset 1845248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1849344 ++wrote 2048/2048 bytes at offset 1849344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1853440 ++wrote 2048/2048 bytes at offset 1853440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1857536 ++wrote 2048/2048 bytes at offset 1857536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1861632 ++wrote 2048/2048 bytes at offset 1861632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1865728 ++wrote 2048/2048 bytes at offset 1865728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1869824 ++wrote 2048/2048 bytes at offset 1869824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1873920 ++wrote 2048/2048 bytes at offset 1873920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1878016 ++wrote 2048/2048 bytes at offset 1878016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1882112 ++wrote 2048/2048 bytes at offset 1882112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1886208 ++wrote 2048/2048 bytes at offset 1886208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1890304 ++wrote 2048/2048 bytes at offset 1890304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1894400 ++wrote 2048/2048 bytes at offset 1894400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1898496 ++wrote 2048/2048 bytes at offset 1898496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1902592 ++wrote 2048/2048 bytes at offset 1902592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1906688 ++wrote 2048/2048 bytes at offset 1906688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1910784 ++wrote 2048/2048 bytes at offset 1910784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1914880 ++wrote 2048/2048 bytes at offset 1914880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1918976 ++wrote 2048/2048 bytes at offset 1918976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1923072 ++wrote 2048/2048 bytes at offset 1923072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1927168 ++wrote 2048/2048 bytes at offset 1927168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1931264 ++wrote 2048/2048 bytes at offset 1931264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1935360 ++wrote 2048/2048 bytes at offset 1935360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1939456 ++wrote 2048/2048 bytes at offset 1939456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1943552 ++wrote 2048/2048 bytes at offset 1943552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1947648 ++wrote 2048/2048 bytes at offset 1947648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1951744 ++wrote 2048/2048 bytes at offset 1951744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1955840 ++wrote 2048/2048 bytes at offset 1955840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1959936 ++wrote 2048/2048 bytes at offset 1959936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1964032 ++wrote 2048/2048 bytes at offset 1964032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1968128 ++wrote 2048/2048 bytes at offset 1968128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1972224 ++wrote 2048/2048 bytes at offset 1972224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1976320 ++wrote 2048/2048 bytes at offset 1976320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1980416 ++wrote 2048/2048 bytes at offset 1980416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1984512 ++wrote 2048/2048 bytes at offset 1984512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1988608 ++wrote 2048/2048 bytes at offset 1988608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1992704 ++wrote 2048/2048 bytes at offset 1992704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1996800 ++wrote 2048/2048 bytes at offset 1996800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2000896 ++wrote 2048/2048 bytes at offset 2000896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2004992 ++wrote 2048/2048 bytes at offset 2004992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2009088 ++wrote 2048/2048 bytes at offset 2009088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2013184 ++wrote 2048/2048 bytes at offset 2013184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2017280 ++wrote 2048/2048 bytes at offset 2017280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2021376 ++wrote 2048/2048 bytes at offset 2021376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2025472 ++wrote 2048/2048 bytes at offset 2025472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2029568 ++wrote 2048/2048 bytes at offset 2029568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2033664 ++wrote 2048/2048 bytes at offset 2033664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2037760 ++wrote 2048/2048 bytes at offset 2037760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2041856 ++wrote 2048/2048 bytes at offset 2041856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2045952 ++wrote 2048/2048 bytes at offset 2045952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2050048 ++wrote 2048/2048 bytes at offset 2050048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2054144 ++wrote 2048/2048 bytes at offset 2054144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2058240 ++wrote 2048/2048 bytes at offset 2058240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2062336 ++wrote 2048/2048 bytes at offset 2062336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2066432 ++wrote 2048/2048 bytes at offset 2066432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2070528 ++wrote 2048/2048 bytes at offset 2070528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2074624 ++wrote 2048/2048 bytes at offset 2074624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2078720 ++wrote 2048/2048 bytes at offset 2078720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2082816 ++wrote 2048/2048 bytes at offset 2082816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2086912 ++wrote 2048/2048 bytes at offset 2086912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2091008 ++wrote 2048/2048 bytes at offset 2091008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2095104 ++wrote 2048/2048 bytes at offset 2095104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> wrote 2048/2048 bytes at offset 2097152 ++=== IO: pattern 0 ++wrote 2048/2048 bytes at offset 2097152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2101248 ++wrote 2048/2048 bytes at offset 2101248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2105344 ++wrote 2048/2048 bytes at offset 2105344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2109440 ++wrote 2048/2048 bytes at offset 2109440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2113536 ++wrote 2048/2048 bytes at offset 2113536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2117632 ++wrote 2048/2048 bytes at offset 2117632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2121728 ++wrote 2048/2048 bytes at offset 2121728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2125824 ++wrote 2048/2048 bytes at offset 2125824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2129920 ++wrote 2048/2048 bytes at offset 2129920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2134016 ++wrote 2048/2048 bytes at offset 2134016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2138112 ++wrote 2048/2048 bytes at offset 2138112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2142208 ++wrote 2048/2048 bytes at offset 2142208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2146304 ++wrote 2048/2048 bytes at offset 2146304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2150400 ++wrote 2048/2048 bytes at offset 2150400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2154496 ++wrote 2048/2048 bytes at offset 2154496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2158592 ++wrote 2048/2048 bytes at offset 2158592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2162688 ++wrote 2048/2048 bytes at offset 2162688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2166784 ++wrote 2048/2048 bytes at offset 2166784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2170880 ++wrote 2048/2048 bytes at offset 2170880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2174976 ++wrote 2048/2048 bytes at offset 2174976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2179072 ++wrote 2048/2048 bytes at offset 2179072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2183168 ++wrote 2048/2048 bytes at offset 2183168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2187264 ++wrote 2048/2048 bytes at offset 2187264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2191360 ++wrote 2048/2048 bytes at offset 2191360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2195456 ++wrote 2048/2048 bytes at offset 2195456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2199552 ++wrote 2048/2048 bytes at offset 2199552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2203648 ++wrote 2048/2048 bytes at offset 2203648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2207744 ++wrote 2048/2048 bytes at offset 2207744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2211840 ++wrote 2048/2048 bytes at offset 2211840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2215936 ++wrote 2048/2048 bytes at offset 2215936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2220032 ++wrote 2048/2048 bytes at offset 2220032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2224128 ++wrote 2048/2048 bytes at offset 2224128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2228224 ++wrote 2048/2048 bytes at offset 2228224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2232320 ++wrote 2048/2048 bytes at offset 2232320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2236416 ++wrote 2048/2048 bytes at offset 2236416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2240512 ++wrote 2048/2048 bytes at offset 2240512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2244608 ++wrote 2048/2048 bytes at offset 2244608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2248704 ++wrote 2048/2048 bytes at offset 2248704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2252800 ++wrote 2048/2048 bytes at offset 2252800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2256896 ++wrote 2048/2048 bytes at offset 2256896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2260992 ++wrote 2048/2048 bytes at offset 2260992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2265088 ++wrote 2048/2048 bytes at offset 2265088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2269184 ++wrote 2048/2048 bytes at offset 2269184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2273280 ++wrote 2048/2048 bytes at offset 2273280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2277376 ++wrote 2048/2048 bytes at offset 2277376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2281472 ++wrote 2048/2048 bytes at offset 2281472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2285568 ++wrote 2048/2048 bytes at offset 2285568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2289664 ++wrote 2048/2048 bytes at offset 2289664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2293760 ++wrote 2048/2048 bytes at offset 2293760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2297856 ++wrote 2048/2048 bytes at offset 2297856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2301952 ++wrote 2048/2048 bytes at offset 2301952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2306048 ++wrote 2048/2048 bytes at offset 2306048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2310144 ++wrote 2048/2048 bytes at offset 2310144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2314240 ++wrote 2048/2048 bytes at offset 2314240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2318336 ++wrote 2048/2048 bytes at offset 2318336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2322432 ++wrote 2048/2048 bytes at offset 2322432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2326528 ++wrote 2048/2048 bytes at offset 2326528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2330624 ++wrote 2048/2048 bytes at offset 2330624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2334720 ++wrote 2048/2048 bytes at offset 2334720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2338816 ++wrote 2048/2048 bytes at offset 2338816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2342912 ++wrote 2048/2048 bytes at offset 2342912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2347008 ++wrote 2048/2048 bytes at offset 2347008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2351104 ++wrote 2048/2048 bytes at offset 2351104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2355200 ++wrote 2048/2048 bytes at offset 2355200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2359296 ++wrote 2048/2048 bytes at offset 2359296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2363392 ++wrote 2048/2048 bytes at offset 2363392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2367488 ++wrote 2048/2048 bytes at offset 2367488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2371584 ++wrote 2048/2048 bytes at offset 2371584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2375680 ++wrote 2048/2048 bytes at offset 2375680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2379776 ++wrote 2048/2048 bytes at offset 2379776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2383872 ++wrote 2048/2048 bytes at offset 2383872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2387968 ++wrote 2048/2048 bytes at offset 2387968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2392064 ++wrote 2048/2048 bytes at offset 2392064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2396160 ++wrote 2048/2048 bytes at offset 2396160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2400256 ++wrote 2048/2048 bytes at offset 2400256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2404352 ++wrote 2048/2048 bytes at offset 2404352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2408448 ++wrote 2048/2048 bytes at offset 2408448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2412544 ++wrote 2048/2048 bytes at offset 2412544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2416640 ++wrote 2048/2048 bytes at offset 2416640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2420736 ++wrote 2048/2048 bytes at offset 2420736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2424832 ++wrote 2048/2048 bytes at offset 2424832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2428928 ++wrote 2048/2048 bytes at offset 2428928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2433024 ++wrote 2048/2048 bytes at offset 2433024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2437120 ++wrote 2048/2048 bytes at offset 2437120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2441216 ++wrote 2048/2048 bytes at offset 2441216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2445312 ++wrote 2048/2048 bytes at offset 2445312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2449408 ++wrote 2048/2048 bytes at offset 2449408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2453504 ++wrote 2048/2048 bytes at offset 2453504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2457600 ++wrote 2048/2048 bytes at offset 2457600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2461696 ++wrote 2048/2048 bytes at offset 2461696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2465792 ++wrote 2048/2048 bytes at offset 2465792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2469888 ++wrote 2048/2048 bytes at offset 2469888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2473984 ++wrote 2048/2048 bytes at offset 2473984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2478080 ++wrote 2048/2048 bytes at offset 2478080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2482176 ++wrote 2048/2048 bytes at offset 2482176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2486272 ++wrote 2048/2048 bytes at offset 2486272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2490368 ++wrote 2048/2048 bytes at offset 2490368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2494464 ++wrote 2048/2048 bytes at offset 2494464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2498560 ++wrote 2048/2048 bytes at offset 2498560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2502656 ++wrote 2048/2048 bytes at offset 2502656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2506752 ++wrote 2048/2048 bytes at offset 2506752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2510848 ++wrote 2048/2048 bytes at offset 2510848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2514944 ++wrote 2048/2048 bytes at offset 2514944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2519040 ++wrote 2048/2048 bytes at offset 2519040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2523136 ++wrote 2048/2048 bytes at offset 2523136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2527232 ++wrote 2048/2048 bytes at offset 2527232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2531328 ++wrote 2048/2048 bytes at offset 2531328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2535424 ++wrote 2048/2048 bytes at offset 2535424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2539520 ++wrote 2048/2048 bytes at offset 2539520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2543616 ++wrote 2048/2048 bytes at offset 2543616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2547712 ++wrote 2048/2048 bytes at offset 2547712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2551808 ++wrote 2048/2048 bytes at offset 2551808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2555904 ++wrote 2048/2048 bytes at offset 2555904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2560000 ++wrote 2048/2048 bytes at offset 2560000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2564096 ++wrote 2048/2048 bytes at offset 2564096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2568192 ++wrote 2048/2048 bytes at offset 2568192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2572288 ++wrote 2048/2048 bytes at offset 2572288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2576384 ++wrote 2048/2048 bytes at offset 2576384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2580480 ++wrote 2048/2048 bytes at offset 2580480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2584576 ++wrote 2048/2048 bytes at offset 2584576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2588672 ++wrote 2048/2048 bytes at offset 2588672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2592768 ++wrote 2048/2048 bytes at offset 2592768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2596864 ++wrote 2048/2048 bytes at offset 2596864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2600960 ++wrote 2048/2048 bytes at offset 2600960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2605056 ++wrote 2048/2048 bytes at offset 2605056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2609152 ++wrote 2048/2048 bytes at offset 2609152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2613248 ++wrote 2048/2048 bytes at offset 2613248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2617344 ++wrote 2048/2048 bytes at offset 2617344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2621440 ++wrote 2048/2048 bytes at offset 2621440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2625536 ++wrote 2048/2048 bytes at offset 2625536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2629632 ++wrote 2048/2048 bytes at offset 2629632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2633728 ++wrote 2048/2048 bytes at offset 2633728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2637824 ++wrote 2048/2048 bytes at offset 2637824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2641920 ++wrote 2048/2048 bytes at offset 2641920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2646016 ++wrote 2048/2048 bytes at offset 2646016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2650112 ++wrote 2048/2048 bytes at offset 2650112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2654208 ++wrote 2048/2048 bytes at offset 2654208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2658304 ++wrote 2048/2048 bytes at offset 2658304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2662400 ++wrote 2048/2048 bytes at offset 2662400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2666496 ++wrote 2048/2048 bytes at offset 2666496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2670592 ++wrote 2048/2048 bytes at offset 2670592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2674688 ++wrote 2048/2048 bytes at offset 2674688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2678784 ++wrote 2048/2048 bytes at offset 2678784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2682880 ++wrote 2048/2048 bytes at offset 2682880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2686976 ++wrote 2048/2048 bytes at offset 2686976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2691072 ++wrote 2048/2048 bytes at offset 2691072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2695168 ++wrote 2048/2048 bytes at offset 2695168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2699264 ++wrote 2048/2048 bytes at offset 2699264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2703360 ++wrote 2048/2048 bytes at offset 2703360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2707456 ++wrote 2048/2048 bytes at offset 2707456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2711552 ++wrote 2048/2048 bytes at offset 2711552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2715648 ++wrote 2048/2048 bytes at offset 2715648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2719744 ++wrote 2048/2048 bytes at offset 2719744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2723840 ++wrote 2048/2048 bytes at offset 2723840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2727936 ++wrote 2048/2048 bytes at offset 2727936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2732032 ++wrote 2048/2048 bytes at offset 2732032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2736128 ++wrote 2048/2048 bytes at offset 2736128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2740224 ++wrote 2048/2048 bytes at offset 2740224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2744320 ++wrote 2048/2048 bytes at offset 2744320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2748416 ++wrote 2048/2048 bytes at offset 2748416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2752512 ++wrote 2048/2048 bytes at offset 2752512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2756608 ++wrote 2048/2048 bytes at offset 2756608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2760704 ++wrote 2048/2048 bytes at offset 2760704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2764800 ++wrote 2048/2048 bytes at offset 2764800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2768896 ++wrote 2048/2048 bytes at offset 2768896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2772992 ++wrote 2048/2048 bytes at offset 2772992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2777088 ++wrote 2048/2048 bytes at offset 2777088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2781184 ++wrote 2048/2048 bytes at offset 2781184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2785280 ++wrote 2048/2048 bytes at offset 2785280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2789376 ++wrote 2048/2048 bytes at offset 2789376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2793472 ++wrote 2048/2048 bytes at offset 2793472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2797568 ++wrote 2048/2048 bytes at offset 2797568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2801664 ++wrote 2048/2048 bytes at offset 2801664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2805760 ++wrote 2048/2048 bytes at offset 2805760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2809856 ++wrote 2048/2048 bytes at offset 2809856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2813952 ++wrote 2048/2048 bytes at offset 2813952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2818048 ++wrote 2048/2048 bytes at offset 2818048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2822144 ++wrote 2048/2048 bytes at offset 2822144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2826240 ++wrote 2048/2048 bytes at offset 2826240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2830336 ++wrote 2048/2048 bytes at offset 2830336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2834432 ++wrote 2048/2048 bytes at offset 2834432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2838528 ++wrote 2048/2048 bytes at offset 2838528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2842624 ++wrote 2048/2048 bytes at offset 2842624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2846720 ++wrote 2048/2048 bytes at offset 2846720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2850816 ++wrote 2048/2048 bytes at offset 2850816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2854912 ++wrote 2048/2048 bytes at offset 2854912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2859008 ++wrote 2048/2048 bytes at offset 2859008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2863104 ++wrote 2048/2048 bytes at offset 2863104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2867200 ++wrote 2048/2048 bytes at offset 2867200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2871296 ++wrote 2048/2048 bytes at offset 2871296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2875392 ++wrote 2048/2048 bytes at offset 2875392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2879488 ++wrote 2048/2048 bytes at offset 2879488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2883584 ++wrote 2048/2048 bytes at offset 2883584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2887680 ++wrote 2048/2048 bytes at offset 2887680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2891776 ++wrote 2048/2048 bytes at offset 2891776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2895872 ++wrote 2048/2048 bytes at offset 2895872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2899968 ++wrote 2048/2048 bytes at offset 2899968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2904064 ++wrote 2048/2048 bytes at offset 2904064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2908160 ++wrote 2048/2048 bytes at offset 2908160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2912256 ++wrote 2048/2048 bytes at offset 2912256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2916352 ++wrote 2048/2048 bytes at offset 2916352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2920448 ++wrote 2048/2048 bytes at offset 2920448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2924544 ++wrote 2048/2048 bytes at offset 2924544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2928640 ++wrote 2048/2048 bytes at offset 2928640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2932736 ++wrote 2048/2048 bytes at offset 2932736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2936832 ++wrote 2048/2048 bytes at offset 2936832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2940928 ++wrote 2048/2048 bytes at offset 2940928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2945024 ++wrote 2048/2048 bytes at offset 2945024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2949120 ++wrote 2048/2048 bytes at offset 2949120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2953216 ++wrote 2048/2048 bytes at offset 2953216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2957312 ++wrote 2048/2048 bytes at offset 2957312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2961408 ++wrote 2048/2048 bytes at offset 2961408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2965504 ++wrote 2048/2048 bytes at offset 2965504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2969600 ++wrote 2048/2048 bytes at offset 2969600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2973696 ++wrote 2048/2048 bytes at offset 2973696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2977792 ++wrote 2048/2048 bytes at offset 2977792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2981888 ++wrote 2048/2048 bytes at offset 2981888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2985984 ++wrote 2048/2048 bytes at offset 2985984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2990080 ++wrote 2048/2048 bytes at offset 2990080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2994176 ++wrote 2048/2048 bytes at offset 2994176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2998272 ++wrote 2048/2048 bytes at offset 2998272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3002368 ++wrote 2048/2048 bytes at offset 3002368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3006464 ++wrote 2048/2048 bytes at offset 3006464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3010560 ++wrote 2048/2048 bytes at offset 3010560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3014656 ++wrote 2048/2048 bytes at offset 3014656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3018752 ++wrote 2048/2048 bytes at offset 3018752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3022848 ++wrote 2048/2048 bytes at offset 3022848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3026944 ++wrote 2048/2048 bytes at offset 3026944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3031040 ++wrote 2048/2048 bytes at offset 3031040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3035136 ++wrote 2048/2048 bytes at offset 3035136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3039232 ++wrote 2048/2048 bytes at offset 3039232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3043328 ++wrote 2048/2048 bytes at offset 3043328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3047424 ++wrote 2048/2048 bytes at offset 3047424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3051520 ++wrote 2048/2048 bytes at offset 3051520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3055616 ++wrote 2048/2048 bytes at offset 3055616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3059712 ++wrote 2048/2048 bytes at offset 3059712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3063808 ++wrote 2048/2048 bytes at offset 3063808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3067904 ++wrote 2048/2048 bytes at offset 3067904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3072000 ++wrote 2048/2048 bytes at offset 3072000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3076096 ++wrote 2048/2048 bytes at offset 3076096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3080192 ++wrote 2048/2048 bytes at offset 3080192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3084288 ++wrote 2048/2048 bytes at offset 3084288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3088384 ++wrote 2048/2048 bytes at offset 3088384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3092480 ++wrote 2048/2048 bytes at offset 3092480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3096576 ++wrote 2048/2048 bytes at offset 3096576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3100672 ++wrote 2048/2048 bytes at offset 3100672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3104768 ++wrote 2048/2048 bytes at offset 3104768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3108864 ++wrote 2048/2048 bytes at offset 3108864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3112960 ++wrote 2048/2048 bytes at offset 3112960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3117056 ++wrote 2048/2048 bytes at offset 3117056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3121152 ++wrote 2048/2048 bytes at offset 3121152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3125248 ++wrote 2048/2048 bytes at offset 3125248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3129344 ++wrote 2048/2048 bytes at offset 3129344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3133440 ++wrote 2048/2048 bytes at offset 3133440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3137536 ++wrote 2048/2048 bytes at offset 3137536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3141632 ++wrote 2048/2048 bytes at offset 3141632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 2 +-qemu-io> wrote 2048/2048 bytes at offset 3146752 ++=== IO: pattern 2 ++wrote 2048/2048 bytes at offset 3146752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3150848 ++wrote 2048/2048 bytes at offset 3150848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3154944 ++wrote 2048/2048 bytes at offset 3154944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3159040 ++wrote 2048/2048 bytes at offset 3159040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3163136 ++wrote 2048/2048 bytes at offset 3163136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3167232 ++wrote 2048/2048 bytes at offset 3167232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3171328 ++wrote 2048/2048 bytes at offset 3171328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3175424 ++wrote 2048/2048 bytes at offset 3175424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3179520 ++wrote 2048/2048 bytes at offset 3179520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3183616 ++wrote 2048/2048 bytes at offset 3183616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3187712 ++wrote 2048/2048 bytes at offset 3187712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3191808 ++wrote 2048/2048 bytes at offset 3191808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3195904 ++wrote 2048/2048 bytes at offset 3195904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3200000 ++wrote 2048/2048 bytes at offset 3200000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3204096 ++wrote 2048/2048 bytes at offset 3204096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3208192 ++wrote 2048/2048 bytes at offset 3208192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3212288 ++wrote 2048/2048 bytes at offset 3212288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3216384 ++wrote 2048/2048 bytes at offset 3216384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3220480 ++wrote 2048/2048 bytes at offset 3220480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3224576 ++wrote 2048/2048 bytes at offset 3224576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3228672 ++wrote 2048/2048 bytes at offset 3228672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3232768 ++wrote 2048/2048 bytes at offset 3232768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3236864 ++wrote 2048/2048 bytes at offset 3236864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3240960 ++wrote 2048/2048 bytes at offset 3240960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3245056 ++wrote 2048/2048 bytes at offset 3245056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3249152 ++wrote 2048/2048 bytes at offset 3249152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3253248 ++wrote 2048/2048 bytes at offset 3253248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3257344 ++wrote 2048/2048 bytes at offset 3257344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3261440 ++wrote 2048/2048 bytes at offset 3261440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3265536 ++wrote 2048/2048 bytes at offset 3265536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3269632 ++wrote 2048/2048 bytes at offset 3269632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3273728 ++wrote 2048/2048 bytes at offset 3273728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3277824 ++wrote 2048/2048 bytes at offset 3277824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3281920 ++wrote 2048/2048 bytes at offset 3281920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3286016 ++wrote 2048/2048 bytes at offset 3286016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3290112 ++wrote 2048/2048 bytes at offset 3290112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3294208 ++wrote 2048/2048 bytes at offset 3294208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3298304 ++wrote 2048/2048 bytes at offset 3298304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3302400 ++wrote 2048/2048 bytes at offset 3302400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3306496 ++wrote 2048/2048 bytes at offset 3306496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3310592 ++wrote 2048/2048 bytes at offset 3310592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3314688 ++wrote 2048/2048 bytes at offset 3314688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3318784 ++wrote 2048/2048 bytes at offset 3318784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3322880 ++wrote 2048/2048 bytes at offset 3322880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3326976 ++wrote 2048/2048 bytes at offset 3326976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3331072 ++wrote 2048/2048 bytes at offset 3331072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3335168 ++wrote 2048/2048 bytes at offset 3335168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3339264 ++wrote 2048/2048 bytes at offset 3339264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3343360 ++wrote 2048/2048 bytes at offset 3343360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3347456 ++wrote 2048/2048 bytes at offset 3347456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3351552 ++wrote 2048/2048 bytes at offset 3351552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3355648 ++wrote 2048/2048 bytes at offset 3355648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3359744 ++wrote 2048/2048 bytes at offset 3359744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3363840 ++wrote 2048/2048 bytes at offset 3363840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3367936 ++wrote 2048/2048 bytes at offset 3367936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3372032 ++wrote 2048/2048 bytes at offset 3372032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3376128 ++wrote 2048/2048 bytes at offset 3376128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3380224 ++wrote 2048/2048 bytes at offset 3380224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3384320 ++wrote 2048/2048 bytes at offset 3384320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3388416 ++wrote 2048/2048 bytes at offset 3388416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3392512 ++wrote 2048/2048 bytes at offset 3392512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3396608 ++wrote 2048/2048 bytes at offset 3396608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3400704 ++wrote 2048/2048 bytes at offset 3400704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3404800 ++wrote 2048/2048 bytes at offset 3404800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3408896 ++wrote 2048/2048 bytes at offset 3408896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3412992 ++wrote 2048/2048 bytes at offset 3412992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3417088 ++wrote 2048/2048 bytes at offset 3417088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3421184 ++wrote 2048/2048 bytes at offset 3421184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3425280 ++wrote 2048/2048 bytes at offset 3425280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3429376 ++wrote 2048/2048 bytes at offset 3429376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3433472 ++wrote 2048/2048 bytes at offset 3433472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3437568 ++wrote 2048/2048 bytes at offset 3437568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3441664 ++wrote 2048/2048 bytes at offset 3441664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3445760 ++wrote 2048/2048 bytes at offset 3445760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3449856 ++wrote 2048/2048 bytes at offset 3449856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3453952 ++wrote 2048/2048 bytes at offset 3453952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3458048 ++wrote 2048/2048 bytes at offset 3458048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3462144 ++wrote 2048/2048 bytes at offset 3462144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3466240 ++wrote 2048/2048 bytes at offset 3466240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3470336 ++wrote 2048/2048 bytes at offset 3470336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3474432 ++wrote 2048/2048 bytes at offset 3474432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3478528 ++wrote 2048/2048 bytes at offset 3478528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3482624 ++wrote 2048/2048 bytes at offset 3482624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3486720 ++wrote 2048/2048 bytes at offset 3486720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3490816 ++wrote 2048/2048 bytes at offset 3490816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3494912 ++wrote 2048/2048 bytes at offset 3494912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3499008 ++wrote 2048/2048 bytes at offset 3499008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3503104 ++wrote 2048/2048 bytes at offset 3503104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3507200 ++wrote 2048/2048 bytes at offset 3507200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3511296 ++wrote 2048/2048 bytes at offset 3511296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3515392 ++wrote 2048/2048 bytes at offset 3515392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3519488 ++wrote 2048/2048 bytes at offset 3519488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3523584 ++wrote 2048/2048 bytes at offset 3523584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3527680 ++wrote 2048/2048 bytes at offset 3527680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3531776 ++wrote 2048/2048 bytes at offset 3531776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3535872 ++wrote 2048/2048 bytes at offset 3535872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3539968 ++wrote 2048/2048 bytes at offset 3539968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3544064 ++wrote 2048/2048 bytes at offset 3544064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3548160 ++wrote 2048/2048 bytes at offset 3548160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3552256 ++wrote 2048/2048 bytes at offset 3552256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3556352 ++wrote 2048/2048 bytes at offset 3556352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3560448 ++wrote 2048/2048 bytes at offset 3560448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3564544 ++wrote 2048/2048 bytes at offset 3564544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3568640 ++wrote 2048/2048 bytes at offset 3568640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3572736 ++wrote 2048/2048 bytes at offset 3572736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3576832 ++wrote 2048/2048 bytes at offset 3576832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3580928 ++wrote 2048/2048 bytes at offset 3580928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3585024 ++wrote 2048/2048 bytes at offset 3585024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3589120 ++wrote 2048/2048 bytes at offset 3589120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3593216 ++wrote 2048/2048 bytes at offset 3593216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3597312 ++wrote 2048/2048 bytes at offset 3597312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3601408 ++wrote 2048/2048 bytes at offset 3601408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3605504 ++wrote 2048/2048 bytes at offset 3605504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3609600 ++wrote 2048/2048 bytes at offset 3609600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3613696 ++wrote 2048/2048 bytes at offset 3613696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3617792 ++wrote 2048/2048 bytes at offset 3617792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3621888 ++wrote 2048/2048 bytes at offset 3621888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3625984 ++wrote 2048/2048 bytes at offset 3625984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3630080 ++wrote 2048/2048 bytes at offset 3630080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3634176 ++wrote 2048/2048 bytes at offset 3634176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3638272 ++wrote 2048/2048 bytes at offset 3638272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3642368 ++wrote 2048/2048 bytes at offset 3642368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3646464 ++wrote 2048/2048 bytes at offset 3646464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3650560 ++wrote 2048/2048 bytes at offset 3650560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3654656 ++wrote 2048/2048 bytes at offset 3654656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3658752 ++wrote 2048/2048 bytes at offset 3658752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3662848 ++wrote 2048/2048 bytes at offset 3662848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3666944 ++wrote 2048/2048 bytes at offset 3666944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3671040 ++wrote 2048/2048 bytes at offset 3671040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3675136 ++wrote 2048/2048 bytes at offset 3675136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3679232 ++wrote 2048/2048 bytes at offset 3679232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3683328 ++wrote 2048/2048 bytes at offset 3683328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3687424 ++wrote 2048/2048 bytes at offset 3687424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3691520 ++wrote 2048/2048 bytes at offset 3691520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3695616 ++wrote 2048/2048 bytes at offset 3695616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3699712 ++wrote 2048/2048 bytes at offset 3699712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3703808 ++wrote 2048/2048 bytes at offset 3703808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3707904 ++wrote 2048/2048 bytes at offset 3707904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3712000 ++wrote 2048/2048 bytes at offset 3712000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3716096 ++wrote 2048/2048 bytes at offset 3716096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3720192 ++wrote 2048/2048 bytes at offset 3720192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3724288 ++wrote 2048/2048 bytes at offset 3724288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3728384 ++wrote 2048/2048 bytes at offset 3728384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3732480 ++wrote 2048/2048 bytes at offset 3732480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3736576 ++wrote 2048/2048 bytes at offset 3736576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3740672 ++wrote 2048/2048 bytes at offset 3740672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3744768 ++wrote 2048/2048 bytes at offset 3744768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3748864 ++wrote 2048/2048 bytes at offset 3748864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3752960 ++wrote 2048/2048 bytes at offset 3752960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3757056 ++wrote 2048/2048 bytes at offset 3757056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3761152 ++wrote 2048/2048 bytes at offset 3761152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3765248 ++wrote 2048/2048 bytes at offset 3765248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3769344 ++wrote 2048/2048 bytes at offset 3769344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3773440 ++wrote 2048/2048 bytes at offset 3773440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3777536 ++wrote 2048/2048 bytes at offset 3777536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3781632 ++wrote 2048/2048 bytes at offset 3781632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3785728 ++wrote 2048/2048 bytes at offset 3785728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3789824 ++wrote 2048/2048 bytes at offset 3789824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3793920 ++wrote 2048/2048 bytes at offset 3793920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3798016 ++wrote 2048/2048 bytes at offset 3798016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3802112 ++wrote 2048/2048 bytes at offset 3802112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3806208 ++wrote 2048/2048 bytes at offset 3806208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3810304 ++wrote 2048/2048 bytes at offset 3810304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3814400 ++wrote 2048/2048 bytes at offset 3814400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3818496 ++wrote 2048/2048 bytes at offset 3818496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3822592 ++wrote 2048/2048 bytes at offset 3822592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3826688 ++wrote 2048/2048 bytes at offset 3826688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3830784 ++wrote 2048/2048 bytes at offset 3830784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3834880 ++wrote 2048/2048 bytes at offset 3834880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3838976 ++wrote 2048/2048 bytes at offset 3838976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3843072 ++wrote 2048/2048 bytes at offset 3843072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3847168 ++wrote 2048/2048 bytes at offset 3847168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3851264 ++wrote 2048/2048 bytes at offset 3851264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3855360 ++wrote 2048/2048 bytes at offset 3855360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3859456 ++wrote 2048/2048 bytes at offset 3859456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3863552 ++wrote 2048/2048 bytes at offset 3863552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3867648 ++wrote 2048/2048 bytes at offset 3867648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3871744 ++wrote 2048/2048 bytes at offset 3871744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3875840 ++wrote 2048/2048 bytes at offset 3875840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3879936 ++wrote 2048/2048 bytes at offset 3879936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3884032 ++wrote 2048/2048 bytes at offset 3884032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3888128 ++wrote 2048/2048 bytes at offset 3888128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3892224 ++wrote 2048/2048 bytes at offset 3892224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3896320 ++wrote 2048/2048 bytes at offset 3896320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3900416 ++wrote 2048/2048 bytes at offset 3900416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3904512 ++wrote 2048/2048 bytes at offset 3904512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3908608 ++wrote 2048/2048 bytes at offset 3908608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3912704 ++wrote 2048/2048 bytes at offset 3912704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3916800 ++wrote 2048/2048 bytes at offset 3916800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3920896 ++wrote 2048/2048 bytes at offset 3920896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3924992 ++wrote 2048/2048 bytes at offset 3924992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3929088 ++wrote 2048/2048 bytes at offset 3929088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3933184 ++wrote 2048/2048 bytes at offset 3933184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3937280 ++wrote 2048/2048 bytes at offset 3937280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3941376 ++wrote 2048/2048 bytes at offset 3941376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3945472 ++wrote 2048/2048 bytes at offset 3945472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3949568 ++wrote 2048/2048 bytes at offset 3949568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3953664 ++wrote 2048/2048 bytes at offset 3953664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3957760 ++wrote 2048/2048 bytes at offset 3957760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3961856 ++wrote 2048/2048 bytes at offset 3961856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3965952 ++wrote 2048/2048 bytes at offset 3965952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3970048 ++wrote 2048/2048 bytes at offset 3970048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3974144 ++wrote 2048/2048 bytes at offset 3974144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3978240 ++wrote 2048/2048 bytes at offset 3978240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3982336 ++wrote 2048/2048 bytes at offset 3982336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3986432 ++wrote 2048/2048 bytes at offset 3986432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3990528 ++wrote 2048/2048 bytes at offset 3990528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3994624 ++wrote 2048/2048 bytes at offset 3994624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3998720 ++wrote 2048/2048 bytes at offset 3998720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4002816 ++wrote 2048/2048 bytes at offset 4002816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4006912 ++wrote 2048/2048 bytes at offset 4006912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4011008 ++wrote 2048/2048 bytes at offset 4011008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4015104 ++wrote 2048/2048 bytes at offset 4015104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4019200 ++wrote 2048/2048 bytes at offset 4019200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4023296 ++wrote 2048/2048 bytes at offset 4023296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4027392 ++wrote 2048/2048 bytes at offset 4027392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4031488 ++wrote 2048/2048 bytes at offset 4031488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4035584 ++wrote 2048/2048 bytes at offset 4035584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4039680 ++wrote 2048/2048 bytes at offset 4039680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4043776 ++wrote 2048/2048 bytes at offset 4043776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4047872 ++wrote 2048/2048 bytes at offset 4047872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4051968 ++wrote 2048/2048 bytes at offset 4051968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4056064 ++wrote 2048/2048 bytes at offset 4056064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4060160 ++wrote 2048/2048 bytes at offset 4060160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4064256 ++wrote 2048/2048 bytes at offset 4064256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4068352 ++wrote 2048/2048 bytes at offset 4068352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4072448 ++wrote 2048/2048 bytes at offset 4072448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4076544 ++wrote 2048/2048 bytes at offset 4076544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4080640 ++wrote 2048/2048 bytes at offset 4080640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4084736 ++wrote 2048/2048 bytes at offset 4084736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4088832 ++wrote 2048/2048 bytes at offset 4088832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4092928 ++wrote 2048/2048 bytes at offset 4092928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4097024 ++wrote 2048/2048 bytes at offset 4097024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4101120 ++wrote 2048/2048 bytes at offset 4101120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4105216 ++wrote 2048/2048 bytes at offset 4105216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4109312 ++wrote 2048/2048 bytes at offset 4109312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4113408 ++wrote 2048/2048 bytes at offset 4113408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4117504 ++wrote 2048/2048 bytes at offset 4117504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4121600 ++wrote 2048/2048 bytes at offset 4121600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4125696 ++wrote 2048/2048 bytes at offset 4125696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4129792 ++wrote 2048/2048 bytes at offset 4129792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4133888 ++wrote 2048/2048 bytes at offset 4133888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4137984 ++wrote 2048/2048 bytes at offset 4137984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4142080 ++wrote 2048/2048 bytes at offset 4142080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4146176 ++wrote 2048/2048 bytes at offset 4146176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4150272 ++wrote 2048/2048 bytes at offset 4150272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4154368 ++wrote 2048/2048 bytes at offset 4154368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4158464 ++wrote 2048/2048 bytes at offset 4158464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4162560 ++wrote 2048/2048 bytes at offset 4162560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4166656 ++wrote 2048/2048 bytes at offset 4166656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4170752 ++wrote 2048/2048 bytes at offset 4170752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4174848 ++wrote 2048/2048 bytes at offset 4174848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4178944 ++wrote 2048/2048 bytes at offset 4178944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4183040 ++wrote 2048/2048 bytes at offset 4183040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4187136 ++wrote 2048/2048 bytes at offset 4187136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4191232 ++wrote 2048/2048 bytes at offset 4191232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 4 +-qemu-io> wrote 8192/8192 bytes at offset 4196352 ++=== IO: pattern 4 ++wrote 8192/8192 bytes at offset 4196352 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4208640 ++wrote 8192/8192 bytes at offset 4208640 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4220928 ++wrote 8192/8192 bytes at offset 4220928 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4233216 ++wrote 8192/8192 bytes at offset 4233216 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4245504 ++wrote 8192/8192 bytes at offset 4245504 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4257792 ++wrote 8192/8192 bytes at offset 4257792 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4270080 ++wrote 8192/8192 bytes at offset 4270080 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4282368 ++wrote 8192/8192 bytes at offset 4282368 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4294656 ++wrote 8192/8192 bytes at offset 4294656 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4306944 ++wrote 8192/8192 bytes at offset 4306944 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4319232 ++wrote 8192/8192 bytes at offset 4319232 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4331520 ++wrote 8192/8192 bytes at offset 4331520 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4343808 ++wrote 8192/8192 bytes at offset 4343808 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4356096 ++wrote 8192/8192 bytes at offset 4356096 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4368384 ++wrote 8192/8192 bytes at offset 4368384 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4380672 ++wrote 8192/8192 bytes at offset 4380672 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4392960 ++wrote 8192/8192 bytes at offset 4392960 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4405248 ++wrote 8192/8192 bytes at offset 4405248 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4417536 ++wrote 8192/8192 bytes at offset 4417536 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4429824 ++wrote 8192/8192 bytes at offset 4429824 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4442112 ++wrote 8192/8192 bytes at offset 4442112 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4454400 ++wrote 8192/8192 bytes at offset 4454400 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4466688 ++wrote 8192/8192 bytes at offset 4466688 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4478976 ++wrote 8192/8192 bytes at offset 4478976 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4491264 ++wrote 8192/8192 bytes at offset 4491264 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4503552 ++wrote 8192/8192 bytes at offset 4503552 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4515840 ++wrote 8192/8192 bytes at offset 4515840 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4528128 ++wrote 8192/8192 bytes at offset 4528128 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4540416 ++wrote 8192/8192 bytes at offset 4540416 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4552704 ++wrote 8192/8192 bytes at offset 4552704 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4564992 ++wrote 8192/8192 bytes at offset 4564992 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4577280 ++wrote 8192/8192 bytes at offset 4577280 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4589568 ++wrote 8192/8192 bytes at offset 4589568 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4601856 ++wrote 8192/8192 bytes at offset 4601856 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4614144 ++wrote 8192/8192 bytes at offset 4614144 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4626432 ++wrote 8192/8192 bytes at offset 4626432 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4638720 ++wrote 8192/8192 bytes at offset 4638720 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4651008 ++wrote 8192/8192 bytes at offset 4651008 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4663296 ++wrote 8192/8192 bytes at offset 4663296 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4675584 ++wrote 8192/8192 bytes at offset 4675584 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4687872 ++wrote 8192/8192 bytes at offset 4687872 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4700160 ++wrote 8192/8192 bytes at offset 4700160 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4712448 ++wrote 8192/8192 bytes at offset 4712448 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4724736 ++wrote 8192/8192 bytes at offset 4724736 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4737024 ++wrote 8192/8192 bytes at offset 4737024 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4749312 ++wrote 8192/8192 bytes at offset 4749312 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4761600 ++wrote 8192/8192 bytes at offset 4761600 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4773888 ++wrote 8192/8192 bytes at offset 4773888 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4786176 ++wrote 8192/8192 bytes at offset 4786176 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4798464 ++wrote 8192/8192 bytes at offset 4798464 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4810752 ++wrote 8192/8192 bytes at offset 4810752 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4823040 ++wrote 8192/8192 bytes at offset 4823040 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4835328 ++wrote 8192/8192 bytes at offset 4835328 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4847616 ++wrote 8192/8192 bytes at offset 4847616 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4859904 ++wrote 8192/8192 bytes at offset 4859904 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4872192 ++wrote 8192/8192 bytes at offset 4872192 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4884480 ++wrote 8192/8192 bytes at offset 4884480 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4896768 ++wrote 8192/8192 bytes at offset 4896768 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4909056 ++wrote 8192/8192 bytes at offset 4909056 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4921344 ++wrote 8192/8192 bytes at offset 4921344 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4933632 ++wrote 8192/8192 bytes at offset 4933632 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4945920 ++wrote 8192/8192 bytes at offset 4945920 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4958208 ++wrote 8192/8192 bytes at offset 4958208 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4970496 ++wrote 8192/8192 bytes at offset 4970496 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 244 +-qemu-io> wrote 12288/12288 bytes at offset 6285312 ++=== IO: pattern 244 ++wrote 12288/12288 bytes at offset 6285312 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 8384512 ++wrote 12288/12288 bytes at offset 8384512 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 10483712 ++wrote 12288/12288 bytes at offset 10483712 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 12582912 ++wrote 12288/12288 bytes at offset 12582912 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 14682112 ++wrote 12288/12288 bytes at offset 14682112 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 16781312 ++wrote 12288/12288 bytes at offset 16781312 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 18880512 ++wrote 12288/12288 bytes at offset 18880512 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 20979712 ++wrote 12288/12288 bytes at offset 20979712 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> read 4096/4096 bytes at offset 0 ++=== IO: pattern 0 ++read 4096/4096 bytes at offset 0 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4096 ++read 4096/4096 bytes at offset 4096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 8192 ++read 4096/4096 bytes at offset 8192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 12288 ++read 4096/4096 bytes at offset 12288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 16384 ++read 4096/4096 bytes at offset 16384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 20480 ++read 4096/4096 bytes at offset 20480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 24576 ++read 4096/4096 bytes at offset 24576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 28672 ++read 4096/4096 bytes at offset 28672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 32768 ++read 4096/4096 bytes at offset 32768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 36864 ++read 4096/4096 bytes at offset 36864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 40960 ++read 4096/4096 bytes at offset 40960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 45056 ++read 4096/4096 bytes at offset 45056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 49152 ++read 4096/4096 bytes at offset 49152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 53248 ++read 4096/4096 bytes at offset 53248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 57344 ++read 4096/4096 bytes at offset 57344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 61440 ++read 4096/4096 bytes at offset 61440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 65536 ++read 4096/4096 bytes at offset 65536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 69632 ++read 4096/4096 bytes at offset 69632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 73728 ++read 4096/4096 bytes at offset 73728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 77824 ++read 4096/4096 bytes at offset 77824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 81920 ++read 4096/4096 bytes at offset 81920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 86016 ++read 4096/4096 bytes at offset 86016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 90112 ++read 4096/4096 bytes at offset 90112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 94208 ++read 4096/4096 bytes at offset 94208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 98304 ++read 4096/4096 bytes at offset 98304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 102400 ++read 4096/4096 bytes at offset 102400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 106496 ++read 4096/4096 bytes at offset 106496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 110592 ++read 4096/4096 bytes at offset 110592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 114688 ++read 4096/4096 bytes at offset 114688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 118784 ++read 4096/4096 bytes at offset 118784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 122880 ++read 4096/4096 bytes at offset 122880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 126976 ++read 4096/4096 bytes at offset 126976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 131072 ++read 4096/4096 bytes at offset 131072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 135168 ++read 4096/4096 bytes at offset 135168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 139264 ++read 4096/4096 bytes at offset 139264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 143360 ++read 4096/4096 bytes at offset 143360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 147456 ++read 4096/4096 bytes at offset 147456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 151552 ++read 4096/4096 bytes at offset 151552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 155648 ++read 4096/4096 bytes at offset 155648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 159744 ++read 4096/4096 bytes at offset 159744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 163840 ++read 4096/4096 bytes at offset 163840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 167936 ++read 4096/4096 bytes at offset 167936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 172032 ++read 4096/4096 bytes at offset 172032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 176128 ++read 4096/4096 bytes at offset 176128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 180224 ++read 4096/4096 bytes at offset 180224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 184320 ++read 4096/4096 bytes at offset 184320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 188416 ++read 4096/4096 bytes at offset 188416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 192512 ++read 4096/4096 bytes at offset 192512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 196608 ++read 4096/4096 bytes at offset 196608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 200704 ++read 4096/4096 bytes at offset 200704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 204800 ++read 4096/4096 bytes at offset 204800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 208896 ++read 4096/4096 bytes at offset 208896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 212992 ++read 4096/4096 bytes at offset 212992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 217088 ++read 4096/4096 bytes at offset 217088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 221184 ++read 4096/4096 bytes at offset 221184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 225280 ++read 4096/4096 bytes at offset 225280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 229376 ++read 4096/4096 bytes at offset 229376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 233472 ++read 4096/4096 bytes at offset 233472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 237568 ++read 4096/4096 bytes at offset 237568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 241664 ++read 4096/4096 bytes at offset 241664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 245760 ++read 4096/4096 bytes at offset 245760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 249856 ++read 4096/4096 bytes at offset 249856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 253952 ++read 4096/4096 bytes at offset 253952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 258048 ++read 4096/4096 bytes at offset 258048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 262144 ++read 4096/4096 bytes at offset 262144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 266240 ++read 4096/4096 bytes at offset 266240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 270336 ++read 4096/4096 bytes at offset 270336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 274432 ++read 4096/4096 bytes at offset 274432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 278528 ++read 4096/4096 bytes at offset 278528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 282624 ++read 4096/4096 bytes at offset 282624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 286720 ++read 4096/4096 bytes at offset 286720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 290816 ++read 4096/4096 bytes at offset 290816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 294912 ++read 4096/4096 bytes at offset 294912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 299008 ++read 4096/4096 bytes at offset 299008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 303104 ++read 4096/4096 bytes at offset 303104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 307200 ++read 4096/4096 bytes at offset 307200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 311296 ++read 4096/4096 bytes at offset 311296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 315392 ++read 4096/4096 bytes at offset 315392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 319488 ++read 4096/4096 bytes at offset 319488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 323584 ++read 4096/4096 bytes at offset 323584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 327680 ++read 4096/4096 bytes at offset 327680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 331776 ++read 4096/4096 bytes at offset 331776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 335872 ++read 4096/4096 bytes at offset 335872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 339968 ++read 4096/4096 bytes at offset 339968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 344064 ++read 4096/4096 bytes at offset 344064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 348160 ++read 4096/4096 bytes at offset 348160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 352256 ++read 4096/4096 bytes at offset 352256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 356352 ++read 4096/4096 bytes at offset 356352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 360448 ++read 4096/4096 bytes at offset 360448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 364544 ++read 4096/4096 bytes at offset 364544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 368640 ++read 4096/4096 bytes at offset 368640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 372736 ++read 4096/4096 bytes at offset 372736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 376832 ++read 4096/4096 bytes at offset 376832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 380928 ++read 4096/4096 bytes at offset 380928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 385024 ++read 4096/4096 bytes at offset 385024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 389120 ++read 4096/4096 bytes at offset 389120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 393216 ++read 4096/4096 bytes at offset 393216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 397312 ++read 4096/4096 bytes at offset 397312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 401408 ++read 4096/4096 bytes at offset 401408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 405504 ++read 4096/4096 bytes at offset 405504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 409600 ++read 4096/4096 bytes at offset 409600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 413696 ++read 4096/4096 bytes at offset 413696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 417792 ++read 4096/4096 bytes at offset 417792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 421888 ++read 4096/4096 bytes at offset 421888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 425984 ++read 4096/4096 bytes at offset 425984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 430080 ++read 4096/4096 bytes at offset 430080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 434176 ++read 4096/4096 bytes at offset 434176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 438272 ++read 4096/4096 bytes at offset 438272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 442368 ++read 4096/4096 bytes at offset 442368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 446464 ++read 4096/4096 bytes at offset 446464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 450560 ++read 4096/4096 bytes at offset 450560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 454656 ++read 4096/4096 bytes at offset 454656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 458752 ++read 4096/4096 bytes at offset 458752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 462848 ++read 4096/4096 bytes at offset 462848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 466944 ++read 4096/4096 bytes at offset 466944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 471040 ++read 4096/4096 bytes at offset 471040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 475136 ++read 4096/4096 bytes at offset 475136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 479232 ++read 4096/4096 bytes at offset 479232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 483328 ++read 4096/4096 bytes at offset 483328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 487424 ++read 4096/4096 bytes at offset 487424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 491520 ++read 4096/4096 bytes at offset 491520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 495616 ++read 4096/4096 bytes at offset 495616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 499712 ++read 4096/4096 bytes at offset 499712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 503808 ++read 4096/4096 bytes at offset 503808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 507904 ++read 4096/4096 bytes at offset 507904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 512000 ++read 4096/4096 bytes at offset 512000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 516096 ++read 4096/4096 bytes at offset 516096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 520192 ++read 4096/4096 bytes at offset 520192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 524288 ++read 4096/4096 bytes at offset 524288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 528384 ++read 4096/4096 bytes at offset 528384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 532480 ++read 4096/4096 bytes at offset 532480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 536576 ++read 4096/4096 bytes at offset 536576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 540672 ++read 4096/4096 bytes at offset 540672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 544768 ++read 4096/4096 bytes at offset 544768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 548864 ++read 4096/4096 bytes at offset 548864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 552960 ++read 4096/4096 bytes at offset 552960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 557056 ++read 4096/4096 bytes at offset 557056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 561152 ++read 4096/4096 bytes at offset 561152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 565248 ++read 4096/4096 bytes at offset 565248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 569344 ++read 4096/4096 bytes at offset 569344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 573440 ++read 4096/4096 bytes at offset 573440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 577536 ++read 4096/4096 bytes at offset 577536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 581632 ++read 4096/4096 bytes at offset 581632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 585728 ++read 4096/4096 bytes at offset 585728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 589824 ++read 4096/4096 bytes at offset 589824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 593920 ++read 4096/4096 bytes at offset 593920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 598016 ++read 4096/4096 bytes at offset 598016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 602112 ++read 4096/4096 bytes at offset 602112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 606208 ++read 4096/4096 bytes at offset 606208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 610304 ++read 4096/4096 bytes at offset 610304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 614400 ++read 4096/4096 bytes at offset 614400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 618496 ++read 4096/4096 bytes at offset 618496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 622592 ++read 4096/4096 bytes at offset 622592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 626688 ++read 4096/4096 bytes at offset 626688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 630784 ++read 4096/4096 bytes at offset 630784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 634880 ++read 4096/4096 bytes at offset 634880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 638976 ++read 4096/4096 bytes at offset 638976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 643072 ++read 4096/4096 bytes at offset 643072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 647168 ++read 4096/4096 bytes at offset 647168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 651264 ++read 4096/4096 bytes at offset 651264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 655360 ++read 4096/4096 bytes at offset 655360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 659456 ++read 4096/4096 bytes at offset 659456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 663552 ++read 4096/4096 bytes at offset 663552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 667648 ++read 4096/4096 bytes at offset 667648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 671744 ++read 4096/4096 bytes at offset 671744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 675840 ++read 4096/4096 bytes at offset 675840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 679936 ++read 4096/4096 bytes at offset 679936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 684032 ++read 4096/4096 bytes at offset 684032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 688128 ++read 4096/4096 bytes at offset 688128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 692224 ++read 4096/4096 bytes at offset 692224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 696320 ++read 4096/4096 bytes at offset 696320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 700416 ++read 4096/4096 bytes at offset 700416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 704512 ++read 4096/4096 bytes at offset 704512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 708608 ++read 4096/4096 bytes at offset 708608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 712704 ++read 4096/4096 bytes at offset 712704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 716800 ++read 4096/4096 bytes at offset 716800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 720896 ++read 4096/4096 bytes at offset 720896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 724992 ++read 4096/4096 bytes at offset 724992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 729088 ++read 4096/4096 bytes at offset 729088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 733184 ++read 4096/4096 bytes at offset 733184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 737280 ++read 4096/4096 bytes at offset 737280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 741376 ++read 4096/4096 bytes at offset 741376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 745472 ++read 4096/4096 bytes at offset 745472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 749568 ++read 4096/4096 bytes at offset 749568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 753664 ++read 4096/4096 bytes at offset 753664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 757760 ++read 4096/4096 bytes at offset 757760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 761856 ++read 4096/4096 bytes at offset 761856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 765952 ++read 4096/4096 bytes at offset 765952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 770048 ++read 4096/4096 bytes at offset 770048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 774144 ++read 4096/4096 bytes at offset 774144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 778240 ++read 4096/4096 bytes at offset 778240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 782336 ++read 4096/4096 bytes at offset 782336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 786432 ++read 4096/4096 bytes at offset 786432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 790528 ++read 4096/4096 bytes at offset 790528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 794624 ++read 4096/4096 bytes at offset 794624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 798720 ++read 4096/4096 bytes at offset 798720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 802816 ++read 4096/4096 bytes at offset 802816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 806912 ++read 4096/4096 bytes at offset 806912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 811008 ++read 4096/4096 bytes at offset 811008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 815104 ++read 4096/4096 bytes at offset 815104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 819200 ++read 4096/4096 bytes at offset 819200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 823296 ++read 4096/4096 bytes at offset 823296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 827392 ++read 4096/4096 bytes at offset 827392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 831488 ++read 4096/4096 bytes at offset 831488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 835584 ++read 4096/4096 bytes at offset 835584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 839680 ++read 4096/4096 bytes at offset 839680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 843776 ++read 4096/4096 bytes at offset 843776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 847872 ++read 4096/4096 bytes at offset 847872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 851968 ++read 4096/4096 bytes at offset 851968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 856064 ++read 4096/4096 bytes at offset 856064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 860160 ++read 4096/4096 bytes at offset 860160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 864256 ++read 4096/4096 bytes at offset 864256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 868352 ++read 4096/4096 bytes at offset 868352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 872448 ++read 4096/4096 bytes at offset 872448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 876544 ++read 4096/4096 bytes at offset 876544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 880640 ++read 4096/4096 bytes at offset 880640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 884736 ++read 4096/4096 bytes at offset 884736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 888832 ++read 4096/4096 bytes at offset 888832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 892928 ++read 4096/4096 bytes at offset 892928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 897024 ++read 4096/4096 bytes at offset 897024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 901120 ++read 4096/4096 bytes at offset 901120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 905216 ++read 4096/4096 bytes at offset 905216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 909312 ++read 4096/4096 bytes at offset 909312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 913408 ++read 4096/4096 bytes at offset 913408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 917504 ++read 4096/4096 bytes at offset 917504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 921600 ++read 4096/4096 bytes at offset 921600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 925696 ++read 4096/4096 bytes at offset 925696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 929792 ++read 4096/4096 bytes at offset 929792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 933888 ++read 4096/4096 bytes at offset 933888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 937984 ++read 4096/4096 bytes at offset 937984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 942080 ++read 4096/4096 bytes at offset 942080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 946176 ++read 4096/4096 bytes at offset 946176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 950272 ++read 4096/4096 bytes at offset 950272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 954368 ++read 4096/4096 bytes at offset 954368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 958464 ++read 4096/4096 bytes at offset 958464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 962560 ++read 4096/4096 bytes at offset 962560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 966656 ++read 4096/4096 bytes at offset 966656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 970752 ++read 4096/4096 bytes at offset 970752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 974848 ++read 4096/4096 bytes at offset 974848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 978944 ++read 4096/4096 bytes at offset 978944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 983040 ++read 4096/4096 bytes at offset 983040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 987136 ++read 4096/4096 bytes at offset 987136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 991232 ++read 4096/4096 bytes at offset 991232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 995328 ++read 4096/4096 bytes at offset 995328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 999424 ++read 4096/4096 bytes at offset 999424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1003520 ++read 4096/4096 bytes at offset 1003520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1007616 ++read 4096/4096 bytes at offset 1007616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1011712 ++read 4096/4096 bytes at offset 1011712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1015808 ++read 4096/4096 bytes at offset 1015808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1019904 ++read 4096/4096 bytes at offset 1019904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1024000 ++read 4096/4096 bytes at offset 1024000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1028096 ++read 4096/4096 bytes at offset 1028096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1032192 ++read 4096/4096 bytes at offset 1032192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1036288 ++read 4096/4096 bytes at offset 1036288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1040384 ++read 4096/4096 bytes at offset 1040384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1044480 ++read 4096/4096 bytes at offset 1044480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 4 +-qemu-io> read 2048/2048 bytes at offset 1050624 ++=== IO: pattern 4 ++read 2048/2048 bytes at offset 1050624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1054720 ++read 2048/2048 bytes at offset 1054720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1058816 ++read 2048/2048 bytes at offset 1058816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1062912 ++read 2048/2048 bytes at offset 1062912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1067008 ++read 2048/2048 bytes at offset 1067008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1071104 ++read 2048/2048 bytes at offset 1071104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1075200 ++read 2048/2048 bytes at offset 1075200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1079296 ++read 2048/2048 bytes at offset 1079296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1083392 ++read 2048/2048 bytes at offset 1083392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1087488 ++read 2048/2048 bytes at offset 1087488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1091584 ++read 2048/2048 bytes at offset 1091584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1095680 ++read 2048/2048 bytes at offset 1095680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1099776 ++read 2048/2048 bytes at offset 1099776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1103872 ++read 2048/2048 bytes at offset 1103872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1107968 ++read 2048/2048 bytes at offset 1107968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1112064 ++read 2048/2048 bytes at offset 1112064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1116160 ++read 2048/2048 bytes at offset 1116160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1120256 ++read 2048/2048 bytes at offset 1120256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1124352 ++read 2048/2048 bytes at offset 1124352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1128448 ++read 2048/2048 bytes at offset 1128448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1132544 ++read 2048/2048 bytes at offset 1132544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1136640 ++read 2048/2048 bytes at offset 1136640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1140736 ++read 2048/2048 bytes at offset 1140736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1144832 ++read 2048/2048 bytes at offset 1144832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1148928 ++read 2048/2048 bytes at offset 1148928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1153024 ++read 2048/2048 bytes at offset 1153024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1157120 ++read 2048/2048 bytes at offset 1157120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1161216 ++read 2048/2048 bytes at offset 1161216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1165312 ++read 2048/2048 bytes at offset 1165312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1169408 ++read 2048/2048 bytes at offset 1169408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1173504 ++read 2048/2048 bytes at offset 1173504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1177600 ++read 2048/2048 bytes at offset 1177600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1181696 ++read 2048/2048 bytes at offset 1181696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1185792 ++read 2048/2048 bytes at offset 1185792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1189888 ++read 2048/2048 bytes at offset 1189888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1193984 ++read 2048/2048 bytes at offset 1193984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1198080 ++read 2048/2048 bytes at offset 1198080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1202176 ++read 2048/2048 bytes at offset 1202176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1206272 ++read 2048/2048 bytes at offset 1206272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1210368 ++read 2048/2048 bytes at offset 1210368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1214464 ++read 2048/2048 bytes at offset 1214464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1218560 ++read 2048/2048 bytes at offset 1218560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1222656 ++read 2048/2048 bytes at offset 1222656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1226752 ++read 2048/2048 bytes at offset 1226752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1230848 ++read 2048/2048 bytes at offset 1230848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1234944 ++read 2048/2048 bytes at offset 1234944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1239040 ++read 2048/2048 bytes at offset 1239040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1243136 ++read 2048/2048 bytes at offset 1243136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1247232 ++read 2048/2048 bytes at offset 1247232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1251328 ++read 2048/2048 bytes at offset 1251328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1255424 ++read 2048/2048 bytes at offset 1255424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1259520 ++read 2048/2048 bytes at offset 1259520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1263616 ++read 2048/2048 bytes at offset 1263616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1267712 ++read 2048/2048 bytes at offset 1267712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1271808 ++read 2048/2048 bytes at offset 1271808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1275904 ++read 2048/2048 bytes at offset 1275904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1280000 ++read 2048/2048 bytes at offset 1280000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1284096 ++read 2048/2048 bytes at offset 1284096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1288192 ++read 2048/2048 bytes at offset 1288192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1292288 ++read 2048/2048 bytes at offset 1292288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1296384 ++read 2048/2048 bytes at offset 1296384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1300480 ++read 2048/2048 bytes at offset 1300480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1304576 ++read 2048/2048 bytes at offset 1304576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1308672 ++read 2048/2048 bytes at offset 1308672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1312768 ++read 2048/2048 bytes at offset 1312768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1316864 ++read 2048/2048 bytes at offset 1316864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1320960 ++read 2048/2048 bytes at offset 1320960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1325056 ++read 2048/2048 bytes at offset 1325056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1329152 ++read 2048/2048 bytes at offset 1329152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1333248 ++read 2048/2048 bytes at offset 1333248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1337344 ++read 2048/2048 bytes at offset 1337344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1341440 ++read 2048/2048 bytes at offset 1341440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1345536 ++read 2048/2048 bytes at offset 1345536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1349632 ++read 2048/2048 bytes at offset 1349632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1353728 ++read 2048/2048 bytes at offset 1353728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1357824 ++read 2048/2048 bytes at offset 1357824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1361920 ++read 2048/2048 bytes at offset 1361920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1366016 ++read 2048/2048 bytes at offset 1366016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1370112 ++read 2048/2048 bytes at offset 1370112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1374208 ++read 2048/2048 bytes at offset 1374208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1378304 ++read 2048/2048 bytes at offset 1378304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1382400 ++read 2048/2048 bytes at offset 1382400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1386496 ++read 2048/2048 bytes at offset 1386496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1390592 ++read 2048/2048 bytes at offset 1390592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1394688 ++read 2048/2048 bytes at offset 1394688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1398784 ++read 2048/2048 bytes at offset 1398784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1402880 ++read 2048/2048 bytes at offset 1402880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1406976 ++read 2048/2048 bytes at offset 1406976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1411072 ++read 2048/2048 bytes at offset 1411072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1415168 ++read 2048/2048 bytes at offset 1415168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1419264 ++read 2048/2048 bytes at offset 1419264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1423360 ++read 2048/2048 bytes at offset 1423360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1427456 ++read 2048/2048 bytes at offset 1427456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1431552 ++read 2048/2048 bytes at offset 1431552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1435648 ++read 2048/2048 bytes at offset 1435648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1439744 ++read 2048/2048 bytes at offset 1439744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1443840 ++read 2048/2048 bytes at offset 1443840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1447936 ++read 2048/2048 bytes at offset 1447936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1452032 ++read 2048/2048 bytes at offset 1452032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1456128 ++read 2048/2048 bytes at offset 1456128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1460224 ++read 2048/2048 bytes at offset 1460224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1464320 ++read 2048/2048 bytes at offset 1464320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1468416 ++read 2048/2048 bytes at offset 1468416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1472512 ++read 2048/2048 bytes at offset 1472512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1476608 ++read 2048/2048 bytes at offset 1476608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1480704 ++read 2048/2048 bytes at offset 1480704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1484800 ++read 2048/2048 bytes at offset 1484800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1488896 ++read 2048/2048 bytes at offset 1488896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1492992 ++read 2048/2048 bytes at offset 1492992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1497088 ++read 2048/2048 bytes at offset 1497088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1501184 ++read 2048/2048 bytes at offset 1501184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1505280 ++read 2048/2048 bytes at offset 1505280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1509376 ++read 2048/2048 bytes at offset 1509376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1513472 ++read 2048/2048 bytes at offset 1513472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1517568 ++read 2048/2048 bytes at offset 1517568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1521664 ++read 2048/2048 bytes at offset 1521664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1525760 ++read 2048/2048 bytes at offset 1525760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1529856 ++read 2048/2048 bytes at offset 1529856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1533952 ++read 2048/2048 bytes at offset 1533952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1538048 ++read 2048/2048 bytes at offset 1538048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1542144 ++read 2048/2048 bytes at offset 1542144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1546240 ++read 2048/2048 bytes at offset 1546240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1550336 ++read 2048/2048 bytes at offset 1550336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1554432 ++read 2048/2048 bytes at offset 1554432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1558528 ++read 2048/2048 bytes at offset 1558528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1562624 ++read 2048/2048 bytes at offset 1562624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1566720 ++read 2048/2048 bytes at offset 1566720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1570816 ++read 2048/2048 bytes at offset 1570816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1574912 ++read 2048/2048 bytes at offset 1574912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1579008 ++read 2048/2048 bytes at offset 1579008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1583104 ++read 2048/2048 bytes at offset 1583104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1587200 ++read 2048/2048 bytes at offset 1587200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1591296 ++read 2048/2048 bytes at offset 1591296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1595392 ++read 2048/2048 bytes at offset 1595392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1599488 ++read 2048/2048 bytes at offset 1599488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1603584 ++read 2048/2048 bytes at offset 1603584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1607680 ++read 2048/2048 bytes at offset 1607680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1611776 ++read 2048/2048 bytes at offset 1611776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1615872 ++read 2048/2048 bytes at offset 1615872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1619968 ++read 2048/2048 bytes at offset 1619968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1624064 ++read 2048/2048 bytes at offset 1624064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1628160 ++read 2048/2048 bytes at offset 1628160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1632256 ++read 2048/2048 bytes at offset 1632256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1636352 ++read 2048/2048 bytes at offset 1636352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1640448 ++read 2048/2048 bytes at offset 1640448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1644544 ++read 2048/2048 bytes at offset 1644544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1648640 ++read 2048/2048 bytes at offset 1648640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1652736 ++read 2048/2048 bytes at offset 1652736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1656832 ++read 2048/2048 bytes at offset 1656832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1660928 ++read 2048/2048 bytes at offset 1660928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1665024 ++read 2048/2048 bytes at offset 1665024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1669120 ++read 2048/2048 bytes at offset 1669120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1673216 ++read 2048/2048 bytes at offset 1673216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1677312 ++read 2048/2048 bytes at offset 1677312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1681408 ++read 2048/2048 bytes at offset 1681408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1685504 ++read 2048/2048 bytes at offset 1685504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1689600 ++read 2048/2048 bytes at offset 1689600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1693696 ++read 2048/2048 bytes at offset 1693696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1697792 ++read 2048/2048 bytes at offset 1697792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1701888 ++read 2048/2048 bytes at offset 1701888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1705984 ++read 2048/2048 bytes at offset 1705984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1710080 ++read 2048/2048 bytes at offset 1710080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1714176 ++read 2048/2048 bytes at offset 1714176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1718272 ++read 2048/2048 bytes at offset 1718272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1722368 ++read 2048/2048 bytes at offset 1722368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1726464 ++read 2048/2048 bytes at offset 1726464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1730560 ++read 2048/2048 bytes at offset 1730560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1734656 ++read 2048/2048 bytes at offset 1734656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1738752 ++read 2048/2048 bytes at offset 1738752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1742848 ++read 2048/2048 bytes at offset 1742848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1746944 ++read 2048/2048 bytes at offset 1746944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1751040 ++read 2048/2048 bytes at offset 1751040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1755136 ++read 2048/2048 bytes at offset 1755136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1759232 ++read 2048/2048 bytes at offset 1759232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1763328 ++read 2048/2048 bytes at offset 1763328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1767424 ++read 2048/2048 bytes at offset 1767424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1771520 ++read 2048/2048 bytes at offset 1771520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1775616 ++read 2048/2048 bytes at offset 1775616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1779712 ++read 2048/2048 bytes at offset 1779712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1783808 ++read 2048/2048 bytes at offset 1783808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1787904 ++read 2048/2048 bytes at offset 1787904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1792000 ++read 2048/2048 bytes at offset 1792000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1796096 ++read 2048/2048 bytes at offset 1796096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1800192 ++read 2048/2048 bytes at offset 1800192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1804288 ++read 2048/2048 bytes at offset 1804288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1808384 ++read 2048/2048 bytes at offset 1808384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1812480 ++read 2048/2048 bytes at offset 1812480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1816576 ++read 2048/2048 bytes at offset 1816576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1820672 ++read 2048/2048 bytes at offset 1820672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1824768 ++read 2048/2048 bytes at offset 1824768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1828864 ++read 2048/2048 bytes at offset 1828864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1832960 ++read 2048/2048 bytes at offset 1832960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1837056 ++read 2048/2048 bytes at offset 1837056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1841152 ++read 2048/2048 bytes at offset 1841152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1845248 ++read 2048/2048 bytes at offset 1845248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1849344 ++read 2048/2048 bytes at offset 1849344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1853440 ++read 2048/2048 bytes at offset 1853440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1857536 ++read 2048/2048 bytes at offset 1857536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1861632 ++read 2048/2048 bytes at offset 1861632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1865728 ++read 2048/2048 bytes at offset 1865728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1869824 ++read 2048/2048 bytes at offset 1869824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1873920 ++read 2048/2048 bytes at offset 1873920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1878016 ++read 2048/2048 bytes at offset 1878016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1882112 ++read 2048/2048 bytes at offset 1882112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1886208 ++read 2048/2048 bytes at offset 1886208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1890304 ++read 2048/2048 bytes at offset 1890304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1894400 ++read 2048/2048 bytes at offset 1894400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1898496 ++read 2048/2048 bytes at offset 1898496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1902592 ++read 2048/2048 bytes at offset 1902592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1906688 ++read 2048/2048 bytes at offset 1906688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1910784 ++read 2048/2048 bytes at offset 1910784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1914880 ++read 2048/2048 bytes at offset 1914880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1918976 ++read 2048/2048 bytes at offset 1918976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1923072 ++read 2048/2048 bytes at offset 1923072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1927168 ++read 2048/2048 bytes at offset 1927168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1931264 ++read 2048/2048 bytes at offset 1931264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1935360 ++read 2048/2048 bytes at offset 1935360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1939456 ++read 2048/2048 bytes at offset 1939456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1943552 ++read 2048/2048 bytes at offset 1943552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1947648 ++read 2048/2048 bytes at offset 1947648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1951744 ++read 2048/2048 bytes at offset 1951744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1955840 ++read 2048/2048 bytes at offset 1955840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1959936 ++read 2048/2048 bytes at offset 1959936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1964032 ++read 2048/2048 bytes at offset 1964032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1968128 ++read 2048/2048 bytes at offset 1968128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1972224 ++read 2048/2048 bytes at offset 1972224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1976320 ++read 2048/2048 bytes at offset 1976320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1980416 ++read 2048/2048 bytes at offset 1980416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1984512 ++read 2048/2048 bytes at offset 1984512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1988608 ++read 2048/2048 bytes at offset 1988608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1992704 ++read 2048/2048 bytes at offset 1992704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1996800 ++read 2048/2048 bytes at offset 1996800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2000896 ++read 2048/2048 bytes at offset 2000896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2004992 ++read 2048/2048 bytes at offset 2004992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2009088 ++read 2048/2048 bytes at offset 2009088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2013184 ++read 2048/2048 bytes at offset 2013184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2017280 ++read 2048/2048 bytes at offset 2017280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2021376 ++read 2048/2048 bytes at offset 2021376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2025472 ++read 2048/2048 bytes at offset 2025472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2029568 ++read 2048/2048 bytes at offset 2029568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2033664 ++read 2048/2048 bytes at offset 2033664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2037760 ++read 2048/2048 bytes at offset 2037760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2041856 ++read 2048/2048 bytes at offset 2041856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2045952 ++read 2048/2048 bytes at offset 2045952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2050048 ++read 2048/2048 bytes at offset 2050048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2054144 ++read 2048/2048 bytes at offset 2054144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2058240 ++read 2048/2048 bytes at offset 2058240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2062336 ++read 2048/2048 bytes at offset 2062336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2066432 ++read 2048/2048 bytes at offset 2066432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2070528 ++read 2048/2048 bytes at offset 2070528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2074624 ++read 2048/2048 bytes at offset 2074624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2078720 ++read 2048/2048 bytes at offset 2078720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2082816 ++read 2048/2048 bytes at offset 2082816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2086912 ++read 2048/2048 bytes at offset 2086912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2091008 ++read 2048/2048 bytes at offset 2091008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2095104 ++read 2048/2048 bytes at offset 2095104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> read 2048/2048 bytes at offset 2097152 ++=== IO: pattern 0 ++read 2048/2048 bytes at offset 2097152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2101248 ++read 2048/2048 bytes at offset 2101248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2105344 ++read 2048/2048 bytes at offset 2105344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2109440 ++read 2048/2048 bytes at offset 2109440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2113536 ++read 2048/2048 bytes at offset 2113536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2117632 ++read 2048/2048 bytes at offset 2117632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2121728 ++read 2048/2048 bytes at offset 2121728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2125824 ++read 2048/2048 bytes at offset 2125824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2129920 ++read 2048/2048 bytes at offset 2129920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2134016 ++read 2048/2048 bytes at offset 2134016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2138112 ++read 2048/2048 bytes at offset 2138112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2142208 ++read 2048/2048 bytes at offset 2142208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2146304 ++read 2048/2048 bytes at offset 2146304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2150400 ++read 2048/2048 bytes at offset 2150400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2154496 ++read 2048/2048 bytes at offset 2154496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2158592 ++read 2048/2048 bytes at offset 2158592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2162688 ++read 2048/2048 bytes at offset 2162688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2166784 ++read 2048/2048 bytes at offset 2166784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2170880 ++read 2048/2048 bytes at offset 2170880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2174976 ++read 2048/2048 bytes at offset 2174976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2179072 ++read 2048/2048 bytes at offset 2179072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2183168 ++read 2048/2048 bytes at offset 2183168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2187264 ++read 2048/2048 bytes at offset 2187264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2191360 ++read 2048/2048 bytes at offset 2191360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2195456 ++read 2048/2048 bytes at offset 2195456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2199552 ++read 2048/2048 bytes at offset 2199552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2203648 ++read 2048/2048 bytes at offset 2203648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2207744 ++read 2048/2048 bytes at offset 2207744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2211840 ++read 2048/2048 bytes at offset 2211840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2215936 ++read 2048/2048 bytes at offset 2215936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2220032 ++read 2048/2048 bytes at offset 2220032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2224128 ++read 2048/2048 bytes at offset 2224128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2228224 ++read 2048/2048 bytes at offset 2228224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2232320 ++read 2048/2048 bytes at offset 2232320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2236416 ++read 2048/2048 bytes at offset 2236416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2240512 ++read 2048/2048 bytes at offset 2240512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2244608 ++read 2048/2048 bytes at offset 2244608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2248704 ++read 2048/2048 bytes at offset 2248704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2252800 ++read 2048/2048 bytes at offset 2252800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2256896 ++read 2048/2048 bytes at offset 2256896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2260992 ++read 2048/2048 bytes at offset 2260992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2265088 ++read 2048/2048 bytes at offset 2265088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2269184 ++read 2048/2048 bytes at offset 2269184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2273280 ++read 2048/2048 bytes at offset 2273280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2277376 ++read 2048/2048 bytes at offset 2277376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2281472 ++read 2048/2048 bytes at offset 2281472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2285568 ++read 2048/2048 bytes at offset 2285568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2289664 ++read 2048/2048 bytes at offset 2289664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2293760 ++read 2048/2048 bytes at offset 2293760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2297856 ++read 2048/2048 bytes at offset 2297856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2301952 ++read 2048/2048 bytes at offset 2301952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2306048 ++read 2048/2048 bytes at offset 2306048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2310144 ++read 2048/2048 bytes at offset 2310144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2314240 ++read 2048/2048 bytes at offset 2314240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2318336 ++read 2048/2048 bytes at offset 2318336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2322432 ++read 2048/2048 bytes at offset 2322432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2326528 ++read 2048/2048 bytes at offset 2326528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2330624 ++read 2048/2048 bytes at offset 2330624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2334720 ++read 2048/2048 bytes at offset 2334720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2338816 ++read 2048/2048 bytes at offset 2338816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2342912 ++read 2048/2048 bytes at offset 2342912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2347008 ++read 2048/2048 bytes at offset 2347008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2351104 ++read 2048/2048 bytes at offset 2351104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2355200 ++read 2048/2048 bytes at offset 2355200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2359296 ++read 2048/2048 bytes at offset 2359296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2363392 ++read 2048/2048 bytes at offset 2363392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2367488 ++read 2048/2048 bytes at offset 2367488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2371584 ++read 2048/2048 bytes at offset 2371584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2375680 ++read 2048/2048 bytes at offset 2375680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2379776 ++read 2048/2048 bytes at offset 2379776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2383872 ++read 2048/2048 bytes at offset 2383872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2387968 ++read 2048/2048 bytes at offset 2387968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2392064 ++read 2048/2048 bytes at offset 2392064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2396160 ++read 2048/2048 bytes at offset 2396160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2400256 ++read 2048/2048 bytes at offset 2400256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2404352 ++read 2048/2048 bytes at offset 2404352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2408448 ++read 2048/2048 bytes at offset 2408448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2412544 ++read 2048/2048 bytes at offset 2412544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2416640 ++read 2048/2048 bytes at offset 2416640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2420736 ++read 2048/2048 bytes at offset 2420736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2424832 ++read 2048/2048 bytes at offset 2424832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2428928 ++read 2048/2048 bytes at offset 2428928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2433024 ++read 2048/2048 bytes at offset 2433024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2437120 ++read 2048/2048 bytes at offset 2437120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2441216 ++read 2048/2048 bytes at offset 2441216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2445312 ++read 2048/2048 bytes at offset 2445312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2449408 ++read 2048/2048 bytes at offset 2449408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2453504 ++read 2048/2048 bytes at offset 2453504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2457600 ++read 2048/2048 bytes at offset 2457600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2461696 ++read 2048/2048 bytes at offset 2461696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2465792 ++read 2048/2048 bytes at offset 2465792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2469888 ++read 2048/2048 bytes at offset 2469888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2473984 ++read 2048/2048 bytes at offset 2473984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2478080 ++read 2048/2048 bytes at offset 2478080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2482176 ++read 2048/2048 bytes at offset 2482176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2486272 ++read 2048/2048 bytes at offset 2486272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2490368 ++read 2048/2048 bytes at offset 2490368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2494464 ++read 2048/2048 bytes at offset 2494464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2498560 ++read 2048/2048 bytes at offset 2498560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2502656 ++read 2048/2048 bytes at offset 2502656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2506752 ++read 2048/2048 bytes at offset 2506752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2510848 ++read 2048/2048 bytes at offset 2510848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2514944 ++read 2048/2048 bytes at offset 2514944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2519040 ++read 2048/2048 bytes at offset 2519040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2523136 ++read 2048/2048 bytes at offset 2523136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2527232 ++read 2048/2048 bytes at offset 2527232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2531328 ++read 2048/2048 bytes at offset 2531328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2535424 ++read 2048/2048 bytes at offset 2535424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2539520 ++read 2048/2048 bytes at offset 2539520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2543616 ++read 2048/2048 bytes at offset 2543616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2547712 ++read 2048/2048 bytes at offset 2547712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2551808 ++read 2048/2048 bytes at offset 2551808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2555904 ++read 2048/2048 bytes at offset 2555904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2560000 ++read 2048/2048 bytes at offset 2560000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2564096 ++read 2048/2048 bytes at offset 2564096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2568192 ++read 2048/2048 bytes at offset 2568192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2572288 ++read 2048/2048 bytes at offset 2572288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2576384 ++read 2048/2048 bytes at offset 2576384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2580480 ++read 2048/2048 bytes at offset 2580480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2584576 ++read 2048/2048 bytes at offset 2584576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2588672 ++read 2048/2048 bytes at offset 2588672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2592768 ++read 2048/2048 bytes at offset 2592768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2596864 ++read 2048/2048 bytes at offset 2596864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2600960 ++read 2048/2048 bytes at offset 2600960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2605056 ++read 2048/2048 bytes at offset 2605056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2609152 ++read 2048/2048 bytes at offset 2609152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2613248 ++read 2048/2048 bytes at offset 2613248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2617344 ++read 2048/2048 bytes at offset 2617344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2621440 ++read 2048/2048 bytes at offset 2621440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2625536 ++read 2048/2048 bytes at offset 2625536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2629632 ++read 2048/2048 bytes at offset 2629632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2633728 ++read 2048/2048 bytes at offset 2633728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2637824 ++read 2048/2048 bytes at offset 2637824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2641920 ++read 2048/2048 bytes at offset 2641920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2646016 ++read 2048/2048 bytes at offset 2646016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2650112 ++read 2048/2048 bytes at offset 2650112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2654208 ++read 2048/2048 bytes at offset 2654208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2658304 ++read 2048/2048 bytes at offset 2658304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2662400 ++read 2048/2048 bytes at offset 2662400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2666496 ++read 2048/2048 bytes at offset 2666496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2670592 ++read 2048/2048 bytes at offset 2670592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2674688 ++read 2048/2048 bytes at offset 2674688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2678784 ++read 2048/2048 bytes at offset 2678784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2682880 ++read 2048/2048 bytes at offset 2682880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2686976 ++read 2048/2048 bytes at offset 2686976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2691072 ++read 2048/2048 bytes at offset 2691072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2695168 ++read 2048/2048 bytes at offset 2695168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2699264 ++read 2048/2048 bytes at offset 2699264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2703360 ++read 2048/2048 bytes at offset 2703360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2707456 ++read 2048/2048 bytes at offset 2707456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2711552 ++read 2048/2048 bytes at offset 2711552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2715648 ++read 2048/2048 bytes at offset 2715648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2719744 ++read 2048/2048 bytes at offset 2719744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2723840 ++read 2048/2048 bytes at offset 2723840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2727936 ++read 2048/2048 bytes at offset 2727936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2732032 ++read 2048/2048 bytes at offset 2732032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2736128 ++read 2048/2048 bytes at offset 2736128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2740224 ++read 2048/2048 bytes at offset 2740224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2744320 ++read 2048/2048 bytes at offset 2744320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2748416 ++read 2048/2048 bytes at offset 2748416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2752512 ++read 2048/2048 bytes at offset 2752512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2756608 ++read 2048/2048 bytes at offset 2756608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2760704 ++read 2048/2048 bytes at offset 2760704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2764800 ++read 2048/2048 bytes at offset 2764800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2768896 ++read 2048/2048 bytes at offset 2768896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2772992 ++read 2048/2048 bytes at offset 2772992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2777088 ++read 2048/2048 bytes at offset 2777088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2781184 ++read 2048/2048 bytes at offset 2781184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2785280 ++read 2048/2048 bytes at offset 2785280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2789376 ++read 2048/2048 bytes at offset 2789376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2793472 ++read 2048/2048 bytes at offset 2793472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2797568 ++read 2048/2048 bytes at offset 2797568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2801664 ++read 2048/2048 bytes at offset 2801664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2805760 ++read 2048/2048 bytes at offset 2805760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2809856 ++read 2048/2048 bytes at offset 2809856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2813952 ++read 2048/2048 bytes at offset 2813952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2818048 ++read 2048/2048 bytes at offset 2818048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2822144 ++read 2048/2048 bytes at offset 2822144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2826240 ++read 2048/2048 bytes at offset 2826240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2830336 ++read 2048/2048 bytes at offset 2830336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2834432 ++read 2048/2048 bytes at offset 2834432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2838528 ++read 2048/2048 bytes at offset 2838528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2842624 ++read 2048/2048 bytes at offset 2842624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2846720 ++read 2048/2048 bytes at offset 2846720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2850816 ++read 2048/2048 bytes at offset 2850816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2854912 ++read 2048/2048 bytes at offset 2854912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2859008 ++read 2048/2048 bytes at offset 2859008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2863104 ++read 2048/2048 bytes at offset 2863104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2867200 ++read 2048/2048 bytes at offset 2867200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2871296 ++read 2048/2048 bytes at offset 2871296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2875392 ++read 2048/2048 bytes at offset 2875392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2879488 ++read 2048/2048 bytes at offset 2879488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2883584 ++read 2048/2048 bytes at offset 2883584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2887680 ++read 2048/2048 bytes at offset 2887680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2891776 ++read 2048/2048 bytes at offset 2891776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2895872 ++read 2048/2048 bytes at offset 2895872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2899968 ++read 2048/2048 bytes at offset 2899968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2904064 ++read 2048/2048 bytes at offset 2904064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2908160 ++read 2048/2048 bytes at offset 2908160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2912256 ++read 2048/2048 bytes at offset 2912256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2916352 ++read 2048/2048 bytes at offset 2916352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2920448 ++read 2048/2048 bytes at offset 2920448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2924544 ++read 2048/2048 bytes at offset 2924544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2928640 ++read 2048/2048 bytes at offset 2928640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2932736 ++read 2048/2048 bytes at offset 2932736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2936832 ++read 2048/2048 bytes at offset 2936832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2940928 ++read 2048/2048 bytes at offset 2940928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2945024 ++read 2048/2048 bytes at offset 2945024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2949120 ++read 2048/2048 bytes at offset 2949120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2953216 ++read 2048/2048 bytes at offset 2953216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2957312 ++read 2048/2048 bytes at offset 2957312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2961408 ++read 2048/2048 bytes at offset 2961408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2965504 ++read 2048/2048 bytes at offset 2965504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2969600 ++read 2048/2048 bytes at offset 2969600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2973696 ++read 2048/2048 bytes at offset 2973696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2977792 ++read 2048/2048 bytes at offset 2977792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2981888 ++read 2048/2048 bytes at offset 2981888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2985984 ++read 2048/2048 bytes at offset 2985984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2990080 ++read 2048/2048 bytes at offset 2990080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2994176 ++read 2048/2048 bytes at offset 2994176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2998272 ++read 2048/2048 bytes at offset 2998272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3002368 ++read 2048/2048 bytes at offset 3002368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3006464 ++read 2048/2048 bytes at offset 3006464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3010560 ++read 2048/2048 bytes at offset 3010560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3014656 ++read 2048/2048 bytes at offset 3014656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3018752 ++read 2048/2048 bytes at offset 3018752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3022848 ++read 2048/2048 bytes at offset 3022848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3026944 ++read 2048/2048 bytes at offset 3026944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3031040 ++read 2048/2048 bytes at offset 3031040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3035136 ++read 2048/2048 bytes at offset 3035136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3039232 ++read 2048/2048 bytes at offset 3039232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3043328 ++read 2048/2048 bytes at offset 3043328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3047424 ++read 2048/2048 bytes at offset 3047424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3051520 ++read 2048/2048 bytes at offset 3051520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3055616 ++read 2048/2048 bytes at offset 3055616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3059712 ++read 2048/2048 bytes at offset 3059712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3063808 ++read 2048/2048 bytes at offset 3063808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3067904 ++read 2048/2048 bytes at offset 3067904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3072000 ++read 2048/2048 bytes at offset 3072000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3076096 ++read 2048/2048 bytes at offset 3076096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3080192 ++read 2048/2048 bytes at offset 3080192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3084288 ++read 2048/2048 bytes at offset 3084288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3088384 ++read 2048/2048 bytes at offset 3088384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3092480 ++read 2048/2048 bytes at offset 3092480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3096576 ++read 2048/2048 bytes at offset 3096576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3100672 ++read 2048/2048 bytes at offset 3100672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3104768 ++read 2048/2048 bytes at offset 3104768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3108864 ++read 2048/2048 bytes at offset 3108864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3112960 ++read 2048/2048 bytes at offset 3112960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3117056 ++read 2048/2048 bytes at offset 3117056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3121152 ++read 2048/2048 bytes at offset 3121152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3125248 ++read 2048/2048 bytes at offset 3125248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3129344 ++read 2048/2048 bytes at offset 3129344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3133440 ++read 2048/2048 bytes at offset 3133440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3137536 ++read 2048/2048 bytes at offset 3137536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3141632 ++read 2048/2048 bytes at offset 3141632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 2 +-qemu-io> read 2048/2048 bytes at offset 3146752 ++=== IO: pattern 2 ++read 2048/2048 bytes at offset 3146752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3150848 ++read 2048/2048 bytes at offset 3150848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3154944 ++read 2048/2048 bytes at offset 3154944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3159040 ++read 2048/2048 bytes at offset 3159040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3163136 ++read 2048/2048 bytes at offset 3163136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3167232 ++read 2048/2048 bytes at offset 3167232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3171328 ++read 2048/2048 bytes at offset 3171328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3175424 ++read 2048/2048 bytes at offset 3175424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3179520 ++read 2048/2048 bytes at offset 3179520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3183616 ++read 2048/2048 bytes at offset 3183616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3187712 ++read 2048/2048 bytes at offset 3187712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3191808 ++read 2048/2048 bytes at offset 3191808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3195904 ++read 2048/2048 bytes at offset 3195904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3200000 ++read 2048/2048 bytes at offset 3200000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3204096 ++read 2048/2048 bytes at offset 3204096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3208192 ++read 2048/2048 bytes at offset 3208192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3212288 ++read 2048/2048 bytes at offset 3212288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3216384 ++read 2048/2048 bytes at offset 3216384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3220480 ++read 2048/2048 bytes at offset 3220480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3224576 ++read 2048/2048 bytes at offset 3224576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3228672 ++read 2048/2048 bytes at offset 3228672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3232768 ++read 2048/2048 bytes at offset 3232768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3236864 ++read 2048/2048 bytes at offset 3236864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3240960 ++read 2048/2048 bytes at offset 3240960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3245056 ++read 2048/2048 bytes at offset 3245056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3249152 ++read 2048/2048 bytes at offset 3249152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3253248 ++read 2048/2048 bytes at offset 3253248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3257344 ++read 2048/2048 bytes at offset 3257344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3261440 ++read 2048/2048 bytes at offset 3261440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3265536 ++read 2048/2048 bytes at offset 3265536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3269632 ++read 2048/2048 bytes at offset 3269632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3273728 ++read 2048/2048 bytes at offset 3273728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3277824 ++read 2048/2048 bytes at offset 3277824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3281920 ++read 2048/2048 bytes at offset 3281920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3286016 ++read 2048/2048 bytes at offset 3286016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3290112 ++read 2048/2048 bytes at offset 3290112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3294208 ++read 2048/2048 bytes at offset 3294208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3298304 ++read 2048/2048 bytes at offset 3298304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3302400 ++read 2048/2048 bytes at offset 3302400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3306496 ++read 2048/2048 bytes at offset 3306496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3310592 ++read 2048/2048 bytes at offset 3310592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3314688 ++read 2048/2048 bytes at offset 3314688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3318784 ++read 2048/2048 bytes at offset 3318784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3322880 ++read 2048/2048 bytes at offset 3322880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3326976 ++read 2048/2048 bytes at offset 3326976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3331072 ++read 2048/2048 bytes at offset 3331072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3335168 ++read 2048/2048 bytes at offset 3335168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3339264 ++read 2048/2048 bytes at offset 3339264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3343360 ++read 2048/2048 bytes at offset 3343360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3347456 ++read 2048/2048 bytes at offset 3347456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3351552 ++read 2048/2048 bytes at offset 3351552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3355648 ++read 2048/2048 bytes at offset 3355648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3359744 ++read 2048/2048 bytes at offset 3359744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3363840 ++read 2048/2048 bytes at offset 3363840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3367936 ++read 2048/2048 bytes at offset 3367936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3372032 ++read 2048/2048 bytes at offset 3372032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3376128 ++read 2048/2048 bytes at offset 3376128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3380224 ++read 2048/2048 bytes at offset 3380224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3384320 ++read 2048/2048 bytes at offset 3384320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3388416 ++read 2048/2048 bytes at offset 3388416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3392512 ++read 2048/2048 bytes at offset 3392512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3396608 ++read 2048/2048 bytes at offset 3396608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3400704 ++read 2048/2048 bytes at offset 3400704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3404800 ++read 2048/2048 bytes at offset 3404800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3408896 ++read 2048/2048 bytes at offset 3408896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3412992 ++read 2048/2048 bytes at offset 3412992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3417088 ++read 2048/2048 bytes at offset 3417088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3421184 ++read 2048/2048 bytes at offset 3421184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3425280 ++read 2048/2048 bytes at offset 3425280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3429376 ++read 2048/2048 bytes at offset 3429376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3433472 ++read 2048/2048 bytes at offset 3433472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3437568 ++read 2048/2048 bytes at offset 3437568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3441664 ++read 2048/2048 bytes at offset 3441664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3445760 ++read 2048/2048 bytes at offset 3445760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3449856 ++read 2048/2048 bytes at offset 3449856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3453952 ++read 2048/2048 bytes at offset 3453952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3458048 ++read 2048/2048 bytes at offset 3458048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3462144 ++read 2048/2048 bytes at offset 3462144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3466240 ++read 2048/2048 bytes at offset 3466240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3470336 ++read 2048/2048 bytes at offset 3470336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3474432 ++read 2048/2048 bytes at offset 3474432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3478528 ++read 2048/2048 bytes at offset 3478528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3482624 ++read 2048/2048 bytes at offset 3482624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3486720 ++read 2048/2048 bytes at offset 3486720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3490816 ++read 2048/2048 bytes at offset 3490816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3494912 ++read 2048/2048 bytes at offset 3494912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3499008 ++read 2048/2048 bytes at offset 3499008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3503104 ++read 2048/2048 bytes at offset 3503104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3507200 ++read 2048/2048 bytes at offset 3507200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3511296 ++read 2048/2048 bytes at offset 3511296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3515392 ++read 2048/2048 bytes at offset 3515392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3519488 ++read 2048/2048 bytes at offset 3519488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3523584 ++read 2048/2048 bytes at offset 3523584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3527680 ++read 2048/2048 bytes at offset 3527680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3531776 ++read 2048/2048 bytes at offset 3531776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3535872 ++read 2048/2048 bytes at offset 3535872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3539968 ++read 2048/2048 bytes at offset 3539968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3544064 ++read 2048/2048 bytes at offset 3544064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3548160 ++read 2048/2048 bytes at offset 3548160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3552256 ++read 2048/2048 bytes at offset 3552256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3556352 ++read 2048/2048 bytes at offset 3556352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3560448 ++read 2048/2048 bytes at offset 3560448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3564544 ++read 2048/2048 bytes at offset 3564544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3568640 ++read 2048/2048 bytes at offset 3568640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3572736 ++read 2048/2048 bytes at offset 3572736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3576832 ++read 2048/2048 bytes at offset 3576832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3580928 ++read 2048/2048 bytes at offset 3580928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3585024 ++read 2048/2048 bytes at offset 3585024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3589120 ++read 2048/2048 bytes at offset 3589120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3593216 ++read 2048/2048 bytes at offset 3593216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3597312 ++read 2048/2048 bytes at offset 3597312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3601408 ++read 2048/2048 bytes at offset 3601408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3605504 ++read 2048/2048 bytes at offset 3605504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3609600 ++read 2048/2048 bytes at offset 3609600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3613696 ++read 2048/2048 bytes at offset 3613696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3617792 ++read 2048/2048 bytes at offset 3617792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3621888 ++read 2048/2048 bytes at offset 3621888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3625984 ++read 2048/2048 bytes at offset 3625984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3630080 ++read 2048/2048 bytes at offset 3630080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3634176 ++read 2048/2048 bytes at offset 3634176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3638272 ++read 2048/2048 bytes at offset 3638272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3642368 ++read 2048/2048 bytes at offset 3642368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3646464 ++read 2048/2048 bytes at offset 3646464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3650560 ++read 2048/2048 bytes at offset 3650560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3654656 ++read 2048/2048 bytes at offset 3654656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3658752 ++read 2048/2048 bytes at offset 3658752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3662848 ++read 2048/2048 bytes at offset 3662848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3666944 ++read 2048/2048 bytes at offset 3666944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3671040 ++read 2048/2048 bytes at offset 3671040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3675136 ++read 2048/2048 bytes at offset 3675136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3679232 ++read 2048/2048 bytes at offset 3679232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3683328 ++read 2048/2048 bytes at offset 3683328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3687424 ++read 2048/2048 bytes at offset 3687424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3691520 ++read 2048/2048 bytes at offset 3691520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3695616 ++read 2048/2048 bytes at offset 3695616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3699712 ++read 2048/2048 bytes at offset 3699712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3703808 ++read 2048/2048 bytes at offset 3703808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3707904 ++read 2048/2048 bytes at offset 3707904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3712000 ++read 2048/2048 bytes at offset 3712000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3716096 ++read 2048/2048 bytes at offset 3716096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3720192 ++read 2048/2048 bytes at offset 3720192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3724288 ++read 2048/2048 bytes at offset 3724288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3728384 ++read 2048/2048 bytes at offset 3728384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3732480 ++read 2048/2048 bytes at offset 3732480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3736576 ++read 2048/2048 bytes at offset 3736576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3740672 ++read 2048/2048 bytes at offset 3740672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3744768 ++read 2048/2048 bytes at offset 3744768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3748864 ++read 2048/2048 bytes at offset 3748864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3752960 ++read 2048/2048 bytes at offset 3752960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3757056 ++read 2048/2048 bytes at offset 3757056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3761152 ++read 2048/2048 bytes at offset 3761152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3765248 ++read 2048/2048 bytes at offset 3765248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3769344 ++read 2048/2048 bytes at offset 3769344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3773440 ++read 2048/2048 bytes at offset 3773440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3777536 ++read 2048/2048 bytes at offset 3777536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3781632 ++read 2048/2048 bytes at offset 3781632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3785728 ++read 2048/2048 bytes at offset 3785728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3789824 ++read 2048/2048 bytes at offset 3789824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3793920 ++read 2048/2048 bytes at offset 3793920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3798016 ++read 2048/2048 bytes at offset 3798016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3802112 ++read 2048/2048 bytes at offset 3802112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3806208 ++read 2048/2048 bytes at offset 3806208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3810304 ++read 2048/2048 bytes at offset 3810304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3814400 ++read 2048/2048 bytes at offset 3814400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3818496 ++read 2048/2048 bytes at offset 3818496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3822592 ++read 2048/2048 bytes at offset 3822592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3826688 ++read 2048/2048 bytes at offset 3826688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3830784 ++read 2048/2048 bytes at offset 3830784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3834880 ++read 2048/2048 bytes at offset 3834880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3838976 ++read 2048/2048 bytes at offset 3838976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3843072 ++read 2048/2048 bytes at offset 3843072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3847168 ++read 2048/2048 bytes at offset 3847168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3851264 ++read 2048/2048 bytes at offset 3851264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3855360 ++read 2048/2048 bytes at offset 3855360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3859456 ++read 2048/2048 bytes at offset 3859456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3863552 ++read 2048/2048 bytes at offset 3863552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3867648 ++read 2048/2048 bytes at offset 3867648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3871744 ++read 2048/2048 bytes at offset 3871744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3875840 ++read 2048/2048 bytes at offset 3875840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3879936 ++read 2048/2048 bytes at offset 3879936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3884032 ++read 2048/2048 bytes at offset 3884032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3888128 ++read 2048/2048 bytes at offset 3888128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3892224 ++read 2048/2048 bytes at offset 3892224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3896320 ++read 2048/2048 bytes at offset 3896320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3900416 ++read 2048/2048 bytes at offset 3900416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3904512 ++read 2048/2048 bytes at offset 3904512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3908608 ++read 2048/2048 bytes at offset 3908608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3912704 ++read 2048/2048 bytes at offset 3912704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3916800 ++read 2048/2048 bytes at offset 3916800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3920896 ++read 2048/2048 bytes at offset 3920896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3924992 ++read 2048/2048 bytes at offset 3924992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3929088 ++read 2048/2048 bytes at offset 3929088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3933184 ++read 2048/2048 bytes at offset 3933184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3937280 ++read 2048/2048 bytes at offset 3937280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3941376 ++read 2048/2048 bytes at offset 3941376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3945472 ++read 2048/2048 bytes at offset 3945472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3949568 ++read 2048/2048 bytes at offset 3949568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3953664 ++read 2048/2048 bytes at offset 3953664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3957760 ++read 2048/2048 bytes at offset 3957760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3961856 ++read 2048/2048 bytes at offset 3961856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3965952 ++read 2048/2048 bytes at offset 3965952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3970048 ++read 2048/2048 bytes at offset 3970048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3974144 ++read 2048/2048 bytes at offset 3974144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3978240 ++read 2048/2048 bytes at offset 3978240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3982336 ++read 2048/2048 bytes at offset 3982336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3986432 ++read 2048/2048 bytes at offset 3986432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3990528 ++read 2048/2048 bytes at offset 3990528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3994624 ++read 2048/2048 bytes at offset 3994624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3998720 ++read 2048/2048 bytes at offset 3998720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4002816 ++read 2048/2048 bytes at offset 4002816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4006912 ++read 2048/2048 bytes at offset 4006912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4011008 ++read 2048/2048 bytes at offset 4011008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4015104 ++read 2048/2048 bytes at offset 4015104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4019200 ++read 2048/2048 bytes at offset 4019200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4023296 ++read 2048/2048 bytes at offset 4023296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4027392 ++read 2048/2048 bytes at offset 4027392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4031488 ++read 2048/2048 bytes at offset 4031488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4035584 ++read 2048/2048 bytes at offset 4035584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4039680 ++read 2048/2048 bytes at offset 4039680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4043776 ++read 2048/2048 bytes at offset 4043776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4047872 ++read 2048/2048 bytes at offset 4047872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4051968 ++read 2048/2048 bytes at offset 4051968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4056064 ++read 2048/2048 bytes at offset 4056064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4060160 ++read 2048/2048 bytes at offset 4060160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4064256 ++read 2048/2048 bytes at offset 4064256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4068352 ++read 2048/2048 bytes at offset 4068352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4072448 ++read 2048/2048 bytes at offset 4072448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4076544 ++read 2048/2048 bytes at offset 4076544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4080640 ++read 2048/2048 bytes at offset 4080640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4084736 ++read 2048/2048 bytes at offset 4084736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4088832 ++read 2048/2048 bytes at offset 4088832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4092928 ++read 2048/2048 bytes at offset 4092928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4097024 ++read 2048/2048 bytes at offset 4097024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4101120 ++read 2048/2048 bytes at offset 4101120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4105216 ++read 2048/2048 bytes at offset 4105216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4109312 ++read 2048/2048 bytes at offset 4109312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4113408 ++read 2048/2048 bytes at offset 4113408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4117504 ++read 2048/2048 bytes at offset 4117504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4121600 ++read 2048/2048 bytes at offset 4121600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4125696 ++read 2048/2048 bytes at offset 4125696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4129792 ++read 2048/2048 bytes at offset 4129792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4133888 ++read 2048/2048 bytes at offset 4133888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4137984 ++read 2048/2048 bytes at offset 4137984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4142080 ++read 2048/2048 bytes at offset 4142080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4146176 ++read 2048/2048 bytes at offset 4146176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4150272 ++read 2048/2048 bytes at offset 4150272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4154368 ++read 2048/2048 bytes at offset 4154368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4158464 ++read 2048/2048 bytes at offset 4158464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4162560 ++read 2048/2048 bytes at offset 4162560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4166656 ++read 2048/2048 bytes at offset 4166656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4170752 ++read 2048/2048 bytes at offset 4170752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4174848 ++read 2048/2048 bytes at offset 4174848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4178944 ++read 2048/2048 bytes at offset 4178944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4183040 ++read 2048/2048 bytes at offset 4183040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4187136 ++read 2048/2048 bytes at offset 4187136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4191232 ++read 2048/2048 bytes at offset 4191232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 4 +-qemu-io> read 8192/8192 bytes at offset 4196352 ++=== IO: pattern 4 ++read 8192/8192 bytes at offset 4196352 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4208640 ++read 8192/8192 bytes at offset 4208640 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4220928 ++read 8192/8192 bytes at offset 4220928 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4233216 ++read 8192/8192 bytes at offset 4233216 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4245504 ++read 8192/8192 bytes at offset 4245504 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4257792 ++read 8192/8192 bytes at offset 4257792 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4270080 ++read 8192/8192 bytes at offset 4270080 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4282368 ++read 8192/8192 bytes at offset 4282368 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4294656 ++read 8192/8192 bytes at offset 4294656 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4306944 ++read 8192/8192 bytes at offset 4306944 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4319232 ++read 8192/8192 bytes at offset 4319232 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4331520 ++read 8192/8192 bytes at offset 4331520 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4343808 ++read 8192/8192 bytes at offset 4343808 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4356096 ++read 8192/8192 bytes at offset 4356096 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4368384 ++read 8192/8192 bytes at offset 4368384 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4380672 ++read 8192/8192 bytes at offset 4380672 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4392960 ++read 8192/8192 bytes at offset 4392960 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4405248 ++read 8192/8192 bytes at offset 4405248 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4417536 ++read 8192/8192 bytes at offset 4417536 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4429824 ++read 8192/8192 bytes at offset 4429824 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4442112 ++read 8192/8192 bytes at offset 4442112 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4454400 ++read 8192/8192 bytes at offset 4454400 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4466688 ++read 8192/8192 bytes at offset 4466688 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4478976 ++read 8192/8192 bytes at offset 4478976 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4491264 ++read 8192/8192 bytes at offset 4491264 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4503552 ++read 8192/8192 bytes at offset 4503552 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4515840 ++read 8192/8192 bytes at offset 4515840 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4528128 ++read 8192/8192 bytes at offset 4528128 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4540416 ++read 8192/8192 bytes at offset 4540416 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4552704 ++read 8192/8192 bytes at offset 4552704 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4564992 ++read 8192/8192 bytes at offset 4564992 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4577280 ++read 8192/8192 bytes at offset 4577280 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4589568 ++read 8192/8192 bytes at offset 4589568 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4601856 ++read 8192/8192 bytes at offset 4601856 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4614144 ++read 8192/8192 bytes at offset 4614144 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4626432 ++read 8192/8192 bytes at offset 4626432 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4638720 ++read 8192/8192 bytes at offset 4638720 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4651008 ++read 8192/8192 bytes at offset 4651008 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4663296 ++read 8192/8192 bytes at offset 4663296 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4675584 ++read 8192/8192 bytes at offset 4675584 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4687872 ++read 8192/8192 bytes at offset 4687872 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4700160 ++read 8192/8192 bytes at offset 4700160 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4712448 ++read 8192/8192 bytes at offset 4712448 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4724736 ++read 8192/8192 bytes at offset 4724736 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4737024 ++read 8192/8192 bytes at offset 4737024 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4749312 ++read 8192/8192 bytes at offset 4749312 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4761600 ++read 8192/8192 bytes at offset 4761600 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4773888 ++read 8192/8192 bytes at offset 4773888 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4786176 ++read 8192/8192 bytes at offset 4786176 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4798464 ++read 8192/8192 bytes at offset 4798464 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4810752 ++read 8192/8192 bytes at offset 4810752 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4823040 ++read 8192/8192 bytes at offset 4823040 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4835328 ++read 8192/8192 bytes at offset 4835328 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4847616 ++read 8192/8192 bytes at offset 4847616 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4859904 ++read 8192/8192 bytes at offset 4859904 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4872192 ++read 8192/8192 bytes at offset 4872192 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4884480 ++read 8192/8192 bytes at offset 4884480 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4896768 ++read 8192/8192 bytes at offset 4896768 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4909056 ++read 8192/8192 bytes at offset 4909056 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4921344 ++read 8192/8192 bytes at offset 4921344 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4933632 ++read 8192/8192 bytes at offset 4933632 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4945920 ++read 8192/8192 bytes at offset 4945920 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4958208 ++read 8192/8192 bytes at offset 4958208 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4970496 ++read 8192/8192 bytes at offset 4970496 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 244 +-qemu-io> read 12288/12288 bytes at offset 6285312 ++=== IO: pattern 244 ++read 12288/12288 bytes at offset 6285312 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 8384512 ++read 12288/12288 bytes at offset 8384512 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 10483712 ++read 12288/12288 bytes at offset 10483712 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 12582912 ++read 12288/12288 bytes at offset 12582912 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 14682112 ++read 12288/12288 bytes at offset 14682112 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 16781312 ++read 12288/12288 bytes at offset 16781312 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 18880512 ++read 12288/12288 bytes at offset 18880512 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 20979712 ++read 12288/12288 bytes at offset 20979712 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> wrote 4096/4096 bytes at offset 0 ++=== IO: pattern 0 ++wrote 4096/4096 bytes at offset 0 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4096 ++wrote 4096/4096 bytes at offset 4096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8192 ++wrote 4096/4096 bytes at offset 8192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 12288 ++wrote 4096/4096 bytes at offset 12288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 16384 ++wrote 4096/4096 bytes at offset 16384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 20480 ++wrote 4096/4096 bytes at offset 20480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 24576 ++wrote 4096/4096 bytes at offset 24576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 28672 ++wrote 4096/4096 bytes at offset 28672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 32768 ++wrote 4096/4096 bytes at offset 32768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 36864 ++wrote 4096/4096 bytes at offset 36864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 40960 ++wrote 4096/4096 bytes at offset 40960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 45056 ++wrote 4096/4096 bytes at offset 45056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 49152 ++wrote 4096/4096 bytes at offset 49152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 53248 ++wrote 4096/4096 bytes at offset 53248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 57344 ++wrote 4096/4096 bytes at offset 57344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 61440 ++wrote 4096/4096 bytes at offset 61440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 65536 ++wrote 4096/4096 bytes at offset 65536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 69632 ++wrote 4096/4096 bytes at offset 69632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 73728 ++wrote 4096/4096 bytes at offset 73728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 77824 ++wrote 4096/4096 bytes at offset 77824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 81920 ++wrote 4096/4096 bytes at offset 81920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 86016 ++wrote 4096/4096 bytes at offset 86016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 90112 ++wrote 4096/4096 bytes at offset 90112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 94208 ++wrote 4096/4096 bytes at offset 94208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 98304 ++wrote 4096/4096 bytes at offset 98304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 102400 ++wrote 4096/4096 bytes at offset 102400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 106496 ++wrote 4096/4096 bytes at offset 106496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 110592 ++wrote 4096/4096 bytes at offset 110592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 114688 ++wrote 4096/4096 bytes at offset 114688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 118784 ++wrote 4096/4096 bytes at offset 118784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 122880 ++wrote 4096/4096 bytes at offset 122880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 126976 ++wrote 4096/4096 bytes at offset 126976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 131072 ++wrote 4096/4096 bytes at offset 131072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 135168 ++wrote 4096/4096 bytes at offset 135168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 139264 ++wrote 4096/4096 bytes at offset 139264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 143360 ++wrote 4096/4096 bytes at offset 143360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 147456 ++wrote 4096/4096 bytes at offset 147456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 151552 ++wrote 4096/4096 bytes at offset 151552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 155648 ++wrote 4096/4096 bytes at offset 155648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 159744 ++wrote 4096/4096 bytes at offset 159744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 163840 ++wrote 4096/4096 bytes at offset 163840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 167936 ++wrote 4096/4096 bytes at offset 167936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 172032 ++wrote 4096/4096 bytes at offset 172032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 176128 ++wrote 4096/4096 bytes at offset 176128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 180224 ++wrote 4096/4096 bytes at offset 180224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 184320 ++wrote 4096/4096 bytes at offset 184320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 188416 ++wrote 4096/4096 bytes at offset 188416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 192512 ++wrote 4096/4096 bytes at offset 192512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 196608 ++wrote 4096/4096 bytes at offset 196608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 200704 ++wrote 4096/4096 bytes at offset 200704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 204800 ++wrote 4096/4096 bytes at offset 204800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 208896 ++wrote 4096/4096 bytes at offset 208896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 212992 ++wrote 4096/4096 bytes at offset 212992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 217088 ++wrote 4096/4096 bytes at offset 217088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 221184 ++wrote 4096/4096 bytes at offset 221184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 225280 ++wrote 4096/4096 bytes at offset 225280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 229376 ++wrote 4096/4096 bytes at offset 229376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 233472 ++wrote 4096/4096 bytes at offset 233472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 237568 ++wrote 4096/4096 bytes at offset 237568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 241664 ++wrote 4096/4096 bytes at offset 241664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 245760 ++wrote 4096/4096 bytes at offset 245760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 249856 ++wrote 4096/4096 bytes at offset 249856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 253952 ++wrote 4096/4096 bytes at offset 253952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 258048 ++wrote 4096/4096 bytes at offset 258048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 262144 ++wrote 4096/4096 bytes at offset 262144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 266240 ++wrote 4096/4096 bytes at offset 266240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 270336 ++wrote 4096/4096 bytes at offset 270336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 274432 ++wrote 4096/4096 bytes at offset 274432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 278528 ++wrote 4096/4096 bytes at offset 278528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 282624 ++wrote 4096/4096 bytes at offset 282624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 286720 ++wrote 4096/4096 bytes at offset 286720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 290816 ++wrote 4096/4096 bytes at offset 290816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 294912 ++wrote 4096/4096 bytes at offset 294912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 299008 ++wrote 4096/4096 bytes at offset 299008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 303104 ++wrote 4096/4096 bytes at offset 303104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 307200 ++wrote 4096/4096 bytes at offset 307200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 311296 ++wrote 4096/4096 bytes at offset 311296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 315392 ++wrote 4096/4096 bytes at offset 315392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 319488 ++wrote 4096/4096 bytes at offset 319488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 323584 ++wrote 4096/4096 bytes at offset 323584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 327680 ++wrote 4096/4096 bytes at offset 327680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 331776 ++wrote 4096/4096 bytes at offset 331776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 335872 ++wrote 4096/4096 bytes at offset 335872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 339968 ++wrote 4096/4096 bytes at offset 339968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 344064 ++wrote 4096/4096 bytes at offset 344064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 348160 ++wrote 4096/4096 bytes at offset 348160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 352256 ++wrote 4096/4096 bytes at offset 352256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 356352 ++wrote 4096/4096 bytes at offset 356352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 360448 ++wrote 4096/4096 bytes at offset 360448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 364544 ++wrote 4096/4096 bytes at offset 364544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 368640 ++wrote 4096/4096 bytes at offset 368640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 372736 ++wrote 4096/4096 bytes at offset 372736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 376832 ++wrote 4096/4096 bytes at offset 376832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 380928 ++wrote 4096/4096 bytes at offset 380928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 385024 ++wrote 4096/4096 bytes at offset 385024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 389120 ++wrote 4096/4096 bytes at offset 389120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 393216 ++wrote 4096/4096 bytes at offset 393216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 397312 ++wrote 4096/4096 bytes at offset 397312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 401408 ++wrote 4096/4096 bytes at offset 401408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 405504 ++wrote 4096/4096 bytes at offset 405504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 409600 ++wrote 4096/4096 bytes at offset 409600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 413696 ++wrote 4096/4096 bytes at offset 413696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 417792 ++wrote 4096/4096 bytes at offset 417792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 421888 ++wrote 4096/4096 bytes at offset 421888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 425984 ++wrote 4096/4096 bytes at offset 425984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 430080 ++wrote 4096/4096 bytes at offset 430080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 434176 ++wrote 4096/4096 bytes at offset 434176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 438272 ++wrote 4096/4096 bytes at offset 438272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 442368 ++wrote 4096/4096 bytes at offset 442368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 446464 ++wrote 4096/4096 bytes at offset 446464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 450560 ++wrote 4096/4096 bytes at offset 450560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 454656 ++wrote 4096/4096 bytes at offset 454656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 458752 ++wrote 4096/4096 bytes at offset 458752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 462848 ++wrote 4096/4096 bytes at offset 462848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 466944 ++wrote 4096/4096 bytes at offset 466944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 471040 ++wrote 4096/4096 bytes at offset 471040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 475136 ++wrote 4096/4096 bytes at offset 475136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 479232 ++wrote 4096/4096 bytes at offset 479232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 483328 ++wrote 4096/4096 bytes at offset 483328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 487424 ++wrote 4096/4096 bytes at offset 487424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 491520 ++wrote 4096/4096 bytes at offset 491520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 495616 ++wrote 4096/4096 bytes at offset 495616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 499712 ++wrote 4096/4096 bytes at offset 499712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 503808 ++wrote 4096/4096 bytes at offset 503808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 507904 ++wrote 4096/4096 bytes at offset 507904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 512000 ++wrote 4096/4096 bytes at offset 512000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 516096 ++wrote 4096/4096 bytes at offset 516096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 520192 ++wrote 4096/4096 bytes at offset 520192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 524288 ++wrote 4096/4096 bytes at offset 524288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 528384 ++wrote 4096/4096 bytes at offset 528384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 532480 ++wrote 4096/4096 bytes at offset 532480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 536576 ++wrote 4096/4096 bytes at offset 536576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 540672 ++wrote 4096/4096 bytes at offset 540672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 544768 ++wrote 4096/4096 bytes at offset 544768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 548864 ++wrote 4096/4096 bytes at offset 548864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 552960 ++wrote 4096/4096 bytes at offset 552960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 557056 ++wrote 4096/4096 bytes at offset 557056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 561152 ++wrote 4096/4096 bytes at offset 561152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 565248 ++wrote 4096/4096 bytes at offset 565248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 569344 ++wrote 4096/4096 bytes at offset 569344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 573440 ++wrote 4096/4096 bytes at offset 573440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 577536 ++wrote 4096/4096 bytes at offset 577536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 581632 ++wrote 4096/4096 bytes at offset 581632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 585728 ++wrote 4096/4096 bytes at offset 585728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 589824 ++wrote 4096/4096 bytes at offset 589824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 593920 ++wrote 4096/4096 bytes at offset 593920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 598016 ++wrote 4096/4096 bytes at offset 598016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 602112 ++wrote 4096/4096 bytes at offset 602112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 606208 ++wrote 4096/4096 bytes at offset 606208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 610304 ++wrote 4096/4096 bytes at offset 610304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 614400 ++wrote 4096/4096 bytes at offset 614400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 618496 ++wrote 4096/4096 bytes at offset 618496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 622592 ++wrote 4096/4096 bytes at offset 622592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 626688 ++wrote 4096/4096 bytes at offset 626688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 630784 ++wrote 4096/4096 bytes at offset 630784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 634880 ++wrote 4096/4096 bytes at offset 634880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 638976 ++wrote 4096/4096 bytes at offset 638976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 643072 ++wrote 4096/4096 bytes at offset 643072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 647168 ++wrote 4096/4096 bytes at offset 647168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 651264 ++wrote 4096/4096 bytes at offset 651264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 655360 ++wrote 4096/4096 bytes at offset 655360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 659456 ++wrote 4096/4096 bytes at offset 659456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 663552 ++wrote 4096/4096 bytes at offset 663552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 667648 ++wrote 4096/4096 bytes at offset 667648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 671744 ++wrote 4096/4096 bytes at offset 671744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 675840 ++wrote 4096/4096 bytes at offset 675840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 679936 ++wrote 4096/4096 bytes at offset 679936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 684032 ++wrote 4096/4096 bytes at offset 684032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 688128 ++wrote 4096/4096 bytes at offset 688128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 692224 ++wrote 4096/4096 bytes at offset 692224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 696320 ++wrote 4096/4096 bytes at offset 696320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 700416 ++wrote 4096/4096 bytes at offset 700416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 704512 ++wrote 4096/4096 bytes at offset 704512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 708608 ++wrote 4096/4096 bytes at offset 708608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 712704 ++wrote 4096/4096 bytes at offset 712704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 716800 ++wrote 4096/4096 bytes at offset 716800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 720896 ++wrote 4096/4096 bytes at offset 720896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 724992 ++wrote 4096/4096 bytes at offset 724992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 729088 ++wrote 4096/4096 bytes at offset 729088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 733184 ++wrote 4096/4096 bytes at offset 733184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 737280 ++wrote 4096/4096 bytes at offset 737280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 741376 ++wrote 4096/4096 bytes at offset 741376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 745472 ++wrote 4096/4096 bytes at offset 745472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 749568 ++wrote 4096/4096 bytes at offset 749568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 753664 ++wrote 4096/4096 bytes at offset 753664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 757760 ++wrote 4096/4096 bytes at offset 757760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 761856 ++wrote 4096/4096 bytes at offset 761856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 765952 ++wrote 4096/4096 bytes at offset 765952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 770048 ++wrote 4096/4096 bytes at offset 770048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 774144 ++wrote 4096/4096 bytes at offset 774144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 778240 ++wrote 4096/4096 bytes at offset 778240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 782336 ++wrote 4096/4096 bytes at offset 782336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 786432 ++wrote 4096/4096 bytes at offset 786432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 790528 ++wrote 4096/4096 bytes at offset 790528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 794624 ++wrote 4096/4096 bytes at offset 794624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 798720 ++wrote 4096/4096 bytes at offset 798720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 802816 ++wrote 4096/4096 bytes at offset 802816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 806912 ++wrote 4096/4096 bytes at offset 806912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 811008 ++wrote 4096/4096 bytes at offset 811008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 815104 ++wrote 4096/4096 bytes at offset 815104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 819200 ++wrote 4096/4096 bytes at offset 819200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 823296 ++wrote 4096/4096 bytes at offset 823296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 827392 ++wrote 4096/4096 bytes at offset 827392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 831488 ++wrote 4096/4096 bytes at offset 831488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 835584 ++wrote 4096/4096 bytes at offset 835584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 839680 ++wrote 4096/4096 bytes at offset 839680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 843776 ++wrote 4096/4096 bytes at offset 843776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 847872 ++wrote 4096/4096 bytes at offset 847872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 851968 ++wrote 4096/4096 bytes at offset 851968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 856064 ++wrote 4096/4096 bytes at offset 856064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 860160 ++wrote 4096/4096 bytes at offset 860160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 864256 ++wrote 4096/4096 bytes at offset 864256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 868352 ++wrote 4096/4096 bytes at offset 868352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 872448 ++wrote 4096/4096 bytes at offset 872448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 876544 ++wrote 4096/4096 bytes at offset 876544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 880640 ++wrote 4096/4096 bytes at offset 880640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 884736 ++wrote 4096/4096 bytes at offset 884736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 888832 ++wrote 4096/4096 bytes at offset 888832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 892928 ++wrote 4096/4096 bytes at offset 892928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 897024 ++wrote 4096/4096 bytes at offset 897024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 901120 ++wrote 4096/4096 bytes at offset 901120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 905216 ++wrote 4096/4096 bytes at offset 905216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 909312 ++wrote 4096/4096 bytes at offset 909312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 913408 ++wrote 4096/4096 bytes at offset 913408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 917504 ++wrote 4096/4096 bytes at offset 917504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 921600 ++wrote 4096/4096 bytes at offset 921600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 925696 ++wrote 4096/4096 bytes at offset 925696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 929792 ++wrote 4096/4096 bytes at offset 929792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 933888 ++wrote 4096/4096 bytes at offset 933888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 937984 ++wrote 4096/4096 bytes at offset 937984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 942080 ++wrote 4096/4096 bytes at offset 942080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 946176 ++wrote 4096/4096 bytes at offset 946176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 950272 ++wrote 4096/4096 bytes at offset 950272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 954368 ++wrote 4096/4096 bytes at offset 954368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 958464 ++wrote 4096/4096 bytes at offset 958464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 962560 ++wrote 4096/4096 bytes at offset 962560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 966656 ++wrote 4096/4096 bytes at offset 966656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 970752 ++wrote 4096/4096 bytes at offset 970752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 974848 ++wrote 4096/4096 bytes at offset 974848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 978944 ++wrote 4096/4096 bytes at offset 978944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 983040 ++wrote 4096/4096 bytes at offset 983040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 987136 ++wrote 4096/4096 bytes at offset 987136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 991232 ++wrote 4096/4096 bytes at offset 991232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 995328 ++wrote 4096/4096 bytes at offset 995328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 999424 ++wrote 4096/4096 bytes at offset 999424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1003520 ++wrote 4096/4096 bytes at offset 1003520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1007616 ++wrote 4096/4096 bytes at offset 1007616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1011712 ++wrote 4096/4096 bytes at offset 1011712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1015808 ++wrote 4096/4096 bytes at offset 1015808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1019904 ++wrote 4096/4096 bytes at offset 1019904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1024000 ++wrote 4096/4096 bytes at offset 1024000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1028096 ++wrote 4096/4096 bytes at offset 1028096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1032192 ++wrote 4096/4096 bytes at offset 1032192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1036288 ++wrote 4096/4096 bytes at offset 1036288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1040384 ++wrote 4096/4096 bytes at offset 1040384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1044480 ++wrote 4096/4096 bytes at offset 1044480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 4 +-qemu-io> wrote 2048/2048 bytes at offset 1050624 ++=== IO: pattern 4 ++wrote 2048/2048 bytes at offset 1050624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1054720 ++wrote 2048/2048 bytes at offset 1054720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1058816 ++wrote 2048/2048 bytes at offset 1058816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1062912 ++wrote 2048/2048 bytes at offset 1062912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1067008 ++wrote 2048/2048 bytes at offset 1067008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1071104 ++wrote 2048/2048 bytes at offset 1071104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1075200 ++wrote 2048/2048 bytes at offset 1075200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1079296 ++wrote 2048/2048 bytes at offset 1079296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1083392 ++wrote 2048/2048 bytes at offset 1083392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1087488 ++wrote 2048/2048 bytes at offset 1087488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1091584 ++wrote 2048/2048 bytes at offset 1091584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1095680 ++wrote 2048/2048 bytes at offset 1095680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1099776 ++wrote 2048/2048 bytes at offset 1099776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1103872 ++wrote 2048/2048 bytes at offset 1103872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1107968 ++wrote 2048/2048 bytes at offset 1107968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1112064 ++wrote 2048/2048 bytes at offset 1112064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1116160 ++wrote 2048/2048 bytes at offset 1116160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1120256 ++wrote 2048/2048 bytes at offset 1120256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1124352 ++wrote 2048/2048 bytes at offset 1124352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1128448 ++wrote 2048/2048 bytes at offset 1128448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1132544 ++wrote 2048/2048 bytes at offset 1132544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1136640 ++wrote 2048/2048 bytes at offset 1136640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1140736 ++wrote 2048/2048 bytes at offset 1140736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1144832 ++wrote 2048/2048 bytes at offset 1144832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1148928 ++wrote 2048/2048 bytes at offset 1148928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1153024 ++wrote 2048/2048 bytes at offset 1153024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1157120 ++wrote 2048/2048 bytes at offset 1157120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1161216 ++wrote 2048/2048 bytes at offset 1161216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1165312 ++wrote 2048/2048 bytes at offset 1165312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1169408 ++wrote 2048/2048 bytes at offset 1169408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1173504 ++wrote 2048/2048 bytes at offset 1173504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1177600 ++wrote 2048/2048 bytes at offset 1177600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1181696 ++wrote 2048/2048 bytes at offset 1181696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1185792 ++wrote 2048/2048 bytes at offset 1185792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1189888 ++wrote 2048/2048 bytes at offset 1189888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1193984 ++wrote 2048/2048 bytes at offset 1193984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1198080 ++wrote 2048/2048 bytes at offset 1198080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1202176 ++wrote 2048/2048 bytes at offset 1202176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1206272 ++wrote 2048/2048 bytes at offset 1206272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1210368 ++wrote 2048/2048 bytes at offset 1210368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1214464 ++wrote 2048/2048 bytes at offset 1214464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1218560 ++wrote 2048/2048 bytes at offset 1218560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1222656 ++wrote 2048/2048 bytes at offset 1222656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1226752 ++wrote 2048/2048 bytes at offset 1226752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1230848 ++wrote 2048/2048 bytes at offset 1230848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1234944 ++wrote 2048/2048 bytes at offset 1234944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1239040 ++wrote 2048/2048 bytes at offset 1239040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1243136 ++wrote 2048/2048 bytes at offset 1243136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1247232 ++wrote 2048/2048 bytes at offset 1247232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1251328 ++wrote 2048/2048 bytes at offset 1251328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1255424 ++wrote 2048/2048 bytes at offset 1255424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1259520 ++wrote 2048/2048 bytes at offset 1259520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1263616 ++wrote 2048/2048 bytes at offset 1263616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1267712 ++wrote 2048/2048 bytes at offset 1267712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1271808 ++wrote 2048/2048 bytes at offset 1271808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1275904 ++wrote 2048/2048 bytes at offset 1275904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1280000 ++wrote 2048/2048 bytes at offset 1280000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1284096 ++wrote 2048/2048 bytes at offset 1284096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1288192 ++wrote 2048/2048 bytes at offset 1288192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1292288 ++wrote 2048/2048 bytes at offset 1292288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1296384 ++wrote 2048/2048 bytes at offset 1296384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1300480 ++wrote 2048/2048 bytes at offset 1300480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1304576 ++wrote 2048/2048 bytes at offset 1304576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1308672 ++wrote 2048/2048 bytes at offset 1308672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1312768 ++wrote 2048/2048 bytes at offset 1312768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1316864 ++wrote 2048/2048 bytes at offset 1316864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1320960 ++wrote 2048/2048 bytes at offset 1320960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1325056 ++wrote 2048/2048 bytes at offset 1325056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1329152 ++wrote 2048/2048 bytes at offset 1329152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1333248 ++wrote 2048/2048 bytes at offset 1333248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1337344 ++wrote 2048/2048 bytes at offset 1337344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1341440 ++wrote 2048/2048 bytes at offset 1341440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1345536 ++wrote 2048/2048 bytes at offset 1345536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1349632 ++wrote 2048/2048 bytes at offset 1349632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1353728 ++wrote 2048/2048 bytes at offset 1353728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1357824 ++wrote 2048/2048 bytes at offset 1357824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1361920 ++wrote 2048/2048 bytes at offset 1361920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1366016 ++wrote 2048/2048 bytes at offset 1366016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1370112 ++wrote 2048/2048 bytes at offset 1370112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1374208 ++wrote 2048/2048 bytes at offset 1374208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1378304 ++wrote 2048/2048 bytes at offset 1378304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1382400 ++wrote 2048/2048 bytes at offset 1382400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1386496 ++wrote 2048/2048 bytes at offset 1386496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1390592 ++wrote 2048/2048 bytes at offset 1390592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1394688 ++wrote 2048/2048 bytes at offset 1394688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1398784 ++wrote 2048/2048 bytes at offset 1398784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1402880 ++wrote 2048/2048 bytes at offset 1402880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1406976 ++wrote 2048/2048 bytes at offset 1406976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1411072 ++wrote 2048/2048 bytes at offset 1411072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1415168 ++wrote 2048/2048 bytes at offset 1415168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1419264 ++wrote 2048/2048 bytes at offset 1419264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1423360 ++wrote 2048/2048 bytes at offset 1423360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1427456 ++wrote 2048/2048 bytes at offset 1427456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1431552 ++wrote 2048/2048 bytes at offset 1431552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1435648 ++wrote 2048/2048 bytes at offset 1435648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1439744 ++wrote 2048/2048 bytes at offset 1439744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1443840 ++wrote 2048/2048 bytes at offset 1443840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1447936 ++wrote 2048/2048 bytes at offset 1447936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1452032 ++wrote 2048/2048 bytes at offset 1452032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1456128 ++wrote 2048/2048 bytes at offset 1456128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1460224 ++wrote 2048/2048 bytes at offset 1460224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1464320 ++wrote 2048/2048 bytes at offset 1464320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1468416 ++wrote 2048/2048 bytes at offset 1468416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1472512 ++wrote 2048/2048 bytes at offset 1472512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1476608 ++wrote 2048/2048 bytes at offset 1476608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1480704 ++wrote 2048/2048 bytes at offset 1480704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1484800 ++wrote 2048/2048 bytes at offset 1484800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1488896 ++wrote 2048/2048 bytes at offset 1488896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1492992 ++wrote 2048/2048 bytes at offset 1492992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1497088 ++wrote 2048/2048 bytes at offset 1497088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1501184 ++wrote 2048/2048 bytes at offset 1501184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1505280 ++wrote 2048/2048 bytes at offset 1505280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1509376 ++wrote 2048/2048 bytes at offset 1509376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1513472 ++wrote 2048/2048 bytes at offset 1513472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1517568 ++wrote 2048/2048 bytes at offset 1517568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1521664 ++wrote 2048/2048 bytes at offset 1521664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1525760 ++wrote 2048/2048 bytes at offset 1525760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1529856 ++wrote 2048/2048 bytes at offset 1529856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1533952 ++wrote 2048/2048 bytes at offset 1533952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1538048 ++wrote 2048/2048 bytes at offset 1538048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1542144 ++wrote 2048/2048 bytes at offset 1542144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1546240 ++wrote 2048/2048 bytes at offset 1546240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1550336 ++wrote 2048/2048 bytes at offset 1550336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1554432 ++wrote 2048/2048 bytes at offset 1554432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1558528 ++wrote 2048/2048 bytes at offset 1558528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1562624 ++wrote 2048/2048 bytes at offset 1562624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1566720 ++wrote 2048/2048 bytes at offset 1566720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1570816 ++wrote 2048/2048 bytes at offset 1570816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1574912 ++wrote 2048/2048 bytes at offset 1574912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1579008 ++wrote 2048/2048 bytes at offset 1579008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1583104 ++wrote 2048/2048 bytes at offset 1583104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1587200 ++wrote 2048/2048 bytes at offset 1587200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1591296 ++wrote 2048/2048 bytes at offset 1591296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1595392 ++wrote 2048/2048 bytes at offset 1595392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1599488 ++wrote 2048/2048 bytes at offset 1599488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1603584 ++wrote 2048/2048 bytes at offset 1603584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1607680 ++wrote 2048/2048 bytes at offset 1607680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1611776 ++wrote 2048/2048 bytes at offset 1611776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1615872 ++wrote 2048/2048 bytes at offset 1615872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1619968 ++wrote 2048/2048 bytes at offset 1619968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1624064 ++wrote 2048/2048 bytes at offset 1624064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1628160 ++wrote 2048/2048 bytes at offset 1628160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1632256 ++wrote 2048/2048 bytes at offset 1632256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1636352 ++wrote 2048/2048 bytes at offset 1636352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1640448 ++wrote 2048/2048 bytes at offset 1640448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1644544 ++wrote 2048/2048 bytes at offset 1644544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1648640 ++wrote 2048/2048 bytes at offset 1648640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1652736 ++wrote 2048/2048 bytes at offset 1652736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1656832 ++wrote 2048/2048 bytes at offset 1656832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1660928 ++wrote 2048/2048 bytes at offset 1660928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1665024 ++wrote 2048/2048 bytes at offset 1665024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1669120 ++wrote 2048/2048 bytes at offset 1669120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1673216 ++wrote 2048/2048 bytes at offset 1673216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1677312 ++wrote 2048/2048 bytes at offset 1677312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1681408 ++wrote 2048/2048 bytes at offset 1681408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1685504 ++wrote 2048/2048 bytes at offset 1685504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1689600 ++wrote 2048/2048 bytes at offset 1689600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1693696 ++wrote 2048/2048 bytes at offset 1693696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1697792 ++wrote 2048/2048 bytes at offset 1697792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1701888 ++wrote 2048/2048 bytes at offset 1701888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1705984 ++wrote 2048/2048 bytes at offset 1705984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1710080 ++wrote 2048/2048 bytes at offset 1710080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1714176 ++wrote 2048/2048 bytes at offset 1714176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1718272 ++wrote 2048/2048 bytes at offset 1718272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1722368 ++wrote 2048/2048 bytes at offset 1722368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1726464 ++wrote 2048/2048 bytes at offset 1726464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1730560 ++wrote 2048/2048 bytes at offset 1730560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1734656 ++wrote 2048/2048 bytes at offset 1734656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1738752 ++wrote 2048/2048 bytes at offset 1738752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1742848 ++wrote 2048/2048 bytes at offset 1742848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1746944 ++wrote 2048/2048 bytes at offset 1746944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1751040 ++wrote 2048/2048 bytes at offset 1751040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1755136 ++wrote 2048/2048 bytes at offset 1755136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1759232 ++wrote 2048/2048 bytes at offset 1759232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1763328 ++wrote 2048/2048 bytes at offset 1763328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1767424 ++wrote 2048/2048 bytes at offset 1767424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1771520 ++wrote 2048/2048 bytes at offset 1771520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1775616 ++wrote 2048/2048 bytes at offset 1775616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1779712 ++wrote 2048/2048 bytes at offset 1779712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1783808 ++wrote 2048/2048 bytes at offset 1783808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1787904 ++wrote 2048/2048 bytes at offset 1787904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1792000 ++wrote 2048/2048 bytes at offset 1792000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1796096 ++wrote 2048/2048 bytes at offset 1796096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1800192 ++wrote 2048/2048 bytes at offset 1800192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1804288 ++wrote 2048/2048 bytes at offset 1804288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1808384 ++wrote 2048/2048 bytes at offset 1808384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1812480 ++wrote 2048/2048 bytes at offset 1812480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1816576 ++wrote 2048/2048 bytes at offset 1816576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1820672 ++wrote 2048/2048 bytes at offset 1820672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1824768 ++wrote 2048/2048 bytes at offset 1824768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1828864 ++wrote 2048/2048 bytes at offset 1828864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1832960 ++wrote 2048/2048 bytes at offset 1832960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1837056 ++wrote 2048/2048 bytes at offset 1837056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1841152 ++wrote 2048/2048 bytes at offset 1841152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1845248 ++wrote 2048/2048 bytes at offset 1845248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1849344 ++wrote 2048/2048 bytes at offset 1849344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1853440 ++wrote 2048/2048 bytes at offset 1853440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1857536 ++wrote 2048/2048 bytes at offset 1857536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1861632 ++wrote 2048/2048 bytes at offset 1861632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1865728 ++wrote 2048/2048 bytes at offset 1865728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1869824 ++wrote 2048/2048 bytes at offset 1869824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1873920 ++wrote 2048/2048 bytes at offset 1873920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1878016 ++wrote 2048/2048 bytes at offset 1878016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1882112 ++wrote 2048/2048 bytes at offset 1882112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1886208 ++wrote 2048/2048 bytes at offset 1886208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1890304 ++wrote 2048/2048 bytes at offset 1890304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1894400 ++wrote 2048/2048 bytes at offset 1894400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1898496 ++wrote 2048/2048 bytes at offset 1898496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1902592 ++wrote 2048/2048 bytes at offset 1902592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1906688 ++wrote 2048/2048 bytes at offset 1906688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1910784 ++wrote 2048/2048 bytes at offset 1910784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1914880 ++wrote 2048/2048 bytes at offset 1914880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1918976 ++wrote 2048/2048 bytes at offset 1918976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1923072 ++wrote 2048/2048 bytes at offset 1923072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1927168 ++wrote 2048/2048 bytes at offset 1927168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1931264 ++wrote 2048/2048 bytes at offset 1931264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1935360 ++wrote 2048/2048 bytes at offset 1935360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1939456 ++wrote 2048/2048 bytes at offset 1939456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1943552 ++wrote 2048/2048 bytes at offset 1943552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1947648 ++wrote 2048/2048 bytes at offset 1947648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1951744 ++wrote 2048/2048 bytes at offset 1951744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1955840 ++wrote 2048/2048 bytes at offset 1955840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1959936 ++wrote 2048/2048 bytes at offset 1959936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1964032 ++wrote 2048/2048 bytes at offset 1964032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1968128 ++wrote 2048/2048 bytes at offset 1968128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1972224 ++wrote 2048/2048 bytes at offset 1972224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1976320 ++wrote 2048/2048 bytes at offset 1976320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1980416 ++wrote 2048/2048 bytes at offset 1980416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1984512 ++wrote 2048/2048 bytes at offset 1984512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1988608 ++wrote 2048/2048 bytes at offset 1988608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1992704 ++wrote 2048/2048 bytes at offset 1992704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1996800 ++wrote 2048/2048 bytes at offset 1996800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2000896 ++wrote 2048/2048 bytes at offset 2000896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2004992 ++wrote 2048/2048 bytes at offset 2004992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2009088 ++wrote 2048/2048 bytes at offset 2009088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2013184 ++wrote 2048/2048 bytes at offset 2013184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2017280 ++wrote 2048/2048 bytes at offset 2017280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2021376 ++wrote 2048/2048 bytes at offset 2021376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2025472 ++wrote 2048/2048 bytes at offset 2025472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2029568 ++wrote 2048/2048 bytes at offset 2029568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2033664 ++wrote 2048/2048 bytes at offset 2033664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2037760 ++wrote 2048/2048 bytes at offset 2037760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2041856 ++wrote 2048/2048 bytes at offset 2041856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2045952 ++wrote 2048/2048 bytes at offset 2045952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2050048 ++wrote 2048/2048 bytes at offset 2050048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2054144 ++wrote 2048/2048 bytes at offset 2054144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2058240 ++wrote 2048/2048 bytes at offset 2058240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2062336 ++wrote 2048/2048 bytes at offset 2062336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2066432 ++wrote 2048/2048 bytes at offset 2066432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2070528 ++wrote 2048/2048 bytes at offset 2070528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2074624 ++wrote 2048/2048 bytes at offset 2074624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2078720 ++wrote 2048/2048 bytes at offset 2078720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2082816 ++wrote 2048/2048 bytes at offset 2082816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2086912 ++wrote 2048/2048 bytes at offset 2086912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2091008 ++wrote 2048/2048 bytes at offset 2091008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2095104 ++wrote 2048/2048 bytes at offset 2095104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> wrote 2048/2048 bytes at offset 2097152 ++=== IO: pattern 0 ++wrote 2048/2048 bytes at offset 2097152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2101248 ++wrote 2048/2048 bytes at offset 2101248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2105344 ++wrote 2048/2048 bytes at offset 2105344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2109440 ++wrote 2048/2048 bytes at offset 2109440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2113536 ++wrote 2048/2048 bytes at offset 2113536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2117632 ++wrote 2048/2048 bytes at offset 2117632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2121728 ++wrote 2048/2048 bytes at offset 2121728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2125824 ++wrote 2048/2048 bytes at offset 2125824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2129920 ++wrote 2048/2048 bytes at offset 2129920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2134016 ++wrote 2048/2048 bytes at offset 2134016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2138112 ++wrote 2048/2048 bytes at offset 2138112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2142208 ++wrote 2048/2048 bytes at offset 2142208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2146304 ++wrote 2048/2048 bytes at offset 2146304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2150400 ++wrote 2048/2048 bytes at offset 2150400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2154496 ++wrote 2048/2048 bytes at offset 2154496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2158592 ++wrote 2048/2048 bytes at offset 2158592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2162688 ++wrote 2048/2048 bytes at offset 2162688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2166784 ++wrote 2048/2048 bytes at offset 2166784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2170880 ++wrote 2048/2048 bytes at offset 2170880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2174976 ++wrote 2048/2048 bytes at offset 2174976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2179072 ++wrote 2048/2048 bytes at offset 2179072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2183168 ++wrote 2048/2048 bytes at offset 2183168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2187264 ++wrote 2048/2048 bytes at offset 2187264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2191360 ++wrote 2048/2048 bytes at offset 2191360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2195456 ++wrote 2048/2048 bytes at offset 2195456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2199552 ++wrote 2048/2048 bytes at offset 2199552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2203648 ++wrote 2048/2048 bytes at offset 2203648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2207744 ++wrote 2048/2048 bytes at offset 2207744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2211840 ++wrote 2048/2048 bytes at offset 2211840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2215936 ++wrote 2048/2048 bytes at offset 2215936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2220032 ++wrote 2048/2048 bytes at offset 2220032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2224128 ++wrote 2048/2048 bytes at offset 2224128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2228224 ++wrote 2048/2048 bytes at offset 2228224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2232320 ++wrote 2048/2048 bytes at offset 2232320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2236416 ++wrote 2048/2048 bytes at offset 2236416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2240512 ++wrote 2048/2048 bytes at offset 2240512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2244608 ++wrote 2048/2048 bytes at offset 2244608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2248704 ++wrote 2048/2048 bytes at offset 2248704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2252800 ++wrote 2048/2048 bytes at offset 2252800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2256896 ++wrote 2048/2048 bytes at offset 2256896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2260992 ++wrote 2048/2048 bytes at offset 2260992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2265088 ++wrote 2048/2048 bytes at offset 2265088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2269184 ++wrote 2048/2048 bytes at offset 2269184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2273280 ++wrote 2048/2048 bytes at offset 2273280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2277376 ++wrote 2048/2048 bytes at offset 2277376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2281472 ++wrote 2048/2048 bytes at offset 2281472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2285568 ++wrote 2048/2048 bytes at offset 2285568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2289664 ++wrote 2048/2048 bytes at offset 2289664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2293760 ++wrote 2048/2048 bytes at offset 2293760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2297856 ++wrote 2048/2048 bytes at offset 2297856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2301952 ++wrote 2048/2048 bytes at offset 2301952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2306048 ++wrote 2048/2048 bytes at offset 2306048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2310144 ++wrote 2048/2048 bytes at offset 2310144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2314240 ++wrote 2048/2048 bytes at offset 2314240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2318336 ++wrote 2048/2048 bytes at offset 2318336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2322432 ++wrote 2048/2048 bytes at offset 2322432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2326528 ++wrote 2048/2048 bytes at offset 2326528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2330624 ++wrote 2048/2048 bytes at offset 2330624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2334720 ++wrote 2048/2048 bytes at offset 2334720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2338816 ++wrote 2048/2048 bytes at offset 2338816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2342912 ++wrote 2048/2048 bytes at offset 2342912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2347008 ++wrote 2048/2048 bytes at offset 2347008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2351104 ++wrote 2048/2048 bytes at offset 2351104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2355200 ++wrote 2048/2048 bytes at offset 2355200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2359296 ++wrote 2048/2048 bytes at offset 2359296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2363392 ++wrote 2048/2048 bytes at offset 2363392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2367488 ++wrote 2048/2048 bytes at offset 2367488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2371584 ++wrote 2048/2048 bytes at offset 2371584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2375680 ++wrote 2048/2048 bytes at offset 2375680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2379776 ++wrote 2048/2048 bytes at offset 2379776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2383872 ++wrote 2048/2048 bytes at offset 2383872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2387968 ++wrote 2048/2048 bytes at offset 2387968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2392064 ++wrote 2048/2048 bytes at offset 2392064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2396160 ++wrote 2048/2048 bytes at offset 2396160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2400256 ++wrote 2048/2048 bytes at offset 2400256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2404352 ++wrote 2048/2048 bytes at offset 2404352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2408448 ++wrote 2048/2048 bytes at offset 2408448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2412544 ++wrote 2048/2048 bytes at offset 2412544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2416640 ++wrote 2048/2048 bytes at offset 2416640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2420736 ++wrote 2048/2048 bytes at offset 2420736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2424832 ++wrote 2048/2048 bytes at offset 2424832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2428928 ++wrote 2048/2048 bytes at offset 2428928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2433024 ++wrote 2048/2048 bytes at offset 2433024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2437120 ++wrote 2048/2048 bytes at offset 2437120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2441216 ++wrote 2048/2048 bytes at offset 2441216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2445312 ++wrote 2048/2048 bytes at offset 2445312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2449408 ++wrote 2048/2048 bytes at offset 2449408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2453504 ++wrote 2048/2048 bytes at offset 2453504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2457600 ++wrote 2048/2048 bytes at offset 2457600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2461696 ++wrote 2048/2048 bytes at offset 2461696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2465792 ++wrote 2048/2048 bytes at offset 2465792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2469888 ++wrote 2048/2048 bytes at offset 2469888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2473984 ++wrote 2048/2048 bytes at offset 2473984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2478080 ++wrote 2048/2048 bytes at offset 2478080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2482176 ++wrote 2048/2048 bytes at offset 2482176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2486272 ++wrote 2048/2048 bytes at offset 2486272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2490368 ++wrote 2048/2048 bytes at offset 2490368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2494464 ++wrote 2048/2048 bytes at offset 2494464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2498560 ++wrote 2048/2048 bytes at offset 2498560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2502656 ++wrote 2048/2048 bytes at offset 2502656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2506752 ++wrote 2048/2048 bytes at offset 2506752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2510848 ++wrote 2048/2048 bytes at offset 2510848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2514944 ++wrote 2048/2048 bytes at offset 2514944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2519040 ++wrote 2048/2048 bytes at offset 2519040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2523136 ++wrote 2048/2048 bytes at offset 2523136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2527232 ++wrote 2048/2048 bytes at offset 2527232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2531328 ++wrote 2048/2048 bytes at offset 2531328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2535424 ++wrote 2048/2048 bytes at offset 2535424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2539520 ++wrote 2048/2048 bytes at offset 2539520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2543616 ++wrote 2048/2048 bytes at offset 2543616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2547712 ++wrote 2048/2048 bytes at offset 2547712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2551808 ++wrote 2048/2048 bytes at offset 2551808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2555904 ++wrote 2048/2048 bytes at offset 2555904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2560000 ++wrote 2048/2048 bytes at offset 2560000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2564096 ++wrote 2048/2048 bytes at offset 2564096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2568192 ++wrote 2048/2048 bytes at offset 2568192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2572288 ++wrote 2048/2048 bytes at offset 2572288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2576384 ++wrote 2048/2048 bytes at offset 2576384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2580480 ++wrote 2048/2048 bytes at offset 2580480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2584576 ++wrote 2048/2048 bytes at offset 2584576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2588672 ++wrote 2048/2048 bytes at offset 2588672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2592768 ++wrote 2048/2048 bytes at offset 2592768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2596864 ++wrote 2048/2048 bytes at offset 2596864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2600960 ++wrote 2048/2048 bytes at offset 2600960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2605056 ++wrote 2048/2048 bytes at offset 2605056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2609152 ++wrote 2048/2048 bytes at offset 2609152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2613248 ++wrote 2048/2048 bytes at offset 2613248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2617344 ++wrote 2048/2048 bytes at offset 2617344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2621440 ++wrote 2048/2048 bytes at offset 2621440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2625536 ++wrote 2048/2048 bytes at offset 2625536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2629632 ++wrote 2048/2048 bytes at offset 2629632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2633728 ++wrote 2048/2048 bytes at offset 2633728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2637824 ++wrote 2048/2048 bytes at offset 2637824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2641920 ++wrote 2048/2048 bytes at offset 2641920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2646016 ++wrote 2048/2048 bytes at offset 2646016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2650112 ++wrote 2048/2048 bytes at offset 2650112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2654208 ++wrote 2048/2048 bytes at offset 2654208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2658304 ++wrote 2048/2048 bytes at offset 2658304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2662400 ++wrote 2048/2048 bytes at offset 2662400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2666496 ++wrote 2048/2048 bytes at offset 2666496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2670592 ++wrote 2048/2048 bytes at offset 2670592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2674688 ++wrote 2048/2048 bytes at offset 2674688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2678784 ++wrote 2048/2048 bytes at offset 2678784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2682880 ++wrote 2048/2048 bytes at offset 2682880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2686976 ++wrote 2048/2048 bytes at offset 2686976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2691072 ++wrote 2048/2048 bytes at offset 2691072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2695168 ++wrote 2048/2048 bytes at offset 2695168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2699264 ++wrote 2048/2048 bytes at offset 2699264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2703360 ++wrote 2048/2048 bytes at offset 2703360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2707456 ++wrote 2048/2048 bytes at offset 2707456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2711552 ++wrote 2048/2048 bytes at offset 2711552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2715648 ++wrote 2048/2048 bytes at offset 2715648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2719744 ++wrote 2048/2048 bytes at offset 2719744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2723840 ++wrote 2048/2048 bytes at offset 2723840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2727936 ++wrote 2048/2048 bytes at offset 2727936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2732032 ++wrote 2048/2048 bytes at offset 2732032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2736128 ++wrote 2048/2048 bytes at offset 2736128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2740224 ++wrote 2048/2048 bytes at offset 2740224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2744320 ++wrote 2048/2048 bytes at offset 2744320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2748416 ++wrote 2048/2048 bytes at offset 2748416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2752512 ++wrote 2048/2048 bytes at offset 2752512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2756608 ++wrote 2048/2048 bytes at offset 2756608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2760704 ++wrote 2048/2048 bytes at offset 2760704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2764800 ++wrote 2048/2048 bytes at offset 2764800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2768896 ++wrote 2048/2048 bytes at offset 2768896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2772992 ++wrote 2048/2048 bytes at offset 2772992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2777088 ++wrote 2048/2048 bytes at offset 2777088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2781184 ++wrote 2048/2048 bytes at offset 2781184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2785280 ++wrote 2048/2048 bytes at offset 2785280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2789376 ++wrote 2048/2048 bytes at offset 2789376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2793472 ++wrote 2048/2048 bytes at offset 2793472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2797568 ++wrote 2048/2048 bytes at offset 2797568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2801664 ++wrote 2048/2048 bytes at offset 2801664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2805760 ++wrote 2048/2048 bytes at offset 2805760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2809856 ++wrote 2048/2048 bytes at offset 2809856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2813952 ++wrote 2048/2048 bytes at offset 2813952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2818048 ++wrote 2048/2048 bytes at offset 2818048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2822144 ++wrote 2048/2048 bytes at offset 2822144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2826240 ++wrote 2048/2048 bytes at offset 2826240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2830336 ++wrote 2048/2048 bytes at offset 2830336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2834432 ++wrote 2048/2048 bytes at offset 2834432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2838528 ++wrote 2048/2048 bytes at offset 2838528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2842624 ++wrote 2048/2048 bytes at offset 2842624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2846720 ++wrote 2048/2048 bytes at offset 2846720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2850816 ++wrote 2048/2048 bytes at offset 2850816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2854912 ++wrote 2048/2048 bytes at offset 2854912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2859008 ++wrote 2048/2048 bytes at offset 2859008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2863104 ++wrote 2048/2048 bytes at offset 2863104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2867200 ++wrote 2048/2048 bytes at offset 2867200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2871296 ++wrote 2048/2048 bytes at offset 2871296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2875392 ++wrote 2048/2048 bytes at offset 2875392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2879488 ++wrote 2048/2048 bytes at offset 2879488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2883584 ++wrote 2048/2048 bytes at offset 2883584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2887680 ++wrote 2048/2048 bytes at offset 2887680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2891776 ++wrote 2048/2048 bytes at offset 2891776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2895872 ++wrote 2048/2048 bytes at offset 2895872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2899968 ++wrote 2048/2048 bytes at offset 2899968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2904064 ++wrote 2048/2048 bytes at offset 2904064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2908160 ++wrote 2048/2048 bytes at offset 2908160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2912256 ++wrote 2048/2048 bytes at offset 2912256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2916352 ++wrote 2048/2048 bytes at offset 2916352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2920448 ++wrote 2048/2048 bytes at offset 2920448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2924544 ++wrote 2048/2048 bytes at offset 2924544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2928640 ++wrote 2048/2048 bytes at offset 2928640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2932736 ++wrote 2048/2048 bytes at offset 2932736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2936832 ++wrote 2048/2048 bytes at offset 2936832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2940928 ++wrote 2048/2048 bytes at offset 2940928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2945024 ++wrote 2048/2048 bytes at offset 2945024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2949120 ++wrote 2048/2048 bytes at offset 2949120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2953216 ++wrote 2048/2048 bytes at offset 2953216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2957312 ++wrote 2048/2048 bytes at offset 2957312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2961408 ++wrote 2048/2048 bytes at offset 2961408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2965504 ++wrote 2048/2048 bytes at offset 2965504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2969600 ++wrote 2048/2048 bytes at offset 2969600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2973696 ++wrote 2048/2048 bytes at offset 2973696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2977792 ++wrote 2048/2048 bytes at offset 2977792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2981888 ++wrote 2048/2048 bytes at offset 2981888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2985984 ++wrote 2048/2048 bytes at offset 2985984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2990080 ++wrote 2048/2048 bytes at offset 2990080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2994176 ++wrote 2048/2048 bytes at offset 2994176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2998272 ++wrote 2048/2048 bytes at offset 2998272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3002368 ++wrote 2048/2048 bytes at offset 3002368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3006464 ++wrote 2048/2048 bytes at offset 3006464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3010560 ++wrote 2048/2048 bytes at offset 3010560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3014656 ++wrote 2048/2048 bytes at offset 3014656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3018752 ++wrote 2048/2048 bytes at offset 3018752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3022848 ++wrote 2048/2048 bytes at offset 3022848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3026944 ++wrote 2048/2048 bytes at offset 3026944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3031040 ++wrote 2048/2048 bytes at offset 3031040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3035136 ++wrote 2048/2048 bytes at offset 3035136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3039232 ++wrote 2048/2048 bytes at offset 3039232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3043328 ++wrote 2048/2048 bytes at offset 3043328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3047424 ++wrote 2048/2048 bytes at offset 3047424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3051520 ++wrote 2048/2048 bytes at offset 3051520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3055616 ++wrote 2048/2048 bytes at offset 3055616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3059712 ++wrote 2048/2048 bytes at offset 3059712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3063808 ++wrote 2048/2048 bytes at offset 3063808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3067904 ++wrote 2048/2048 bytes at offset 3067904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3072000 ++wrote 2048/2048 bytes at offset 3072000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3076096 ++wrote 2048/2048 bytes at offset 3076096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3080192 ++wrote 2048/2048 bytes at offset 3080192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3084288 ++wrote 2048/2048 bytes at offset 3084288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3088384 ++wrote 2048/2048 bytes at offset 3088384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3092480 ++wrote 2048/2048 bytes at offset 3092480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3096576 ++wrote 2048/2048 bytes at offset 3096576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3100672 ++wrote 2048/2048 bytes at offset 3100672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3104768 ++wrote 2048/2048 bytes at offset 3104768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3108864 ++wrote 2048/2048 bytes at offset 3108864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3112960 ++wrote 2048/2048 bytes at offset 3112960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3117056 ++wrote 2048/2048 bytes at offset 3117056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3121152 ++wrote 2048/2048 bytes at offset 3121152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3125248 ++wrote 2048/2048 bytes at offset 3125248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3129344 ++wrote 2048/2048 bytes at offset 3129344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3133440 ++wrote 2048/2048 bytes at offset 3133440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3137536 ++wrote 2048/2048 bytes at offset 3137536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3141632 ++wrote 2048/2048 bytes at offset 3141632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 2 +-qemu-io> wrote 2048/2048 bytes at offset 3146752 ++=== IO: pattern 2 ++wrote 2048/2048 bytes at offset 3146752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3150848 ++wrote 2048/2048 bytes at offset 3150848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3154944 ++wrote 2048/2048 bytes at offset 3154944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3159040 ++wrote 2048/2048 bytes at offset 3159040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3163136 ++wrote 2048/2048 bytes at offset 3163136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3167232 ++wrote 2048/2048 bytes at offset 3167232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3171328 ++wrote 2048/2048 bytes at offset 3171328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3175424 ++wrote 2048/2048 bytes at offset 3175424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3179520 ++wrote 2048/2048 bytes at offset 3179520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3183616 ++wrote 2048/2048 bytes at offset 3183616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3187712 ++wrote 2048/2048 bytes at offset 3187712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3191808 ++wrote 2048/2048 bytes at offset 3191808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3195904 ++wrote 2048/2048 bytes at offset 3195904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3200000 ++wrote 2048/2048 bytes at offset 3200000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3204096 ++wrote 2048/2048 bytes at offset 3204096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3208192 ++wrote 2048/2048 bytes at offset 3208192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3212288 ++wrote 2048/2048 bytes at offset 3212288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3216384 ++wrote 2048/2048 bytes at offset 3216384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3220480 ++wrote 2048/2048 bytes at offset 3220480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3224576 ++wrote 2048/2048 bytes at offset 3224576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3228672 ++wrote 2048/2048 bytes at offset 3228672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3232768 ++wrote 2048/2048 bytes at offset 3232768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3236864 ++wrote 2048/2048 bytes at offset 3236864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3240960 ++wrote 2048/2048 bytes at offset 3240960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3245056 ++wrote 2048/2048 bytes at offset 3245056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3249152 ++wrote 2048/2048 bytes at offset 3249152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3253248 ++wrote 2048/2048 bytes at offset 3253248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3257344 ++wrote 2048/2048 bytes at offset 3257344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3261440 ++wrote 2048/2048 bytes at offset 3261440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3265536 ++wrote 2048/2048 bytes at offset 3265536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3269632 ++wrote 2048/2048 bytes at offset 3269632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3273728 ++wrote 2048/2048 bytes at offset 3273728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3277824 ++wrote 2048/2048 bytes at offset 3277824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3281920 ++wrote 2048/2048 bytes at offset 3281920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3286016 ++wrote 2048/2048 bytes at offset 3286016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3290112 ++wrote 2048/2048 bytes at offset 3290112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3294208 ++wrote 2048/2048 bytes at offset 3294208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3298304 ++wrote 2048/2048 bytes at offset 3298304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3302400 ++wrote 2048/2048 bytes at offset 3302400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3306496 ++wrote 2048/2048 bytes at offset 3306496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3310592 ++wrote 2048/2048 bytes at offset 3310592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3314688 ++wrote 2048/2048 bytes at offset 3314688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3318784 ++wrote 2048/2048 bytes at offset 3318784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3322880 ++wrote 2048/2048 bytes at offset 3322880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3326976 ++wrote 2048/2048 bytes at offset 3326976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3331072 ++wrote 2048/2048 bytes at offset 3331072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3335168 ++wrote 2048/2048 bytes at offset 3335168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3339264 ++wrote 2048/2048 bytes at offset 3339264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3343360 ++wrote 2048/2048 bytes at offset 3343360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3347456 ++wrote 2048/2048 bytes at offset 3347456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3351552 ++wrote 2048/2048 bytes at offset 3351552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3355648 ++wrote 2048/2048 bytes at offset 3355648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3359744 ++wrote 2048/2048 bytes at offset 3359744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3363840 ++wrote 2048/2048 bytes at offset 3363840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3367936 ++wrote 2048/2048 bytes at offset 3367936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3372032 ++wrote 2048/2048 bytes at offset 3372032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3376128 ++wrote 2048/2048 bytes at offset 3376128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3380224 ++wrote 2048/2048 bytes at offset 3380224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3384320 ++wrote 2048/2048 bytes at offset 3384320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3388416 ++wrote 2048/2048 bytes at offset 3388416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3392512 ++wrote 2048/2048 bytes at offset 3392512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3396608 ++wrote 2048/2048 bytes at offset 3396608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3400704 ++wrote 2048/2048 bytes at offset 3400704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3404800 ++wrote 2048/2048 bytes at offset 3404800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3408896 ++wrote 2048/2048 bytes at offset 3408896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3412992 ++wrote 2048/2048 bytes at offset 3412992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3417088 ++wrote 2048/2048 bytes at offset 3417088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3421184 ++wrote 2048/2048 bytes at offset 3421184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3425280 ++wrote 2048/2048 bytes at offset 3425280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3429376 ++wrote 2048/2048 bytes at offset 3429376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3433472 ++wrote 2048/2048 bytes at offset 3433472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3437568 ++wrote 2048/2048 bytes at offset 3437568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3441664 ++wrote 2048/2048 bytes at offset 3441664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3445760 ++wrote 2048/2048 bytes at offset 3445760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3449856 ++wrote 2048/2048 bytes at offset 3449856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3453952 ++wrote 2048/2048 bytes at offset 3453952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3458048 ++wrote 2048/2048 bytes at offset 3458048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3462144 ++wrote 2048/2048 bytes at offset 3462144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3466240 ++wrote 2048/2048 bytes at offset 3466240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3470336 ++wrote 2048/2048 bytes at offset 3470336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3474432 ++wrote 2048/2048 bytes at offset 3474432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3478528 ++wrote 2048/2048 bytes at offset 3478528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3482624 ++wrote 2048/2048 bytes at offset 3482624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3486720 ++wrote 2048/2048 bytes at offset 3486720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3490816 ++wrote 2048/2048 bytes at offset 3490816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3494912 ++wrote 2048/2048 bytes at offset 3494912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3499008 ++wrote 2048/2048 bytes at offset 3499008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3503104 ++wrote 2048/2048 bytes at offset 3503104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3507200 ++wrote 2048/2048 bytes at offset 3507200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3511296 ++wrote 2048/2048 bytes at offset 3511296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3515392 ++wrote 2048/2048 bytes at offset 3515392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3519488 ++wrote 2048/2048 bytes at offset 3519488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3523584 ++wrote 2048/2048 bytes at offset 3523584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3527680 ++wrote 2048/2048 bytes at offset 3527680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3531776 ++wrote 2048/2048 bytes at offset 3531776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3535872 ++wrote 2048/2048 bytes at offset 3535872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3539968 ++wrote 2048/2048 bytes at offset 3539968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3544064 ++wrote 2048/2048 bytes at offset 3544064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3548160 ++wrote 2048/2048 bytes at offset 3548160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3552256 ++wrote 2048/2048 bytes at offset 3552256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3556352 ++wrote 2048/2048 bytes at offset 3556352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3560448 ++wrote 2048/2048 bytes at offset 3560448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3564544 ++wrote 2048/2048 bytes at offset 3564544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3568640 ++wrote 2048/2048 bytes at offset 3568640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3572736 ++wrote 2048/2048 bytes at offset 3572736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3576832 ++wrote 2048/2048 bytes at offset 3576832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3580928 ++wrote 2048/2048 bytes at offset 3580928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3585024 ++wrote 2048/2048 bytes at offset 3585024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3589120 ++wrote 2048/2048 bytes at offset 3589120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3593216 ++wrote 2048/2048 bytes at offset 3593216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3597312 ++wrote 2048/2048 bytes at offset 3597312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3601408 ++wrote 2048/2048 bytes at offset 3601408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3605504 ++wrote 2048/2048 bytes at offset 3605504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3609600 ++wrote 2048/2048 bytes at offset 3609600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3613696 ++wrote 2048/2048 bytes at offset 3613696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3617792 ++wrote 2048/2048 bytes at offset 3617792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3621888 ++wrote 2048/2048 bytes at offset 3621888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3625984 ++wrote 2048/2048 bytes at offset 3625984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3630080 ++wrote 2048/2048 bytes at offset 3630080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3634176 ++wrote 2048/2048 bytes at offset 3634176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3638272 ++wrote 2048/2048 bytes at offset 3638272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3642368 ++wrote 2048/2048 bytes at offset 3642368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3646464 ++wrote 2048/2048 bytes at offset 3646464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3650560 ++wrote 2048/2048 bytes at offset 3650560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3654656 ++wrote 2048/2048 bytes at offset 3654656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3658752 ++wrote 2048/2048 bytes at offset 3658752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3662848 ++wrote 2048/2048 bytes at offset 3662848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3666944 ++wrote 2048/2048 bytes at offset 3666944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3671040 ++wrote 2048/2048 bytes at offset 3671040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3675136 ++wrote 2048/2048 bytes at offset 3675136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3679232 ++wrote 2048/2048 bytes at offset 3679232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3683328 ++wrote 2048/2048 bytes at offset 3683328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3687424 ++wrote 2048/2048 bytes at offset 3687424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3691520 ++wrote 2048/2048 bytes at offset 3691520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3695616 ++wrote 2048/2048 bytes at offset 3695616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3699712 ++wrote 2048/2048 bytes at offset 3699712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3703808 ++wrote 2048/2048 bytes at offset 3703808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3707904 ++wrote 2048/2048 bytes at offset 3707904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3712000 ++wrote 2048/2048 bytes at offset 3712000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3716096 ++wrote 2048/2048 bytes at offset 3716096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3720192 ++wrote 2048/2048 bytes at offset 3720192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3724288 ++wrote 2048/2048 bytes at offset 3724288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3728384 ++wrote 2048/2048 bytes at offset 3728384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3732480 ++wrote 2048/2048 bytes at offset 3732480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3736576 ++wrote 2048/2048 bytes at offset 3736576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3740672 ++wrote 2048/2048 bytes at offset 3740672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3744768 ++wrote 2048/2048 bytes at offset 3744768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3748864 ++wrote 2048/2048 bytes at offset 3748864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3752960 ++wrote 2048/2048 bytes at offset 3752960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3757056 ++wrote 2048/2048 bytes at offset 3757056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3761152 ++wrote 2048/2048 bytes at offset 3761152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3765248 ++wrote 2048/2048 bytes at offset 3765248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3769344 ++wrote 2048/2048 bytes at offset 3769344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3773440 ++wrote 2048/2048 bytes at offset 3773440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3777536 ++wrote 2048/2048 bytes at offset 3777536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3781632 ++wrote 2048/2048 bytes at offset 3781632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3785728 ++wrote 2048/2048 bytes at offset 3785728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3789824 ++wrote 2048/2048 bytes at offset 3789824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3793920 ++wrote 2048/2048 bytes at offset 3793920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3798016 ++wrote 2048/2048 bytes at offset 3798016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3802112 ++wrote 2048/2048 bytes at offset 3802112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3806208 ++wrote 2048/2048 bytes at offset 3806208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3810304 ++wrote 2048/2048 bytes at offset 3810304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3814400 ++wrote 2048/2048 bytes at offset 3814400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3818496 ++wrote 2048/2048 bytes at offset 3818496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3822592 ++wrote 2048/2048 bytes at offset 3822592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3826688 ++wrote 2048/2048 bytes at offset 3826688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3830784 ++wrote 2048/2048 bytes at offset 3830784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3834880 ++wrote 2048/2048 bytes at offset 3834880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3838976 ++wrote 2048/2048 bytes at offset 3838976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3843072 ++wrote 2048/2048 bytes at offset 3843072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3847168 ++wrote 2048/2048 bytes at offset 3847168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3851264 ++wrote 2048/2048 bytes at offset 3851264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3855360 ++wrote 2048/2048 bytes at offset 3855360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3859456 ++wrote 2048/2048 bytes at offset 3859456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3863552 ++wrote 2048/2048 bytes at offset 3863552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3867648 ++wrote 2048/2048 bytes at offset 3867648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3871744 ++wrote 2048/2048 bytes at offset 3871744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3875840 ++wrote 2048/2048 bytes at offset 3875840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3879936 ++wrote 2048/2048 bytes at offset 3879936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3884032 ++wrote 2048/2048 bytes at offset 3884032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3888128 ++wrote 2048/2048 bytes at offset 3888128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3892224 ++wrote 2048/2048 bytes at offset 3892224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3896320 ++wrote 2048/2048 bytes at offset 3896320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3900416 ++wrote 2048/2048 bytes at offset 3900416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3904512 ++wrote 2048/2048 bytes at offset 3904512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3908608 ++wrote 2048/2048 bytes at offset 3908608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3912704 ++wrote 2048/2048 bytes at offset 3912704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3916800 ++wrote 2048/2048 bytes at offset 3916800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3920896 ++wrote 2048/2048 bytes at offset 3920896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3924992 ++wrote 2048/2048 bytes at offset 3924992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3929088 ++wrote 2048/2048 bytes at offset 3929088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3933184 ++wrote 2048/2048 bytes at offset 3933184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3937280 ++wrote 2048/2048 bytes at offset 3937280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3941376 ++wrote 2048/2048 bytes at offset 3941376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3945472 ++wrote 2048/2048 bytes at offset 3945472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3949568 ++wrote 2048/2048 bytes at offset 3949568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3953664 ++wrote 2048/2048 bytes at offset 3953664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3957760 ++wrote 2048/2048 bytes at offset 3957760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3961856 ++wrote 2048/2048 bytes at offset 3961856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3965952 ++wrote 2048/2048 bytes at offset 3965952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3970048 ++wrote 2048/2048 bytes at offset 3970048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3974144 ++wrote 2048/2048 bytes at offset 3974144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3978240 ++wrote 2048/2048 bytes at offset 3978240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3982336 ++wrote 2048/2048 bytes at offset 3982336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3986432 ++wrote 2048/2048 bytes at offset 3986432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3990528 ++wrote 2048/2048 bytes at offset 3990528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3994624 ++wrote 2048/2048 bytes at offset 3994624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3998720 ++wrote 2048/2048 bytes at offset 3998720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4002816 ++wrote 2048/2048 bytes at offset 4002816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4006912 ++wrote 2048/2048 bytes at offset 4006912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4011008 ++wrote 2048/2048 bytes at offset 4011008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4015104 ++wrote 2048/2048 bytes at offset 4015104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4019200 ++wrote 2048/2048 bytes at offset 4019200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4023296 ++wrote 2048/2048 bytes at offset 4023296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4027392 ++wrote 2048/2048 bytes at offset 4027392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4031488 ++wrote 2048/2048 bytes at offset 4031488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4035584 ++wrote 2048/2048 bytes at offset 4035584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4039680 ++wrote 2048/2048 bytes at offset 4039680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4043776 ++wrote 2048/2048 bytes at offset 4043776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4047872 ++wrote 2048/2048 bytes at offset 4047872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4051968 ++wrote 2048/2048 bytes at offset 4051968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4056064 ++wrote 2048/2048 bytes at offset 4056064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4060160 ++wrote 2048/2048 bytes at offset 4060160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4064256 ++wrote 2048/2048 bytes at offset 4064256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4068352 ++wrote 2048/2048 bytes at offset 4068352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4072448 ++wrote 2048/2048 bytes at offset 4072448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4076544 ++wrote 2048/2048 bytes at offset 4076544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4080640 ++wrote 2048/2048 bytes at offset 4080640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4084736 ++wrote 2048/2048 bytes at offset 4084736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4088832 ++wrote 2048/2048 bytes at offset 4088832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4092928 ++wrote 2048/2048 bytes at offset 4092928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4097024 ++wrote 2048/2048 bytes at offset 4097024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4101120 ++wrote 2048/2048 bytes at offset 4101120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4105216 ++wrote 2048/2048 bytes at offset 4105216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4109312 ++wrote 2048/2048 bytes at offset 4109312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4113408 ++wrote 2048/2048 bytes at offset 4113408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4117504 ++wrote 2048/2048 bytes at offset 4117504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4121600 ++wrote 2048/2048 bytes at offset 4121600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4125696 ++wrote 2048/2048 bytes at offset 4125696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4129792 ++wrote 2048/2048 bytes at offset 4129792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4133888 ++wrote 2048/2048 bytes at offset 4133888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4137984 ++wrote 2048/2048 bytes at offset 4137984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4142080 ++wrote 2048/2048 bytes at offset 4142080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4146176 ++wrote 2048/2048 bytes at offset 4146176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4150272 ++wrote 2048/2048 bytes at offset 4150272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4154368 ++wrote 2048/2048 bytes at offset 4154368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4158464 ++wrote 2048/2048 bytes at offset 4158464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4162560 ++wrote 2048/2048 bytes at offset 4162560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4166656 ++wrote 2048/2048 bytes at offset 4166656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4170752 ++wrote 2048/2048 bytes at offset 4170752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4174848 ++wrote 2048/2048 bytes at offset 4174848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4178944 ++wrote 2048/2048 bytes at offset 4178944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4183040 ++wrote 2048/2048 bytes at offset 4183040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4187136 ++wrote 2048/2048 bytes at offset 4187136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4191232 ++wrote 2048/2048 bytes at offset 4191232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 4 +-qemu-io> wrote 8192/8192 bytes at offset 4196352 ++=== IO: pattern 4 ++wrote 8192/8192 bytes at offset 4196352 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4208640 ++wrote 8192/8192 bytes at offset 4208640 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4220928 ++wrote 8192/8192 bytes at offset 4220928 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4233216 ++wrote 8192/8192 bytes at offset 4233216 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4245504 ++wrote 8192/8192 bytes at offset 4245504 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4257792 ++wrote 8192/8192 bytes at offset 4257792 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4270080 ++wrote 8192/8192 bytes at offset 4270080 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4282368 ++wrote 8192/8192 bytes at offset 4282368 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4294656 ++wrote 8192/8192 bytes at offset 4294656 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4306944 ++wrote 8192/8192 bytes at offset 4306944 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4319232 ++wrote 8192/8192 bytes at offset 4319232 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4331520 ++wrote 8192/8192 bytes at offset 4331520 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4343808 ++wrote 8192/8192 bytes at offset 4343808 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4356096 ++wrote 8192/8192 bytes at offset 4356096 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4368384 ++wrote 8192/8192 bytes at offset 4368384 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4380672 ++wrote 8192/8192 bytes at offset 4380672 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4392960 ++wrote 8192/8192 bytes at offset 4392960 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4405248 ++wrote 8192/8192 bytes at offset 4405248 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4417536 ++wrote 8192/8192 bytes at offset 4417536 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4429824 ++wrote 8192/8192 bytes at offset 4429824 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4442112 ++wrote 8192/8192 bytes at offset 4442112 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4454400 ++wrote 8192/8192 bytes at offset 4454400 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4466688 ++wrote 8192/8192 bytes at offset 4466688 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4478976 ++wrote 8192/8192 bytes at offset 4478976 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4491264 ++wrote 8192/8192 bytes at offset 4491264 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4503552 ++wrote 8192/8192 bytes at offset 4503552 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4515840 ++wrote 8192/8192 bytes at offset 4515840 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4528128 ++wrote 8192/8192 bytes at offset 4528128 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4540416 ++wrote 8192/8192 bytes at offset 4540416 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4552704 ++wrote 8192/8192 bytes at offset 4552704 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4564992 ++wrote 8192/8192 bytes at offset 4564992 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4577280 ++wrote 8192/8192 bytes at offset 4577280 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4589568 ++wrote 8192/8192 bytes at offset 4589568 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4601856 ++wrote 8192/8192 bytes at offset 4601856 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4614144 ++wrote 8192/8192 bytes at offset 4614144 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4626432 ++wrote 8192/8192 bytes at offset 4626432 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4638720 ++wrote 8192/8192 bytes at offset 4638720 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4651008 ++wrote 8192/8192 bytes at offset 4651008 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4663296 ++wrote 8192/8192 bytes at offset 4663296 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4675584 ++wrote 8192/8192 bytes at offset 4675584 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4687872 ++wrote 8192/8192 bytes at offset 4687872 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4700160 ++wrote 8192/8192 bytes at offset 4700160 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4712448 ++wrote 8192/8192 bytes at offset 4712448 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4724736 ++wrote 8192/8192 bytes at offset 4724736 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4737024 ++wrote 8192/8192 bytes at offset 4737024 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4749312 ++wrote 8192/8192 bytes at offset 4749312 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4761600 ++wrote 8192/8192 bytes at offset 4761600 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4773888 ++wrote 8192/8192 bytes at offset 4773888 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4786176 ++wrote 8192/8192 bytes at offset 4786176 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4798464 ++wrote 8192/8192 bytes at offset 4798464 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4810752 ++wrote 8192/8192 bytes at offset 4810752 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4823040 ++wrote 8192/8192 bytes at offset 4823040 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4835328 ++wrote 8192/8192 bytes at offset 4835328 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4847616 ++wrote 8192/8192 bytes at offset 4847616 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4859904 ++wrote 8192/8192 bytes at offset 4859904 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4872192 ++wrote 8192/8192 bytes at offset 4872192 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4884480 ++wrote 8192/8192 bytes at offset 4884480 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4896768 ++wrote 8192/8192 bytes at offset 4896768 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4909056 ++wrote 8192/8192 bytes at offset 4909056 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4921344 ++wrote 8192/8192 bytes at offset 4921344 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4933632 ++wrote 8192/8192 bytes at offset 4933632 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4945920 ++wrote 8192/8192 bytes at offset 4945920 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4958208 ++wrote 8192/8192 bytes at offset 4958208 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4970496 ++wrote 8192/8192 bytes at offset 4970496 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 244 +-qemu-io> wrote 12288/12288 bytes at offset 6285312 ++=== IO: pattern 244 ++wrote 12288/12288 bytes at offset 6285312 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 8384512 ++wrote 12288/12288 bytes at offset 8384512 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 10483712 ++wrote 12288/12288 bytes at offset 10483712 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 12582912 ++wrote 12288/12288 bytes at offset 12582912 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 14682112 ++wrote 12288/12288 bytes at offset 14682112 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 16781312 ++wrote 12288/12288 bytes at offset 16781312 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 18880512 ++wrote 12288/12288 bytes at offset 18880512 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 20979712 ++wrote 12288/12288 bytes at offset 20979712 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> read 4096/4096 bytes at offset 0 ++=== IO: pattern 0 ++read 4096/4096 bytes at offset 0 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4096 ++read 4096/4096 bytes at offset 4096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 8192 ++read 4096/4096 bytes at offset 8192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 12288 ++read 4096/4096 bytes at offset 12288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 16384 ++read 4096/4096 bytes at offset 16384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 20480 ++read 4096/4096 bytes at offset 20480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 24576 ++read 4096/4096 bytes at offset 24576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 28672 ++read 4096/4096 bytes at offset 28672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 32768 ++read 4096/4096 bytes at offset 32768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 36864 ++read 4096/4096 bytes at offset 36864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 40960 ++read 4096/4096 bytes at offset 40960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 45056 ++read 4096/4096 bytes at offset 45056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 49152 ++read 4096/4096 bytes at offset 49152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 53248 ++read 4096/4096 bytes at offset 53248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 57344 ++read 4096/4096 bytes at offset 57344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 61440 ++read 4096/4096 bytes at offset 61440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 65536 ++read 4096/4096 bytes at offset 65536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 69632 ++read 4096/4096 bytes at offset 69632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 73728 ++read 4096/4096 bytes at offset 73728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 77824 ++read 4096/4096 bytes at offset 77824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 81920 ++read 4096/4096 bytes at offset 81920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 86016 ++read 4096/4096 bytes at offset 86016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 90112 ++read 4096/4096 bytes at offset 90112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 94208 ++read 4096/4096 bytes at offset 94208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 98304 ++read 4096/4096 bytes at offset 98304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 102400 ++read 4096/4096 bytes at offset 102400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 106496 ++read 4096/4096 bytes at offset 106496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 110592 ++read 4096/4096 bytes at offset 110592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 114688 ++read 4096/4096 bytes at offset 114688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 118784 ++read 4096/4096 bytes at offset 118784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 122880 ++read 4096/4096 bytes at offset 122880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 126976 ++read 4096/4096 bytes at offset 126976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 131072 ++read 4096/4096 bytes at offset 131072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 135168 ++read 4096/4096 bytes at offset 135168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 139264 ++read 4096/4096 bytes at offset 139264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 143360 ++read 4096/4096 bytes at offset 143360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 147456 ++read 4096/4096 bytes at offset 147456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 151552 ++read 4096/4096 bytes at offset 151552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 155648 ++read 4096/4096 bytes at offset 155648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 159744 ++read 4096/4096 bytes at offset 159744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 163840 ++read 4096/4096 bytes at offset 163840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 167936 ++read 4096/4096 bytes at offset 167936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 172032 ++read 4096/4096 bytes at offset 172032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 176128 ++read 4096/4096 bytes at offset 176128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 180224 ++read 4096/4096 bytes at offset 180224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 184320 ++read 4096/4096 bytes at offset 184320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 188416 ++read 4096/4096 bytes at offset 188416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 192512 ++read 4096/4096 bytes at offset 192512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 196608 ++read 4096/4096 bytes at offset 196608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 200704 ++read 4096/4096 bytes at offset 200704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 204800 ++read 4096/4096 bytes at offset 204800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 208896 ++read 4096/4096 bytes at offset 208896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 212992 ++read 4096/4096 bytes at offset 212992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 217088 ++read 4096/4096 bytes at offset 217088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 221184 ++read 4096/4096 bytes at offset 221184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 225280 ++read 4096/4096 bytes at offset 225280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 229376 ++read 4096/4096 bytes at offset 229376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 233472 ++read 4096/4096 bytes at offset 233472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 237568 ++read 4096/4096 bytes at offset 237568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 241664 ++read 4096/4096 bytes at offset 241664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 245760 ++read 4096/4096 bytes at offset 245760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 249856 ++read 4096/4096 bytes at offset 249856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 253952 ++read 4096/4096 bytes at offset 253952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 258048 ++read 4096/4096 bytes at offset 258048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 262144 ++read 4096/4096 bytes at offset 262144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 266240 ++read 4096/4096 bytes at offset 266240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 270336 ++read 4096/4096 bytes at offset 270336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 274432 ++read 4096/4096 bytes at offset 274432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 278528 ++read 4096/4096 bytes at offset 278528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 282624 ++read 4096/4096 bytes at offset 282624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 286720 ++read 4096/4096 bytes at offset 286720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 290816 ++read 4096/4096 bytes at offset 290816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 294912 ++read 4096/4096 bytes at offset 294912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 299008 ++read 4096/4096 bytes at offset 299008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 303104 ++read 4096/4096 bytes at offset 303104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 307200 ++read 4096/4096 bytes at offset 307200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 311296 ++read 4096/4096 bytes at offset 311296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 315392 ++read 4096/4096 bytes at offset 315392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 319488 ++read 4096/4096 bytes at offset 319488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 323584 ++read 4096/4096 bytes at offset 323584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 327680 ++read 4096/4096 bytes at offset 327680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 331776 ++read 4096/4096 bytes at offset 331776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 335872 ++read 4096/4096 bytes at offset 335872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 339968 ++read 4096/4096 bytes at offset 339968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 344064 ++read 4096/4096 bytes at offset 344064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 348160 ++read 4096/4096 bytes at offset 348160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 352256 ++read 4096/4096 bytes at offset 352256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 356352 ++read 4096/4096 bytes at offset 356352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 360448 ++read 4096/4096 bytes at offset 360448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 364544 ++read 4096/4096 bytes at offset 364544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 368640 ++read 4096/4096 bytes at offset 368640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 372736 ++read 4096/4096 bytes at offset 372736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 376832 ++read 4096/4096 bytes at offset 376832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 380928 ++read 4096/4096 bytes at offset 380928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 385024 ++read 4096/4096 bytes at offset 385024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 389120 ++read 4096/4096 bytes at offset 389120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 393216 ++read 4096/4096 bytes at offset 393216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 397312 ++read 4096/4096 bytes at offset 397312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 401408 ++read 4096/4096 bytes at offset 401408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 405504 ++read 4096/4096 bytes at offset 405504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 409600 ++read 4096/4096 bytes at offset 409600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 413696 ++read 4096/4096 bytes at offset 413696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 417792 ++read 4096/4096 bytes at offset 417792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 421888 ++read 4096/4096 bytes at offset 421888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 425984 ++read 4096/4096 bytes at offset 425984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 430080 ++read 4096/4096 bytes at offset 430080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 434176 ++read 4096/4096 bytes at offset 434176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 438272 ++read 4096/4096 bytes at offset 438272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 442368 ++read 4096/4096 bytes at offset 442368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 446464 ++read 4096/4096 bytes at offset 446464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 450560 ++read 4096/4096 bytes at offset 450560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 454656 ++read 4096/4096 bytes at offset 454656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 458752 ++read 4096/4096 bytes at offset 458752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 462848 ++read 4096/4096 bytes at offset 462848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 466944 ++read 4096/4096 bytes at offset 466944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 471040 ++read 4096/4096 bytes at offset 471040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 475136 ++read 4096/4096 bytes at offset 475136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 479232 ++read 4096/4096 bytes at offset 479232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 483328 ++read 4096/4096 bytes at offset 483328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 487424 ++read 4096/4096 bytes at offset 487424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 491520 ++read 4096/4096 bytes at offset 491520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 495616 ++read 4096/4096 bytes at offset 495616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 499712 ++read 4096/4096 bytes at offset 499712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 503808 ++read 4096/4096 bytes at offset 503808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 507904 ++read 4096/4096 bytes at offset 507904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 512000 ++read 4096/4096 bytes at offset 512000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 516096 ++read 4096/4096 bytes at offset 516096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 520192 ++read 4096/4096 bytes at offset 520192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 524288 ++read 4096/4096 bytes at offset 524288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 528384 ++read 4096/4096 bytes at offset 528384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 532480 ++read 4096/4096 bytes at offset 532480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 536576 ++read 4096/4096 bytes at offset 536576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 540672 ++read 4096/4096 bytes at offset 540672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 544768 ++read 4096/4096 bytes at offset 544768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 548864 ++read 4096/4096 bytes at offset 548864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 552960 ++read 4096/4096 bytes at offset 552960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 557056 ++read 4096/4096 bytes at offset 557056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 561152 ++read 4096/4096 bytes at offset 561152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 565248 ++read 4096/4096 bytes at offset 565248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 569344 ++read 4096/4096 bytes at offset 569344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 573440 ++read 4096/4096 bytes at offset 573440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 577536 ++read 4096/4096 bytes at offset 577536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 581632 ++read 4096/4096 bytes at offset 581632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 585728 ++read 4096/4096 bytes at offset 585728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 589824 ++read 4096/4096 bytes at offset 589824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 593920 ++read 4096/4096 bytes at offset 593920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 598016 ++read 4096/4096 bytes at offset 598016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 602112 ++read 4096/4096 bytes at offset 602112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 606208 ++read 4096/4096 bytes at offset 606208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 610304 ++read 4096/4096 bytes at offset 610304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 614400 ++read 4096/4096 bytes at offset 614400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 618496 ++read 4096/4096 bytes at offset 618496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 622592 ++read 4096/4096 bytes at offset 622592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 626688 ++read 4096/4096 bytes at offset 626688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 630784 ++read 4096/4096 bytes at offset 630784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 634880 ++read 4096/4096 bytes at offset 634880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 638976 ++read 4096/4096 bytes at offset 638976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 643072 ++read 4096/4096 bytes at offset 643072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 647168 ++read 4096/4096 bytes at offset 647168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 651264 ++read 4096/4096 bytes at offset 651264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 655360 ++read 4096/4096 bytes at offset 655360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 659456 ++read 4096/4096 bytes at offset 659456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 663552 ++read 4096/4096 bytes at offset 663552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 667648 ++read 4096/4096 bytes at offset 667648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 671744 ++read 4096/4096 bytes at offset 671744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 675840 ++read 4096/4096 bytes at offset 675840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 679936 ++read 4096/4096 bytes at offset 679936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 684032 ++read 4096/4096 bytes at offset 684032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 688128 ++read 4096/4096 bytes at offset 688128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 692224 ++read 4096/4096 bytes at offset 692224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 696320 ++read 4096/4096 bytes at offset 696320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 700416 ++read 4096/4096 bytes at offset 700416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 704512 ++read 4096/4096 bytes at offset 704512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 708608 ++read 4096/4096 bytes at offset 708608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 712704 ++read 4096/4096 bytes at offset 712704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 716800 ++read 4096/4096 bytes at offset 716800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 720896 ++read 4096/4096 bytes at offset 720896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 724992 ++read 4096/4096 bytes at offset 724992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 729088 ++read 4096/4096 bytes at offset 729088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 733184 ++read 4096/4096 bytes at offset 733184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 737280 ++read 4096/4096 bytes at offset 737280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 741376 ++read 4096/4096 bytes at offset 741376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 745472 ++read 4096/4096 bytes at offset 745472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 749568 ++read 4096/4096 bytes at offset 749568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 753664 ++read 4096/4096 bytes at offset 753664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 757760 ++read 4096/4096 bytes at offset 757760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 761856 ++read 4096/4096 bytes at offset 761856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 765952 ++read 4096/4096 bytes at offset 765952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 770048 ++read 4096/4096 bytes at offset 770048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 774144 ++read 4096/4096 bytes at offset 774144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 778240 ++read 4096/4096 bytes at offset 778240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 782336 ++read 4096/4096 bytes at offset 782336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 786432 ++read 4096/4096 bytes at offset 786432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 790528 ++read 4096/4096 bytes at offset 790528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 794624 ++read 4096/4096 bytes at offset 794624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 798720 ++read 4096/4096 bytes at offset 798720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 802816 ++read 4096/4096 bytes at offset 802816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 806912 ++read 4096/4096 bytes at offset 806912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 811008 ++read 4096/4096 bytes at offset 811008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 815104 ++read 4096/4096 bytes at offset 815104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 819200 ++read 4096/4096 bytes at offset 819200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 823296 ++read 4096/4096 bytes at offset 823296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 827392 ++read 4096/4096 bytes at offset 827392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 831488 ++read 4096/4096 bytes at offset 831488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 835584 ++read 4096/4096 bytes at offset 835584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 839680 ++read 4096/4096 bytes at offset 839680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 843776 ++read 4096/4096 bytes at offset 843776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 847872 ++read 4096/4096 bytes at offset 847872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 851968 ++read 4096/4096 bytes at offset 851968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 856064 ++read 4096/4096 bytes at offset 856064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 860160 ++read 4096/4096 bytes at offset 860160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 864256 ++read 4096/4096 bytes at offset 864256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 868352 ++read 4096/4096 bytes at offset 868352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 872448 ++read 4096/4096 bytes at offset 872448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 876544 ++read 4096/4096 bytes at offset 876544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 880640 ++read 4096/4096 bytes at offset 880640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 884736 ++read 4096/4096 bytes at offset 884736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 888832 ++read 4096/4096 bytes at offset 888832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 892928 ++read 4096/4096 bytes at offset 892928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 897024 ++read 4096/4096 bytes at offset 897024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 901120 ++read 4096/4096 bytes at offset 901120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 905216 ++read 4096/4096 bytes at offset 905216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 909312 ++read 4096/4096 bytes at offset 909312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 913408 ++read 4096/4096 bytes at offset 913408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 917504 ++read 4096/4096 bytes at offset 917504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 921600 ++read 4096/4096 bytes at offset 921600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 925696 ++read 4096/4096 bytes at offset 925696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 929792 ++read 4096/4096 bytes at offset 929792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 933888 ++read 4096/4096 bytes at offset 933888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 937984 ++read 4096/4096 bytes at offset 937984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 942080 ++read 4096/4096 bytes at offset 942080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 946176 ++read 4096/4096 bytes at offset 946176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 950272 ++read 4096/4096 bytes at offset 950272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 954368 ++read 4096/4096 bytes at offset 954368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 958464 ++read 4096/4096 bytes at offset 958464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 962560 ++read 4096/4096 bytes at offset 962560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 966656 ++read 4096/4096 bytes at offset 966656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 970752 ++read 4096/4096 bytes at offset 970752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 974848 ++read 4096/4096 bytes at offset 974848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 978944 ++read 4096/4096 bytes at offset 978944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 983040 ++read 4096/4096 bytes at offset 983040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 987136 ++read 4096/4096 bytes at offset 987136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 991232 ++read 4096/4096 bytes at offset 991232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 995328 ++read 4096/4096 bytes at offset 995328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 999424 ++read 4096/4096 bytes at offset 999424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1003520 ++read 4096/4096 bytes at offset 1003520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1007616 ++read 4096/4096 bytes at offset 1007616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1011712 ++read 4096/4096 bytes at offset 1011712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1015808 ++read 4096/4096 bytes at offset 1015808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1019904 ++read 4096/4096 bytes at offset 1019904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1024000 ++read 4096/4096 bytes at offset 1024000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1028096 ++read 4096/4096 bytes at offset 1028096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1032192 ++read 4096/4096 bytes at offset 1032192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1036288 ++read 4096/4096 bytes at offset 1036288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1040384 ++read 4096/4096 bytes at offset 1040384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1044480 ++read 4096/4096 bytes at offset 1044480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 4 +-qemu-io> read 2048/2048 bytes at offset 1050624 ++=== IO: pattern 4 ++read 2048/2048 bytes at offset 1050624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1054720 ++read 2048/2048 bytes at offset 1054720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1058816 ++read 2048/2048 bytes at offset 1058816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1062912 ++read 2048/2048 bytes at offset 1062912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1067008 ++read 2048/2048 bytes at offset 1067008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1071104 ++read 2048/2048 bytes at offset 1071104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1075200 ++read 2048/2048 bytes at offset 1075200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1079296 ++read 2048/2048 bytes at offset 1079296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1083392 ++read 2048/2048 bytes at offset 1083392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1087488 ++read 2048/2048 bytes at offset 1087488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1091584 ++read 2048/2048 bytes at offset 1091584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1095680 ++read 2048/2048 bytes at offset 1095680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1099776 ++read 2048/2048 bytes at offset 1099776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1103872 ++read 2048/2048 bytes at offset 1103872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1107968 ++read 2048/2048 bytes at offset 1107968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1112064 ++read 2048/2048 bytes at offset 1112064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1116160 ++read 2048/2048 bytes at offset 1116160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1120256 ++read 2048/2048 bytes at offset 1120256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1124352 ++read 2048/2048 bytes at offset 1124352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1128448 ++read 2048/2048 bytes at offset 1128448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1132544 ++read 2048/2048 bytes at offset 1132544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1136640 ++read 2048/2048 bytes at offset 1136640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1140736 ++read 2048/2048 bytes at offset 1140736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1144832 ++read 2048/2048 bytes at offset 1144832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1148928 ++read 2048/2048 bytes at offset 1148928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1153024 ++read 2048/2048 bytes at offset 1153024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1157120 ++read 2048/2048 bytes at offset 1157120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1161216 ++read 2048/2048 bytes at offset 1161216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1165312 ++read 2048/2048 bytes at offset 1165312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1169408 ++read 2048/2048 bytes at offset 1169408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1173504 ++read 2048/2048 bytes at offset 1173504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1177600 ++read 2048/2048 bytes at offset 1177600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1181696 ++read 2048/2048 bytes at offset 1181696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1185792 ++read 2048/2048 bytes at offset 1185792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1189888 ++read 2048/2048 bytes at offset 1189888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1193984 ++read 2048/2048 bytes at offset 1193984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1198080 ++read 2048/2048 bytes at offset 1198080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1202176 ++read 2048/2048 bytes at offset 1202176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1206272 ++read 2048/2048 bytes at offset 1206272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1210368 ++read 2048/2048 bytes at offset 1210368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1214464 ++read 2048/2048 bytes at offset 1214464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1218560 ++read 2048/2048 bytes at offset 1218560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1222656 ++read 2048/2048 bytes at offset 1222656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1226752 ++read 2048/2048 bytes at offset 1226752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1230848 ++read 2048/2048 bytes at offset 1230848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1234944 ++read 2048/2048 bytes at offset 1234944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1239040 ++read 2048/2048 bytes at offset 1239040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1243136 ++read 2048/2048 bytes at offset 1243136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1247232 ++read 2048/2048 bytes at offset 1247232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1251328 ++read 2048/2048 bytes at offset 1251328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1255424 ++read 2048/2048 bytes at offset 1255424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1259520 ++read 2048/2048 bytes at offset 1259520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1263616 ++read 2048/2048 bytes at offset 1263616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1267712 ++read 2048/2048 bytes at offset 1267712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1271808 ++read 2048/2048 bytes at offset 1271808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1275904 ++read 2048/2048 bytes at offset 1275904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1280000 ++read 2048/2048 bytes at offset 1280000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1284096 ++read 2048/2048 bytes at offset 1284096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1288192 ++read 2048/2048 bytes at offset 1288192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1292288 ++read 2048/2048 bytes at offset 1292288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1296384 ++read 2048/2048 bytes at offset 1296384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1300480 ++read 2048/2048 bytes at offset 1300480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1304576 ++read 2048/2048 bytes at offset 1304576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1308672 ++read 2048/2048 bytes at offset 1308672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1312768 ++read 2048/2048 bytes at offset 1312768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1316864 ++read 2048/2048 bytes at offset 1316864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1320960 ++read 2048/2048 bytes at offset 1320960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1325056 ++read 2048/2048 bytes at offset 1325056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1329152 ++read 2048/2048 bytes at offset 1329152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1333248 ++read 2048/2048 bytes at offset 1333248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1337344 ++read 2048/2048 bytes at offset 1337344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1341440 ++read 2048/2048 bytes at offset 1341440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1345536 ++read 2048/2048 bytes at offset 1345536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1349632 ++read 2048/2048 bytes at offset 1349632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1353728 ++read 2048/2048 bytes at offset 1353728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1357824 ++read 2048/2048 bytes at offset 1357824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1361920 ++read 2048/2048 bytes at offset 1361920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1366016 ++read 2048/2048 bytes at offset 1366016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1370112 ++read 2048/2048 bytes at offset 1370112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1374208 ++read 2048/2048 bytes at offset 1374208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1378304 ++read 2048/2048 bytes at offset 1378304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1382400 ++read 2048/2048 bytes at offset 1382400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1386496 ++read 2048/2048 bytes at offset 1386496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1390592 ++read 2048/2048 bytes at offset 1390592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1394688 ++read 2048/2048 bytes at offset 1394688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1398784 ++read 2048/2048 bytes at offset 1398784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1402880 ++read 2048/2048 bytes at offset 1402880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1406976 ++read 2048/2048 bytes at offset 1406976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1411072 ++read 2048/2048 bytes at offset 1411072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1415168 ++read 2048/2048 bytes at offset 1415168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1419264 ++read 2048/2048 bytes at offset 1419264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1423360 ++read 2048/2048 bytes at offset 1423360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1427456 ++read 2048/2048 bytes at offset 1427456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1431552 ++read 2048/2048 bytes at offset 1431552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1435648 ++read 2048/2048 bytes at offset 1435648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1439744 ++read 2048/2048 bytes at offset 1439744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1443840 ++read 2048/2048 bytes at offset 1443840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1447936 ++read 2048/2048 bytes at offset 1447936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1452032 ++read 2048/2048 bytes at offset 1452032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1456128 ++read 2048/2048 bytes at offset 1456128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1460224 ++read 2048/2048 bytes at offset 1460224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1464320 ++read 2048/2048 bytes at offset 1464320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1468416 ++read 2048/2048 bytes at offset 1468416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1472512 ++read 2048/2048 bytes at offset 1472512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1476608 ++read 2048/2048 bytes at offset 1476608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1480704 ++read 2048/2048 bytes at offset 1480704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1484800 ++read 2048/2048 bytes at offset 1484800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1488896 ++read 2048/2048 bytes at offset 1488896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1492992 ++read 2048/2048 bytes at offset 1492992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1497088 ++read 2048/2048 bytes at offset 1497088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1501184 ++read 2048/2048 bytes at offset 1501184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1505280 ++read 2048/2048 bytes at offset 1505280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1509376 ++read 2048/2048 bytes at offset 1509376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1513472 ++read 2048/2048 bytes at offset 1513472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1517568 ++read 2048/2048 bytes at offset 1517568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1521664 ++read 2048/2048 bytes at offset 1521664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1525760 ++read 2048/2048 bytes at offset 1525760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1529856 ++read 2048/2048 bytes at offset 1529856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1533952 ++read 2048/2048 bytes at offset 1533952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1538048 ++read 2048/2048 bytes at offset 1538048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1542144 ++read 2048/2048 bytes at offset 1542144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1546240 ++read 2048/2048 bytes at offset 1546240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1550336 ++read 2048/2048 bytes at offset 1550336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1554432 ++read 2048/2048 bytes at offset 1554432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1558528 ++read 2048/2048 bytes at offset 1558528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1562624 ++read 2048/2048 bytes at offset 1562624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1566720 ++read 2048/2048 bytes at offset 1566720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1570816 ++read 2048/2048 bytes at offset 1570816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1574912 ++read 2048/2048 bytes at offset 1574912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1579008 ++read 2048/2048 bytes at offset 1579008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1583104 ++read 2048/2048 bytes at offset 1583104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1587200 ++read 2048/2048 bytes at offset 1587200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1591296 ++read 2048/2048 bytes at offset 1591296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1595392 ++read 2048/2048 bytes at offset 1595392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1599488 ++read 2048/2048 bytes at offset 1599488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1603584 ++read 2048/2048 bytes at offset 1603584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1607680 ++read 2048/2048 bytes at offset 1607680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1611776 ++read 2048/2048 bytes at offset 1611776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1615872 ++read 2048/2048 bytes at offset 1615872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1619968 ++read 2048/2048 bytes at offset 1619968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1624064 ++read 2048/2048 bytes at offset 1624064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1628160 ++read 2048/2048 bytes at offset 1628160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1632256 ++read 2048/2048 bytes at offset 1632256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1636352 ++read 2048/2048 bytes at offset 1636352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1640448 ++read 2048/2048 bytes at offset 1640448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1644544 ++read 2048/2048 bytes at offset 1644544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1648640 ++read 2048/2048 bytes at offset 1648640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1652736 ++read 2048/2048 bytes at offset 1652736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1656832 ++read 2048/2048 bytes at offset 1656832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1660928 ++read 2048/2048 bytes at offset 1660928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1665024 ++read 2048/2048 bytes at offset 1665024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1669120 ++read 2048/2048 bytes at offset 1669120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1673216 ++read 2048/2048 bytes at offset 1673216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1677312 ++read 2048/2048 bytes at offset 1677312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1681408 ++read 2048/2048 bytes at offset 1681408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1685504 ++read 2048/2048 bytes at offset 1685504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1689600 ++read 2048/2048 bytes at offset 1689600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1693696 ++read 2048/2048 bytes at offset 1693696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1697792 ++read 2048/2048 bytes at offset 1697792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1701888 ++read 2048/2048 bytes at offset 1701888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1705984 ++read 2048/2048 bytes at offset 1705984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1710080 ++read 2048/2048 bytes at offset 1710080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1714176 ++read 2048/2048 bytes at offset 1714176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1718272 ++read 2048/2048 bytes at offset 1718272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1722368 ++read 2048/2048 bytes at offset 1722368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1726464 ++read 2048/2048 bytes at offset 1726464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1730560 ++read 2048/2048 bytes at offset 1730560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1734656 ++read 2048/2048 bytes at offset 1734656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1738752 ++read 2048/2048 bytes at offset 1738752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1742848 ++read 2048/2048 bytes at offset 1742848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1746944 ++read 2048/2048 bytes at offset 1746944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1751040 ++read 2048/2048 bytes at offset 1751040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1755136 ++read 2048/2048 bytes at offset 1755136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1759232 ++read 2048/2048 bytes at offset 1759232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1763328 ++read 2048/2048 bytes at offset 1763328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1767424 ++read 2048/2048 bytes at offset 1767424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1771520 ++read 2048/2048 bytes at offset 1771520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1775616 ++read 2048/2048 bytes at offset 1775616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1779712 ++read 2048/2048 bytes at offset 1779712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1783808 ++read 2048/2048 bytes at offset 1783808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1787904 ++read 2048/2048 bytes at offset 1787904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1792000 ++read 2048/2048 bytes at offset 1792000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1796096 ++read 2048/2048 bytes at offset 1796096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1800192 ++read 2048/2048 bytes at offset 1800192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1804288 ++read 2048/2048 bytes at offset 1804288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1808384 ++read 2048/2048 bytes at offset 1808384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1812480 ++read 2048/2048 bytes at offset 1812480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1816576 ++read 2048/2048 bytes at offset 1816576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1820672 ++read 2048/2048 bytes at offset 1820672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1824768 ++read 2048/2048 bytes at offset 1824768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1828864 ++read 2048/2048 bytes at offset 1828864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1832960 ++read 2048/2048 bytes at offset 1832960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1837056 ++read 2048/2048 bytes at offset 1837056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1841152 ++read 2048/2048 bytes at offset 1841152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1845248 ++read 2048/2048 bytes at offset 1845248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1849344 ++read 2048/2048 bytes at offset 1849344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1853440 ++read 2048/2048 bytes at offset 1853440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1857536 ++read 2048/2048 bytes at offset 1857536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1861632 ++read 2048/2048 bytes at offset 1861632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1865728 ++read 2048/2048 bytes at offset 1865728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1869824 ++read 2048/2048 bytes at offset 1869824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1873920 ++read 2048/2048 bytes at offset 1873920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1878016 ++read 2048/2048 bytes at offset 1878016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1882112 ++read 2048/2048 bytes at offset 1882112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1886208 ++read 2048/2048 bytes at offset 1886208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1890304 ++read 2048/2048 bytes at offset 1890304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1894400 ++read 2048/2048 bytes at offset 1894400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1898496 ++read 2048/2048 bytes at offset 1898496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1902592 ++read 2048/2048 bytes at offset 1902592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1906688 ++read 2048/2048 bytes at offset 1906688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1910784 ++read 2048/2048 bytes at offset 1910784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1914880 ++read 2048/2048 bytes at offset 1914880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1918976 ++read 2048/2048 bytes at offset 1918976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1923072 ++read 2048/2048 bytes at offset 1923072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1927168 ++read 2048/2048 bytes at offset 1927168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1931264 ++read 2048/2048 bytes at offset 1931264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1935360 ++read 2048/2048 bytes at offset 1935360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1939456 ++read 2048/2048 bytes at offset 1939456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1943552 ++read 2048/2048 bytes at offset 1943552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1947648 ++read 2048/2048 bytes at offset 1947648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1951744 ++read 2048/2048 bytes at offset 1951744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1955840 ++read 2048/2048 bytes at offset 1955840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1959936 ++read 2048/2048 bytes at offset 1959936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1964032 ++read 2048/2048 bytes at offset 1964032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1968128 ++read 2048/2048 bytes at offset 1968128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1972224 ++read 2048/2048 bytes at offset 1972224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1976320 ++read 2048/2048 bytes at offset 1976320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1980416 ++read 2048/2048 bytes at offset 1980416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1984512 ++read 2048/2048 bytes at offset 1984512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1988608 ++read 2048/2048 bytes at offset 1988608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1992704 ++read 2048/2048 bytes at offset 1992704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1996800 ++read 2048/2048 bytes at offset 1996800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2000896 ++read 2048/2048 bytes at offset 2000896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2004992 ++read 2048/2048 bytes at offset 2004992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2009088 ++read 2048/2048 bytes at offset 2009088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2013184 ++read 2048/2048 bytes at offset 2013184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2017280 ++read 2048/2048 bytes at offset 2017280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2021376 ++read 2048/2048 bytes at offset 2021376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2025472 ++read 2048/2048 bytes at offset 2025472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2029568 ++read 2048/2048 bytes at offset 2029568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2033664 ++read 2048/2048 bytes at offset 2033664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2037760 ++read 2048/2048 bytes at offset 2037760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2041856 ++read 2048/2048 bytes at offset 2041856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2045952 ++read 2048/2048 bytes at offset 2045952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2050048 ++read 2048/2048 bytes at offset 2050048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2054144 ++read 2048/2048 bytes at offset 2054144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2058240 ++read 2048/2048 bytes at offset 2058240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2062336 ++read 2048/2048 bytes at offset 2062336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2066432 ++read 2048/2048 bytes at offset 2066432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2070528 ++read 2048/2048 bytes at offset 2070528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2074624 ++read 2048/2048 bytes at offset 2074624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2078720 ++read 2048/2048 bytes at offset 2078720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2082816 ++read 2048/2048 bytes at offset 2082816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2086912 ++read 2048/2048 bytes at offset 2086912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2091008 ++read 2048/2048 bytes at offset 2091008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2095104 ++read 2048/2048 bytes at offset 2095104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> read 2048/2048 bytes at offset 2097152 ++=== IO: pattern 0 ++read 2048/2048 bytes at offset 2097152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2101248 ++read 2048/2048 bytes at offset 2101248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2105344 ++read 2048/2048 bytes at offset 2105344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2109440 ++read 2048/2048 bytes at offset 2109440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2113536 ++read 2048/2048 bytes at offset 2113536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2117632 ++read 2048/2048 bytes at offset 2117632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2121728 ++read 2048/2048 bytes at offset 2121728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2125824 ++read 2048/2048 bytes at offset 2125824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2129920 ++read 2048/2048 bytes at offset 2129920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2134016 ++read 2048/2048 bytes at offset 2134016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2138112 ++read 2048/2048 bytes at offset 2138112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2142208 ++read 2048/2048 bytes at offset 2142208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2146304 ++read 2048/2048 bytes at offset 2146304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2150400 ++read 2048/2048 bytes at offset 2150400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2154496 ++read 2048/2048 bytes at offset 2154496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2158592 ++read 2048/2048 bytes at offset 2158592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2162688 ++read 2048/2048 bytes at offset 2162688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2166784 ++read 2048/2048 bytes at offset 2166784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2170880 ++read 2048/2048 bytes at offset 2170880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2174976 ++read 2048/2048 bytes at offset 2174976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2179072 ++read 2048/2048 bytes at offset 2179072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2183168 ++read 2048/2048 bytes at offset 2183168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2187264 ++read 2048/2048 bytes at offset 2187264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2191360 ++read 2048/2048 bytes at offset 2191360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2195456 ++read 2048/2048 bytes at offset 2195456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2199552 ++read 2048/2048 bytes at offset 2199552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2203648 ++read 2048/2048 bytes at offset 2203648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2207744 ++read 2048/2048 bytes at offset 2207744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2211840 ++read 2048/2048 bytes at offset 2211840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2215936 ++read 2048/2048 bytes at offset 2215936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2220032 ++read 2048/2048 bytes at offset 2220032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2224128 ++read 2048/2048 bytes at offset 2224128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2228224 ++read 2048/2048 bytes at offset 2228224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2232320 ++read 2048/2048 bytes at offset 2232320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2236416 ++read 2048/2048 bytes at offset 2236416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2240512 ++read 2048/2048 bytes at offset 2240512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2244608 ++read 2048/2048 bytes at offset 2244608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2248704 ++read 2048/2048 bytes at offset 2248704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2252800 ++read 2048/2048 bytes at offset 2252800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2256896 ++read 2048/2048 bytes at offset 2256896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2260992 ++read 2048/2048 bytes at offset 2260992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2265088 ++read 2048/2048 bytes at offset 2265088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2269184 ++read 2048/2048 bytes at offset 2269184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2273280 ++read 2048/2048 bytes at offset 2273280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2277376 ++read 2048/2048 bytes at offset 2277376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2281472 ++read 2048/2048 bytes at offset 2281472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2285568 ++read 2048/2048 bytes at offset 2285568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2289664 ++read 2048/2048 bytes at offset 2289664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2293760 ++read 2048/2048 bytes at offset 2293760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2297856 ++read 2048/2048 bytes at offset 2297856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2301952 ++read 2048/2048 bytes at offset 2301952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2306048 ++read 2048/2048 bytes at offset 2306048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2310144 ++read 2048/2048 bytes at offset 2310144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2314240 ++read 2048/2048 bytes at offset 2314240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2318336 ++read 2048/2048 bytes at offset 2318336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2322432 ++read 2048/2048 bytes at offset 2322432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2326528 ++read 2048/2048 bytes at offset 2326528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2330624 ++read 2048/2048 bytes at offset 2330624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2334720 ++read 2048/2048 bytes at offset 2334720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2338816 ++read 2048/2048 bytes at offset 2338816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2342912 ++read 2048/2048 bytes at offset 2342912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2347008 ++read 2048/2048 bytes at offset 2347008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2351104 ++read 2048/2048 bytes at offset 2351104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2355200 ++read 2048/2048 bytes at offset 2355200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2359296 ++read 2048/2048 bytes at offset 2359296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2363392 ++read 2048/2048 bytes at offset 2363392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2367488 ++read 2048/2048 bytes at offset 2367488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2371584 ++read 2048/2048 bytes at offset 2371584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2375680 ++read 2048/2048 bytes at offset 2375680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2379776 ++read 2048/2048 bytes at offset 2379776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2383872 ++read 2048/2048 bytes at offset 2383872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2387968 ++read 2048/2048 bytes at offset 2387968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2392064 ++read 2048/2048 bytes at offset 2392064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2396160 ++read 2048/2048 bytes at offset 2396160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2400256 ++read 2048/2048 bytes at offset 2400256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2404352 ++read 2048/2048 bytes at offset 2404352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2408448 ++read 2048/2048 bytes at offset 2408448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2412544 ++read 2048/2048 bytes at offset 2412544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2416640 ++read 2048/2048 bytes at offset 2416640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2420736 ++read 2048/2048 bytes at offset 2420736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2424832 ++read 2048/2048 bytes at offset 2424832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2428928 ++read 2048/2048 bytes at offset 2428928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2433024 ++read 2048/2048 bytes at offset 2433024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2437120 ++read 2048/2048 bytes at offset 2437120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2441216 ++read 2048/2048 bytes at offset 2441216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2445312 ++read 2048/2048 bytes at offset 2445312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2449408 ++read 2048/2048 bytes at offset 2449408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2453504 ++read 2048/2048 bytes at offset 2453504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2457600 ++read 2048/2048 bytes at offset 2457600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2461696 ++read 2048/2048 bytes at offset 2461696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2465792 ++read 2048/2048 bytes at offset 2465792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2469888 ++read 2048/2048 bytes at offset 2469888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2473984 ++read 2048/2048 bytes at offset 2473984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2478080 ++read 2048/2048 bytes at offset 2478080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2482176 ++read 2048/2048 bytes at offset 2482176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2486272 ++read 2048/2048 bytes at offset 2486272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2490368 ++read 2048/2048 bytes at offset 2490368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2494464 ++read 2048/2048 bytes at offset 2494464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2498560 ++read 2048/2048 bytes at offset 2498560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2502656 ++read 2048/2048 bytes at offset 2502656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2506752 ++read 2048/2048 bytes at offset 2506752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2510848 ++read 2048/2048 bytes at offset 2510848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2514944 ++read 2048/2048 bytes at offset 2514944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2519040 ++read 2048/2048 bytes at offset 2519040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2523136 ++read 2048/2048 bytes at offset 2523136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2527232 ++read 2048/2048 bytes at offset 2527232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2531328 ++read 2048/2048 bytes at offset 2531328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2535424 ++read 2048/2048 bytes at offset 2535424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2539520 ++read 2048/2048 bytes at offset 2539520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2543616 ++read 2048/2048 bytes at offset 2543616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2547712 ++read 2048/2048 bytes at offset 2547712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2551808 ++read 2048/2048 bytes at offset 2551808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2555904 ++read 2048/2048 bytes at offset 2555904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2560000 ++read 2048/2048 bytes at offset 2560000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2564096 ++read 2048/2048 bytes at offset 2564096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2568192 ++read 2048/2048 bytes at offset 2568192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2572288 ++read 2048/2048 bytes at offset 2572288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2576384 ++read 2048/2048 bytes at offset 2576384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2580480 ++read 2048/2048 bytes at offset 2580480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2584576 ++read 2048/2048 bytes at offset 2584576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2588672 ++read 2048/2048 bytes at offset 2588672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2592768 ++read 2048/2048 bytes at offset 2592768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2596864 ++read 2048/2048 bytes at offset 2596864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2600960 ++read 2048/2048 bytes at offset 2600960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2605056 ++read 2048/2048 bytes at offset 2605056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2609152 ++read 2048/2048 bytes at offset 2609152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2613248 ++read 2048/2048 bytes at offset 2613248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2617344 ++read 2048/2048 bytes at offset 2617344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2621440 ++read 2048/2048 bytes at offset 2621440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2625536 ++read 2048/2048 bytes at offset 2625536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2629632 ++read 2048/2048 bytes at offset 2629632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2633728 ++read 2048/2048 bytes at offset 2633728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2637824 ++read 2048/2048 bytes at offset 2637824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2641920 ++read 2048/2048 bytes at offset 2641920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2646016 ++read 2048/2048 bytes at offset 2646016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2650112 ++read 2048/2048 bytes at offset 2650112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2654208 ++read 2048/2048 bytes at offset 2654208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2658304 ++read 2048/2048 bytes at offset 2658304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2662400 ++read 2048/2048 bytes at offset 2662400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2666496 ++read 2048/2048 bytes at offset 2666496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2670592 ++read 2048/2048 bytes at offset 2670592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2674688 ++read 2048/2048 bytes at offset 2674688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2678784 ++read 2048/2048 bytes at offset 2678784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2682880 ++read 2048/2048 bytes at offset 2682880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2686976 ++read 2048/2048 bytes at offset 2686976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2691072 ++read 2048/2048 bytes at offset 2691072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2695168 ++read 2048/2048 bytes at offset 2695168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2699264 ++read 2048/2048 bytes at offset 2699264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2703360 ++read 2048/2048 bytes at offset 2703360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2707456 ++read 2048/2048 bytes at offset 2707456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2711552 ++read 2048/2048 bytes at offset 2711552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2715648 ++read 2048/2048 bytes at offset 2715648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2719744 ++read 2048/2048 bytes at offset 2719744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2723840 ++read 2048/2048 bytes at offset 2723840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2727936 ++read 2048/2048 bytes at offset 2727936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2732032 ++read 2048/2048 bytes at offset 2732032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2736128 ++read 2048/2048 bytes at offset 2736128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2740224 ++read 2048/2048 bytes at offset 2740224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2744320 ++read 2048/2048 bytes at offset 2744320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2748416 ++read 2048/2048 bytes at offset 2748416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2752512 ++read 2048/2048 bytes at offset 2752512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2756608 ++read 2048/2048 bytes at offset 2756608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2760704 ++read 2048/2048 bytes at offset 2760704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2764800 ++read 2048/2048 bytes at offset 2764800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2768896 ++read 2048/2048 bytes at offset 2768896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2772992 ++read 2048/2048 bytes at offset 2772992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2777088 ++read 2048/2048 bytes at offset 2777088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2781184 ++read 2048/2048 bytes at offset 2781184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2785280 ++read 2048/2048 bytes at offset 2785280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2789376 ++read 2048/2048 bytes at offset 2789376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2793472 ++read 2048/2048 bytes at offset 2793472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2797568 ++read 2048/2048 bytes at offset 2797568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2801664 ++read 2048/2048 bytes at offset 2801664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2805760 ++read 2048/2048 bytes at offset 2805760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2809856 ++read 2048/2048 bytes at offset 2809856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2813952 ++read 2048/2048 bytes at offset 2813952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2818048 ++read 2048/2048 bytes at offset 2818048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2822144 ++read 2048/2048 bytes at offset 2822144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2826240 ++read 2048/2048 bytes at offset 2826240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2830336 ++read 2048/2048 bytes at offset 2830336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2834432 ++read 2048/2048 bytes at offset 2834432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2838528 ++read 2048/2048 bytes at offset 2838528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2842624 ++read 2048/2048 bytes at offset 2842624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2846720 ++read 2048/2048 bytes at offset 2846720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2850816 ++read 2048/2048 bytes at offset 2850816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2854912 ++read 2048/2048 bytes at offset 2854912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2859008 ++read 2048/2048 bytes at offset 2859008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2863104 ++read 2048/2048 bytes at offset 2863104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2867200 ++read 2048/2048 bytes at offset 2867200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2871296 ++read 2048/2048 bytes at offset 2871296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2875392 ++read 2048/2048 bytes at offset 2875392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2879488 ++read 2048/2048 bytes at offset 2879488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2883584 ++read 2048/2048 bytes at offset 2883584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2887680 ++read 2048/2048 bytes at offset 2887680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2891776 ++read 2048/2048 bytes at offset 2891776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2895872 ++read 2048/2048 bytes at offset 2895872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2899968 ++read 2048/2048 bytes at offset 2899968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2904064 ++read 2048/2048 bytes at offset 2904064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2908160 ++read 2048/2048 bytes at offset 2908160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2912256 ++read 2048/2048 bytes at offset 2912256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2916352 ++read 2048/2048 bytes at offset 2916352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2920448 ++read 2048/2048 bytes at offset 2920448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2924544 ++read 2048/2048 bytes at offset 2924544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2928640 ++read 2048/2048 bytes at offset 2928640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2932736 ++read 2048/2048 bytes at offset 2932736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2936832 ++read 2048/2048 bytes at offset 2936832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2940928 ++read 2048/2048 bytes at offset 2940928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2945024 ++read 2048/2048 bytes at offset 2945024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2949120 ++read 2048/2048 bytes at offset 2949120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2953216 ++read 2048/2048 bytes at offset 2953216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2957312 ++read 2048/2048 bytes at offset 2957312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2961408 ++read 2048/2048 bytes at offset 2961408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2965504 ++read 2048/2048 bytes at offset 2965504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2969600 ++read 2048/2048 bytes at offset 2969600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2973696 ++read 2048/2048 bytes at offset 2973696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2977792 ++read 2048/2048 bytes at offset 2977792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2981888 ++read 2048/2048 bytes at offset 2981888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2985984 ++read 2048/2048 bytes at offset 2985984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2990080 ++read 2048/2048 bytes at offset 2990080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2994176 ++read 2048/2048 bytes at offset 2994176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2998272 ++read 2048/2048 bytes at offset 2998272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3002368 ++read 2048/2048 bytes at offset 3002368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3006464 ++read 2048/2048 bytes at offset 3006464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3010560 ++read 2048/2048 bytes at offset 3010560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3014656 ++read 2048/2048 bytes at offset 3014656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3018752 ++read 2048/2048 bytes at offset 3018752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3022848 ++read 2048/2048 bytes at offset 3022848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3026944 ++read 2048/2048 bytes at offset 3026944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3031040 ++read 2048/2048 bytes at offset 3031040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3035136 ++read 2048/2048 bytes at offset 3035136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3039232 ++read 2048/2048 bytes at offset 3039232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3043328 ++read 2048/2048 bytes at offset 3043328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3047424 ++read 2048/2048 bytes at offset 3047424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3051520 ++read 2048/2048 bytes at offset 3051520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3055616 ++read 2048/2048 bytes at offset 3055616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3059712 ++read 2048/2048 bytes at offset 3059712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3063808 ++read 2048/2048 bytes at offset 3063808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3067904 ++read 2048/2048 bytes at offset 3067904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3072000 ++read 2048/2048 bytes at offset 3072000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3076096 ++read 2048/2048 bytes at offset 3076096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3080192 ++read 2048/2048 bytes at offset 3080192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3084288 ++read 2048/2048 bytes at offset 3084288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3088384 ++read 2048/2048 bytes at offset 3088384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3092480 ++read 2048/2048 bytes at offset 3092480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3096576 ++read 2048/2048 bytes at offset 3096576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3100672 ++read 2048/2048 bytes at offset 3100672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3104768 ++read 2048/2048 bytes at offset 3104768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3108864 ++read 2048/2048 bytes at offset 3108864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3112960 ++read 2048/2048 bytes at offset 3112960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3117056 ++read 2048/2048 bytes at offset 3117056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3121152 ++read 2048/2048 bytes at offset 3121152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3125248 ++read 2048/2048 bytes at offset 3125248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3129344 ++read 2048/2048 bytes at offset 3129344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3133440 ++read 2048/2048 bytes at offset 3133440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3137536 ++read 2048/2048 bytes at offset 3137536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3141632 ++read 2048/2048 bytes at offset 3141632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 2 +-qemu-io> read 2048/2048 bytes at offset 3146752 ++=== IO: pattern 2 ++read 2048/2048 bytes at offset 3146752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3150848 ++read 2048/2048 bytes at offset 3150848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3154944 ++read 2048/2048 bytes at offset 3154944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3159040 ++read 2048/2048 bytes at offset 3159040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3163136 ++read 2048/2048 bytes at offset 3163136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3167232 ++read 2048/2048 bytes at offset 3167232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3171328 ++read 2048/2048 bytes at offset 3171328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3175424 ++read 2048/2048 bytes at offset 3175424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3179520 ++read 2048/2048 bytes at offset 3179520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3183616 ++read 2048/2048 bytes at offset 3183616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3187712 ++read 2048/2048 bytes at offset 3187712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3191808 ++read 2048/2048 bytes at offset 3191808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3195904 ++read 2048/2048 bytes at offset 3195904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3200000 ++read 2048/2048 bytes at offset 3200000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3204096 ++read 2048/2048 bytes at offset 3204096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3208192 ++read 2048/2048 bytes at offset 3208192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3212288 ++read 2048/2048 bytes at offset 3212288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3216384 ++read 2048/2048 bytes at offset 3216384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3220480 ++read 2048/2048 bytes at offset 3220480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3224576 ++read 2048/2048 bytes at offset 3224576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3228672 ++read 2048/2048 bytes at offset 3228672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3232768 ++read 2048/2048 bytes at offset 3232768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3236864 ++read 2048/2048 bytes at offset 3236864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3240960 ++read 2048/2048 bytes at offset 3240960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3245056 ++read 2048/2048 bytes at offset 3245056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3249152 ++read 2048/2048 bytes at offset 3249152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3253248 ++read 2048/2048 bytes at offset 3253248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3257344 ++read 2048/2048 bytes at offset 3257344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3261440 ++read 2048/2048 bytes at offset 3261440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3265536 ++read 2048/2048 bytes at offset 3265536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3269632 ++read 2048/2048 bytes at offset 3269632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3273728 ++read 2048/2048 bytes at offset 3273728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3277824 ++read 2048/2048 bytes at offset 3277824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3281920 ++read 2048/2048 bytes at offset 3281920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3286016 ++read 2048/2048 bytes at offset 3286016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3290112 ++read 2048/2048 bytes at offset 3290112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3294208 ++read 2048/2048 bytes at offset 3294208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3298304 ++read 2048/2048 bytes at offset 3298304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3302400 ++read 2048/2048 bytes at offset 3302400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3306496 ++read 2048/2048 bytes at offset 3306496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3310592 ++read 2048/2048 bytes at offset 3310592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3314688 ++read 2048/2048 bytes at offset 3314688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3318784 ++read 2048/2048 bytes at offset 3318784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3322880 ++read 2048/2048 bytes at offset 3322880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3326976 ++read 2048/2048 bytes at offset 3326976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3331072 ++read 2048/2048 bytes at offset 3331072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3335168 ++read 2048/2048 bytes at offset 3335168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3339264 ++read 2048/2048 bytes at offset 3339264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3343360 ++read 2048/2048 bytes at offset 3343360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3347456 ++read 2048/2048 bytes at offset 3347456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3351552 ++read 2048/2048 bytes at offset 3351552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3355648 ++read 2048/2048 bytes at offset 3355648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3359744 ++read 2048/2048 bytes at offset 3359744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3363840 ++read 2048/2048 bytes at offset 3363840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3367936 ++read 2048/2048 bytes at offset 3367936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3372032 ++read 2048/2048 bytes at offset 3372032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3376128 ++read 2048/2048 bytes at offset 3376128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3380224 ++read 2048/2048 bytes at offset 3380224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3384320 ++read 2048/2048 bytes at offset 3384320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3388416 ++read 2048/2048 bytes at offset 3388416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3392512 ++read 2048/2048 bytes at offset 3392512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3396608 ++read 2048/2048 bytes at offset 3396608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3400704 ++read 2048/2048 bytes at offset 3400704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3404800 ++read 2048/2048 bytes at offset 3404800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3408896 ++read 2048/2048 bytes at offset 3408896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3412992 ++read 2048/2048 bytes at offset 3412992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3417088 ++read 2048/2048 bytes at offset 3417088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3421184 ++read 2048/2048 bytes at offset 3421184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3425280 ++read 2048/2048 bytes at offset 3425280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3429376 ++read 2048/2048 bytes at offset 3429376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3433472 ++read 2048/2048 bytes at offset 3433472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3437568 ++read 2048/2048 bytes at offset 3437568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3441664 ++read 2048/2048 bytes at offset 3441664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3445760 ++read 2048/2048 bytes at offset 3445760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3449856 ++read 2048/2048 bytes at offset 3449856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3453952 ++read 2048/2048 bytes at offset 3453952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3458048 ++read 2048/2048 bytes at offset 3458048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3462144 ++read 2048/2048 bytes at offset 3462144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3466240 ++read 2048/2048 bytes at offset 3466240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3470336 ++read 2048/2048 bytes at offset 3470336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3474432 ++read 2048/2048 bytes at offset 3474432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3478528 ++read 2048/2048 bytes at offset 3478528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3482624 ++read 2048/2048 bytes at offset 3482624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3486720 ++read 2048/2048 bytes at offset 3486720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3490816 ++read 2048/2048 bytes at offset 3490816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3494912 ++read 2048/2048 bytes at offset 3494912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3499008 ++read 2048/2048 bytes at offset 3499008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3503104 ++read 2048/2048 bytes at offset 3503104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3507200 ++read 2048/2048 bytes at offset 3507200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3511296 ++read 2048/2048 bytes at offset 3511296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3515392 ++read 2048/2048 bytes at offset 3515392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3519488 ++read 2048/2048 bytes at offset 3519488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3523584 ++read 2048/2048 bytes at offset 3523584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3527680 ++read 2048/2048 bytes at offset 3527680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3531776 ++read 2048/2048 bytes at offset 3531776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3535872 ++read 2048/2048 bytes at offset 3535872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3539968 ++read 2048/2048 bytes at offset 3539968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3544064 ++read 2048/2048 bytes at offset 3544064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3548160 ++read 2048/2048 bytes at offset 3548160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3552256 ++read 2048/2048 bytes at offset 3552256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3556352 ++read 2048/2048 bytes at offset 3556352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3560448 ++read 2048/2048 bytes at offset 3560448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3564544 ++read 2048/2048 bytes at offset 3564544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3568640 ++read 2048/2048 bytes at offset 3568640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3572736 ++read 2048/2048 bytes at offset 3572736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3576832 ++read 2048/2048 bytes at offset 3576832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3580928 ++read 2048/2048 bytes at offset 3580928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3585024 ++read 2048/2048 bytes at offset 3585024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3589120 ++read 2048/2048 bytes at offset 3589120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3593216 ++read 2048/2048 bytes at offset 3593216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3597312 ++read 2048/2048 bytes at offset 3597312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3601408 ++read 2048/2048 bytes at offset 3601408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3605504 ++read 2048/2048 bytes at offset 3605504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3609600 ++read 2048/2048 bytes at offset 3609600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3613696 ++read 2048/2048 bytes at offset 3613696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3617792 ++read 2048/2048 bytes at offset 3617792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3621888 ++read 2048/2048 bytes at offset 3621888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3625984 ++read 2048/2048 bytes at offset 3625984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3630080 ++read 2048/2048 bytes at offset 3630080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3634176 ++read 2048/2048 bytes at offset 3634176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3638272 ++read 2048/2048 bytes at offset 3638272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3642368 ++read 2048/2048 bytes at offset 3642368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3646464 ++read 2048/2048 bytes at offset 3646464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3650560 ++read 2048/2048 bytes at offset 3650560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3654656 ++read 2048/2048 bytes at offset 3654656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3658752 ++read 2048/2048 bytes at offset 3658752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3662848 ++read 2048/2048 bytes at offset 3662848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3666944 ++read 2048/2048 bytes at offset 3666944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3671040 ++read 2048/2048 bytes at offset 3671040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3675136 ++read 2048/2048 bytes at offset 3675136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3679232 ++read 2048/2048 bytes at offset 3679232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3683328 ++read 2048/2048 bytes at offset 3683328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3687424 ++read 2048/2048 bytes at offset 3687424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3691520 ++read 2048/2048 bytes at offset 3691520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3695616 ++read 2048/2048 bytes at offset 3695616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3699712 ++read 2048/2048 bytes at offset 3699712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3703808 ++read 2048/2048 bytes at offset 3703808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3707904 ++read 2048/2048 bytes at offset 3707904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3712000 ++read 2048/2048 bytes at offset 3712000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3716096 ++read 2048/2048 bytes at offset 3716096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3720192 ++read 2048/2048 bytes at offset 3720192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3724288 ++read 2048/2048 bytes at offset 3724288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3728384 ++read 2048/2048 bytes at offset 3728384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3732480 ++read 2048/2048 bytes at offset 3732480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3736576 ++read 2048/2048 bytes at offset 3736576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3740672 ++read 2048/2048 bytes at offset 3740672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3744768 ++read 2048/2048 bytes at offset 3744768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3748864 ++read 2048/2048 bytes at offset 3748864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3752960 ++read 2048/2048 bytes at offset 3752960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3757056 ++read 2048/2048 bytes at offset 3757056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3761152 ++read 2048/2048 bytes at offset 3761152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3765248 ++read 2048/2048 bytes at offset 3765248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3769344 ++read 2048/2048 bytes at offset 3769344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3773440 ++read 2048/2048 bytes at offset 3773440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3777536 ++read 2048/2048 bytes at offset 3777536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3781632 ++read 2048/2048 bytes at offset 3781632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3785728 ++read 2048/2048 bytes at offset 3785728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3789824 ++read 2048/2048 bytes at offset 3789824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3793920 ++read 2048/2048 bytes at offset 3793920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3798016 ++read 2048/2048 bytes at offset 3798016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3802112 ++read 2048/2048 bytes at offset 3802112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3806208 ++read 2048/2048 bytes at offset 3806208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3810304 ++read 2048/2048 bytes at offset 3810304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3814400 ++read 2048/2048 bytes at offset 3814400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3818496 ++read 2048/2048 bytes at offset 3818496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3822592 ++read 2048/2048 bytes at offset 3822592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3826688 ++read 2048/2048 bytes at offset 3826688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3830784 ++read 2048/2048 bytes at offset 3830784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3834880 ++read 2048/2048 bytes at offset 3834880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3838976 ++read 2048/2048 bytes at offset 3838976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3843072 ++read 2048/2048 bytes at offset 3843072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3847168 ++read 2048/2048 bytes at offset 3847168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3851264 ++read 2048/2048 bytes at offset 3851264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3855360 ++read 2048/2048 bytes at offset 3855360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3859456 ++read 2048/2048 bytes at offset 3859456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3863552 ++read 2048/2048 bytes at offset 3863552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3867648 ++read 2048/2048 bytes at offset 3867648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3871744 ++read 2048/2048 bytes at offset 3871744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3875840 ++read 2048/2048 bytes at offset 3875840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3879936 ++read 2048/2048 bytes at offset 3879936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3884032 ++read 2048/2048 bytes at offset 3884032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3888128 ++read 2048/2048 bytes at offset 3888128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3892224 ++read 2048/2048 bytes at offset 3892224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3896320 ++read 2048/2048 bytes at offset 3896320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3900416 ++read 2048/2048 bytes at offset 3900416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3904512 ++read 2048/2048 bytes at offset 3904512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3908608 ++read 2048/2048 bytes at offset 3908608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3912704 ++read 2048/2048 bytes at offset 3912704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3916800 ++read 2048/2048 bytes at offset 3916800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3920896 ++read 2048/2048 bytes at offset 3920896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3924992 ++read 2048/2048 bytes at offset 3924992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3929088 ++read 2048/2048 bytes at offset 3929088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3933184 ++read 2048/2048 bytes at offset 3933184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3937280 ++read 2048/2048 bytes at offset 3937280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3941376 ++read 2048/2048 bytes at offset 3941376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3945472 ++read 2048/2048 bytes at offset 3945472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3949568 ++read 2048/2048 bytes at offset 3949568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3953664 ++read 2048/2048 bytes at offset 3953664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3957760 ++read 2048/2048 bytes at offset 3957760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3961856 ++read 2048/2048 bytes at offset 3961856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3965952 ++read 2048/2048 bytes at offset 3965952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3970048 ++read 2048/2048 bytes at offset 3970048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3974144 ++read 2048/2048 bytes at offset 3974144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3978240 ++read 2048/2048 bytes at offset 3978240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3982336 ++read 2048/2048 bytes at offset 3982336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3986432 ++read 2048/2048 bytes at offset 3986432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3990528 ++read 2048/2048 bytes at offset 3990528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3994624 ++read 2048/2048 bytes at offset 3994624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3998720 ++read 2048/2048 bytes at offset 3998720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4002816 ++read 2048/2048 bytes at offset 4002816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4006912 ++read 2048/2048 bytes at offset 4006912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4011008 ++read 2048/2048 bytes at offset 4011008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4015104 ++read 2048/2048 bytes at offset 4015104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4019200 ++read 2048/2048 bytes at offset 4019200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4023296 ++read 2048/2048 bytes at offset 4023296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4027392 ++read 2048/2048 bytes at offset 4027392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4031488 ++read 2048/2048 bytes at offset 4031488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4035584 ++read 2048/2048 bytes at offset 4035584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4039680 ++read 2048/2048 bytes at offset 4039680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4043776 ++read 2048/2048 bytes at offset 4043776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4047872 ++read 2048/2048 bytes at offset 4047872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4051968 ++read 2048/2048 bytes at offset 4051968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4056064 ++read 2048/2048 bytes at offset 4056064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4060160 ++read 2048/2048 bytes at offset 4060160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4064256 ++read 2048/2048 bytes at offset 4064256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4068352 ++read 2048/2048 bytes at offset 4068352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4072448 ++read 2048/2048 bytes at offset 4072448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4076544 ++read 2048/2048 bytes at offset 4076544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4080640 ++read 2048/2048 bytes at offset 4080640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4084736 ++read 2048/2048 bytes at offset 4084736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4088832 ++read 2048/2048 bytes at offset 4088832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4092928 ++read 2048/2048 bytes at offset 4092928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4097024 ++read 2048/2048 bytes at offset 4097024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4101120 ++read 2048/2048 bytes at offset 4101120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4105216 ++read 2048/2048 bytes at offset 4105216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4109312 ++read 2048/2048 bytes at offset 4109312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4113408 ++read 2048/2048 bytes at offset 4113408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4117504 ++read 2048/2048 bytes at offset 4117504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4121600 ++read 2048/2048 bytes at offset 4121600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4125696 ++read 2048/2048 bytes at offset 4125696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4129792 ++read 2048/2048 bytes at offset 4129792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4133888 ++read 2048/2048 bytes at offset 4133888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4137984 ++read 2048/2048 bytes at offset 4137984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4142080 ++read 2048/2048 bytes at offset 4142080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4146176 ++read 2048/2048 bytes at offset 4146176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4150272 ++read 2048/2048 bytes at offset 4150272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4154368 ++read 2048/2048 bytes at offset 4154368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4158464 ++read 2048/2048 bytes at offset 4158464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4162560 ++read 2048/2048 bytes at offset 4162560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4166656 ++read 2048/2048 bytes at offset 4166656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4170752 ++read 2048/2048 bytes at offset 4170752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4174848 ++read 2048/2048 bytes at offset 4174848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4178944 ++read 2048/2048 bytes at offset 4178944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4183040 ++read 2048/2048 bytes at offset 4183040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4187136 ++read 2048/2048 bytes at offset 4187136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4191232 ++read 2048/2048 bytes at offset 4191232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 4 +-qemu-io> read 8192/8192 bytes at offset 4196352 ++=== IO: pattern 4 ++read 8192/8192 bytes at offset 4196352 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4208640 ++read 8192/8192 bytes at offset 4208640 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4220928 ++read 8192/8192 bytes at offset 4220928 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4233216 ++read 8192/8192 bytes at offset 4233216 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4245504 ++read 8192/8192 bytes at offset 4245504 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4257792 ++read 8192/8192 bytes at offset 4257792 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4270080 ++read 8192/8192 bytes at offset 4270080 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4282368 ++read 8192/8192 bytes at offset 4282368 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4294656 ++read 8192/8192 bytes at offset 4294656 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4306944 ++read 8192/8192 bytes at offset 4306944 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4319232 ++read 8192/8192 bytes at offset 4319232 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4331520 ++read 8192/8192 bytes at offset 4331520 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4343808 ++read 8192/8192 bytes at offset 4343808 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4356096 ++read 8192/8192 bytes at offset 4356096 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4368384 ++read 8192/8192 bytes at offset 4368384 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4380672 ++read 8192/8192 bytes at offset 4380672 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4392960 ++read 8192/8192 bytes at offset 4392960 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4405248 ++read 8192/8192 bytes at offset 4405248 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4417536 ++read 8192/8192 bytes at offset 4417536 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4429824 ++read 8192/8192 bytes at offset 4429824 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4442112 ++read 8192/8192 bytes at offset 4442112 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4454400 ++read 8192/8192 bytes at offset 4454400 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4466688 ++read 8192/8192 bytes at offset 4466688 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4478976 ++read 8192/8192 bytes at offset 4478976 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4491264 ++read 8192/8192 bytes at offset 4491264 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4503552 ++read 8192/8192 bytes at offset 4503552 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4515840 ++read 8192/8192 bytes at offset 4515840 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4528128 ++read 8192/8192 bytes at offset 4528128 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4540416 ++read 8192/8192 bytes at offset 4540416 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4552704 ++read 8192/8192 bytes at offset 4552704 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4564992 ++read 8192/8192 bytes at offset 4564992 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4577280 ++read 8192/8192 bytes at offset 4577280 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4589568 ++read 8192/8192 bytes at offset 4589568 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4601856 ++read 8192/8192 bytes at offset 4601856 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4614144 ++read 8192/8192 bytes at offset 4614144 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4626432 ++read 8192/8192 bytes at offset 4626432 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4638720 ++read 8192/8192 bytes at offset 4638720 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4651008 ++read 8192/8192 bytes at offset 4651008 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4663296 ++read 8192/8192 bytes at offset 4663296 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4675584 ++read 8192/8192 bytes at offset 4675584 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4687872 ++read 8192/8192 bytes at offset 4687872 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4700160 ++read 8192/8192 bytes at offset 4700160 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4712448 ++read 8192/8192 bytes at offset 4712448 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4724736 ++read 8192/8192 bytes at offset 4724736 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4737024 ++read 8192/8192 bytes at offset 4737024 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4749312 ++read 8192/8192 bytes at offset 4749312 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4761600 ++read 8192/8192 bytes at offset 4761600 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4773888 ++read 8192/8192 bytes at offset 4773888 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4786176 ++read 8192/8192 bytes at offset 4786176 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4798464 ++read 8192/8192 bytes at offset 4798464 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4810752 ++read 8192/8192 bytes at offset 4810752 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4823040 ++read 8192/8192 bytes at offset 4823040 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4835328 ++read 8192/8192 bytes at offset 4835328 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4847616 ++read 8192/8192 bytes at offset 4847616 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4859904 ++read 8192/8192 bytes at offset 4859904 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4872192 ++read 8192/8192 bytes at offset 4872192 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4884480 ++read 8192/8192 bytes at offset 4884480 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4896768 ++read 8192/8192 bytes at offset 4896768 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4909056 ++read 8192/8192 bytes at offset 4909056 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4921344 ++read 8192/8192 bytes at offset 4921344 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4933632 ++read 8192/8192 bytes at offset 4933632 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4945920 ++read 8192/8192 bytes at offset 4945920 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4958208 ++read 8192/8192 bytes at offset 4958208 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4970496 ++read 8192/8192 bytes at offset 4970496 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 244 +-qemu-io> read 12288/12288 bytes at offset 6285312 ++=== IO: pattern 244 ++read 12288/12288 bytes at offset 6285312 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 8384512 ++read 12288/12288 bytes at offset 8384512 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 10483712 ++read 12288/12288 bytes at offset 10483712 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 12582912 ++read 12288/12288 bytes at offset 12582912 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 14682112 ++read 12288/12288 bytes at offset 14682112 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 16781312 ++read 12288/12288 bytes at offset 16781312 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 18880512 ++read 12288/12288 bytes at offset 18880512 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 20979712 ++read 12288/12288 bytes at offset 20979712 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> No errors were found on the image. ++No errors were found on the image. + With snapshot test2, offset 4294967296 + === IO: pattern 0 +-qemu-io> wrote 4096/4096 bytes at offset 4294967296 ++wrote 4096/4096 bytes at offset 4294967296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4294971392 ++wrote 4096/4096 bytes at offset 4294971392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4294975488 ++wrote 4096/4096 bytes at offset 4294975488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4294979584 ++wrote 4096/4096 bytes at offset 4294979584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4294983680 ++wrote 4096/4096 bytes at offset 4294983680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4294987776 ++wrote 4096/4096 bytes at offset 4294987776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4294991872 ++wrote 4096/4096 bytes at offset 4294991872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4294995968 ++wrote 4096/4096 bytes at offset 4294995968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295000064 ++wrote 4096/4096 bytes at offset 4295000064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295004160 ++wrote 4096/4096 bytes at offset 4295004160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295008256 ++wrote 4096/4096 bytes at offset 4295008256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295012352 ++wrote 4096/4096 bytes at offset 4295012352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295016448 ++wrote 4096/4096 bytes at offset 4295016448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295020544 ++wrote 4096/4096 bytes at offset 4295020544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295024640 ++wrote 4096/4096 bytes at offset 4295024640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295028736 ++wrote 4096/4096 bytes at offset 4295028736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295032832 ++wrote 4096/4096 bytes at offset 4295032832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295036928 ++wrote 4096/4096 bytes at offset 4295036928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295041024 ++wrote 4096/4096 bytes at offset 4295041024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295045120 ++wrote 4096/4096 bytes at offset 4295045120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295049216 ++wrote 4096/4096 bytes at offset 4295049216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295053312 ++wrote 4096/4096 bytes at offset 4295053312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295057408 ++wrote 4096/4096 bytes at offset 4295057408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295061504 ++wrote 4096/4096 bytes at offset 4295061504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295065600 ++wrote 4096/4096 bytes at offset 4295065600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295069696 ++wrote 4096/4096 bytes at offset 4295069696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295073792 ++wrote 4096/4096 bytes at offset 4295073792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295077888 ++wrote 4096/4096 bytes at offset 4295077888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295081984 ++wrote 4096/4096 bytes at offset 4295081984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295086080 ++wrote 4096/4096 bytes at offset 4295086080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295090176 ++wrote 4096/4096 bytes at offset 4295090176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295094272 ++wrote 4096/4096 bytes at offset 4295094272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295098368 ++wrote 4096/4096 bytes at offset 4295098368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295102464 ++wrote 4096/4096 bytes at offset 4295102464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295106560 ++wrote 4096/4096 bytes at offset 4295106560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295110656 ++wrote 4096/4096 bytes at offset 4295110656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295114752 ++wrote 4096/4096 bytes at offset 4295114752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295118848 ++wrote 4096/4096 bytes at offset 4295118848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295122944 ++wrote 4096/4096 bytes at offset 4295122944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295127040 ++wrote 4096/4096 bytes at offset 4295127040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295131136 ++wrote 4096/4096 bytes at offset 4295131136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295135232 ++wrote 4096/4096 bytes at offset 4295135232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295139328 ++wrote 4096/4096 bytes at offset 4295139328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295143424 ++wrote 4096/4096 bytes at offset 4295143424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295147520 ++wrote 4096/4096 bytes at offset 4295147520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295151616 ++wrote 4096/4096 bytes at offset 4295151616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295155712 ++wrote 4096/4096 bytes at offset 4295155712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295159808 ++wrote 4096/4096 bytes at offset 4295159808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295163904 ++wrote 4096/4096 bytes at offset 4295163904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295168000 ++wrote 4096/4096 bytes at offset 4295168000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295172096 ++wrote 4096/4096 bytes at offset 4295172096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295176192 ++wrote 4096/4096 bytes at offset 4295176192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295180288 ++wrote 4096/4096 bytes at offset 4295180288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295184384 ++wrote 4096/4096 bytes at offset 4295184384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295188480 ++wrote 4096/4096 bytes at offset 4295188480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295192576 ++wrote 4096/4096 bytes at offset 4295192576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295196672 ++wrote 4096/4096 bytes at offset 4295196672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295200768 ++wrote 4096/4096 bytes at offset 4295200768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295204864 ++wrote 4096/4096 bytes at offset 4295204864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295208960 ++wrote 4096/4096 bytes at offset 4295208960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295213056 ++wrote 4096/4096 bytes at offset 4295213056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295217152 ++wrote 4096/4096 bytes at offset 4295217152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295221248 ++wrote 4096/4096 bytes at offset 4295221248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295225344 ++wrote 4096/4096 bytes at offset 4295225344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295229440 ++wrote 4096/4096 bytes at offset 4295229440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295233536 ++wrote 4096/4096 bytes at offset 4295233536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295237632 ++wrote 4096/4096 bytes at offset 4295237632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295241728 ++wrote 4096/4096 bytes at offset 4295241728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295245824 ++wrote 4096/4096 bytes at offset 4295245824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295249920 ++wrote 4096/4096 bytes at offset 4295249920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295254016 ++wrote 4096/4096 bytes at offset 4295254016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295258112 ++wrote 4096/4096 bytes at offset 4295258112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295262208 ++wrote 4096/4096 bytes at offset 4295262208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295266304 ++wrote 4096/4096 bytes at offset 4295266304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295270400 ++wrote 4096/4096 bytes at offset 4295270400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295274496 ++wrote 4096/4096 bytes at offset 4295274496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295278592 ++wrote 4096/4096 bytes at offset 4295278592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295282688 ++wrote 4096/4096 bytes at offset 4295282688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295286784 ++wrote 4096/4096 bytes at offset 4295286784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295290880 ++wrote 4096/4096 bytes at offset 4295290880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295294976 ++wrote 4096/4096 bytes at offset 4295294976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295299072 ++wrote 4096/4096 bytes at offset 4295299072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295303168 ++wrote 4096/4096 bytes at offset 4295303168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295307264 ++wrote 4096/4096 bytes at offset 4295307264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295311360 ++wrote 4096/4096 bytes at offset 4295311360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295315456 ++wrote 4096/4096 bytes at offset 4295315456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295319552 ++wrote 4096/4096 bytes at offset 4295319552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295323648 ++wrote 4096/4096 bytes at offset 4295323648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295327744 ++wrote 4096/4096 bytes at offset 4295327744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295331840 ++wrote 4096/4096 bytes at offset 4295331840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295335936 ++wrote 4096/4096 bytes at offset 4295335936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295340032 ++wrote 4096/4096 bytes at offset 4295340032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295344128 ++wrote 4096/4096 bytes at offset 4295344128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295348224 ++wrote 4096/4096 bytes at offset 4295348224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295352320 ++wrote 4096/4096 bytes at offset 4295352320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295356416 ++wrote 4096/4096 bytes at offset 4295356416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295360512 ++wrote 4096/4096 bytes at offset 4295360512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295364608 ++wrote 4096/4096 bytes at offset 4295364608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295368704 ++wrote 4096/4096 bytes at offset 4295368704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295372800 ++wrote 4096/4096 bytes at offset 4295372800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295376896 ++wrote 4096/4096 bytes at offset 4295376896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295380992 ++wrote 4096/4096 bytes at offset 4295380992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295385088 ++wrote 4096/4096 bytes at offset 4295385088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295389184 ++wrote 4096/4096 bytes at offset 4295389184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295393280 ++wrote 4096/4096 bytes at offset 4295393280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295397376 ++wrote 4096/4096 bytes at offset 4295397376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295401472 ++wrote 4096/4096 bytes at offset 4295401472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295405568 ++wrote 4096/4096 bytes at offset 4295405568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295409664 ++wrote 4096/4096 bytes at offset 4295409664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295413760 ++wrote 4096/4096 bytes at offset 4295413760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295417856 ++wrote 4096/4096 bytes at offset 4295417856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295421952 ++wrote 4096/4096 bytes at offset 4295421952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295426048 ++wrote 4096/4096 bytes at offset 4295426048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295430144 ++wrote 4096/4096 bytes at offset 4295430144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295434240 ++wrote 4096/4096 bytes at offset 4295434240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295438336 ++wrote 4096/4096 bytes at offset 4295438336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295442432 ++wrote 4096/4096 bytes at offset 4295442432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295446528 ++wrote 4096/4096 bytes at offset 4295446528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295450624 ++wrote 4096/4096 bytes at offset 4295450624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295454720 ++wrote 4096/4096 bytes at offset 4295454720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295458816 ++wrote 4096/4096 bytes at offset 4295458816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295462912 ++wrote 4096/4096 bytes at offset 4295462912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295467008 ++wrote 4096/4096 bytes at offset 4295467008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295471104 ++wrote 4096/4096 bytes at offset 4295471104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295475200 ++wrote 4096/4096 bytes at offset 4295475200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295479296 ++wrote 4096/4096 bytes at offset 4295479296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295483392 ++wrote 4096/4096 bytes at offset 4295483392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295487488 ++wrote 4096/4096 bytes at offset 4295487488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295491584 ++wrote 4096/4096 bytes at offset 4295491584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295495680 ++wrote 4096/4096 bytes at offset 4295495680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295499776 ++wrote 4096/4096 bytes at offset 4295499776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295503872 ++wrote 4096/4096 bytes at offset 4295503872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295507968 ++wrote 4096/4096 bytes at offset 4295507968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295512064 ++wrote 4096/4096 bytes at offset 4295512064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295516160 ++wrote 4096/4096 bytes at offset 4295516160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295520256 ++wrote 4096/4096 bytes at offset 4295520256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295524352 ++wrote 4096/4096 bytes at offset 4295524352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295528448 ++wrote 4096/4096 bytes at offset 4295528448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295532544 ++wrote 4096/4096 bytes at offset 4295532544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295536640 ++wrote 4096/4096 bytes at offset 4295536640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295540736 ++wrote 4096/4096 bytes at offset 4295540736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295544832 ++wrote 4096/4096 bytes at offset 4295544832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295548928 ++wrote 4096/4096 bytes at offset 4295548928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295553024 ++wrote 4096/4096 bytes at offset 4295553024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295557120 ++wrote 4096/4096 bytes at offset 4295557120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295561216 ++wrote 4096/4096 bytes at offset 4295561216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295565312 ++wrote 4096/4096 bytes at offset 4295565312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295569408 ++wrote 4096/4096 bytes at offset 4295569408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295573504 ++wrote 4096/4096 bytes at offset 4295573504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295577600 ++wrote 4096/4096 bytes at offset 4295577600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295581696 ++wrote 4096/4096 bytes at offset 4295581696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295585792 ++wrote 4096/4096 bytes at offset 4295585792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295589888 ++wrote 4096/4096 bytes at offset 4295589888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295593984 ++wrote 4096/4096 bytes at offset 4295593984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295598080 ++wrote 4096/4096 bytes at offset 4295598080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295602176 ++wrote 4096/4096 bytes at offset 4295602176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295606272 ++wrote 4096/4096 bytes at offset 4295606272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295610368 ++wrote 4096/4096 bytes at offset 4295610368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295614464 ++wrote 4096/4096 bytes at offset 4295614464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295618560 ++wrote 4096/4096 bytes at offset 4295618560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295622656 ++wrote 4096/4096 bytes at offset 4295622656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295626752 ++wrote 4096/4096 bytes at offset 4295626752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295630848 ++wrote 4096/4096 bytes at offset 4295630848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295634944 ++wrote 4096/4096 bytes at offset 4295634944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295639040 ++wrote 4096/4096 bytes at offset 4295639040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295643136 ++wrote 4096/4096 bytes at offset 4295643136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295647232 ++wrote 4096/4096 bytes at offset 4295647232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295651328 ++wrote 4096/4096 bytes at offset 4295651328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295655424 ++wrote 4096/4096 bytes at offset 4295655424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295659520 ++wrote 4096/4096 bytes at offset 4295659520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295663616 ++wrote 4096/4096 bytes at offset 4295663616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295667712 ++wrote 4096/4096 bytes at offset 4295667712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295671808 ++wrote 4096/4096 bytes at offset 4295671808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295675904 ++wrote 4096/4096 bytes at offset 4295675904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295680000 ++wrote 4096/4096 bytes at offset 4295680000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295684096 ++wrote 4096/4096 bytes at offset 4295684096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295688192 ++wrote 4096/4096 bytes at offset 4295688192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295692288 ++wrote 4096/4096 bytes at offset 4295692288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295696384 ++wrote 4096/4096 bytes at offset 4295696384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295700480 ++wrote 4096/4096 bytes at offset 4295700480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295704576 ++wrote 4096/4096 bytes at offset 4295704576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295708672 ++wrote 4096/4096 bytes at offset 4295708672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295712768 ++wrote 4096/4096 bytes at offset 4295712768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295716864 ++wrote 4096/4096 bytes at offset 4295716864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295720960 ++wrote 4096/4096 bytes at offset 4295720960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295725056 ++wrote 4096/4096 bytes at offset 4295725056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295729152 ++wrote 4096/4096 bytes at offset 4295729152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295733248 ++wrote 4096/4096 bytes at offset 4295733248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295737344 ++wrote 4096/4096 bytes at offset 4295737344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295741440 ++wrote 4096/4096 bytes at offset 4295741440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295745536 ++wrote 4096/4096 bytes at offset 4295745536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295749632 ++wrote 4096/4096 bytes at offset 4295749632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295753728 ++wrote 4096/4096 bytes at offset 4295753728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295757824 ++wrote 4096/4096 bytes at offset 4295757824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295761920 ++wrote 4096/4096 bytes at offset 4295761920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295766016 ++wrote 4096/4096 bytes at offset 4295766016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295770112 ++wrote 4096/4096 bytes at offset 4295770112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295774208 ++wrote 4096/4096 bytes at offset 4295774208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295778304 ++wrote 4096/4096 bytes at offset 4295778304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295782400 ++wrote 4096/4096 bytes at offset 4295782400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295786496 ++wrote 4096/4096 bytes at offset 4295786496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295790592 ++wrote 4096/4096 bytes at offset 4295790592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295794688 ++wrote 4096/4096 bytes at offset 4295794688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295798784 ++wrote 4096/4096 bytes at offset 4295798784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295802880 ++wrote 4096/4096 bytes at offset 4295802880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295806976 ++wrote 4096/4096 bytes at offset 4295806976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295811072 ++wrote 4096/4096 bytes at offset 4295811072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295815168 ++wrote 4096/4096 bytes at offset 4295815168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295819264 ++wrote 4096/4096 bytes at offset 4295819264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295823360 ++wrote 4096/4096 bytes at offset 4295823360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295827456 ++wrote 4096/4096 bytes at offset 4295827456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295831552 ++wrote 4096/4096 bytes at offset 4295831552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295835648 ++wrote 4096/4096 bytes at offset 4295835648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295839744 ++wrote 4096/4096 bytes at offset 4295839744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295843840 ++wrote 4096/4096 bytes at offset 4295843840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295847936 ++wrote 4096/4096 bytes at offset 4295847936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295852032 ++wrote 4096/4096 bytes at offset 4295852032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295856128 ++wrote 4096/4096 bytes at offset 4295856128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295860224 ++wrote 4096/4096 bytes at offset 4295860224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295864320 ++wrote 4096/4096 bytes at offset 4295864320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295868416 ++wrote 4096/4096 bytes at offset 4295868416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295872512 ++wrote 4096/4096 bytes at offset 4295872512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295876608 ++wrote 4096/4096 bytes at offset 4295876608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295880704 ++wrote 4096/4096 bytes at offset 4295880704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295884800 ++wrote 4096/4096 bytes at offset 4295884800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295888896 ++wrote 4096/4096 bytes at offset 4295888896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295892992 ++wrote 4096/4096 bytes at offset 4295892992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295897088 ++wrote 4096/4096 bytes at offset 4295897088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295901184 ++wrote 4096/4096 bytes at offset 4295901184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295905280 ++wrote 4096/4096 bytes at offset 4295905280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295909376 ++wrote 4096/4096 bytes at offset 4295909376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295913472 ++wrote 4096/4096 bytes at offset 4295913472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295917568 ++wrote 4096/4096 bytes at offset 4295917568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295921664 ++wrote 4096/4096 bytes at offset 4295921664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295925760 ++wrote 4096/4096 bytes at offset 4295925760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295929856 ++wrote 4096/4096 bytes at offset 4295929856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295933952 ++wrote 4096/4096 bytes at offset 4295933952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295938048 ++wrote 4096/4096 bytes at offset 4295938048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295942144 ++wrote 4096/4096 bytes at offset 4295942144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295946240 ++wrote 4096/4096 bytes at offset 4295946240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295950336 ++wrote 4096/4096 bytes at offset 4295950336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295954432 ++wrote 4096/4096 bytes at offset 4295954432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295958528 ++wrote 4096/4096 bytes at offset 4295958528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295962624 ++wrote 4096/4096 bytes at offset 4295962624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295966720 ++wrote 4096/4096 bytes at offset 4295966720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295970816 ++wrote 4096/4096 bytes at offset 4295970816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295974912 ++wrote 4096/4096 bytes at offset 4295974912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295979008 ++wrote 4096/4096 bytes at offset 4295979008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295983104 ++wrote 4096/4096 bytes at offset 4295983104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295987200 ++wrote 4096/4096 bytes at offset 4295987200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295991296 ++wrote 4096/4096 bytes at offset 4295991296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295995392 ++wrote 4096/4096 bytes at offset 4295995392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295999488 ++wrote 4096/4096 bytes at offset 4295999488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296003584 ++wrote 4096/4096 bytes at offset 4296003584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296007680 ++wrote 4096/4096 bytes at offset 4296007680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296011776 ++wrote 4096/4096 bytes at offset 4296011776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 4 +-qemu-io> wrote 2048/2048 bytes at offset 4296017920 ++=== IO: pattern 4 ++wrote 2048/2048 bytes at offset 4296017920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296022016 ++wrote 2048/2048 bytes at offset 4296022016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296026112 ++wrote 2048/2048 bytes at offset 4296026112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296030208 ++wrote 2048/2048 bytes at offset 4296030208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296034304 ++wrote 2048/2048 bytes at offset 4296034304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296038400 ++wrote 2048/2048 bytes at offset 4296038400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296042496 ++wrote 2048/2048 bytes at offset 4296042496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296046592 ++wrote 2048/2048 bytes at offset 4296046592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296050688 ++wrote 2048/2048 bytes at offset 4296050688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296054784 ++wrote 2048/2048 bytes at offset 4296054784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296058880 ++wrote 2048/2048 bytes at offset 4296058880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296062976 ++wrote 2048/2048 bytes at offset 4296062976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296067072 ++wrote 2048/2048 bytes at offset 4296067072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296071168 ++wrote 2048/2048 bytes at offset 4296071168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296075264 ++wrote 2048/2048 bytes at offset 4296075264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296079360 ++wrote 2048/2048 bytes at offset 4296079360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296083456 ++wrote 2048/2048 bytes at offset 4296083456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296087552 ++wrote 2048/2048 bytes at offset 4296087552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296091648 ++wrote 2048/2048 bytes at offset 4296091648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296095744 ++wrote 2048/2048 bytes at offset 4296095744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296099840 ++wrote 2048/2048 bytes at offset 4296099840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296103936 ++wrote 2048/2048 bytes at offset 4296103936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296108032 ++wrote 2048/2048 bytes at offset 4296108032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296112128 ++wrote 2048/2048 bytes at offset 4296112128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296116224 ++wrote 2048/2048 bytes at offset 4296116224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296120320 ++wrote 2048/2048 bytes at offset 4296120320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296124416 ++wrote 2048/2048 bytes at offset 4296124416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296128512 ++wrote 2048/2048 bytes at offset 4296128512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296132608 ++wrote 2048/2048 bytes at offset 4296132608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296136704 ++wrote 2048/2048 bytes at offset 4296136704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296140800 ++wrote 2048/2048 bytes at offset 4296140800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296144896 ++wrote 2048/2048 bytes at offset 4296144896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296148992 ++wrote 2048/2048 bytes at offset 4296148992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296153088 ++wrote 2048/2048 bytes at offset 4296153088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296157184 ++wrote 2048/2048 bytes at offset 4296157184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296161280 ++wrote 2048/2048 bytes at offset 4296161280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296165376 ++wrote 2048/2048 bytes at offset 4296165376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296169472 ++wrote 2048/2048 bytes at offset 4296169472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296173568 ++wrote 2048/2048 bytes at offset 4296173568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296177664 ++wrote 2048/2048 bytes at offset 4296177664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296181760 ++wrote 2048/2048 bytes at offset 4296181760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296185856 ++wrote 2048/2048 bytes at offset 4296185856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296189952 ++wrote 2048/2048 bytes at offset 4296189952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296194048 ++wrote 2048/2048 bytes at offset 4296194048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296198144 ++wrote 2048/2048 bytes at offset 4296198144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296202240 ++wrote 2048/2048 bytes at offset 4296202240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296206336 ++wrote 2048/2048 bytes at offset 4296206336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296210432 ++wrote 2048/2048 bytes at offset 4296210432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296214528 ++wrote 2048/2048 bytes at offset 4296214528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296218624 ++wrote 2048/2048 bytes at offset 4296218624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296222720 ++wrote 2048/2048 bytes at offset 4296222720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296226816 ++wrote 2048/2048 bytes at offset 4296226816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296230912 ++wrote 2048/2048 bytes at offset 4296230912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296235008 ++wrote 2048/2048 bytes at offset 4296235008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296239104 ++wrote 2048/2048 bytes at offset 4296239104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296243200 ++wrote 2048/2048 bytes at offset 4296243200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296247296 ++wrote 2048/2048 bytes at offset 4296247296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296251392 ++wrote 2048/2048 bytes at offset 4296251392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296255488 ++wrote 2048/2048 bytes at offset 4296255488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296259584 ++wrote 2048/2048 bytes at offset 4296259584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296263680 ++wrote 2048/2048 bytes at offset 4296263680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296267776 ++wrote 2048/2048 bytes at offset 4296267776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296271872 ++wrote 2048/2048 bytes at offset 4296271872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296275968 ++wrote 2048/2048 bytes at offset 4296275968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296280064 ++wrote 2048/2048 bytes at offset 4296280064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296284160 ++wrote 2048/2048 bytes at offset 4296284160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296288256 ++wrote 2048/2048 bytes at offset 4296288256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296292352 ++wrote 2048/2048 bytes at offset 4296292352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296296448 ++wrote 2048/2048 bytes at offset 4296296448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296300544 ++wrote 2048/2048 bytes at offset 4296300544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296304640 ++wrote 2048/2048 bytes at offset 4296304640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296308736 ++wrote 2048/2048 bytes at offset 4296308736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296312832 ++wrote 2048/2048 bytes at offset 4296312832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296316928 ++wrote 2048/2048 bytes at offset 4296316928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296321024 ++wrote 2048/2048 bytes at offset 4296321024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296325120 ++wrote 2048/2048 bytes at offset 4296325120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296329216 ++wrote 2048/2048 bytes at offset 4296329216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296333312 ++wrote 2048/2048 bytes at offset 4296333312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296337408 ++wrote 2048/2048 bytes at offset 4296337408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296341504 ++wrote 2048/2048 bytes at offset 4296341504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296345600 ++wrote 2048/2048 bytes at offset 4296345600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296349696 ++wrote 2048/2048 bytes at offset 4296349696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296353792 ++wrote 2048/2048 bytes at offset 4296353792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296357888 ++wrote 2048/2048 bytes at offset 4296357888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296361984 ++wrote 2048/2048 bytes at offset 4296361984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296366080 ++wrote 2048/2048 bytes at offset 4296366080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296370176 ++wrote 2048/2048 bytes at offset 4296370176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296374272 ++wrote 2048/2048 bytes at offset 4296374272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296378368 ++wrote 2048/2048 bytes at offset 4296378368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296382464 ++wrote 2048/2048 bytes at offset 4296382464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296386560 ++wrote 2048/2048 bytes at offset 4296386560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296390656 ++wrote 2048/2048 bytes at offset 4296390656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296394752 ++wrote 2048/2048 bytes at offset 4296394752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296398848 ++wrote 2048/2048 bytes at offset 4296398848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296402944 ++wrote 2048/2048 bytes at offset 4296402944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296407040 ++wrote 2048/2048 bytes at offset 4296407040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296411136 ++wrote 2048/2048 bytes at offset 4296411136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296415232 ++wrote 2048/2048 bytes at offset 4296415232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296419328 ++wrote 2048/2048 bytes at offset 4296419328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296423424 ++wrote 2048/2048 bytes at offset 4296423424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296427520 ++wrote 2048/2048 bytes at offset 4296427520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296431616 ++wrote 2048/2048 bytes at offset 4296431616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296435712 ++wrote 2048/2048 bytes at offset 4296435712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296439808 ++wrote 2048/2048 bytes at offset 4296439808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296443904 ++wrote 2048/2048 bytes at offset 4296443904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296448000 ++wrote 2048/2048 bytes at offset 4296448000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296452096 ++wrote 2048/2048 bytes at offset 4296452096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296456192 ++wrote 2048/2048 bytes at offset 4296456192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296460288 ++wrote 2048/2048 bytes at offset 4296460288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296464384 ++wrote 2048/2048 bytes at offset 4296464384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296468480 ++wrote 2048/2048 bytes at offset 4296468480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296472576 ++wrote 2048/2048 bytes at offset 4296472576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296476672 ++wrote 2048/2048 bytes at offset 4296476672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296480768 ++wrote 2048/2048 bytes at offset 4296480768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296484864 ++wrote 2048/2048 bytes at offset 4296484864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296488960 ++wrote 2048/2048 bytes at offset 4296488960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296493056 ++wrote 2048/2048 bytes at offset 4296493056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296497152 ++wrote 2048/2048 bytes at offset 4296497152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296501248 ++wrote 2048/2048 bytes at offset 4296501248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296505344 ++wrote 2048/2048 bytes at offset 4296505344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296509440 ++wrote 2048/2048 bytes at offset 4296509440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296513536 ++wrote 2048/2048 bytes at offset 4296513536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296517632 ++wrote 2048/2048 bytes at offset 4296517632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296521728 ++wrote 2048/2048 bytes at offset 4296521728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296525824 ++wrote 2048/2048 bytes at offset 4296525824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296529920 ++wrote 2048/2048 bytes at offset 4296529920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296534016 ++wrote 2048/2048 bytes at offset 4296534016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296538112 ++wrote 2048/2048 bytes at offset 4296538112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296542208 ++wrote 2048/2048 bytes at offset 4296542208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296546304 ++wrote 2048/2048 bytes at offset 4296546304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296550400 ++wrote 2048/2048 bytes at offset 4296550400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296554496 ++wrote 2048/2048 bytes at offset 4296554496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296558592 ++wrote 2048/2048 bytes at offset 4296558592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296562688 ++wrote 2048/2048 bytes at offset 4296562688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296566784 ++wrote 2048/2048 bytes at offset 4296566784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296570880 ++wrote 2048/2048 bytes at offset 4296570880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296574976 ++wrote 2048/2048 bytes at offset 4296574976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296579072 ++wrote 2048/2048 bytes at offset 4296579072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296583168 ++wrote 2048/2048 bytes at offset 4296583168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296587264 ++wrote 2048/2048 bytes at offset 4296587264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296591360 ++wrote 2048/2048 bytes at offset 4296591360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296595456 ++wrote 2048/2048 bytes at offset 4296595456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296599552 ++wrote 2048/2048 bytes at offset 4296599552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296603648 ++wrote 2048/2048 bytes at offset 4296603648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296607744 ++wrote 2048/2048 bytes at offset 4296607744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296611840 ++wrote 2048/2048 bytes at offset 4296611840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296615936 ++wrote 2048/2048 bytes at offset 4296615936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296620032 ++wrote 2048/2048 bytes at offset 4296620032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296624128 ++wrote 2048/2048 bytes at offset 4296624128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296628224 ++wrote 2048/2048 bytes at offset 4296628224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296632320 ++wrote 2048/2048 bytes at offset 4296632320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296636416 ++wrote 2048/2048 bytes at offset 4296636416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296640512 ++wrote 2048/2048 bytes at offset 4296640512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296644608 ++wrote 2048/2048 bytes at offset 4296644608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296648704 ++wrote 2048/2048 bytes at offset 4296648704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296652800 ++wrote 2048/2048 bytes at offset 4296652800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296656896 ++wrote 2048/2048 bytes at offset 4296656896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296660992 ++wrote 2048/2048 bytes at offset 4296660992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296665088 ++wrote 2048/2048 bytes at offset 4296665088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296669184 ++wrote 2048/2048 bytes at offset 4296669184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296673280 ++wrote 2048/2048 bytes at offset 4296673280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296677376 ++wrote 2048/2048 bytes at offset 4296677376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296681472 ++wrote 2048/2048 bytes at offset 4296681472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296685568 ++wrote 2048/2048 bytes at offset 4296685568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296689664 ++wrote 2048/2048 bytes at offset 4296689664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296693760 ++wrote 2048/2048 bytes at offset 4296693760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296697856 ++wrote 2048/2048 bytes at offset 4296697856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296701952 ++wrote 2048/2048 bytes at offset 4296701952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296706048 ++wrote 2048/2048 bytes at offset 4296706048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296710144 ++wrote 2048/2048 bytes at offset 4296710144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296714240 ++wrote 2048/2048 bytes at offset 4296714240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296718336 ++wrote 2048/2048 bytes at offset 4296718336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296722432 ++wrote 2048/2048 bytes at offset 4296722432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296726528 ++wrote 2048/2048 bytes at offset 4296726528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296730624 ++wrote 2048/2048 bytes at offset 4296730624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296734720 ++wrote 2048/2048 bytes at offset 4296734720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296738816 ++wrote 2048/2048 bytes at offset 4296738816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296742912 ++wrote 2048/2048 bytes at offset 4296742912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296747008 ++wrote 2048/2048 bytes at offset 4296747008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296751104 ++wrote 2048/2048 bytes at offset 4296751104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296755200 ++wrote 2048/2048 bytes at offset 4296755200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296759296 ++wrote 2048/2048 bytes at offset 4296759296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296763392 ++wrote 2048/2048 bytes at offset 4296763392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296767488 ++wrote 2048/2048 bytes at offset 4296767488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296771584 ++wrote 2048/2048 bytes at offset 4296771584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296775680 ++wrote 2048/2048 bytes at offset 4296775680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296779776 ++wrote 2048/2048 bytes at offset 4296779776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296783872 ++wrote 2048/2048 bytes at offset 4296783872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296787968 ++wrote 2048/2048 bytes at offset 4296787968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296792064 ++wrote 2048/2048 bytes at offset 4296792064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296796160 ++wrote 2048/2048 bytes at offset 4296796160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296800256 ++wrote 2048/2048 bytes at offset 4296800256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296804352 ++wrote 2048/2048 bytes at offset 4296804352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296808448 ++wrote 2048/2048 bytes at offset 4296808448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296812544 ++wrote 2048/2048 bytes at offset 4296812544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296816640 ++wrote 2048/2048 bytes at offset 4296816640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296820736 ++wrote 2048/2048 bytes at offset 4296820736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296824832 ++wrote 2048/2048 bytes at offset 4296824832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296828928 ++wrote 2048/2048 bytes at offset 4296828928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296833024 ++wrote 2048/2048 bytes at offset 4296833024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296837120 ++wrote 2048/2048 bytes at offset 4296837120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296841216 ++wrote 2048/2048 bytes at offset 4296841216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296845312 ++wrote 2048/2048 bytes at offset 4296845312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296849408 ++wrote 2048/2048 bytes at offset 4296849408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296853504 ++wrote 2048/2048 bytes at offset 4296853504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296857600 ++wrote 2048/2048 bytes at offset 4296857600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296861696 ++wrote 2048/2048 bytes at offset 4296861696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296865792 ++wrote 2048/2048 bytes at offset 4296865792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296869888 ++wrote 2048/2048 bytes at offset 4296869888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296873984 ++wrote 2048/2048 bytes at offset 4296873984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296878080 ++wrote 2048/2048 bytes at offset 4296878080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296882176 ++wrote 2048/2048 bytes at offset 4296882176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296886272 ++wrote 2048/2048 bytes at offset 4296886272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296890368 ++wrote 2048/2048 bytes at offset 4296890368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296894464 ++wrote 2048/2048 bytes at offset 4296894464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296898560 ++wrote 2048/2048 bytes at offset 4296898560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296902656 ++wrote 2048/2048 bytes at offset 4296902656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296906752 ++wrote 2048/2048 bytes at offset 4296906752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296910848 ++wrote 2048/2048 bytes at offset 4296910848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296914944 ++wrote 2048/2048 bytes at offset 4296914944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296919040 ++wrote 2048/2048 bytes at offset 4296919040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296923136 ++wrote 2048/2048 bytes at offset 4296923136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296927232 ++wrote 2048/2048 bytes at offset 4296927232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296931328 ++wrote 2048/2048 bytes at offset 4296931328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296935424 ++wrote 2048/2048 bytes at offset 4296935424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296939520 ++wrote 2048/2048 bytes at offset 4296939520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296943616 ++wrote 2048/2048 bytes at offset 4296943616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296947712 ++wrote 2048/2048 bytes at offset 4296947712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296951808 ++wrote 2048/2048 bytes at offset 4296951808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296955904 ++wrote 2048/2048 bytes at offset 4296955904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296960000 ++wrote 2048/2048 bytes at offset 4296960000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296964096 ++wrote 2048/2048 bytes at offset 4296964096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296968192 ++wrote 2048/2048 bytes at offset 4296968192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296972288 ++wrote 2048/2048 bytes at offset 4296972288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296976384 ++wrote 2048/2048 bytes at offset 4296976384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296980480 ++wrote 2048/2048 bytes at offset 4296980480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296984576 ++wrote 2048/2048 bytes at offset 4296984576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296988672 ++wrote 2048/2048 bytes at offset 4296988672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296992768 ++wrote 2048/2048 bytes at offset 4296992768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296996864 ++wrote 2048/2048 bytes at offset 4296996864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297000960 ++wrote 2048/2048 bytes at offset 4297000960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297005056 ++wrote 2048/2048 bytes at offset 4297005056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297009152 ++wrote 2048/2048 bytes at offset 4297009152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297013248 ++wrote 2048/2048 bytes at offset 4297013248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297017344 ++wrote 2048/2048 bytes at offset 4297017344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297021440 ++wrote 2048/2048 bytes at offset 4297021440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297025536 ++wrote 2048/2048 bytes at offset 4297025536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297029632 ++wrote 2048/2048 bytes at offset 4297029632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297033728 ++wrote 2048/2048 bytes at offset 4297033728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297037824 ++wrote 2048/2048 bytes at offset 4297037824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297041920 ++wrote 2048/2048 bytes at offset 4297041920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297046016 ++wrote 2048/2048 bytes at offset 4297046016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297050112 ++wrote 2048/2048 bytes at offset 4297050112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297054208 ++wrote 2048/2048 bytes at offset 4297054208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297058304 ++wrote 2048/2048 bytes at offset 4297058304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297062400 ++wrote 2048/2048 bytes at offset 4297062400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> wrote 2048/2048 bytes at offset 4297064448 ++=== IO: pattern 0 ++wrote 2048/2048 bytes at offset 4297064448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297068544 ++wrote 2048/2048 bytes at offset 4297068544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297072640 ++wrote 2048/2048 bytes at offset 4297072640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297076736 ++wrote 2048/2048 bytes at offset 4297076736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297080832 ++wrote 2048/2048 bytes at offset 4297080832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297084928 ++wrote 2048/2048 bytes at offset 4297084928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297089024 ++wrote 2048/2048 bytes at offset 4297089024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297093120 ++wrote 2048/2048 bytes at offset 4297093120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297097216 ++wrote 2048/2048 bytes at offset 4297097216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297101312 ++wrote 2048/2048 bytes at offset 4297101312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297105408 ++wrote 2048/2048 bytes at offset 4297105408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297109504 ++wrote 2048/2048 bytes at offset 4297109504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297113600 ++wrote 2048/2048 bytes at offset 4297113600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297117696 ++wrote 2048/2048 bytes at offset 4297117696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297121792 ++wrote 2048/2048 bytes at offset 4297121792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297125888 ++wrote 2048/2048 bytes at offset 4297125888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297129984 ++wrote 2048/2048 bytes at offset 4297129984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297134080 ++wrote 2048/2048 bytes at offset 4297134080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297138176 ++wrote 2048/2048 bytes at offset 4297138176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297142272 ++wrote 2048/2048 bytes at offset 4297142272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297146368 ++wrote 2048/2048 bytes at offset 4297146368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297150464 ++wrote 2048/2048 bytes at offset 4297150464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297154560 ++wrote 2048/2048 bytes at offset 4297154560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297158656 ++wrote 2048/2048 bytes at offset 4297158656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297162752 ++wrote 2048/2048 bytes at offset 4297162752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297166848 ++wrote 2048/2048 bytes at offset 4297166848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297170944 ++wrote 2048/2048 bytes at offset 4297170944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297175040 ++wrote 2048/2048 bytes at offset 4297175040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297179136 ++wrote 2048/2048 bytes at offset 4297179136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297183232 ++wrote 2048/2048 bytes at offset 4297183232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297187328 ++wrote 2048/2048 bytes at offset 4297187328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297191424 ++wrote 2048/2048 bytes at offset 4297191424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297195520 ++wrote 2048/2048 bytes at offset 4297195520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297199616 ++wrote 2048/2048 bytes at offset 4297199616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297203712 ++wrote 2048/2048 bytes at offset 4297203712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297207808 ++wrote 2048/2048 bytes at offset 4297207808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297211904 ++wrote 2048/2048 bytes at offset 4297211904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297216000 ++wrote 2048/2048 bytes at offset 4297216000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297220096 ++wrote 2048/2048 bytes at offset 4297220096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297224192 ++wrote 2048/2048 bytes at offset 4297224192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297228288 ++wrote 2048/2048 bytes at offset 4297228288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297232384 ++wrote 2048/2048 bytes at offset 4297232384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297236480 ++wrote 2048/2048 bytes at offset 4297236480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297240576 ++wrote 2048/2048 bytes at offset 4297240576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297244672 ++wrote 2048/2048 bytes at offset 4297244672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297248768 ++wrote 2048/2048 bytes at offset 4297248768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297252864 ++wrote 2048/2048 bytes at offset 4297252864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297256960 ++wrote 2048/2048 bytes at offset 4297256960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297261056 ++wrote 2048/2048 bytes at offset 4297261056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297265152 ++wrote 2048/2048 bytes at offset 4297265152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297269248 ++wrote 2048/2048 bytes at offset 4297269248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297273344 ++wrote 2048/2048 bytes at offset 4297273344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297277440 ++wrote 2048/2048 bytes at offset 4297277440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297281536 ++wrote 2048/2048 bytes at offset 4297281536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297285632 ++wrote 2048/2048 bytes at offset 4297285632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297289728 ++wrote 2048/2048 bytes at offset 4297289728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297293824 ++wrote 2048/2048 bytes at offset 4297293824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297297920 ++wrote 2048/2048 bytes at offset 4297297920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297302016 ++wrote 2048/2048 bytes at offset 4297302016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297306112 ++wrote 2048/2048 bytes at offset 4297306112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297310208 ++wrote 2048/2048 bytes at offset 4297310208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297314304 ++wrote 2048/2048 bytes at offset 4297314304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297318400 ++wrote 2048/2048 bytes at offset 4297318400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297322496 ++wrote 2048/2048 bytes at offset 4297322496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297326592 ++wrote 2048/2048 bytes at offset 4297326592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297330688 ++wrote 2048/2048 bytes at offset 4297330688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297334784 ++wrote 2048/2048 bytes at offset 4297334784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297338880 ++wrote 2048/2048 bytes at offset 4297338880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297342976 ++wrote 2048/2048 bytes at offset 4297342976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297347072 ++wrote 2048/2048 bytes at offset 4297347072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297351168 ++wrote 2048/2048 bytes at offset 4297351168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297355264 ++wrote 2048/2048 bytes at offset 4297355264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297359360 ++wrote 2048/2048 bytes at offset 4297359360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297363456 ++wrote 2048/2048 bytes at offset 4297363456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297367552 ++wrote 2048/2048 bytes at offset 4297367552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297371648 ++wrote 2048/2048 bytes at offset 4297371648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297375744 ++wrote 2048/2048 bytes at offset 4297375744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297379840 ++wrote 2048/2048 bytes at offset 4297379840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297383936 ++wrote 2048/2048 bytes at offset 4297383936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297388032 ++wrote 2048/2048 bytes at offset 4297388032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297392128 ++wrote 2048/2048 bytes at offset 4297392128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297396224 ++wrote 2048/2048 bytes at offset 4297396224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297400320 ++wrote 2048/2048 bytes at offset 4297400320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297404416 ++wrote 2048/2048 bytes at offset 4297404416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297408512 ++wrote 2048/2048 bytes at offset 4297408512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297412608 ++wrote 2048/2048 bytes at offset 4297412608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297416704 ++wrote 2048/2048 bytes at offset 4297416704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297420800 ++wrote 2048/2048 bytes at offset 4297420800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297424896 ++wrote 2048/2048 bytes at offset 4297424896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297428992 ++wrote 2048/2048 bytes at offset 4297428992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297433088 ++wrote 2048/2048 bytes at offset 4297433088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297437184 ++wrote 2048/2048 bytes at offset 4297437184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297441280 ++wrote 2048/2048 bytes at offset 4297441280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297445376 ++wrote 2048/2048 bytes at offset 4297445376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297449472 ++wrote 2048/2048 bytes at offset 4297449472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297453568 ++wrote 2048/2048 bytes at offset 4297453568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297457664 ++wrote 2048/2048 bytes at offset 4297457664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297461760 ++wrote 2048/2048 bytes at offset 4297461760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297465856 ++wrote 2048/2048 bytes at offset 4297465856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297469952 ++wrote 2048/2048 bytes at offset 4297469952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297474048 ++wrote 2048/2048 bytes at offset 4297474048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297478144 ++wrote 2048/2048 bytes at offset 4297478144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297482240 ++wrote 2048/2048 bytes at offset 4297482240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297486336 ++wrote 2048/2048 bytes at offset 4297486336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297490432 ++wrote 2048/2048 bytes at offset 4297490432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297494528 ++wrote 2048/2048 bytes at offset 4297494528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297498624 ++wrote 2048/2048 bytes at offset 4297498624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297502720 ++wrote 2048/2048 bytes at offset 4297502720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297506816 ++wrote 2048/2048 bytes at offset 4297506816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297510912 ++wrote 2048/2048 bytes at offset 4297510912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297515008 ++wrote 2048/2048 bytes at offset 4297515008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297519104 ++wrote 2048/2048 bytes at offset 4297519104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297523200 ++wrote 2048/2048 bytes at offset 4297523200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297527296 ++wrote 2048/2048 bytes at offset 4297527296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297531392 ++wrote 2048/2048 bytes at offset 4297531392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297535488 ++wrote 2048/2048 bytes at offset 4297535488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297539584 ++wrote 2048/2048 bytes at offset 4297539584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297543680 ++wrote 2048/2048 bytes at offset 4297543680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297547776 ++wrote 2048/2048 bytes at offset 4297547776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297551872 ++wrote 2048/2048 bytes at offset 4297551872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297555968 ++wrote 2048/2048 bytes at offset 4297555968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297560064 ++wrote 2048/2048 bytes at offset 4297560064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297564160 ++wrote 2048/2048 bytes at offset 4297564160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297568256 ++wrote 2048/2048 bytes at offset 4297568256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297572352 ++wrote 2048/2048 bytes at offset 4297572352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297576448 ++wrote 2048/2048 bytes at offset 4297576448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297580544 ++wrote 2048/2048 bytes at offset 4297580544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297584640 ++wrote 2048/2048 bytes at offset 4297584640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297588736 ++wrote 2048/2048 bytes at offset 4297588736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297592832 ++wrote 2048/2048 bytes at offset 4297592832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297596928 ++wrote 2048/2048 bytes at offset 4297596928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297601024 ++wrote 2048/2048 bytes at offset 4297601024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297605120 ++wrote 2048/2048 bytes at offset 4297605120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297609216 ++wrote 2048/2048 bytes at offset 4297609216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297613312 ++wrote 2048/2048 bytes at offset 4297613312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297617408 ++wrote 2048/2048 bytes at offset 4297617408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297621504 ++wrote 2048/2048 bytes at offset 4297621504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297625600 ++wrote 2048/2048 bytes at offset 4297625600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297629696 ++wrote 2048/2048 bytes at offset 4297629696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297633792 ++wrote 2048/2048 bytes at offset 4297633792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297637888 ++wrote 2048/2048 bytes at offset 4297637888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297641984 ++wrote 2048/2048 bytes at offset 4297641984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297646080 ++wrote 2048/2048 bytes at offset 4297646080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297650176 ++wrote 2048/2048 bytes at offset 4297650176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297654272 ++wrote 2048/2048 bytes at offset 4297654272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297658368 ++wrote 2048/2048 bytes at offset 4297658368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297662464 ++wrote 2048/2048 bytes at offset 4297662464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297666560 ++wrote 2048/2048 bytes at offset 4297666560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297670656 ++wrote 2048/2048 bytes at offset 4297670656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297674752 ++wrote 2048/2048 bytes at offset 4297674752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297678848 ++wrote 2048/2048 bytes at offset 4297678848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297682944 ++wrote 2048/2048 bytes at offset 4297682944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297687040 ++wrote 2048/2048 bytes at offset 4297687040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297691136 ++wrote 2048/2048 bytes at offset 4297691136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297695232 ++wrote 2048/2048 bytes at offset 4297695232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297699328 ++wrote 2048/2048 bytes at offset 4297699328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297703424 ++wrote 2048/2048 bytes at offset 4297703424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297707520 ++wrote 2048/2048 bytes at offset 4297707520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297711616 ++wrote 2048/2048 bytes at offset 4297711616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297715712 ++wrote 2048/2048 bytes at offset 4297715712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297719808 ++wrote 2048/2048 bytes at offset 4297719808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297723904 ++wrote 2048/2048 bytes at offset 4297723904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297728000 ++wrote 2048/2048 bytes at offset 4297728000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297732096 ++wrote 2048/2048 bytes at offset 4297732096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297736192 ++wrote 2048/2048 bytes at offset 4297736192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297740288 ++wrote 2048/2048 bytes at offset 4297740288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297744384 ++wrote 2048/2048 bytes at offset 4297744384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297748480 ++wrote 2048/2048 bytes at offset 4297748480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297752576 ++wrote 2048/2048 bytes at offset 4297752576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297756672 ++wrote 2048/2048 bytes at offset 4297756672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297760768 ++wrote 2048/2048 bytes at offset 4297760768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297764864 ++wrote 2048/2048 bytes at offset 4297764864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297768960 ++wrote 2048/2048 bytes at offset 4297768960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297773056 ++wrote 2048/2048 bytes at offset 4297773056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297777152 ++wrote 2048/2048 bytes at offset 4297777152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297781248 ++wrote 2048/2048 bytes at offset 4297781248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297785344 ++wrote 2048/2048 bytes at offset 4297785344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297789440 ++wrote 2048/2048 bytes at offset 4297789440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297793536 ++wrote 2048/2048 bytes at offset 4297793536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297797632 ++wrote 2048/2048 bytes at offset 4297797632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297801728 ++wrote 2048/2048 bytes at offset 4297801728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297805824 ++wrote 2048/2048 bytes at offset 4297805824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297809920 ++wrote 2048/2048 bytes at offset 4297809920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297814016 ++wrote 2048/2048 bytes at offset 4297814016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297818112 ++wrote 2048/2048 bytes at offset 4297818112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297822208 ++wrote 2048/2048 bytes at offset 4297822208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297826304 ++wrote 2048/2048 bytes at offset 4297826304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297830400 ++wrote 2048/2048 bytes at offset 4297830400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297834496 ++wrote 2048/2048 bytes at offset 4297834496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297838592 ++wrote 2048/2048 bytes at offset 4297838592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297842688 ++wrote 2048/2048 bytes at offset 4297842688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297846784 ++wrote 2048/2048 bytes at offset 4297846784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297850880 ++wrote 2048/2048 bytes at offset 4297850880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297854976 ++wrote 2048/2048 bytes at offset 4297854976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297859072 ++wrote 2048/2048 bytes at offset 4297859072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297863168 ++wrote 2048/2048 bytes at offset 4297863168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297867264 ++wrote 2048/2048 bytes at offset 4297867264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297871360 ++wrote 2048/2048 bytes at offset 4297871360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297875456 ++wrote 2048/2048 bytes at offset 4297875456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297879552 ++wrote 2048/2048 bytes at offset 4297879552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297883648 ++wrote 2048/2048 bytes at offset 4297883648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297887744 ++wrote 2048/2048 bytes at offset 4297887744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297891840 ++wrote 2048/2048 bytes at offset 4297891840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297895936 ++wrote 2048/2048 bytes at offset 4297895936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297900032 ++wrote 2048/2048 bytes at offset 4297900032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297904128 ++wrote 2048/2048 bytes at offset 4297904128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297908224 ++wrote 2048/2048 bytes at offset 4297908224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297912320 ++wrote 2048/2048 bytes at offset 4297912320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297916416 ++wrote 2048/2048 bytes at offset 4297916416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297920512 ++wrote 2048/2048 bytes at offset 4297920512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297924608 ++wrote 2048/2048 bytes at offset 4297924608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297928704 ++wrote 2048/2048 bytes at offset 4297928704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297932800 ++wrote 2048/2048 bytes at offset 4297932800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297936896 ++wrote 2048/2048 bytes at offset 4297936896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297940992 ++wrote 2048/2048 bytes at offset 4297940992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297945088 ++wrote 2048/2048 bytes at offset 4297945088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297949184 ++wrote 2048/2048 bytes at offset 4297949184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297953280 ++wrote 2048/2048 bytes at offset 4297953280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297957376 ++wrote 2048/2048 bytes at offset 4297957376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297961472 ++wrote 2048/2048 bytes at offset 4297961472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297965568 ++wrote 2048/2048 bytes at offset 4297965568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297969664 ++wrote 2048/2048 bytes at offset 4297969664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297973760 ++wrote 2048/2048 bytes at offset 4297973760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297977856 ++wrote 2048/2048 bytes at offset 4297977856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297981952 ++wrote 2048/2048 bytes at offset 4297981952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297986048 ++wrote 2048/2048 bytes at offset 4297986048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297990144 ++wrote 2048/2048 bytes at offset 4297990144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297994240 ++wrote 2048/2048 bytes at offset 4297994240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297998336 ++wrote 2048/2048 bytes at offset 4297998336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298002432 ++wrote 2048/2048 bytes at offset 4298002432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298006528 ++wrote 2048/2048 bytes at offset 4298006528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298010624 ++wrote 2048/2048 bytes at offset 4298010624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298014720 ++wrote 2048/2048 bytes at offset 4298014720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298018816 ++wrote 2048/2048 bytes at offset 4298018816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298022912 ++wrote 2048/2048 bytes at offset 4298022912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298027008 ++wrote 2048/2048 bytes at offset 4298027008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298031104 ++wrote 2048/2048 bytes at offset 4298031104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298035200 ++wrote 2048/2048 bytes at offset 4298035200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298039296 ++wrote 2048/2048 bytes at offset 4298039296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298043392 ++wrote 2048/2048 bytes at offset 4298043392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298047488 ++wrote 2048/2048 bytes at offset 4298047488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298051584 ++wrote 2048/2048 bytes at offset 4298051584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298055680 ++wrote 2048/2048 bytes at offset 4298055680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298059776 ++wrote 2048/2048 bytes at offset 4298059776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298063872 ++wrote 2048/2048 bytes at offset 4298063872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298067968 ++wrote 2048/2048 bytes at offset 4298067968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298072064 ++wrote 2048/2048 bytes at offset 4298072064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298076160 ++wrote 2048/2048 bytes at offset 4298076160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298080256 ++wrote 2048/2048 bytes at offset 4298080256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298084352 ++wrote 2048/2048 bytes at offset 4298084352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298088448 ++wrote 2048/2048 bytes at offset 4298088448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298092544 ++wrote 2048/2048 bytes at offset 4298092544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298096640 ++wrote 2048/2048 bytes at offset 4298096640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298100736 ++wrote 2048/2048 bytes at offset 4298100736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298104832 ++wrote 2048/2048 bytes at offset 4298104832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298108928 ++wrote 2048/2048 bytes at offset 4298108928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 2 +-qemu-io> wrote 2048/2048 bytes at offset 4298114048 ++=== IO: pattern 2 ++wrote 2048/2048 bytes at offset 4298114048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298118144 ++wrote 2048/2048 bytes at offset 4298118144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298122240 ++wrote 2048/2048 bytes at offset 4298122240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298126336 ++wrote 2048/2048 bytes at offset 4298126336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298130432 ++wrote 2048/2048 bytes at offset 4298130432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298134528 ++wrote 2048/2048 bytes at offset 4298134528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298138624 ++wrote 2048/2048 bytes at offset 4298138624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298142720 ++wrote 2048/2048 bytes at offset 4298142720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298146816 ++wrote 2048/2048 bytes at offset 4298146816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298150912 ++wrote 2048/2048 bytes at offset 4298150912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298155008 ++wrote 2048/2048 bytes at offset 4298155008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298159104 ++wrote 2048/2048 bytes at offset 4298159104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298163200 ++wrote 2048/2048 bytes at offset 4298163200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298167296 ++wrote 2048/2048 bytes at offset 4298167296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298171392 ++wrote 2048/2048 bytes at offset 4298171392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298175488 ++wrote 2048/2048 bytes at offset 4298175488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298179584 ++wrote 2048/2048 bytes at offset 4298179584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298183680 ++wrote 2048/2048 bytes at offset 4298183680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298187776 ++wrote 2048/2048 bytes at offset 4298187776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298191872 ++wrote 2048/2048 bytes at offset 4298191872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298195968 ++wrote 2048/2048 bytes at offset 4298195968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298200064 ++wrote 2048/2048 bytes at offset 4298200064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298204160 ++wrote 2048/2048 bytes at offset 4298204160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298208256 ++wrote 2048/2048 bytes at offset 4298208256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298212352 ++wrote 2048/2048 bytes at offset 4298212352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298216448 ++wrote 2048/2048 bytes at offset 4298216448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298220544 ++wrote 2048/2048 bytes at offset 4298220544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298224640 ++wrote 2048/2048 bytes at offset 4298224640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298228736 ++wrote 2048/2048 bytes at offset 4298228736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298232832 ++wrote 2048/2048 bytes at offset 4298232832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298236928 ++wrote 2048/2048 bytes at offset 4298236928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298241024 ++wrote 2048/2048 bytes at offset 4298241024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298245120 ++wrote 2048/2048 bytes at offset 4298245120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298249216 ++wrote 2048/2048 bytes at offset 4298249216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298253312 ++wrote 2048/2048 bytes at offset 4298253312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298257408 ++wrote 2048/2048 bytes at offset 4298257408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298261504 ++wrote 2048/2048 bytes at offset 4298261504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298265600 ++wrote 2048/2048 bytes at offset 4298265600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298269696 ++wrote 2048/2048 bytes at offset 4298269696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298273792 ++wrote 2048/2048 bytes at offset 4298273792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298277888 ++wrote 2048/2048 bytes at offset 4298277888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298281984 ++wrote 2048/2048 bytes at offset 4298281984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298286080 ++wrote 2048/2048 bytes at offset 4298286080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298290176 ++wrote 2048/2048 bytes at offset 4298290176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298294272 ++wrote 2048/2048 bytes at offset 4298294272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298298368 ++wrote 2048/2048 bytes at offset 4298298368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298302464 ++wrote 2048/2048 bytes at offset 4298302464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298306560 ++wrote 2048/2048 bytes at offset 4298306560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298310656 ++wrote 2048/2048 bytes at offset 4298310656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298314752 ++wrote 2048/2048 bytes at offset 4298314752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298318848 ++wrote 2048/2048 bytes at offset 4298318848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298322944 ++wrote 2048/2048 bytes at offset 4298322944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298327040 ++wrote 2048/2048 bytes at offset 4298327040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298331136 ++wrote 2048/2048 bytes at offset 4298331136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298335232 ++wrote 2048/2048 bytes at offset 4298335232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298339328 ++wrote 2048/2048 bytes at offset 4298339328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298343424 ++wrote 2048/2048 bytes at offset 4298343424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298347520 ++wrote 2048/2048 bytes at offset 4298347520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298351616 ++wrote 2048/2048 bytes at offset 4298351616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298355712 ++wrote 2048/2048 bytes at offset 4298355712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298359808 ++wrote 2048/2048 bytes at offset 4298359808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298363904 ++wrote 2048/2048 bytes at offset 4298363904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298368000 ++wrote 2048/2048 bytes at offset 4298368000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298372096 ++wrote 2048/2048 bytes at offset 4298372096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298376192 ++wrote 2048/2048 bytes at offset 4298376192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298380288 ++wrote 2048/2048 bytes at offset 4298380288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298384384 ++wrote 2048/2048 bytes at offset 4298384384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298388480 ++wrote 2048/2048 bytes at offset 4298388480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298392576 ++wrote 2048/2048 bytes at offset 4298392576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298396672 ++wrote 2048/2048 bytes at offset 4298396672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298400768 ++wrote 2048/2048 bytes at offset 4298400768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298404864 ++wrote 2048/2048 bytes at offset 4298404864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298408960 ++wrote 2048/2048 bytes at offset 4298408960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298413056 ++wrote 2048/2048 bytes at offset 4298413056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298417152 ++wrote 2048/2048 bytes at offset 4298417152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298421248 ++wrote 2048/2048 bytes at offset 4298421248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298425344 ++wrote 2048/2048 bytes at offset 4298425344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298429440 ++wrote 2048/2048 bytes at offset 4298429440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298433536 ++wrote 2048/2048 bytes at offset 4298433536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298437632 ++wrote 2048/2048 bytes at offset 4298437632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298441728 ++wrote 2048/2048 bytes at offset 4298441728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298445824 ++wrote 2048/2048 bytes at offset 4298445824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298449920 ++wrote 2048/2048 bytes at offset 4298449920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298454016 ++wrote 2048/2048 bytes at offset 4298454016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298458112 ++wrote 2048/2048 bytes at offset 4298458112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298462208 ++wrote 2048/2048 bytes at offset 4298462208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298466304 ++wrote 2048/2048 bytes at offset 4298466304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298470400 ++wrote 2048/2048 bytes at offset 4298470400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298474496 ++wrote 2048/2048 bytes at offset 4298474496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298478592 ++wrote 2048/2048 bytes at offset 4298478592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298482688 ++wrote 2048/2048 bytes at offset 4298482688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298486784 ++wrote 2048/2048 bytes at offset 4298486784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298490880 ++wrote 2048/2048 bytes at offset 4298490880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298494976 ++wrote 2048/2048 bytes at offset 4298494976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298499072 ++wrote 2048/2048 bytes at offset 4298499072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298503168 ++wrote 2048/2048 bytes at offset 4298503168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298507264 ++wrote 2048/2048 bytes at offset 4298507264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298511360 ++wrote 2048/2048 bytes at offset 4298511360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298515456 ++wrote 2048/2048 bytes at offset 4298515456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298519552 ++wrote 2048/2048 bytes at offset 4298519552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298523648 ++wrote 2048/2048 bytes at offset 4298523648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298527744 ++wrote 2048/2048 bytes at offset 4298527744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298531840 ++wrote 2048/2048 bytes at offset 4298531840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298535936 ++wrote 2048/2048 bytes at offset 4298535936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298540032 ++wrote 2048/2048 bytes at offset 4298540032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298544128 ++wrote 2048/2048 bytes at offset 4298544128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298548224 ++wrote 2048/2048 bytes at offset 4298548224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298552320 ++wrote 2048/2048 bytes at offset 4298552320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298556416 ++wrote 2048/2048 bytes at offset 4298556416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298560512 ++wrote 2048/2048 bytes at offset 4298560512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298564608 ++wrote 2048/2048 bytes at offset 4298564608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298568704 ++wrote 2048/2048 bytes at offset 4298568704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298572800 ++wrote 2048/2048 bytes at offset 4298572800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298576896 ++wrote 2048/2048 bytes at offset 4298576896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298580992 ++wrote 2048/2048 bytes at offset 4298580992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298585088 ++wrote 2048/2048 bytes at offset 4298585088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298589184 ++wrote 2048/2048 bytes at offset 4298589184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298593280 ++wrote 2048/2048 bytes at offset 4298593280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298597376 ++wrote 2048/2048 bytes at offset 4298597376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298601472 ++wrote 2048/2048 bytes at offset 4298601472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298605568 ++wrote 2048/2048 bytes at offset 4298605568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298609664 ++wrote 2048/2048 bytes at offset 4298609664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298613760 ++wrote 2048/2048 bytes at offset 4298613760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298617856 ++wrote 2048/2048 bytes at offset 4298617856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298621952 ++wrote 2048/2048 bytes at offset 4298621952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298626048 ++wrote 2048/2048 bytes at offset 4298626048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298630144 ++wrote 2048/2048 bytes at offset 4298630144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298634240 ++wrote 2048/2048 bytes at offset 4298634240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298638336 ++wrote 2048/2048 bytes at offset 4298638336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298642432 ++wrote 2048/2048 bytes at offset 4298642432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298646528 ++wrote 2048/2048 bytes at offset 4298646528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298650624 ++wrote 2048/2048 bytes at offset 4298650624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298654720 ++wrote 2048/2048 bytes at offset 4298654720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298658816 ++wrote 2048/2048 bytes at offset 4298658816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298662912 ++wrote 2048/2048 bytes at offset 4298662912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298667008 ++wrote 2048/2048 bytes at offset 4298667008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298671104 ++wrote 2048/2048 bytes at offset 4298671104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298675200 ++wrote 2048/2048 bytes at offset 4298675200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298679296 ++wrote 2048/2048 bytes at offset 4298679296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298683392 ++wrote 2048/2048 bytes at offset 4298683392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298687488 ++wrote 2048/2048 bytes at offset 4298687488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298691584 ++wrote 2048/2048 bytes at offset 4298691584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298695680 ++wrote 2048/2048 bytes at offset 4298695680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298699776 ++wrote 2048/2048 bytes at offset 4298699776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298703872 ++wrote 2048/2048 bytes at offset 4298703872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298707968 ++wrote 2048/2048 bytes at offset 4298707968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298712064 ++wrote 2048/2048 bytes at offset 4298712064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298716160 ++wrote 2048/2048 bytes at offset 4298716160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298720256 ++wrote 2048/2048 bytes at offset 4298720256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298724352 ++wrote 2048/2048 bytes at offset 4298724352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298728448 ++wrote 2048/2048 bytes at offset 4298728448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298732544 ++wrote 2048/2048 bytes at offset 4298732544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298736640 ++wrote 2048/2048 bytes at offset 4298736640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298740736 ++wrote 2048/2048 bytes at offset 4298740736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298744832 ++wrote 2048/2048 bytes at offset 4298744832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298748928 ++wrote 2048/2048 bytes at offset 4298748928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298753024 ++wrote 2048/2048 bytes at offset 4298753024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298757120 ++wrote 2048/2048 bytes at offset 4298757120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298761216 ++wrote 2048/2048 bytes at offset 4298761216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298765312 ++wrote 2048/2048 bytes at offset 4298765312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298769408 ++wrote 2048/2048 bytes at offset 4298769408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298773504 ++wrote 2048/2048 bytes at offset 4298773504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298777600 ++wrote 2048/2048 bytes at offset 4298777600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298781696 ++wrote 2048/2048 bytes at offset 4298781696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298785792 ++wrote 2048/2048 bytes at offset 4298785792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298789888 ++wrote 2048/2048 bytes at offset 4298789888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298793984 ++wrote 2048/2048 bytes at offset 4298793984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298798080 ++wrote 2048/2048 bytes at offset 4298798080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298802176 ++wrote 2048/2048 bytes at offset 4298802176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298806272 ++wrote 2048/2048 bytes at offset 4298806272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298810368 ++wrote 2048/2048 bytes at offset 4298810368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298814464 ++wrote 2048/2048 bytes at offset 4298814464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298818560 ++wrote 2048/2048 bytes at offset 4298818560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298822656 ++wrote 2048/2048 bytes at offset 4298822656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298826752 ++wrote 2048/2048 bytes at offset 4298826752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298830848 ++wrote 2048/2048 bytes at offset 4298830848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298834944 ++wrote 2048/2048 bytes at offset 4298834944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298839040 ++wrote 2048/2048 bytes at offset 4298839040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298843136 ++wrote 2048/2048 bytes at offset 4298843136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298847232 ++wrote 2048/2048 bytes at offset 4298847232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298851328 ++wrote 2048/2048 bytes at offset 4298851328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298855424 ++wrote 2048/2048 bytes at offset 4298855424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298859520 ++wrote 2048/2048 bytes at offset 4298859520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298863616 ++wrote 2048/2048 bytes at offset 4298863616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298867712 ++wrote 2048/2048 bytes at offset 4298867712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298871808 ++wrote 2048/2048 bytes at offset 4298871808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298875904 ++wrote 2048/2048 bytes at offset 4298875904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298880000 ++wrote 2048/2048 bytes at offset 4298880000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298884096 ++wrote 2048/2048 bytes at offset 4298884096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298888192 ++wrote 2048/2048 bytes at offset 4298888192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298892288 ++wrote 2048/2048 bytes at offset 4298892288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298896384 ++wrote 2048/2048 bytes at offset 4298896384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298900480 ++wrote 2048/2048 bytes at offset 4298900480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298904576 ++wrote 2048/2048 bytes at offset 4298904576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298908672 ++wrote 2048/2048 bytes at offset 4298908672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298912768 ++wrote 2048/2048 bytes at offset 4298912768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298916864 ++wrote 2048/2048 bytes at offset 4298916864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298920960 ++wrote 2048/2048 bytes at offset 4298920960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298925056 ++wrote 2048/2048 bytes at offset 4298925056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298929152 ++wrote 2048/2048 bytes at offset 4298929152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298933248 ++wrote 2048/2048 bytes at offset 4298933248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298937344 ++wrote 2048/2048 bytes at offset 4298937344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298941440 ++wrote 2048/2048 bytes at offset 4298941440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298945536 ++wrote 2048/2048 bytes at offset 4298945536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298949632 ++wrote 2048/2048 bytes at offset 4298949632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298953728 ++wrote 2048/2048 bytes at offset 4298953728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298957824 ++wrote 2048/2048 bytes at offset 4298957824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298961920 ++wrote 2048/2048 bytes at offset 4298961920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298966016 ++wrote 2048/2048 bytes at offset 4298966016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298970112 ++wrote 2048/2048 bytes at offset 4298970112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298974208 ++wrote 2048/2048 bytes at offset 4298974208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298978304 ++wrote 2048/2048 bytes at offset 4298978304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298982400 ++wrote 2048/2048 bytes at offset 4298982400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298986496 ++wrote 2048/2048 bytes at offset 4298986496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298990592 ++wrote 2048/2048 bytes at offset 4298990592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298994688 ++wrote 2048/2048 bytes at offset 4298994688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298998784 ++wrote 2048/2048 bytes at offset 4298998784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299002880 ++wrote 2048/2048 bytes at offset 4299002880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299006976 ++wrote 2048/2048 bytes at offset 4299006976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299011072 ++wrote 2048/2048 bytes at offset 4299011072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299015168 ++wrote 2048/2048 bytes at offset 4299015168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299019264 ++wrote 2048/2048 bytes at offset 4299019264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299023360 ++wrote 2048/2048 bytes at offset 4299023360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299027456 ++wrote 2048/2048 bytes at offset 4299027456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299031552 ++wrote 2048/2048 bytes at offset 4299031552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299035648 ++wrote 2048/2048 bytes at offset 4299035648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299039744 ++wrote 2048/2048 bytes at offset 4299039744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299043840 ++wrote 2048/2048 bytes at offset 4299043840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299047936 ++wrote 2048/2048 bytes at offset 4299047936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299052032 ++wrote 2048/2048 bytes at offset 4299052032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299056128 ++wrote 2048/2048 bytes at offset 4299056128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299060224 ++wrote 2048/2048 bytes at offset 4299060224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299064320 ++wrote 2048/2048 bytes at offset 4299064320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299068416 ++wrote 2048/2048 bytes at offset 4299068416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299072512 ++wrote 2048/2048 bytes at offset 4299072512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299076608 ++wrote 2048/2048 bytes at offset 4299076608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299080704 ++wrote 2048/2048 bytes at offset 4299080704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299084800 ++wrote 2048/2048 bytes at offset 4299084800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299088896 ++wrote 2048/2048 bytes at offset 4299088896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299092992 ++wrote 2048/2048 bytes at offset 4299092992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299097088 ++wrote 2048/2048 bytes at offset 4299097088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299101184 ++wrote 2048/2048 bytes at offset 4299101184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299105280 ++wrote 2048/2048 bytes at offset 4299105280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299109376 ++wrote 2048/2048 bytes at offset 4299109376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299113472 ++wrote 2048/2048 bytes at offset 4299113472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299117568 ++wrote 2048/2048 bytes at offset 4299117568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299121664 ++wrote 2048/2048 bytes at offset 4299121664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299125760 ++wrote 2048/2048 bytes at offset 4299125760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299129856 ++wrote 2048/2048 bytes at offset 4299129856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299133952 ++wrote 2048/2048 bytes at offset 4299133952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299138048 ++wrote 2048/2048 bytes at offset 4299138048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299142144 ++wrote 2048/2048 bytes at offset 4299142144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299146240 ++wrote 2048/2048 bytes at offset 4299146240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299150336 ++wrote 2048/2048 bytes at offset 4299150336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299154432 ++wrote 2048/2048 bytes at offset 4299154432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299158528 ++wrote 2048/2048 bytes at offset 4299158528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 4 +-qemu-io> wrote 8192/8192 bytes at offset 4299163648 ++=== IO: pattern 4 ++wrote 8192/8192 bytes at offset 4299163648 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299175936 ++wrote 8192/8192 bytes at offset 4299175936 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299188224 ++wrote 8192/8192 bytes at offset 4299188224 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299200512 ++wrote 8192/8192 bytes at offset 4299200512 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299212800 ++wrote 8192/8192 bytes at offset 4299212800 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299225088 ++wrote 8192/8192 bytes at offset 4299225088 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299237376 ++wrote 8192/8192 bytes at offset 4299237376 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299249664 ++wrote 8192/8192 bytes at offset 4299249664 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299261952 ++wrote 8192/8192 bytes at offset 4299261952 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299274240 ++wrote 8192/8192 bytes at offset 4299274240 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299286528 ++wrote 8192/8192 bytes at offset 4299286528 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299298816 ++wrote 8192/8192 bytes at offset 4299298816 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299311104 ++wrote 8192/8192 bytes at offset 4299311104 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299323392 ++wrote 8192/8192 bytes at offset 4299323392 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299335680 ++wrote 8192/8192 bytes at offset 4299335680 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299347968 ++wrote 8192/8192 bytes at offset 4299347968 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299360256 ++wrote 8192/8192 bytes at offset 4299360256 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299372544 ++wrote 8192/8192 bytes at offset 4299372544 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299384832 ++wrote 8192/8192 bytes at offset 4299384832 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299397120 ++wrote 8192/8192 bytes at offset 4299397120 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299409408 ++wrote 8192/8192 bytes at offset 4299409408 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299421696 ++wrote 8192/8192 bytes at offset 4299421696 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299433984 ++wrote 8192/8192 bytes at offset 4299433984 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299446272 ++wrote 8192/8192 bytes at offset 4299446272 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299458560 ++wrote 8192/8192 bytes at offset 4299458560 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299470848 ++wrote 8192/8192 bytes at offset 4299470848 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299483136 ++wrote 8192/8192 bytes at offset 4299483136 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299495424 ++wrote 8192/8192 bytes at offset 4299495424 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299507712 ++wrote 8192/8192 bytes at offset 4299507712 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299520000 ++wrote 8192/8192 bytes at offset 4299520000 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299532288 ++wrote 8192/8192 bytes at offset 4299532288 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299544576 ++wrote 8192/8192 bytes at offset 4299544576 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299556864 ++wrote 8192/8192 bytes at offset 4299556864 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299569152 ++wrote 8192/8192 bytes at offset 4299569152 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299581440 ++wrote 8192/8192 bytes at offset 4299581440 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299593728 ++wrote 8192/8192 bytes at offset 4299593728 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299606016 ++wrote 8192/8192 bytes at offset 4299606016 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299618304 ++wrote 8192/8192 bytes at offset 4299618304 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299630592 ++wrote 8192/8192 bytes at offset 4299630592 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299642880 ++wrote 8192/8192 bytes at offset 4299642880 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299655168 ++wrote 8192/8192 bytes at offset 4299655168 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299667456 ++wrote 8192/8192 bytes at offset 4299667456 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299679744 ++wrote 8192/8192 bytes at offset 4299679744 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299692032 ++wrote 8192/8192 bytes at offset 4299692032 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299704320 ++wrote 8192/8192 bytes at offset 4299704320 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299716608 ++wrote 8192/8192 bytes at offset 4299716608 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299728896 ++wrote 8192/8192 bytes at offset 4299728896 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299741184 ++wrote 8192/8192 bytes at offset 4299741184 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299753472 ++wrote 8192/8192 bytes at offset 4299753472 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299765760 ++wrote 8192/8192 bytes at offset 4299765760 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299778048 ++wrote 8192/8192 bytes at offset 4299778048 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299790336 ++wrote 8192/8192 bytes at offset 4299790336 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299802624 ++wrote 8192/8192 bytes at offset 4299802624 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299814912 ++wrote 8192/8192 bytes at offset 4299814912 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299827200 ++wrote 8192/8192 bytes at offset 4299827200 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299839488 ++wrote 8192/8192 bytes at offset 4299839488 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299851776 ++wrote 8192/8192 bytes at offset 4299851776 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299864064 ++wrote 8192/8192 bytes at offset 4299864064 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299876352 ++wrote 8192/8192 bytes at offset 4299876352 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299888640 ++wrote 8192/8192 bytes at offset 4299888640 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299900928 ++wrote 8192/8192 bytes at offset 4299900928 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299913216 ++wrote 8192/8192 bytes at offset 4299913216 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299925504 ++wrote 8192/8192 bytes at offset 4299925504 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299937792 ++wrote 8192/8192 bytes at offset 4299937792 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 244 +-qemu-io> wrote 12288/12288 bytes at offset 4301252608 ++=== IO: pattern 244 ++wrote 12288/12288 bytes at offset 4301252608 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 4303351808 ++wrote 12288/12288 bytes at offset 4303351808 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 4305451008 ++wrote 12288/12288 bytes at offset 4305451008 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 4307550208 ++wrote 12288/12288 bytes at offset 4307550208 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 4309649408 ++wrote 12288/12288 bytes at offset 4309649408 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 4311748608 ++wrote 12288/12288 bytes at offset 4311748608 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 4313847808 ++wrote 12288/12288 bytes at offset 4313847808 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 4315947008 ++wrote 12288/12288 bytes at offset 4315947008 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> read 4096/4096 bytes at offset 4294967296 ++=== IO: pattern 0 ++read 4096/4096 bytes at offset 4294967296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294971392 ++read 4096/4096 bytes at offset 4294971392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294975488 ++read 4096/4096 bytes at offset 4294975488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294979584 ++read 4096/4096 bytes at offset 4294979584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294983680 ++read 4096/4096 bytes at offset 4294983680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294987776 ++read 4096/4096 bytes at offset 4294987776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294991872 ++read 4096/4096 bytes at offset 4294991872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294995968 ++read 4096/4096 bytes at offset 4294995968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295000064 ++read 4096/4096 bytes at offset 4295000064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295004160 ++read 4096/4096 bytes at offset 4295004160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295008256 ++read 4096/4096 bytes at offset 4295008256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295012352 ++read 4096/4096 bytes at offset 4295012352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295016448 ++read 4096/4096 bytes at offset 4295016448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295020544 ++read 4096/4096 bytes at offset 4295020544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295024640 ++read 4096/4096 bytes at offset 4295024640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295028736 ++read 4096/4096 bytes at offset 4295028736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295032832 ++read 4096/4096 bytes at offset 4295032832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295036928 ++read 4096/4096 bytes at offset 4295036928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295041024 ++read 4096/4096 bytes at offset 4295041024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295045120 ++read 4096/4096 bytes at offset 4295045120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295049216 ++read 4096/4096 bytes at offset 4295049216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295053312 ++read 4096/4096 bytes at offset 4295053312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295057408 ++read 4096/4096 bytes at offset 4295057408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295061504 ++read 4096/4096 bytes at offset 4295061504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295065600 ++read 4096/4096 bytes at offset 4295065600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295069696 ++read 4096/4096 bytes at offset 4295069696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295073792 ++read 4096/4096 bytes at offset 4295073792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295077888 ++read 4096/4096 bytes at offset 4295077888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295081984 ++read 4096/4096 bytes at offset 4295081984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295086080 ++read 4096/4096 bytes at offset 4295086080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295090176 ++read 4096/4096 bytes at offset 4295090176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295094272 ++read 4096/4096 bytes at offset 4295094272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295098368 ++read 4096/4096 bytes at offset 4295098368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295102464 ++read 4096/4096 bytes at offset 4295102464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295106560 ++read 4096/4096 bytes at offset 4295106560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295110656 ++read 4096/4096 bytes at offset 4295110656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295114752 ++read 4096/4096 bytes at offset 4295114752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295118848 ++read 4096/4096 bytes at offset 4295118848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295122944 ++read 4096/4096 bytes at offset 4295122944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295127040 ++read 4096/4096 bytes at offset 4295127040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295131136 ++read 4096/4096 bytes at offset 4295131136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295135232 ++read 4096/4096 bytes at offset 4295135232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295139328 ++read 4096/4096 bytes at offset 4295139328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295143424 ++read 4096/4096 bytes at offset 4295143424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295147520 ++read 4096/4096 bytes at offset 4295147520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295151616 ++read 4096/4096 bytes at offset 4295151616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295155712 ++read 4096/4096 bytes at offset 4295155712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295159808 ++read 4096/4096 bytes at offset 4295159808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295163904 ++read 4096/4096 bytes at offset 4295163904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295168000 ++read 4096/4096 bytes at offset 4295168000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295172096 ++read 4096/4096 bytes at offset 4295172096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295176192 ++read 4096/4096 bytes at offset 4295176192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295180288 ++read 4096/4096 bytes at offset 4295180288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295184384 ++read 4096/4096 bytes at offset 4295184384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295188480 ++read 4096/4096 bytes at offset 4295188480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295192576 ++read 4096/4096 bytes at offset 4295192576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295196672 ++read 4096/4096 bytes at offset 4295196672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295200768 ++read 4096/4096 bytes at offset 4295200768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295204864 ++read 4096/4096 bytes at offset 4295204864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295208960 ++read 4096/4096 bytes at offset 4295208960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295213056 ++read 4096/4096 bytes at offset 4295213056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295217152 ++read 4096/4096 bytes at offset 4295217152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295221248 ++read 4096/4096 bytes at offset 4295221248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295225344 ++read 4096/4096 bytes at offset 4295225344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295229440 ++read 4096/4096 bytes at offset 4295229440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295233536 ++read 4096/4096 bytes at offset 4295233536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295237632 ++read 4096/4096 bytes at offset 4295237632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295241728 ++read 4096/4096 bytes at offset 4295241728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295245824 ++read 4096/4096 bytes at offset 4295245824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295249920 ++read 4096/4096 bytes at offset 4295249920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295254016 ++read 4096/4096 bytes at offset 4295254016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295258112 ++read 4096/4096 bytes at offset 4295258112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295262208 ++read 4096/4096 bytes at offset 4295262208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295266304 ++read 4096/4096 bytes at offset 4295266304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295270400 ++read 4096/4096 bytes at offset 4295270400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295274496 ++read 4096/4096 bytes at offset 4295274496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295278592 ++read 4096/4096 bytes at offset 4295278592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295282688 ++read 4096/4096 bytes at offset 4295282688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295286784 ++read 4096/4096 bytes at offset 4295286784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295290880 ++read 4096/4096 bytes at offset 4295290880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295294976 ++read 4096/4096 bytes at offset 4295294976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295299072 ++read 4096/4096 bytes at offset 4295299072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295303168 ++read 4096/4096 bytes at offset 4295303168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295307264 ++read 4096/4096 bytes at offset 4295307264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295311360 ++read 4096/4096 bytes at offset 4295311360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295315456 ++read 4096/4096 bytes at offset 4295315456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295319552 ++read 4096/4096 bytes at offset 4295319552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295323648 ++read 4096/4096 bytes at offset 4295323648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295327744 ++read 4096/4096 bytes at offset 4295327744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295331840 ++read 4096/4096 bytes at offset 4295331840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295335936 ++read 4096/4096 bytes at offset 4295335936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295340032 ++read 4096/4096 bytes at offset 4295340032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295344128 ++read 4096/4096 bytes at offset 4295344128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295348224 ++read 4096/4096 bytes at offset 4295348224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295352320 ++read 4096/4096 bytes at offset 4295352320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295356416 ++read 4096/4096 bytes at offset 4295356416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295360512 ++read 4096/4096 bytes at offset 4295360512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295364608 ++read 4096/4096 bytes at offset 4295364608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295368704 ++read 4096/4096 bytes at offset 4295368704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295372800 ++read 4096/4096 bytes at offset 4295372800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295376896 ++read 4096/4096 bytes at offset 4295376896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295380992 ++read 4096/4096 bytes at offset 4295380992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295385088 ++read 4096/4096 bytes at offset 4295385088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295389184 ++read 4096/4096 bytes at offset 4295389184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295393280 ++read 4096/4096 bytes at offset 4295393280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295397376 ++read 4096/4096 bytes at offset 4295397376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295401472 ++read 4096/4096 bytes at offset 4295401472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295405568 ++read 4096/4096 bytes at offset 4295405568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295409664 ++read 4096/4096 bytes at offset 4295409664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295413760 ++read 4096/4096 bytes at offset 4295413760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295417856 ++read 4096/4096 bytes at offset 4295417856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295421952 ++read 4096/4096 bytes at offset 4295421952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295426048 ++read 4096/4096 bytes at offset 4295426048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295430144 ++read 4096/4096 bytes at offset 4295430144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295434240 ++read 4096/4096 bytes at offset 4295434240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295438336 ++read 4096/4096 bytes at offset 4295438336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295442432 ++read 4096/4096 bytes at offset 4295442432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295446528 ++read 4096/4096 bytes at offset 4295446528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295450624 ++read 4096/4096 bytes at offset 4295450624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295454720 ++read 4096/4096 bytes at offset 4295454720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295458816 ++read 4096/4096 bytes at offset 4295458816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295462912 ++read 4096/4096 bytes at offset 4295462912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295467008 ++read 4096/4096 bytes at offset 4295467008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295471104 ++read 4096/4096 bytes at offset 4295471104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295475200 ++read 4096/4096 bytes at offset 4295475200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295479296 ++read 4096/4096 bytes at offset 4295479296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295483392 ++read 4096/4096 bytes at offset 4295483392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295487488 ++read 4096/4096 bytes at offset 4295487488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295491584 ++read 4096/4096 bytes at offset 4295491584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295495680 ++read 4096/4096 bytes at offset 4295495680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295499776 ++read 4096/4096 bytes at offset 4295499776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295503872 ++read 4096/4096 bytes at offset 4295503872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295507968 ++read 4096/4096 bytes at offset 4295507968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295512064 ++read 4096/4096 bytes at offset 4295512064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295516160 ++read 4096/4096 bytes at offset 4295516160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295520256 ++read 4096/4096 bytes at offset 4295520256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295524352 ++read 4096/4096 bytes at offset 4295524352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295528448 ++read 4096/4096 bytes at offset 4295528448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295532544 ++read 4096/4096 bytes at offset 4295532544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295536640 ++read 4096/4096 bytes at offset 4295536640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295540736 ++read 4096/4096 bytes at offset 4295540736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295544832 ++read 4096/4096 bytes at offset 4295544832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295548928 ++read 4096/4096 bytes at offset 4295548928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295553024 ++read 4096/4096 bytes at offset 4295553024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295557120 ++read 4096/4096 bytes at offset 4295557120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295561216 ++read 4096/4096 bytes at offset 4295561216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295565312 ++read 4096/4096 bytes at offset 4295565312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295569408 ++read 4096/4096 bytes at offset 4295569408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295573504 ++read 4096/4096 bytes at offset 4295573504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295577600 ++read 4096/4096 bytes at offset 4295577600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295581696 ++read 4096/4096 bytes at offset 4295581696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295585792 ++read 4096/4096 bytes at offset 4295585792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295589888 ++read 4096/4096 bytes at offset 4295589888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295593984 ++read 4096/4096 bytes at offset 4295593984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295598080 ++read 4096/4096 bytes at offset 4295598080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295602176 ++read 4096/4096 bytes at offset 4295602176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295606272 ++read 4096/4096 bytes at offset 4295606272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295610368 ++read 4096/4096 bytes at offset 4295610368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295614464 ++read 4096/4096 bytes at offset 4295614464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295618560 ++read 4096/4096 bytes at offset 4295618560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295622656 ++read 4096/4096 bytes at offset 4295622656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295626752 ++read 4096/4096 bytes at offset 4295626752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295630848 ++read 4096/4096 bytes at offset 4295630848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295634944 ++read 4096/4096 bytes at offset 4295634944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295639040 ++read 4096/4096 bytes at offset 4295639040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295643136 ++read 4096/4096 bytes at offset 4295643136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295647232 ++read 4096/4096 bytes at offset 4295647232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295651328 ++read 4096/4096 bytes at offset 4295651328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295655424 ++read 4096/4096 bytes at offset 4295655424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295659520 ++read 4096/4096 bytes at offset 4295659520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295663616 ++read 4096/4096 bytes at offset 4295663616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295667712 ++read 4096/4096 bytes at offset 4295667712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295671808 ++read 4096/4096 bytes at offset 4295671808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295675904 ++read 4096/4096 bytes at offset 4295675904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295680000 ++read 4096/4096 bytes at offset 4295680000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295684096 ++read 4096/4096 bytes at offset 4295684096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295688192 ++read 4096/4096 bytes at offset 4295688192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295692288 ++read 4096/4096 bytes at offset 4295692288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295696384 ++read 4096/4096 bytes at offset 4295696384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295700480 ++read 4096/4096 bytes at offset 4295700480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295704576 ++read 4096/4096 bytes at offset 4295704576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295708672 ++read 4096/4096 bytes at offset 4295708672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295712768 ++read 4096/4096 bytes at offset 4295712768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295716864 ++read 4096/4096 bytes at offset 4295716864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295720960 ++read 4096/4096 bytes at offset 4295720960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295725056 ++read 4096/4096 bytes at offset 4295725056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295729152 ++read 4096/4096 bytes at offset 4295729152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295733248 ++read 4096/4096 bytes at offset 4295733248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295737344 ++read 4096/4096 bytes at offset 4295737344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295741440 ++read 4096/4096 bytes at offset 4295741440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295745536 ++read 4096/4096 bytes at offset 4295745536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295749632 ++read 4096/4096 bytes at offset 4295749632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295753728 ++read 4096/4096 bytes at offset 4295753728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295757824 ++read 4096/4096 bytes at offset 4295757824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295761920 ++read 4096/4096 bytes at offset 4295761920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295766016 ++read 4096/4096 bytes at offset 4295766016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295770112 ++read 4096/4096 bytes at offset 4295770112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295774208 ++read 4096/4096 bytes at offset 4295774208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295778304 ++read 4096/4096 bytes at offset 4295778304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295782400 ++read 4096/4096 bytes at offset 4295782400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295786496 ++read 4096/4096 bytes at offset 4295786496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295790592 ++read 4096/4096 bytes at offset 4295790592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295794688 ++read 4096/4096 bytes at offset 4295794688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295798784 ++read 4096/4096 bytes at offset 4295798784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295802880 ++read 4096/4096 bytes at offset 4295802880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295806976 ++read 4096/4096 bytes at offset 4295806976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295811072 ++read 4096/4096 bytes at offset 4295811072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295815168 ++read 4096/4096 bytes at offset 4295815168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295819264 ++read 4096/4096 bytes at offset 4295819264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295823360 ++read 4096/4096 bytes at offset 4295823360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295827456 ++read 4096/4096 bytes at offset 4295827456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295831552 ++read 4096/4096 bytes at offset 4295831552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295835648 ++read 4096/4096 bytes at offset 4295835648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295839744 ++read 4096/4096 bytes at offset 4295839744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295843840 ++read 4096/4096 bytes at offset 4295843840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295847936 ++read 4096/4096 bytes at offset 4295847936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295852032 ++read 4096/4096 bytes at offset 4295852032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295856128 ++read 4096/4096 bytes at offset 4295856128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295860224 ++read 4096/4096 bytes at offset 4295860224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295864320 ++read 4096/4096 bytes at offset 4295864320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295868416 ++read 4096/4096 bytes at offset 4295868416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295872512 ++read 4096/4096 bytes at offset 4295872512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295876608 ++read 4096/4096 bytes at offset 4295876608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295880704 ++read 4096/4096 bytes at offset 4295880704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295884800 ++read 4096/4096 bytes at offset 4295884800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295888896 ++read 4096/4096 bytes at offset 4295888896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295892992 ++read 4096/4096 bytes at offset 4295892992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295897088 ++read 4096/4096 bytes at offset 4295897088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295901184 ++read 4096/4096 bytes at offset 4295901184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295905280 ++read 4096/4096 bytes at offset 4295905280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295909376 ++read 4096/4096 bytes at offset 4295909376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295913472 ++read 4096/4096 bytes at offset 4295913472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295917568 ++read 4096/4096 bytes at offset 4295917568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295921664 ++read 4096/4096 bytes at offset 4295921664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295925760 ++read 4096/4096 bytes at offset 4295925760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295929856 ++read 4096/4096 bytes at offset 4295929856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295933952 ++read 4096/4096 bytes at offset 4295933952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295938048 ++read 4096/4096 bytes at offset 4295938048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295942144 ++read 4096/4096 bytes at offset 4295942144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295946240 ++read 4096/4096 bytes at offset 4295946240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295950336 ++read 4096/4096 bytes at offset 4295950336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295954432 ++read 4096/4096 bytes at offset 4295954432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295958528 ++read 4096/4096 bytes at offset 4295958528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295962624 ++read 4096/4096 bytes at offset 4295962624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295966720 ++read 4096/4096 bytes at offset 4295966720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295970816 ++read 4096/4096 bytes at offset 4295970816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295974912 ++read 4096/4096 bytes at offset 4295974912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295979008 ++read 4096/4096 bytes at offset 4295979008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295983104 ++read 4096/4096 bytes at offset 4295983104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295987200 ++read 4096/4096 bytes at offset 4295987200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295991296 ++read 4096/4096 bytes at offset 4295991296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295995392 ++read 4096/4096 bytes at offset 4295995392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295999488 ++read 4096/4096 bytes at offset 4295999488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4296003584 ++read 4096/4096 bytes at offset 4296003584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4296007680 ++read 4096/4096 bytes at offset 4296007680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4296011776 ++read 4096/4096 bytes at offset 4296011776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 4 +-qemu-io> read 2048/2048 bytes at offset 4296017920 ++=== IO: pattern 4 ++read 2048/2048 bytes at offset 4296017920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296022016 ++read 2048/2048 bytes at offset 4296022016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296026112 ++read 2048/2048 bytes at offset 4296026112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296030208 ++read 2048/2048 bytes at offset 4296030208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296034304 ++read 2048/2048 bytes at offset 4296034304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296038400 ++read 2048/2048 bytes at offset 4296038400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296042496 ++read 2048/2048 bytes at offset 4296042496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296046592 ++read 2048/2048 bytes at offset 4296046592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296050688 ++read 2048/2048 bytes at offset 4296050688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296054784 ++read 2048/2048 bytes at offset 4296054784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296058880 ++read 2048/2048 bytes at offset 4296058880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296062976 ++read 2048/2048 bytes at offset 4296062976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296067072 ++read 2048/2048 bytes at offset 4296067072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296071168 ++read 2048/2048 bytes at offset 4296071168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296075264 ++read 2048/2048 bytes at offset 4296075264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296079360 ++read 2048/2048 bytes at offset 4296079360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296083456 ++read 2048/2048 bytes at offset 4296083456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296087552 ++read 2048/2048 bytes at offset 4296087552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296091648 ++read 2048/2048 bytes at offset 4296091648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296095744 ++read 2048/2048 bytes at offset 4296095744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296099840 ++read 2048/2048 bytes at offset 4296099840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296103936 ++read 2048/2048 bytes at offset 4296103936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296108032 ++read 2048/2048 bytes at offset 4296108032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296112128 ++read 2048/2048 bytes at offset 4296112128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296116224 ++read 2048/2048 bytes at offset 4296116224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296120320 ++read 2048/2048 bytes at offset 4296120320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296124416 ++read 2048/2048 bytes at offset 4296124416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296128512 ++read 2048/2048 bytes at offset 4296128512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296132608 ++read 2048/2048 bytes at offset 4296132608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296136704 ++read 2048/2048 bytes at offset 4296136704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296140800 ++read 2048/2048 bytes at offset 4296140800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296144896 ++read 2048/2048 bytes at offset 4296144896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296148992 ++read 2048/2048 bytes at offset 4296148992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296153088 ++read 2048/2048 bytes at offset 4296153088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296157184 ++read 2048/2048 bytes at offset 4296157184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296161280 ++read 2048/2048 bytes at offset 4296161280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296165376 ++read 2048/2048 bytes at offset 4296165376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296169472 ++read 2048/2048 bytes at offset 4296169472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296173568 ++read 2048/2048 bytes at offset 4296173568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296177664 ++read 2048/2048 bytes at offset 4296177664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296181760 ++read 2048/2048 bytes at offset 4296181760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296185856 ++read 2048/2048 bytes at offset 4296185856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296189952 ++read 2048/2048 bytes at offset 4296189952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296194048 ++read 2048/2048 bytes at offset 4296194048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296198144 ++read 2048/2048 bytes at offset 4296198144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296202240 ++read 2048/2048 bytes at offset 4296202240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296206336 ++read 2048/2048 bytes at offset 4296206336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296210432 ++read 2048/2048 bytes at offset 4296210432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296214528 ++read 2048/2048 bytes at offset 4296214528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296218624 ++read 2048/2048 bytes at offset 4296218624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296222720 ++read 2048/2048 bytes at offset 4296222720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296226816 ++read 2048/2048 bytes at offset 4296226816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296230912 ++read 2048/2048 bytes at offset 4296230912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296235008 ++read 2048/2048 bytes at offset 4296235008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296239104 ++read 2048/2048 bytes at offset 4296239104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296243200 ++read 2048/2048 bytes at offset 4296243200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296247296 ++read 2048/2048 bytes at offset 4296247296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296251392 ++read 2048/2048 bytes at offset 4296251392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296255488 ++read 2048/2048 bytes at offset 4296255488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296259584 ++read 2048/2048 bytes at offset 4296259584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296263680 ++read 2048/2048 bytes at offset 4296263680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296267776 ++read 2048/2048 bytes at offset 4296267776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296271872 ++read 2048/2048 bytes at offset 4296271872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296275968 ++read 2048/2048 bytes at offset 4296275968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296280064 ++read 2048/2048 bytes at offset 4296280064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296284160 ++read 2048/2048 bytes at offset 4296284160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296288256 ++read 2048/2048 bytes at offset 4296288256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296292352 ++read 2048/2048 bytes at offset 4296292352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296296448 ++read 2048/2048 bytes at offset 4296296448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296300544 ++read 2048/2048 bytes at offset 4296300544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296304640 ++read 2048/2048 bytes at offset 4296304640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296308736 ++read 2048/2048 bytes at offset 4296308736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296312832 ++read 2048/2048 bytes at offset 4296312832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296316928 ++read 2048/2048 bytes at offset 4296316928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296321024 ++read 2048/2048 bytes at offset 4296321024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296325120 ++read 2048/2048 bytes at offset 4296325120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296329216 ++read 2048/2048 bytes at offset 4296329216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296333312 ++read 2048/2048 bytes at offset 4296333312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296337408 ++read 2048/2048 bytes at offset 4296337408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296341504 ++read 2048/2048 bytes at offset 4296341504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296345600 ++read 2048/2048 bytes at offset 4296345600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296349696 ++read 2048/2048 bytes at offset 4296349696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296353792 ++read 2048/2048 bytes at offset 4296353792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296357888 ++read 2048/2048 bytes at offset 4296357888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296361984 ++read 2048/2048 bytes at offset 4296361984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296366080 ++read 2048/2048 bytes at offset 4296366080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296370176 ++read 2048/2048 bytes at offset 4296370176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296374272 ++read 2048/2048 bytes at offset 4296374272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296378368 ++read 2048/2048 bytes at offset 4296378368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296382464 ++read 2048/2048 bytes at offset 4296382464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296386560 ++read 2048/2048 bytes at offset 4296386560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296390656 ++read 2048/2048 bytes at offset 4296390656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296394752 ++read 2048/2048 bytes at offset 4296394752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296398848 ++read 2048/2048 bytes at offset 4296398848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296402944 ++read 2048/2048 bytes at offset 4296402944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296407040 ++read 2048/2048 bytes at offset 4296407040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296411136 ++read 2048/2048 bytes at offset 4296411136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296415232 ++read 2048/2048 bytes at offset 4296415232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296419328 ++read 2048/2048 bytes at offset 4296419328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296423424 ++read 2048/2048 bytes at offset 4296423424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296427520 ++read 2048/2048 bytes at offset 4296427520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296431616 ++read 2048/2048 bytes at offset 4296431616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296435712 ++read 2048/2048 bytes at offset 4296435712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296439808 ++read 2048/2048 bytes at offset 4296439808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296443904 ++read 2048/2048 bytes at offset 4296443904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296448000 ++read 2048/2048 bytes at offset 4296448000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296452096 ++read 2048/2048 bytes at offset 4296452096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296456192 ++read 2048/2048 bytes at offset 4296456192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296460288 ++read 2048/2048 bytes at offset 4296460288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296464384 ++read 2048/2048 bytes at offset 4296464384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296468480 ++read 2048/2048 bytes at offset 4296468480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296472576 ++read 2048/2048 bytes at offset 4296472576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296476672 ++read 2048/2048 bytes at offset 4296476672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296480768 ++read 2048/2048 bytes at offset 4296480768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296484864 ++read 2048/2048 bytes at offset 4296484864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296488960 ++read 2048/2048 bytes at offset 4296488960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296493056 ++read 2048/2048 bytes at offset 4296493056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296497152 ++read 2048/2048 bytes at offset 4296497152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296501248 ++read 2048/2048 bytes at offset 4296501248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296505344 ++read 2048/2048 bytes at offset 4296505344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296509440 ++read 2048/2048 bytes at offset 4296509440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296513536 ++read 2048/2048 bytes at offset 4296513536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296517632 ++read 2048/2048 bytes at offset 4296517632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296521728 ++read 2048/2048 bytes at offset 4296521728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296525824 ++read 2048/2048 bytes at offset 4296525824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296529920 ++read 2048/2048 bytes at offset 4296529920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296534016 ++read 2048/2048 bytes at offset 4296534016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296538112 ++read 2048/2048 bytes at offset 4296538112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296542208 ++read 2048/2048 bytes at offset 4296542208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296546304 ++read 2048/2048 bytes at offset 4296546304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296550400 ++read 2048/2048 bytes at offset 4296550400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296554496 ++read 2048/2048 bytes at offset 4296554496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296558592 ++read 2048/2048 bytes at offset 4296558592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296562688 ++read 2048/2048 bytes at offset 4296562688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296566784 ++read 2048/2048 bytes at offset 4296566784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296570880 ++read 2048/2048 bytes at offset 4296570880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296574976 ++read 2048/2048 bytes at offset 4296574976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296579072 ++read 2048/2048 bytes at offset 4296579072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296583168 ++read 2048/2048 bytes at offset 4296583168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296587264 ++read 2048/2048 bytes at offset 4296587264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296591360 ++read 2048/2048 bytes at offset 4296591360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296595456 ++read 2048/2048 bytes at offset 4296595456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296599552 ++read 2048/2048 bytes at offset 4296599552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296603648 ++read 2048/2048 bytes at offset 4296603648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296607744 ++read 2048/2048 bytes at offset 4296607744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296611840 ++read 2048/2048 bytes at offset 4296611840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296615936 ++read 2048/2048 bytes at offset 4296615936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296620032 ++read 2048/2048 bytes at offset 4296620032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296624128 ++read 2048/2048 bytes at offset 4296624128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296628224 ++read 2048/2048 bytes at offset 4296628224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296632320 ++read 2048/2048 bytes at offset 4296632320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296636416 ++read 2048/2048 bytes at offset 4296636416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296640512 ++read 2048/2048 bytes at offset 4296640512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296644608 ++read 2048/2048 bytes at offset 4296644608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296648704 ++read 2048/2048 bytes at offset 4296648704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296652800 ++read 2048/2048 bytes at offset 4296652800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296656896 ++read 2048/2048 bytes at offset 4296656896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296660992 ++read 2048/2048 bytes at offset 4296660992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296665088 ++read 2048/2048 bytes at offset 4296665088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296669184 ++read 2048/2048 bytes at offset 4296669184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296673280 ++read 2048/2048 bytes at offset 4296673280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296677376 ++read 2048/2048 bytes at offset 4296677376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296681472 ++read 2048/2048 bytes at offset 4296681472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296685568 ++read 2048/2048 bytes at offset 4296685568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296689664 ++read 2048/2048 bytes at offset 4296689664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296693760 ++read 2048/2048 bytes at offset 4296693760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296697856 ++read 2048/2048 bytes at offset 4296697856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296701952 ++read 2048/2048 bytes at offset 4296701952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296706048 ++read 2048/2048 bytes at offset 4296706048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296710144 ++read 2048/2048 bytes at offset 4296710144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296714240 ++read 2048/2048 bytes at offset 4296714240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296718336 ++read 2048/2048 bytes at offset 4296718336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296722432 ++read 2048/2048 bytes at offset 4296722432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296726528 ++read 2048/2048 bytes at offset 4296726528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296730624 ++read 2048/2048 bytes at offset 4296730624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296734720 ++read 2048/2048 bytes at offset 4296734720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296738816 ++read 2048/2048 bytes at offset 4296738816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296742912 ++read 2048/2048 bytes at offset 4296742912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296747008 ++read 2048/2048 bytes at offset 4296747008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296751104 ++read 2048/2048 bytes at offset 4296751104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296755200 ++read 2048/2048 bytes at offset 4296755200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296759296 ++read 2048/2048 bytes at offset 4296759296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296763392 ++read 2048/2048 bytes at offset 4296763392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296767488 ++read 2048/2048 bytes at offset 4296767488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296771584 ++read 2048/2048 bytes at offset 4296771584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296775680 ++read 2048/2048 bytes at offset 4296775680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296779776 ++read 2048/2048 bytes at offset 4296779776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296783872 ++read 2048/2048 bytes at offset 4296783872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296787968 ++read 2048/2048 bytes at offset 4296787968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296792064 ++read 2048/2048 bytes at offset 4296792064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296796160 ++read 2048/2048 bytes at offset 4296796160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296800256 ++read 2048/2048 bytes at offset 4296800256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296804352 ++read 2048/2048 bytes at offset 4296804352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296808448 ++read 2048/2048 bytes at offset 4296808448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296812544 ++read 2048/2048 bytes at offset 4296812544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296816640 ++read 2048/2048 bytes at offset 4296816640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296820736 ++read 2048/2048 bytes at offset 4296820736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296824832 ++read 2048/2048 bytes at offset 4296824832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296828928 ++read 2048/2048 bytes at offset 4296828928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296833024 ++read 2048/2048 bytes at offset 4296833024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296837120 ++read 2048/2048 bytes at offset 4296837120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296841216 ++read 2048/2048 bytes at offset 4296841216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296845312 ++read 2048/2048 bytes at offset 4296845312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296849408 ++read 2048/2048 bytes at offset 4296849408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296853504 ++read 2048/2048 bytes at offset 4296853504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296857600 ++read 2048/2048 bytes at offset 4296857600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296861696 ++read 2048/2048 bytes at offset 4296861696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296865792 ++read 2048/2048 bytes at offset 4296865792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296869888 ++read 2048/2048 bytes at offset 4296869888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296873984 ++read 2048/2048 bytes at offset 4296873984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296878080 ++read 2048/2048 bytes at offset 4296878080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296882176 ++read 2048/2048 bytes at offset 4296882176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296886272 ++read 2048/2048 bytes at offset 4296886272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296890368 ++read 2048/2048 bytes at offset 4296890368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296894464 ++read 2048/2048 bytes at offset 4296894464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296898560 ++read 2048/2048 bytes at offset 4296898560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296902656 ++read 2048/2048 bytes at offset 4296902656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296906752 ++read 2048/2048 bytes at offset 4296906752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296910848 ++read 2048/2048 bytes at offset 4296910848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296914944 ++read 2048/2048 bytes at offset 4296914944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296919040 ++read 2048/2048 bytes at offset 4296919040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296923136 ++read 2048/2048 bytes at offset 4296923136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296927232 ++read 2048/2048 bytes at offset 4296927232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296931328 ++read 2048/2048 bytes at offset 4296931328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296935424 ++read 2048/2048 bytes at offset 4296935424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296939520 ++read 2048/2048 bytes at offset 4296939520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296943616 ++read 2048/2048 bytes at offset 4296943616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296947712 ++read 2048/2048 bytes at offset 4296947712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296951808 ++read 2048/2048 bytes at offset 4296951808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296955904 ++read 2048/2048 bytes at offset 4296955904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296960000 ++read 2048/2048 bytes at offset 4296960000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296964096 ++read 2048/2048 bytes at offset 4296964096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296968192 ++read 2048/2048 bytes at offset 4296968192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296972288 ++read 2048/2048 bytes at offset 4296972288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296976384 ++read 2048/2048 bytes at offset 4296976384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296980480 ++read 2048/2048 bytes at offset 4296980480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296984576 ++read 2048/2048 bytes at offset 4296984576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296988672 ++read 2048/2048 bytes at offset 4296988672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296992768 ++read 2048/2048 bytes at offset 4296992768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296996864 ++read 2048/2048 bytes at offset 4296996864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297000960 ++read 2048/2048 bytes at offset 4297000960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297005056 ++read 2048/2048 bytes at offset 4297005056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297009152 ++read 2048/2048 bytes at offset 4297009152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297013248 ++read 2048/2048 bytes at offset 4297013248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297017344 ++read 2048/2048 bytes at offset 4297017344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297021440 ++read 2048/2048 bytes at offset 4297021440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297025536 ++read 2048/2048 bytes at offset 4297025536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297029632 ++read 2048/2048 bytes at offset 4297029632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297033728 ++read 2048/2048 bytes at offset 4297033728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297037824 ++read 2048/2048 bytes at offset 4297037824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297041920 ++read 2048/2048 bytes at offset 4297041920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297046016 ++read 2048/2048 bytes at offset 4297046016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297050112 ++read 2048/2048 bytes at offset 4297050112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297054208 ++read 2048/2048 bytes at offset 4297054208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297058304 ++read 2048/2048 bytes at offset 4297058304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297062400 ++read 2048/2048 bytes at offset 4297062400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> read 2048/2048 bytes at offset 4297064448 ++=== IO: pattern 0 ++read 2048/2048 bytes at offset 4297064448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297068544 ++read 2048/2048 bytes at offset 4297068544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297072640 ++read 2048/2048 bytes at offset 4297072640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297076736 ++read 2048/2048 bytes at offset 4297076736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297080832 ++read 2048/2048 bytes at offset 4297080832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297084928 ++read 2048/2048 bytes at offset 4297084928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297089024 ++read 2048/2048 bytes at offset 4297089024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297093120 ++read 2048/2048 bytes at offset 4297093120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297097216 ++read 2048/2048 bytes at offset 4297097216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297101312 ++read 2048/2048 bytes at offset 4297101312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297105408 ++read 2048/2048 bytes at offset 4297105408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297109504 ++read 2048/2048 bytes at offset 4297109504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297113600 ++read 2048/2048 bytes at offset 4297113600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297117696 ++read 2048/2048 bytes at offset 4297117696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297121792 ++read 2048/2048 bytes at offset 4297121792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297125888 ++read 2048/2048 bytes at offset 4297125888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297129984 ++read 2048/2048 bytes at offset 4297129984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297134080 ++read 2048/2048 bytes at offset 4297134080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297138176 ++read 2048/2048 bytes at offset 4297138176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297142272 ++read 2048/2048 bytes at offset 4297142272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297146368 ++read 2048/2048 bytes at offset 4297146368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297150464 ++read 2048/2048 bytes at offset 4297150464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297154560 ++read 2048/2048 bytes at offset 4297154560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297158656 ++read 2048/2048 bytes at offset 4297158656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297162752 ++read 2048/2048 bytes at offset 4297162752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297166848 ++read 2048/2048 bytes at offset 4297166848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297170944 ++read 2048/2048 bytes at offset 4297170944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297175040 ++read 2048/2048 bytes at offset 4297175040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297179136 ++read 2048/2048 bytes at offset 4297179136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297183232 ++read 2048/2048 bytes at offset 4297183232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297187328 ++read 2048/2048 bytes at offset 4297187328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297191424 ++read 2048/2048 bytes at offset 4297191424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297195520 ++read 2048/2048 bytes at offset 4297195520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297199616 ++read 2048/2048 bytes at offset 4297199616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297203712 ++read 2048/2048 bytes at offset 4297203712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297207808 ++read 2048/2048 bytes at offset 4297207808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297211904 ++read 2048/2048 bytes at offset 4297211904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297216000 ++read 2048/2048 bytes at offset 4297216000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297220096 ++read 2048/2048 bytes at offset 4297220096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297224192 ++read 2048/2048 bytes at offset 4297224192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297228288 ++read 2048/2048 bytes at offset 4297228288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297232384 ++read 2048/2048 bytes at offset 4297232384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297236480 ++read 2048/2048 bytes at offset 4297236480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297240576 ++read 2048/2048 bytes at offset 4297240576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297244672 ++read 2048/2048 bytes at offset 4297244672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297248768 ++read 2048/2048 bytes at offset 4297248768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297252864 ++read 2048/2048 bytes at offset 4297252864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297256960 ++read 2048/2048 bytes at offset 4297256960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297261056 ++read 2048/2048 bytes at offset 4297261056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297265152 ++read 2048/2048 bytes at offset 4297265152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297269248 ++read 2048/2048 bytes at offset 4297269248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297273344 ++read 2048/2048 bytes at offset 4297273344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297277440 ++read 2048/2048 bytes at offset 4297277440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297281536 ++read 2048/2048 bytes at offset 4297281536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297285632 ++read 2048/2048 bytes at offset 4297285632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297289728 ++read 2048/2048 bytes at offset 4297289728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297293824 ++read 2048/2048 bytes at offset 4297293824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297297920 ++read 2048/2048 bytes at offset 4297297920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297302016 ++read 2048/2048 bytes at offset 4297302016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297306112 ++read 2048/2048 bytes at offset 4297306112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297310208 ++read 2048/2048 bytes at offset 4297310208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297314304 ++read 2048/2048 bytes at offset 4297314304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297318400 ++read 2048/2048 bytes at offset 4297318400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297322496 ++read 2048/2048 bytes at offset 4297322496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297326592 ++read 2048/2048 bytes at offset 4297326592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297330688 ++read 2048/2048 bytes at offset 4297330688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297334784 ++read 2048/2048 bytes at offset 4297334784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297338880 ++read 2048/2048 bytes at offset 4297338880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297342976 ++read 2048/2048 bytes at offset 4297342976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297347072 ++read 2048/2048 bytes at offset 4297347072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297351168 ++read 2048/2048 bytes at offset 4297351168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297355264 ++read 2048/2048 bytes at offset 4297355264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297359360 ++read 2048/2048 bytes at offset 4297359360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297363456 ++read 2048/2048 bytes at offset 4297363456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297367552 ++read 2048/2048 bytes at offset 4297367552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297371648 ++read 2048/2048 bytes at offset 4297371648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297375744 ++read 2048/2048 bytes at offset 4297375744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297379840 ++read 2048/2048 bytes at offset 4297379840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297383936 ++read 2048/2048 bytes at offset 4297383936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297388032 ++read 2048/2048 bytes at offset 4297388032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297392128 ++read 2048/2048 bytes at offset 4297392128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297396224 ++read 2048/2048 bytes at offset 4297396224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297400320 ++read 2048/2048 bytes at offset 4297400320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297404416 ++read 2048/2048 bytes at offset 4297404416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297408512 ++read 2048/2048 bytes at offset 4297408512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297412608 ++read 2048/2048 bytes at offset 4297412608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297416704 ++read 2048/2048 bytes at offset 4297416704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297420800 ++read 2048/2048 bytes at offset 4297420800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297424896 ++read 2048/2048 bytes at offset 4297424896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297428992 ++read 2048/2048 bytes at offset 4297428992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297433088 ++read 2048/2048 bytes at offset 4297433088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297437184 ++read 2048/2048 bytes at offset 4297437184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297441280 ++read 2048/2048 bytes at offset 4297441280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297445376 ++read 2048/2048 bytes at offset 4297445376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297449472 ++read 2048/2048 bytes at offset 4297449472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297453568 ++read 2048/2048 bytes at offset 4297453568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297457664 ++read 2048/2048 bytes at offset 4297457664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297461760 ++read 2048/2048 bytes at offset 4297461760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297465856 ++read 2048/2048 bytes at offset 4297465856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297469952 ++read 2048/2048 bytes at offset 4297469952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297474048 ++read 2048/2048 bytes at offset 4297474048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297478144 ++read 2048/2048 bytes at offset 4297478144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297482240 ++read 2048/2048 bytes at offset 4297482240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297486336 ++read 2048/2048 bytes at offset 4297486336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297490432 ++read 2048/2048 bytes at offset 4297490432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297494528 ++read 2048/2048 bytes at offset 4297494528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297498624 ++read 2048/2048 bytes at offset 4297498624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297502720 ++read 2048/2048 bytes at offset 4297502720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297506816 ++read 2048/2048 bytes at offset 4297506816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297510912 ++read 2048/2048 bytes at offset 4297510912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297515008 ++read 2048/2048 bytes at offset 4297515008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297519104 ++read 2048/2048 bytes at offset 4297519104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297523200 ++read 2048/2048 bytes at offset 4297523200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297527296 ++read 2048/2048 bytes at offset 4297527296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297531392 ++read 2048/2048 bytes at offset 4297531392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297535488 ++read 2048/2048 bytes at offset 4297535488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297539584 ++read 2048/2048 bytes at offset 4297539584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297543680 ++read 2048/2048 bytes at offset 4297543680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297547776 ++read 2048/2048 bytes at offset 4297547776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297551872 ++read 2048/2048 bytes at offset 4297551872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297555968 ++read 2048/2048 bytes at offset 4297555968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297560064 ++read 2048/2048 bytes at offset 4297560064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297564160 ++read 2048/2048 bytes at offset 4297564160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297568256 ++read 2048/2048 bytes at offset 4297568256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297572352 ++read 2048/2048 bytes at offset 4297572352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297576448 ++read 2048/2048 bytes at offset 4297576448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297580544 ++read 2048/2048 bytes at offset 4297580544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297584640 ++read 2048/2048 bytes at offset 4297584640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297588736 ++read 2048/2048 bytes at offset 4297588736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297592832 ++read 2048/2048 bytes at offset 4297592832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297596928 ++read 2048/2048 bytes at offset 4297596928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297601024 ++read 2048/2048 bytes at offset 4297601024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297605120 ++read 2048/2048 bytes at offset 4297605120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297609216 ++read 2048/2048 bytes at offset 4297609216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297613312 ++read 2048/2048 bytes at offset 4297613312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297617408 ++read 2048/2048 bytes at offset 4297617408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297621504 ++read 2048/2048 bytes at offset 4297621504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297625600 ++read 2048/2048 bytes at offset 4297625600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297629696 ++read 2048/2048 bytes at offset 4297629696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297633792 ++read 2048/2048 bytes at offset 4297633792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297637888 ++read 2048/2048 bytes at offset 4297637888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297641984 ++read 2048/2048 bytes at offset 4297641984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297646080 ++read 2048/2048 bytes at offset 4297646080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297650176 ++read 2048/2048 bytes at offset 4297650176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297654272 ++read 2048/2048 bytes at offset 4297654272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297658368 ++read 2048/2048 bytes at offset 4297658368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297662464 ++read 2048/2048 bytes at offset 4297662464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297666560 ++read 2048/2048 bytes at offset 4297666560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297670656 ++read 2048/2048 bytes at offset 4297670656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297674752 ++read 2048/2048 bytes at offset 4297674752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297678848 ++read 2048/2048 bytes at offset 4297678848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297682944 ++read 2048/2048 bytes at offset 4297682944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297687040 ++read 2048/2048 bytes at offset 4297687040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297691136 ++read 2048/2048 bytes at offset 4297691136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297695232 ++read 2048/2048 bytes at offset 4297695232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297699328 ++read 2048/2048 bytes at offset 4297699328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297703424 ++read 2048/2048 bytes at offset 4297703424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297707520 ++read 2048/2048 bytes at offset 4297707520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297711616 ++read 2048/2048 bytes at offset 4297711616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297715712 ++read 2048/2048 bytes at offset 4297715712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297719808 ++read 2048/2048 bytes at offset 4297719808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297723904 ++read 2048/2048 bytes at offset 4297723904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297728000 ++read 2048/2048 bytes at offset 4297728000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297732096 ++read 2048/2048 bytes at offset 4297732096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297736192 ++read 2048/2048 bytes at offset 4297736192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297740288 ++read 2048/2048 bytes at offset 4297740288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297744384 ++read 2048/2048 bytes at offset 4297744384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297748480 ++read 2048/2048 bytes at offset 4297748480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297752576 ++read 2048/2048 bytes at offset 4297752576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297756672 ++read 2048/2048 bytes at offset 4297756672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297760768 ++read 2048/2048 bytes at offset 4297760768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297764864 ++read 2048/2048 bytes at offset 4297764864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297768960 ++read 2048/2048 bytes at offset 4297768960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297773056 ++read 2048/2048 bytes at offset 4297773056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297777152 ++read 2048/2048 bytes at offset 4297777152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297781248 ++read 2048/2048 bytes at offset 4297781248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297785344 ++read 2048/2048 bytes at offset 4297785344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297789440 ++read 2048/2048 bytes at offset 4297789440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297793536 ++read 2048/2048 bytes at offset 4297793536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297797632 ++read 2048/2048 bytes at offset 4297797632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297801728 ++read 2048/2048 bytes at offset 4297801728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297805824 ++read 2048/2048 bytes at offset 4297805824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297809920 ++read 2048/2048 bytes at offset 4297809920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297814016 ++read 2048/2048 bytes at offset 4297814016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297818112 ++read 2048/2048 bytes at offset 4297818112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297822208 ++read 2048/2048 bytes at offset 4297822208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297826304 ++read 2048/2048 bytes at offset 4297826304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297830400 ++read 2048/2048 bytes at offset 4297830400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297834496 ++read 2048/2048 bytes at offset 4297834496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297838592 ++read 2048/2048 bytes at offset 4297838592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297842688 ++read 2048/2048 bytes at offset 4297842688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297846784 ++read 2048/2048 bytes at offset 4297846784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297850880 ++read 2048/2048 bytes at offset 4297850880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297854976 ++read 2048/2048 bytes at offset 4297854976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297859072 ++read 2048/2048 bytes at offset 4297859072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297863168 ++read 2048/2048 bytes at offset 4297863168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297867264 ++read 2048/2048 bytes at offset 4297867264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297871360 ++read 2048/2048 bytes at offset 4297871360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297875456 ++read 2048/2048 bytes at offset 4297875456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297879552 ++read 2048/2048 bytes at offset 4297879552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297883648 ++read 2048/2048 bytes at offset 4297883648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297887744 ++read 2048/2048 bytes at offset 4297887744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297891840 ++read 2048/2048 bytes at offset 4297891840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297895936 ++read 2048/2048 bytes at offset 4297895936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297900032 ++read 2048/2048 bytes at offset 4297900032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297904128 ++read 2048/2048 bytes at offset 4297904128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297908224 ++read 2048/2048 bytes at offset 4297908224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297912320 ++read 2048/2048 bytes at offset 4297912320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297916416 ++read 2048/2048 bytes at offset 4297916416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297920512 ++read 2048/2048 bytes at offset 4297920512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297924608 ++read 2048/2048 bytes at offset 4297924608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297928704 ++read 2048/2048 bytes at offset 4297928704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297932800 ++read 2048/2048 bytes at offset 4297932800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297936896 ++read 2048/2048 bytes at offset 4297936896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297940992 ++read 2048/2048 bytes at offset 4297940992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297945088 ++read 2048/2048 bytes at offset 4297945088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297949184 ++read 2048/2048 bytes at offset 4297949184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297953280 ++read 2048/2048 bytes at offset 4297953280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297957376 ++read 2048/2048 bytes at offset 4297957376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297961472 ++read 2048/2048 bytes at offset 4297961472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297965568 ++read 2048/2048 bytes at offset 4297965568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297969664 ++read 2048/2048 bytes at offset 4297969664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297973760 ++read 2048/2048 bytes at offset 4297973760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297977856 ++read 2048/2048 bytes at offset 4297977856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297981952 ++read 2048/2048 bytes at offset 4297981952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297986048 ++read 2048/2048 bytes at offset 4297986048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297990144 ++read 2048/2048 bytes at offset 4297990144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297994240 ++read 2048/2048 bytes at offset 4297994240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297998336 ++read 2048/2048 bytes at offset 4297998336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298002432 ++read 2048/2048 bytes at offset 4298002432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298006528 ++read 2048/2048 bytes at offset 4298006528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298010624 ++read 2048/2048 bytes at offset 4298010624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298014720 ++read 2048/2048 bytes at offset 4298014720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298018816 ++read 2048/2048 bytes at offset 4298018816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298022912 ++read 2048/2048 bytes at offset 4298022912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298027008 ++read 2048/2048 bytes at offset 4298027008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298031104 ++read 2048/2048 bytes at offset 4298031104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298035200 ++read 2048/2048 bytes at offset 4298035200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298039296 ++read 2048/2048 bytes at offset 4298039296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298043392 ++read 2048/2048 bytes at offset 4298043392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298047488 ++read 2048/2048 bytes at offset 4298047488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298051584 ++read 2048/2048 bytes at offset 4298051584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298055680 ++read 2048/2048 bytes at offset 4298055680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298059776 ++read 2048/2048 bytes at offset 4298059776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298063872 ++read 2048/2048 bytes at offset 4298063872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298067968 ++read 2048/2048 bytes at offset 4298067968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298072064 ++read 2048/2048 bytes at offset 4298072064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298076160 ++read 2048/2048 bytes at offset 4298076160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298080256 ++read 2048/2048 bytes at offset 4298080256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298084352 ++read 2048/2048 bytes at offset 4298084352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298088448 ++read 2048/2048 bytes at offset 4298088448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298092544 ++read 2048/2048 bytes at offset 4298092544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298096640 ++read 2048/2048 bytes at offset 4298096640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298100736 ++read 2048/2048 bytes at offset 4298100736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298104832 ++read 2048/2048 bytes at offset 4298104832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298108928 ++read 2048/2048 bytes at offset 4298108928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 2 +-qemu-io> read 2048/2048 bytes at offset 4298114048 ++=== IO: pattern 2 ++read 2048/2048 bytes at offset 4298114048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298118144 ++read 2048/2048 bytes at offset 4298118144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298122240 ++read 2048/2048 bytes at offset 4298122240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298126336 ++read 2048/2048 bytes at offset 4298126336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298130432 ++read 2048/2048 bytes at offset 4298130432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298134528 ++read 2048/2048 bytes at offset 4298134528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298138624 ++read 2048/2048 bytes at offset 4298138624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298142720 ++read 2048/2048 bytes at offset 4298142720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298146816 ++read 2048/2048 bytes at offset 4298146816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298150912 ++read 2048/2048 bytes at offset 4298150912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298155008 ++read 2048/2048 bytes at offset 4298155008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298159104 ++read 2048/2048 bytes at offset 4298159104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298163200 ++read 2048/2048 bytes at offset 4298163200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298167296 ++read 2048/2048 bytes at offset 4298167296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298171392 ++read 2048/2048 bytes at offset 4298171392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298175488 ++read 2048/2048 bytes at offset 4298175488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298179584 ++read 2048/2048 bytes at offset 4298179584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298183680 ++read 2048/2048 bytes at offset 4298183680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298187776 ++read 2048/2048 bytes at offset 4298187776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298191872 ++read 2048/2048 bytes at offset 4298191872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298195968 ++read 2048/2048 bytes at offset 4298195968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298200064 ++read 2048/2048 bytes at offset 4298200064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298204160 ++read 2048/2048 bytes at offset 4298204160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298208256 ++read 2048/2048 bytes at offset 4298208256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298212352 ++read 2048/2048 bytes at offset 4298212352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298216448 ++read 2048/2048 bytes at offset 4298216448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298220544 ++read 2048/2048 bytes at offset 4298220544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298224640 ++read 2048/2048 bytes at offset 4298224640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298228736 ++read 2048/2048 bytes at offset 4298228736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298232832 ++read 2048/2048 bytes at offset 4298232832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298236928 ++read 2048/2048 bytes at offset 4298236928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298241024 ++read 2048/2048 bytes at offset 4298241024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298245120 ++read 2048/2048 bytes at offset 4298245120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298249216 ++read 2048/2048 bytes at offset 4298249216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298253312 ++read 2048/2048 bytes at offset 4298253312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298257408 ++read 2048/2048 bytes at offset 4298257408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298261504 ++read 2048/2048 bytes at offset 4298261504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298265600 ++read 2048/2048 bytes at offset 4298265600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298269696 ++read 2048/2048 bytes at offset 4298269696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298273792 ++read 2048/2048 bytes at offset 4298273792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298277888 ++read 2048/2048 bytes at offset 4298277888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298281984 ++read 2048/2048 bytes at offset 4298281984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298286080 ++read 2048/2048 bytes at offset 4298286080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298290176 ++read 2048/2048 bytes at offset 4298290176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298294272 ++read 2048/2048 bytes at offset 4298294272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298298368 ++read 2048/2048 bytes at offset 4298298368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298302464 ++read 2048/2048 bytes at offset 4298302464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298306560 ++read 2048/2048 bytes at offset 4298306560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298310656 ++read 2048/2048 bytes at offset 4298310656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298314752 ++read 2048/2048 bytes at offset 4298314752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298318848 ++read 2048/2048 bytes at offset 4298318848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298322944 ++read 2048/2048 bytes at offset 4298322944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298327040 ++read 2048/2048 bytes at offset 4298327040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298331136 ++read 2048/2048 bytes at offset 4298331136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298335232 ++read 2048/2048 bytes at offset 4298335232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298339328 ++read 2048/2048 bytes at offset 4298339328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298343424 ++read 2048/2048 bytes at offset 4298343424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298347520 ++read 2048/2048 bytes at offset 4298347520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298351616 ++read 2048/2048 bytes at offset 4298351616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298355712 ++read 2048/2048 bytes at offset 4298355712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298359808 ++read 2048/2048 bytes at offset 4298359808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298363904 ++read 2048/2048 bytes at offset 4298363904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298368000 ++read 2048/2048 bytes at offset 4298368000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298372096 ++read 2048/2048 bytes at offset 4298372096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298376192 ++read 2048/2048 bytes at offset 4298376192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298380288 ++read 2048/2048 bytes at offset 4298380288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298384384 ++read 2048/2048 bytes at offset 4298384384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298388480 ++read 2048/2048 bytes at offset 4298388480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298392576 ++read 2048/2048 bytes at offset 4298392576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298396672 ++read 2048/2048 bytes at offset 4298396672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298400768 ++read 2048/2048 bytes at offset 4298400768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298404864 ++read 2048/2048 bytes at offset 4298404864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298408960 ++read 2048/2048 bytes at offset 4298408960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298413056 ++read 2048/2048 bytes at offset 4298413056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298417152 ++read 2048/2048 bytes at offset 4298417152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298421248 ++read 2048/2048 bytes at offset 4298421248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298425344 ++read 2048/2048 bytes at offset 4298425344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298429440 ++read 2048/2048 bytes at offset 4298429440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298433536 ++read 2048/2048 bytes at offset 4298433536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298437632 ++read 2048/2048 bytes at offset 4298437632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298441728 ++read 2048/2048 bytes at offset 4298441728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298445824 ++read 2048/2048 bytes at offset 4298445824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298449920 ++read 2048/2048 bytes at offset 4298449920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298454016 ++read 2048/2048 bytes at offset 4298454016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298458112 ++read 2048/2048 bytes at offset 4298458112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298462208 ++read 2048/2048 bytes at offset 4298462208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298466304 ++read 2048/2048 bytes at offset 4298466304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298470400 ++read 2048/2048 bytes at offset 4298470400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298474496 ++read 2048/2048 bytes at offset 4298474496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298478592 ++read 2048/2048 bytes at offset 4298478592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298482688 ++read 2048/2048 bytes at offset 4298482688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298486784 ++read 2048/2048 bytes at offset 4298486784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298490880 ++read 2048/2048 bytes at offset 4298490880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298494976 ++read 2048/2048 bytes at offset 4298494976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298499072 ++read 2048/2048 bytes at offset 4298499072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298503168 ++read 2048/2048 bytes at offset 4298503168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298507264 ++read 2048/2048 bytes at offset 4298507264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298511360 ++read 2048/2048 bytes at offset 4298511360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298515456 ++read 2048/2048 bytes at offset 4298515456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298519552 ++read 2048/2048 bytes at offset 4298519552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298523648 ++read 2048/2048 bytes at offset 4298523648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298527744 ++read 2048/2048 bytes at offset 4298527744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298531840 ++read 2048/2048 bytes at offset 4298531840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298535936 ++read 2048/2048 bytes at offset 4298535936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298540032 ++read 2048/2048 bytes at offset 4298540032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298544128 ++read 2048/2048 bytes at offset 4298544128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298548224 ++read 2048/2048 bytes at offset 4298548224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298552320 ++read 2048/2048 bytes at offset 4298552320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298556416 ++read 2048/2048 bytes at offset 4298556416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298560512 ++read 2048/2048 bytes at offset 4298560512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298564608 ++read 2048/2048 bytes at offset 4298564608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298568704 ++read 2048/2048 bytes at offset 4298568704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298572800 ++read 2048/2048 bytes at offset 4298572800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298576896 ++read 2048/2048 bytes at offset 4298576896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298580992 ++read 2048/2048 bytes at offset 4298580992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298585088 ++read 2048/2048 bytes at offset 4298585088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298589184 ++read 2048/2048 bytes at offset 4298589184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298593280 ++read 2048/2048 bytes at offset 4298593280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298597376 ++read 2048/2048 bytes at offset 4298597376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298601472 ++read 2048/2048 bytes at offset 4298601472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298605568 ++read 2048/2048 bytes at offset 4298605568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298609664 ++read 2048/2048 bytes at offset 4298609664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298613760 ++read 2048/2048 bytes at offset 4298613760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298617856 ++read 2048/2048 bytes at offset 4298617856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298621952 ++read 2048/2048 bytes at offset 4298621952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298626048 ++read 2048/2048 bytes at offset 4298626048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298630144 ++read 2048/2048 bytes at offset 4298630144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298634240 ++read 2048/2048 bytes at offset 4298634240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298638336 ++read 2048/2048 bytes at offset 4298638336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298642432 ++read 2048/2048 bytes at offset 4298642432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298646528 ++read 2048/2048 bytes at offset 4298646528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298650624 ++read 2048/2048 bytes at offset 4298650624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298654720 ++read 2048/2048 bytes at offset 4298654720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298658816 ++read 2048/2048 bytes at offset 4298658816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298662912 ++read 2048/2048 bytes at offset 4298662912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298667008 ++read 2048/2048 bytes at offset 4298667008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298671104 ++read 2048/2048 bytes at offset 4298671104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298675200 ++read 2048/2048 bytes at offset 4298675200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298679296 ++read 2048/2048 bytes at offset 4298679296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298683392 ++read 2048/2048 bytes at offset 4298683392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298687488 ++read 2048/2048 bytes at offset 4298687488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298691584 ++read 2048/2048 bytes at offset 4298691584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298695680 ++read 2048/2048 bytes at offset 4298695680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298699776 ++read 2048/2048 bytes at offset 4298699776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298703872 ++read 2048/2048 bytes at offset 4298703872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298707968 ++read 2048/2048 bytes at offset 4298707968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298712064 ++read 2048/2048 bytes at offset 4298712064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298716160 ++read 2048/2048 bytes at offset 4298716160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298720256 ++read 2048/2048 bytes at offset 4298720256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298724352 ++read 2048/2048 bytes at offset 4298724352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298728448 ++read 2048/2048 bytes at offset 4298728448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298732544 ++read 2048/2048 bytes at offset 4298732544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298736640 ++read 2048/2048 bytes at offset 4298736640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298740736 ++read 2048/2048 bytes at offset 4298740736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298744832 ++read 2048/2048 bytes at offset 4298744832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298748928 ++read 2048/2048 bytes at offset 4298748928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298753024 ++read 2048/2048 bytes at offset 4298753024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298757120 ++read 2048/2048 bytes at offset 4298757120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298761216 ++read 2048/2048 bytes at offset 4298761216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298765312 ++read 2048/2048 bytes at offset 4298765312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298769408 ++read 2048/2048 bytes at offset 4298769408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298773504 ++read 2048/2048 bytes at offset 4298773504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298777600 ++read 2048/2048 bytes at offset 4298777600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298781696 ++read 2048/2048 bytes at offset 4298781696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298785792 ++read 2048/2048 bytes at offset 4298785792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298789888 ++read 2048/2048 bytes at offset 4298789888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298793984 ++read 2048/2048 bytes at offset 4298793984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298798080 ++read 2048/2048 bytes at offset 4298798080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298802176 ++read 2048/2048 bytes at offset 4298802176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298806272 ++read 2048/2048 bytes at offset 4298806272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298810368 ++read 2048/2048 bytes at offset 4298810368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298814464 ++read 2048/2048 bytes at offset 4298814464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298818560 ++read 2048/2048 bytes at offset 4298818560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298822656 ++read 2048/2048 bytes at offset 4298822656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298826752 ++read 2048/2048 bytes at offset 4298826752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298830848 ++read 2048/2048 bytes at offset 4298830848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298834944 ++read 2048/2048 bytes at offset 4298834944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298839040 ++read 2048/2048 bytes at offset 4298839040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298843136 ++read 2048/2048 bytes at offset 4298843136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298847232 ++read 2048/2048 bytes at offset 4298847232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298851328 ++read 2048/2048 bytes at offset 4298851328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298855424 ++read 2048/2048 bytes at offset 4298855424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298859520 ++read 2048/2048 bytes at offset 4298859520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298863616 ++read 2048/2048 bytes at offset 4298863616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298867712 ++read 2048/2048 bytes at offset 4298867712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298871808 ++read 2048/2048 bytes at offset 4298871808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298875904 ++read 2048/2048 bytes at offset 4298875904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298880000 ++read 2048/2048 bytes at offset 4298880000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298884096 ++read 2048/2048 bytes at offset 4298884096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298888192 ++read 2048/2048 bytes at offset 4298888192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298892288 ++read 2048/2048 bytes at offset 4298892288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298896384 ++read 2048/2048 bytes at offset 4298896384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298900480 ++read 2048/2048 bytes at offset 4298900480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298904576 ++read 2048/2048 bytes at offset 4298904576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298908672 ++read 2048/2048 bytes at offset 4298908672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298912768 ++read 2048/2048 bytes at offset 4298912768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298916864 ++read 2048/2048 bytes at offset 4298916864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298920960 ++read 2048/2048 bytes at offset 4298920960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298925056 ++read 2048/2048 bytes at offset 4298925056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298929152 ++read 2048/2048 bytes at offset 4298929152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298933248 ++read 2048/2048 bytes at offset 4298933248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298937344 ++read 2048/2048 bytes at offset 4298937344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298941440 ++read 2048/2048 bytes at offset 4298941440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298945536 ++read 2048/2048 bytes at offset 4298945536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298949632 ++read 2048/2048 bytes at offset 4298949632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298953728 ++read 2048/2048 bytes at offset 4298953728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298957824 ++read 2048/2048 bytes at offset 4298957824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298961920 ++read 2048/2048 bytes at offset 4298961920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298966016 ++read 2048/2048 bytes at offset 4298966016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298970112 ++read 2048/2048 bytes at offset 4298970112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298974208 ++read 2048/2048 bytes at offset 4298974208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298978304 ++read 2048/2048 bytes at offset 4298978304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298982400 ++read 2048/2048 bytes at offset 4298982400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298986496 ++read 2048/2048 bytes at offset 4298986496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298990592 ++read 2048/2048 bytes at offset 4298990592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298994688 ++read 2048/2048 bytes at offset 4298994688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298998784 ++read 2048/2048 bytes at offset 4298998784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299002880 ++read 2048/2048 bytes at offset 4299002880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299006976 ++read 2048/2048 bytes at offset 4299006976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299011072 ++read 2048/2048 bytes at offset 4299011072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299015168 ++read 2048/2048 bytes at offset 4299015168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299019264 ++read 2048/2048 bytes at offset 4299019264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299023360 ++read 2048/2048 bytes at offset 4299023360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299027456 ++read 2048/2048 bytes at offset 4299027456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299031552 ++read 2048/2048 bytes at offset 4299031552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299035648 ++read 2048/2048 bytes at offset 4299035648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299039744 ++read 2048/2048 bytes at offset 4299039744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299043840 ++read 2048/2048 bytes at offset 4299043840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299047936 ++read 2048/2048 bytes at offset 4299047936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299052032 ++read 2048/2048 bytes at offset 4299052032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299056128 ++read 2048/2048 bytes at offset 4299056128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299060224 ++read 2048/2048 bytes at offset 4299060224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299064320 ++read 2048/2048 bytes at offset 4299064320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299068416 ++read 2048/2048 bytes at offset 4299068416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299072512 ++read 2048/2048 bytes at offset 4299072512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299076608 ++read 2048/2048 bytes at offset 4299076608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299080704 ++read 2048/2048 bytes at offset 4299080704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299084800 ++read 2048/2048 bytes at offset 4299084800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299088896 ++read 2048/2048 bytes at offset 4299088896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299092992 ++read 2048/2048 bytes at offset 4299092992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299097088 ++read 2048/2048 bytes at offset 4299097088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299101184 ++read 2048/2048 bytes at offset 4299101184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299105280 ++read 2048/2048 bytes at offset 4299105280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299109376 ++read 2048/2048 bytes at offset 4299109376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299113472 ++read 2048/2048 bytes at offset 4299113472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299117568 ++read 2048/2048 bytes at offset 4299117568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299121664 ++read 2048/2048 bytes at offset 4299121664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299125760 ++read 2048/2048 bytes at offset 4299125760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299129856 ++read 2048/2048 bytes at offset 4299129856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299133952 ++read 2048/2048 bytes at offset 4299133952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299138048 ++read 2048/2048 bytes at offset 4299138048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299142144 ++read 2048/2048 bytes at offset 4299142144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299146240 ++read 2048/2048 bytes at offset 4299146240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299150336 ++read 2048/2048 bytes at offset 4299150336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299154432 ++read 2048/2048 bytes at offset 4299154432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299158528 ++read 2048/2048 bytes at offset 4299158528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 4 +-qemu-io> read 8192/8192 bytes at offset 4299163648 ++=== IO: pattern 4 ++read 8192/8192 bytes at offset 4299163648 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299175936 ++read 8192/8192 bytes at offset 4299175936 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299188224 ++read 8192/8192 bytes at offset 4299188224 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299200512 ++read 8192/8192 bytes at offset 4299200512 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299212800 ++read 8192/8192 bytes at offset 4299212800 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299225088 ++read 8192/8192 bytes at offset 4299225088 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299237376 ++read 8192/8192 bytes at offset 4299237376 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299249664 ++read 8192/8192 bytes at offset 4299249664 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299261952 ++read 8192/8192 bytes at offset 4299261952 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299274240 ++read 8192/8192 bytes at offset 4299274240 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299286528 ++read 8192/8192 bytes at offset 4299286528 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299298816 ++read 8192/8192 bytes at offset 4299298816 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299311104 ++read 8192/8192 bytes at offset 4299311104 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299323392 ++read 8192/8192 bytes at offset 4299323392 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299335680 ++read 8192/8192 bytes at offset 4299335680 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299347968 ++read 8192/8192 bytes at offset 4299347968 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299360256 ++read 8192/8192 bytes at offset 4299360256 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299372544 ++read 8192/8192 bytes at offset 4299372544 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299384832 ++read 8192/8192 bytes at offset 4299384832 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299397120 ++read 8192/8192 bytes at offset 4299397120 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299409408 ++read 8192/8192 bytes at offset 4299409408 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299421696 ++read 8192/8192 bytes at offset 4299421696 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299433984 ++read 8192/8192 bytes at offset 4299433984 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299446272 ++read 8192/8192 bytes at offset 4299446272 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299458560 ++read 8192/8192 bytes at offset 4299458560 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299470848 ++read 8192/8192 bytes at offset 4299470848 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299483136 ++read 8192/8192 bytes at offset 4299483136 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299495424 ++read 8192/8192 bytes at offset 4299495424 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299507712 ++read 8192/8192 bytes at offset 4299507712 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299520000 ++read 8192/8192 bytes at offset 4299520000 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299532288 ++read 8192/8192 bytes at offset 4299532288 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299544576 ++read 8192/8192 bytes at offset 4299544576 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299556864 ++read 8192/8192 bytes at offset 4299556864 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299569152 ++read 8192/8192 bytes at offset 4299569152 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299581440 ++read 8192/8192 bytes at offset 4299581440 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299593728 ++read 8192/8192 bytes at offset 4299593728 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299606016 ++read 8192/8192 bytes at offset 4299606016 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299618304 ++read 8192/8192 bytes at offset 4299618304 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299630592 ++read 8192/8192 bytes at offset 4299630592 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299642880 ++read 8192/8192 bytes at offset 4299642880 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299655168 ++read 8192/8192 bytes at offset 4299655168 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299667456 ++read 8192/8192 bytes at offset 4299667456 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299679744 ++read 8192/8192 bytes at offset 4299679744 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299692032 ++read 8192/8192 bytes at offset 4299692032 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299704320 ++read 8192/8192 bytes at offset 4299704320 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299716608 ++read 8192/8192 bytes at offset 4299716608 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299728896 ++read 8192/8192 bytes at offset 4299728896 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299741184 ++read 8192/8192 bytes at offset 4299741184 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299753472 ++read 8192/8192 bytes at offset 4299753472 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299765760 ++read 8192/8192 bytes at offset 4299765760 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299778048 ++read 8192/8192 bytes at offset 4299778048 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299790336 ++read 8192/8192 bytes at offset 4299790336 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299802624 ++read 8192/8192 bytes at offset 4299802624 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299814912 ++read 8192/8192 bytes at offset 4299814912 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299827200 ++read 8192/8192 bytes at offset 4299827200 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299839488 ++read 8192/8192 bytes at offset 4299839488 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299851776 ++read 8192/8192 bytes at offset 4299851776 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299864064 ++read 8192/8192 bytes at offset 4299864064 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299876352 ++read 8192/8192 bytes at offset 4299876352 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299888640 ++read 8192/8192 bytes at offset 4299888640 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299900928 ++read 8192/8192 bytes at offset 4299900928 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299913216 ++read 8192/8192 bytes at offset 4299913216 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299925504 ++read 8192/8192 bytes at offset 4299925504 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299937792 ++read 8192/8192 bytes at offset 4299937792 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 244 +-qemu-io> read 12288/12288 bytes at offset 4301252608 ++=== IO: pattern 244 ++read 12288/12288 bytes at offset 4301252608 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4303351808 ++read 12288/12288 bytes at offset 4303351808 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4305451008 ++read 12288/12288 bytes at offset 4305451008 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4307550208 ++read 12288/12288 bytes at offset 4307550208 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4309649408 ++read 12288/12288 bytes at offset 4309649408 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4311748608 ++read 12288/12288 bytes at offset 4311748608 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4313847808 ++read 12288/12288 bytes at offset 4313847808 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4315947008 ++read 12288/12288 bytes at offset 4315947008 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> wrote 4096/4096 bytes at offset 4294967296 ++=== IO: pattern 0 ++wrote 4096/4096 bytes at offset 4294967296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4294971392 ++wrote 4096/4096 bytes at offset 4294971392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4294975488 ++wrote 4096/4096 bytes at offset 4294975488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4294979584 ++wrote 4096/4096 bytes at offset 4294979584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4294983680 ++wrote 4096/4096 bytes at offset 4294983680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4294987776 ++wrote 4096/4096 bytes at offset 4294987776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4294991872 ++wrote 4096/4096 bytes at offset 4294991872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4294995968 ++wrote 4096/4096 bytes at offset 4294995968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295000064 ++wrote 4096/4096 bytes at offset 4295000064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295004160 ++wrote 4096/4096 bytes at offset 4295004160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295008256 ++wrote 4096/4096 bytes at offset 4295008256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295012352 ++wrote 4096/4096 bytes at offset 4295012352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295016448 ++wrote 4096/4096 bytes at offset 4295016448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295020544 ++wrote 4096/4096 bytes at offset 4295020544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295024640 ++wrote 4096/4096 bytes at offset 4295024640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295028736 ++wrote 4096/4096 bytes at offset 4295028736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295032832 ++wrote 4096/4096 bytes at offset 4295032832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295036928 ++wrote 4096/4096 bytes at offset 4295036928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295041024 ++wrote 4096/4096 bytes at offset 4295041024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295045120 ++wrote 4096/4096 bytes at offset 4295045120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295049216 ++wrote 4096/4096 bytes at offset 4295049216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295053312 ++wrote 4096/4096 bytes at offset 4295053312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295057408 ++wrote 4096/4096 bytes at offset 4295057408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295061504 ++wrote 4096/4096 bytes at offset 4295061504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295065600 ++wrote 4096/4096 bytes at offset 4295065600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295069696 ++wrote 4096/4096 bytes at offset 4295069696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295073792 ++wrote 4096/4096 bytes at offset 4295073792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295077888 ++wrote 4096/4096 bytes at offset 4295077888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295081984 ++wrote 4096/4096 bytes at offset 4295081984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295086080 ++wrote 4096/4096 bytes at offset 4295086080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295090176 ++wrote 4096/4096 bytes at offset 4295090176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295094272 ++wrote 4096/4096 bytes at offset 4295094272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295098368 ++wrote 4096/4096 bytes at offset 4295098368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295102464 ++wrote 4096/4096 bytes at offset 4295102464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295106560 ++wrote 4096/4096 bytes at offset 4295106560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295110656 ++wrote 4096/4096 bytes at offset 4295110656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295114752 ++wrote 4096/4096 bytes at offset 4295114752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295118848 ++wrote 4096/4096 bytes at offset 4295118848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295122944 ++wrote 4096/4096 bytes at offset 4295122944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295127040 ++wrote 4096/4096 bytes at offset 4295127040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295131136 ++wrote 4096/4096 bytes at offset 4295131136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295135232 ++wrote 4096/4096 bytes at offset 4295135232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295139328 ++wrote 4096/4096 bytes at offset 4295139328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295143424 ++wrote 4096/4096 bytes at offset 4295143424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295147520 ++wrote 4096/4096 bytes at offset 4295147520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295151616 ++wrote 4096/4096 bytes at offset 4295151616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295155712 ++wrote 4096/4096 bytes at offset 4295155712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295159808 ++wrote 4096/4096 bytes at offset 4295159808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295163904 ++wrote 4096/4096 bytes at offset 4295163904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295168000 ++wrote 4096/4096 bytes at offset 4295168000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295172096 ++wrote 4096/4096 bytes at offset 4295172096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295176192 ++wrote 4096/4096 bytes at offset 4295176192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295180288 ++wrote 4096/4096 bytes at offset 4295180288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295184384 ++wrote 4096/4096 bytes at offset 4295184384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295188480 ++wrote 4096/4096 bytes at offset 4295188480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295192576 ++wrote 4096/4096 bytes at offset 4295192576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295196672 ++wrote 4096/4096 bytes at offset 4295196672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295200768 ++wrote 4096/4096 bytes at offset 4295200768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295204864 ++wrote 4096/4096 bytes at offset 4295204864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295208960 ++wrote 4096/4096 bytes at offset 4295208960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295213056 ++wrote 4096/4096 bytes at offset 4295213056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295217152 ++wrote 4096/4096 bytes at offset 4295217152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295221248 ++wrote 4096/4096 bytes at offset 4295221248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295225344 ++wrote 4096/4096 bytes at offset 4295225344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295229440 ++wrote 4096/4096 bytes at offset 4295229440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295233536 ++wrote 4096/4096 bytes at offset 4295233536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295237632 ++wrote 4096/4096 bytes at offset 4295237632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295241728 ++wrote 4096/4096 bytes at offset 4295241728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295245824 ++wrote 4096/4096 bytes at offset 4295245824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295249920 ++wrote 4096/4096 bytes at offset 4295249920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295254016 ++wrote 4096/4096 bytes at offset 4295254016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295258112 ++wrote 4096/4096 bytes at offset 4295258112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295262208 ++wrote 4096/4096 bytes at offset 4295262208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295266304 ++wrote 4096/4096 bytes at offset 4295266304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295270400 ++wrote 4096/4096 bytes at offset 4295270400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295274496 ++wrote 4096/4096 bytes at offset 4295274496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295278592 ++wrote 4096/4096 bytes at offset 4295278592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295282688 ++wrote 4096/4096 bytes at offset 4295282688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295286784 ++wrote 4096/4096 bytes at offset 4295286784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295290880 ++wrote 4096/4096 bytes at offset 4295290880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295294976 ++wrote 4096/4096 bytes at offset 4295294976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295299072 ++wrote 4096/4096 bytes at offset 4295299072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295303168 ++wrote 4096/4096 bytes at offset 4295303168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295307264 ++wrote 4096/4096 bytes at offset 4295307264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295311360 ++wrote 4096/4096 bytes at offset 4295311360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295315456 ++wrote 4096/4096 bytes at offset 4295315456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295319552 ++wrote 4096/4096 bytes at offset 4295319552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295323648 ++wrote 4096/4096 bytes at offset 4295323648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295327744 ++wrote 4096/4096 bytes at offset 4295327744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295331840 ++wrote 4096/4096 bytes at offset 4295331840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295335936 ++wrote 4096/4096 bytes at offset 4295335936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295340032 ++wrote 4096/4096 bytes at offset 4295340032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295344128 ++wrote 4096/4096 bytes at offset 4295344128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295348224 ++wrote 4096/4096 bytes at offset 4295348224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295352320 ++wrote 4096/4096 bytes at offset 4295352320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295356416 ++wrote 4096/4096 bytes at offset 4295356416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295360512 ++wrote 4096/4096 bytes at offset 4295360512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295364608 ++wrote 4096/4096 bytes at offset 4295364608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295368704 ++wrote 4096/4096 bytes at offset 4295368704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295372800 ++wrote 4096/4096 bytes at offset 4295372800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295376896 ++wrote 4096/4096 bytes at offset 4295376896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295380992 ++wrote 4096/4096 bytes at offset 4295380992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295385088 ++wrote 4096/4096 bytes at offset 4295385088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295389184 ++wrote 4096/4096 bytes at offset 4295389184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295393280 ++wrote 4096/4096 bytes at offset 4295393280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295397376 ++wrote 4096/4096 bytes at offset 4295397376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295401472 ++wrote 4096/4096 bytes at offset 4295401472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295405568 ++wrote 4096/4096 bytes at offset 4295405568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295409664 ++wrote 4096/4096 bytes at offset 4295409664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295413760 ++wrote 4096/4096 bytes at offset 4295413760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295417856 ++wrote 4096/4096 bytes at offset 4295417856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295421952 ++wrote 4096/4096 bytes at offset 4295421952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295426048 ++wrote 4096/4096 bytes at offset 4295426048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295430144 ++wrote 4096/4096 bytes at offset 4295430144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295434240 ++wrote 4096/4096 bytes at offset 4295434240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295438336 ++wrote 4096/4096 bytes at offset 4295438336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295442432 ++wrote 4096/4096 bytes at offset 4295442432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295446528 ++wrote 4096/4096 bytes at offset 4295446528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295450624 ++wrote 4096/4096 bytes at offset 4295450624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295454720 ++wrote 4096/4096 bytes at offset 4295454720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295458816 ++wrote 4096/4096 bytes at offset 4295458816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295462912 ++wrote 4096/4096 bytes at offset 4295462912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295467008 ++wrote 4096/4096 bytes at offset 4295467008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295471104 ++wrote 4096/4096 bytes at offset 4295471104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295475200 ++wrote 4096/4096 bytes at offset 4295475200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295479296 ++wrote 4096/4096 bytes at offset 4295479296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295483392 ++wrote 4096/4096 bytes at offset 4295483392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295487488 ++wrote 4096/4096 bytes at offset 4295487488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295491584 ++wrote 4096/4096 bytes at offset 4295491584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295495680 ++wrote 4096/4096 bytes at offset 4295495680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295499776 ++wrote 4096/4096 bytes at offset 4295499776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295503872 ++wrote 4096/4096 bytes at offset 4295503872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295507968 ++wrote 4096/4096 bytes at offset 4295507968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295512064 ++wrote 4096/4096 bytes at offset 4295512064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295516160 ++wrote 4096/4096 bytes at offset 4295516160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295520256 ++wrote 4096/4096 bytes at offset 4295520256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295524352 ++wrote 4096/4096 bytes at offset 4295524352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295528448 ++wrote 4096/4096 bytes at offset 4295528448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295532544 ++wrote 4096/4096 bytes at offset 4295532544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295536640 ++wrote 4096/4096 bytes at offset 4295536640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295540736 ++wrote 4096/4096 bytes at offset 4295540736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295544832 ++wrote 4096/4096 bytes at offset 4295544832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295548928 ++wrote 4096/4096 bytes at offset 4295548928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295553024 ++wrote 4096/4096 bytes at offset 4295553024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295557120 ++wrote 4096/4096 bytes at offset 4295557120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295561216 ++wrote 4096/4096 bytes at offset 4295561216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295565312 ++wrote 4096/4096 bytes at offset 4295565312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295569408 ++wrote 4096/4096 bytes at offset 4295569408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295573504 ++wrote 4096/4096 bytes at offset 4295573504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295577600 ++wrote 4096/4096 bytes at offset 4295577600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295581696 ++wrote 4096/4096 bytes at offset 4295581696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295585792 ++wrote 4096/4096 bytes at offset 4295585792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295589888 ++wrote 4096/4096 bytes at offset 4295589888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295593984 ++wrote 4096/4096 bytes at offset 4295593984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295598080 ++wrote 4096/4096 bytes at offset 4295598080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295602176 ++wrote 4096/4096 bytes at offset 4295602176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295606272 ++wrote 4096/4096 bytes at offset 4295606272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295610368 ++wrote 4096/4096 bytes at offset 4295610368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295614464 ++wrote 4096/4096 bytes at offset 4295614464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295618560 ++wrote 4096/4096 bytes at offset 4295618560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295622656 ++wrote 4096/4096 bytes at offset 4295622656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295626752 ++wrote 4096/4096 bytes at offset 4295626752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295630848 ++wrote 4096/4096 bytes at offset 4295630848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295634944 ++wrote 4096/4096 bytes at offset 4295634944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295639040 ++wrote 4096/4096 bytes at offset 4295639040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295643136 ++wrote 4096/4096 bytes at offset 4295643136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295647232 ++wrote 4096/4096 bytes at offset 4295647232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295651328 ++wrote 4096/4096 bytes at offset 4295651328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295655424 ++wrote 4096/4096 bytes at offset 4295655424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295659520 ++wrote 4096/4096 bytes at offset 4295659520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295663616 ++wrote 4096/4096 bytes at offset 4295663616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295667712 ++wrote 4096/4096 bytes at offset 4295667712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295671808 ++wrote 4096/4096 bytes at offset 4295671808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295675904 ++wrote 4096/4096 bytes at offset 4295675904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295680000 ++wrote 4096/4096 bytes at offset 4295680000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295684096 ++wrote 4096/4096 bytes at offset 4295684096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295688192 ++wrote 4096/4096 bytes at offset 4295688192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295692288 ++wrote 4096/4096 bytes at offset 4295692288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295696384 ++wrote 4096/4096 bytes at offset 4295696384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295700480 ++wrote 4096/4096 bytes at offset 4295700480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295704576 ++wrote 4096/4096 bytes at offset 4295704576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295708672 ++wrote 4096/4096 bytes at offset 4295708672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295712768 ++wrote 4096/4096 bytes at offset 4295712768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295716864 ++wrote 4096/4096 bytes at offset 4295716864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295720960 ++wrote 4096/4096 bytes at offset 4295720960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295725056 ++wrote 4096/4096 bytes at offset 4295725056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295729152 ++wrote 4096/4096 bytes at offset 4295729152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295733248 ++wrote 4096/4096 bytes at offset 4295733248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295737344 ++wrote 4096/4096 bytes at offset 4295737344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295741440 ++wrote 4096/4096 bytes at offset 4295741440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295745536 ++wrote 4096/4096 bytes at offset 4295745536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295749632 ++wrote 4096/4096 bytes at offset 4295749632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295753728 ++wrote 4096/4096 bytes at offset 4295753728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295757824 ++wrote 4096/4096 bytes at offset 4295757824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295761920 ++wrote 4096/4096 bytes at offset 4295761920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295766016 ++wrote 4096/4096 bytes at offset 4295766016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295770112 ++wrote 4096/4096 bytes at offset 4295770112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295774208 ++wrote 4096/4096 bytes at offset 4295774208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295778304 ++wrote 4096/4096 bytes at offset 4295778304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295782400 ++wrote 4096/4096 bytes at offset 4295782400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295786496 ++wrote 4096/4096 bytes at offset 4295786496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295790592 ++wrote 4096/4096 bytes at offset 4295790592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295794688 ++wrote 4096/4096 bytes at offset 4295794688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295798784 ++wrote 4096/4096 bytes at offset 4295798784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295802880 ++wrote 4096/4096 bytes at offset 4295802880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295806976 ++wrote 4096/4096 bytes at offset 4295806976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295811072 ++wrote 4096/4096 bytes at offset 4295811072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295815168 ++wrote 4096/4096 bytes at offset 4295815168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295819264 ++wrote 4096/4096 bytes at offset 4295819264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295823360 ++wrote 4096/4096 bytes at offset 4295823360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295827456 ++wrote 4096/4096 bytes at offset 4295827456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295831552 ++wrote 4096/4096 bytes at offset 4295831552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295835648 ++wrote 4096/4096 bytes at offset 4295835648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295839744 ++wrote 4096/4096 bytes at offset 4295839744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295843840 ++wrote 4096/4096 bytes at offset 4295843840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295847936 ++wrote 4096/4096 bytes at offset 4295847936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295852032 ++wrote 4096/4096 bytes at offset 4295852032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295856128 ++wrote 4096/4096 bytes at offset 4295856128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295860224 ++wrote 4096/4096 bytes at offset 4295860224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295864320 ++wrote 4096/4096 bytes at offset 4295864320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295868416 ++wrote 4096/4096 bytes at offset 4295868416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295872512 ++wrote 4096/4096 bytes at offset 4295872512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295876608 ++wrote 4096/4096 bytes at offset 4295876608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295880704 ++wrote 4096/4096 bytes at offset 4295880704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295884800 ++wrote 4096/4096 bytes at offset 4295884800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295888896 ++wrote 4096/4096 bytes at offset 4295888896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295892992 ++wrote 4096/4096 bytes at offset 4295892992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295897088 ++wrote 4096/4096 bytes at offset 4295897088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295901184 ++wrote 4096/4096 bytes at offset 4295901184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295905280 ++wrote 4096/4096 bytes at offset 4295905280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295909376 ++wrote 4096/4096 bytes at offset 4295909376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295913472 ++wrote 4096/4096 bytes at offset 4295913472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295917568 ++wrote 4096/4096 bytes at offset 4295917568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295921664 ++wrote 4096/4096 bytes at offset 4295921664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295925760 ++wrote 4096/4096 bytes at offset 4295925760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295929856 ++wrote 4096/4096 bytes at offset 4295929856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295933952 ++wrote 4096/4096 bytes at offset 4295933952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295938048 ++wrote 4096/4096 bytes at offset 4295938048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295942144 ++wrote 4096/4096 bytes at offset 4295942144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295946240 ++wrote 4096/4096 bytes at offset 4295946240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295950336 ++wrote 4096/4096 bytes at offset 4295950336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295954432 ++wrote 4096/4096 bytes at offset 4295954432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295958528 ++wrote 4096/4096 bytes at offset 4295958528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295962624 ++wrote 4096/4096 bytes at offset 4295962624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295966720 ++wrote 4096/4096 bytes at offset 4295966720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295970816 ++wrote 4096/4096 bytes at offset 4295970816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295974912 ++wrote 4096/4096 bytes at offset 4295974912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295979008 ++wrote 4096/4096 bytes at offset 4295979008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295983104 ++wrote 4096/4096 bytes at offset 4295983104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295987200 ++wrote 4096/4096 bytes at offset 4295987200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295991296 ++wrote 4096/4096 bytes at offset 4295991296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295995392 ++wrote 4096/4096 bytes at offset 4295995392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295999488 ++wrote 4096/4096 bytes at offset 4295999488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296003584 ++wrote 4096/4096 bytes at offset 4296003584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296007680 ++wrote 4096/4096 bytes at offset 4296007680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296011776 ++wrote 4096/4096 bytes at offset 4296011776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 4 +-qemu-io> wrote 2048/2048 bytes at offset 4296017920 ++=== IO: pattern 4 ++wrote 2048/2048 bytes at offset 4296017920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296022016 ++wrote 2048/2048 bytes at offset 4296022016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296026112 ++wrote 2048/2048 bytes at offset 4296026112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296030208 ++wrote 2048/2048 bytes at offset 4296030208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296034304 ++wrote 2048/2048 bytes at offset 4296034304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296038400 ++wrote 2048/2048 bytes at offset 4296038400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296042496 ++wrote 2048/2048 bytes at offset 4296042496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296046592 ++wrote 2048/2048 bytes at offset 4296046592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296050688 ++wrote 2048/2048 bytes at offset 4296050688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296054784 ++wrote 2048/2048 bytes at offset 4296054784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296058880 ++wrote 2048/2048 bytes at offset 4296058880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296062976 ++wrote 2048/2048 bytes at offset 4296062976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296067072 ++wrote 2048/2048 bytes at offset 4296067072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296071168 ++wrote 2048/2048 bytes at offset 4296071168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296075264 ++wrote 2048/2048 bytes at offset 4296075264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296079360 ++wrote 2048/2048 bytes at offset 4296079360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296083456 ++wrote 2048/2048 bytes at offset 4296083456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296087552 ++wrote 2048/2048 bytes at offset 4296087552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296091648 ++wrote 2048/2048 bytes at offset 4296091648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296095744 ++wrote 2048/2048 bytes at offset 4296095744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296099840 ++wrote 2048/2048 bytes at offset 4296099840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296103936 ++wrote 2048/2048 bytes at offset 4296103936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296108032 ++wrote 2048/2048 bytes at offset 4296108032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296112128 ++wrote 2048/2048 bytes at offset 4296112128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296116224 ++wrote 2048/2048 bytes at offset 4296116224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296120320 ++wrote 2048/2048 bytes at offset 4296120320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296124416 ++wrote 2048/2048 bytes at offset 4296124416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296128512 ++wrote 2048/2048 bytes at offset 4296128512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296132608 ++wrote 2048/2048 bytes at offset 4296132608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296136704 ++wrote 2048/2048 bytes at offset 4296136704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296140800 ++wrote 2048/2048 bytes at offset 4296140800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296144896 ++wrote 2048/2048 bytes at offset 4296144896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296148992 ++wrote 2048/2048 bytes at offset 4296148992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296153088 ++wrote 2048/2048 bytes at offset 4296153088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296157184 ++wrote 2048/2048 bytes at offset 4296157184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296161280 ++wrote 2048/2048 bytes at offset 4296161280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296165376 ++wrote 2048/2048 bytes at offset 4296165376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296169472 ++wrote 2048/2048 bytes at offset 4296169472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296173568 ++wrote 2048/2048 bytes at offset 4296173568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296177664 ++wrote 2048/2048 bytes at offset 4296177664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296181760 ++wrote 2048/2048 bytes at offset 4296181760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296185856 ++wrote 2048/2048 bytes at offset 4296185856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296189952 ++wrote 2048/2048 bytes at offset 4296189952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296194048 ++wrote 2048/2048 bytes at offset 4296194048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296198144 ++wrote 2048/2048 bytes at offset 4296198144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296202240 ++wrote 2048/2048 bytes at offset 4296202240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296206336 ++wrote 2048/2048 bytes at offset 4296206336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296210432 ++wrote 2048/2048 bytes at offset 4296210432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296214528 ++wrote 2048/2048 bytes at offset 4296214528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296218624 ++wrote 2048/2048 bytes at offset 4296218624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296222720 ++wrote 2048/2048 bytes at offset 4296222720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296226816 ++wrote 2048/2048 bytes at offset 4296226816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296230912 ++wrote 2048/2048 bytes at offset 4296230912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296235008 ++wrote 2048/2048 bytes at offset 4296235008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296239104 ++wrote 2048/2048 bytes at offset 4296239104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296243200 ++wrote 2048/2048 bytes at offset 4296243200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296247296 ++wrote 2048/2048 bytes at offset 4296247296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296251392 ++wrote 2048/2048 bytes at offset 4296251392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296255488 ++wrote 2048/2048 bytes at offset 4296255488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296259584 ++wrote 2048/2048 bytes at offset 4296259584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296263680 ++wrote 2048/2048 bytes at offset 4296263680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296267776 ++wrote 2048/2048 bytes at offset 4296267776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296271872 ++wrote 2048/2048 bytes at offset 4296271872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296275968 ++wrote 2048/2048 bytes at offset 4296275968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296280064 ++wrote 2048/2048 bytes at offset 4296280064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296284160 ++wrote 2048/2048 bytes at offset 4296284160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296288256 ++wrote 2048/2048 bytes at offset 4296288256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296292352 ++wrote 2048/2048 bytes at offset 4296292352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296296448 ++wrote 2048/2048 bytes at offset 4296296448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296300544 ++wrote 2048/2048 bytes at offset 4296300544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296304640 ++wrote 2048/2048 bytes at offset 4296304640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296308736 ++wrote 2048/2048 bytes at offset 4296308736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296312832 ++wrote 2048/2048 bytes at offset 4296312832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296316928 ++wrote 2048/2048 bytes at offset 4296316928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296321024 ++wrote 2048/2048 bytes at offset 4296321024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296325120 ++wrote 2048/2048 bytes at offset 4296325120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296329216 ++wrote 2048/2048 bytes at offset 4296329216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296333312 ++wrote 2048/2048 bytes at offset 4296333312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296337408 ++wrote 2048/2048 bytes at offset 4296337408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296341504 ++wrote 2048/2048 bytes at offset 4296341504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296345600 ++wrote 2048/2048 bytes at offset 4296345600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296349696 ++wrote 2048/2048 bytes at offset 4296349696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296353792 ++wrote 2048/2048 bytes at offset 4296353792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296357888 ++wrote 2048/2048 bytes at offset 4296357888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296361984 ++wrote 2048/2048 bytes at offset 4296361984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296366080 ++wrote 2048/2048 bytes at offset 4296366080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296370176 ++wrote 2048/2048 bytes at offset 4296370176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296374272 ++wrote 2048/2048 bytes at offset 4296374272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296378368 ++wrote 2048/2048 bytes at offset 4296378368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296382464 ++wrote 2048/2048 bytes at offset 4296382464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296386560 ++wrote 2048/2048 bytes at offset 4296386560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296390656 ++wrote 2048/2048 bytes at offset 4296390656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296394752 ++wrote 2048/2048 bytes at offset 4296394752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296398848 ++wrote 2048/2048 bytes at offset 4296398848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296402944 ++wrote 2048/2048 bytes at offset 4296402944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296407040 ++wrote 2048/2048 bytes at offset 4296407040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296411136 ++wrote 2048/2048 bytes at offset 4296411136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296415232 ++wrote 2048/2048 bytes at offset 4296415232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296419328 ++wrote 2048/2048 bytes at offset 4296419328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296423424 ++wrote 2048/2048 bytes at offset 4296423424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296427520 ++wrote 2048/2048 bytes at offset 4296427520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296431616 ++wrote 2048/2048 bytes at offset 4296431616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296435712 ++wrote 2048/2048 bytes at offset 4296435712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296439808 ++wrote 2048/2048 bytes at offset 4296439808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296443904 ++wrote 2048/2048 bytes at offset 4296443904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296448000 ++wrote 2048/2048 bytes at offset 4296448000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296452096 ++wrote 2048/2048 bytes at offset 4296452096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296456192 ++wrote 2048/2048 bytes at offset 4296456192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296460288 ++wrote 2048/2048 bytes at offset 4296460288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296464384 ++wrote 2048/2048 bytes at offset 4296464384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296468480 ++wrote 2048/2048 bytes at offset 4296468480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296472576 ++wrote 2048/2048 bytes at offset 4296472576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296476672 ++wrote 2048/2048 bytes at offset 4296476672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296480768 ++wrote 2048/2048 bytes at offset 4296480768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296484864 ++wrote 2048/2048 bytes at offset 4296484864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296488960 ++wrote 2048/2048 bytes at offset 4296488960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296493056 ++wrote 2048/2048 bytes at offset 4296493056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296497152 ++wrote 2048/2048 bytes at offset 4296497152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296501248 ++wrote 2048/2048 bytes at offset 4296501248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296505344 ++wrote 2048/2048 bytes at offset 4296505344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296509440 ++wrote 2048/2048 bytes at offset 4296509440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296513536 ++wrote 2048/2048 bytes at offset 4296513536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296517632 ++wrote 2048/2048 bytes at offset 4296517632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296521728 ++wrote 2048/2048 bytes at offset 4296521728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296525824 ++wrote 2048/2048 bytes at offset 4296525824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296529920 ++wrote 2048/2048 bytes at offset 4296529920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296534016 ++wrote 2048/2048 bytes at offset 4296534016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296538112 ++wrote 2048/2048 bytes at offset 4296538112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296542208 ++wrote 2048/2048 bytes at offset 4296542208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296546304 ++wrote 2048/2048 bytes at offset 4296546304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296550400 ++wrote 2048/2048 bytes at offset 4296550400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296554496 ++wrote 2048/2048 bytes at offset 4296554496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296558592 ++wrote 2048/2048 bytes at offset 4296558592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296562688 ++wrote 2048/2048 bytes at offset 4296562688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296566784 ++wrote 2048/2048 bytes at offset 4296566784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296570880 ++wrote 2048/2048 bytes at offset 4296570880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296574976 ++wrote 2048/2048 bytes at offset 4296574976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296579072 ++wrote 2048/2048 bytes at offset 4296579072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296583168 ++wrote 2048/2048 bytes at offset 4296583168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296587264 ++wrote 2048/2048 bytes at offset 4296587264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296591360 ++wrote 2048/2048 bytes at offset 4296591360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296595456 ++wrote 2048/2048 bytes at offset 4296595456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296599552 ++wrote 2048/2048 bytes at offset 4296599552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296603648 ++wrote 2048/2048 bytes at offset 4296603648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296607744 ++wrote 2048/2048 bytes at offset 4296607744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296611840 ++wrote 2048/2048 bytes at offset 4296611840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296615936 ++wrote 2048/2048 bytes at offset 4296615936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296620032 ++wrote 2048/2048 bytes at offset 4296620032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296624128 ++wrote 2048/2048 bytes at offset 4296624128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296628224 ++wrote 2048/2048 bytes at offset 4296628224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296632320 ++wrote 2048/2048 bytes at offset 4296632320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296636416 ++wrote 2048/2048 bytes at offset 4296636416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296640512 ++wrote 2048/2048 bytes at offset 4296640512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296644608 ++wrote 2048/2048 bytes at offset 4296644608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296648704 ++wrote 2048/2048 bytes at offset 4296648704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296652800 ++wrote 2048/2048 bytes at offset 4296652800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296656896 ++wrote 2048/2048 bytes at offset 4296656896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296660992 ++wrote 2048/2048 bytes at offset 4296660992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296665088 ++wrote 2048/2048 bytes at offset 4296665088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296669184 ++wrote 2048/2048 bytes at offset 4296669184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296673280 ++wrote 2048/2048 bytes at offset 4296673280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296677376 ++wrote 2048/2048 bytes at offset 4296677376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296681472 ++wrote 2048/2048 bytes at offset 4296681472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296685568 ++wrote 2048/2048 bytes at offset 4296685568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296689664 ++wrote 2048/2048 bytes at offset 4296689664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296693760 ++wrote 2048/2048 bytes at offset 4296693760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296697856 ++wrote 2048/2048 bytes at offset 4296697856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296701952 ++wrote 2048/2048 bytes at offset 4296701952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296706048 ++wrote 2048/2048 bytes at offset 4296706048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296710144 ++wrote 2048/2048 bytes at offset 4296710144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296714240 ++wrote 2048/2048 bytes at offset 4296714240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296718336 ++wrote 2048/2048 bytes at offset 4296718336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296722432 ++wrote 2048/2048 bytes at offset 4296722432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296726528 ++wrote 2048/2048 bytes at offset 4296726528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296730624 ++wrote 2048/2048 bytes at offset 4296730624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296734720 ++wrote 2048/2048 bytes at offset 4296734720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296738816 ++wrote 2048/2048 bytes at offset 4296738816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296742912 ++wrote 2048/2048 bytes at offset 4296742912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296747008 ++wrote 2048/2048 bytes at offset 4296747008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296751104 ++wrote 2048/2048 bytes at offset 4296751104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296755200 ++wrote 2048/2048 bytes at offset 4296755200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296759296 ++wrote 2048/2048 bytes at offset 4296759296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296763392 ++wrote 2048/2048 bytes at offset 4296763392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296767488 ++wrote 2048/2048 bytes at offset 4296767488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296771584 ++wrote 2048/2048 bytes at offset 4296771584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296775680 ++wrote 2048/2048 bytes at offset 4296775680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296779776 ++wrote 2048/2048 bytes at offset 4296779776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296783872 ++wrote 2048/2048 bytes at offset 4296783872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296787968 ++wrote 2048/2048 bytes at offset 4296787968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296792064 ++wrote 2048/2048 bytes at offset 4296792064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296796160 ++wrote 2048/2048 bytes at offset 4296796160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296800256 ++wrote 2048/2048 bytes at offset 4296800256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296804352 ++wrote 2048/2048 bytes at offset 4296804352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296808448 ++wrote 2048/2048 bytes at offset 4296808448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296812544 ++wrote 2048/2048 bytes at offset 4296812544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296816640 ++wrote 2048/2048 bytes at offset 4296816640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296820736 ++wrote 2048/2048 bytes at offset 4296820736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296824832 ++wrote 2048/2048 bytes at offset 4296824832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296828928 ++wrote 2048/2048 bytes at offset 4296828928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296833024 ++wrote 2048/2048 bytes at offset 4296833024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296837120 ++wrote 2048/2048 bytes at offset 4296837120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296841216 ++wrote 2048/2048 bytes at offset 4296841216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296845312 ++wrote 2048/2048 bytes at offset 4296845312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296849408 ++wrote 2048/2048 bytes at offset 4296849408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296853504 ++wrote 2048/2048 bytes at offset 4296853504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296857600 ++wrote 2048/2048 bytes at offset 4296857600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296861696 ++wrote 2048/2048 bytes at offset 4296861696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296865792 ++wrote 2048/2048 bytes at offset 4296865792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296869888 ++wrote 2048/2048 bytes at offset 4296869888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296873984 ++wrote 2048/2048 bytes at offset 4296873984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296878080 ++wrote 2048/2048 bytes at offset 4296878080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296882176 ++wrote 2048/2048 bytes at offset 4296882176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296886272 ++wrote 2048/2048 bytes at offset 4296886272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296890368 ++wrote 2048/2048 bytes at offset 4296890368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296894464 ++wrote 2048/2048 bytes at offset 4296894464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296898560 ++wrote 2048/2048 bytes at offset 4296898560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296902656 ++wrote 2048/2048 bytes at offset 4296902656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296906752 ++wrote 2048/2048 bytes at offset 4296906752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296910848 ++wrote 2048/2048 bytes at offset 4296910848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296914944 ++wrote 2048/2048 bytes at offset 4296914944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296919040 ++wrote 2048/2048 bytes at offset 4296919040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296923136 ++wrote 2048/2048 bytes at offset 4296923136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296927232 ++wrote 2048/2048 bytes at offset 4296927232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296931328 ++wrote 2048/2048 bytes at offset 4296931328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296935424 ++wrote 2048/2048 bytes at offset 4296935424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296939520 ++wrote 2048/2048 bytes at offset 4296939520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296943616 ++wrote 2048/2048 bytes at offset 4296943616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296947712 ++wrote 2048/2048 bytes at offset 4296947712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296951808 ++wrote 2048/2048 bytes at offset 4296951808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296955904 ++wrote 2048/2048 bytes at offset 4296955904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296960000 ++wrote 2048/2048 bytes at offset 4296960000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296964096 ++wrote 2048/2048 bytes at offset 4296964096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296968192 ++wrote 2048/2048 bytes at offset 4296968192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296972288 ++wrote 2048/2048 bytes at offset 4296972288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296976384 ++wrote 2048/2048 bytes at offset 4296976384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296980480 ++wrote 2048/2048 bytes at offset 4296980480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296984576 ++wrote 2048/2048 bytes at offset 4296984576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296988672 ++wrote 2048/2048 bytes at offset 4296988672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296992768 ++wrote 2048/2048 bytes at offset 4296992768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296996864 ++wrote 2048/2048 bytes at offset 4296996864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297000960 ++wrote 2048/2048 bytes at offset 4297000960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297005056 ++wrote 2048/2048 bytes at offset 4297005056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297009152 ++wrote 2048/2048 bytes at offset 4297009152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297013248 ++wrote 2048/2048 bytes at offset 4297013248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297017344 ++wrote 2048/2048 bytes at offset 4297017344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297021440 ++wrote 2048/2048 bytes at offset 4297021440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297025536 ++wrote 2048/2048 bytes at offset 4297025536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297029632 ++wrote 2048/2048 bytes at offset 4297029632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297033728 ++wrote 2048/2048 bytes at offset 4297033728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297037824 ++wrote 2048/2048 bytes at offset 4297037824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297041920 ++wrote 2048/2048 bytes at offset 4297041920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297046016 ++wrote 2048/2048 bytes at offset 4297046016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297050112 ++wrote 2048/2048 bytes at offset 4297050112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297054208 ++wrote 2048/2048 bytes at offset 4297054208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297058304 ++wrote 2048/2048 bytes at offset 4297058304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297062400 ++wrote 2048/2048 bytes at offset 4297062400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> wrote 2048/2048 bytes at offset 4297064448 ++=== IO: pattern 0 ++wrote 2048/2048 bytes at offset 4297064448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297068544 ++wrote 2048/2048 bytes at offset 4297068544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297072640 ++wrote 2048/2048 bytes at offset 4297072640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297076736 ++wrote 2048/2048 bytes at offset 4297076736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297080832 ++wrote 2048/2048 bytes at offset 4297080832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297084928 ++wrote 2048/2048 bytes at offset 4297084928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297089024 ++wrote 2048/2048 bytes at offset 4297089024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297093120 ++wrote 2048/2048 bytes at offset 4297093120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297097216 ++wrote 2048/2048 bytes at offset 4297097216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297101312 ++wrote 2048/2048 bytes at offset 4297101312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297105408 ++wrote 2048/2048 bytes at offset 4297105408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297109504 ++wrote 2048/2048 bytes at offset 4297109504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297113600 ++wrote 2048/2048 bytes at offset 4297113600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297117696 ++wrote 2048/2048 bytes at offset 4297117696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297121792 ++wrote 2048/2048 bytes at offset 4297121792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297125888 ++wrote 2048/2048 bytes at offset 4297125888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297129984 ++wrote 2048/2048 bytes at offset 4297129984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297134080 ++wrote 2048/2048 bytes at offset 4297134080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297138176 ++wrote 2048/2048 bytes at offset 4297138176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297142272 ++wrote 2048/2048 bytes at offset 4297142272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297146368 ++wrote 2048/2048 bytes at offset 4297146368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297150464 ++wrote 2048/2048 bytes at offset 4297150464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297154560 ++wrote 2048/2048 bytes at offset 4297154560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297158656 ++wrote 2048/2048 bytes at offset 4297158656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297162752 ++wrote 2048/2048 bytes at offset 4297162752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297166848 ++wrote 2048/2048 bytes at offset 4297166848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297170944 ++wrote 2048/2048 bytes at offset 4297170944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297175040 ++wrote 2048/2048 bytes at offset 4297175040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297179136 ++wrote 2048/2048 bytes at offset 4297179136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297183232 ++wrote 2048/2048 bytes at offset 4297183232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297187328 ++wrote 2048/2048 bytes at offset 4297187328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297191424 ++wrote 2048/2048 bytes at offset 4297191424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297195520 ++wrote 2048/2048 bytes at offset 4297195520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297199616 ++wrote 2048/2048 bytes at offset 4297199616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297203712 ++wrote 2048/2048 bytes at offset 4297203712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297207808 ++wrote 2048/2048 bytes at offset 4297207808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297211904 ++wrote 2048/2048 bytes at offset 4297211904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297216000 ++wrote 2048/2048 bytes at offset 4297216000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297220096 ++wrote 2048/2048 bytes at offset 4297220096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297224192 ++wrote 2048/2048 bytes at offset 4297224192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297228288 ++wrote 2048/2048 bytes at offset 4297228288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297232384 ++wrote 2048/2048 bytes at offset 4297232384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297236480 ++wrote 2048/2048 bytes at offset 4297236480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297240576 ++wrote 2048/2048 bytes at offset 4297240576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297244672 ++wrote 2048/2048 bytes at offset 4297244672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297248768 ++wrote 2048/2048 bytes at offset 4297248768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297252864 ++wrote 2048/2048 bytes at offset 4297252864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297256960 ++wrote 2048/2048 bytes at offset 4297256960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297261056 ++wrote 2048/2048 bytes at offset 4297261056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297265152 ++wrote 2048/2048 bytes at offset 4297265152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297269248 ++wrote 2048/2048 bytes at offset 4297269248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297273344 ++wrote 2048/2048 bytes at offset 4297273344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297277440 ++wrote 2048/2048 bytes at offset 4297277440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297281536 ++wrote 2048/2048 bytes at offset 4297281536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297285632 ++wrote 2048/2048 bytes at offset 4297285632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297289728 ++wrote 2048/2048 bytes at offset 4297289728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297293824 ++wrote 2048/2048 bytes at offset 4297293824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297297920 ++wrote 2048/2048 bytes at offset 4297297920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297302016 ++wrote 2048/2048 bytes at offset 4297302016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297306112 ++wrote 2048/2048 bytes at offset 4297306112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297310208 ++wrote 2048/2048 bytes at offset 4297310208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297314304 ++wrote 2048/2048 bytes at offset 4297314304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297318400 ++wrote 2048/2048 bytes at offset 4297318400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297322496 ++wrote 2048/2048 bytes at offset 4297322496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297326592 ++wrote 2048/2048 bytes at offset 4297326592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297330688 ++wrote 2048/2048 bytes at offset 4297330688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297334784 ++wrote 2048/2048 bytes at offset 4297334784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297338880 ++wrote 2048/2048 bytes at offset 4297338880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297342976 ++wrote 2048/2048 bytes at offset 4297342976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297347072 ++wrote 2048/2048 bytes at offset 4297347072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297351168 ++wrote 2048/2048 bytes at offset 4297351168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297355264 ++wrote 2048/2048 bytes at offset 4297355264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297359360 ++wrote 2048/2048 bytes at offset 4297359360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297363456 ++wrote 2048/2048 bytes at offset 4297363456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297367552 ++wrote 2048/2048 bytes at offset 4297367552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297371648 ++wrote 2048/2048 bytes at offset 4297371648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297375744 ++wrote 2048/2048 bytes at offset 4297375744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297379840 ++wrote 2048/2048 bytes at offset 4297379840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297383936 ++wrote 2048/2048 bytes at offset 4297383936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297388032 ++wrote 2048/2048 bytes at offset 4297388032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297392128 ++wrote 2048/2048 bytes at offset 4297392128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297396224 ++wrote 2048/2048 bytes at offset 4297396224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297400320 ++wrote 2048/2048 bytes at offset 4297400320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297404416 ++wrote 2048/2048 bytes at offset 4297404416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297408512 ++wrote 2048/2048 bytes at offset 4297408512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297412608 ++wrote 2048/2048 bytes at offset 4297412608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297416704 ++wrote 2048/2048 bytes at offset 4297416704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297420800 ++wrote 2048/2048 bytes at offset 4297420800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297424896 ++wrote 2048/2048 bytes at offset 4297424896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297428992 ++wrote 2048/2048 bytes at offset 4297428992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297433088 ++wrote 2048/2048 bytes at offset 4297433088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297437184 ++wrote 2048/2048 bytes at offset 4297437184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297441280 ++wrote 2048/2048 bytes at offset 4297441280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297445376 ++wrote 2048/2048 bytes at offset 4297445376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297449472 ++wrote 2048/2048 bytes at offset 4297449472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297453568 ++wrote 2048/2048 bytes at offset 4297453568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297457664 ++wrote 2048/2048 bytes at offset 4297457664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297461760 ++wrote 2048/2048 bytes at offset 4297461760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297465856 ++wrote 2048/2048 bytes at offset 4297465856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297469952 ++wrote 2048/2048 bytes at offset 4297469952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297474048 ++wrote 2048/2048 bytes at offset 4297474048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297478144 ++wrote 2048/2048 bytes at offset 4297478144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297482240 ++wrote 2048/2048 bytes at offset 4297482240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297486336 ++wrote 2048/2048 bytes at offset 4297486336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297490432 ++wrote 2048/2048 bytes at offset 4297490432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297494528 ++wrote 2048/2048 bytes at offset 4297494528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297498624 ++wrote 2048/2048 bytes at offset 4297498624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297502720 ++wrote 2048/2048 bytes at offset 4297502720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297506816 ++wrote 2048/2048 bytes at offset 4297506816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297510912 ++wrote 2048/2048 bytes at offset 4297510912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297515008 ++wrote 2048/2048 bytes at offset 4297515008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297519104 ++wrote 2048/2048 bytes at offset 4297519104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297523200 ++wrote 2048/2048 bytes at offset 4297523200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297527296 ++wrote 2048/2048 bytes at offset 4297527296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297531392 ++wrote 2048/2048 bytes at offset 4297531392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297535488 ++wrote 2048/2048 bytes at offset 4297535488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297539584 ++wrote 2048/2048 bytes at offset 4297539584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297543680 ++wrote 2048/2048 bytes at offset 4297543680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297547776 ++wrote 2048/2048 bytes at offset 4297547776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297551872 ++wrote 2048/2048 bytes at offset 4297551872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297555968 ++wrote 2048/2048 bytes at offset 4297555968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297560064 ++wrote 2048/2048 bytes at offset 4297560064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297564160 ++wrote 2048/2048 bytes at offset 4297564160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297568256 ++wrote 2048/2048 bytes at offset 4297568256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297572352 ++wrote 2048/2048 bytes at offset 4297572352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297576448 ++wrote 2048/2048 bytes at offset 4297576448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297580544 ++wrote 2048/2048 bytes at offset 4297580544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297584640 ++wrote 2048/2048 bytes at offset 4297584640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297588736 ++wrote 2048/2048 bytes at offset 4297588736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297592832 ++wrote 2048/2048 bytes at offset 4297592832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297596928 ++wrote 2048/2048 bytes at offset 4297596928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297601024 ++wrote 2048/2048 bytes at offset 4297601024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297605120 ++wrote 2048/2048 bytes at offset 4297605120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297609216 ++wrote 2048/2048 bytes at offset 4297609216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297613312 ++wrote 2048/2048 bytes at offset 4297613312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297617408 ++wrote 2048/2048 bytes at offset 4297617408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297621504 ++wrote 2048/2048 bytes at offset 4297621504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297625600 ++wrote 2048/2048 bytes at offset 4297625600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297629696 ++wrote 2048/2048 bytes at offset 4297629696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297633792 ++wrote 2048/2048 bytes at offset 4297633792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297637888 ++wrote 2048/2048 bytes at offset 4297637888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297641984 ++wrote 2048/2048 bytes at offset 4297641984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297646080 ++wrote 2048/2048 bytes at offset 4297646080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297650176 ++wrote 2048/2048 bytes at offset 4297650176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297654272 ++wrote 2048/2048 bytes at offset 4297654272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297658368 ++wrote 2048/2048 bytes at offset 4297658368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297662464 ++wrote 2048/2048 bytes at offset 4297662464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297666560 ++wrote 2048/2048 bytes at offset 4297666560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297670656 ++wrote 2048/2048 bytes at offset 4297670656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297674752 ++wrote 2048/2048 bytes at offset 4297674752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297678848 ++wrote 2048/2048 bytes at offset 4297678848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297682944 ++wrote 2048/2048 bytes at offset 4297682944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297687040 ++wrote 2048/2048 bytes at offset 4297687040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297691136 ++wrote 2048/2048 bytes at offset 4297691136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297695232 ++wrote 2048/2048 bytes at offset 4297695232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297699328 ++wrote 2048/2048 bytes at offset 4297699328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297703424 ++wrote 2048/2048 bytes at offset 4297703424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297707520 ++wrote 2048/2048 bytes at offset 4297707520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297711616 ++wrote 2048/2048 bytes at offset 4297711616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297715712 ++wrote 2048/2048 bytes at offset 4297715712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297719808 ++wrote 2048/2048 bytes at offset 4297719808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297723904 ++wrote 2048/2048 bytes at offset 4297723904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297728000 ++wrote 2048/2048 bytes at offset 4297728000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297732096 ++wrote 2048/2048 bytes at offset 4297732096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297736192 ++wrote 2048/2048 bytes at offset 4297736192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297740288 ++wrote 2048/2048 bytes at offset 4297740288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297744384 ++wrote 2048/2048 bytes at offset 4297744384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297748480 ++wrote 2048/2048 bytes at offset 4297748480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297752576 ++wrote 2048/2048 bytes at offset 4297752576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297756672 ++wrote 2048/2048 bytes at offset 4297756672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297760768 ++wrote 2048/2048 bytes at offset 4297760768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297764864 ++wrote 2048/2048 bytes at offset 4297764864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297768960 ++wrote 2048/2048 bytes at offset 4297768960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297773056 ++wrote 2048/2048 bytes at offset 4297773056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297777152 ++wrote 2048/2048 bytes at offset 4297777152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297781248 ++wrote 2048/2048 bytes at offset 4297781248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297785344 ++wrote 2048/2048 bytes at offset 4297785344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297789440 ++wrote 2048/2048 bytes at offset 4297789440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297793536 ++wrote 2048/2048 bytes at offset 4297793536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297797632 ++wrote 2048/2048 bytes at offset 4297797632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297801728 ++wrote 2048/2048 bytes at offset 4297801728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297805824 ++wrote 2048/2048 bytes at offset 4297805824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297809920 ++wrote 2048/2048 bytes at offset 4297809920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297814016 ++wrote 2048/2048 bytes at offset 4297814016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297818112 ++wrote 2048/2048 bytes at offset 4297818112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297822208 ++wrote 2048/2048 bytes at offset 4297822208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297826304 ++wrote 2048/2048 bytes at offset 4297826304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297830400 ++wrote 2048/2048 bytes at offset 4297830400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297834496 ++wrote 2048/2048 bytes at offset 4297834496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297838592 ++wrote 2048/2048 bytes at offset 4297838592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297842688 ++wrote 2048/2048 bytes at offset 4297842688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297846784 ++wrote 2048/2048 bytes at offset 4297846784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297850880 ++wrote 2048/2048 bytes at offset 4297850880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297854976 ++wrote 2048/2048 bytes at offset 4297854976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297859072 ++wrote 2048/2048 bytes at offset 4297859072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297863168 ++wrote 2048/2048 bytes at offset 4297863168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297867264 ++wrote 2048/2048 bytes at offset 4297867264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297871360 ++wrote 2048/2048 bytes at offset 4297871360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297875456 ++wrote 2048/2048 bytes at offset 4297875456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297879552 ++wrote 2048/2048 bytes at offset 4297879552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297883648 ++wrote 2048/2048 bytes at offset 4297883648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297887744 ++wrote 2048/2048 bytes at offset 4297887744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297891840 ++wrote 2048/2048 bytes at offset 4297891840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297895936 ++wrote 2048/2048 bytes at offset 4297895936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297900032 ++wrote 2048/2048 bytes at offset 4297900032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297904128 ++wrote 2048/2048 bytes at offset 4297904128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297908224 ++wrote 2048/2048 bytes at offset 4297908224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297912320 ++wrote 2048/2048 bytes at offset 4297912320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297916416 ++wrote 2048/2048 bytes at offset 4297916416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297920512 ++wrote 2048/2048 bytes at offset 4297920512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297924608 ++wrote 2048/2048 bytes at offset 4297924608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297928704 ++wrote 2048/2048 bytes at offset 4297928704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297932800 ++wrote 2048/2048 bytes at offset 4297932800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297936896 ++wrote 2048/2048 bytes at offset 4297936896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297940992 ++wrote 2048/2048 bytes at offset 4297940992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297945088 ++wrote 2048/2048 bytes at offset 4297945088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297949184 ++wrote 2048/2048 bytes at offset 4297949184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297953280 ++wrote 2048/2048 bytes at offset 4297953280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297957376 ++wrote 2048/2048 bytes at offset 4297957376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297961472 ++wrote 2048/2048 bytes at offset 4297961472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297965568 ++wrote 2048/2048 bytes at offset 4297965568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297969664 ++wrote 2048/2048 bytes at offset 4297969664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297973760 ++wrote 2048/2048 bytes at offset 4297973760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297977856 ++wrote 2048/2048 bytes at offset 4297977856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297981952 ++wrote 2048/2048 bytes at offset 4297981952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297986048 ++wrote 2048/2048 bytes at offset 4297986048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297990144 ++wrote 2048/2048 bytes at offset 4297990144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297994240 ++wrote 2048/2048 bytes at offset 4297994240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297998336 ++wrote 2048/2048 bytes at offset 4297998336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298002432 ++wrote 2048/2048 bytes at offset 4298002432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298006528 ++wrote 2048/2048 bytes at offset 4298006528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298010624 ++wrote 2048/2048 bytes at offset 4298010624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298014720 ++wrote 2048/2048 bytes at offset 4298014720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298018816 ++wrote 2048/2048 bytes at offset 4298018816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298022912 ++wrote 2048/2048 bytes at offset 4298022912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298027008 ++wrote 2048/2048 bytes at offset 4298027008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298031104 ++wrote 2048/2048 bytes at offset 4298031104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298035200 ++wrote 2048/2048 bytes at offset 4298035200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298039296 ++wrote 2048/2048 bytes at offset 4298039296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298043392 ++wrote 2048/2048 bytes at offset 4298043392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298047488 ++wrote 2048/2048 bytes at offset 4298047488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298051584 ++wrote 2048/2048 bytes at offset 4298051584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298055680 ++wrote 2048/2048 bytes at offset 4298055680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298059776 ++wrote 2048/2048 bytes at offset 4298059776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298063872 ++wrote 2048/2048 bytes at offset 4298063872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298067968 ++wrote 2048/2048 bytes at offset 4298067968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298072064 ++wrote 2048/2048 bytes at offset 4298072064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298076160 ++wrote 2048/2048 bytes at offset 4298076160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298080256 ++wrote 2048/2048 bytes at offset 4298080256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298084352 ++wrote 2048/2048 bytes at offset 4298084352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298088448 ++wrote 2048/2048 bytes at offset 4298088448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298092544 ++wrote 2048/2048 bytes at offset 4298092544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298096640 ++wrote 2048/2048 bytes at offset 4298096640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298100736 ++wrote 2048/2048 bytes at offset 4298100736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298104832 ++wrote 2048/2048 bytes at offset 4298104832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298108928 ++wrote 2048/2048 bytes at offset 4298108928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 2 +-qemu-io> wrote 2048/2048 bytes at offset 4298114048 ++=== IO: pattern 2 ++wrote 2048/2048 bytes at offset 4298114048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298118144 ++wrote 2048/2048 bytes at offset 4298118144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298122240 ++wrote 2048/2048 bytes at offset 4298122240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298126336 ++wrote 2048/2048 bytes at offset 4298126336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298130432 ++wrote 2048/2048 bytes at offset 4298130432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298134528 ++wrote 2048/2048 bytes at offset 4298134528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298138624 ++wrote 2048/2048 bytes at offset 4298138624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298142720 ++wrote 2048/2048 bytes at offset 4298142720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298146816 ++wrote 2048/2048 bytes at offset 4298146816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298150912 ++wrote 2048/2048 bytes at offset 4298150912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298155008 ++wrote 2048/2048 bytes at offset 4298155008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298159104 ++wrote 2048/2048 bytes at offset 4298159104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298163200 ++wrote 2048/2048 bytes at offset 4298163200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298167296 ++wrote 2048/2048 bytes at offset 4298167296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298171392 ++wrote 2048/2048 bytes at offset 4298171392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298175488 ++wrote 2048/2048 bytes at offset 4298175488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298179584 ++wrote 2048/2048 bytes at offset 4298179584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298183680 ++wrote 2048/2048 bytes at offset 4298183680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298187776 ++wrote 2048/2048 bytes at offset 4298187776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298191872 ++wrote 2048/2048 bytes at offset 4298191872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298195968 ++wrote 2048/2048 bytes at offset 4298195968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298200064 ++wrote 2048/2048 bytes at offset 4298200064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298204160 ++wrote 2048/2048 bytes at offset 4298204160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298208256 ++wrote 2048/2048 bytes at offset 4298208256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298212352 ++wrote 2048/2048 bytes at offset 4298212352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298216448 ++wrote 2048/2048 bytes at offset 4298216448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298220544 ++wrote 2048/2048 bytes at offset 4298220544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298224640 ++wrote 2048/2048 bytes at offset 4298224640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298228736 ++wrote 2048/2048 bytes at offset 4298228736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298232832 ++wrote 2048/2048 bytes at offset 4298232832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298236928 ++wrote 2048/2048 bytes at offset 4298236928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298241024 ++wrote 2048/2048 bytes at offset 4298241024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298245120 ++wrote 2048/2048 bytes at offset 4298245120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298249216 ++wrote 2048/2048 bytes at offset 4298249216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298253312 ++wrote 2048/2048 bytes at offset 4298253312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298257408 ++wrote 2048/2048 bytes at offset 4298257408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298261504 ++wrote 2048/2048 bytes at offset 4298261504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298265600 ++wrote 2048/2048 bytes at offset 4298265600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298269696 ++wrote 2048/2048 bytes at offset 4298269696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298273792 ++wrote 2048/2048 bytes at offset 4298273792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298277888 ++wrote 2048/2048 bytes at offset 4298277888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298281984 ++wrote 2048/2048 bytes at offset 4298281984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298286080 ++wrote 2048/2048 bytes at offset 4298286080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298290176 ++wrote 2048/2048 bytes at offset 4298290176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298294272 ++wrote 2048/2048 bytes at offset 4298294272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298298368 ++wrote 2048/2048 bytes at offset 4298298368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298302464 ++wrote 2048/2048 bytes at offset 4298302464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298306560 ++wrote 2048/2048 bytes at offset 4298306560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298310656 ++wrote 2048/2048 bytes at offset 4298310656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298314752 ++wrote 2048/2048 bytes at offset 4298314752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298318848 ++wrote 2048/2048 bytes at offset 4298318848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298322944 ++wrote 2048/2048 bytes at offset 4298322944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298327040 ++wrote 2048/2048 bytes at offset 4298327040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298331136 ++wrote 2048/2048 bytes at offset 4298331136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298335232 ++wrote 2048/2048 bytes at offset 4298335232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298339328 ++wrote 2048/2048 bytes at offset 4298339328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298343424 ++wrote 2048/2048 bytes at offset 4298343424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298347520 ++wrote 2048/2048 bytes at offset 4298347520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298351616 ++wrote 2048/2048 bytes at offset 4298351616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298355712 ++wrote 2048/2048 bytes at offset 4298355712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298359808 ++wrote 2048/2048 bytes at offset 4298359808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298363904 ++wrote 2048/2048 bytes at offset 4298363904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298368000 ++wrote 2048/2048 bytes at offset 4298368000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298372096 ++wrote 2048/2048 bytes at offset 4298372096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298376192 ++wrote 2048/2048 bytes at offset 4298376192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298380288 ++wrote 2048/2048 bytes at offset 4298380288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298384384 ++wrote 2048/2048 bytes at offset 4298384384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298388480 ++wrote 2048/2048 bytes at offset 4298388480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298392576 ++wrote 2048/2048 bytes at offset 4298392576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298396672 ++wrote 2048/2048 bytes at offset 4298396672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298400768 ++wrote 2048/2048 bytes at offset 4298400768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298404864 ++wrote 2048/2048 bytes at offset 4298404864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298408960 ++wrote 2048/2048 bytes at offset 4298408960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298413056 ++wrote 2048/2048 bytes at offset 4298413056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298417152 ++wrote 2048/2048 bytes at offset 4298417152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298421248 ++wrote 2048/2048 bytes at offset 4298421248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298425344 ++wrote 2048/2048 bytes at offset 4298425344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298429440 ++wrote 2048/2048 bytes at offset 4298429440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298433536 ++wrote 2048/2048 bytes at offset 4298433536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298437632 ++wrote 2048/2048 bytes at offset 4298437632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298441728 ++wrote 2048/2048 bytes at offset 4298441728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298445824 ++wrote 2048/2048 bytes at offset 4298445824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298449920 ++wrote 2048/2048 bytes at offset 4298449920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298454016 ++wrote 2048/2048 bytes at offset 4298454016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298458112 ++wrote 2048/2048 bytes at offset 4298458112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298462208 ++wrote 2048/2048 bytes at offset 4298462208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298466304 ++wrote 2048/2048 bytes at offset 4298466304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298470400 ++wrote 2048/2048 bytes at offset 4298470400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298474496 ++wrote 2048/2048 bytes at offset 4298474496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298478592 ++wrote 2048/2048 bytes at offset 4298478592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298482688 ++wrote 2048/2048 bytes at offset 4298482688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298486784 ++wrote 2048/2048 bytes at offset 4298486784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298490880 ++wrote 2048/2048 bytes at offset 4298490880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298494976 ++wrote 2048/2048 bytes at offset 4298494976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298499072 ++wrote 2048/2048 bytes at offset 4298499072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298503168 ++wrote 2048/2048 bytes at offset 4298503168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298507264 ++wrote 2048/2048 bytes at offset 4298507264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298511360 ++wrote 2048/2048 bytes at offset 4298511360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298515456 ++wrote 2048/2048 bytes at offset 4298515456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298519552 ++wrote 2048/2048 bytes at offset 4298519552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298523648 ++wrote 2048/2048 bytes at offset 4298523648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298527744 ++wrote 2048/2048 bytes at offset 4298527744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298531840 ++wrote 2048/2048 bytes at offset 4298531840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298535936 ++wrote 2048/2048 bytes at offset 4298535936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298540032 ++wrote 2048/2048 bytes at offset 4298540032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298544128 ++wrote 2048/2048 bytes at offset 4298544128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298548224 ++wrote 2048/2048 bytes at offset 4298548224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298552320 ++wrote 2048/2048 bytes at offset 4298552320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298556416 ++wrote 2048/2048 bytes at offset 4298556416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298560512 ++wrote 2048/2048 bytes at offset 4298560512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298564608 ++wrote 2048/2048 bytes at offset 4298564608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298568704 ++wrote 2048/2048 bytes at offset 4298568704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298572800 ++wrote 2048/2048 bytes at offset 4298572800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298576896 ++wrote 2048/2048 bytes at offset 4298576896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298580992 ++wrote 2048/2048 bytes at offset 4298580992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298585088 ++wrote 2048/2048 bytes at offset 4298585088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298589184 ++wrote 2048/2048 bytes at offset 4298589184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298593280 ++wrote 2048/2048 bytes at offset 4298593280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298597376 ++wrote 2048/2048 bytes at offset 4298597376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298601472 ++wrote 2048/2048 bytes at offset 4298601472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298605568 ++wrote 2048/2048 bytes at offset 4298605568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298609664 ++wrote 2048/2048 bytes at offset 4298609664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298613760 ++wrote 2048/2048 bytes at offset 4298613760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298617856 ++wrote 2048/2048 bytes at offset 4298617856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298621952 ++wrote 2048/2048 bytes at offset 4298621952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298626048 ++wrote 2048/2048 bytes at offset 4298626048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298630144 ++wrote 2048/2048 bytes at offset 4298630144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298634240 ++wrote 2048/2048 bytes at offset 4298634240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298638336 ++wrote 2048/2048 bytes at offset 4298638336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298642432 ++wrote 2048/2048 bytes at offset 4298642432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298646528 ++wrote 2048/2048 bytes at offset 4298646528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298650624 ++wrote 2048/2048 bytes at offset 4298650624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298654720 ++wrote 2048/2048 bytes at offset 4298654720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298658816 ++wrote 2048/2048 bytes at offset 4298658816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298662912 ++wrote 2048/2048 bytes at offset 4298662912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298667008 ++wrote 2048/2048 bytes at offset 4298667008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298671104 ++wrote 2048/2048 bytes at offset 4298671104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298675200 ++wrote 2048/2048 bytes at offset 4298675200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298679296 ++wrote 2048/2048 bytes at offset 4298679296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298683392 ++wrote 2048/2048 bytes at offset 4298683392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298687488 ++wrote 2048/2048 bytes at offset 4298687488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298691584 ++wrote 2048/2048 bytes at offset 4298691584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298695680 ++wrote 2048/2048 bytes at offset 4298695680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298699776 ++wrote 2048/2048 bytes at offset 4298699776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298703872 ++wrote 2048/2048 bytes at offset 4298703872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298707968 ++wrote 2048/2048 bytes at offset 4298707968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298712064 ++wrote 2048/2048 bytes at offset 4298712064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298716160 ++wrote 2048/2048 bytes at offset 4298716160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298720256 ++wrote 2048/2048 bytes at offset 4298720256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298724352 ++wrote 2048/2048 bytes at offset 4298724352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298728448 ++wrote 2048/2048 bytes at offset 4298728448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298732544 ++wrote 2048/2048 bytes at offset 4298732544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298736640 ++wrote 2048/2048 bytes at offset 4298736640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298740736 ++wrote 2048/2048 bytes at offset 4298740736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298744832 ++wrote 2048/2048 bytes at offset 4298744832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298748928 ++wrote 2048/2048 bytes at offset 4298748928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298753024 ++wrote 2048/2048 bytes at offset 4298753024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298757120 ++wrote 2048/2048 bytes at offset 4298757120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298761216 ++wrote 2048/2048 bytes at offset 4298761216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298765312 ++wrote 2048/2048 bytes at offset 4298765312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298769408 ++wrote 2048/2048 bytes at offset 4298769408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298773504 ++wrote 2048/2048 bytes at offset 4298773504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298777600 ++wrote 2048/2048 bytes at offset 4298777600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298781696 ++wrote 2048/2048 bytes at offset 4298781696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298785792 ++wrote 2048/2048 bytes at offset 4298785792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298789888 ++wrote 2048/2048 bytes at offset 4298789888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298793984 ++wrote 2048/2048 bytes at offset 4298793984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298798080 ++wrote 2048/2048 bytes at offset 4298798080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298802176 ++wrote 2048/2048 bytes at offset 4298802176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298806272 ++wrote 2048/2048 bytes at offset 4298806272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298810368 ++wrote 2048/2048 bytes at offset 4298810368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298814464 ++wrote 2048/2048 bytes at offset 4298814464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298818560 ++wrote 2048/2048 bytes at offset 4298818560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298822656 ++wrote 2048/2048 bytes at offset 4298822656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298826752 ++wrote 2048/2048 bytes at offset 4298826752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298830848 ++wrote 2048/2048 bytes at offset 4298830848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298834944 ++wrote 2048/2048 bytes at offset 4298834944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298839040 ++wrote 2048/2048 bytes at offset 4298839040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298843136 ++wrote 2048/2048 bytes at offset 4298843136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298847232 ++wrote 2048/2048 bytes at offset 4298847232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298851328 ++wrote 2048/2048 bytes at offset 4298851328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298855424 ++wrote 2048/2048 bytes at offset 4298855424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298859520 ++wrote 2048/2048 bytes at offset 4298859520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298863616 ++wrote 2048/2048 bytes at offset 4298863616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298867712 ++wrote 2048/2048 bytes at offset 4298867712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298871808 ++wrote 2048/2048 bytes at offset 4298871808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298875904 ++wrote 2048/2048 bytes at offset 4298875904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298880000 ++wrote 2048/2048 bytes at offset 4298880000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298884096 ++wrote 2048/2048 bytes at offset 4298884096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298888192 ++wrote 2048/2048 bytes at offset 4298888192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298892288 ++wrote 2048/2048 bytes at offset 4298892288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298896384 ++wrote 2048/2048 bytes at offset 4298896384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298900480 ++wrote 2048/2048 bytes at offset 4298900480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298904576 ++wrote 2048/2048 bytes at offset 4298904576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298908672 ++wrote 2048/2048 bytes at offset 4298908672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298912768 ++wrote 2048/2048 bytes at offset 4298912768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298916864 ++wrote 2048/2048 bytes at offset 4298916864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298920960 ++wrote 2048/2048 bytes at offset 4298920960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298925056 ++wrote 2048/2048 bytes at offset 4298925056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298929152 ++wrote 2048/2048 bytes at offset 4298929152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298933248 ++wrote 2048/2048 bytes at offset 4298933248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298937344 ++wrote 2048/2048 bytes at offset 4298937344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298941440 ++wrote 2048/2048 bytes at offset 4298941440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298945536 ++wrote 2048/2048 bytes at offset 4298945536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298949632 ++wrote 2048/2048 bytes at offset 4298949632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298953728 ++wrote 2048/2048 bytes at offset 4298953728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298957824 ++wrote 2048/2048 bytes at offset 4298957824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298961920 ++wrote 2048/2048 bytes at offset 4298961920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298966016 ++wrote 2048/2048 bytes at offset 4298966016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298970112 ++wrote 2048/2048 bytes at offset 4298970112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298974208 ++wrote 2048/2048 bytes at offset 4298974208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298978304 ++wrote 2048/2048 bytes at offset 4298978304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298982400 ++wrote 2048/2048 bytes at offset 4298982400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298986496 ++wrote 2048/2048 bytes at offset 4298986496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298990592 ++wrote 2048/2048 bytes at offset 4298990592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298994688 ++wrote 2048/2048 bytes at offset 4298994688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298998784 ++wrote 2048/2048 bytes at offset 4298998784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299002880 ++wrote 2048/2048 bytes at offset 4299002880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299006976 ++wrote 2048/2048 bytes at offset 4299006976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299011072 ++wrote 2048/2048 bytes at offset 4299011072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299015168 ++wrote 2048/2048 bytes at offset 4299015168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299019264 ++wrote 2048/2048 bytes at offset 4299019264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299023360 ++wrote 2048/2048 bytes at offset 4299023360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299027456 ++wrote 2048/2048 bytes at offset 4299027456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299031552 ++wrote 2048/2048 bytes at offset 4299031552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299035648 ++wrote 2048/2048 bytes at offset 4299035648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299039744 ++wrote 2048/2048 bytes at offset 4299039744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299043840 ++wrote 2048/2048 bytes at offset 4299043840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299047936 ++wrote 2048/2048 bytes at offset 4299047936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299052032 ++wrote 2048/2048 bytes at offset 4299052032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299056128 ++wrote 2048/2048 bytes at offset 4299056128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299060224 ++wrote 2048/2048 bytes at offset 4299060224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299064320 ++wrote 2048/2048 bytes at offset 4299064320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299068416 ++wrote 2048/2048 bytes at offset 4299068416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299072512 ++wrote 2048/2048 bytes at offset 4299072512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299076608 ++wrote 2048/2048 bytes at offset 4299076608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299080704 ++wrote 2048/2048 bytes at offset 4299080704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299084800 ++wrote 2048/2048 bytes at offset 4299084800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299088896 ++wrote 2048/2048 bytes at offset 4299088896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299092992 ++wrote 2048/2048 bytes at offset 4299092992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299097088 ++wrote 2048/2048 bytes at offset 4299097088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299101184 ++wrote 2048/2048 bytes at offset 4299101184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299105280 ++wrote 2048/2048 bytes at offset 4299105280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299109376 ++wrote 2048/2048 bytes at offset 4299109376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299113472 ++wrote 2048/2048 bytes at offset 4299113472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299117568 ++wrote 2048/2048 bytes at offset 4299117568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299121664 ++wrote 2048/2048 bytes at offset 4299121664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299125760 ++wrote 2048/2048 bytes at offset 4299125760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299129856 ++wrote 2048/2048 bytes at offset 4299129856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299133952 ++wrote 2048/2048 bytes at offset 4299133952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299138048 ++wrote 2048/2048 bytes at offset 4299138048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299142144 ++wrote 2048/2048 bytes at offset 4299142144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299146240 ++wrote 2048/2048 bytes at offset 4299146240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299150336 ++wrote 2048/2048 bytes at offset 4299150336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299154432 ++wrote 2048/2048 bytes at offset 4299154432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299158528 ++wrote 2048/2048 bytes at offset 4299158528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 4 +-qemu-io> wrote 8192/8192 bytes at offset 4299163648 ++=== IO: pattern 4 ++wrote 8192/8192 bytes at offset 4299163648 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299175936 ++wrote 8192/8192 bytes at offset 4299175936 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299188224 ++wrote 8192/8192 bytes at offset 4299188224 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299200512 ++wrote 8192/8192 bytes at offset 4299200512 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299212800 ++wrote 8192/8192 bytes at offset 4299212800 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299225088 ++wrote 8192/8192 bytes at offset 4299225088 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299237376 ++wrote 8192/8192 bytes at offset 4299237376 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299249664 ++wrote 8192/8192 bytes at offset 4299249664 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299261952 ++wrote 8192/8192 bytes at offset 4299261952 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299274240 ++wrote 8192/8192 bytes at offset 4299274240 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299286528 ++wrote 8192/8192 bytes at offset 4299286528 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299298816 ++wrote 8192/8192 bytes at offset 4299298816 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299311104 ++wrote 8192/8192 bytes at offset 4299311104 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299323392 ++wrote 8192/8192 bytes at offset 4299323392 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299335680 ++wrote 8192/8192 bytes at offset 4299335680 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299347968 ++wrote 8192/8192 bytes at offset 4299347968 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299360256 ++wrote 8192/8192 bytes at offset 4299360256 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299372544 ++wrote 8192/8192 bytes at offset 4299372544 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299384832 ++wrote 8192/8192 bytes at offset 4299384832 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299397120 ++wrote 8192/8192 bytes at offset 4299397120 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299409408 ++wrote 8192/8192 bytes at offset 4299409408 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299421696 ++wrote 8192/8192 bytes at offset 4299421696 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299433984 ++wrote 8192/8192 bytes at offset 4299433984 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299446272 ++wrote 8192/8192 bytes at offset 4299446272 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299458560 ++wrote 8192/8192 bytes at offset 4299458560 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299470848 ++wrote 8192/8192 bytes at offset 4299470848 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299483136 ++wrote 8192/8192 bytes at offset 4299483136 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299495424 ++wrote 8192/8192 bytes at offset 4299495424 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299507712 ++wrote 8192/8192 bytes at offset 4299507712 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299520000 ++wrote 8192/8192 bytes at offset 4299520000 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299532288 ++wrote 8192/8192 bytes at offset 4299532288 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299544576 ++wrote 8192/8192 bytes at offset 4299544576 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299556864 ++wrote 8192/8192 bytes at offset 4299556864 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299569152 ++wrote 8192/8192 bytes at offset 4299569152 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299581440 ++wrote 8192/8192 bytes at offset 4299581440 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299593728 ++wrote 8192/8192 bytes at offset 4299593728 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299606016 ++wrote 8192/8192 bytes at offset 4299606016 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299618304 ++wrote 8192/8192 bytes at offset 4299618304 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299630592 ++wrote 8192/8192 bytes at offset 4299630592 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299642880 ++wrote 8192/8192 bytes at offset 4299642880 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299655168 ++wrote 8192/8192 bytes at offset 4299655168 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299667456 ++wrote 8192/8192 bytes at offset 4299667456 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299679744 ++wrote 8192/8192 bytes at offset 4299679744 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299692032 ++wrote 8192/8192 bytes at offset 4299692032 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299704320 ++wrote 8192/8192 bytes at offset 4299704320 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299716608 ++wrote 8192/8192 bytes at offset 4299716608 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299728896 ++wrote 8192/8192 bytes at offset 4299728896 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299741184 ++wrote 8192/8192 bytes at offset 4299741184 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299753472 ++wrote 8192/8192 bytes at offset 4299753472 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299765760 ++wrote 8192/8192 bytes at offset 4299765760 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299778048 ++wrote 8192/8192 bytes at offset 4299778048 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299790336 ++wrote 8192/8192 bytes at offset 4299790336 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299802624 ++wrote 8192/8192 bytes at offset 4299802624 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299814912 ++wrote 8192/8192 bytes at offset 4299814912 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299827200 ++wrote 8192/8192 bytes at offset 4299827200 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299839488 ++wrote 8192/8192 bytes at offset 4299839488 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299851776 ++wrote 8192/8192 bytes at offset 4299851776 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299864064 ++wrote 8192/8192 bytes at offset 4299864064 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299876352 ++wrote 8192/8192 bytes at offset 4299876352 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299888640 ++wrote 8192/8192 bytes at offset 4299888640 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299900928 ++wrote 8192/8192 bytes at offset 4299900928 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299913216 ++wrote 8192/8192 bytes at offset 4299913216 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299925504 ++wrote 8192/8192 bytes at offset 4299925504 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299937792 ++wrote 8192/8192 bytes at offset 4299937792 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 244 +-qemu-io> wrote 12288/12288 bytes at offset 4301252608 ++=== IO: pattern 244 ++wrote 12288/12288 bytes at offset 4301252608 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 4303351808 ++wrote 12288/12288 bytes at offset 4303351808 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 4305451008 ++wrote 12288/12288 bytes at offset 4305451008 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 4307550208 ++wrote 12288/12288 bytes at offset 4307550208 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 4309649408 ++wrote 12288/12288 bytes at offset 4309649408 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 4311748608 ++wrote 12288/12288 bytes at offset 4311748608 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 4313847808 ++wrote 12288/12288 bytes at offset 4313847808 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 4315947008 ++wrote 12288/12288 bytes at offset 4315947008 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> read 4096/4096 bytes at offset 4294967296 ++=== IO: pattern 0 ++read 4096/4096 bytes at offset 4294967296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294971392 ++read 4096/4096 bytes at offset 4294971392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294975488 ++read 4096/4096 bytes at offset 4294975488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294979584 ++read 4096/4096 bytes at offset 4294979584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294983680 ++read 4096/4096 bytes at offset 4294983680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294987776 ++read 4096/4096 bytes at offset 4294987776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294991872 ++read 4096/4096 bytes at offset 4294991872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294995968 ++read 4096/4096 bytes at offset 4294995968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295000064 ++read 4096/4096 bytes at offset 4295000064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295004160 ++read 4096/4096 bytes at offset 4295004160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295008256 ++read 4096/4096 bytes at offset 4295008256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295012352 ++read 4096/4096 bytes at offset 4295012352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295016448 ++read 4096/4096 bytes at offset 4295016448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295020544 ++read 4096/4096 bytes at offset 4295020544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295024640 ++read 4096/4096 bytes at offset 4295024640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295028736 ++read 4096/4096 bytes at offset 4295028736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295032832 ++read 4096/4096 bytes at offset 4295032832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295036928 ++read 4096/4096 bytes at offset 4295036928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295041024 ++read 4096/4096 bytes at offset 4295041024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295045120 ++read 4096/4096 bytes at offset 4295045120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295049216 ++read 4096/4096 bytes at offset 4295049216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295053312 ++read 4096/4096 bytes at offset 4295053312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295057408 ++read 4096/4096 bytes at offset 4295057408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295061504 ++read 4096/4096 bytes at offset 4295061504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295065600 ++read 4096/4096 bytes at offset 4295065600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295069696 ++read 4096/4096 bytes at offset 4295069696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295073792 ++read 4096/4096 bytes at offset 4295073792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295077888 ++read 4096/4096 bytes at offset 4295077888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295081984 ++read 4096/4096 bytes at offset 4295081984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295086080 ++read 4096/4096 bytes at offset 4295086080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295090176 ++read 4096/4096 bytes at offset 4295090176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295094272 ++read 4096/4096 bytes at offset 4295094272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295098368 ++read 4096/4096 bytes at offset 4295098368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295102464 ++read 4096/4096 bytes at offset 4295102464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295106560 ++read 4096/4096 bytes at offset 4295106560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295110656 ++read 4096/4096 bytes at offset 4295110656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295114752 ++read 4096/4096 bytes at offset 4295114752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295118848 ++read 4096/4096 bytes at offset 4295118848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295122944 ++read 4096/4096 bytes at offset 4295122944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295127040 ++read 4096/4096 bytes at offset 4295127040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295131136 ++read 4096/4096 bytes at offset 4295131136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295135232 ++read 4096/4096 bytes at offset 4295135232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295139328 ++read 4096/4096 bytes at offset 4295139328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295143424 ++read 4096/4096 bytes at offset 4295143424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295147520 ++read 4096/4096 bytes at offset 4295147520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295151616 ++read 4096/4096 bytes at offset 4295151616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295155712 ++read 4096/4096 bytes at offset 4295155712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295159808 ++read 4096/4096 bytes at offset 4295159808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295163904 ++read 4096/4096 bytes at offset 4295163904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295168000 ++read 4096/4096 bytes at offset 4295168000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295172096 ++read 4096/4096 bytes at offset 4295172096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295176192 ++read 4096/4096 bytes at offset 4295176192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295180288 ++read 4096/4096 bytes at offset 4295180288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295184384 ++read 4096/4096 bytes at offset 4295184384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295188480 ++read 4096/4096 bytes at offset 4295188480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295192576 ++read 4096/4096 bytes at offset 4295192576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295196672 ++read 4096/4096 bytes at offset 4295196672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295200768 ++read 4096/4096 bytes at offset 4295200768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295204864 ++read 4096/4096 bytes at offset 4295204864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295208960 ++read 4096/4096 bytes at offset 4295208960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295213056 ++read 4096/4096 bytes at offset 4295213056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295217152 ++read 4096/4096 bytes at offset 4295217152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295221248 ++read 4096/4096 bytes at offset 4295221248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295225344 ++read 4096/4096 bytes at offset 4295225344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295229440 ++read 4096/4096 bytes at offset 4295229440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295233536 ++read 4096/4096 bytes at offset 4295233536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295237632 ++read 4096/4096 bytes at offset 4295237632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295241728 ++read 4096/4096 bytes at offset 4295241728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295245824 ++read 4096/4096 bytes at offset 4295245824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295249920 ++read 4096/4096 bytes at offset 4295249920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295254016 ++read 4096/4096 bytes at offset 4295254016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295258112 ++read 4096/4096 bytes at offset 4295258112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295262208 ++read 4096/4096 bytes at offset 4295262208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295266304 ++read 4096/4096 bytes at offset 4295266304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295270400 ++read 4096/4096 bytes at offset 4295270400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295274496 ++read 4096/4096 bytes at offset 4295274496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295278592 ++read 4096/4096 bytes at offset 4295278592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295282688 ++read 4096/4096 bytes at offset 4295282688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295286784 ++read 4096/4096 bytes at offset 4295286784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295290880 ++read 4096/4096 bytes at offset 4295290880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295294976 ++read 4096/4096 bytes at offset 4295294976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295299072 ++read 4096/4096 bytes at offset 4295299072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295303168 ++read 4096/4096 bytes at offset 4295303168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295307264 ++read 4096/4096 bytes at offset 4295307264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295311360 ++read 4096/4096 bytes at offset 4295311360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295315456 ++read 4096/4096 bytes at offset 4295315456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295319552 ++read 4096/4096 bytes at offset 4295319552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295323648 ++read 4096/4096 bytes at offset 4295323648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295327744 ++read 4096/4096 bytes at offset 4295327744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295331840 ++read 4096/4096 bytes at offset 4295331840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295335936 ++read 4096/4096 bytes at offset 4295335936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295340032 ++read 4096/4096 bytes at offset 4295340032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295344128 ++read 4096/4096 bytes at offset 4295344128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295348224 ++read 4096/4096 bytes at offset 4295348224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295352320 ++read 4096/4096 bytes at offset 4295352320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295356416 ++read 4096/4096 bytes at offset 4295356416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295360512 ++read 4096/4096 bytes at offset 4295360512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295364608 ++read 4096/4096 bytes at offset 4295364608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295368704 ++read 4096/4096 bytes at offset 4295368704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295372800 ++read 4096/4096 bytes at offset 4295372800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295376896 ++read 4096/4096 bytes at offset 4295376896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295380992 ++read 4096/4096 bytes at offset 4295380992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295385088 ++read 4096/4096 bytes at offset 4295385088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295389184 ++read 4096/4096 bytes at offset 4295389184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295393280 ++read 4096/4096 bytes at offset 4295393280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295397376 ++read 4096/4096 bytes at offset 4295397376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295401472 ++read 4096/4096 bytes at offset 4295401472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295405568 ++read 4096/4096 bytes at offset 4295405568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295409664 ++read 4096/4096 bytes at offset 4295409664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295413760 ++read 4096/4096 bytes at offset 4295413760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295417856 ++read 4096/4096 bytes at offset 4295417856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295421952 ++read 4096/4096 bytes at offset 4295421952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295426048 ++read 4096/4096 bytes at offset 4295426048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295430144 ++read 4096/4096 bytes at offset 4295430144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295434240 ++read 4096/4096 bytes at offset 4295434240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295438336 ++read 4096/4096 bytes at offset 4295438336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295442432 ++read 4096/4096 bytes at offset 4295442432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295446528 ++read 4096/4096 bytes at offset 4295446528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295450624 ++read 4096/4096 bytes at offset 4295450624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295454720 ++read 4096/4096 bytes at offset 4295454720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295458816 ++read 4096/4096 bytes at offset 4295458816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295462912 ++read 4096/4096 bytes at offset 4295462912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295467008 ++read 4096/4096 bytes at offset 4295467008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295471104 ++read 4096/4096 bytes at offset 4295471104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295475200 ++read 4096/4096 bytes at offset 4295475200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295479296 ++read 4096/4096 bytes at offset 4295479296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295483392 ++read 4096/4096 bytes at offset 4295483392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295487488 ++read 4096/4096 bytes at offset 4295487488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295491584 ++read 4096/4096 bytes at offset 4295491584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295495680 ++read 4096/4096 bytes at offset 4295495680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295499776 ++read 4096/4096 bytes at offset 4295499776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295503872 ++read 4096/4096 bytes at offset 4295503872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295507968 ++read 4096/4096 bytes at offset 4295507968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295512064 ++read 4096/4096 bytes at offset 4295512064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295516160 ++read 4096/4096 bytes at offset 4295516160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295520256 ++read 4096/4096 bytes at offset 4295520256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295524352 ++read 4096/4096 bytes at offset 4295524352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295528448 ++read 4096/4096 bytes at offset 4295528448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295532544 ++read 4096/4096 bytes at offset 4295532544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295536640 ++read 4096/4096 bytes at offset 4295536640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295540736 ++read 4096/4096 bytes at offset 4295540736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295544832 ++read 4096/4096 bytes at offset 4295544832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295548928 ++read 4096/4096 bytes at offset 4295548928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295553024 ++read 4096/4096 bytes at offset 4295553024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295557120 ++read 4096/4096 bytes at offset 4295557120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295561216 ++read 4096/4096 bytes at offset 4295561216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295565312 ++read 4096/4096 bytes at offset 4295565312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295569408 ++read 4096/4096 bytes at offset 4295569408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295573504 ++read 4096/4096 bytes at offset 4295573504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295577600 ++read 4096/4096 bytes at offset 4295577600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295581696 ++read 4096/4096 bytes at offset 4295581696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295585792 ++read 4096/4096 bytes at offset 4295585792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295589888 ++read 4096/4096 bytes at offset 4295589888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295593984 ++read 4096/4096 bytes at offset 4295593984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295598080 ++read 4096/4096 bytes at offset 4295598080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295602176 ++read 4096/4096 bytes at offset 4295602176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295606272 ++read 4096/4096 bytes at offset 4295606272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295610368 ++read 4096/4096 bytes at offset 4295610368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295614464 ++read 4096/4096 bytes at offset 4295614464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295618560 ++read 4096/4096 bytes at offset 4295618560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295622656 ++read 4096/4096 bytes at offset 4295622656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295626752 ++read 4096/4096 bytes at offset 4295626752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295630848 ++read 4096/4096 bytes at offset 4295630848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295634944 ++read 4096/4096 bytes at offset 4295634944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295639040 ++read 4096/4096 bytes at offset 4295639040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295643136 ++read 4096/4096 bytes at offset 4295643136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295647232 ++read 4096/4096 bytes at offset 4295647232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295651328 ++read 4096/4096 bytes at offset 4295651328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295655424 ++read 4096/4096 bytes at offset 4295655424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295659520 ++read 4096/4096 bytes at offset 4295659520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295663616 ++read 4096/4096 bytes at offset 4295663616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295667712 ++read 4096/4096 bytes at offset 4295667712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295671808 ++read 4096/4096 bytes at offset 4295671808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295675904 ++read 4096/4096 bytes at offset 4295675904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295680000 ++read 4096/4096 bytes at offset 4295680000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295684096 ++read 4096/4096 bytes at offset 4295684096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295688192 ++read 4096/4096 bytes at offset 4295688192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295692288 ++read 4096/4096 bytes at offset 4295692288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295696384 ++read 4096/4096 bytes at offset 4295696384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295700480 ++read 4096/4096 bytes at offset 4295700480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295704576 ++read 4096/4096 bytes at offset 4295704576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295708672 ++read 4096/4096 bytes at offset 4295708672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295712768 ++read 4096/4096 bytes at offset 4295712768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295716864 ++read 4096/4096 bytes at offset 4295716864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295720960 ++read 4096/4096 bytes at offset 4295720960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295725056 ++read 4096/4096 bytes at offset 4295725056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295729152 ++read 4096/4096 bytes at offset 4295729152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295733248 ++read 4096/4096 bytes at offset 4295733248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295737344 ++read 4096/4096 bytes at offset 4295737344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295741440 ++read 4096/4096 bytes at offset 4295741440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295745536 ++read 4096/4096 bytes at offset 4295745536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295749632 ++read 4096/4096 bytes at offset 4295749632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295753728 ++read 4096/4096 bytes at offset 4295753728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295757824 ++read 4096/4096 bytes at offset 4295757824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295761920 ++read 4096/4096 bytes at offset 4295761920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295766016 ++read 4096/4096 bytes at offset 4295766016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295770112 ++read 4096/4096 bytes at offset 4295770112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295774208 ++read 4096/4096 bytes at offset 4295774208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295778304 ++read 4096/4096 bytes at offset 4295778304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295782400 ++read 4096/4096 bytes at offset 4295782400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295786496 ++read 4096/4096 bytes at offset 4295786496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295790592 ++read 4096/4096 bytes at offset 4295790592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295794688 ++read 4096/4096 bytes at offset 4295794688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295798784 ++read 4096/4096 bytes at offset 4295798784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295802880 ++read 4096/4096 bytes at offset 4295802880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295806976 ++read 4096/4096 bytes at offset 4295806976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295811072 ++read 4096/4096 bytes at offset 4295811072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295815168 ++read 4096/4096 bytes at offset 4295815168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295819264 ++read 4096/4096 bytes at offset 4295819264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295823360 ++read 4096/4096 bytes at offset 4295823360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295827456 ++read 4096/4096 bytes at offset 4295827456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295831552 ++read 4096/4096 bytes at offset 4295831552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295835648 ++read 4096/4096 bytes at offset 4295835648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295839744 ++read 4096/4096 bytes at offset 4295839744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295843840 ++read 4096/4096 bytes at offset 4295843840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295847936 ++read 4096/4096 bytes at offset 4295847936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295852032 ++read 4096/4096 bytes at offset 4295852032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295856128 ++read 4096/4096 bytes at offset 4295856128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295860224 ++read 4096/4096 bytes at offset 4295860224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295864320 ++read 4096/4096 bytes at offset 4295864320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295868416 ++read 4096/4096 bytes at offset 4295868416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295872512 ++read 4096/4096 bytes at offset 4295872512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295876608 ++read 4096/4096 bytes at offset 4295876608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295880704 ++read 4096/4096 bytes at offset 4295880704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295884800 ++read 4096/4096 bytes at offset 4295884800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295888896 ++read 4096/4096 bytes at offset 4295888896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295892992 ++read 4096/4096 bytes at offset 4295892992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295897088 ++read 4096/4096 bytes at offset 4295897088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295901184 ++read 4096/4096 bytes at offset 4295901184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295905280 ++read 4096/4096 bytes at offset 4295905280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295909376 ++read 4096/4096 bytes at offset 4295909376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295913472 ++read 4096/4096 bytes at offset 4295913472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295917568 ++read 4096/4096 bytes at offset 4295917568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295921664 ++read 4096/4096 bytes at offset 4295921664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295925760 ++read 4096/4096 bytes at offset 4295925760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295929856 ++read 4096/4096 bytes at offset 4295929856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295933952 ++read 4096/4096 bytes at offset 4295933952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295938048 ++read 4096/4096 bytes at offset 4295938048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295942144 ++read 4096/4096 bytes at offset 4295942144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295946240 ++read 4096/4096 bytes at offset 4295946240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295950336 ++read 4096/4096 bytes at offset 4295950336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295954432 ++read 4096/4096 bytes at offset 4295954432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295958528 ++read 4096/4096 bytes at offset 4295958528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295962624 ++read 4096/4096 bytes at offset 4295962624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295966720 ++read 4096/4096 bytes at offset 4295966720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295970816 ++read 4096/4096 bytes at offset 4295970816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295974912 ++read 4096/4096 bytes at offset 4295974912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295979008 ++read 4096/4096 bytes at offset 4295979008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295983104 ++read 4096/4096 bytes at offset 4295983104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295987200 ++read 4096/4096 bytes at offset 4295987200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295991296 ++read 4096/4096 bytes at offset 4295991296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295995392 ++read 4096/4096 bytes at offset 4295995392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295999488 ++read 4096/4096 bytes at offset 4295999488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4296003584 ++read 4096/4096 bytes at offset 4296003584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4296007680 ++read 4096/4096 bytes at offset 4296007680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4296011776 ++read 4096/4096 bytes at offset 4296011776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 4 +-qemu-io> read 2048/2048 bytes at offset 4296017920 ++=== IO: pattern 4 ++read 2048/2048 bytes at offset 4296017920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296022016 ++read 2048/2048 bytes at offset 4296022016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296026112 ++read 2048/2048 bytes at offset 4296026112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296030208 ++read 2048/2048 bytes at offset 4296030208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296034304 ++read 2048/2048 bytes at offset 4296034304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296038400 ++read 2048/2048 bytes at offset 4296038400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296042496 ++read 2048/2048 bytes at offset 4296042496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296046592 ++read 2048/2048 bytes at offset 4296046592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296050688 ++read 2048/2048 bytes at offset 4296050688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296054784 ++read 2048/2048 bytes at offset 4296054784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296058880 ++read 2048/2048 bytes at offset 4296058880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296062976 ++read 2048/2048 bytes at offset 4296062976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296067072 ++read 2048/2048 bytes at offset 4296067072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296071168 ++read 2048/2048 bytes at offset 4296071168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296075264 ++read 2048/2048 bytes at offset 4296075264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296079360 ++read 2048/2048 bytes at offset 4296079360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296083456 ++read 2048/2048 bytes at offset 4296083456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296087552 ++read 2048/2048 bytes at offset 4296087552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296091648 ++read 2048/2048 bytes at offset 4296091648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296095744 ++read 2048/2048 bytes at offset 4296095744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296099840 ++read 2048/2048 bytes at offset 4296099840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296103936 ++read 2048/2048 bytes at offset 4296103936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296108032 ++read 2048/2048 bytes at offset 4296108032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296112128 ++read 2048/2048 bytes at offset 4296112128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296116224 ++read 2048/2048 bytes at offset 4296116224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296120320 ++read 2048/2048 bytes at offset 4296120320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296124416 ++read 2048/2048 bytes at offset 4296124416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296128512 ++read 2048/2048 bytes at offset 4296128512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296132608 ++read 2048/2048 bytes at offset 4296132608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296136704 ++read 2048/2048 bytes at offset 4296136704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296140800 ++read 2048/2048 bytes at offset 4296140800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296144896 ++read 2048/2048 bytes at offset 4296144896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296148992 ++read 2048/2048 bytes at offset 4296148992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296153088 ++read 2048/2048 bytes at offset 4296153088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296157184 ++read 2048/2048 bytes at offset 4296157184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296161280 ++read 2048/2048 bytes at offset 4296161280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296165376 ++read 2048/2048 bytes at offset 4296165376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296169472 ++read 2048/2048 bytes at offset 4296169472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296173568 ++read 2048/2048 bytes at offset 4296173568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296177664 ++read 2048/2048 bytes at offset 4296177664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296181760 ++read 2048/2048 bytes at offset 4296181760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296185856 ++read 2048/2048 bytes at offset 4296185856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296189952 ++read 2048/2048 bytes at offset 4296189952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296194048 ++read 2048/2048 bytes at offset 4296194048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296198144 ++read 2048/2048 bytes at offset 4296198144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296202240 ++read 2048/2048 bytes at offset 4296202240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296206336 ++read 2048/2048 bytes at offset 4296206336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296210432 ++read 2048/2048 bytes at offset 4296210432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296214528 ++read 2048/2048 bytes at offset 4296214528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296218624 ++read 2048/2048 bytes at offset 4296218624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296222720 ++read 2048/2048 bytes at offset 4296222720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296226816 ++read 2048/2048 bytes at offset 4296226816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296230912 ++read 2048/2048 bytes at offset 4296230912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296235008 ++read 2048/2048 bytes at offset 4296235008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296239104 ++read 2048/2048 bytes at offset 4296239104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296243200 ++read 2048/2048 bytes at offset 4296243200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296247296 ++read 2048/2048 bytes at offset 4296247296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296251392 ++read 2048/2048 bytes at offset 4296251392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296255488 ++read 2048/2048 bytes at offset 4296255488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296259584 ++read 2048/2048 bytes at offset 4296259584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296263680 ++read 2048/2048 bytes at offset 4296263680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296267776 ++read 2048/2048 bytes at offset 4296267776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296271872 ++read 2048/2048 bytes at offset 4296271872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296275968 ++read 2048/2048 bytes at offset 4296275968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296280064 ++read 2048/2048 bytes at offset 4296280064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296284160 ++read 2048/2048 bytes at offset 4296284160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296288256 ++read 2048/2048 bytes at offset 4296288256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296292352 ++read 2048/2048 bytes at offset 4296292352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296296448 ++read 2048/2048 bytes at offset 4296296448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296300544 ++read 2048/2048 bytes at offset 4296300544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296304640 ++read 2048/2048 bytes at offset 4296304640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296308736 ++read 2048/2048 bytes at offset 4296308736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296312832 ++read 2048/2048 bytes at offset 4296312832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296316928 ++read 2048/2048 bytes at offset 4296316928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296321024 ++read 2048/2048 bytes at offset 4296321024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296325120 ++read 2048/2048 bytes at offset 4296325120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296329216 ++read 2048/2048 bytes at offset 4296329216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296333312 ++read 2048/2048 bytes at offset 4296333312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296337408 ++read 2048/2048 bytes at offset 4296337408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296341504 ++read 2048/2048 bytes at offset 4296341504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296345600 ++read 2048/2048 bytes at offset 4296345600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296349696 ++read 2048/2048 bytes at offset 4296349696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296353792 ++read 2048/2048 bytes at offset 4296353792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296357888 ++read 2048/2048 bytes at offset 4296357888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296361984 ++read 2048/2048 bytes at offset 4296361984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296366080 ++read 2048/2048 bytes at offset 4296366080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296370176 ++read 2048/2048 bytes at offset 4296370176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296374272 ++read 2048/2048 bytes at offset 4296374272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296378368 ++read 2048/2048 bytes at offset 4296378368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296382464 ++read 2048/2048 bytes at offset 4296382464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296386560 ++read 2048/2048 bytes at offset 4296386560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296390656 ++read 2048/2048 bytes at offset 4296390656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296394752 ++read 2048/2048 bytes at offset 4296394752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296398848 ++read 2048/2048 bytes at offset 4296398848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296402944 ++read 2048/2048 bytes at offset 4296402944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296407040 ++read 2048/2048 bytes at offset 4296407040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296411136 ++read 2048/2048 bytes at offset 4296411136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296415232 ++read 2048/2048 bytes at offset 4296415232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296419328 ++read 2048/2048 bytes at offset 4296419328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296423424 ++read 2048/2048 bytes at offset 4296423424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296427520 ++read 2048/2048 bytes at offset 4296427520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296431616 ++read 2048/2048 bytes at offset 4296431616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296435712 ++read 2048/2048 bytes at offset 4296435712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296439808 ++read 2048/2048 bytes at offset 4296439808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296443904 ++read 2048/2048 bytes at offset 4296443904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296448000 ++read 2048/2048 bytes at offset 4296448000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296452096 ++read 2048/2048 bytes at offset 4296452096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296456192 ++read 2048/2048 bytes at offset 4296456192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296460288 ++read 2048/2048 bytes at offset 4296460288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296464384 ++read 2048/2048 bytes at offset 4296464384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296468480 ++read 2048/2048 bytes at offset 4296468480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296472576 ++read 2048/2048 bytes at offset 4296472576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296476672 ++read 2048/2048 bytes at offset 4296476672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296480768 ++read 2048/2048 bytes at offset 4296480768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296484864 ++read 2048/2048 bytes at offset 4296484864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296488960 ++read 2048/2048 bytes at offset 4296488960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296493056 ++read 2048/2048 bytes at offset 4296493056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296497152 ++read 2048/2048 bytes at offset 4296497152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296501248 ++read 2048/2048 bytes at offset 4296501248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296505344 ++read 2048/2048 bytes at offset 4296505344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296509440 ++read 2048/2048 bytes at offset 4296509440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296513536 ++read 2048/2048 bytes at offset 4296513536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296517632 ++read 2048/2048 bytes at offset 4296517632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296521728 ++read 2048/2048 bytes at offset 4296521728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296525824 ++read 2048/2048 bytes at offset 4296525824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296529920 ++read 2048/2048 bytes at offset 4296529920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296534016 ++read 2048/2048 bytes at offset 4296534016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296538112 ++read 2048/2048 bytes at offset 4296538112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296542208 ++read 2048/2048 bytes at offset 4296542208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296546304 ++read 2048/2048 bytes at offset 4296546304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296550400 ++read 2048/2048 bytes at offset 4296550400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296554496 ++read 2048/2048 bytes at offset 4296554496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296558592 ++read 2048/2048 bytes at offset 4296558592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296562688 ++read 2048/2048 bytes at offset 4296562688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296566784 ++read 2048/2048 bytes at offset 4296566784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296570880 ++read 2048/2048 bytes at offset 4296570880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296574976 ++read 2048/2048 bytes at offset 4296574976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296579072 ++read 2048/2048 bytes at offset 4296579072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296583168 ++read 2048/2048 bytes at offset 4296583168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296587264 ++read 2048/2048 bytes at offset 4296587264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296591360 ++read 2048/2048 bytes at offset 4296591360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296595456 ++read 2048/2048 bytes at offset 4296595456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296599552 ++read 2048/2048 bytes at offset 4296599552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296603648 ++read 2048/2048 bytes at offset 4296603648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296607744 ++read 2048/2048 bytes at offset 4296607744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296611840 ++read 2048/2048 bytes at offset 4296611840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296615936 ++read 2048/2048 bytes at offset 4296615936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296620032 ++read 2048/2048 bytes at offset 4296620032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296624128 ++read 2048/2048 bytes at offset 4296624128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296628224 ++read 2048/2048 bytes at offset 4296628224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296632320 ++read 2048/2048 bytes at offset 4296632320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296636416 ++read 2048/2048 bytes at offset 4296636416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296640512 ++read 2048/2048 bytes at offset 4296640512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296644608 ++read 2048/2048 bytes at offset 4296644608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296648704 ++read 2048/2048 bytes at offset 4296648704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296652800 ++read 2048/2048 bytes at offset 4296652800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296656896 ++read 2048/2048 bytes at offset 4296656896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296660992 ++read 2048/2048 bytes at offset 4296660992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296665088 ++read 2048/2048 bytes at offset 4296665088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296669184 ++read 2048/2048 bytes at offset 4296669184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296673280 ++read 2048/2048 bytes at offset 4296673280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296677376 ++read 2048/2048 bytes at offset 4296677376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296681472 ++read 2048/2048 bytes at offset 4296681472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296685568 ++read 2048/2048 bytes at offset 4296685568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296689664 ++read 2048/2048 bytes at offset 4296689664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296693760 ++read 2048/2048 bytes at offset 4296693760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296697856 ++read 2048/2048 bytes at offset 4296697856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296701952 ++read 2048/2048 bytes at offset 4296701952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296706048 ++read 2048/2048 bytes at offset 4296706048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296710144 ++read 2048/2048 bytes at offset 4296710144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296714240 ++read 2048/2048 bytes at offset 4296714240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296718336 ++read 2048/2048 bytes at offset 4296718336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296722432 ++read 2048/2048 bytes at offset 4296722432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296726528 ++read 2048/2048 bytes at offset 4296726528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296730624 ++read 2048/2048 bytes at offset 4296730624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296734720 ++read 2048/2048 bytes at offset 4296734720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296738816 ++read 2048/2048 bytes at offset 4296738816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296742912 ++read 2048/2048 bytes at offset 4296742912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296747008 ++read 2048/2048 bytes at offset 4296747008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296751104 ++read 2048/2048 bytes at offset 4296751104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296755200 ++read 2048/2048 bytes at offset 4296755200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296759296 ++read 2048/2048 bytes at offset 4296759296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296763392 ++read 2048/2048 bytes at offset 4296763392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296767488 ++read 2048/2048 bytes at offset 4296767488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296771584 ++read 2048/2048 bytes at offset 4296771584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296775680 ++read 2048/2048 bytes at offset 4296775680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296779776 ++read 2048/2048 bytes at offset 4296779776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296783872 ++read 2048/2048 bytes at offset 4296783872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296787968 ++read 2048/2048 bytes at offset 4296787968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296792064 ++read 2048/2048 bytes at offset 4296792064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296796160 ++read 2048/2048 bytes at offset 4296796160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296800256 ++read 2048/2048 bytes at offset 4296800256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296804352 ++read 2048/2048 bytes at offset 4296804352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296808448 ++read 2048/2048 bytes at offset 4296808448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296812544 ++read 2048/2048 bytes at offset 4296812544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296816640 ++read 2048/2048 bytes at offset 4296816640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296820736 ++read 2048/2048 bytes at offset 4296820736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296824832 ++read 2048/2048 bytes at offset 4296824832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296828928 ++read 2048/2048 bytes at offset 4296828928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296833024 ++read 2048/2048 bytes at offset 4296833024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296837120 ++read 2048/2048 bytes at offset 4296837120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296841216 ++read 2048/2048 bytes at offset 4296841216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296845312 ++read 2048/2048 bytes at offset 4296845312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296849408 ++read 2048/2048 bytes at offset 4296849408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296853504 ++read 2048/2048 bytes at offset 4296853504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296857600 ++read 2048/2048 bytes at offset 4296857600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296861696 ++read 2048/2048 bytes at offset 4296861696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296865792 ++read 2048/2048 bytes at offset 4296865792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296869888 ++read 2048/2048 bytes at offset 4296869888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296873984 ++read 2048/2048 bytes at offset 4296873984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296878080 ++read 2048/2048 bytes at offset 4296878080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296882176 ++read 2048/2048 bytes at offset 4296882176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296886272 ++read 2048/2048 bytes at offset 4296886272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296890368 ++read 2048/2048 bytes at offset 4296890368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296894464 ++read 2048/2048 bytes at offset 4296894464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296898560 ++read 2048/2048 bytes at offset 4296898560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296902656 ++read 2048/2048 bytes at offset 4296902656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296906752 ++read 2048/2048 bytes at offset 4296906752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296910848 ++read 2048/2048 bytes at offset 4296910848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296914944 ++read 2048/2048 bytes at offset 4296914944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296919040 ++read 2048/2048 bytes at offset 4296919040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296923136 ++read 2048/2048 bytes at offset 4296923136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296927232 ++read 2048/2048 bytes at offset 4296927232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296931328 ++read 2048/2048 bytes at offset 4296931328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296935424 ++read 2048/2048 bytes at offset 4296935424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296939520 ++read 2048/2048 bytes at offset 4296939520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296943616 ++read 2048/2048 bytes at offset 4296943616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296947712 ++read 2048/2048 bytes at offset 4296947712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296951808 ++read 2048/2048 bytes at offset 4296951808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296955904 ++read 2048/2048 bytes at offset 4296955904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296960000 ++read 2048/2048 bytes at offset 4296960000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296964096 ++read 2048/2048 bytes at offset 4296964096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296968192 ++read 2048/2048 bytes at offset 4296968192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296972288 ++read 2048/2048 bytes at offset 4296972288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296976384 ++read 2048/2048 bytes at offset 4296976384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296980480 ++read 2048/2048 bytes at offset 4296980480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296984576 ++read 2048/2048 bytes at offset 4296984576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296988672 ++read 2048/2048 bytes at offset 4296988672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296992768 ++read 2048/2048 bytes at offset 4296992768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296996864 ++read 2048/2048 bytes at offset 4296996864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297000960 ++read 2048/2048 bytes at offset 4297000960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297005056 ++read 2048/2048 bytes at offset 4297005056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297009152 ++read 2048/2048 bytes at offset 4297009152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297013248 ++read 2048/2048 bytes at offset 4297013248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297017344 ++read 2048/2048 bytes at offset 4297017344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297021440 ++read 2048/2048 bytes at offset 4297021440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297025536 ++read 2048/2048 bytes at offset 4297025536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297029632 ++read 2048/2048 bytes at offset 4297029632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297033728 ++read 2048/2048 bytes at offset 4297033728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297037824 ++read 2048/2048 bytes at offset 4297037824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297041920 ++read 2048/2048 bytes at offset 4297041920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297046016 ++read 2048/2048 bytes at offset 4297046016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297050112 ++read 2048/2048 bytes at offset 4297050112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297054208 ++read 2048/2048 bytes at offset 4297054208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297058304 ++read 2048/2048 bytes at offset 4297058304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297062400 ++read 2048/2048 bytes at offset 4297062400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> read 2048/2048 bytes at offset 4297064448 ++=== IO: pattern 0 ++read 2048/2048 bytes at offset 4297064448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297068544 ++read 2048/2048 bytes at offset 4297068544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297072640 ++read 2048/2048 bytes at offset 4297072640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297076736 ++read 2048/2048 bytes at offset 4297076736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297080832 ++read 2048/2048 bytes at offset 4297080832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297084928 ++read 2048/2048 bytes at offset 4297084928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297089024 ++read 2048/2048 bytes at offset 4297089024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297093120 ++read 2048/2048 bytes at offset 4297093120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297097216 ++read 2048/2048 bytes at offset 4297097216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297101312 ++read 2048/2048 bytes at offset 4297101312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297105408 ++read 2048/2048 bytes at offset 4297105408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297109504 ++read 2048/2048 bytes at offset 4297109504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297113600 ++read 2048/2048 bytes at offset 4297113600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297117696 ++read 2048/2048 bytes at offset 4297117696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297121792 ++read 2048/2048 bytes at offset 4297121792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297125888 ++read 2048/2048 bytes at offset 4297125888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297129984 ++read 2048/2048 bytes at offset 4297129984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297134080 ++read 2048/2048 bytes at offset 4297134080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297138176 ++read 2048/2048 bytes at offset 4297138176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297142272 ++read 2048/2048 bytes at offset 4297142272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297146368 ++read 2048/2048 bytes at offset 4297146368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297150464 ++read 2048/2048 bytes at offset 4297150464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297154560 ++read 2048/2048 bytes at offset 4297154560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297158656 ++read 2048/2048 bytes at offset 4297158656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297162752 ++read 2048/2048 bytes at offset 4297162752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297166848 ++read 2048/2048 bytes at offset 4297166848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297170944 ++read 2048/2048 bytes at offset 4297170944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297175040 ++read 2048/2048 bytes at offset 4297175040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297179136 ++read 2048/2048 bytes at offset 4297179136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297183232 ++read 2048/2048 bytes at offset 4297183232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297187328 ++read 2048/2048 bytes at offset 4297187328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297191424 ++read 2048/2048 bytes at offset 4297191424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297195520 ++read 2048/2048 bytes at offset 4297195520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297199616 ++read 2048/2048 bytes at offset 4297199616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297203712 ++read 2048/2048 bytes at offset 4297203712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297207808 ++read 2048/2048 bytes at offset 4297207808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297211904 ++read 2048/2048 bytes at offset 4297211904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297216000 ++read 2048/2048 bytes at offset 4297216000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297220096 ++read 2048/2048 bytes at offset 4297220096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297224192 ++read 2048/2048 bytes at offset 4297224192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297228288 ++read 2048/2048 bytes at offset 4297228288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297232384 ++read 2048/2048 bytes at offset 4297232384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297236480 ++read 2048/2048 bytes at offset 4297236480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297240576 ++read 2048/2048 bytes at offset 4297240576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297244672 ++read 2048/2048 bytes at offset 4297244672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297248768 ++read 2048/2048 bytes at offset 4297248768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297252864 ++read 2048/2048 bytes at offset 4297252864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297256960 ++read 2048/2048 bytes at offset 4297256960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297261056 ++read 2048/2048 bytes at offset 4297261056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297265152 ++read 2048/2048 bytes at offset 4297265152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297269248 ++read 2048/2048 bytes at offset 4297269248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297273344 ++read 2048/2048 bytes at offset 4297273344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297277440 ++read 2048/2048 bytes at offset 4297277440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297281536 ++read 2048/2048 bytes at offset 4297281536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297285632 ++read 2048/2048 bytes at offset 4297285632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297289728 ++read 2048/2048 bytes at offset 4297289728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297293824 ++read 2048/2048 bytes at offset 4297293824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297297920 ++read 2048/2048 bytes at offset 4297297920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297302016 ++read 2048/2048 bytes at offset 4297302016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297306112 ++read 2048/2048 bytes at offset 4297306112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297310208 ++read 2048/2048 bytes at offset 4297310208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297314304 ++read 2048/2048 bytes at offset 4297314304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297318400 ++read 2048/2048 bytes at offset 4297318400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297322496 ++read 2048/2048 bytes at offset 4297322496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297326592 ++read 2048/2048 bytes at offset 4297326592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297330688 ++read 2048/2048 bytes at offset 4297330688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297334784 ++read 2048/2048 bytes at offset 4297334784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297338880 ++read 2048/2048 bytes at offset 4297338880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297342976 ++read 2048/2048 bytes at offset 4297342976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297347072 ++read 2048/2048 bytes at offset 4297347072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297351168 ++read 2048/2048 bytes at offset 4297351168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297355264 ++read 2048/2048 bytes at offset 4297355264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297359360 ++read 2048/2048 bytes at offset 4297359360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297363456 ++read 2048/2048 bytes at offset 4297363456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297367552 ++read 2048/2048 bytes at offset 4297367552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297371648 ++read 2048/2048 bytes at offset 4297371648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297375744 ++read 2048/2048 bytes at offset 4297375744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297379840 ++read 2048/2048 bytes at offset 4297379840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297383936 ++read 2048/2048 bytes at offset 4297383936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297388032 ++read 2048/2048 bytes at offset 4297388032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297392128 ++read 2048/2048 bytes at offset 4297392128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297396224 ++read 2048/2048 bytes at offset 4297396224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297400320 ++read 2048/2048 bytes at offset 4297400320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297404416 ++read 2048/2048 bytes at offset 4297404416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297408512 ++read 2048/2048 bytes at offset 4297408512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297412608 ++read 2048/2048 bytes at offset 4297412608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297416704 ++read 2048/2048 bytes at offset 4297416704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297420800 ++read 2048/2048 bytes at offset 4297420800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297424896 ++read 2048/2048 bytes at offset 4297424896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297428992 ++read 2048/2048 bytes at offset 4297428992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297433088 ++read 2048/2048 bytes at offset 4297433088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297437184 ++read 2048/2048 bytes at offset 4297437184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297441280 ++read 2048/2048 bytes at offset 4297441280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297445376 ++read 2048/2048 bytes at offset 4297445376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297449472 ++read 2048/2048 bytes at offset 4297449472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297453568 ++read 2048/2048 bytes at offset 4297453568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297457664 ++read 2048/2048 bytes at offset 4297457664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297461760 ++read 2048/2048 bytes at offset 4297461760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297465856 ++read 2048/2048 bytes at offset 4297465856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297469952 ++read 2048/2048 bytes at offset 4297469952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297474048 ++read 2048/2048 bytes at offset 4297474048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297478144 ++read 2048/2048 bytes at offset 4297478144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297482240 ++read 2048/2048 bytes at offset 4297482240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297486336 ++read 2048/2048 bytes at offset 4297486336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297490432 ++read 2048/2048 bytes at offset 4297490432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297494528 ++read 2048/2048 bytes at offset 4297494528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297498624 ++read 2048/2048 bytes at offset 4297498624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297502720 ++read 2048/2048 bytes at offset 4297502720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297506816 ++read 2048/2048 bytes at offset 4297506816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297510912 ++read 2048/2048 bytes at offset 4297510912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297515008 ++read 2048/2048 bytes at offset 4297515008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297519104 ++read 2048/2048 bytes at offset 4297519104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297523200 ++read 2048/2048 bytes at offset 4297523200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297527296 ++read 2048/2048 bytes at offset 4297527296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297531392 ++read 2048/2048 bytes at offset 4297531392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297535488 ++read 2048/2048 bytes at offset 4297535488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297539584 ++read 2048/2048 bytes at offset 4297539584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297543680 ++read 2048/2048 bytes at offset 4297543680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297547776 ++read 2048/2048 bytes at offset 4297547776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297551872 ++read 2048/2048 bytes at offset 4297551872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297555968 ++read 2048/2048 bytes at offset 4297555968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297560064 ++read 2048/2048 bytes at offset 4297560064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297564160 ++read 2048/2048 bytes at offset 4297564160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297568256 ++read 2048/2048 bytes at offset 4297568256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297572352 ++read 2048/2048 bytes at offset 4297572352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297576448 ++read 2048/2048 bytes at offset 4297576448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297580544 ++read 2048/2048 bytes at offset 4297580544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297584640 ++read 2048/2048 bytes at offset 4297584640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297588736 ++read 2048/2048 bytes at offset 4297588736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297592832 ++read 2048/2048 bytes at offset 4297592832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297596928 ++read 2048/2048 bytes at offset 4297596928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297601024 ++read 2048/2048 bytes at offset 4297601024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297605120 ++read 2048/2048 bytes at offset 4297605120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297609216 ++read 2048/2048 bytes at offset 4297609216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297613312 ++read 2048/2048 bytes at offset 4297613312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297617408 ++read 2048/2048 bytes at offset 4297617408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297621504 ++read 2048/2048 bytes at offset 4297621504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297625600 ++read 2048/2048 bytes at offset 4297625600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297629696 ++read 2048/2048 bytes at offset 4297629696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297633792 ++read 2048/2048 bytes at offset 4297633792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297637888 ++read 2048/2048 bytes at offset 4297637888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297641984 ++read 2048/2048 bytes at offset 4297641984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297646080 ++read 2048/2048 bytes at offset 4297646080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297650176 ++read 2048/2048 bytes at offset 4297650176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297654272 ++read 2048/2048 bytes at offset 4297654272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297658368 ++read 2048/2048 bytes at offset 4297658368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297662464 ++read 2048/2048 bytes at offset 4297662464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297666560 ++read 2048/2048 bytes at offset 4297666560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297670656 ++read 2048/2048 bytes at offset 4297670656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297674752 ++read 2048/2048 bytes at offset 4297674752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297678848 ++read 2048/2048 bytes at offset 4297678848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297682944 ++read 2048/2048 bytes at offset 4297682944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297687040 ++read 2048/2048 bytes at offset 4297687040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297691136 ++read 2048/2048 bytes at offset 4297691136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297695232 ++read 2048/2048 bytes at offset 4297695232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297699328 ++read 2048/2048 bytes at offset 4297699328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297703424 ++read 2048/2048 bytes at offset 4297703424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297707520 ++read 2048/2048 bytes at offset 4297707520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297711616 ++read 2048/2048 bytes at offset 4297711616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297715712 ++read 2048/2048 bytes at offset 4297715712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297719808 ++read 2048/2048 bytes at offset 4297719808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297723904 ++read 2048/2048 bytes at offset 4297723904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297728000 ++read 2048/2048 bytes at offset 4297728000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297732096 ++read 2048/2048 bytes at offset 4297732096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297736192 ++read 2048/2048 bytes at offset 4297736192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297740288 ++read 2048/2048 bytes at offset 4297740288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297744384 ++read 2048/2048 bytes at offset 4297744384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297748480 ++read 2048/2048 bytes at offset 4297748480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297752576 ++read 2048/2048 bytes at offset 4297752576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297756672 ++read 2048/2048 bytes at offset 4297756672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297760768 ++read 2048/2048 bytes at offset 4297760768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297764864 ++read 2048/2048 bytes at offset 4297764864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297768960 ++read 2048/2048 bytes at offset 4297768960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297773056 ++read 2048/2048 bytes at offset 4297773056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297777152 ++read 2048/2048 bytes at offset 4297777152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297781248 ++read 2048/2048 bytes at offset 4297781248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297785344 ++read 2048/2048 bytes at offset 4297785344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297789440 ++read 2048/2048 bytes at offset 4297789440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297793536 ++read 2048/2048 bytes at offset 4297793536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297797632 ++read 2048/2048 bytes at offset 4297797632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297801728 ++read 2048/2048 bytes at offset 4297801728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297805824 ++read 2048/2048 bytes at offset 4297805824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297809920 ++read 2048/2048 bytes at offset 4297809920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297814016 ++read 2048/2048 bytes at offset 4297814016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297818112 ++read 2048/2048 bytes at offset 4297818112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297822208 ++read 2048/2048 bytes at offset 4297822208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297826304 ++read 2048/2048 bytes at offset 4297826304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297830400 ++read 2048/2048 bytes at offset 4297830400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297834496 ++read 2048/2048 bytes at offset 4297834496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297838592 ++read 2048/2048 bytes at offset 4297838592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297842688 ++read 2048/2048 bytes at offset 4297842688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297846784 ++read 2048/2048 bytes at offset 4297846784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297850880 ++read 2048/2048 bytes at offset 4297850880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297854976 ++read 2048/2048 bytes at offset 4297854976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297859072 ++read 2048/2048 bytes at offset 4297859072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297863168 ++read 2048/2048 bytes at offset 4297863168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297867264 ++read 2048/2048 bytes at offset 4297867264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297871360 ++read 2048/2048 bytes at offset 4297871360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297875456 ++read 2048/2048 bytes at offset 4297875456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297879552 ++read 2048/2048 bytes at offset 4297879552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297883648 ++read 2048/2048 bytes at offset 4297883648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297887744 ++read 2048/2048 bytes at offset 4297887744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297891840 ++read 2048/2048 bytes at offset 4297891840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297895936 ++read 2048/2048 bytes at offset 4297895936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297900032 ++read 2048/2048 bytes at offset 4297900032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297904128 ++read 2048/2048 bytes at offset 4297904128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297908224 ++read 2048/2048 bytes at offset 4297908224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297912320 ++read 2048/2048 bytes at offset 4297912320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297916416 ++read 2048/2048 bytes at offset 4297916416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297920512 ++read 2048/2048 bytes at offset 4297920512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297924608 ++read 2048/2048 bytes at offset 4297924608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297928704 ++read 2048/2048 bytes at offset 4297928704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297932800 ++read 2048/2048 bytes at offset 4297932800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297936896 ++read 2048/2048 bytes at offset 4297936896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297940992 ++read 2048/2048 bytes at offset 4297940992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297945088 ++read 2048/2048 bytes at offset 4297945088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297949184 ++read 2048/2048 bytes at offset 4297949184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297953280 ++read 2048/2048 bytes at offset 4297953280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297957376 ++read 2048/2048 bytes at offset 4297957376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297961472 ++read 2048/2048 bytes at offset 4297961472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297965568 ++read 2048/2048 bytes at offset 4297965568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297969664 ++read 2048/2048 bytes at offset 4297969664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297973760 ++read 2048/2048 bytes at offset 4297973760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297977856 ++read 2048/2048 bytes at offset 4297977856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297981952 ++read 2048/2048 bytes at offset 4297981952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297986048 ++read 2048/2048 bytes at offset 4297986048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297990144 ++read 2048/2048 bytes at offset 4297990144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297994240 ++read 2048/2048 bytes at offset 4297994240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297998336 ++read 2048/2048 bytes at offset 4297998336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298002432 ++read 2048/2048 bytes at offset 4298002432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298006528 ++read 2048/2048 bytes at offset 4298006528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298010624 ++read 2048/2048 bytes at offset 4298010624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298014720 ++read 2048/2048 bytes at offset 4298014720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298018816 ++read 2048/2048 bytes at offset 4298018816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298022912 ++read 2048/2048 bytes at offset 4298022912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298027008 ++read 2048/2048 bytes at offset 4298027008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298031104 ++read 2048/2048 bytes at offset 4298031104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298035200 ++read 2048/2048 bytes at offset 4298035200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298039296 ++read 2048/2048 bytes at offset 4298039296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298043392 ++read 2048/2048 bytes at offset 4298043392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298047488 ++read 2048/2048 bytes at offset 4298047488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298051584 ++read 2048/2048 bytes at offset 4298051584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298055680 ++read 2048/2048 bytes at offset 4298055680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298059776 ++read 2048/2048 bytes at offset 4298059776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298063872 ++read 2048/2048 bytes at offset 4298063872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298067968 ++read 2048/2048 bytes at offset 4298067968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298072064 ++read 2048/2048 bytes at offset 4298072064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298076160 ++read 2048/2048 bytes at offset 4298076160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298080256 ++read 2048/2048 bytes at offset 4298080256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298084352 ++read 2048/2048 bytes at offset 4298084352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298088448 ++read 2048/2048 bytes at offset 4298088448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298092544 ++read 2048/2048 bytes at offset 4298092544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298096640 ++read 2048/2048 bytes at offset 4298096640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298100736 ++read 2048/2048 bytes at offset 4298100736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298104832 ++read 2048/2048 bytes at offset 4298104832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298108928 ++read 2048/2048 bytes at offset 4298108928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 2 +-qemu-io> read 2048/2048 bytes at offset 4298114048 ++=== IO: pattern 2 ++read 2048/2048 bytes at offset 4298114048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298118144 ++read 2048/2048 bytes at offset 4298118144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298122240 ++read 2048/2048 bytes at offset 4298122240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298126336 ++read 2048/2048 bytes at offset 4298126336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298130432 ++read 2048/2048 bytes at offset 4298130432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298134528 ++read 2048/2048 bytes at offset 4298134528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298138624 ++read 2048/2048 bytes at offset 4298138624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298142720 ++read 2048/2048 bytes at offset 4298142720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298146816 ++read 2048/2048 bytes at offset 4298146816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298150912 ++read 2048/2048 bytes at offset 4298150912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298155008 ++read 2048/2048 bytes at offset 4298155008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298159104 ++read 2048/2048 bytes at offset 4298159104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298163200 ++read 2048/2048 bytes at offset 4298163200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298167296 ++read 2048/2048 bytes at offset 4298167296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298171392 ++read 2048/2048 bytes at offset 4298171392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298175488 ++read 2048/2048 bytes at offset 4298175488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298179584 ++read 2048/2048 bytes at offset 4298179584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298183680 ++read 2048/2048 bytes at offset 4298183680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298187776 ++read 2048/2048 bytes at offset 4298187776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298191872 ++read 2048/2048 bytes at offset 4298191872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298195968 ++read 2048/2048 bytes at offset 4298195968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298200064 ++read 2048/2048 bytes at offset 4298200064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298204160 ++read 2048/2048 bytes at offset 4298204160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298208256 ++read 2048/2048 bytes at offset 4298208256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298212352 ++read 2048/2048 bytes at offset 4298212352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298216448 ++read 2048/2048 bytes at offset 4298216448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298220544 ++read 2048/2048 bytes at offset 4298220544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298224640 ++read 2048/2048 bytes at offset 4298224640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298228736 ++read 2048/2048 bytes at offset 4298228736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298232832 ++read 2048/2048 bytes at offset 4298232832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298236928 ++read 2048/2048 bytes at offset 4298236928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298241024 ++read 2048/2048 bytes at offset 4298241024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298245120 ++read 2048/2048 bytes at offset 4298245120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298249216 ++read 2048/2048 bytes at offset 4298249216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298253312 ++read 2048/2048 bytes at offset 4298253312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298257408 ++read 2048/2048 bytes at offset 4298257408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298261504 ++read 2048/2048 bytes at offset 4298261504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298265600 ++read 2048/2048 bytes at offset 4298265600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298269696 ++read 2048/2048 bytes at offset 4298269696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298273792 ++read 2048/2048 bytes at offset 4298273792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298277888 ++read 2048/2048 bytes at offset 4298277888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298281984 ++read 2048/2048 bytes at offset 4298281984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298286080 ++read 2048/2048 bytes at offset 4298286080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298290176 ++read 2048/2048 bytes at offset 4298290176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298294272 ++read 2048/2048 bytes at offset 4298294272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298298368 ++read 2048/2048 bytes at offset 4298298368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298302464 ++read 2048/2048 bytes at offset 4298302464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298306560 ++read 2048/2048 bytes at offset 4298306560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298310656 ++read 2048/2048 bytes at offset 4298310656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298314752 ++read 2048/2048 bytes at offset 4298314752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298318848 ++read 2048/2048 bytes at offset 4298318848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298322944 ++read 2048/2048 bytes at offset 4298322944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298327040 ++read 2048/2048 bytes at offset 4298327040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298331136 ++read 2048/2048 bytes at offset 4298331136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298335232 ++read 2048/2048 bytes at offset 4298335232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298339328 ++read 2048/2048 bytes at offset 4298339328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298343424 ++read 2048/2048 bytes at offset 4298343424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298347520 ++read 2048/2048 bytes at offset 4298347520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298351616 ++read 2048/2048 bytes at offset 4298351616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298355712 ++read 2048/2048 bytes at offset 4298355712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298359808 ++read 2048/2048 bytes at offset 4298359808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298363904 ++read 2048/2048 bytes at offset 4298363904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298368000 ++read 2048/2048 bytes at offset 4298368000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298372096 ++read 2048/2048 bytes at offset 4298372096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298376192 ++read 2048/2048 bytes at offset 4298376192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298380288 ++read 2048/2048 bytes at offset 4298380288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298384384 ++read 2048/2048 bytes at offset 4298384384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298388480 ++read 2048/2048 bytes at offset 4298388480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298392576 ++read 2048/2048 bytes at offset 4298392576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298396672 ++read 2048/2048 bytes at offset 4298396672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298400768 ++read 2048/2048 bytes at offset 4298400768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298404864 ++read 2048/2048 bytes at offset 4298404864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298408960 ++read 2048/2048 bytes at offset 4298408960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298413056 ++read 2048/2048 bytes at offset 4298413056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298417152 ++read 2048/2048 bytes at offset 4298417152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298421248 ++read 2048/2048 bytes at offset 4298421248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298425344 ++read 2048/2048 bytes at offset 4298425344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298429440 ++read 2048/2048 bytes at offset 4298429440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298433536 ++read 2048/2048 bytes at offset 4298433536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298437632 ++read 2048/2048 bytes at offset 4298437632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298441728 ++read 2048/2048 bytes at offset 4298441728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298445824 ++read 2048/2048 bytes at offset 4298445824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298449920 ++read 2048/2048 bytes at offset 4298449920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298454016 ++read 2048/2048 bytes at offset 4298454016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298458112 ++read 2048/2048 bytes at offset 4298458112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298462208 ++read 2048/2048 bytes at offset 4298462208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298466304 ++read 2048/2048 bytes at offset 4298466304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298470400 ++read 2048/2048 bytes at offset 4298470400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298474496 ++read 2048/2048 bytes at offset 4298474496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298478592 ++read 2048/2048 bytes at offset 4298478592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298482688 ++read 2048/2048 bytes at offset 4298482688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298486784 ++read 2048/2048 bytes at offset 4298486784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298490880 ++read 2048/2048 bytes at offset 4298490880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298494976 ++read 2048/2048 bytes at offset 4298494976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298499072 ++read 2048/2048 bytes at offset 4298499072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298503168 ++read 2048/2048 bytes at offset 4298503168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298507264 ++read 2048/2048 bytes at offset 4298507264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298511360 ++read 2048/2048 bytes at offset 4298511360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298515456 ++read 2048/2048 bytes at offset 4298515456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298519552 ++read 2048/2048 bytes at offset 4298519552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298523648 ++read 2048/2048 bytes at offset 4298523648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298527744 ++read 2048/2048 bytes at offset 4298527744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298531840 ++read 2048/2048 bytes at offset 4298531840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298535936 ++read 2048/2048 bytes at offset 4298535936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298540032 ++read 2048/2048 bytes at offset 4298540032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298544128 ++read 2048/2048 bytes at offset 4298544128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298548224 ++read 2048/2048 bytes at offset 4298548224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298552320 ++read 2048/2048 bytes at offset 4298552320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298556416 ++read 2048/2048 bytes at offset 4298556416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298560512 ++read 2048/2048 bytes at offset 4298560512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298564608 ++read 2048/2048 bytes at offset 4298564608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298568704 ++read 2048/2048 bytes at offset 4298568704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298572800 ++read 2048/2048 bytes at offset 4298572800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298576896 ++read 2048/2048 bytes at offset 4298576896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298580992 ++read 2048/2048 bytes at offset 4298580992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298585088 ++read 2048/2048 bytes at offset 4298585088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298589184 ++read 2048/2048 bytes at offset 4298589184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298593280 ++read 2048/2048 bytes at offset 4298593280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298597376 ++read 2048/2048 bytes at offset 4298597376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298601472 ++read 2048/2048 bytes at offset 4298601472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298605568 ++read 2048/2048 bytes at offset 4298605568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298609664 ++read 2048/2048 bytes at offset 4298609664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298613760 ++read 2048/2048 bytes at offset 4298613760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298617856 ++read 2048/2048 bytes at offset 4298617856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298621952 ++read 2048/2048 bytes at offset 4298621952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298626048 ++read 2048/2048 bytes at offset 4298626048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298630144 ++read 2048/2048 bytes at offset 4298630144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298634240 ++read 2048/2048 bytes at offset 4298634240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298638336 ++read 2048/2048 bytes at offset 4298638336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298642432 ++read 2048/2048 bytes at offset 4298642432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298646528 ++read 2048/2048 bytes at offset 4298646528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298650624 ++read 2048/2048 bytes at offset 4298650624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298654720 ++read 2048/2048 bytes at offset 4298654720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298658816 ++read 2048/2048 bytes at offset 4298658816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298662912 ++read 2048/2048 bytes at offset 4298662912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298667008 ++read 2048/2048 bytes at offset 4298667008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298671104 ++read 2048/2048 bytes at offset 4298671104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298675200 ++read 2048/2048 bytes at offset 4298675200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298679296 ++read 2048/2048 bytes at offset 4298679296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298683392 ++read 2048/2048 bytes at offset 4298683392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298687488 ++read 2048/2048 bytes at offset 4298687488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298691584 ++read 2048/2048 bytes at offset 4298691584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298695680 ++read 2048/2048 bytes at offset 4298695680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298699776 ++read 2048/2048 bytes at offset 4298699776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298703872 ++read 2048/2048 bytes at offset 4298703872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298707968 ++read 2048/2048 bytes at offset 4298707968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298712064 ++read 2048/2048 bytes at offset 4298712064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298716160 ++read 2048/2048 bytes at offset 4298716160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298720256 ++read 2048/2048 bytes at offset 4298720256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298724352 ++read 2048/2048 bytes at offset 4298724352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298728448 ++read 2048/2048 bytes at offset 4298728448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298732544 ++read 2048/2048 bytes at offset 4298732544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298736640 ++read 2048/2048 bytes at offset 4298736640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298740736 ++read 2048/2048 bytes at offset 4298740736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298744832 ++read 2048/2048 bytes at offset 4298744832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298748928 ++read 2048/2048 bytes at offset 4298748928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298753024 ++read 2048/2048 bytes at offset 4298753024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298757120 ++read 2048/2048 bytes at offset 4298757120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298761216 ++read 2048/2048 bytes at offset 4298761216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298765312 ++read 2048/2048 bytes at offset 4298765312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298769408 ++read 2048/2048 bytes at offset 4298769408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298773504 ++read 2048/2048 bytes at offset 4298773504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298777600 ++read 2048/2048 bytes at offset 4298777600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298781696 ++read 2048/2048 bytes at offset 4298781696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298785792 ++read 2048/2048 bytes at offset 4298785792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298789888 ++read 2048/2048 bytes at offset 4298789888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298793984 ++read 2048/2048 bytes at offset 4298793984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298798080 ++read 2048/2048 bytes at offset 4298798080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298802176 ++read 2048/2048 bytes at offset 4298802176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298806272 ++read 2048/2048 bytes at offset 4298806272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298810368 ++read 2048/2048 bytes at offset 4298810368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298814464 ++read 2048/2048 bytes at offset 4298814464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298818560 ++read 2048/2048 bytes at offset 4298818560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298822656 ++read 2048/2048 bytes at offset 4298822656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298826752 ++read 2048/2048 bytes at offset 4298826752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298830848 ++read 2048/2048 bytes at offset 4298830848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298834944 ++read 2048/2048 bytes at offset 4298834944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298839040 ++read 2048/2048 bytes at offset 4298839040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298843136 ++read 2048/2048 bytes at offset 4298843136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298847232 ++read 2048/2048 bytes at offset 4298847232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298851328 ++read 2048/2048 bytes at offset 4298851328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298855424 ++read 2048/2048 bytes at offset 4298855424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298859520 ++read 2048/2048 bytes at offset 4298859520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298863616 ++read 2048/2048 bytes at offset 4298863616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298867712 ++read 2048/2048 bytes at offset 4298867712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298871808 ++read 2048/2048 bytes at offset 4298871808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298875904 ++read 2048/2048 bytes at offset 4298875904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298880000 ++read 2048/2048 bytes at offset 4298880000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298884096 ++read 2048/2048 bytes at offset 4298884096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298888192 ++read 2048/2048 bytes at offset 4298888192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298892288 ++read 2048/2048 bytes at offset 4298892288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298896384 ++read 2048/2048 bytes at offset 4298896384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298900480 ++read 2048/2048 bytes at offset 4298900480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298904576 ++read 2048/2048 bytes at offset 4298904576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298908672 ++read 2048/2048 bytes at offset 4298908672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298912768 ++read 2048/2048 bytes at offset 4298912768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298916864 ++read 2048/2048 bytes at offset 4298916864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298920960 ++read 2048/2048 bytes at offset 4298920960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298925056 ++read 2048/2048 bytes at offset 4298925056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298929152 ++read 2048/2048 bytes at offset 4298929152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298933248 ++read 2048/2048 bytes at offset 4298933248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298937344 ++read 2048/2048 bytes at offset 4298937344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298941440 ++read 2048/2048 bytes at offset 4298941440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298945536 ++read 2048/2048 bytes at offset 4298945536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298949632 ++read 2048/2048 bytes at offset 4298949632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298953728 ++read 2048/2048 bytes at offset 4298953728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298957824 ++read 2048/2048 bytes at offset 4298957824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298961920 ++read 2048/2048 bytes at offset 4298961920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298966016 ++read 2048/2048 bytes at offset 4298966016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298970112 ++read 2048/2048 bytes at offset 4298970112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298974208 ++read 2048/2048 bytes at offset 4298974208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298978304 ++read 2048/2048 bytes at offset 4298978304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298982400 ++read 2048/2048 bytes at offset 4298982400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298986496 ++read 2048/2048 bytes at offset 4298986496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298990592 ++read 2048/2048 bytes at offset 4298990592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298994688 ++read 2048/2048 bytes at offset 4298994688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298998784 ++read 2048/2048 bytes at offset 4298998784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299002880 ++read 2048/2048 bytes at offset 4299002880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299006976 ++read 2048/2048 bytes at offset 4299006976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299011072 ++read 2048/2048 bytes at offset 4299011072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299015168 ++read 2048/2048 bytes at offset 4299015168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299019264 ++read 2048/2048 bytes at offset 4299019264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299023360 ++read 2048/2048 bytes at offset 4299023360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299027456 ++read 2048/2048 bytes at offset 4299027456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299031552 ++read 2048/2048 bytes at offset 4299031552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299035648 ++read 2048/2048 bytes at offset 4299035648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299039744 ++read 2048/2048 bytes at offset 4299039744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299043840 ++read 2048/2048 bytes at offset 4299043840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299047936 ++read 2048/2048 bytes at offset 4299047936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299052032 ++read 2048/2048 bytes at offset 4299052032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299056128 ++read 2048/2048 bytes at offset 4299056128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299060224 ++read 2048/2048 bytes at offset 4299060224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299064320 ++read 2048/2048 bytes at offset 4299064320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299068416 ++read 2048/2048 bytes at offset 4299068416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299072512 ++read 2048/2048 bytes at offset 4299072512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299076608 ++read 2048/2048 bytes at offset 4299076608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299080704 ++read 2048/2048 bytes at offset 4299080704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299084800 ++read 2048/2048 bytes at offset 4299084800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299088896 ++read 2048/2048 bytes at offset 4299088896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299092992 ++read 2048/2048 bytes at offset 4299092992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299097088 ++read 2048/2048 bytes at offset 4299097088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299101184 ++read 2048/2048 bytes at offset 4299101184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299105280 ++read 2048/2048 bytes at offset 4299105280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299109376 ++read 2048/2048 bytes at offset 4299109376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299113472 ++read 2048/2048 bytes at offset 4299113472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299117568 ++read 2048/2048 bytes at offset 4299117568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299121664 ++read 2048/2048 bytes at offset 4299121664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299125760 ++read 2048/2048 bytes at offset 4299125760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299129856 ++read 2048/2048 bytes at offset 4299129856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299133952 ++read 2048/2048 bytes at offset 4299133952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299138048 ++read 2048/2048 bytes at offset 4299138048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299142144 ++read 2048/2048 bytes at offset 4299142144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299146240 ++read 2048/2048 bytes at offset 4299146240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299150336 ++read 2048/2048 bytes at offset 4299150336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299154432 ++read 2048/2048 bytes at offset 4299154432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299158528 ++read 2048/2048 bytes at offset 4299158528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 4 +-qemu-io> read 8192/8192 bytes at offset 4299163648 ++=== IO: pattern 4 ++read 8192/8192 bytes at offset 4299163648 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299175936 ++read 8192/8192 bytes at offset 4299175936 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299188224 ++read 8192/8192 bytes at offset 4299188224 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299200512 ++read 8192/8192 bytes at offset 4299200512 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299212800 ++read 8192/8192 bytes at offset 4299212800 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299225088 ++read 8192/8192 bytes at offset 4299225088 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299237376 ++read 8192/8192 bytes at offset 4299237376 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299249664 ++read 8192/8192 bytes at offset 4299249664 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299261952 ++read 8192/8192 bytes at offset 4299261952 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299274240 ++read 8192/8192 bytes at offset 4299274240 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299286528 ++read 8192/8192 bytes at offset 4299286528 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299298816 ++read 8192/8192 bytes at offset 4299298816 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299311104 ++read 8192/8192 bytes at offset 4299311104 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299323392 ++read 8192/8192 bytes at offset 4299323392 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299335680 ++read 8192/8192 bytes at offset 4299335680 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299347968 ++read 8192/8192 bytes at offset 4299347968 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299360256 ++read 8192/8192 bytes at offset 4299360256 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299372544 ++read 8192/8192 bytes at offset 4299372544 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299384832 ++read 8192/8192 bytes at offset 4299384832 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299397120 ++read 8192/8192 bytes at offset 4299397120 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299409408 ++read 8192/8192 bytes at offset 4299409408 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299421696 ++read 8192/8192 bytes at offset 4299421696 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299433984 ++read 8192/8192 bytes at offset 4299433984 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299446272 ++read 8192/8192 bytes at offset 4299446272 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299458560 ++read 8192/8192 bytes at offset 4299458560 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299470848 ++read 8192/8192 bytes at offset 4299470848 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299483136 ++read 8192/8192 bytes at offset 4299483136 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299495424 ++read 8192/8192 bytes at offset 4299495424 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299507712 ++read 8192/8192 bytes at offset 4299507712 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299520000 ++read 8192/8192 bytes at offset 4299520000 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299532288 ++read 8192/8192 bytes at offset 4299532288 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299544576 ++read 8192/8192 bytes at offset 4299544576 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299556864 ++read 8192/8192 bytes at offset 4299556864 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299569152 ++read 8192/8192 bytes at offset 4299569152 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299581440 ++read 8192/8192 bytes at offset 4299581440 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299593728 ++read 8192/8192 bytes at offset 4299593728 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299606016 ++read 8192/8192 bytes at offset 4299606016 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299618304 ++read 8192/8192 bytes at offset 4299618304 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299630592 ++read 8192/8192 bytes at offset 4299630592 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299642880 ++read 8192/8192 bytes at offset 4299642880 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299655168 ++read 8192/8192 bytes at offset 4299655168 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299667456 ++read 8192/8192 bytes at offset 4299667456 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299679744 ++read 8192/8192 bytes at offset 4299679744 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299692032 ++read 8192/8192 bytes at offset 4299692032 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299704320 ++read 8192/8192 bytes at offset 4299704320 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299716608 ++read 8192/8192 bytes at offset 4299716608 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299728896 ++read 8192/8192 bytes at offset 4299728896 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299741184 ++read 8192/8192 bytes at offset 4299741184 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299753472 ++read 8192/8192 bytes at offset 4299753472 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299765760 ++read 8192/8192 bytes at offset 4299765760 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299778048 ++read 8192/8192 bytes at offset 4299778048 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299790336 ++read 8192/8192 bytes at offset 4299790336 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299802624 ++read 8192/8192 bytes at offset 4299802624 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299814912 ++read 8192/8192 bytes at offset 4299814912 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299827200 ++read 8192/8192 bytes at offset 4299827200 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299839488 ++read 8192/8192 bytes at offset 4299839488 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299851776 ++read 8192/8192 bytes at offset 4299851776 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299864064 ++read 8192/8192 bytes at offset 4299864064 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299876352 ++read 8192/8192 bytes at offset 4299876352 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299888640 ++read 8192/8192 bytes at offset 4299888640 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299900928 ++read 8192/8192 bytes at offset 4299900928 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299913216 ++read 8192/8192 bytes at offset 4299913216 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299925504 ++read 8192/8192 bytes at offset 4299925504 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299937792 ++read 8192/8192 bytes at offset 4299937792 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 244 +-qemu-io> read 12288/12288 bytes at offset 4301252608 ++=== IO: pattern 244 ++read 12288/12288 bytes at offset 4301252608 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4303351808 ++read 12288/12288 bytes at offset 4303351808 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4305451008 ++read 12288/12288 bytes at offset 4305451008 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4307550208 ++read 12288/12288 bytes at offset 4307550208 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4309649408 ++read 12288/12288 bytes at offset 4309649408 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4311748608 ++read 12288/12288 bytes at offset 4311748608 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4313847808 ++read 12288/12288 bytes at offset 4313847808 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4315947008 ++read 12288/12288 bytes at offset 4315947008 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> No errors were found on the image. ++No errors were found on the image. + With snapshot test3, offset 0 + === IO: pattern 0 +-qemu-io> wrote 4096/4096 bytes at offset 0 ++wrote 4096/4096 bytes at offset 0 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4096 ++wrote 4096/4096 bytes at offset 4096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8192 ++wrote 4096/4096 bytes at offset 8192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 12288 ++wrote 4096/4096 bytes at offset 12288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 16384 ++wrote 4096/4096 bytes at offset 16384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 20480 ++wrote 4096/4096 bytes at offset 20480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 24576 ++wrote 4096/4096 bytes at offset 24576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 28672 ++wrote 4096/4096 bytes at offset 28672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 32768 ++wrote 4096/4096 bytes at offset 32768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 36864 ++wrote 4096/4096 bytes at offset 36864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 40960 ++wrote 4096/4096 bytes at offset 40960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 45056 ++wrote 4096/4096 bytes at offset 45056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 49152 ++wrote 4096/4096 bytes at offset 49152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 53248 ++wrote 4096/4096 bytes at offset 53248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 57344 ++wrote 4096/4096 bytes at offset 57344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 61440 ++wrote 4096/4096 bytes at offset 61440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 65536 ++wrote 4096/4096 bytes at offset 65536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 69632 ++wrote 4096/4096 bytes at offset 69632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 73728 ++wrote 4096/4096 bytes at offset 73728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 77824 ++wrote 4096/4096 bytes at offset 77824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 81920 ++wrote 4096/4096 bytes at offset 81920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 86016 ++wrote 4096/4096 bytes at offset 86016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 90112 ++wrote 4096/4096 bytes at offset 90112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 94208 ++wrote 4096/4096 bytes at offset 94208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 98304 ++wrote 4096/4096 bytes at offset 98304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 102400 ++wrote 4096/4096 bytes at offset 102400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 106496 ++wrote 4096/4096 bytes at offset 106496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 110592 ++wrote 4096/4096 bytes at offset 110592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 114688 ++wrote 4096/4096 bytes at offset 114688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 118784 ++wrote 4096/4096 bytes at offset 118784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 122880 ++wrote 4096/4096 bytes at offset 122880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 126976 ++wrote 4096/4096 bytes at offset 126976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 131072 ++wrote 4096/4096 bytes at offset 131072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 135168 ++wrote 4096/4096 bytes at offset 135168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 139264 ++wrote 4096/4096 bytes at offset 139264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 143360 ++wrote 4096/4096 bytes at offset 143360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 147456 ++wrote 4096/4096 bytes at offset 147456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 151552 ++wrote 4096/4096 bytes at offset 151552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 155648 ++wrote 4096/4096 bytes at offset 155648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 159744 ++wrote 4096/4096 bytes at offset 159744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 163840 ++wrote 4096/4096 bytes at offset 163840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 167936 ++wrote 4096/4096 bytes at offset 167936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 172032 ++wrote 4096/4096 bytes at offset 172032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 176128 ++wrote 4096/4096 bytes at offset 176128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 180224 ++wrote 4096/4096 bytes at offset 180224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 184320 ++wrote 4096/4096 bytes at offset 184320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 188416 ++wrote 4096/4096 bytes at offset 188416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 192512 ++wrote 4096/4096 bytes at offset 192512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 196608 ++wrote 4096/4096 bytes at offset 196608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 200704 ++wrote 4096/4096 bytes at offset 200704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 204800 ++wrote 4096/4096 bytes at offset 204800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 208896 ++wrote 4096/4096 bytes at offset 208896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 212992 ++wrote 4096/4096 bytes at offset 212992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 217088 ++wrote 4096/4096 bytes at offset 217088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 221184 ++wrote 4096/4096 bytes at offset 221184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 225280 ++wrote 4096/4096 bytes at offset 225280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 229376 ++wrote 4096/4096 bytes at offset 229376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 233472 ++wrote 4096/4096 bytes at offset 233472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 237568 ++wrote 4096/4096 bytes at offset 237568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 241664 ++wrote 4096/4096 bytes at offset 241664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 245760 ++wrote 4096/4096 bytes at offset 245760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 249856 ++wrote 4096/4096 bytes at offset 249856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 253952 ++wrote 4096/4096 bytes at offset 253952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 258048 ++wrote 4096/4096 bytes at offset 258048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 262144 ++wrote 4096/4096 bytes at offset 262144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 266240 ++wrote 4096/4096 bytes at offset 266240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 270336 ++wrote 4096/4096 bytes at offset 270336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 274432 ++wrote 4096/4096 bytes at offset 274432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 278528 ++wrote 4096/4096 bytes at offset 278528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 282624 ++wrote 4096/4096 bytes at offset 282624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 286720 ++wrote 4096/4096 bytes at offset 286720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 290816 ++wrote 4096/4096 bytes at offset 290816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 294912 ++wrote 4096/4096 bytes at offset 294912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 299008 ++wrote 4096/4096 bytes at offset 299008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 303104 ++wrote 4096/4096 bytes at offset 303104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 307200 ++wrote 4096/4096 bytes at offset 307200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 311296 ++wrote 4096/4096 bytes at offset 311296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 315392 ++wrote 4096/4096 bytes at offset 315392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 319488 ++wrote 4096/4096 bytes at offset 319488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 323584 ++wrote 4096/4096 bytes at offset 323584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 327680 ++wrote 4096/4096 bytes at offset 327680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 331776 ++wrote 4096/4096 bytes at offset 331776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 335872 ++wrote 4096/4096 bytes at offset 335872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 339968 ++wrote 4096/4096 bytes at offset 339968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 344064 ++wrote 4096/4096 bytes at offset 344064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 348160 ++wrote 4096/4096 bytes at offset 348160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 352256 ++wrote 4096/4096 bytes at offset 352256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 356352 ++wrote 4096/4096 bytes at offset 356352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 360448 ++wrote 4096/4096 bytes at offset 360448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 364544 ++wrote 4096/4096 bytes at offset 364544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 368640 ++wrote 4096/4096 bytes at offset 368640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 372736 ++wrote 4096/4096 bytes at offset 372736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 376832 ++wrote 4096/4096 bytes at offset 376832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 380928 ++wrote 4096/4096 bytes at offset 380928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 385024 ++wrote 4096/4096 bytes at offset 385024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 389120 ++wrote 4096/4096 bytes at offset 389120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 393216 ++wrote 4096/4096 bytes at offset 393216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 397312 ++wrote 4096/4096 bytes at offset 397312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 401408 ++wrote 4096/4096 bytes at offset 401408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 405504 ++wrote 4096/4096 bytes at offset 405504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 409600 ++wrote 4096/4096 bytes at offset 409600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 413696 ++wrote 4096/4096 bytes at offset 413696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 417792 ++wrote 4096/4096 bytes at offset 417792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 421888 ++wrote 4096/4096 bytes at offset 421888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 425984 ++wrote 4096/4096 bytes at offset 425984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 430080 ++wrote 4096/4096 bytes at offset 430080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 434176 ++wrote 4096/4096 bytes at offset 434176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 438272 ++wrote 4096/4096 bytes at offset 438272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 442368 ++wrote 4096/4096 bytes at offset 442368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 446464 ++wrote 4096/4096 bytes at offset 446464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 450560 ++wrote 4096/4096 bytes at offset 450560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 454656 ++wrote 4096/4096 bytes at offset 454656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 458752 ++wrote 4096/4096 bytes at offset 458752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 462848 ++wrote 4096/4096 bytes at offset 462848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 466944 ++wrote 4096/4096 bytes at offset 466944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 471040 ++wrote 4096/4096 bytes at offset 471040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 475136 ++wrote 4096/4096 bytes at offset 475136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 479232 ++wrote 4096/4096 bytes at offset 479232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 483328 ++wrote 4096/4096 bytes at offset 483328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 487424 ++wrote 4096/4096 bytes at offset 487424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 491520 ++wrote 4096/4096 bytes at offset 491520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 495616 ++wrote 4096/4096 bytes at offset 495616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 499712 ++wrote 4096/4096 bytes at offset 499712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 503808 ++wrote 4096/4096 bytes at offset 503808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 507904 ++wrote 4096/4096 bytes at offset 507904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 512000 ++wrote 4096/4096 bytes at offset 512000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 516096 ++wrote 4096/4096 bytes at offset 516096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 520192 ++wrote 4096/4096 bytes at offset 520192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 524288 ++wrote 4096/4096 bytes at offset 524288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 528384 ++wrote 4096/4096 bytes at offset 528384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 532480 ++wrote 4096/4096 bytes at offset 532480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 536576 ++wrote 4096/4096 bytes at offset 536576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 540672 ++wrote 4096/4096 bytes at offset 540672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 544768 ++wrote 4096/4096 bytes at offset 544768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 548864 ++wrote 4096/4096 bytes at offset 548864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 552960 ++wrote 4096/4096 bytes at offset 552960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 557056 ++wrote 4096/4096 bytes at offset 557056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 561152 ++wrote 4096/4096 bytes at offset 561152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 565248 ++wrote 4096/4096 bytes at offset 565248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 569344 ++wrote 4096/4096 bytes at offset 569344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 573440 ++wrote 4096/4096 bytes at offset 573440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 577536 ++wrote 4096/4096 bytes at offset 577536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 581632 ++wrote 4096/4096 bytes at offset 581632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 585728 ++wrote 4096/4096 bytes at offset 585728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 589824 ++wrote 4096/4096 bytes at offset 589824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 593920 ++wrote 4096/4096 bytes at offset 593920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 598016 ++wrote 4096/4096 bytes at offset 598016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 602112 ++wrote 4096/4096 bytes at offset 602112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 606208 ++wrote 4096/4096 bytes at offset 606208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 610304 ++wrote 4096/4096 bytes at offset 610304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 614400 ++wrote 4096/4096 bytes at offset 614400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 618496 ++wrote 4096/4096 bytes at offset 618496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 622592 ++wrote 4096/4096 bytes at offset 622592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 626688 ++wrote 4096/4096 bytes at offset 626688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 630784 ++wrote 4096/4096 bytes at offset 630784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 634880 ++wrote 4096/4096 bytes at offset 634880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 638976 ++wrote 4096/4096 bytes at offset 638976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 643072 ++wrote 4096/4096 bytes at offset 643072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 647168 ++wrote 4096/4096 bytes at offset 647168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 651264 ++wrote 4096/4096 bytes at offset 651264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 655360 ++wrote 4096/4096 bytes at offset 655360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 659456 ++wrote 4096/4096 bytes at offset 659456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 663552 ++wrote 4096/4096 bytes at offset 663552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 667648 ++wrote 4096/4096 bytes at offset 667648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 671744 ++wrote 4096/4096 bytes at offset 671744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 675840 ++wrote 4096/4096 bytes at offset 675840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 679936 ++wrote 4096/4096 bytes at offset 679936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 684032 ++wrote 4096/4096 bytes at offset 684032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 688128 ++wrote 4096/4096 bytes at offset 688128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 692224 ++wrote 4096/4096 bytes at offset 692224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 696320 ++wrote 4096/4096 bytes at offset 696320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 700416 ++wrote 4096/4096 bytes at offset 700416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 704512 ++wrote 4096/4096 bytes at offset 704512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 708608 ++wrote 4096/4096 bytes at offset 708608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 712704 ++wrote 4096/4096 bytes at offset 712704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 716800 ++wrote 4096/4096 bytes at offset 716800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 720896 ++wrote 4096/4096 bytes at offset 720896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 724992 ++wrote 4096/4096 bytes at offset 724992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 729088 ++wrote 4096/4096 bytes at offset 729088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 733184 ++wrote 4096/4096 bytes at offset 733184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 737280 ++wrote 4096/4096 bytes at offset 737280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 741376 ++wrote 4096/4096 bytes at offset 741376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 745472 ++wrote 4096/4096 bytes at offset 745472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 749568 ++wrote 4096/4096 bytes at offset 749568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 753664 ++wrote 4096/4096 bytes at offset 753664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 757760 ++wrote 4096/4096 bytes at offset 757760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 761856 ++wrote 4096/4096 bytes at offset 761856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 765952 ++wrote 4096/4096 bytes at offset 765952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 770048 ++wrote 4096/4096 bytes at offset 770048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 774144 ++wrote 4096/4096 bytes at offset 774144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 778240 ++wrote 4096/4096 bytes at offset 778240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 782336 ++wrote 4096/4096 bytes at offset 782336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 786432 ++wrote 4096/4096 bytes at offset 786432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 790528 ++wrote 4096/4096 bytes at offset 790528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 794624 ++wrote 4096/4096 bytes at offset 794624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 798720 ++wrote 4096/4096 bytes at offset 798720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 802816 ++wrote 4096/4096 bytes at offset 802816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 806912 ++wrote 4096/4096 bytes at offset 806912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 811008 ++wrote 4096/4096 bytes at offset 811008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 815104 ++wrote 4096/4096 bytes at offset 815104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 819200 ++wrote 4096/4096 bytes at offset 819200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 823296 ++wrote 4096/4096 bytes at offset 823296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 827392 ++wrote 4096/4096 bytes at offset 827392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 831488 ++wrote 4096/4096 bytes at offset 831488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 835584 ++wrote 4096/4096 bytes at offset 835584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 839680 ++wrote 4096/4096 bytes at offset 839680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 843776 ++wrote 4096/4096 bytes at offset 843776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 847872 ++wrote 4096/4096 bytes at offset 847872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 851968 ++wrote 4096/4096 bytes at offset 851968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 856064 ++wrote 4096/4096 bytes at offset 856064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 860160 ++wrote 4096/4096 bytes at offset 860160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 864256 ++wrote 4096/4096 bytes at offset 864256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 868352 ++wrote 4096/4096 bytes at offset 868352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 872448 ++wrote 4096/4096 bytes at offset 872448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 876544 ++wrote 4096/4096 bytes at offset 876544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 880640 ++wrote 4096/4096 bytes at offset 880640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 884736 ++wrote 4096/4096 bytes at offset 884736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 888832 ++wrote 4096/4096 bytes at offset 888832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 892928 ++wrote 4096/4096 bytes at offset 892928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 897024 ++wrote 4096/4096 bytes at offset 897024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 901120 ++wrote 4096/4096 bytes at offset 901120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 905216 ++wrote 4096/4096 bytes at offset 905216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 909312 ++wrote 4096/4096 bytes at offset 909312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 913408 ++wrote 4096/4096 bytes at offset 913408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 917504 ++wrote 4096/4096 bytes at offset 917504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 921600 ++wrote 4096/4096 bytes at offset 921600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 925696 ++wrote 4096/4096 bytes at offset 925696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 929792 ++wrote 4096/4096 bytes at offset 929792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 933888 ++wrote 4096/4096 bytes at offset 933888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 937984 ++wrote 4096/4096 bytes at offset 937984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 942080 ++wrote 4096/4096 bytes at offset 942080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 946176 ++wrote 4096/4096 bytes at offset 946176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 950272 ++wrote 4096/4096 bytes at offset 950272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 954368 ++wrote 4096/4096 bytes at offset 954368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 958464 ++wrote 4096/4096 bytes at offset 958464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 962560 ++wrote 4096/4096 bytes at offset 962560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 966656 ++wrote 4096/4096 bytes at offset 966656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 970752 ++wrote 4096/4096 bytes at offset 970752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 974848 ++wrote 4096/4096 bytes at offset 974848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 978944 ++wrote 4096/4096 bytes at offset 978944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 983040 ++wrote 4096/4096 bytes at offset 983040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 987136 ++wrote 4096/4096 bytes at offset 987136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 991232 ++wrote 4096/4096 bytes at offset 991232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 995328 ++wrote 4096/4096 bytes at offset 995328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 999424 ++wrote 4096/4096 bytes at offset 999424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1003520 ++wrote 4096/4096 bytes at offset 1003520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1007616 ++wrote 4096/4096 bytes at offset 1007616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1011712 ++wrote 4096/4096 bytes at offset 1011712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1015808 ++wrote 4096/4096 bytes at offset 1015808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1019904 ++wrote 4096/4096 bytes at offset 1019904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1024000 ++wrote 4096/4096 bytes at offset 1024000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1028096 ++wrote 4096/4096 bytes at offset 1028096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1032192 ++wrote 4096/4096 bytes at offset 1032192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1036288 ++wrote 4096/4096 bytes at offset 1036288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1040384 ++wrote 4096/4096 bytes at offset 1040384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1044480 ++wrote 4096/4096 bytes at offset 1044480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 4 +-qemu-io> wrote 2048/2048 bytes at offset 1050624 ++=== IO: pattern 4 ++wrote 2048/2048 bytes at offset 1050624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1054720 ++wrote 2048/2048 bytes at offset 1054720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1058816 ++wrote 2048/2048 bytes at offset 1058816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1062912 ++wrote 2048/2048 bytes at offset 1062912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1067008 ++wrote 2048/2048 bytes at offset 1067008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1071104 ++wrote 2048/2048 bytes at offset 1071104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1075200 ++wrote 2048/2048 bytes at offset 1075200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1079296 ++wrote 2048/2048 bytes at offset 1079296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1083392 ++wrote 2048/2048 bytes at offset 1083392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1087488 ++wrote 2048/2048 bytes at offset 1087488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1091584 ++wrote 2048/2048 bytes at offset 1091584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1095680 ++wrote 2048/2048 bytes at offset 1095680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1099776 ++wrote 2048/2048 bytes at offset 1099776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1103872 ++wrote 2048/2048 bytes at offset 1103872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1107968 ++wrote 2048/2048 bytes at offset 1107968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1112064 ++wrote 2048/2048 bytes at offset 1112064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1116160 ++wrote 2048/2048 bytes at offset 1116160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1120256 ++wrote 2048/2048 bytes at offset 1120256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1124352 ++wrote 2048/2048 bytes at offset 1124352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1128448 ++wrote 2048/2048 bytes at offset 1128448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1132544 ++wrote 2048/2048 bytes at offset 1132544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1136640 ++wrote 2048/2048 bytes at offset 1136640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1140736 ++wrote 2048/2048 bytes at offset 1140736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1144832 ++wrote 2048/2048 bytes at offset 1144832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1148928 ++wrote 2048/2048 bytes at offset 1148928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1153024 ++wrote 2048/2048 bytes at offset 1153024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1157120 ++wrote 2048/2048 bytes at offset 1157120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1161216 ++wrote 2048/2048 bytes at offset 1161216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1165312 ++wrote 2048/2048 bytes at offset 1165312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1169408 ++wrote 2048/2048 bytes at offset 1169408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1173504 ++wrote 2048/2048 bytes at offset 1173504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1177600 ++wrote 2048/2048 bytes at offset 1177600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1181696 ++wrote 2048/2048 bytes at offset 1181696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1185792 ++wrote 2048/2048 bytes at offset 1185792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1189888 ++wrote 2048/2048 bytes at offset 1189888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1193984 ++wrote 2048/2048 bytes at offset 1193984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1198080 ++wrote 2048/2048 bytes at offset 1198080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1202176 ++wrote 2048/2048 bytes at offset 1202176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1206272 ++wrote 2048/2048 bytes at offset 1206272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1210368 ++wrote 2048/2048 bytes at offset 1210368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1214464 ++wrote 2048/2048 bytes at offset 1214464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1218560 ++wrote 2048/2048 bytes at offset 1218560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1222656 ++wrote 2048/2048 bytes at offset 1222656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1226752 ++wrote 2048/2048 bytes at offset 1226752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1230848 ++wrote 2048/2048 bytes at offset 1230848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1234944 ++wrote 2048/2048 bytes at offset 1234944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1239040 ++wrote 2048/2048 bytes at offset 1239040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1243136 ++wrote 2048/2048 bytes at offset 1243136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1247232 ++wrote 2048/2048 bytes at offset 1247232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1251328 ++wrote 2048/2048 bytes at offset 1251328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1255424 ++wrote 2048/2048 bytes at offset 1255424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1259520 ++wrote 2048/2048 bytes at offset 1259520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1263616 ++wrote 2048/2048 bytes at offset 1263616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1267712 ++wrote 2048/2048 bytes at offset 1267712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1271808 ++wrote 2048/2048 bytes at offset 1271808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1275904 ++wrote 2048/2048 bytes at offset 1275904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1280000 ++wrote 2048/2048 bytes at offset 1280000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1284096 ++wrote 2048/2048 bytes at offset 1284096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1288192 ++wrote 2048/2048 bytes at offset 1288192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1292288 ++wrote 2048/2048 bytes at offset 1292288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1296384 ++wrote 2048/2048 bytes at offset 1296384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1300480 ++wrote 2048/2048 bytes at offset 1300480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1304576 ++wrote 2048/2048 bytes at offset 1304576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1308672 ++wrote 2048/2048 bytes at offset 1308672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1312768 ++wrote 2048/2048 bytes at offset 1312768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1316864 ++wrote 2048/2048 bytes at offset 1316864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1320960 ++wrote 2048/2048 bytes at offset 1320960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1325056 ++wrote 2048/2048 bytes at offset 1325056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1329152 ++wrote 2048/2048 bytes at offset 1329152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1333248 ++wrote 2048/2048 bytes at offset 1333248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1337344 ++wrote 2048/2048 bytes at offset 1337344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1341440 ++wrote 2048/2048 bytes at offset 1341440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1345536 ++wrote 2048/2048 bytes at offset 1345536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1349632 ++wrote 2048/2048 bytes at offset 1349632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1353728 ++wrote 2048/2048 bytes at offset 1353728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1357824 ++wrote 2048/2048 bytes at offset 1357824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1361920 ++wrote 2048/2048 bytes at offset 1361920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1366016 ++wrote 2048/2048 bytes at offset 1366016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1370112 ++wrote 2048/2048 bytes at offset 1370112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1374208 ++wrote 2048/2048 bytes at offset 1374208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1378304 ++wrote 2048/2048 bytes at offset 1378304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1382400 ++wrote 2048/2048 bytes at offset 1382400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1386496 ++wrote 2048/2048 bytes at offset 1386496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1390592 ++wrote 2048/2048 bytes at offset 1390592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1394688 ++wrote 2048/2048 bytes at offset 1394688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1398784 ++wrote 2048/2048 bytes at offset 1398784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1402880 ++wrote 2048/2048 bytes at offset 1402880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1406976 ++wrote 2048/2048 bytes at offset 1406976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1411072 ++wrote 2048/2048 bytes at offset 1411072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1415168 ++wrote 2048/2048 bytes at offset 1415168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1419264 ++wrote 2048/2048 bytes at offset 1419264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1423360 ++wrote 2048/2048 bytes at offset 1423360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1427456 ++wrote 2048/2048 bytes at offset 1427456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1431552 ++wrote 2048/2048 bytes at offset 1431552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1435648 ++wrote 2048/2048 bytes at offset 1435648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1439744 ++wrote 2048/2048 bytes at offset 1439744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1443840 ++wrote 2048/2048 bytes at offset 1443840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1447936 ++wrote 2048/2048 bytes at offset 1447936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1452032 ++wrote 2048/2048 bytes at offset 1452032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1456128 ++wrote 2048/2048 bytes at offset 1456128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1460224 ++wrote 2048/2048 bytes at offset 1460224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1464320 ++wrote 2048/2048 bytes at offset 1464320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1468416 ++wrote 2048/2048 bytes at offset 1468416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1472512 ++wrote 2048/2048 bytes at offset 1472512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1476608 ++wrote 2048/2048 bytes at offset 1476608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1480704 ++wrote 2048/2048 bytes at offset 1480704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1484800 ++wrote 2048/2048 bytes at offset 1484800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1488896 ++wrote 2048/2048 bytes at offset 1488896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1492992 ++wrote 2048/2048 bytes at offset 1492992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1497088 ++wrote 2048/2048 bytes at offset 1497088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1501184 ++wrote 2048/2048 bytes at offset 1501184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1505280 ++wrote 2048/2048 bytes at offset 1505280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1509376 ++wrote 2048/2048 bytes at offset 1509376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1513472 ++wrote 2048/2048 bytes at offset 1513472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1517568 ++wrote 2048/2048 bytes at offset 1517568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1521664 ++wrote 2048/2048 bytes at offset 1521664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1525760 ++wrote 2048/2048 bytes at offset 1525760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1529856 ++wrote 2048/2048 bytes at offset 1529856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1533952 ++wrote 2048/2048 bytes at offset 1533952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1538048 ++wrote 2048/2048 bytes at offset 1538048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1542144 ++wrote 2048/2048 bytes at offset 1542144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1546240 ++wrote 2048/2048 bytes at offset 1546240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1550336 ++wrote 2048/2048 bytes at offset 1550336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1554432 ++wrote 2048/2048 bytes at offset 1554432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1558528 ++wrote 2048/2048 bytes at offset 1558528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1562624 ++wrote 2048/2048 bytes at offset 1562624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1566720 ++wrote 2048/2048 bytes at offset 1566720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1570816 ++wrote 2048/2048 bytes at offset 1570816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1574912 ++wrote 2048/2048 bytes at offset 1574912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1579008 ++wrote 2048/2048 bytes at offset 1579008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1583104 ++wrote 2048/2048 bytes at offset 1583104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1587200 ++wrote 2048/2048 bytes at offset 1587200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1591296 ++wrote 2048/2048 bytes at offset 1591296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1595392 ++wrote 2048/2048 bytes at offset 1595392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1599488 ++wrote 2048/2048 bytes at offset 1599488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1603584 ++wrote 2048/2048 bytes at offset 1603584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1607680 ++wrote 2048/2048 bytes at offset 1607680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1611776 ++wrote 2048/2048 bytes at offset 1611776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1615872 ++wrote 2048/2048 bytes at offset 1615872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1619968 ++wrote 2048/2048 bytes at offset 1619968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1624064 ++wrote 2048/2048 bytes at offset 1624064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1628160 ++wrote 2048/2048 bytes at offset 1628160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1632256 ++wrote 2048/2048 bytes at offset 1632256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1636352 ++wrote 2048/2048 bytes at offset 1636352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1640448 ++wrote 2048/2048 bytes at offset 1640448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1644544 ++wrote 2048/2048 bytes at offset 1644544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1648640 ++wrote 2048/2048 bytes at offset 1648640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1652736 ++wrote 2048/2048 bytes at offset 1652736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1656832 ++wrote 2048/2048 bytes at offset 1656832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1660928 ++wrote 2048/2048 bytes at offset 1660928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1665024 ++wrote 2048/2048 bytes at offset 1665024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1669120 ++wrote 2048/2048 bytes at offset 1669120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1673216 ++wrote 2048/2048 bytes at offset 1673216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1677312 ++wrote 2048/2048 bytes at offset 1677312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1681408 ++wrote 2048/2048 bytes at offset 1681408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1685504 ++wrote 2048/2048 bytes at offset 1685504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1689600 ++wrote 2048/2048 bytes at offset 1689600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1693696 ++wrote 2048/2048 bytes at offset 1693696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1697792 ++wrote 2048/2048 bytes at offset 1697792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1701888 ++wrote 2048/2048 bytes at offset 1701888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1705984 ++wrote 2048/2048 bytes at offset 1705984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1710080 ++wrote 2048/2048 bytes at offset 1710080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1714176 ++wrote 2048/2048 bytes at offset 1714176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1718272 ++wrote 2048/2048 bytes at offset 1718272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1722368 ++wrote 2048/2048 bytes at offset 1722368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1726464 ++wrote 2048/2048 bytes at offset 1726464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1730560 ++wrote 2048/2048 bytes at offset 1730560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1734656 ++wrote 2048/2048 bytes at offset 1734656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1738752 ++wrote 2048/2048 bytes at offset 1738752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1742848 ++wrote 2048/2048 bytes at offset 1742848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1746944 ++wrote 2048/2048 bytes at offset 1746944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1751040 ++wrote 2048/2048 bytes at offset 1751040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1755136 ++wrote 2048/2048 bytes at offset 1755136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1759232 ++wrote 2048/2048 bytes at offset 1759232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1763328 ++wrote 2048/2048 bytes at offset 1763328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1767424 ++wrote 2048/2048 bytes at offset 1767424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1771520 ++wrote 2048/2048 bytes at offset 1771520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1775616 ++wrote 2048/2048 bytes at offset 1775616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1779712 ++wrote 2048/2048 bytes at offset 1779712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1783808 ++wrote 2048/2048 bytes at offset 1783808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1787904 ++wrote 2048/2048 bytes at offset 1787904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1792000 ++wrote 2048/2048 bytes at offset 1792000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1796096 ++wrote 2048/2048 bytes at offset 1796096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1800192 ++wrote 2048/2048 bytes at offset 1800192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1804288 ++wrote 2048/2048 bytes at offset 1804288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1808384 ++wrote 2048/2048 bytes at offset 1808384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1812480 ++wrote 2048/2048 bytes at offset 1812480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1816576 ++wrote 2048/2048 bytes at offset 1816576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1820672 ++wrote 2048/2048 bytes at offset 1820672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1824768 ++wrote 2048/2048 bytes at offset 1824768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1828864 ++wrote 2048/2048 bytes at offset 1828864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1832960 ++wrote 2048/2048 bytes at offset 1832960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1837056 ++wrote 2048/2048 bytes at offset 1837056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1841152 ++wrote 2048/2048 bytes at offset 1841152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1845248 ++wrote 2048/2048 bytes at offset 1845248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1849344 ++wrote 2048/2048 bytes at offset 1849344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1853440 ++wrote 2048/2048 bytes at offset 1853440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1857536 ++wrote 2048/2048 bytes at offset 1857536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1861632 ++wrote 2048/2048 bytes at offset 1861632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1865728 ++wrote 2048/2048 bytes at offset 1865728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1869824 ++wrote 2048/2048 bytes at offset 1869824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1873920 ++wrote 2048/2048 bytes at offset 1873920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1878016 ++wrote 2048/2048 bytes at offset 1878016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1882112 ++wrote 2048/2048 bytes at offset 1882112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1886208 ++wrote 2048/2048 bytes at offset 1886208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1890304 ++wrote 2048/2048 bytes at offset 1890304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1894400 ++wrote 2048/2048 bytes at offset 1894400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1898496 ++wrote 2048/2048 bytes at offset 1898496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1902592 ++wrote 2048/2048 bytes at offset 1902592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1906688 ++wrote 2048/2048 bytes at offset 1906688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1910784 ++wrote 2048/2048 bytes at offset 1910784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1914880 ++wrote 2048/2048 bytes at offset 1914880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1918976 ++wrote 2048/2048 bytes at offset 1918976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1923072 ++wrote 2048/2048 bytes at offset 1923072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1927168 ++wrote 2048/2048 bytes at offset 1927168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1931264 ++wrote 2048/2048 bytes at offset 1931264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1935360 ++wrote 2048/2048 bytes at offset 1935360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1939456 ++wrote 2048/2048 bytes at offset 1939456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1943552 ++wrote 2048/2048 bytes at offset 1943552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1947648 ++wrote 2048/2048 bytes at offset 1947648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1951744 ++wrote 2048/2048 bytes at offset 1951744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1955840 ++wrote 2048/2048 bytes at offset 1955840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1959936 ++wrote 2048/2048 bytes at offset 1959936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1964032 ++wrote 2048/2048 bytes at offset 1964032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1968128 ++wrote 2048/2048 bytes at offset 1968128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1972224 ++wrote 2048/2048 bytes at offset 1972224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1976320 ++wrote 2048/2048 bytes at offset 1976320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1980416 ++wrote 2048/2048 bytes at offset 1980416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1984512 ++wrote 2048/2048 bytes at offset 1984512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1988608 ++wrote 2048/2048 bytes at offset 1988608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1992704 ++wrote 2048/2048 bytes at offset 1992704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1996800 ++wrote 2048/2048 bytes at offset 1996800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2000896 ++wrote 2048/2048 bytes at offset 2000896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2004992 ++wrote 2048/2048 bytes at offset 2004992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2009088 ++wrote 2048/2048 bytes at offset 2009088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2013184 ++wrote 2048/2048 bytes at offset 2013184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2017280 ++wrote 2048/2048 bytes at offset 2017280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2021376 ++wrote 2048/2048 bytes at offset 2021376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2025472 ++wrote 2048/2048 bytes at offset 2025472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2029568 ++wrote 2048/2048 bytes at offset 2029568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2033664 ++wrote 2048/2048 bytes at offset 2033664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2037760 ++wrote 2048/2048 bytes at offset 2037760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2041856 ++wrote 2048/2048 bytes at offset 2041856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2045952 ++wrote 2048/2048 bytes at offset 2045952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2050048 ++wrote 2048/2048 bytes at offset 2050048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2054144 ++wrote 2048/2048 bytes at offset 2054144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2058240 ++wrote 2048/2048 bytes at offset 2058240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2062336 ++wrote 2048/2048 bytes at offset 2062336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2066432 ++wrote 2048/2048 bytes at offset 2066432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2070528 ++wrote 2048/2048 bytes at offset 2070528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2074624 ++wrote 2048/2048 bytes at offset 2074624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2078720 ++wrote 2048/2048 bytes at offset 2078720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2082816 ++wrote 2048/2048 bytes at offset 2082816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2086912 ++wrote 2048/2048 bytes at offset 2086912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2091008 ++wrote 2048/2048 bytes at offset 2091008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2095104 ++wrote 2048/2048 bytes at offset 2095104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> wrote 2048/2048 bytes at offset 2097152 ++=== IO: pattern 0 ++wrote 2048/2048 bytes at offset 2097152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2101248 ++wrote 2048/2048 bytes at offset 2101248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2105344 ++wrote 2048/2048 bytes at offset 2105344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2109440 ++wrote 2048/2048 bytes at offset 2109440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2113536 ++wrote 2048/2048 bytes at offset 2113536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2117632 ++wrote 2048/2048 bytes at offset 2117632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2121728 ++wrote 2048/2048 bytes at offset 2121728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2125824 ++wrote 2048/2048 bytes at offset 2125824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2129920 ++wrote 2048/2048 bytes at offset 2129920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2134016 ++wrote 2048/2048 bytes at offset 2134016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2138112 ++wrote 2048/2048 bytes at offset 2138112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2142208 ++wrote 2048/2048 bytes at offset 2142208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2146304 ++wrote 2048/2048 bytes at offset 2146304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2150400 ++wrote 2048/2048 bytes at offset 2150400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2154496 ++wrote 2048/2048 bytes at offset 2154496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2158592 ++wrote 2048/2048 bytes at offset 2158592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2162688 ++wrote 2048/2048 bytes at offset 2162688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2166784 ++wrote 2048/2048 bytes at offset 2166784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2170880 ++wrote 2048/2048 bytes at offset 2170880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2174976 ++wrote 2048/2048 bytes at offset 2174976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2179072 ++wrote 2048/2048 bytes at offset 2179072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2183168 ++wrote 2048/2048 bytes at offset 2183168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2187264 ++wrote 2048/2048 bytes at offset 2187264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2191360 ++wrote 2048/2048 bytes at offset 2191360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2195456 ++wrote 2048/2048 bytes at offset 2195456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2199552 ++wrote 2048/2048 bytes at offset 2199552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2203648 ++wrote 2048/2048 bytes at offset 2203648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2207744 ++wrote 2048/2048 bytes at offset 2207744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2211840 ++wrote 2048/2048 bytes at offset 2211840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2215936 ++wrote 2048/2048 bytes at offset 2215936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2220032 ++wrote 2048/2048 bytes at offset 2220032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2224128 ++wrote 2048/2048 bytes at offset 2224128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2228224 ++wrote 2048/2048 bytes at offset 2228224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2232320 ++wrote 2048/2048 bytes at offset 2232320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2236416 ++wrote 2048/2048 bytes at offset 2236416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2240512 ++wrote 2048/2048 bytes at offset 2240512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2244608 ++wrote 2048/2048 bytes at offset 2244608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2248704 ++wrote 2048/2048 bytes at offset 2248704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2252800 ++wrote 2048/2048 bytes at offset 2252800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2256896 ++wrote 2048/2048 bytes at offset 2256896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2260992 ++wrote 2048/2048 bytes at offset 2260992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2265088 ++wrote 2048/2048 bytes at offset 2265088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2269184 ++wrote 2048/2048 bytes at offset 2269184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2273280 ++wrote 2048/2048 bytes at offset 2273280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2277376 ++wrote 2048/2048 bytes at offset 2277376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2281472 ++wrote 2048/2048 bytes at offset 2281472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2285568 ++wrote 2048/2048 bytes at offset 2285568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2289664 ++wrote 2048/2048 bytes at offset 2289664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2293760 ++wrote 2048/2048 bytes at offset 2293760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2297856 ++wrote 2048/2048 bytes at offset 2297856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2301952 ++wrote 2048/2048 bytes at offset 2301952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2306048 ++wrote 2048/2048 bytes at offset 2306048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2310144 ++wrote 2048/2048 bytes at offset 2310144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2314240 ++wrote 2048/2048 bytes at offset 2314240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2318336 ++wrote 2048/2048 bytes at offset 2318336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2322432 ++wrote 2048/2048 bytes at offset 2322432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2326528 ++wrote 2048/2048 bytes at offset 2326528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2330624 ++wrote 2048/2048 bytes at offset 2330624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2334720 ++wrote 2048/2048 bytes at offset 2334720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2338816 ++wrote 2048/2048 bytes at offset 2338816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2342912 ++wrote 2048/2048 bytes at offset 2342912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2347008 ++wrote 2048/2048 bytes at offset 2347008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2351104 ++wrote 2048/2048 bytes at offset 2351104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2355200 ++wrote 2048/2048 bytes at offset 2355200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2359296 ++wrote 2048/2048 bytes at offset 2359296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2363392 ++wrote 2048/2048 bytes at offset 2363392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2367488 ++wrote 2048/2048 bytes at offset 2367488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2371584 ++wrote 2048/2048 bytes at offset 2371584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2375680 ++wrote 2048/2048 bytes at offset 2375680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2379776 ++wrote 2048/2048 bytes at offset 2379776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2383872 ++wrote 2048/2048 bytes at offset 2383872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2387968 ++wrote 2048/2048 bytes at offset 2387968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2392064 ++wrote 2048/2048 bytes at offset 2392064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2396160 ++wrote 2048/2048 bytes at offset 2396160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2400256 ++wrote 2048/2048 bytes at offset 2400256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2404352 ++wrote 2048/2048 bytes at offset 2404352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2408448 ++wrote 2048/2048 bytes at offset 2408448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2412544 ++wrote 2048/2048 bytes at offset 2412544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2416640 ++wrote 2048/2048 bytes at offset 2416640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2420736 ++wrote 2048/2048 bytes at offset 2420736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2424832 ++wrote 2048/2048 bytes at offset 2424832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2428928 ++wrote 2048/2048 bytes at offset 2428928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2433024 ++wrote 2048/2048 bytes at offset 2433024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2437120 ++wrote 2048/2048 bytes at offset 2437120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2441216 ++wrote 2048/2048 bytes at offset 2441216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2445312 ++wrote 2048/2048 bytes at offset 2445312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2449408 ++wrote 2048/2048 bytes at offset 2449408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2453504 ++wrote 2048/2048 bytes at offset 2453504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2457600 ++wrote 2048/2048 bytes at offset 2457600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2461696 ++wrote 2048/2048 bytes at offset 2461696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2465792 ++wrote 2048/2048 bytes at offset 2465792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2469888 ++wrote 2048/2048 bytes at offset 2469888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2473984 ++wrote 2048/2048 bytes at offset 2473984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2478080 ++wrote 2048/2048 bytes at offset 2478080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2482176 ++wrote 2048/2048 bytes at offset 2482176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2486272 ++wrote 2048/2048 bytes at offset 2486272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2490368 ++wrote 2048/2048 bytes at offset 2490368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2494464 ++wrote 2048/2048 bytes at offset 2494464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2498560 ++wrote 2048/2048 bytes at offset 2498560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2502656 ++wrote 2048/2048 bytes at offset 2502656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2506752 ++wrote 2048/2048 bytes at offset 2506752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2510848 ++wrote 2048/2048 bytes at offset 2510848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2514944 ++wrote 2048/2048 bytes at offset 2514944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2519040 ++wrote 2048/2048 bytes at offset 2519040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2523136 ++wrote 2048/2048 bytes at offset 2523136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2527232 ++wrote 2048/2048 bytes at offset 2527232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2531328 ++wrote 2048/2048 bytes at offset 2531328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2535424 ++wrote 2048/2048 bytes at offset 2535424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2539520 ++wrote 2048/2048 bytes at offset 2539520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2543616 ++wrote 2048/2048 bytes at offset 2543616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2547712 ++wrote 2048/2048 bytes at offset 2547712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2551808 ++wrote 2048/2048 bytes at offset 2551808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2555904 ++wrote 2048/2048 bytes at offset 2555904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2560000 ++wrote 2048/2048 bytes at offset 2560000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2564096 ++wrote 2048/2048 bytes at offset 2564096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2568192 ++wrote 2048/2048 bytes at offset 2568192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2572288 ++wrote 2048/2048 bytes at offset 2572288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2576384 ++wrote 2048/2048 bytes at offset 2576384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2580480 ++wrote 2048/2048 bytes at offset 2580480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2584576 ++wrote 2048/2048 bytes at offset 2584576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2588672 ++wrote 2048/2048 bytes at offset 2588672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2592768 ++wrote 2048/2048 bytes at offset 2592768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2596864 ++wrote 2048/2048 bytes at offset 2596864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2600960 ++wrote 2048/2048 bytes at offset 2600960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2605056 ++wrote 2048/2048 bytes at offset 2605056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2609152 ++wrote 2048/2048 bytes at offset 2609152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2613248 ++wrote 2048/2048 bytes at offset 2613248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2617344 ++wrote 2048/2048 bytes at offset 2617344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2621440 ++wrote 2048/2048 bytes at offset 2621440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2625536 ++wrote 2048/2048 bytes at offset 2625536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2629632 ++wrote 2048/2048 bytes at offset 2629632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2633728 ++wrote 2048/2048 bytes at offset 2633728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2637824 ++wrote 2048/2048 bytes at offset 2637824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2641920 ++wrote 2048/2048 bytes at offset 2641920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2646016 ++wrote 2048/2048 bytes at offset 2646016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2650112 ++wrote 2048/2048 bytes at offset 2650112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2654208 ++wrote 2048/2048 bytes at offset 2654208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2658304 ++wrote 2048/2048 bytes at offset 2658304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2662400 ++wrote 2048/2048 bytes at offset 2662400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2666496 ++wrote 2048/2048 bytes at offset 2666496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2670592 ++wrote 2048/2048 bytes at offset 2670592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2674688 ++wrote 2048/2048 bytes at offset 2674688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2678784 ++wrote 2048/2048 bytes at offset 2678784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2682880 ++wrote 2048/2048 bytes at offset 2682880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2686976 ++wrote 2048/2048 bytes at offset 2686976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2691072 ++wrote 2048/2048 bytes at offset 2691072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2695168 ++wrote 2048/2048 bytes at offset 2695168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2699264 ++wrote 2048/2048 bytes at offset 2699264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2703360 ++wrote 2048/2048 bytes at offset 2703360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2707456 ++wrote 2048/2048 bytes at offset 2707456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2711552 ++wrote 2048/2048 bytes at offset 2711552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2715648 ++wrote 2048/2048 bytes at offset 2715648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2719744 ++wrote 2048/2048 bytes at offset 2719744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2723840 ++wrote 2048/2048 bytes at offset 2723840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2727936 ++wrote 2048/2048 bytes at offset 2727936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2732032 ++wrote 2048/2048 bytes at offset 2732032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2736128 ++wrote 2048/2048 bytes at offset 2736128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2740224 ++wrote 2048/2048 bytes at offset 2740224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2744320 ++wrote 2048/2048 bytes at offset 2744320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2748416 ++wrote 2048/2048 bytes at offset 2748416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2752512 ++wrote 2048/2048 bytes at offset 2752512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2756608 ++wrote 2048/2048 bytes at offset 2756608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2760704 ++wrote 2048/2048 bytes at offset 2760704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2764800 ++wrote 2048/2048 bytes at offset 2764800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2768896 ++wrote 2048/2048 bytes at offset 2768896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2772992 ++wrote 2048/2048 bytes at offset 2772992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2777088 ++wrote 2048/2048 bytes at offset 2777088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2781184 ++wrote 2048/2048 bytes at offset 2781184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2785280 ++wrote 2048/2048 bytes at offset 2785280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2789376 ++wrote 2048/2048 bytes at offset 2789376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2793472 ++wrote 2048/2048 bytes at offset 2793472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2797568 ++wrote 2048/2048 bytes at offset 2797568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2801664 ++wrote 2048/2048 bytes at offset 2801664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2805760 ++wrote 2048/2048 bytes at offset 2805760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2809856 ++wrote 2048/2048 bytes at offset 2809856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2813952 ++wrote 2048/2048 bytes at offset 2813952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2818048 ++wrote 2048/2048 bytes at offset 2818048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2822144 ++wrote 2048/2048 bytes at offset 2822144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2826240 ++wrote 2048/2048 bytes at offset 2826240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2830336 ++wrote 2048/2048 bytes at offset 2830336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2834432 ++wrote 2048/2048 bytes at offset 2834432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2838528 ++wrote 2048/2048 bytes at offset 2838528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2842624 ++wrote 2048/2048 bytes at offset 2842624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2846720 ++wrote 2048/2048 bytes at offset 2846720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2850816 ++wrote 2048/2048 bytes at offset 2850816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2854912 ++wrote 2048/2048 bytes at offset 2854912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2859008 ++wrote 2048/2048 bytes at offset 2859008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2863104 ++wrote 2048/2048 bytes at offset 2863104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2867200 ++wrote 2048/2048 bytes at offset 2867200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2871296 ++wrote 2048/2048 bytes at offset 2871296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2875392 ++wrote 2048/2048 bytes at offset 2875392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2879488 ++wrote 2048/2048 bytes at offset 2879488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2883584 ++wrote 2048/2048 bytes at offset 2883584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2887680 ++wrote 2048/2048 bytes at offset 2887680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2891776 ++wrote 2048/2048 bytes at offset 2891776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2895872 ++wrote 2048/2048 bytes at offset 2895872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2899968 ++wrote 2048/2048 bytes at offset 2899968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2904064 ++wrote 2048/2048 bytes at offset 2904064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2908160 ++wrote 2048/2048 bytes at offset 2908160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2912256 ++wrote 2048/2048 bytes at offset 2912256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2916352 ++wrote 2048/2048 bytes at offset 2916352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2920448 ++wrote 2048/2048 bytes at offset 2920448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2924544 ++wrote 2048/2048 bytes at offset 2924544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2928640 ++wrote 2048/2048 bytes at offset 2928640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2932736 ++wrote 2048/2048 bytes at offset 2932736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2936832 ++wrote 2048/2048 bytes at offset 2936832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2940928 ++wrote 2048/2048 bytes at offset 2940928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2945024 ++wrote 2048/2048 bytes at offset 2945024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2949120 ++wrote 2048/2048 bytes at offset 2949120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2953216 ++wrote 2048/2048 bytes at offset 2953216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2957312 ++wrote 2048/2048 bytes at offset 2957312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2961408 ++wrote 2048/2048 bytes at offset 2961408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2965504 ++wrote 2048/2048 bytes at offset 2965504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2969600 ++wrote 2048/2048 bytes at offset 2969600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2973696 ++wrote 2048/2048 bytes at offset 2973696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2977792 ++wrote 2048/2048 bytes at offset 2977792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2981888 ++wrote 2048/2048 bytes at offset 2981888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2985984 ++wrote 2048/2048 bytes at offset 2985984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2990080 ++wrote 2048/2048 bytes at offset 2990080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2994176 ++wrote 2048/2048 bytes at offset 2994176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2998272 ++wrote 2048/2048 bytes at offset 2998272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3002368 ++wrote 2048/2048 bytes at offset 3002368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3006464 ++wrote 2048/2048 bytes at offset 3006464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3010560 ++wrote 2048/2048 bytes at offset 3010560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3014656 ++wrote 2048/2048 bytes at offset 3014656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3018752 ++wrote 2048/2048 bytes at offset 3018752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3022848 ++wrote 2048/2048 bytes at offset 3022848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3026944 ++wrote 2048/2048 bytes at offset 3026944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3031040 ++wrote 2048/2048 bytes at offset 3031040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3035136 ++wrote 2048/2048 bytes at offset 3035136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3039232 ++wrote 2048/2048 bytes at offset 3039232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3043328 ++wrote 2048/2048 bytes at offset 3043328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3047424 ++wrote 2048/2048 bytes at offset 3047424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3051520 ++wrote 2048/2048 bytes at offset 3051520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3055616 ++wrote 2048/2048 bytes at offset 3055616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3059712 ++wrote 2048/2048 bytes at offset 3059712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3063808 ++wrote 2048/2048 bytes at offset 3063808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3067904 ++wrote 2048/2048 bytes at offset 3067904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3072000 ++wrote 2048/2048 bytes at offset 3072000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3076096 ++wrote 2048/2048 bytes at offset 3076096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3080192 ++wrote 2048/2048 bytes at offset 3080192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3084288 ++wrote 2048/2048 bytes at offset 3084288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3088384 ++wrote 2048/2048 bytes at offset 3088384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3092480 ++wrote 2048/2048 bytes at offset 3092480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3096576 ++wrote 2048/2048 bytes at offset 3096576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3100672 ++wrote 2048/2048 bytes at offset 3100672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3104768 ++wrote 2048/2048 bytes at offset 3104768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3108864 ++wrote 2048/2048 bytes at offset 3108864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3112960 ++wrote 2048/2048 bytes at offset 3112960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3117056 ++wrote 2048/2048 bytes at offset 3117056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3121152 ++wrote 2048/2048 bytes at offset 3121152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3125248 ++wrote 2048/2048 bytes at offset 3125248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3129344 ++wrote 2048/2048 bytes at offset 3129344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3133440 ++wrote 2048/2048 bytes at offset 3133440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3137536 ++wrote 2048/2048 bytes at offset 3137536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3141632 ++wrote 2048/2048 bytes at offset 3141632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 2 +-qemu-io> wrote 2048/2048 bytes at offset 3146752 ++=== IO: pattern 2 ++wrote 2048/2048 bytes at offset 3146752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3150848 ++wrote 2048/2048 bytes at offset 3150848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3154944 ++wrote 2048/2048 bytes at offset 3154944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3159040 ++wrote 2048/2048 bytes at offset 3159040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3163136 ++wrote 2048/2048 bytes at offset 3163136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3167232 ++wrote 2048/2048 bytes at offset 3167232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3171328 ++wrote 2048/2048 bytes at offset 3171328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3175424 ++wrote 2048/2048 bytes at offset 3175424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3179520 ++wrote 2048/2048 bytes at offset 3179520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3183616 ++wrote 2048/2048 bytes at offset 3183616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3187712 ++wrote 2048/2048 bytes at offset 3187712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3191808 ++wrote 2048/2048 bytes at offset 3191808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3195904 ++wrote 2048/2048 bytes at offset 3195904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3200000 ++wrote 2048/2048 bytes at offset 3200000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3204096 ++wrote 2048/2048 bytes at offset 3204096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3208192 ++wrote 2048/2048 bytes at offset 3208192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3212288 ++wrote 2048/2048 bytes at offset 3212288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3216384 ++wrote 2048/2048 bytes at offset 3216384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3220480 ++wrote 2048/2048 bytes at offset 3220480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3224576 ++wrote 2048/2048 bytes at offset 3224576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3228672 ++wrote 2048/2048 bytes at offset 3228672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3232768 ++wrote 2048/2048 bytes at offset 3232768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3236864 ++wrote 2048/2048 bytes at offset 3236864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3240960 ++wrote 2048/2048 bytes at offset 3240960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3245056 ++wrote 2048/2048 bytes at offset 3245056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3249152 ++wrote 2048/2048 bytes at offset 3249152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3253248 ++wrote 2048/2048 bytes at offset 3253248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3257344 ++wrote 2048/2048 bytes at offset 3257344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3261440 ++wrote 2048/2048 bytes at offset 3261440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3265536 ++wrote 2048/2048 bytes at offset 3265536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3269632 ++wrote 2048/2048 bytes at offset 3269632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3273728 ++wrote 2048/2048 bytes at offset 3273728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3277824 ++wrote 2048/2048 bytes at offset 3277824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3281920 ++wrote 2048/2048 bytes at offset 3281920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3286016 ++wrote 2048/2048 bytes at offset 3286016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3290112 ++wrote 2048/2048 bytes at offset 3290112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3294208 ++wrote 2048/2048 bytes at offset 3294208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3298304 ++wrote 2048/2048 bytes at offset 3298304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3302400 ++wrote 2048/2048 bytes at offset 3302400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3306496 ++wrote 2048/2048 bytes at offset 3306496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3310592 ++wrote 2048/2048 bytes at offset 3310592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3314688 ++wrote 2048/2048 bytes at offset 3314688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3318784 ++wrote 2048/2048 bytes at offset 3318784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3322880 ++wrote 2048/2048 bytes at offset 3322880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3326976 ++wrote 2048/2048 bytes at offset 3326976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3331072 ++wrote 2048/2048 bytes at offset 3331072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3335168 ++wrote 2048/2048 bytes at offset 3335168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3339264 ++wrote 2048/2048 bytes at offset 3339264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3343360 ++wrote 2048/2048 bytes at offset 3343360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3347456 ++wrote 2048/2048 bytes at offset 3347456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3351552 ++wrote 2048/2048 bytes at offset 3351552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3355648 ++wrote 2048/2048 bytes at offset 3355648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3359744 ++wrote 2048/2048 bytes at offset 3359744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3363840 ++wrote 2048/2048 bytes at offset 3363840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3367936 ++wrote 2048/2048 bytes at offset 3367936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3372032 ++wrote 2048/2048 bytes at offset 3372032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3376128 ++wrote 2048/2048 bytes at offset 3376128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3380224 ++wrote 2048/2048 bytes at offset 3380224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3384320 ++wrote 2048/2048 bytes at offset 3384320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3388416 ++wrote 2048/2048 bytes at offset 3388416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3392512 ++wrote 2048/2048 bytes at offset 3392512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3396608 ++wrote 2048/2048 bytes at offset 3396608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3400704 ++wrote 2048/2048 bytes at offset 3400704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3404800 ++wrote 2048/2048 bytes at offset 3404800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3408896 ++wrote 2048/2048 bytes at offset 3408896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3412992 ++wrote 2048/2048 bytes at offset 3412992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3417088 ++wrote 2048/2048 bytes at offset 3417088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3421184 ++wrote 2048/2048 bytes at offset 3421184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3425280 ++wrote 2048/2048 bytes at offset 3425280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3429376 ++wrote 2048/2048 bytes at offset 3429376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3433472 ++wrote 2048/2048 bytes at offset 3433472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3437568 ++wrote 2048/2048 bytes at offset 3437568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3441664 ++wrote 2048/2048 bytes at offset 3441664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3445760 ++wrote 2048/2048 bytes at offset 3445760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3449856 ++wrote 2048/2048 bytes at offset 3449856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3453952 ++wrote 2048/2048 bytes at offset 3453952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3458048 ++wrote 2048/2048 bytes at offset 3458048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3462144 ++wrote 2048/2048 bytes at offset 3462144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3466240 ++wrote 2048/2048 bytes at offset 3466240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3470336 ++wrote 2048/2048 bytes at offset 3470336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3474432 ++wrote 2048/2048 bytes at offset 3474432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3478528 ++wrote 2048/2048 bytes at offset 3478528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3482624 ++wrote 2048/2048 bytes at offset 3482624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3486720 ++wrote 2048/2048 bytes at offset 3486720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3490816 ++wrote 2048/2048 bytes at offset 3490816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3494912 ++wrote 2048/2048 bytes at offset 3494912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3499008 ++wrote 2048/2048 bytes at offset 3499008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3503104 ++wrote 2048/2048 bytes at offset 3503104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3507200 ++wrote 2048/2048 bytes at offset 3507200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3511296 ++wrote 2048/2048 bytes at offset 3511296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3515392 ++wrote 2048/2048 bytes at offset 3515392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3519488 ++wrote 2048/2048 bytes at offset 3519488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3523584 ++wrote 2048/2048 bytes at offset 3523584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3527680 ++wrote 2048/2048 bytes at offset 3527680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3531776 ++wrote 2048/2048 bytes at offset 3531776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3535872 ++wrote 2048/2048 bytes at offset 3535872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3539968 ++wrote 2048/2048 bytes at offset 3539968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3544064 ++wrote 2048/2048 bytes at offset 3544064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3548160 ++wrote 2048/2048 bytes at offset 3548160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3552256 ++wrote 2048/2048 bytes at offset 3552256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3556352 ++wrote 2048/2048 bytes at offset 3556352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3560448 ++wrote 2048/2048 bytes at offset 3560448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3564544 ++wrote 2048/2048 bytes at offset 3564544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3568640 ++wrote 2048/2048 bytes at offset 3568640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3572736 ++wrote 2048/2048 bytes at offset 3572736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3576832 ++wrote 2048/2048 bytes at offset 3576832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3580928 ++wrote 2048/2048 bytes at offset 3580928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3585024 ++wrote 2048/2048 bytes at offset 3585024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3589120 ++wrote 2048/2048 bytes at offset 3589120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3593216 ++wrote 2048/2048 bytes at offset 3593216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3597312 ++wrote 2048/2048 bytes at offset 3597312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3601408 ++wrote 2048/2048 bytes at offset 3601408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3605504 ++wrote 2048/2048 bytes at offset 3605504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3609600 ++wrote 2048/2048 bytes at offset 3609600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3613696 ++wrote 2048/2048 bytes at offset 3613696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3617792 ++wrote 2048/2048 bytes at offset 3617792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3621888 ++wrote 2048/2048 bytes at offset 3621888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3625984 ++wrote 2048/2048 bytes at offset 3625984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3630080 ++wrote 2048/2048 bytes at offset 3630080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3634176 ++wrote 2048/2048 bytes at offset 3634176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3638272 ++wrote 2048/2048 bytes at offset 3638272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3642368 ++wrote 2048/2048 bytes at offset 3642368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3646464 ++wrote 2048/2048 bytes at offset 3646464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3650560 ++wrote 2048/2048 bytes at offset 3650560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3654656 ++wrote 2048/2048 bytes at offset 3654656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3658752 ++wrote 2048/2048 bytes at offset 3658752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3662848 ++wrote 2048/2048 bytes at offset 3662848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3666944 ++wrote 2048/2048 bytes at offset 3666944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3671040 ++wrote 2048/2048 bytes at offset 3671040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3675136 ++wrote 2048/2048 bytes at offset 3675136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3679232 ++wrote 2048/2048 bytes at offset 3679232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3683328 ++wrote 2048/2048 bytes at offset 3683328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3687424 ++wrote 2048/2048 bytes at offset 3687424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3691520 ++wrote 2048/2048 bytes at offset 3691520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3695616 ++wrote 2048/2048 bytes at offset 3695616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3699712 ++wrote 2048/2048 bytes at offset 3699712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3703808 ++wrote 2048/2048 bytes at offset 3703808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3707904 ++wrote 2048/2048 bytes at offset 3707904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3712000 ++wrote 2048/2048 bytes at offset 3712000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3716096 ++wrote 2048/2048 bytes at offset 3716096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3720192 ++wrote 2048/2048 bytes at offset 3720192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3724288 ++wrote 2048/2048 bytes at offset 3724288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3728384 ++wrote 2048/2048 bytes at offset 3728384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3732480 ++wrote 2048/2048 bytes at offset 3732480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3736576 ++wrote 2048/2048 bytes at offset 3736576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3740672 ++wrote 2048/2048 bytes at offset 3740672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3744768 ++wrote 2048/2048 bytes at offset 3744768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3748864 ++wrote 2048/2048 bytes at offset 3748864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3752960 ++wrote 2048/2048 bytes at offset 3752960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3757056 ++wrote 2048/2048 bytes at offset 3757056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3761152 ++wrote 2048/2048 bytes at offset 3761152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3765248 ++wrote 2048/2048 bytes at offset 3765248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3769344 ++wrote 2048/2048 bytes at offset 3769344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3773440 ++wrote 2048/2048 bytes at offset 3773440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3777536 ++wrote 2048/2048 bytes at offset 3777536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3781632 ++wrote 2048/2048 bytes at offset 3781632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3785728 ++wrote 2048/2048 bytes at offset 3785728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3789824 ++wrote 2048/2048 bytes at offset 3789824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3793920 ++wrote 2048/2048 bytes at offset 3793920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3798016 ++wrote 2048/2048 bytes at offset 3798016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3802112 ++wrote 2048/2048 bytes at offset 3802112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3806208 ++wrote 2048/2048 bytes at offset 3806208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3810304 ++wrote 2048/2048 bytes at offset 3810304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3814400 ++wrote 2048/2048 bytes at offset 3814400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3818496 ++wrote 2048/2048 bytes at offset 3818496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3822592 ++wrote 2048/2048 bytes at offset 3822592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3826688 ++wrote 2048/2048 bytes at offset 3826688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3830784 ++wrote 2048/2048 bytes at offset 3830784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3834880 ++wrote 2048/2048 bytes at offset 3834880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3838976 ++wrote 2048/2048 bytes at offset 3838976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3843072 ++wrote 2048/2048 bytes at offset 3843072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3847168 ++wrote 2048/2048 bytes at offset 3847168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3851264 ++wrote 2048/2048 bytes at offset 3851264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3855360 ++wrote 2048/2048 bytes at offset 3855360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3859456 ++wrote 2048/2048 bytes at offset 3859456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3863552 ++wrote 2048/2048 bytes at offset 3863552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3867648 ++wrote 2048/2048 bytes at offset 3867648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3871744 ++wrote 2048/2048 bytes at offset 3871744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3875840 ++wrote 2048/2048 bytes at offset 3875840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3879936 ++wrote 2048/2048 bytes at offset 3879936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3884032 ++wrote 2048/2048 bytes at offset 3884032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3888128 ++wrote 2048/2048 bytes at offset 3888128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3892224 ++wrote 2048/2048 bytes at offset 3892224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3896320 ++wrote 2048/2048 bytes at offset 3896320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3900416 ++wrote 2048/2048 bytes at offset 3900416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3904512 ++wrote 2048/2048 bytes at offset 3904512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3908608 ++wrote 2048/2048 bytes at offset 3908608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3912704 ++wrote 2048/2048 bytes at offset 3912704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3916800 ++wrote 2048/2048 bytes at offset 3916800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3920896 ++wrote 2048/2048 bytes at offset 3920896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3924992 ++wrote 2048/2048 bytes at offset 3924992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3929088 ++wrote 2048/2048 bytes at offset 3929088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3933184 ++wrote 2048/2048 bytes at offset 3933184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3937280 ++wrote 2048/2048 bytes at offset 3937280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3941376 ++wrote 2048/2048 bytes at offset 3941376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3945472 ++wrote 2048/2048 bytes at offset 3945472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3949568 ++wrote 2048/2048 bytes at offset 3949568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3953664 ++wrote 2048/2048 bytes at offset 3953664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3957760 ++wrote 2048/2048 bytes at offset 3957760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3961856 ++wrote 2048/2048 bytes at offset 3961856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3965952 ++wrote 2048/2048 bytes at offset 3965952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3970048 ++wrote 2048/2048 bytes at offset 3970048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3974144 ++wrote 2048/2048 bytes at offset 3974144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3978240 ++wrote 2048/2048 bytes at offset 3978240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3982336 ++wrote 2048/2048 bytes at offset 3982336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3986432 ++wrote 2048/2048 bytes at offset 3986432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3990528 ++wrote 2048/2048 bytes at offset 3990528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3994624 ++wrote 2048/2048 bytes at offset 3994624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3998720 ++wrote 2048/2048 bytes at offset 3998720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4002816 ++wrote 2048/2048 bytes at offset 4002816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4006912 ++wrote 2048/2048 bytes at offset 4006912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4011008 ++wrote 2048/2048 bytes at offset 4011008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4015104 ++wrote 2048/2048 bytes at offset 4015104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4019200 ++wrote 2048/2048 bytes at offset 4019200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4023296 ++wrote 2048/2048 bytes at offset 4023296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4027392 ++wrote 2048/2048 bytes at offset 4027392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4031488 ++wrote 2048/2048 bytes at offset 4031488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4035584 ++wrote 2048/2048 bytes at offset 4035584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4039680 ++wrote 2048/2048 bytes at offset 4039680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4043776 ++wrote 2048/2048 bytes at offset 4043776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4047872 ++wrote 2048/2048 bytes at offset 4047872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4051968 ++wrote 2048/2048 bytes at offset 4051968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4056064 ++wrote 2048/2048 bytes at offset 4056064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4060160 ++wrote 2048/2048 bytes at offset 4060160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4064256 ++wrote 2048/2048 bytes at offset 4064256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4068352 ++wrote 2048/2048 bytes at offset 4068352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4072448 ++wrote 2048/2048 bytes at offset 4072448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4076544 ++wrote 2048/2048 bytes at offset 4076544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4080640 ++wrote 2048/2048 bytes at offset 4080640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4084736 ++wrote 2048/2048 bytes at offset 4084736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4088832 ++wrote 2048/2048 bytes at offset 4088832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4092928 ++wrote 2048/2048 bytes at offset 4092928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4097024 ++wrote 2048/2048 bytes at offset 4097024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4101120 ++wrote 2048/2048 bytes at offset 4101120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4105216 ++wrote 2048/2048 bytes at offset 4105216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4109312 ++wrote 2048/2048 bytes at offset 4109312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4113408 ++wrote 2048/2048 bytes at offset 4113408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4117504 ++wrote 2048/2048 bytes at offset 4117504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4121600 ++wrote 2048/2048 bytes at offset 4121600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4125696 ++wrote 2048/2048 bytes at offset 4125696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4129792 ++wrote 2048/2048 bytes at offset 4129792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4133888 ++wrote 2048/2048 bytes at offset 4133888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4137984 ++wrote 2048/2048 bytes at offset 4137984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4142080 ++wrote 2048/2048 bytes at offset 4142080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4146176 ++wrote 2048/2048 bytes at offset 4146176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4150272 ++wrote 2048/2048 bytes at offset 4150272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4154368 ++wrote 2048/2048 bytes at offset 4154368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4158464 ++wrote 2048/2048 bytes at offset 4158464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4162560 ++wrote 2048/2048 bytes at offset 4162560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4166656 ++wrote 2048/2048 bytes at offset 4166656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4170752 ++wrote 2048/2048 bytes at offset 4170752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4174848 ++wrote 2048/2048 bytes at offset 4174848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4178944 ++wrote 2048/2048 bytes at offset 4178944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4183040 ++wrote 2048/2048 bytes at offset 4183040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4187136 ++wrote 2048/2048 bytes at offset 4187136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4191232 ++wrote 2048/2048 bytes at offset 4191232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 4 +-qemu-io> wrote 8192/8192 bytes at offset 4196352 ++=== IO: pattern 4 ++wrote 8192/8192 bytes at offset 4196352 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4208640 ++wrote 8192/8192 bytes at offset 4208640 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4220928 ++wrote 8192/8192 bytes at offset 4220928 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4233216 ++wrote 8192/8192 bytes at offset 4233216 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4245504 ++wrote 8192/8192 bytes at offset 4245504 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4257792 ++wrote 8192/8192 bytes at offset 4257792 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4270080 ++wrote 8192/8192 bytes at offset 4270080 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4282368 ++wrote 8192/8192 bytes at offset 4282368 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4294656 ++wrote 8192/8192 bytes at offset 4294656 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4306944 ++wrote 8192/8192 bytes at offset 4306944 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4319232 ++wrote 8192/8192 bytes at offset 4319232 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4331520 ++wrote 8192/8192 bytes at offset 4331520 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4343808 ++wrote 8192/8192 bytes at offset 4343808 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4356096 ++wrote 8192/8192 bytes at offset 4356096 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4368384 ++wrote 8192/8192 bytes at offset 4368384 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4380672 ++wrote 8192/8192 bytes at offset 4380672 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4392960 ++wrote 8192/8192 bytes at offset 4392960 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4405248 ++wrote 8192/8192 bytes at offset 4405248 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4417536 ++wrote 8192/8192 bytes at offset 4417536 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4429824 ++wrote 8192/8192 bytes at offset 4429824 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4442112 ++wrote 8192/8192 bytes at offset 4442112 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4454400 ++wrote 8192/8192 bytes at offset 4454400 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4466688 ++wrote 8192/8192 bytes at offset 4466688 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4478976 ++wrote 8192/8192 bytes at offset 4478976 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4491264 ++wrote 8192/8192 bytes at offset 4491264 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4503552 ++wrote 8192/8192 bytes at offset 4503552 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4515840 ++wrote 8192/8192 bytes at offset 4515840 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4528128 ++wrote 8192/8192 bytes at offset 4528128 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4540416 ++wrote 8192/8192 bytes at offset 4540416 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4552704 ++wrote 8192/8192 bytes at offset 4552704 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4564992 ++wrote 8192/8192 bytes at offset 4564992 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4577280 ++wrote 8192/8192 bytes at offset 4577280 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4589568 ++wrote 8192/8192 bytes at offset 4589568 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4601856 ++wrote 8192/8192 bytes at offset 4601856 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4614144 ++wrote 8192/8192 bytes at offset 4614144 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4626432 ++wrote 8192/8192 bytes at offset 4626432 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4638720 ++wrote 8192/8192 bytes at offset 4638720 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4651008 ++wrote 8192/8192 bytes at offset 4651008 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4663296 ++wrote 8192/8192 bytes at offset 4663296 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4675584 ++wrote 8192/8192 bytes at offset 4675584 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4687872 ++wrote 8192/8192 bytes at offset 4687872 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4700160 ++wrote 8192/8192 bytes at offset 4700160 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4712448 ++wrote 8192/8192 bytes at offset 4712448 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4724736 ++wrote 8192/8192 bytes at offset 4724736 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4737024 ++wrote 8192/8192 bytes at offset 4737024 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4749312 ++wrote 8192/8192 bytes at offset 4749312 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4761600 ++wrote 8192/8192 bytes at offset 4761600 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4773888 ++wrote 8192/8192 bytes at offset 4773888 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4786176 ++wrote 8192/8192 bytes at offset 4786176 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4798464 ++wrote 8192/8192 bytes at offset 4798464 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4810752 ++wrote 8192/8192 bytes at offset 4810752 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4823040 ++wrote 8192/8192 bytes at offset 4823040 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4835328 ++wrote 8192/8192 bytes at offset 4835328 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4847616 ++wrote 8192/8192 bytes at offset 4847616 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4859904 ++wrote 8192/8192 bytes at offset 4859904 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4872192 ++wrote 8192/8192 bytes at offset 4872192 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4884480 ++wrote 8192/8192 bytes at offset 4884480 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4896768 ++wrote 8192/8192 bytes at offset 4896768 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4909056 ++wrote 8192/8192 bytes at offset 4909056 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4921344 ++wrote 8192/8192 bytes at offset 4921344 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4933632 ++wrote 8192/8192 bytes at offset 4933632 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4945920 ++wrote 8192/8192 bytes at offset 4945920 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4958208 ++wrote 8192/8192 bytes at offset 4958208 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4970496 ++wrote 8192/8192 bytes at offset 4970496 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 244 +-qemu-io> wrote 12288/12288 bytes at offset 6285312 ++=== IO: pattern 244 ++wrote 12288/12288 bytes at offset 6285312 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 8384512 ++wrote 12288/12288 bytes at offset 8384512 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 10483712 ++wrote 12288/12288 bytes at offset 10483712 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 12582912 ++wrote 12288/12288 bytes at offset 12582912 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 14682112 ++wrote 12288/12288 bytes at offset 14682112 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 16781312 ++wrote 12288/12288 bytes at offset 16781312 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 18880512 ++wrote 12288/12288 bytes at offset 18880512 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 20979712 ++wrote 12288/12288 bytes at offset 20979712 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> read 4096/4096 bytes at offset 0 ++=== IO: pattern 0 ++read 4096/4096 bytes at offset 0 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4096 ++read 4096/4096 bytes at offset 4096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 8192 ++read 4096/4096 bytes at offset 8192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 12288 ++read 4096/4096 bytes at offset 12288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 16384 ++read 4096/4096 bytes at offset 16384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 20480 ++read 4096/4096 bytes at offset 20480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 24576 ++read 4096/4096 bytes at offset 24576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 28672 ++read 4096/4096 bytes at offset 28672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 32768 ++read 4096/4096 bytes at offset 32768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 36864 ++read 4096/4096 bytes at offset 36864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 40960 ++read 4096/4096 bytes at offset 40960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 45056 ++read 4096/4096 bytes at offset 45056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 49152 ++read 4096/4096 bytes at offset 49152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 53248 ++read 4096/4096 bytes at offset 53248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 57344 ++read 4096/4096 bytes at offset 57344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 61440 ++read 4096/4096 bytes at offset 61440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 65536 ++read 4096/4096 bytes at offset 65536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 69632 ++read 4096/4096 bytes at offset 69632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 73728 ++read 4096/4096 bytes at offset 73728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 77824 ++read 4096/4096 bytes at offset 77824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 81920 ++read 4096/4096 bytes at offset 81920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 86016 ++read 4096/4096 bytes at offset 86016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 90112 ++read 4096/4096 bytes at offset 90112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 94208 ++read 4096/4096 bytes at offset 94208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 98304 ++read 4096/4096 bytes at offset 98304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 102400 ++read 4096/4096 bytes at offset 102400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 106496 ++read 4096/4096 bytes at offset 106496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 110592 ++read 4096/4096 bytes at offset 110592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 114688 ++read 4096/4096 bytes at offset 114688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 118784 ++read 4096/4096 bytes at offset 118784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 122880 ++read 4096/4096 bytes at offset 122880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 126976 ++read 4096/4096 bytes at offset 126976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 131072 ++read 4096/4096 bytes at offset 131072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 135168 ++read 4096/4096 bytes at offset 135168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 139264 ++read 4096/4096 bytes at offset 139264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 143360 ++read 4096/4096 bytes at offset 143360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 147456 ++read 4096/4096 bytes at offset 147456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 151552 ++read 4096/4096 bytes at offset 151552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 155648 ++read 4096/4096 bytes at offset 155648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 159744 ++read 4096/4096 bytes at offset 159744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 163840 ++read 4096/4096 bytes at offset 163840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 167936 ++read 4096/4096 bytes at offset 167936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 172032 ++read 4096/4096 bytes at offset 172032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 176128 ++read 4096/4096 bytes at offset 176128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 180224 ++read 4096/4096 bytes at offset 180224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 184320 ++read 4096/4096 bytes at offset 184320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 188416 ++read 4096/4096 bytes at offset 188416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 192512 ++read 4096/4096 bytes at offset 192512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 196608 ++read 4096/4096 bytes at offset 196608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 200704 ++read 4096/4096 bytes at offset 200704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 204800 ++read 4096/4096 bytes at offset 204800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 208896 ++read 4096/4096 bytes at offset 208896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 212992 ++read 4096/4096 bytes at offset 212992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 217088 ++read 4096/4096 bytes at offset 217088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 221184 ++read 4096/4096 bytes at offset 221184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 225280 ++read 4096/4096 bytes at offset 225280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 229376 ++read 4096/4096 bytes at offset 229376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 233472 ++read 4096/4096 bytes at offset 233472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 237568 ++read 4096/4096 bytes at offset 237568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 241664 ++read 4096/4096 bytes at offset 241664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 245760 ++read 4096/4096 bytes at offset 245760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 249856 ++read 4096/4096 bytes at offset 249856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 253952 ++read 4096/4096 bytes at offset 253952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 258048 ++read 4096/4096 bytes at offset 258048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 262144 ++read 4096/4096 bytes at offset 262144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 266240 ++read 4096/4096 bytes at offset 266240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 270336 ++read 4096/4096 bytes at offset 270336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 274432 ++read 4096/4096 bytes at offset 274432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 278528 ++read 4096/4096 bytes at offset 278528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 282624 ++read 4096/4096 bytes at offset 282624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 286720 ++read 4096/4096 bytes at offset 286720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 290816 ++read 4096/4096 bytes at offset 290816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 294912 ++read 4096/4096 bytes at offset 294912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 299008 ++read 4096/4096 bytes at offset 299008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 303104 ++read 4096/4096 bytes at offset 303104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 307200 ++read 4096/4096 bytes at offset 307200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 311296 ++read 4096/4096 bytes at offset 311296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 315392 ++read 4096/4096 bytes at offset 315392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 319488 ++read 4096/4096 bytes at offset 319488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 323584 ++read 4096/4096 bytes at offset 323584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 327680 ++read 4096/4096 bytes at offset 327680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 331776 ++read 4096/4096 bytes at offset 331776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 335872 ++read 4096/4096 bytes at offset 335872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 339968 ++read 4096/4096 bytes at offset 339968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 344064 ++read 4096/4096 bytes at offset 344064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 348160 ++read 4096/4096 bytes at offset 348160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 352256 ++read 4096/4096 bytes at offset 352256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 356352 ++read 4096/4096 bytes at offset 356352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 360448 ++read 4096/4096 bytes at offset 360448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 364544 ++read 4096/4096 bytes at offset 364544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 368640 ++read 4096/4096 bytes at offset 368640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 372736 ++read 4096/4096 bytes at offset 372736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 376832 ++read 4096/4096 bytes at offset 376832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 380928 ++read 4096/4096 bytes at offset 380928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 385024 ++read 4096/4096 bytes at offset 385024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 389120 ++read 4096/4096 bytes at offset 389120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 393216 ++read 4096/4096 bytes at offset 393216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 397312 ++read 4096/4096 bytes at offset 397312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 401408 ++read 4096/4096 bytes at offset 401408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 405504 ++read 4096/4096 bytes at offset 405504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 409600 ++read 4096/4096 bytes at offset 409600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 413696 ++read 4096/4096 bytes at offset 413696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 417792 ++read 4096/4096 bytes at offset 417792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 421888 ++read 4096/4096 bytes at offset 421888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 425984 ++read 4096/4096 bytes at offset 425984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 430080 ++read 4096/4096 bytes at offset 430080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 434176 ++read 4096/4096 bytes at offset 434176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 438272 ++read 4096/4096 bytes at offset 438272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 442368 ++read 4096/4096 bytes at offset 442368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 446464 ++read 4096/4096 bytes at offset 446464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 450560 ++read 4096/4096 bytes at offset 450560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 454656 ++read 4096/4096 bytes at offset 454656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 458752 ++read 4096/4096 bytes at offset 458752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 462848 ++read 4096/4096 bytes at offset 462848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 466944 ++read 4096/4096 bytes at offset 466944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 471040 ++read 4096/4096 bytes at offset 471040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 475136 ++read 4096/4096 bytes at offset 475136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 479232 ++read 4096/4096 bytes at offset 479232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 483328 ++read 4096/4096 bytes at offset 483328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 487424 ++read 4096/4096 bytes at offset 487424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 491520 ++read 4096/4096 bytes at offset 491520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 495616 ++read 4096/4096 bytes at offset 495616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 499712 ++read 4096/4096 bytes at offset 499712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 503808 ++read 4096/4096 bytes at offset 503808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 507904 ++read 4096/4096 bytes at offset 507904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 512000 ++read 4096/4096 bytes at offset 512000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 516096 ++read 4096/4096 bytes at offset 516096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 520192 ++read 4096/4096 bytes at offset 520192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 524288 ++read 4096/4096 bytes at offset 524288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 528384 ++read 4096/4096 bytes at offset 528384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 532480 ++read 4096/4096 bytes at offset 532480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 536576 ++read 4096/4096 bytes at offset 536576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 540672 ++read 4096/4096 bytes at offset 540672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 544768 ++read 4096/4096 bytes at offset 544768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 548864 ++read 4096/4096 bytes at offset 548864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 552960 ++read 4096/4096 bytes at offset 552960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 557056 ++read 4096/4096 bytes at offset 557056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 561152 ++read 4096/4096 bytes at offset 561152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 565248 ++read 4096/4096 bytes at offset 565248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 569344 ++read 4096/4096 bytes at offset 569344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 573440 ++read 4096/4096 bytes at offset 573440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 577536 ++read 4096/4096 bytes at offset 577536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 581632 ++read 4096/4096 bytes at offset 581632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 585728 ++read 4096/4096 bytes at offset 585728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 589824 ++read 4096/4096 bytes at offset 589824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 593920 ++read 4096/4096 bytes at offset 593920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 598016 ++read 4096/4096 bytes at offset 598016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 602112 ++read 4096/4096 bytes at offset 602112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 606208 ++read 4096/4096 bytes at offset 606208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 610304 ++read 4096/4096 bytes at offset 610304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 614400 ++read 4096/4096 bytes at offset 614400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 618496 ++read 4096/4096 bytes at offset 618496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 622592 ++read 4096/4096 bytes at offset 622592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 626688 ++read 4096/4096 bytes at offset 626688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 630784 ++read 4096/4096 bytes at offset 630784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 634880 ++read 4096/4096 bytes at offset 634880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 638976 ++read 4096/4096 bytes at offset 638976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 643072 ++read 4096/4096 bytes at offset 643072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 647168 ++read 4096/4096 bytes at offset 647168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 651264 ++read 4096/4096 bytes at offset 651264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 655360 ++read 4096/4096 bytes at offset 655360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 659456 ++read 4096/4096 bytes at offset 659456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 663552 ++read 4096/4096 bytes at offset 663552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 667648 ++read 4096/4096 bytes at offset 667648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 671744 ++read 4096/4096 bytes at offset 671744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 675840 ++read 4096/4096 bytes at offset 675840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 679936 ++read 4096/4096 bytes at offset 679936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 684032 ++read 4096/4096 bytes at offset 684032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 688128 ++read 4096/4096 bytes at offset 688128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 692224 ++read 4096/4096 bytes at offset 692224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 696320 ++read 4096/4096 bytes at offset 696320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 700416 ++read 4096/4096 bytes at offset 700416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 704512 ++read 4096/4096 bytes at offset 704512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 708608 ++read 4096/4096 bytes at offset 708608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 712704 ++read 4096/4096 bytes at offset 712704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 716800 ++read 4096/4096 bytes at offset 716800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 720896 ++read 4096/4096 bytes at offset 720896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 724992 ++read 4096/4096 bytes at offset 724992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 729088 ++read 4096/4096 bytes at offset 729088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 733184 ++read 4096/4096 bytes at offset 733184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 737280 ++read 4096/4096 bytes at offset 737280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 741376 ++read 4096/4096 bytes at offset 741376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 745472 ++read 4096/4096 bytes at offset 745472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 749568 ++read 4096/4096 bytes at offset 749568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 753664 ++read 4096/4096 bytes at offset 753664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 757760 ++read 4096/4096 bytes at offset 757760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 761856 ++read 4096/4096 bytes at offset 761856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 765952 ++read 4096/4096 bytes at offset 765952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 770048 ++read 4096/4096 bytes at offset 770048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 774144 ++read 4096/4096 bytes at offset 774144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 778240 ++read 4096/4096 bytes at offset 778240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 782336 ++read 4096/4096 bytes at offset 782336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 786432 ++read 4096/4096 bytes at offset 786432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 790528 ++read 4096/4096 bytes at offset 790528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 794624 ++read 4096/4096 bytes at offset 794624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 798720 ++read 4096/4096 bytes at offset 798720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 802816 ++read 4096/4096 bytes at offset 802816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 806912 ++read 4096/4096 bytes at offset 806912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 811008 ++read 4096/4096 bytes at offset 811008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 815104 ++read 4096/4096 bytes at offset 815104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 819200 ++read 4096/4096 bytes at offset 819200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 823296 ++read 4096/4096 bytes at offset 823296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 827392 ++read 4096/4096 bytes at offset 827392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 831488 ++read 4096/4096 bytes at offset 831488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 835584 ++read 4096/4096 bytes at offset 835584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 839680 ++read 4096/4096 bytes at offset 839680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 843776 ++read 4096/4096 bytes at offset 843776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 847872 ++read 4096/4096 bytes at offset 847872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 851968 ++read 4096/4096 bytes at offset 851968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 856064 ++read 4096/4096 bytes at offset 856064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 860160 ++read 4096/4096 bytes at offset 860160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 864256 ++read 4096/4096 bytes at offset 864256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 868352 ++read 4096/4096 bytes at offset 868352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 872448 ++read 4096/4096 bytes at offset 872448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 876544 ++read 4096/4096 bytes at offset 876544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 880640 ++read 4096/4096 bytes at offset 880640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 884736 ++read 4096/4096 bytes at offset 884736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 888832 ++read 4096/4096 bytes at offset 888832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 892928 ++read 4096/4096 bytes at offset 892928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 897024 ++read 4096/4096 bytes at offset 897024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 901120 ++read 4096/4096 bytes at offset 901120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 905216 ++read 4096/4096 bytes at offset 905216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 909312 ++read 4096/4096 bytes at offset 909312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 913408 ++read 4096/4096 bytes at offset 913408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 917504 ++read 4096/4096 bytes at offset 917504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 921600 ++read 4096/4096 bytes at offset 921600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 925696 ++read 4096/4096 bytes at offset 925696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 929792 ++read 4096/4096 bytes at offset 929792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 933888 ++read 4096/4096 bytes at offset 933888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 937984 ++read 4096/4096 bytes at offset 937984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 942080 ++read 4096/4096 bytes at offset 942080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 946176 ++read 4096/4096 bytes at offset 946176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 950272 ++read 4096/4096 bytes at offset 950272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 954368 ++read 4096/4096 bytes at offset 954368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 958464 ++read 4096/4096 bytes at offset 958464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 962560 ++read 4096/4096 bytes at offset 962560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 966656 ++read 4096/4096 bytes at offset 966656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 970752 ++read 4096/4096 bytes at offset 970752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 974848 ++read 4096/4096 bytes at offset 974848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 978944 ++read 4096/4096 bytes at offset 978944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 983040 ++read 4096/4096 bytes at offset 983040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 987136 ++read 4096/4096 bytes at offset 987136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 991232 ++read 4096/4096 bytes at offset 991232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 995328 ++read 4096/4096 bytes at offset 995328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 999424 ++read 4096/4096 bytes at offset 999424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1003520 ++read 4096/4096 bytes at offset 1003520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1007616 ++read 4096/4096 bytes at offset 1007616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1011712 ++read 4096/4096 bytes at offset 1011712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1015808 ++read 4096/4096 bytes at offset 1015808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1019904 ++read 4096/4096 bytes at offset 1019904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1024000 ++read 4096/4096 bytes at offset 1024000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1028096 ++read 4096/4096 bytes at offset 1028096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1032192 ++read 4096/4096 bytes at offset 1032192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1036288 ++read 4096/4096 bytes at offset 1036288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1040384 ++read 4096/4096 bytes at offset 1040384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1044480 ++read 4096/4096 bytes at offset 1044480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 4 +-qemu-io> read 2048/2048 bytes at offset 1050624 ++=== IO: pattern 4 ++read 2048/2048 bytes at offset 1050624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1054720 ++read 2048/2048 bytes at offset 1054720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1058816 ++read 2048/2048 bytes at offset 1058816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1062912 ++read 2048/2048 bytes at offset 1062912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1067008 ++read 2048/2048 bytes at offset 1067008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1071104 ++read 2048/2048 bytes at offset 1071104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1075200 ++read 2048/2048 bytes at offset 1075200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1079296 ++read 2048/2048 bytes at offset 1079296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1083392 ++read 2048/2048 bytes at offset 1083392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1087488 ++read 2048/2048 bytes at offset 1087488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1091584 ++read 2048/2048 bytes at offset 1091584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1095680 ++read 2048/2048 bytes at offset 1095680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1099776 ++read 2048/2048 bytes at offset 1099776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1103872 ++read 2048/2048 bytes at offset 1103872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1107968 ++read 2048/2048 bytes at offset 1107968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1112064 ++read 2048/2048 bytes at offset 1112064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1116160 ++read 2048/2048 bytes at offset 1116160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1120256 ++read 2048/2048 bytes at offset 1120256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1124352 ++read 2048/2048 bytes at offset 1124352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1128448 ++read 2048/2048 bytes at offset 1128448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1132544 ++read 2048/2048 bytes at offset 1132544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1136640 ++read 2048/2048 bytes at offset 1136640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1140736 ++read 2048/2048 bytes at offset 1140736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1144832 ++read 2048/2048 bytes at offset 1144832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1148928 ++read 2048/2048 bytes at offset 1148928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1153024 ++read 2048/2048 bytes at offset 1153024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1157120 ++read 2048/2048 bytes at offset 1157120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1161216 ++read 2048/2048 bytes at offset 1161216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1165312 ++read 2048/2048 bytes at offset 1165312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1169408 ++read 2048/2048 bytes at offset 1169408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1173504 ++read 2048/2048 bytes at offset 1173504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1177600 ++read 2048/2048 bytes at offset 1177600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1181696 ++read 2048/2048 bytes at offset 1181696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1185792 ++read 2048/2048 bytes at offset 1185792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1189888 ++read 2048/2048 bytes at offset 1189888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1193984 ++read 2048/2048 bytes at offset 1193984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1198080 ++read 2048/2048 bytes at offset 1198080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1202176 ++read 2048/2048 bytes at offset 1202176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1206272 ++read 2048/2048 bytes at offset 1206272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1210368 ++read 2048/2048 bytes at offset 1210368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1214464 ++read 2048/2048 bytes at offset 1214464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1218560 ++read 2048/2048 bytes at offset 1218560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1222656 ++read 2048/2048 bytes at offset 1222656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1226752 ++read 2048/2048 bytes at offset 1226752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1230848 ++read 2048/2048 bytes at offset 1230848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1234944 ++read 2048/2048 bytes at offset 1234944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1239040 ++read 2048/2048 bytes at offset 1239040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1243136 ++read 2048/2048 bytes at offset 1243136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1247232 ++read 2048/2048 bytes at offset 1247232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1251328 ++read 2048/2048 bytes at offset 1251328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1255424 ++read 2048/2048 bytes at offset 1255424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1259520 ++read 2048/2048 bytes at offset 1259520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1263616 ++read 2048/2048 bytes at offset 1263616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1267712 ++read 2048/2048 bytes at offset 1267712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1271808 ++read 2048/2048 bytes at offset 1271808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1275904 ++read 2048/2048 bytes at offset 1275904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1280000 ++read 2048/2048 bytes at offset 1280000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1284096 ++read 2048/2048 bytes at offset 1284096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1288192 ++read 2048/2048 bytes at offset 1288192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1292288 ++read 2048/2048 bytes at offset 1292288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1296384 ++read 2048/2048 bytes at offset 1296384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1300480 ++read 2048/2048 bytes at offset 1300480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1304576 ++read 2048/2048 bytes at offset 1304576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1308672 ++read 2048/2048 bytes at offset 1308672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1312768 ++read 2048/2048 bytes at offset 1312768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1316864 ++read 2048/2048 bytes at offset 1316864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1320960 ++read 2048/2048 bytes at offset 1320960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1325056 ++read 2048/2048 bytes at offset 1325056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1329152 ++read 2048/2048 bytes at offset 1329152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1333248 ++read 2048/2048 bytes at offset 1333248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1337344 ++read 2048/2048 bytes at offset 1337344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1341440 ++read 2048/2048 bytes at offset 1341440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1345536 ++read 2048/2048 bytes at offset 1345536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1349632 ++read 2048/2048 bytes at offset 1349632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1353728 ++read 2048/2048 bytes at offset 1353728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1357824 ++read 2048/2048 bytes at offset 1357824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1361920 ++read 2048/2048 bytes at offset 1361920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1366016 ++read 2048/2048 bytes at offset 1366016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1370112 ++read 2048/2048 bytes at offset 1370112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1374208 ++read 2048/2048 bytes at offset 1374208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1378304 ++read 2048/2048 bytes at offset 1378304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1382400 ++read 2048/2048 bytes at offset 1382400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1386496 ++read 2048/2048 bytes at offset 1386496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1390592 ++read 2048/2048 bytes at offset 1390592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1394688 ++read 2048/2048 bytes at offset 1394688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1398784 ++read 2048/2048 bytes at offset 1398784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1402880 ++read 2048/2048 bytes at offset 1402880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1406976 ++read 2048/2048 bytes at offset 1406976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1411072 ++read 2048/2048 bytes at offset 1411072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1415168 ++read 2048/2048 bytes at offset 1415168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1419264 ++read 2048/2048 bytes at offset 1419264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1423360 ++read 2048/2048 bytes at offset 1423360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1427456 ++read 2048/2048 bytes at offset 1427456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1431552 ++read 2048/2048 bytes at offset 1431552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1435648 ++read 2048/2048 bytes at offset 1435648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1439744 ++read 2048/2048 bytes at offset 1439744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1443840 ++read 2048/2048 bytes at offset 1443840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1447936 ++read 2048/2048 bytes at offset 1447936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1452032 ++read 2048/2048 bytes at offset 1452032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1456128 ++read 2048/2048 bytes at offset 1456128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1460224 ++read 2048/2048 bytes at offset 1460224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1464320 ++read 2048/2048 bytes at offset 1464320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1468416 ++read 2048/2048 bytes at offset 1468416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1472512 ++read 2048/2048 bytes at offset 1472512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1476608 ++read 2048/2048 bytes at offset 1476608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1480704 ++read 2048/2048 bytes at offset 1480704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1484800 ++read 2048/2048 bytes at offset 1484800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1488896 ++read 2048/2048 bytes at offset 1488896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1492992 ++read 2048/2048 bytes at offset 1492992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1497088 ++read 2048/2048 bytes at offset 1497088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1501184 ++read 2048/2048 bytes at offset 1501184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1505280 ++read 2048/2048 bytes at offset 1505280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1509376 ++read 2048/2048 bytes at offset 1509376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1513472 ++read 2048/2048 bytes at offset 1513472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1517568 ++read 2048/2048 bytes at offset 1517568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1521664 ++read 2048/2048 bytes at offset 1521664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1525760 ++read 2048/2048 bytes at offset 1525760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1529856 ++read 2048/2048 bytes at offset 1529856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1533952 ++read 2048/2048 bytes at offset 1533952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1538048 ++read 2048/2048 bytes at offset 1538048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1542144 ++read 2048/2048 bytes at offset 1542144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1546240 ++read 2048/2048 bytes at offset 1546240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1550336 ++read 2048/2048 bytes at offset 1550336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1554432 ++read 2048/2048 bytes at offset 1554432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1558528 ++read 2048/2048 bytes at offset 1558528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1562624 ++read 2048/2048 bytes at offset 1562624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1566720 ++read 2048/2048 bytes at offset 1566720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1570816 ++read 2048/2048 bytes at offset 1570816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1574912 ++read 2048/2048 bytes at offset 1574912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1579008 ++read 2048/2048 bytes at offset 1579008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1583104 ++read 2048/2048 bytes at offset 1583104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1587200 ++read 2048/2048 bytes at offset 1587200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1591296 ++read 2048/2048 bytes at offset 1591296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1595392 ++read 2048/2048 bytes at offset 1595392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1599488 ++read 2048/2048 bytes at offset 1599488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1603584 ++read 2048/2048 bytes at offset 1603584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1607680 ++read 2048/2048 bytes at offset 1607680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1611776 ++read 2048/2048 bytes at offset 1611776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1615872 ++read 2048/2048 bytes at offset 1615872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1619968 ++read 2048/2048 bytes at offset 1619968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1624064 ++read 2048/2048 bytes at offset 1624064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1628160 ++read 2048/2048 bytes at offset 1628160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1632256 ++read 2048/2048 bytes at offset 1632256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1636352 ++read 2048/2048 bytes at offset 1636352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1640448 ++read 2048/2048 bytes at offset 1640448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1644544 ++read 2048/2048 bytes at offset 1644544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1648640 ++read 2048/2048 bytes at offset 1648640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1652736 ++read 2048/2048 bytes at offset 1652736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1656832 ++read 2048/2048 bytes at offset 1656832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1660928 ++read 2048/2048 bytes at offset 1660928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1665024 ++read 2048/2048 bytes at offset 1665024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1669120 ++read 2048/2048 bytes at offset 1669120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1673216 ++read 2048/2048 bytes at offset 1673216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1677312 ++read 2048/2048 bytes at offset 1677312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1681408 ++read 2048/2048 bytes at offset 1681408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1685504 ++read 2048/2048 bytes at offset 1685504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1689600 ++read 2048/2048 bytes at offset 1689600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1693696 ++read 2048/2048 bytes at offset 1693696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1697792 ++read 2048/2048 bytes at offset 1697792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1701888 ++read 2048/2048 bytes at offset 1701888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1705984 ++read 2048/2048 bytes at offset 1705984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1710080 ++read 2048/2048 bytes at offset 1710080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1714176 ++read 2048/2048 bytes at offset 1714176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1718272 ++read 2048/2048 bytes at offset 1718272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1722368 ++read 2048/2048 bytes at offset 1722368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1726464 ++read 2048/2048 bytes at offset 1726464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1730560 ++read 2048/2048 bytes at offset 1730560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1734656 ++read 2048/2048 bytes at offset 1734656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1738752 ++read 2048/2048 bytes at offset 1738752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1742848 ++read 2048/2048 bytes at offset 1742848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1746944 ++read 2048/2048 bytes at offset 1746944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1751040 ++read 2048/2048 bytes at offset 1751040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1755136 ++read 2048/2048 bytes at offset 1755136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1759232 ++read 2048/2048 bytes at offset 1759232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1763328 ++read 2048/2048 bytes at offset 1763328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1767424 ++read 2048/2048 bytes at offset 1767424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1771520 ++read 2048/2048 bytes at offset 1771520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1775616 ++read 2048/2048 bytes at offset 1775616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1779712 ++read 2048/2048 bytes at offset 1779712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1783808 ++read 2048/2048 bytes at offset 1783808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1787904 ++read 2048/2048 bytes at offset 1787904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1792000 ++read 2048/2048 bytes at offset 1792000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1796096 ++read 2048/2048 bytes at offset 1796096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1800192 ++read 2048/2048 bytes at offset 1800192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1804288 ++read 2048/2048 bytes at offset 1804288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1808384 ++read 2048/2048 bytes at offset 1808384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1812480 ++read 2048/2048 bytes at offset 1812480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1816576 ++read 2048/2048 bytes at offset 1816576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1820672 ++read 2048/2048 bytes at offset 1820672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1824768 ++read 2048/2048 bytes at offset 1824768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1828864 ++read 2048/2048 bytes at offset 1828864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1832960 ++read 2048/2048 bytes at offset 1832960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1837056 ++read 2048/2048 bytes at offset 1837056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1841152 ++read 2048/2048 bytes at offset 1841152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1845248 ++read 2048/2048 bytes at offset 1845248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1849344 ++read 2048/2048 bytes at offset 1849344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1853440 ++read 2048/2048 bytes at offset 1853440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1857536 ++read 2048/2048 bytes at offset 1857536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1861632 ++read 2048/2048 bytes at offset 1861632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1865728 ++read 2048/2048 bytes at offset 1865728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1869824 ++read 2048/2048 bytes at offset 1869824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1873920 ++read 2048/2048 bytes at offset 1873920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1878016 ++read 2048/2048 bytes at offset 1878016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1882112 ++read 2048/2048 bytes at offset 1882112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1886208 ++read 2048/2048 bytes at offset 1886208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1890304 ++read 2048/2048 bytes at offset 1890304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1894400 ++read 2048/2048 bytes at offset 1894400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1898496 ++read 2048/2048 bytes at offset 1898496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1902592 ++read 2048/2048 bytes at offset 1902592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1906688 ++read 2048/2048 bytes at offset 1906688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1910784 ++read 2048/2048 bytes at offset 1910784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1914880 ++read 2048/2048 bytes at offset 1914880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1918976 ++read 2048/2048 bytes at offset 1918976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1923072 ++read 2048/2048 bytes at offset 1923072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1927168 ++read 2048/2048 bytes at offset 1927168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1931264 ++read 2048/2048 bytes at offset 1931264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1935360 ++read 2048/2048 bytes at offset 1935360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1939456 ++read 2048/2048 bytes at offset 1939456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1943552 ++read 2048/2048 bytes at offset 1943552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1947648 ++read 2048/2048 bytes at offset 1947648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1951744 ++read 2048/2048 bytes at offset 1951744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1955840 ++read 2048/2048 bytes at offset 1955840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1959936 ++read 2048/2048 bytes at offset 1959936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1964032 ++read 2048/2048 bytes at offset 1964032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1968128 ++read 2048/2048 bytes at offset 1968128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1972224 ++read 2048/2048 bytes at offset 1972224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1976320 ++read 2048/2048 bytes at offset 1976320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1980416 ++read 2048/2048 bytes at offset 1980416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1984512 ++read 2048/2048 bytes at offset 1984512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1988608 ++read 2048/2048 bytes at offset 1988608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1992704 ++read 2048/2048 bytes at offset 1992704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1996800 ++read 2048/2048 bytes at offset 1996800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2000896 ++read 2048/2048 bytes at offset 2000896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2004992 ++read 2048/2048 bytes at offset 2004992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2009088 ++read 2048/2048 bytes at offset 2009088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2013184 ++read 2048/2048 bytes at offset 2013184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2017280 ++read 2048/2048 bytes at offset 2017280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2021376 ++read 2048/2048 bytes at offset 2021376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2025472 ++read 2048/2048 bytes at offset 2025472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2029568 ++read 2048/2048 bytes at offset 2029568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2033664 ++read 2048/2048 bytes at offset 2033664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2037760 ++read 2048/2048 bytes at offset 2037760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2041856 ++read 2048/2048 bytes at offset 2041856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2045952 ++read 2048/2048 bytes at offset 2045952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2050048 ++read 2048/2048 bytes at offset 2050048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2054144 ++read 2048/2048 bytes at offset 2054144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2058240 ++read 2048/2048 bytes at offset 2058240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2062336 ++read 2048/2048 bytes at offset 2062336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2066432 ++read 2048/2048 bytes at offset 2066432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2070528 ++read 2048/2048 bytes at offset 2070528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2074624 ++read 2048/2048 bytes at offset 2074624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2078720 ++read 2048/2048 bytes at offset 2078720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2082816 ++read 2048/2048 bytes at offset 2082816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2086912 ++read 2048/2048 bytes at offset 2086912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2091008 ++read 2048/2048 bytes at offset 2091008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2095104 ++read 2048/2048 bytes at offset 2095104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> read 2048/2048 bytes at offset 2097152 ++=== IO: pattern 0 ++read 2048/2048 bytes at offset 2097152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2101248 ++read 2048/2048 bytes at offset 2101248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2105344 ++read 2048/2048 bytes at offset 2105344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2109440 ++read 2048/2048 bytes at offset 2109440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2113536 ++read 2048/2048 bytes at offset 2113536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2117632 ++read 2048/2048 bytes at offset 2117632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2121728 ++read 2048/2048 bytes at offset 2121728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2125824 ++read 2048/2048 bytes at offset 2125824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2129920 ++read 2048/2048 bytes at offset 2129920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2134016 ++read 2048/2048 bytes at offset 2134016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2138112 ++read 2048/2048 bytes at offset 2138112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2142208 ++read 2048/2048 bytes at offset 2142208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2146304 ++read 2048/2048 bytes at offset 2146304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2150400 ++read 2048/2048 bytes at offset 2150400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2154496 ++read 2048/2048 bytes at offset 2154496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2158592 ++read 2048/2048 bytes at offset 2158592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2162688 ++read 2048/2048 bytes at offset 2162688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2166784 ++read 2048/2048 bytes at offset 2166784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2170880 ++read 2048/2048 bytes at offset 2170880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2174976 ++read 2048/2048 bytes at offset 2174976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2179072 ++read 2048/2048 bytes at offset 2179072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2183168 ++read 2048/2048 bytes at offset 2183168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2187264 ++read 2048/2048 bytes at offset 2187264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2191360 ++read 2048/2048 bytes at offset 2191360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2195456 ++read 2048/2048 bytes at offset 2195456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2199552 ++read 2048/2048 bytes at offset 2199552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2203648 ++read 2048/2048 bytes at offset 2203648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2207744 ++read 2048/2048 bytes at offset 2207744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2211840 ++read 2048/2048 bytes at offset 2211840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2215936 ++read 2048/2048 bytes at offset 2215936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2220032 ++read 2048/2048 bytes at offset 2220032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2224128 ++read 2048/2048 bytes at offset 2224128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2228224 ++read 2048/2048 bytes at offset 2228224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2232320 ++read 2048/2048 bytes at offset 2232320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2236416 ++read 2048/2048 bytes at offset 2236416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2240512 ++read 2048/2048 bytes at offset 2240512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2244608 ++read 2048/2048 bytes at offset 2244608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2248704 ++read 2048/2048 bytes at offset 2248704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2252800 ++read 2048/2048 bytes at offset 2252800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2256896 ++read 2048/2048 bytes at offset 2256896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2260992 ++read 2048/2048 bytes at offset 2260992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2265088 ++read 2048/2048 bytes at offset 2265088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2269184 ++read 2048/2048 bytes at offset 2269184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2273280 ++read 2048/2048 bytes at offset 2273280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2277376 ++read 2048/2048 bytes at offset 2277376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2281472 ++read 2048/2048 bytes at offset 2281472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2285568 ++read 2048/2048 bytes at offset 2285568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2289664 ++read 2048/2048 bytes at offset 2289664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2293760 ++read 2048/2048 bytes at offset 2293760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2297856 ++read 2048/2048 bytes at offset 2297856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2301952 ++read 2048/2048 bytes at offset 2301952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2306048 ++read 2048/2048 bytes at offset 2306048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2310144 ++read 2048/2048 bytes at offset 2310144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2314240 ++read 2048/2048 bytes at offset 2314240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2318336 ++read 2048/2048 bytes at offset 2318336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2322432 ++read 2048/2048 bytes at offset 2322432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2326528 ++read 2048/2048 bytes at offset 2326528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2330624 ++read 2048/2048 bytes at offset 2330624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2334720 ++read 2048/2048 bytes at offset 2334720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2338816 ++read 2048/2048 bytes at offset 2338816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2342912 ++read 2048/2048 bytes at offset 2342912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2347008 ++read 2048/2048 bytes at offset 2347008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2351104 ++read 2048/2048 bytes at offset 2351104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2355200 ++read 2048/2048 bytes at offset 2355200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2359296 ++read 2048/2048 bytes at offset 2359296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2363392 ++read 2048/2048 bytes at offset 2363392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2367488 ++read 2048/2048 bytes at offset 2367488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2371584 ++read 2048/2048 bytes at offset 2371584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2375680 ++read 2048/2048 bytes at offset 2375680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2379776 ++read 2048/2048 bytes at offset 2379776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2383872 ++read 2048/2048 bytes at offset 2383872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2387968 ++read 2048/2048 bytes at offset 2387968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2392064 ++read 2048/2048 bytes at offset 2392064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2396160 ++read 2048/2048 bytes at offset 2396160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2400256 ++read 2048/2048 bytes at offset 2400256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2404352 ++read 2048/2048 bytes at offset 2404352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2408448 ++read 2048/2048 bytes at offset 2408448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2412544 ++read 2048/2048 bytes at offset 2412544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2416640 ++read 2048/2048 bytes at offset 2416640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2420736 ++read 2048/2048 bytes at offset 2420736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2424832 ++read 2048/2048 bytes at offset 2424832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2428928 ++read 2048/2048 bytes at offset 2428928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2433024 ++read 2048/2048 bytes at offset 2433024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2437120 ++read 2048/2048 bytes at offset 2437120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2441216 ++read 2048/2048 bytes at offset 2441216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2445312 ++read 2048/2048 bytes at offset 2445312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2449408 ++read 2048/2048 bytes at offset 2449408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2453504 ++read 2048/2048 bytes at offset 2453504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2457600 ++read 2048/2048 bytes at offset 2457600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2461696 ++read 2048/2048 bytes at offset 2461696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2465792 ++read 2048/2048 bytes at offset 2465792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2469888 ++read 2048/2048 bytes at offset 2469888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2473984 ++read 2048/2048 bytes at offset 2473984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2478080 ++read 2048/2048 bytes at offset 2478080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2482176 ++read 2048/2048 bytes at offset 2482176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2486272 ++read 2048/2048 bytes at offset 2486272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2490368 ++read 2048/2048 bytes at offset 2490368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2494464 ++read 2048/2048 bytes at offset 2494464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2498560 ++read 2048/2048 bytes at offset 2498560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2502656 ++read 2048/2048 bytes at offset 2502656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2506752 ++read 2048/2048 bytes at offset 2506752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2510848 ++read 2048/2048 bytes at offset 2510848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2514944 ++read 2048/2048 bytes at offset 2514944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2519040 ++read 2048/2048 bytes at offset 2519040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2523136 ++read 2048/2048 bytes at offset 2523136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2527232 ++read 2048/2048 bytes at offset 2527232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2531328 ++read 2048/2048 bytes at offset 2531328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2535424 ++read 2048/2048 bytes at offset 2535424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2539520 ++read 2048/2048 bytes at offset 2539520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2543616 ++read 2048/2048 bytes at offset 2543616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2547712 ++read 2048/2048 bytes at offset 2547712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2551808 ++read 2048/2048 bytes at offset 2551808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2555904 ++read 2048/2048 bytes at offset 2555904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2560000 ++read 2048/2048 bytes at offset 2560000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2564096 ++read 2048/2048 bytes at offset 2564096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2568192 ++read 2048/2048 bytes at offset 2568192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2572288 ++read 2048/2048 bytes at offset 2572288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2576384 ++read 2048/2048 bytes at offset 2576384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2580480 ++read 2048/2048 bytes at offset 2580480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2584576 ++read 2048/2048 bytes at offset 2584576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2588672 ++read 2048/2048 bytes at offset 2588672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2592768 ++read 2048/2048 bytes at offset 2592768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2596864 ++read 2048/2048 bytes at offset 2596864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2600960 ++read 2048/2048 bytes at offset 2600960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2605056 ++read 2048/2048 bytes at offset 2605056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2609152 ++read 2048/2048 bytes at offset 2609152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2613248 ++read 2048/2048 bytes at offset 2613248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2617344 ++read 2048/2048 bytes at offset 2617344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2621440 ++read 2048/2048 bytes at offset 2621440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2625536 ++read 2048/2048 bytes at offset 2625536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2629632 ++read 2048/2048 bytes at offset 2629632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2633728 ++read 2048/2048 bytes at offset 2633728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2637824 ++read 2048/2048 bytes at offset 2637824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2641920 ++read 2048/2048 bytes at offset 2641920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2646016 ++read 2048/2048 bytes at offset 2646016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2650112 ++read 2048/2048 bytes at offset 2650112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2654208 ++read 2048/2048 bytes at offset 2654208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2658304 ++read 2048/2048 bytes at offset 2658304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2662400 ++read 2048/2048 bytes at offset 2662400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2666496 ++read 2048/2048 bytes at offset 2666496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2670592 ++read 2048/2048 bytes at offset 2670592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2674688 ++read 2048/2048 bytes at offset 2674688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2678784 ++read 2048/2048 bytes at offset 2678784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2682880 ++read 2048/2048 bytes at offset 2682880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2686976 ++read 2048/2048 bytes at offset 2686976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2691072 ++read 2048/2048 bytes at offset 2691072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2695168 ++read 2048/2048 bytes at offset 2695168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2699264 ++read 2048/2048 bytes at offset 2699264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2703360 ++read 2048/2048 bytes at offset 2703360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2707456 ++read 2048/2048 bytes at offset 2707456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2711552 ++read 2048/2048 bytes at offset 2711552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2715648 ++read 2048/2048 bytes at offset 2715648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2719744 ++read 2048/2048 bytes at offset 2719744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2723840 ++read 2048/2048 bytes at offset 2723840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2727936 ++read 2048/2048 bytes at offset 2727936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2732032 ++read 2048/2048 bytes at offset 2732032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2736128 ++read 2048/2048 bytes at offset 2736128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2740224 ++read 2048/2048 bytes at offset 2740224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2744320 ++read 2048/2048 bytes at offset 2744320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2748416 ++read 2048/2048 bytes at offset 2748416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2752512 ++read 2048/2048 bytes at offset 2752512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2756608 ++read 2048/2048 bytes at offset 2756608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2760704 ++read 2048/2048 bytes at offset 2760704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2764800 ++read 2048/2048 bytes at offset 2764800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2768896 ++read 2048/2048 bytes at offset 2768896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2772992 ++read 2048/2048 bytes at offset 2772992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2777088 ++read 2048/2048 bytes at offset 2777088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2781184 ++read 2048/2048 bytes at offset 2781184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2785280 ++read 2048/2048 bytes at offset 2785280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2789376 ++read 2048/2048 bytes at offset 2789376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2793472 ++read 2048/2048 bytes at offset 2793472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2797568 ++read 2048/2048 bytes at offset 2797568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2801664 ++read 2048/2048 bytes at offset 2801664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2805760 ++read 2048/2048 bytes at offset 2805760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2809856 ++read 2048/2048 bytes at offset 2809856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2813952 ++read 2048/2048 bytes at offset 2813952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2818048 ++read 2048/2048 bytes at offset 2818048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2822144 ++read 2048/2048 bytes at offset 2822144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2826240 ++read 2048/2048 bytes at offset 2826240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2830336 ++read 2048/2048 bytes at offset 2830336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2834432 ++read 2048/2048 bytes at offset 2834432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2838528 ++read 2048/2048 bytes at offset 2838528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2842624 ++read 2048/2048 bytes at offset 2842624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2846720 ++read 2048/2048 bytes at offset 2846720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2850816 ++read 2048/2048 bytes at offset 2850816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2854912 ++read 2048/2048 bytes at offset 2854912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2859008 ++read 2048/2048 bytes at offset 2859008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2863104 ++read 2048/2048 bytes at offset 2863104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2867200 ++read 2048/2048 bytes at offset 2867200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2871296 ++read 2048/2048 bytes at offset 2871296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2875392 ++read 2048/2048 bytes at offset 2875392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2879488 ++read 2048/2048 bytes at offset 2879488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2883584 ++read 2048/2048 bytes at offset 2883584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2887680 ++read 2048/2048 bytes at offset 2887680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2891776 ++read 2048/2048 bytes at offset 2891776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2895872 ++read 2048/2048 bytes at offset 2895872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2899968 ++read 2048/2048 bytes at offset 2899968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2904064 ++read 2048/2048 bytes at offset 2904064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2908160 ++read 2048/2048 bytes at offset 2908160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2912256 ++read 2048/2048 bytes at offset 2912256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2916352 ++read 2048/2048 bytes at offset 2916352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2920448 ++read 2048/2048 bytes at offset 2920448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2924544 ++read 2048/2048 bytes at offset 2924544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2928640 ++read 2048/2048 bytes at offset 2928640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2932736 ++read 2048/2048 bytes at offset 2932736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2936832 ++read 2048/2048 bytes at offset 2936832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2940928 ++read 2048/2048 bytes at offset 2940928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2945024 ++read 2048/2048 bytes at offset 2945024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2949120 ++read 2048/2048 bytes at offset 2949120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2953216 ++read 2048/2048 bytes at offset 2953216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2957312 ++read 2048/2048 bytes at offset 2957312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2961408 ++read 2048/2048 bytes at offset 2961408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2965504 ++read 2048/2048 bytes at offset 2965504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2969600 ++read 2048/2048 bytes at offset 2969600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2973696 ++read 2048/2048 bytes at offset 2973696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2977792 ++read 2048/2048 bytes at offset 2977792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2981888 ++read 2048/2048 bytes at offset 2981888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2985984 ++read 2048/2048 bytes at offset 2985984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2990080 ++read 2048/2048 bytes at offset 2990080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2994176 ++read 2048/2048 bytes at offset 2994176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2998272 ++read 2048/2048 bytes at offset 2998272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3002368 ++read 2048/2048 bytes at offset 3002368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3006464 ++read 2048/2048 bytes at offset 3006464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3010560 ++read 2048/2048 bytes at offset 3010560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3014656 ++read 2048/2048 bytes at offset 3014656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3018752 ++read 2048/2048 bytes at offset 3018752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3022848 ++read 2048/2048 bytes at offset 3022848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3026944 ++read 2048/2048 bytes at offset 3026944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3031040 ++read 2048/2048 bytes at offset 3031040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3035136 ++read 2048/2048 bytes at offset 3035136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3039232 ++read 2048/2048 bytes at offset 3039232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3043328 ++read 2048/2048 bytes at offset 3043328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3047424 ++read 2048/2048 bytes at offset 3047424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3051520 ++read 2048/2048 bytes at offset 3051520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3055616 ++read 2048/2048 bytes at offset 3055616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3059712 ++read 2048/2048 bytes at offset 3059712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3063808 ++read 2048/2048 bytes at offset 3063808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3067904 ++read 2048/2048 bytes at offset 3067904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3072000 ++read 2048/2048 bytes at offset 3072000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3076096 ++read 2048/2048 bytes at offset 3076096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3080192 ++read 2048/2048 bytes at offset 3080192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3084288 ++read 2048/2048 bytes at offset 3084288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3088384 ++read 2048/2048 bytes at offset 3088384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3092480 ++read 2048/2048 bytes at offset 3092480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3096576 ++read 2048/2048 bytes at offset 3096576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3100672 ++read 2048/2048 bytes at offset 3100672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3104768 ++read 2048/2048 bytes at offset 3104768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3108864 ++read 2048/2048 bytes at offset 3108864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3112960 ++read 2048/2048 bytes at offset 3112960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3117056 ++read 2048/2048 bytes at offset 3117056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3121152 ++read 2048/2048 bytes at offset 3121152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3125248 ++read 2048/2048 bytes at offset 3125248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3129344 ++read 2048/2048 bytes at offset 3129344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3133440 ++read 2048/2048 bytes at offset 3133440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3137536 ++read 2048/2048 bytes at offset 3137536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3141632 ++read 2048/2048 bytes at offset 3141632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 2 +-qemu-io> read 2048/2048 bytes at offset 3146752 ++=== IO: pattern 2 ++read 2048/2048 bytes at offset 3146752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3150848 ++read 2048/2048 bytes at offset 3150848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3154944 ++read 2048/2048 bytes at offset 3154944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3159040 ++read 2048/2048 bytes at offset 3159040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3163136 ++read 2048/2048 bytes at offset 3163136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3167232 ++read 2048/2048 bytes at offset 3167232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3171328 ++read 2048/2048 bytes at offset 3171328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3175424 ++read 2048/2048 bytes at offset 3175424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3179520 ++read 2048/2048 bytes at offset 3179520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3183616 ++read 2048/2048 bytes at offset 3183616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3187712 ++read 2048/2048 bytes at offset 3187712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3191808 ++read 2048/2048 bytes at offset 3191808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3195904 ++read 2048/2048 bytes at offset 3195904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3200000 ++read 2048/2048 bytes at offset 3200000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3204096 ++read 2048/2048 bytes at offset 3204096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3208192 ++read 2048/2048 bytes at offset 3208192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3212288 ++read 2048/2048 bytes at offset 3212288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3216384 ++read 2048/2048 bytes at offset 3216384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3220480 ++read 2048/2048 bytes at offset 3220480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3224576 ++read 2048/2048 bytes at offset 3224576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3228672 ++read 2048/2048 bytes at offset 3228672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3232768 ++read 2048/2048 bytes at offset 3232768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3236864 ++read 2048/2048 bytes at offset 3236864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3240960 ++read 2048/2048 bytes at offset 3240960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3245056 ++read 2048/2048 bytes at offset 3245056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3249152 ++read 2048/2048 bytes at offset 3249152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3253248 ++read 2048/2048 bytes at offset 3253248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3257344 ++read 2048/2048 bytes at offset 3257344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3261440 ++read 2048/2048 bytes at offset 3261440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3265536 ++read 2048/2048 bytes at offset 3265536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3269632 ++read 2048/2048 bytes at offset 3269632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3273728 ++read 2048/2048 bytes at offset 3273728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3277824 ++read 2048/2048 bytes at offset 3277824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3281920 ++read 2048/2048 bytes at offset 3281920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3286016 ++read 2048/2048 bytes at offset 3286016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3290112 ++read 2048/2048 bytes at offset 3290112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3294208 ++read 2048/2048 bytes at offset 3294208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3298304 ++read 2048/2048 bytes at offset 3298304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3302400 ++read 2048/2048 bytes at offset 3302400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3306496 ++read 2048/2048 bytes at offset 3306496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3310592 ++read 2048/2048 bytes at offset 3310592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3314688 ++read 2048/2048 bytes at offset 3314688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3318784 ++read 2048/2048 bytes at offset 3318784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3322880 ++read 2048/2048 bytes at offset 3322880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3326976 ++read 2048/2048 bytes at offset 3326976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3331072 ++read 2048/2048 bytes at offset 3331072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3335168 ++read 2048/2048 bytes at offset 3335168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3339264 ++read 2048/2048 bytes at offset 3339264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3343360 ++read 2048/2048 bytes at offset 3343360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3347456 ++read 2048/2048 bytes at offset 3347456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3351552 ++read 2048/2048 bytes at offset 3351552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3355648 ++read 2048/2048 bytes at offset 3355648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3359744 ++read 2048/2048 bytes at offset 3359744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3363840 ++read 2048/2048 bytes at offset 3363840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3367936 ++read 2048/2048 bytes at offset 3367936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3372032 ++read 2048/2048 bytes at offset 3372032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3376128 ++read 2048/2048 bytes at offset 3376128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3380224 ++read 2048/2048 bytes at offset 3380224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3384320 ++read 2048/2048 bytes at offset 3384320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3388416 ++read 2048/2048 bytes at offset 3388416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3392512 ++read 2048/2048 bytes at offset 3392512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3396608 ++read 2048/2048 bytes at offset 3396608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3400704 ++read 2048/2048 bytes at offset 3400704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3404800 ++read 2048/2048 bytes at offset 3404800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3408896 ++read 2048/2048 bytes at offset 3408896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3412992 ++read 2048/2048 bytes at offset 3412992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3417088 ++read 2048/2048 bytes at offset 3417088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3421184 ++read 2048/2048 bytes at offset 3421184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3425280 ++read 2048/2048 bytes at offset 3425280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3429376 ++read 2048/2048 bytes at offset 3429376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3433472 ++read 2048/2048 bytes at offset 3433472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3437568 ++read 2048/2048 bytes at offset 3437568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3441664 ++read 2048/2048 bytes at offset 3441664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3445760 ++read 2048/2048 bytes at offset 3445760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3449856 ++read 2048/2048 bytes at offset 3449856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3453952 ++read 2048/2048 bytes at offset 3453952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3458048 ++read 2048/2048 bytes at offset 3458048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3462144 ++read 2048/2048 bytes at offset 3462144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3466240 ++read 2048/2048 bytes at offset 3466240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3470336 ++read 2048/2048 bytes at offset 3470336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3474432 ++read 2048/2048 bytes at offset 3474432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3478528 ++read 2048/2048 bytes at offset 3478528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3482624 ++read 2048/2048 bytes at offset 3482624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3486720 ++read 2048/2048 bytes at offset 3486720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3490816 ++read 2048/2048 bytes at offset 3490816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3494912 ++read 2048/2048 bytes at offset 3494912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3499008 ++read 2048/2048 bytes at offset 3499008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3503104 ++read 2048/2048 bytes at offset 3503104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3507200 ++read 2048/2048 bytes at offset 3507200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3511296 ++read 2048/2048 bytes at offset 3511296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3515392 ++read 2048/2048 bytes at offset 3515392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3519488 ++read 2048/2048 bytes at offset 3519488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3523584 ++read 2048/2048 bytes at offset 3523584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3527680 ++read 2048/2048 bytes at offset 3527680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3531776 ++read 2048/2048 bytes at offset 3531776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3535872 ++read 2048/2048 bytes at offset 3535872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3539968 ++read 2048/2048 bytes at offset 3539968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3544064 ++read 2048/2048 bytes at offset 3544064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3548160 ++read 2048/2048 bytes at offset 3548160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3552256 ++read 2048/2048 bytes at offset 3552256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3556352 ++read 2048/2048 bytes at offset 3556352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3560448 ++read 2048/2048 bytes at offset 3560448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3564544 ++read 2048/2048 bytes at offset 3564544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3568640 ++read 2048/2048 bytes at offset 3568640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3572736 ++read 2048/2048 bytes at offset 3572736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3576832 ++read 2048/2048 bytes at offset 3576832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3580928 ++read 2048/2048 bytes at offset 3580928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3585024 ++read 2048/2048 bytes at offset 3585024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3589120 ++read 2048/2048 bytes at offset 3589120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3593216 ++read 2048/2048 bytes at offset 3593216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3597312 ++read 2048/2048 bytes at offset 3597312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3601408 ++read 2048/2048 bytes at offset 3601408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3605504 ++read 2048/2048 bytes at offset 3605504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3609600 ++read 2048/2048 bytes at offset 3609600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3613696 ++read 2048/2048 bytes at offset 3613696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3617792 ++read 2048/2048 bytes at offset 3617792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3621888 ++read 2048/2048 bytes at offset 3621888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3625984 ++read 2048/2048 bytes at offset 3625984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3630080 ++read 2048/2048 bytes at offset 3630080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3634176 ++read 2048/2048 bytes at offset 3634176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3638272 ++read 2048/2048 bytes at offset 3638272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3642368 ++read 2048/2048 bytes at offset 3642368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3646464 ++read 2048/2048 bytes at offset 3646464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3650560 ++read 2048/2048 bytes at offset 3650560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3654656 ++read 2048/2048 bytes at offset 3654656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3658752 ++read 2048/2048 bytes at offset 3658752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3662848 ++read 2048/2048 bytes at offset 3662848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3666944 ++read 2048/2048 bytes at offset 3666944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3671040 ++read 2048/2048 bytes at offset 3671040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3675136 ++read 2048/2048 bytes at offset 3675136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3679232 ++read 2048/2048 bytes at offset 3679232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3683328 ++read 2048/2048 bytes at offset 3683328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3687424 ++read 2048/2048 bytes at offset 3687424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3691520 ++read 2048/2048 bytes at offset 3691520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3695616 ++read 2048/2048 bytes at offset 3695616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3699712 ++read 2048/2048 bytes at offset 3699712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3703808 ++read 2048/2048 bytes at offset 3703808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3707904 ++read 2048/2048 bytes at offset 3707904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3712000 ++read 2048/2048 bytes at offset 3712000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3716096 ++read 2048/2048 bytes at offset 3716096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3720192 ++read 2048/2048 bytes at offset 3720192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3724288 ++read 2048/2048 bytes at offset 3724288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3728384 ++read 2048/2048 bytes at offset 3728384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3732480 ++read 2048/2048 bytes at offset 3732480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3736576 ++read 2048/2048 bytes at offset 3736576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3740672 ++read 2048/2048 bytes at offset 3740672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3744768 ++read 2048/2048 bytes at offset 3744768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3748864 ++read 2048/2048 bytes at offset 3748864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3752960 ++read 2048/2048 bytes at offset 3752960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3757056 ++read 2048/2048 bytes at offset 3757056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3761152 ++read 2048/2048 bytes at offset 3761152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3765248 ++read 2048/2048 bytes at offset 3765248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3769344 ++read 2048/2048 bytes at offset 3769344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3773440 ++read 2048/2048 bytes at offset 3773440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3777536 ++read 2048/2048 bytes at offset 3777536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3781632 ++read 2048/2048 bytes at offset 3781632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3785728 ++read 2048/2048 bytes at offset 3785728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3789824 ++read 2048/2048 bytes at offset 3789824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3793920 ++read 2048/2048 bytes at offset 3793920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3798016 ++read 2048/2048 bytes at offset 3798016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3802112 ++read 2048/2048 bytes at offset 3802112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3806208 ++read 2048/2048 bytes at offset 3806208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3810304 ++read 2048/2048 bytes at offset 3810304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3814400 ++read 2048/2048 bytes at offset 3814400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3818496 ++read 2048/2048 bytes at offset 3818496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3822592 ++read 2048/2048 bytes at offset 3822592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3826688 ++read 2048/2048 bytes at offset 3826688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3830784 ++read 2048/2048 bytes at offset 3830784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3834880 ++read 2048/2048 bytes at offset 3834880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3838976 ++read 2048/2048 bytes at offset 3838976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3843072 ++read 2048/2048 bytes at offset 3843072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3847168 ++read 2048/2048 bytes at offset 3847168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3851264 ++read 2048/2048 bytes at offset 3851264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3855360 ++read 2048/2048 bytes at offset 3855360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3859456 ++read 2048/2048 bytes at offset 3859456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3863552 ++read 2048/2048 bytes at offset 3863552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3867648 ++read 2048/2048 bytes at offset 3867648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3871744 ++read 2048/2048 bytes at offset 3871744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3875840 ++read 2048/2048 bytes at offset 3875840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3879936 ++read 2048/2048 bytes at offset 3879936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3884032 ++read 2048/2048 bytes at offset 3884032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3888128 ++read 2048/2048 bytes at offset 3888128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3892224 ++read 2048/2048 bytes at offset 3892224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3896320 ++read 2048/2048 bytes at offset 3896320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3900416 ++read 2048/2048 bytes at offset 3900416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3904512 ++read 2048/2048 bytes at offset 3904512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3908608 ++read 2048/2048 bytes at offset 3908608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3912704 ++read 2048/2048 bytes at offset 3912704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3916800 ++read 2048/2048 bytes at offset 3916800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3920896 ++read 2048/2048 bytes at offset 3920896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3924992 ++read 2048/2048 bytes at offset 3924992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3929088 ++read 2048/2048 bytes at offset 3929088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3933184 ++read 2048/2048 bytes at offset 3933184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3937280 ++read 2048/2048 bytes at offset 3937280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3941376 ++read 2048/2048 bytes at offset 3941376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3945472 ++read 2048/2048 bytes at offset 3945472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3949568 ++read 2048/2048 bytes at offset 3949568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3953664 ++read 2048/2048 bytes at offset 3953664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3957760 ++read 2048/2048 bytes at offset 3957760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3961856 ++read 2048/2048 bytes at offset 3961856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3965952 ++read 2048/2048 bytes at offset 3965952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3970048 ++read 2048/2048 bytes at offset 3970048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3974144 ++read 2048/2048 bytes at offset 3974144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3978240 ++read 2048/2048 bytes at offset 3978240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3982336 ++read 2048/2048 bytes at offset 3982336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3986432 ++read 2048/2048 bytes at offset 3986432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3990528 ++read 2048/2048 bytes at offset 3990528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3994624 ++read 2048/2048 bytes at offset 3994624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3998720 ++read 2048/2048 bytes at offset 3998720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4002816 ++read 2048/2048 bytes at offset 4002816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4006912 ++read 2048/2048 bytes at offset 4006912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4011008 ++read 2048/2048 bytes at offset 4011008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4015104 ++read 2048/2048 bytes at offset 4015104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4019200 ++read 2048/2048 bytes at offset 4019200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4023296 ++read 2048/2048 bytes at offset 4023296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4027392 ++read 2048/2048 bytes at offset 4027392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4031488 ++read 2048/2048 bytes at offset 4031488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4035584 ++read 2048/2048 bytes at offset 4035584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4039680 ++read 2048/2048 bytes at offset 4039680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4043776 ++read 2048/2048 bytes at offset 4043776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4047872 ++read 2048/2048 bytes at offset 4047872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4051968 ++read 2048/2048 bytes at offset 4051968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4056064 ++read 2048/2048 bytes at offset 4056064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4060160 ++read 2048/2048 bytes at offset 4060160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4064256 ++read 2048/2048 bytes at offset 4064256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4068352 ++read 2048/2048 bytes at offset 4068352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4072448 ++read 2048/2048 bytes at offset 4072448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4076544 ++read 2048/2048 bytes at offset 4076544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4080640 ++read 2048/2048 bytes at offset 4080640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4084736 ++read 2048/2048 bytes at offset 4084736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4088832 ++read 2048/2048 bytes at offset 4088832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4092928 ++read 2048/2048 bytes at offset 4092928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4097024 ++read 2048/2048 bytes at offset 4097024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4101120 ++read 2048/2048 bytes at offset 4101120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4105216 ++read 2048/2048 bytes at offset 4105216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4109312 ++read 2048/2048 bytes at offset 4109312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4113408 ++read 2048/2048 bytes at offset 4113408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4117504 ++read 2048/2048 bytes at offset 4117504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4121600 ++read 2048/2048 bytes at offset 4121600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4125696 ++read 2048/2048 bytes at offset 4125696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4129792 ++read 2048/2048 bytes at offset 4129792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4133888 ++read 2048/2048 bytes at offset 4133888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4137984 ++read 2048/2048 bytes at offset 4137984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4142080 ++read 2048/2048 bytes at offset 4142080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4146176 ++read 2048/2048 bytes at offset 4146176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4150272 ++read 2048/2048 bytes at offset 4150272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4154368 ++read 2048/2048 bytes at offset 4154368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4158464 ++read 2048/2048 bytes at offset 4158464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4162560 ++read 2048/2048 bytes at offset 4162560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4166656 ++read 2048/2048 bytes at offset 4166656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4170752 ++read 2048/2048 bytes at offset 4170752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4174848 ++read 2048/2048 bytes at offset 4174848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4178944 ++read 2048/2048 bytes at offset 4178944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4183040 ++read 2048/2048 bytes at offset 4183040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4187136 ++read 2048/2048 bytes at offset 4187136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4191232 ++read 2048/2048 bytes at offset 4191232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 4 +-qemu-io> read 8192/8192 bytes at offset 4196352 ++=== IO: pattern 4 ++read 8192/8192 bytes at offset 4196352 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4208640 ++read 8192/8192 bytes at offset 4208640 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4220928 ++read 8192/8192 bytes at offset 4220928 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4233216 ++read 8192/8192 bytes at offset 4233216 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4245504 ++read 8192/8192 bytes at offset 4245504 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4257792 ++read 8192/8192 bytes at offset 4257792 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4270080 ++read 8192/8192 bytes at offset 4270080 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4282368 ++read 8192/8192 bytes at offset 4282368 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4294656 ++read 8192/8192 bytes at offset 4294656 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4306944 ++read 8192/8192 bytes at offset 4306944 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4319232 ++read 8192/8192 bytes at offset 4319232 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4331520 ++read 8192/8192 bytes at offset 4331520 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4343808 ++read 8192/8192 bytes at offset 4343808 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4356096 ++read 8192/8192 bytes at offset 4356096 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4368384 ++read 8192/8192 bytes at offset 4368384 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4380672 ++read 8192/8192 bytes at offset 4380672 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4392960 ++read 8192/8192 bytes at offset 4392960 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4405248 ++read 8192/8192 bytes at offset 4405248 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4417536 ++read 8192/8192 bytes at offset 4417536 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4429824 ++read 8192/8192 bytes at offset 4429824 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4442112 ++read 8192/8192 bytes at offset 4442112 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4454400 ++read 8192/8192 bytes at offset 4454400 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4466688 ++read 8192/8192 bytes at offset 4466688 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4478976 ++read 8192/8192 bytes at offset 4478976 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4491264 ++read 8192/8192 bytes at offset 4491264 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4503552 ++read 8192/8192 bytes at offset 4503552 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4515840 ++read 8192/8192 bytes at offset 4515840 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4528128 ++read 8192/8192 bytes at offset 4528128 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4540416 ++read 8192/8192 bytes at offset 4540416 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4552704 ++read 8192/8192 bytes at offset 4552704 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4564992 ++read 8192/8192 bytes at offset 4564992 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4577280 ++read 8192/8192 bytes at offset 4577280 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4589568 ++read 8192/8192 bytes at offset 4589568 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4601856 ++read 8192/8192 bytes at offset 4601856 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4614144 ++read 8192/8192 bytes at offset 4614144 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4626432 ++read 8192/8192 bytes at offset 4626432 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4638720 ++read 8192/8192 bytes at offset 4638720 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4651008 ++read 8192/8192 bytes at offset 4651008 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4663296 ++read 8192/8192 bytes at offset 4663296 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4675584 ++read 8192/8192 bytes at offset 4675584 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4687872 ++read 8192/8192 bytes at offset 4687872 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4700160 ++read 8192/8192 bytes at offset 4700160 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4712448 ++read 8192/8192 bytes at offset 4712448 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4724736 ++read 8192/8192 bytes at offset 4724736 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4737024 ++read 8192/8192 bytes at offset 4737024 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4749312 ++read 8192/8192 bytes at offset 4749312 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4761600 ++read 8192/8192 bytes at offset 4761600 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4773888 ++read 8192/8192 bytes at offset 4773888 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4786176 ++read 8192/8192 bytes at offset 4786176 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4798464 ++read 8192/8192 bytes at offset 4798464 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4810752 ++read 8192/8192 bytes at offset 4810752 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4823040 ++read 8192/8192 bytes at offset 4823040 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4835328 ++read 8192/8192 bytes at offset 4835328 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4847616 ++read 8192/8192 bytes at offset 4847616 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4859904 ++read 8192/8192 bytes at offset 4859904 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4872192 ++read 8192/8192 bytes at offset 4872192 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4884480 ++read 8192/8192 bytes at offset 4884480 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4896768 ++read 8192/8192 bytes at offset 4896768 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4909056 ++read 8192/8192 bytes at offset 4909056 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4921344 ++read 8192/8192 bytes at offset 4921344 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4933632 ++read 8192/8192 bytes at offset 4933632 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4945920 ++read 8192/8192 bytes at offset 4945920 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4958208 ++read 8192/8192 bytes at offset 4958208 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4970496 ++read 8192/8192 bytes at offset 4970496 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 244 +-qemu-io> read 12288/12288 bytes at offset 6285312 ++=== IO: pattern 244 ++read 12288/12288 bytes at offset 6285312 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 8384512 ++read 12288/12288 bytes at offset 8384512 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 10483712 ++read 12288/12288 bytes at offset 10483712 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 12582912 ++read 12288/12288 bytes at offset 12582912 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 14682112 ++read 12288/12288 bytes at offset 14682112 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 16781312 ++read 12288/12288 bytes at offset 16781312 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 18880512 ++read 12288/12288 bytes at offset 18880512 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 20979712 ++read 12288/12288 bytes at offset 20979712 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> wrote 4096/4096 bytes at offset 0 ++=== IO: pattern 0 ++wrote 4096/4096 bytes at offset 0 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4096 ++wrote 4096/4096 bytes at offset 4096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8192 ++wrote 4096/4096 bytes at offset 8192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 12288 ++wrote 4096/4096 bytes at offset 12288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 16384 ++wrote 4096/4096 bytes at offset 16384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 20480 ++wrote 4096/4096 bytes at offset 20480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 24576 ++wrote 4096/4096 bytes at offset 24576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 28672 ++wrote 4096/4096 bytes at offset 28672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 32768 ++wrote 4096/4096 bytes at offset 32768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 36864 ++wrote 4096/4096 bytes at offset 36864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 40960 ++wrote 4096/4096 bytes at offset 40960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 45056 ++wrote 4096/4096 bytes at offset 45056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 49152 ++wrote 4096/4096 bytes at offset 49152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 53248 ++wrote 4096/4096 bytes at offset 53248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 57344 ++wrote 4096/4096 bytes at offset 57344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 61440 ++wrote 4096/4096 bytes at offset 61440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 65536 ++wrote 4096/4096 bytes at offset 65536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 69632 ++wrote 4096/4096 bytes at offset 69632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 73728 ++wrote 4096/4096 bytes at offset 73728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 77824 ++wrote 4096/4096 bytes at offset 77824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 81920 ++wrote 4096/4096 bytes at offset 81920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 86016 ++wrote 4096/4096 bytes at offset 86016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 90112 ++wrote 4096/4096 bytes at offset 90112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 94208 ++wrote 4096/4096 bytes at offset 94208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 98304 ++wrote 4096/4096 bytes at offset 98304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 102400 ++wrote 4096/4096 bytes at offset 102400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 106496 ++wrote 4096/4096 bytes at offset 106496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 110592 ++wrote 4096/4096 bytes at offset 110592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 114688 ++wrote 4096/4096 bytes at offset 114688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 118784 ++wrote 4096/4096 bytes at offset 118784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 122880 ++wrote 4096/4096 bytes at offset 122880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 126976 ++wrote 4096/4096 bytes at offset 126976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 131072 ++wrote 4096/4096 bytes at offset 131072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 135168 ++wrote 4096/4096 bytes at offset 135168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 139264 ++wrote 4096/4096 bytes at offset 139264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 143360 ++wrote 4096/4096 bytes at offset 143360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 147456 ++wrote 4096/4096 bytes at offset 147456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 151552 ++wrote 4096/4096 bytes at offset 151552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 155648 ++wrote 4096/4096 bytes at offset 155648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 159744 ++wrote 4096/4096 bytes at offset 159744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 163840 ++wrote 4096/4096 bytes at offset 163840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 167936 ++wrote 4096/4096 bytes at offset 167936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 172032 ++wrote 4096/4096 bytes at offset 172032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 176128 ++wrote 4096/4096 bytes at offset 176128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 180224 ++wrote 4096/4096 bytes at offset 180224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 184320 ++wrote 4096/4096 bytes at offset 184320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 188416 ++wrote 4096/4096 bytes at offset 188416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 192512 ++wrote 4096/4096 bytes at offset 192512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 196608 ++wrote 4096/4096 bytes at offset 196608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 200704 ++wrote 4096/4096 bytes at offset 200704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 204800 ++wrote 4096/4096 bytes at offset 204800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 208896 ++wrote 4096/4096 bytes at offset 208896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 212992 ++wrote 4096/4096 bytes at offset 212992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 217088 ++wrote 4096/4096 bytes at offset 217088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 221184 ++wrote 4096/4096 bytes at offset 221184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 225280 ++wrote 4096/4096 bytes at offset 225280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 229376 ++wrote 4096/4096 bytes at offset 229376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 233472 ++wrote 4096/4096 bytes at offset 233472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 237568 ++wrote 4096/4096 bytes at offset 237568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 241664 ++wrote 4096/4096 bytes at offset 241664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 245760 ++wrote 4096/4096 bytes at offset 245760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 249856 ++wrote 4096/4096 bytes at offset 249856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 253952 ++wrote 4096/4096 bytes at offset 253952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 258048 ++wrote 4096/4096 bytes at offset 258048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 262144 ++wrote 4096/4096 bytes at offset 262144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 266240 ++wrote 4096/4096 bytes at offset 266240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 270336 ++wrote 4096/4096 bytes at offset 270336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 274432 ++wrote 4096/4096 bytes at offset 274432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 278528 ++wrote 4096/4096 bytes at offset 278528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 282624 ++wrote 4096/4096 bytes at offset 282624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 286720 ++wrote 4096/4096 bytes at offset 286720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 290816 ++wrote 4096/4096 bytes at offset 290816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 294912 ++wrote 4096/4096 bytes at offset 294912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 299008 ++wrote 4096/4096 bytes at offset 299008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 303104 ++wrote 4096/4096 bytes at offset 303104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 307200 ++wrote 4096/4096 bytes at offset 307200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 311296 ++wrote 4096/4096 bytes at offset 311296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 315392 ++wrote 4096/4096 bytes at offset 315392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 319488 ++wrote 4096/4096 bytes at offset 319488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 323584 ++wrote 4096/4096 bytes at offset 323584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 327680 ++wrote 4096/4096 bytes at offset 327680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 331776 ++wrote 4096/4096 bytes at offset 331776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 335872 ++wrote 4096/4096 bytes at offset 335872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 339968 ++wrote 4096/4096 bytes at offset 339968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 344064 ++wrote 4096/4096 bytes at offset 344064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 348160 ++wrote 4096/4096 bytes at offset 348160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 352256 ++wrote 4096/4096 bytes at offset 352256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 356352 ++wrote 4096/4096 bytes at offset 356352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 360448 ++wrote 4096/4096 bytes at offset 360448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 364544 ++wrote 4096/4096 bytes at offset 364544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 368640 ++wrote 4096/4096 bytes at offset 368640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 372736 ++wrote 4096/4096 bytes at offset 372736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 376832 ++wrote 4096/4096 bytes at offset 376832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 380928 ++wrote 4096/4096 bytes at offset 380928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 385024 ++wrote 4096/4096 bytes at offset 385024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 389120 ++wrote 4096/4096 bytes at offset 389120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 393216 ++wrote 4096/4096 bytes at offset 393216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 397312 ++wrote 4096/4096 bytes at offset 397312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 401408 ++wrote 4096/4096 bytes at offset 401408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 405504 ++wrote 4096/4096 bytes at offset 405504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 409600 ++wrote 4096/4096 bytes at offset 409600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 413696 ++wrote 4096/4096 bytes at offset 413696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 417792 ++wrote 4096/4096 bytes at offset 417792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 421888 ++wrote 4096/4096 bytes at offset 421888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 425984 ++wrote 4096/4096 bytes at offset 425984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 430080 ++wrote 4096/4096 bytes at offset 430080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 434176 ++wrote 4096/4096 bytes at offset 434176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 438272 ++wrote 4096/4096 bytes at offset 438272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 442368 ++wrote 4096/4096 bytes at offset 442368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 446464 ++wrote 4096/4096 bytes at offset 446464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 450560 ++wrote 4096/4096 bytes at offset 450560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 454656 ++wrote 4096/4096 bytes at offset 454656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 458752 ++wrote 4096/4096 bytes at offset 458752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 462848 ++wrote 4096/4096 bytes at offset 462848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 466944 ++wrote 4096/4096 bytes at offset 466944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 471040 ++wrote 4096/4096 bytes at offset 471040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 475136 ++wrote 4096/4096 bytes at offset 475136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 479232 ++wrote 4096/4096 bytes at offset 479232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 483328 ++wrote 4096/4096 bytes at offset 483328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 487424 ++wrote 4096/4096 bytes at offset 487424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 491520 ++wrote 4096/4096 bytes at offset 491520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 495616 ++wrote 4096/4096 bytes at offset 495616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 499712 ++wrote 4096/4096 bytes at offset 499712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 503808 ++wrote 4096/4096 bytes at offset 503808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 507904 ++wrote 4096/4096 bytes at offset 507904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 512000 ++wrote 4096/4096 bytes at offset 512000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 516096 ++wrote 4096/4096 bytes at offset 516096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 520192 ++wrote 4096/4096 bytes at offset 520192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 524288 ++wrote 4096/4096 bytes at offset 524288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 528384 ++wrote 4096/4096 bytes at offset 528384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 532480 ++wrote 4096/4096 bytes at offset 532480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 536576 ++wrote 4096/4096 bytes at offset 536576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 540672 ++wrote 4096/4096 bytes at offset 540672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 544768 ++wrote 4096/4096 bytes at offset 544768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 548864 ++wrote 4096/4096 bytes at offset 548864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 552960 ++wrote 4096/4096 bytes at offset 552960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 557056 ++wrote 4096/4096 bytes at offset 557056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 561152 ++wrote 4096/4096 bytes at offset 561152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 565248 ++wrote 4096/4096 bytes at offset 565248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 569344 ++wrote 4096/4096 bytes at offset 569344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 573440 ++wrote 4096/4096 bytes at offset 573440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 577536 ++wrote 4096/4096 bytes at offset 577536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 581632 ++wrote 4096/4096 bytes at offset 581632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 585728 ++wrote 4096/4096 bytes at offset 585728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 589824 ++wrote 4096/4096 bytes at offset 589824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 593920 ++wrote 4096/4096 bytes at offset 593920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 598016 ++wrote 4096/4096 bytes at offset 598016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 602112 ++wrote 4096/4096 bytes at offset 602112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 606208 ++wrote 4096/4096 bytes at offset 606208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 610304 ++wrote 4096/4096 bytes at offset 610304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 614400 ++wrote 4096/4096 bytes at offset 614400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 618496 ++wrote 4096/4096 bytes at offset 618496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 622592 ++wrote 4096/4096 bytes at offset 622592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 626688 ++wrote 4096/4096 bytes at offset 626688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 630784 ++wrote 4096/4096 bytes at offset 630784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 634880 ++wrote 4096/4096 bytes at offset 634880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 638976 ++wrote 4096/4096 bytes at offset 638976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 643072 ++wrote 4096/4096 bytes at offset 643072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 647168 ++wrote 4096/4096 bytes at offset 647168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 651264 ++wrote 4096/4096 bytes at offset 651264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 655360 ++wrote 4096/4096 bytes at offset 655360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 659456 ++wrote 4096/4096 bytes at offset 659456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 663552 ++wrote 4096/4096 bytes at offset 663552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 667648 ++wrote 4096/4096 bytes at offset 667648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 671744 ++wrote 4096/4096 bytes at offset 671744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 675840 ++wrote 4096/4096 bytes at offset 675840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 679936 ++wrote 4096/4096 bytes at offset 679936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 684032 ++wrote 4096/4096 bytes at offset 684032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 688128 ++wrote 4096/4096 bytes at offset 688128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 692224 ++wrote 4096/4096 bytes at offset 692224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 696320 ++wrote 4096/4096 bytes at offset 696320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 700416 ++wrote 4096/4096 bytes at offset 700416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 704512 ++wrote 4096/4096 bytes at offset 704512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 708608 ++wrote 4096/4096 bytes at offset 708608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 712704 ++wrote 4096/4096 bytes at offset 712704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 716800 ++wrote 4096/4096 bytes at offset 716800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 720896 ++wrote 4096/4096 bytes at offset 720896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 724992 ++wrote 4096/4096 bytes at offset 724992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 729088 ++wrote 4096/4096 bytes at offset 729088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 733184 ++wrote 4096/4096 bytes at offset 733184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 737280 ++wrote 4096/4096 bytes at offset 737280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 741376 ++wrote 4096/4096 bytes at offset 741376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 745472 ++wrote 4096/4096 bytes at offset 745472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 749568 ++wrote 4096/4096 bytes at offset 749568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 753664 ++wrote 4096/4096 bytes at offset 753664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 757760 ++wrote 4096/4096 bytes at offset 757760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 761856 ++wrote 4096/4096 bytes at offset 761856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 765952 ++wrote 4096/4096 bytes at offset 765952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 770048 ++wrote 4096/4096 bytes at offset 770048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 774144 ++wrote 4096/4096 bytes at offset 774144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 778240 ++wrote 4096/4096 bytes at offset 778240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 782336 ++wrote 4096/4096 bytes at offset 782336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 786432 ++wrote 4096/4096 bytes at offset 786432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 790528 ++wrote 4096/4096 bytes at offset 790528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 794624 ++wrote 4096/4096 bytes at offset 794624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 798720 ++wrote 4096/4096 bytes at offset 798720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 802816 ++wrote 4096/4096 bytes at offset 802816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 806912 ++wrote 4096/4096 bytes at offset 806912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 811008 ++wrote 4096/4096 bytes at offset 811008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 815104 ++wrote 4096/4096 bytes at offset 815104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 819200 ++wrote 4096/4096 bytes at offset 819200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 823296 ++wrote 4096/4096 bytes at offset 823296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 827392 ++wrote 4096/4096 bytes at offset 827392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 831488 ++wrote 4096/4096 bytes at offset 831488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 835584 ++wrote 4096/4096 bytes at offset 835584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 839680 ++wrote 4096/4096 bytes at offset 839680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 843776 ++wrote 4096/4096 bytes at offset 843776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 847872 ++wrote 4096/4096 bytes at offset 847872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 851968 ++wrote 4096/4096 bytes at offset 851968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 856064 ++wrote 4096/4096 bytes at offset 856064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 860160 ++wrote 4096/4096 bytes at offset 860160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 864256 ++wrote 4096/4096 bytes at offset 864256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 868352 ++wrote 4096/4096 bytes at offset 868352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 872448 ++wrote 4096/4096 bytes at offset 872448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 876544 ++wrote 4096/4096 bytes at offset 876544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 880640 ++wrote 4096/4096 bytes at offset 880640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 884736 ++wrote 4096/4096 bytes at offset 884736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 888832 ++wrote 4096/4096 bytes at offset 888832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 892928 ++wrote 4096/4096 bytes at offset 892928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 897024 ++wrote 4096/4096 bytes at offset 897024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 901120 ++wrote 4096/4096 bytes at offset 901120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 905216 ++wrote 4096/4096 bytes at offset 905216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 909312 ++wrote 4096/4096 bytes at offset 909312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 913408 ++wrote 4096/4096 bytes at offset 913408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 917504 ++wrote 4096/4096 bytes at offset 917504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 921600 ++wrote 4096/4096 bytes at offset 921600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 925696 ++wrote 4096/4096 bytes at offset 925696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 929792 ++wrote 4096/4096 bytes at offset 929792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 933888 ++wrote 4096/4096 bytes at offset 933888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 937984 ++wrote 4096/4096 bytes at offset 937984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 942080 ++wrote 4096/4096 bytes at offset 942080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 946176 ++wrote 4096/4096 bytes at offset 946176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 950272 ++wrote 4096/4096 bytes at offset 950272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 954368 ++wrote 4096/4096 bytes at offset 954368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 958464 ++wrote 4096/4096 bytes at offset 958464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 962560 ++wrote 4096/4096 bytes at offset 962560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 966656 ++wrote 4096/4096 bytes at offset 966656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 970752 ++wrote 4096/4096 bytes at offset 970752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 974848 ++wrote 4096/4096 bytes at offset 974848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 978944 ++wrote 4096/4096 bytes at offset 978944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 983040 ++wrote 4096/4096 bytes at offset 983040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 987136 ++wrote 4096/4096 bytes at offset 987136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 991232 ++wrote 4096/4096 bytes at offset 991232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 995328 ++wrote 4096/4096 bytes at offset 995328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 999424 ++wrote 4096/4096 bytes at offset 999424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1003520 ++wrote 4096/4096 bytes at offset 1003520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1007616 ++wrote 4096/4096 bytes at offset 1007616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1011712 ++wrote 4096/4096 bytes at offset 1011712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1015808 ++wrote 4096/4096 bytes at offset 1015808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1019904 ++wrote 4096/4096 bytes at offset 1019904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1024000 ++wrote 4096/4096 bytes at offset 1024000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1028096 ++wrote 4096/4096 bytes at offset 1028096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1032192 ++wrote 4096/4096 bytes at offset 1032192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1036288 ++wrote 4096/4096 bytes at offset 1036288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1040384 ++wrote 4096/4096 bytes at offset 1040384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 1044480 ++wrote 4096/4096 bytes at offset 1044480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 4 +-qemu-io> wrote 2048/2048 bytes at offset 1050624 ++=== IO: pattern 4 ++wrote 2048/2048 bytes at offset 1050624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1054720 ++wrote 2048/2048 bytes at offset 1054720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1058816 ++wrote 2048/2048 bytes at offset 1058816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1062912 ++wrote 2048/2048 bytes at offset 1062912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1067008 ++wrote 2048/2048 bytes at offset 1067008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1071104 ++wrote 2048/2048 bytes at offset 1071104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1075200 ++wrote 2048/2048 bytes at offset 1075200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1079296 ++wrote 2048/2048 bytes at offset 1079296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1083392 ++wrote 2048/2048 bytes at offset 1083392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1087488 ++wrote 2048/2048 bytes at offset 1087488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1091584 ++wrote 2048/2048 bytes at offset 1091584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1095680 ++wrote 2048/2048 bytes at offset 1095680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1099776 ++wrote 2048/2048 bytes at offset 1099776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1103872 ++wrote 2048/2048 bytes at offset 1103872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1107968 ++wrote 2048/2048 bytes at offset 1107968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1112064 ++wrote 2048/2048 bytes at offset 1112064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1116160 ++wrote 2048/2048 bytes at offset 1116160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1120256 ++wrote 2048/2048 bytes at offset 1120256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1124352 ++wrote 2048/2048 bytes at offset 1124352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1128448 ++wrote 2048/2048 bytes at offset 1128448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1132544 ++wrote 2048/2048 bytes at offset 1132544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1136640 ++wrote 2048/2048 bytes at offset 1136640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1140736 ++wrote 2048/2048 bytes at offset 1140736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1144832 ++wrote 2048/2048 bytes at offset 1144832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1148928 ++wrote 2048/2048 bytes at offset 1148928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1153024 ++wrote 2048/2048 bytes at offset 1153024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1157120 ++wrote 2048/2048 bytes at offset 1157120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1161216 ++wrote 2048/2048 bytes at offset 1161216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1165312 ++wrote 2048/2048 bytes at offset 1165312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1169408 ++wrote 2048/2048 bytes at offset 1169408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1173504 ++wrote 2048/2048 bytes at offset 1173504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1177600 ++wrote 2048/2048 bytes at offset 1177600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1181696 ++wrote 2048/2048 bytes at offset 1181696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1185792 ++wrote 2048/2048 bytes at offset 1185792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1189888 ++wrote 2048/2048 bytes at offset 1189888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1193984 ++wrote 2048/2048 bytes at offset 1193984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1198080 ++wrote 2048/2048 bytes at offset 1198080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1202176 ++wrote 2048/2048 bytes at offset 1202176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1206272 ++wrote 2048/2048 bytes at offset 1206272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1210368 ++wrote 2048/2048 bytes at offset 1210368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1214464 ++wrote 2048/2048 bytes at offset 1214464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1218560 ++wrote 2048/2048 bytes at offset 1218560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1222656 ++wrote 2048/2048 bytes at offset 1222656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1226752 ++wrote 2048/2048 bytes at offset 1226752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1230848 ++wrote 2048/2048 bytes at offset 1230848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1234944 ++wrote 2048/2048 bytes at offset 1234944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1239040 ++wrote 2048/2048 bytes at offset 1239040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1243136 ++wrote 2048/2048 bytes at offset 1243136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1247232 ++wrote 2048/2048 bytes at offset 1247232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1251328 ++wrote 2048/2048 bytes at offset 1251328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1255424 ++wrote 2048/2048 bytes at offset 1255424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1259520 ++wrote 2048/2048 bytes at offset 1259520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1263616 ++wrote 2048/2048 bytes at offset 1263616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1267712 ++wrote 2048/2048 bytes at offset 1267712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1271808 ++wrote 2048/2048 bytes at offset 1271808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1275904 ++wrote 2048/2048 bytes at offset 1275904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1280000 ++wrote 2048/2048 bytes at offset 1280000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1284096 ++wrote 2048/2048 bytes at offset 1284096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1288192 ++wrote 2048/2048 bytes at offset 1288192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1292288 ++wrote 2048/2048 bytes at offset 1292288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1296384 ++wrote 2048/2048 bytes at offset 1296384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1300480 ++wrote 2048/2048 bytes at offset 1300480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1304576 ++wrote 2048/2048 bytes at offset 1304576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1308672 ++wrote 2048/2048 bytes at offset 1308672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1312768 ++wrote 2048/2048 bytes at offset 1312768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1316864 ++wrote 2048/2048 bytes at offset 1316864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1320960 ++wrote 2048/2048 bytes at offset 1320960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1325056 ++wrote 2048/2048 bytes at offset 1325056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1329152 ++wrote 2048/2048 bytes at offset 1329152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1333248 ++wrote 2048/2048 bytes at offset 1333248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1337344 ++wrote 2048/2048 bytes at offset 1337344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1341440 ++wrote 2048/2048 bytes at offset 1341440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1345536 ++wrote 2048/2048 bytes at offset 1345536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1349632 ++wrote 2048/2048 bytes at offset 1349632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1353728 ++wrote 2048/2048 bytes at offset 1353728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1357824 ++wrote 2048/2048 bytes at offset 1357824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1361920 ++wrote 2048/2048 bytes at offset 1361920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1366016 ++wrote 2048/2048 bytes at offset 1366016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1370112 ++wrote 2048/2048 bytes at offset 1370112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1374208 ++wrote 2048/2048 bytes at offset 1374208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1378304 ++wrote 2048/2048 bytes at offset 1378304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1382400 ++wrote 2048/2048 bytes at offset 1382400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1386496 ++wrote 2048/2048 bytes at offset 1386496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1390592 ++wrote 2048/2048 bytes at offset 1390592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1394688 ++wrote 2048/2048 bytes at offset 1394688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1398784 ++wrote 2048/2048 bytes at offset 1398784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1402880 ++wrote 2048/2048 bytes at offset 1402880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1406976 ++wrote 2048/2048 bytes at offset 1406976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1411072 ++wrote 2048/2048 bytes at offset 1411072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1415168 ++wrote 2048/2048 bytes at offset 1415168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1419264 ++wrote 2048/2048 bytes at offset 1419264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1423360 ++wrote 2048/2048 bytes at offset 1423360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1427456 ++wrote 2048/2048 bytes at offset 1427456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1431552 ++wrote 2048/2048 bytes at offset 1431552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1435648 ++wrote 2048/2048 bytes at offset 1435648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1439744 ++wrote 2048/2048 bytes at offset 1439744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1443840 ++wrote 2048/2048 bytes at offset 1443840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1447936 ++wrote 2048/2048 bytes at offset 1447936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1452032 ++wrote 2048/2048 bytes at offset 1452032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1456128 ++wrote 2048/2048 bytes at offset 1456128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1460224 ++wrote 2048/2048 bytes at offset 1460224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1464320 ++wrote 2048/2048 bytes at offset 1464320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1468416 ++wrote 2048/2048 bytes at offset 1468416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1472512 ++wrote 2048/2048 bytes at offset 1472512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1476608 ++wrote 2048/2048 bytes at offset 1476608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1480704 ++wrote 2048/2048 bytes at offset 1480704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1484800 ++wrote 2048/2048 bytes at offset 1484800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1488896 ++wrote 2048/2048 bytes at offset 1488896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1492992 ++wrote 2048/2048 bytes at offset 1492992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1497088 ++wrote 2048/2048 bytes at offset 1497088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1501184 ++wrote 2048/2048 bytes at offset 1501184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1505280 ++wrote 2048/2048 bytes at offset 1505280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1509376 ++wrote 2048/2048 bytes at offset 1509376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1513472 ++wrote 2048/2048 bytes at offset 1513472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1517568 ++wrote 2048/2048 bytes at offset 1517568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1521664 ++wrote 2048/2048 bytes at offset 1521664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1525760 ++wrote 2048/2048 bytes at offset 1525760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1529856 ++wrote 2048/2048 bytes at offset 1529856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1533952 ++wrote 2048/2048 bytes at offset 1533952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1538048 ++wrote 2048/2048 bytes at offset 1538048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1542144 ++wrote 2048/2048 bytes at offset 1542144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1546240 ++wrote 2048/2048 bytes at offset 1546240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1550336 ++wrote 2048/2048 bytes at offset 1550336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1554432 ++wrote 2048/2048 bytes at offset 1554432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1558528 ++wrote 2048/2048 bytes at offset 1558528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1562624 ++wrote 2048/2048 bytes at offset 1562624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1566720 ++wrote 2048/2048 bytes at offset 1566720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1570816 ++wrote 2048/2048 bytes at offset 1570816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1574912 ++wrote 2048/2048 bytes at offset 1574912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1579008 ++wrote 2048/2048 bytes at offset 1579008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1583104 ++wrote 2048/2048 bytes at offset 1583104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1587200 ++wrote 2048/2048 bytes at offset 1587200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1591296 ++wrote 2048/2048 bytes at offset 1591296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1595392 ++wrote 2048/2048 bytes at offset 1595392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1599488 ++wrote 2048/2048 bytes at offset 1599488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1603584 ++wrote 2048/2048 bytes at offset 1603584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1607680 ++wrote 2048/2048 bytes at offset 1607680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1611776 ++wrote 2048/2048 bytes at offset 1611776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1615872 ++wrote 2048/2048 bytes at offset 1615872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1619968 ++wrote 2048/2048 bytes at offset 1619968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1624064 ++wrote 2048/2048 bytes at offset 1624064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1628160 ++wrote 2048/2048 bytes at offset 1628160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1632256 ++wrote 2048/2048 bytes at offset 1632256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1636352 ++wrote 2048/2048 bytes at offset 1636352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1640448 ++wrote 2048/2048 bytes at offset 1640448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1644544 ++wrote 2048/2048 bytes at offset 1644544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1648640 ++wrote 2048/2048 bytes at offset 1648640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1652736 ++wrote 2048/2048 bytes at offset 1652736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1656832 ++wrote 2048/2048 bytes at offset 1656832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1660928 ++wrote 2048/2048 bytes at offset 1660928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1665024 ++wrote 2048/2048 bytes at offset 1665024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1669120 ++wrote 2048/2048 bytes at offset 1669120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1673216 ++wrote 2048/2048 bytes at offset 1673216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1677312 ++wrote 2048/2048 bytes at offset 1677312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1681408 ++wrote 2048/2048 bytes at offset 1681408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1685504 ++wrote 2048/2048 bytes at offset 1685504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1689600 ++wrote 2048/2048 bytes at offset 1689600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1693696 ++wrote 2048/2048 bytes at offset 1693696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1697792 ++wrote 2048/2048 bytes at offset 1697792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1701888 ++wrote 2048/2048 bytes at offset 1701888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1705984 ++wrote 2048/2048 bytes at offset 1705984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1710080 ++wrote 2048/2048 bytes at offset 1710080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1714176 ++wrote 2048/2048 bytes at offset 1714176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1718272 ++wrote 2048/2048 bytes at offset 1718272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1722368 ++wrote 2048/2048 bytes at offset 1722368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1726464 ++wrote 2048/2048 bytes at offset 1726464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1730560 ++wrote 2048/2048 bytes at offset 1730560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1734656 ++wrote 2048/2048 bytes at offset 1734656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1738752 ++wrote 2048/2048 bytes at offset 1738752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1742848 ++wrote 2048/2048 bytes at offset 1742848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1746944 ++wrote 2048/2048 bytes at offset 1746944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1751040 ++wrote 2048/2048 bytes at offset 1751040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1755136 ++wrote 2048/2048 bytes at offset 1755136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1759232 ++wrote 2048/2048 bytes at offset 1759232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1763328 ++wrote 2048/2048 bytes at offset 1763328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1767424 ++wrote 2048/2048 bytes at offset 1767424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1771520 ++wrote 2048/2048 bytes at offset 1771520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1775616 ++wrote 2048/2048 bytes at offset 1775616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1779712 ++wrote 2048/2048 bytes at offset 1779712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1783808 ++wrote 2048/2048 bytes at offset 1783808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1787904 ++wrote 2048/2048 bytes at offset 1787904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1792000 ++wrote 2048/2048 bytes at offset 1792000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1796096 ++wrote 2048/2048 bytes at offset 1796096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1800192 ++wrote 2048/2048 bytes at offset 1800192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1804288 ++wrote 2048/2048 bytes at offset 1804288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1808384 ++wrote 2048/2048 bytes at offset 1808384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1812480 ++wrote 2048/2048 bytes at offset 1812480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1816576 ++wrote 2048/2048 bytes at offset 1816576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1820672 ++wrote 2048/2048 bytes at offset 1820672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1824768 ++wrote 2048/2048 bytes at offset 1824768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1828864 ++wrote 2048/2048 bytes at offset 1828864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1832960 ++wrote 2048/2048 bytes at offset 1832960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1837056 ++wrote 2048/2048 bytes at offset 1837056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1841152 ++wrote 2048/2048 bytes at offset 1841152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1845248 ++wrote 2048/2048 bytes at offset 1845248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1849344 ++wrote 2048/2048 bytes at offset 1849344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1853440 ++wrote 2048/2048 bytes at offset 1853440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1857536 ++wrote 2048/2048 bytes at offset 1857536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1861632 ++wrote 2048/2048 bytes at offset 1861632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1865728 ++wrote 2048/2048 bytes at offset 1865728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1869824 ++wrote 2048/2048 bytes at offset 1869824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1873920 ++wrote 2048/2048 bytes at offset 1873920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1878016 ++wrote 2048/2048 bytes at offset 1878016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1882112 ++wrote 2048/2048 bytes at offset 1882112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1886208 ++wrote 2048/2048 bytes at offset 1886208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1890304 ++wrote 2048/2048 bytes at offset 1890304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1894400 ++wrote 2048/2048 bytes at offset 1894400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1898496 ++wrote 2048/2048 bytes at offset 1898496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1902592 ++wrote 2048/2048 bytes at offset 1902592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1906688 ++wrote 2048/2048 bytes at offset 1906688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1910784 ++wrote 2048/2048 bytes at offset 1910784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1914880 ++wrote 2048/2048 bytes at offset 1914880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1918976 ++wrote 2048/2048 bytes at offset 1918976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1923072 ++wrote 2048/2048 bytes at offset 1923072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1927168 ++wrote 2048/2048 bytes at offset 1927168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1931264 ++wrote 2048/2048 bytes at offset 1931264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1935360 ++wrote 2048/2048 bytes at offset 1935360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1939456 ++wrote 2048/2048 bytes at offset 1939456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1943552 ++wrote 2048/2048 bytes at offset 1943552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1947648 ++wrote 2048/2048 bytes at offset 1947648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1951744 ++wrote 2048/2048 bytes at offset 1951744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1955840 ++wrote 2048/2048 bytes at offset 1955840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1959936 ++wrote 2048/2048 bytes at offset 1959936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1964032 ++wrote 2048/2048 bytes at offset 1964032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1968128 ++wrote 2048/2048 bytes at offset 1968128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1972224 ++wrote 2048/2048 bytes at offset 1972224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1976320 ++wrote 2048/2048 bytes at offset 1976320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1980416 ++wrote 2048/2048 bytes at offset 1980416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1984512 ++wrote 2048/2048 bytes at offset 1984512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1988608 ++wrote 2048/2048 bytes at offset 1988608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1992704 ++wrote 2048/2048 bytes at offset 1992704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 1996800 ++wrote 2048/2048 bytes at offset 1996800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2000896 ++wrote 2048/2048 bytes at offset 2000896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2004992 ++wrote 2048/2048 bytes at offset 2004992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2009088 ++wrote 2048/2048 bytes at offset 2009088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2013184 ++wrote 2048/2048 bytes at offset 2013184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2017280 ++wrote 2048/2048 bytes at offset 2017280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2021376 ++wrote 2048/2048 bytes at offset 2021376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2025472 ++wrote 2048/2048 bytes at offset 2025472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2029568 ++wrote 2048/2048 bytes at offset 2029568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2033664 ++wrote 2048/2048 bytes at offset 2033664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2037760 ++wrote 2048/2048 bytes at offset 2037760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2041856 ++wrote 2048/2048 bytes at offset 2041856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2045952 ++wrote 2048/2048 bytes at offset 2045952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2050048 ++wrote 2048/2048 bytes at offset 2050048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2054144 ++wrote 2048/2048 bytes at offset 2054144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2058240 ++wrote 2048/2048 bytes at offset 2058240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2062336 ++wrote 2048/2048 bytes at offset 2062336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2066432 ++wrote 2048/2048 bytes at offset 2066432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2070528 ++wrote 2048/2048 bytes at offset 2070528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2074624 ++wrote 2048/2048 bytes at offset 2074624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2078720 ++wrote 2048/2048 bytes at offset 2078720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2082816 ++wrote 2048/2048 bytes at offset 2082816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2086912 ++wrote 2048/2048 bytes at offset 2086912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2091008 ++wrote 2048/2048 bytes at offset 2091008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2095104 ++wrote 2048/2048 bytes at offset 2095104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> wrote 2048/2048 bytes at offset 2097152 ++=== IO: pattern 0 ++wrote 2048/2048 bytes at offset 2097152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2101248 ++wrote 2048/2048 bytes at offset 2101248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2105344 ++wrote 2048/2048 bytes at offset 2105344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2109440 ++wrote 2048/2048 bytes at offset 2109440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2113536 ++wrote 2048/2048 bytes at offset 2113536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2117632 ++wrote 2048/2048 bytes at offset 2117632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2121728 ++wrote 2048/2048 bytes at offset 2121728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2125824 ++wrote 2048/2048 bytes at offset 2125824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2129920 ++wrote 2048/2048 bytes at offset 2129920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2134016 ++wrote 2048/2048 bytes at offset 2134016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2138112 ++wrote 2048/2048 bytes at offset 2138112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2142208 ++wrote 2048/2048 bytes at offset 2142208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2146304 ++wrote 2048/2048 bytes at offset 2146304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2150400 ++wrote 2048/2048 bytes at offset 2150400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2154496 ++wrote 2048/2048 bytes at offset 2154496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2158592 ++wrote 2048/2048 bytes at offset 2158592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2162688 ++wrote 2048/2048 bytes at offset 2162688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2166784 ++wrote 2048/2048 bytes at offset 2166784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2170880 ++wrote 2048/2048 bytes at offset 2170880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2174976 ++wrote 2048/2048 bytes at offset 2174976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2179072 ++wrote 2048/2048 bytes at offset 2179072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2183168 ++wrote 2048/2048 bytes at offset 2183168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2187264 ++wrote 2048/2048 bytes at offset 2187264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2191360 ++wrote 2048/2048 bytes at offset 2191360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2195456 ++wrote 2048/2048 bytes at offset 2195456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2199552 ++wrote 2048/2048 bytes at offset 2199552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2203648 ++wrote 2048/2048 bytes at offset 2203648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2207744 ++wrote 2048/2048 bytes at offset 2207744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2211840 ++wrote 2048/2048 bytes at offset 2211840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2215936 ++wrote 2048/2048 bytes at offset 2215936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2220032 ++wrote 2048/2048 bytes at offset 2220032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2224128 ++wrote 2048/2048 bytes at offset 2224128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2228224 ++wrote 2048/2048 bytes at offset 2228224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2232320 ++wrote 2048/2048 bytes at offset 2232320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2236416 ++wrote 2048/2048 bytes at offset 2236416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2240512 ++wrote 2048/2048 bytes at offset 2240512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2244608 ++wrote 2048/2048 bytes at offset 2244608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2248704 ++wrote 2048/2048 bytes at offset 2248704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2252800 ++wrote 2048/2048 bytes at offset 2252800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2256896 ++wrote 2048/2048 bytes at offset 2256896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2260992 ++wrote 2048/2048 bytes at offset 2260992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2265088 ++wrote 2048/2048 bytes at offset 2265088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2269184 ++wrote 2048/2048 bytes at offset 2269184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2273280 ++wrote 2048/2048 bytes at offset 2273280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2277376 ++wrote 2048/2048 bytes at offset 2277376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2281472 ++wrote 2048/2048 bytes at offset 2281472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2285568 ++wrote 2048/2048 bytes at offset 2285568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2289664 ++wrote 2048/2048 bytes at offset 2289664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2293760 ++wrote 2048/2048 bytes at offset 2293760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2297856 ++wrote 2048/2048 bytes at offset 2297856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2301952 ++wrote 2048/2048 bytes at offset 2301952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2306048 ++wrote 2048/2048 bytes at offset 2306048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2310144 ++wrote 2048/2048 bytes at offset 2310144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2314240 ++wrote 2048/2048 bytes at offset 2314240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2318336 ++wrote 2048/2048 bytes at offset 2318336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2322432 ++wrote 2048/2048 bytes at offset 2322432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2326528 ++wrote 2048/2048 bytes at offset 2326528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2330624 ++wrote 2048/2048 bytes at offset 2330624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2334720 ++wrote 2048/2048 bytes at offset 2334720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2338816 ++wrote 2048/2048 bytes at offset 2338816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2342912 ++wrote 2048/2048 bytes at offset 2342912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2347008 ++wrote 2048/2048 bytes at offset 2347008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2351104 ++wrote 2048/2048 bytes at offset 2351104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2355200 ++wrote 2048/2048 bytes at offset 2355200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2359296 ++wrote 2048/2048 bytes at offset 2359296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2363392 ++wrote 2048/2048 bytes at offset 2363392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2367488 ++wrote 2048/2048 bytes at offset 2367488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2371584 ++wrote 2048/2048 bytes at offset 2371584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2375680 ++wrote 2048/2048 bytes at offset 2375680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2379776 ++wrote 2048/2048 bytes at offset 2379776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2383872 ++wrote 2048/2048 bytes at offset 2383872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2387968 ++wrote 2048/2048 bytes at offset 2387968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2392064 ++wrote 2048/2048 bytes at offset 2392064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2396160 ++wrote 2048/2048 bytes at offset 2396160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2400256 ++wrote 2048/2048 bytes at offset 2400256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2404352 ++wrote 2048/2048 bytes at offset 2404352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2408448 ++wrote 2048/2048 bytes at offset 2408448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2412544 ++wrote 2048/2048 bytes at offset 2412544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2416640 ++wrote 2048/2048 bytes at offset 2416640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2420736 ++wrote 2048/2048 bytes at offset 2420736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2424832 ++wrote 2048/2048 bytes at offset 2424832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2428928 ++wrote 2048/2048 bytes at offset 2428928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2433024 ++wrote 2048/2048 bytes at offset 2433024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2437120 ++wrote 2048/2048 bytes at offset 2437120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2441216 ++wrote 2048/2048 bytes at offset 2441216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2445312 ++wrote 2048/2048 bytes at offset 2445312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2449408 ++wrote 2048/2048 bytes at offset 2449408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2453504 ++wrote 2048/2048 bytes at offset 2453504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2457600 ++wrote 2048/2048 bytes at offset 2457600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2461696 ++wrote 2048/2048 bytes at offset 2461696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2465792 ++wrote 2048/2048 bytes at offset 2465792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2469888 ++wrote 2048/2048 bytes at offset 2469888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2473984 ++wrote 2048/2048 bytes at offset 2473984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2478080 ++wrote 2048/2048 bytes at offset 2478080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2482176 ++wrote 2048/2048 bytes at offset 2482176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2486272 ++wrote 2048/2048 bytes at offset 2486272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2490368 ++wrote 2048/2048 bytes at offset 2490368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2494464 ++wrote 2048/2048 bytes at offset 2494464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2498560 ++wrote 2048/2048 bytes at offset 2498560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2502656 ++wrote 2048/2048 bytes at offset 2502656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2506752 ++wrote 2048/2048 bytes at offset 2506752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2510848 ++wrote 2048/2048 bytes at offset 2510848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2514944 ++wrote 2048/2048 bytes at offset 2514944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2519040 ++wrote 2048/2048 bytes at offset 2519040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2523136 ++wrote 2048/2048 bytes at offset 2523136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2527232 ++wrote 2048/2048 bytes at offset 2527232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2531328 ++wrote 2048/2048 bytes at offset 2531328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2535424 ++wrote 2048/2048 bytes at offset 2535424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2539520 ++wrote 2048/2048 bytes at offset 2539520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2543616 ++wrote 2048/2048 bytes at offset 2543616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2547712 ++wrote 2048/2048 bytes at offset 2547712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2551808 ++wrote 2048/2048 bytes at offset 2551808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2555904 ++wrote 2048/2048 bytes at offset 2555904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2560000 ++wrote 2048/2048 bytes at offset 2560000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2564096 ++wrote 2048/2048 bytes at offset 2564096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2568192 ++wrote 2048/2048 bytes at offset 2568192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2572288 ++wrote 2048/2048 bytes at offset 2572288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2576384 ++wrote 2048/2048 bytes at offset 2576384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2580480 ++wrote 2048/2048 bytes at offset 2580480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2584576 ++wrote 2048/2048 bytes at offset 2584576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2588672 ++wrote 2048/2048 bytes at offset 2588672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2592768 ++wrote 2048/2048 bytes at offset 2592768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2596864 ++wrote 2048/2048 bytes at offset 2596864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2600960 ++wrote 2048/2048 bytes at offset 2600960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2605056 ++wrote 2048/2048 bytes at offset 2605056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2609152 ++wrote 2048/2048 bytes at offset 2609152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2613248 ++wrote 2048/2048 bytes at offset 2613248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2617344 ++wrote 2048/2048 bytes at offset 2617344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2621440 ++wrote 2048/2048 bytes at offset 2621440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2625536 ++wrote 2048/2048 bytes at offset 2625536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2629632 ++wrote 2048/2048 bytes at offset 2629632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2633728 ++wrote 2048/2048 bytes at offset 2633728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2637824 ++wrote 2048/2048 bytes at offset 2637824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2641920 ++wrote 2048/2048 bytes at offset 2641920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2646016 ++wrote 2048/2048 bytes at offset 2646016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2650112 ++wrote 2048/2048 bytes at offset 2650112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2654208 ++wrote 2048/2048 bytes at offset 2654208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2658304 ++wrote 2048/2048 bytes at offset 2658304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2662400 ++wrote 2048/2048 bytes at offset 2662400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2666496 ++wrote 2048/2048 bytes at offset 2666496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2670592 ++wrote 2048/2048 bytes at offset 2670592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2674688 ++wrote 2048/2048 bytes at offset 2674688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2678784 ++wrote 2048/2048 bytes at offset 2678784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2682880 ++wrote 2048/2048 bytes at offset 2682880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2686976 ++wrote 2048/2048 bytes at offset 2686976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2691072 ++wrote 2048/2048 bytes at offset 2691072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2695168 ++wrote 2048/2048 bytes at offset 2695168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2699264 ++wrote 2048/2048 bytes at offset 2699264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2703360 ++wrote 2048/2048 bytes at offset 2703360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2707456 ++wrote 2048/2048 bytes at offset 2707456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2711552 ++wrote 2048/2048 bytes at offset 2711552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2715648 ++wrote 2048/2048 bytes at offset 2715648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2719744 ++wrote 2048/2048 bytes at offset 2719744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2723840 ++wrote 2048/2048 bytes at offset 2723840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2727936 ++wrote 2048/2048 bytes at offset 2727936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2732032 ++wrote 2048/2048 bytes at offset 2732032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2736128 ++wrote 2048/2048 bytes at offset 2736128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2740224 ++wrote 2048/2048 bytes at offset 2740224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2744320 ++wrote 2048/2048 bytes at offset 2744320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2748416 ++wrote 2048/2048 bytes at offset 2748416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2752512 ++wrote 2048/2048 bytes at offset 2752512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2756608 ++wrote 2048/2048 bytes at offset 2756608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2760704 ++wrote 2048/2048 bytes at offset 2760704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2764800 ++wrote 2048/2048 bytes at offset 2764800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2768896 ++wrote 2048/2048 bytes at offset 2768896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2772992 ++wrote 2048/2048 bytes at offset 2772992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2777088 ++wrote 2048/2048 bytes at offset 2777088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2781184 ++wrote 2048/2048 bytes at offset 2781184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2785280 ++wrote 2048/2048 bytes at offset 2785280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2789376 ++wrote 2048/2048 bytes at offset 2789376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2793472 ++wrote 2048/2048 bytes at offset 2793472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2797568 ++wrote 2048/2048 bytes at offset 2797568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2801664 ++wrote 2048/2048 bytes at offset 2801664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2805760 ++wrote 2048/2048 bytes at offset 2805760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2809856 ++wrote 2048/2048 bytes at offset 2809856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2813952 ++wrote 2048/2048 bytes at offset 2813952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2818048 ++wrote 2048/2048 bytes at offset 2818048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2822144 ++wrote 2048/2048 bytes at offset 2822144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2826240 ++wrote 2048/2048 bytes at offset 2826240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2830336 ++wrote 2048/2048 bytes at offset 2830336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2834432 ++wrote 2048/2048 bytes at offset 2834432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2838528 ++wrote 2048/2048 bytes at offset 2838528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2842624 ++wrote 2048/2048 bytes at offset 2842624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2846720 ++wrote 2048/2048 bytes at offset 2846720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2850816 ++wrote 2048/2048 bytes at offset 2850816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2854912 ++wrote 2048/2048 bytes at offset 2854912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2859008 ++wrote 2048/2048 bytes at offset 2859008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2863104 ++wrote 2048/2048 bytes at offset 2863104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2867200 ++wrote 2048/2048 bytes at offset 2867200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2871296 ++wrote 2048/2048 bytes at offset 2871296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2875392 ++wrote 2048/2048 bytes at offset 2875392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2879488 ++wrote 2048/2048 bytes at offset 2879488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2883584 ++wrote 2048/2048 bytes at offset 2883584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2887680 ++wrote 2048/2048 bytes at offset 2887680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2891776 ++wrote 2048/2048 bytes at offset 2891776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2895872 ++wrote 2048/2048 bytes at offset 2895872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2899968 ++wrote 2048/2048 bytes at offset 2899968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2904064 ++wrote 2048/2048 bytes at offset 2904064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2908160 ++wrote 2048/2048 bytes at offset 2908160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2912256 ++wrote 2048/2048 bytes at offset 2912256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2916352 ++wrote 2048/2048 bytes at offset 2916352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2920448 ++wrote 2048/2048 bytes at offset 2920448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2924544 ++wrote 2048/2048 bytes at offset 2924544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2928640 ++wrote 2048/2048 bytes at offset 2928640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2932736 ++wrote 2048/2048 bytes at offset 2932736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2936832 ++wrote 2048/2048 bytes at offset 2936832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2940928 ++wrote 2048/2048 bytes at offset 2940928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2945024 ++wrote 2048/2048 bytes at offset 2945024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2949120 ++wrote 2048/2048 bytes at offset 2949120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2953216 ++wrote 2048/2048 bytes at offset 2953216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2957312 ++wrote 2048/2048 bytes at offset 2957312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2961408 ++wrote 2048/2048 bytes at offset 2961408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2965504 ++wrote 2048/2048 bytes at offset 2965504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2969600 ++wrote 2048/2048 bytes at offset 2969600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2973696 ++wrote 2048/2048 bytes at offset 2973696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2977792 ++wrote 2048/2048 bytes at offset 2977792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2981888 ++wrote 2048/2048 bytes at offset 2981888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2985984 ++wrote 2048/2048 bytes at offset 2985984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2990080 ++wrote 2048/2048 bytes at offset 2990080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2994176 ++wrote 2048/2048 bytes at offset 2994176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 2998272 ++wrote 2048/2048 bytes at offset 2998272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3002368 ++wrote 2048/2048 bytes at offset 3002368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3006464 ++wrote 2048/2048 bytes at offset 3006464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3010560 ++wrote 2048/2048 bytes at offset 3010560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3014656 ++wrote 2048/2048 bytes at offset 3014656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3018752 ++wrote 2048/2048 bytes at offset 3018752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3022848 ++wrote 2048/2048 bytes at offset 3022848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3026944 ++wrote 2048/2048 bytes at offset 3026944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3031040 ++wrote 2048/2048 bytes at offset 3031040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3035136 ++wrote 2048/2048 bytes at offset 3035136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3039232 ++wrote 2048/2048 bytes at offset 3039232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3043328 ++wrote 2048/2048 bytes at offset 3043328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3047424 ++wrote 2048/2048 bytes at offset 3047424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3051520 ++wrote 2048/2048 bytes at offset 3051520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3055616 ++wrote 2048/2048 bytes at offset 3055616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3059712 ++wrote 2048/2048 bytes at offset 3059712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3063808 ++wrote 2048/2048 bytes at offset 3063808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3067904 ++wrote 2048/2048 bytes at offset 3067904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3072000 ++wrote 2048/2048 bytes at offset 3072000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3076096 ++wrote 2048/2048 bytes at offset 3076096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3080192 ++wrote 2048/2048 bytes at offset 3080192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3084288 ++wrote 2048/2048 bytes at offset 3084288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3088384 ++wrote 2048/2048 bytes at offset 3088384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3092480 ++wrote 2048/2048 bytes at offset 3092480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3096576 ++wrote 2048/2048 bytes at offset 3096576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3100672 ++wrote 2048/2048 bytes at offset 3100672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3104768 ++wrote 2048/2048 bytes at offset 3104768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3108864 ++wrote 2048/2048 bytes at offset 3108864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3112960 ++wrote 2048/2048 bytes at offset 3112960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3117056 ++wrote 2048/2048 bytes at offset 3117056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3121152 ++wrote 2048/2048 bytes at offset 3121152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3125248 ++wrote 2048/2048 bytes at offset 3125248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3129344 ++wrote 2048/2048 bytes at offset 3129344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3133440 ++wrote 2048/2048 bytes at offset 3133440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3137536 ++wrote 2048/2048 bytes at offset 3137536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3141632 ++wrote 2048/2048 bytes at offset 3141632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 2 +-qemu-io> wrote 2048/2048 bytes at offset 3146752 ++=== IO: pattern 2 ++wrote 2048/2048 bytes at offset 3146752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3150848 ++wrote 2048/2048 bytes at offset 3150848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3154944 ++wrote 2048/2048 bytes at offset 3154944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3159040 ++wrote 2048/2048 bytes at offset 3159040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3163136 ++wrote 2048/2048 bytes at offset 3163136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3167232 ++wrote 2048/2048 bytes at offset 3167232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3171328 ++wrote 2048/2048 bytes at offset 3171328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3175424 ++wrote 2048/2048 bytes at offset 3175424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3179520 ++wrote 2048/2048 bytes at offset 3179520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3183616 ++wrote 2048/2048 bytes at offset 3183616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3187712 ++wrote 2048/2048 bytes at offset 3187712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3191808 ++wrote 2048/2048 bytes at offset 3191808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3195904 ++wrote 2048/2048 bytes at offset 3195904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3200000 ++wrote 2048/2048 bytes at offset 3200000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3204096 ++wrote 2048/2048 bytes at offset 3204096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3208192 ++wrote 2048/2048 bytes at offset 3208192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3212288 ++wrote 2048/2048 bytes at offset 3212288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3216384 ++wrote 2048/2048 bytes at offset 3216384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3220480 ++wrote 2048/2048 bytes at offset 3220480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3224576 ++wrote 2048/2048 bytes at offset 3224576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3228672 ++wrote 2048/2048 bytes at offset 3228672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3232768 ++wrote 2048/2048 bytes at offset 3232768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3236864 ++wrote 2048/2048 bytes at offset 3236864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3240960 ++wrote 2048/2048 bytes at offset 3240960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3245056 ++wrote 2048/2048 bytes at offset 3245056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3249152 ++wrote 2048/2048 bytes at offset 3249152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3253248 ++wrote 2048/2048 bytes at offset 3253248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3257344 ++wrote 2048/2048 bytes at offset 3257344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3261440 ++wrote 2048/2048 bytes at offset 3261440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3265536 ++wrote 2048/2048 bytes at offset 3265536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3269632 ++wrote 2048/2048 bytes at offset 3269632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3273728 ++wrote 2048/2048 bytes at offset 3273728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3277824 ++wrote 2048/2048 bytes at offset 3277824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3281920 ++wrote 2048/2048 bytes at offset 3281920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3286016 ++wrote 2048/2048 bytes at offset 3286016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3290112 ++wrote 2048/2048 bytes at offset 3290112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3294208 ++wrote 2048/2048 bytes at offset 3294208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3298304 ++wrote 2048/2048 bytes at offset 3298304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3302400 ++wrote 2048/2048 bytes at offset 3302400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3306496 ++wrote 2048/2048 bytes at offset 3306496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3310592 ++wrote 2048/2048 bytes at offset 3310592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3314688 ++wrote 2048/2048 bytes at offset 3314688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3318784 ++wrote 2048/2048 bytes at offset 3318784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3322880 ++wrote 2048/2048 bytes at offset 3322880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3326976 ++wrote 2048/2048 bytes at offset 3326976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3331072 ++wrote 2048/2048 bytes at offset 3331072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3335168 ++wrote 2048/2048 bytes at offset 3335168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3339264 ++wrote 2048/2048 bytes at offset 3339264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3343360 ++wrote 2048/2048 bytes at offset 3343360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3347456 ++wrote 2048/2048 bytes at offset 3347456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3351552 ++wrote 2048/2048 bytes at offset 3351552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3355648 ++wrote 2048/2048 bytes at offset 3355648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3359744 ++wrote 2048/2048 bytes at offset 3359744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3363840 ++wrote 2048/2048 bytes at offset 3363840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3367936 ++wrote 2048/2048 bytes at offset 3367936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3372032 ++wrote 2048/2048 bytes at offset 3372032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3376128 ++wrote 2048/2048 bytes at offset 3376128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3380224 ++wrote 2048/2048 bytes at offset 3380224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3384320 ++wrote 2048/2048 bytes at offset 3384320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3388416 ++wrote 2048/2048 bytes at offset 3388416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3392512 ++wrote 2048/2048 bytes at offset 3392512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3396608 ++wrote 2048/2048 bytes at offset 3396608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3400704 ++wrote 2048/2048 bytes at offset 3400704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3404800 ++wrote 2048/2048 bytes at offset 3404800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3408896 ++wrote 2048/2048 bytes at offset 3408896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3412992 ++wrote 2048/2048 bytes at offset 3412992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3417088 ++wrote 2048/2048 bytes at offset 3417088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3421184 ++wrote 2048/2048 bytes at offset 3421184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3425280 ++wrote 2048/2048 bytes at offset 3425280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3429376 ++wrote 2048/2048 bytes at offset 3429376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3433472 ++wrote 2048/2048 bytes at offset 3433472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3437568 ++wrote 2048/2048 bytes at offset 3437568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3441664 ++wrote 2048/2048 bytes at offset 3441664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3445760 ++wrote 2048/2048 bytes at offset 3445760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3449856 ++wrote 2048/2048 bytes at offset 3449856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3453952 ++wrote 2048/2048 bytes at offset 3453952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3458048 ++wrote 2048/2048 bytes at offset 3458048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3462144 ++wrote 2048/2048 bytes at offset 3462144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3466240 ++wrote 2048/2048 bytes at offset 3466240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3470336 ++wrote 2048/2048 bytes at offset 3470336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3474432 ++wrote 2048/2048 bytes at offset 3474432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3478528 ++wrote 2048/2048 bytes at offset 3478528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3482624 ++wrote 2048/2048 bytes at offset 3482624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3486720 ++wrote 2048/2048 bytes at offset 3486720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3490816 ++wrote 2048/2048 bytes at offset 3490816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3494912 ++wrote 2048/2048 bytes at offset 3494912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3499008 ++wrote 2048/2048 bytes at offset 3499008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3503104 ++wrote 2048/2048 bytes at offset 3503104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3507200 ++wrote 2048/2048 bytes at offset 3507200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3511296 ++wrote 2048/2048 bytes at offset 3511296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3515392 ++wrote 2048/2048 bytes at offset 3515392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3519488 ++wrote 2048/2048 bytes at offset 3519488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3523584 ++wrote 2048/2048 bytes at offset 3523584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3527680 ++wrote 2048/2048 bytes at offset 3527680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3531776 ++wrote 2048/2048 bytes at offset 3531776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3535872 ++wrote 2048/2048 bytes at offset 3535872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3539968 ++wrote 2048/2048 bytes at offset 3539968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3544064 ++wrote 2048/2048 bytes at offset 3544064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3548160 ++wrote 2048/2048 bytes at offset 3548160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3552256 ++wrote 2048/2048 bytes at offset 3552256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3556352 ++wrote 2048/2048 bytes at offset 3556352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3560448 ++wrote 2048/2048 bytes at offset 3560448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3564544 ++wrote 2048/2048 bytes at offset 3564544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3568640 ++wrote 2048/2048 bytes at offset 3568640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3572736 ++wrote 2048/2048 bytes at offset 3572736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3576832 ++wrote 2048/2048 bytes at offset 3576832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3580928 ++wrote 2048/2048 bytes at offset 3580928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3585024 ++wrote 2048/2048 bytes at offset 3585024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3589120 ++wrote 2048/2048 bytes at offset 3589120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3593216 ++wrote 2048/2048 bytes at offset 3593216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3597312 ++wrote 2048/2048 bytes at offset 3597312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3601408 ++wrote 2048/2048 bytes at offset 3601408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3605504 ++wrote 2048/2048 bytes at offset 3605504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3609600 ++wrote 2048/2048 bytes at offset 3609600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3613696 ++wrote 2048/2048 bytes at offset 3613696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3617792 ++wrote 2048/2048 bytes at offset 3617792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3621888 ++wrote 2048/2048 bytes at offset 3621888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3625984 ++wrote 2048/2048 bytes at offset 3625984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3630080 ++wrote 2048/2048 bytes at offset 3630080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3634176 ++wrote 2048/2048 bytes at offset 3634176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3638272 ++wrote 2048/2048 bytes at offset 3638272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3642368 ++wrote 2048/2048 bytes at offset 3642368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3646464 ++wrote 2048/2048 bytes at offset 3646464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3650560 ++wrote 2048/2048 bytes at offset 3650560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3654656 ++wrote 2048/2048 bytes at offset 3654656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3658752 ++wrote 2048/2048 bytes at offset 3658752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3662848 ++wrote 2048/2048 bytes at offset 3662848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3666944 ++wrote 2048/2048 bytes at offset 3666944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3671040 ++wrote 2048/2048 bytes at offset 3671040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3675136 ++wrote 2048/2048 bytes at offset 3675136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3679232 ++wrote 2048/2048 bytes at offset 3679232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3683328 ++wrote 2048/2048 bytes at offset 3683328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3687424 ++wrote 2048/2048 bytes at offset 3687424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3691520 ++wrote 2048/2048 bytes at offset 3691520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3695616 ++wrote 2048/2048 bytes at offset 3695616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3699712 ++wrote 2048/2048 bytes at offset 3699712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3703808 ++wrote 2048/2048 bytes at offset 3703808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3707904 ++wrote 2048/2048 bytes at offset 3707904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3712000 ++wrote 2048/2048 bytes at offset 3712000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3716096 ++wrote 2048/2048 bytes at offset 3716096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3720192 ++wrote 2048/2048 bytes at offset 3720192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3724288 ++wrote 2048/2048 bytes at offset 3724288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3728384 ++wrote 2048/2048 bytes at offset 3728384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3732480 ++wrote 2048/2048 bytes at offset 3732480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3736576 ++wrote 2048/2048 bytes at offset 3736576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3740672 ++wrote 2048/2048 bytes at offset 3740672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3744768 ++wrote 2048/2048 bytes at offset 3744768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3748864 ++wrote 2048/2048 bytes at offset 3748864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3752960 ++wrote 2048/2048 bytes at offset 3752960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3757056 ++wrote 2048/2048 bytes at offset 3757056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3761152 ++wrote 2048/2048 bytes at offset 3761152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3765248 ++wrote 2048/2048 bytes at offset 3765248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3769344 ++wrote 2048/2048 bytes at offset 3769344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3773440 ++wrote 2048/2048 bytes at offset 3773440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3777536 ++wrote 2048/2048 bytes at offset 3777536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3781632 ++wrote 2048/2048 bytes at offset 3781632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3785728 ++wrote 2048/2048 bytes at offset 3785728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3789824 ++wrote 2048/2048 bytes at offset 3789824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3793920 ++wrote 2048/2048 bytes at offset 3793920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3798016 ++wrote 2048/2048 bytes at offset 3798016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3802112 ++wrote 2048/2048 bytes at offset 3802112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3806208 ++wrote 2048/2048 bytes at offset 3806208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3810304 ++wrote 2048/2048 bytes at offset 3810304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3814400 ++wrote 2048/2048 bytes at offset 3814400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3818496 ++wrote 2048/2048 bytes at offset 3818496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3822592 ++wrote 2048/2048 bytes at offset 3822592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3826688 ++wrote 2048/2048 bytes at offset 3826688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3830784 ++wrote 2048/2048 bytes at offset 3830784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3834880 ++wrote 2048/2048 bytes at offset 3834880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3838976 ++wrote 2048/2048 bytes at offset 3838976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3843072 ++wrote 2048/2048 bytes at offset 3843072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3847168 ++wrote 2048/2048 bytes at offset 3847168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3851264 ++wrote 2048/2048 bytes at offset 3851264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3855360 ++wrote 2048/2048 bytes at offset 3855360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3859456 ++wrote 2048/2048 bytes at offset 3859456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3863552 ++wrote 2048/2048 bytes at offset 3863552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3867648 ++wrote 2048/2048 bytes at offset 3867648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3871744 ++wrote 2048/2048 bytes at offset 3871744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3875840 ++wrote 2048/2048 bytes at offset 3875840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3879936 ++wrote 2048/2048 bytes at offset 3879936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3884032 ++wrote 2048/2048 bytes at offset 3884032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3888128 ++wrote 2048/2048 bytes at offset 3888128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3892224 ++wrote 2048/2048 bytes at offset 3892224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3896320 ++wrote 2048/2048 bytes at offset 3896320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3900416 ++wrote 2048/2048 bytes at offset 3900416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3904512 ++wrote 2048/2048 bytes at offset 3904512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3908608 ++wrote 2048/2048 bytes at offset 3908608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3912704 ++wrote 2048/2048 bytes at offset 3912704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3916800 ++wrote 2048/2048 bytes at offset 3916800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3920896 ++wrote 2048/2048 bytes at offset 3920896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3924992 ++wrote 2048/2048 bytes at offset 3924992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3929088 ++wrote 2048/2048 bytes at offset 3929088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3933184 ++wrote 2048/2048 bytes at offset 3933184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3937280 ++wrote 2048/2048 bytes at offset 3937280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3941376 ++wrote 2048/2048 bytes at offset 3941376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3945472 ++wrote 2048/2048 bytes at offset 3945472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3949568 ++wrote 2048/2048 bytes at offset 3949568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3953664 ++wrote 2048/2048 bytes at offset 3953664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3957760 ++wrote 2048/2048 bytes at offset 3957760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3961856 ++wrote 2048/2048 bytes at offset 3961856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3965952 ++wrote 2048/2048 bytes at offset 3965952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3970048 ++wrote 2048/2048 bytes at offset 3970048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3974144 ++wrote 2048/2048 bytes at offset 3974144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3978240 ++wrote 2048/2048 bytes at offset 3978240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3982336 ++wrote 2048/2048 bytes at offset 3982336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3986432 ++wrote 2048/2048 bytes at offset 3986432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3990528 ++wrote 2048/2048 bytes at offset 3990528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3994624 ++wrote 2048/2048 bytes at offset 3994624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 3998720 ++wrote 2048/2048 bytes at offset 3998720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4002816 ++wrote 2048/2048 bytes at offset 4002816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4006912 ++wrote 2048/2048 bytes at offset 4006912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4011008 ++wrote 2048/2048 bytes at offset 4011008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4015104 ++wrote 2048/2048 bytes at offset 4015104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4019200 ++wrote 2048/2048 bytes at offset 4019200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4023296 ++wrote 2048/2048 bytes at offset 4023296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4027392 ++wrote 2048/2048 bytes at offset 4027392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4031488 ++wrote 2048/2048 bytes at offset 4031488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4035584 ++wrote 2048/2048 bytes at offset 4035584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4039680 ++wrote 2048/2048 bytes at offset 4039680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4043776 ++wrote 2048/2048 bytes at offset 4043776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4047872 ++wrote 2048/2048 bytes at offset 4047872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4051968 ++wrote 2048/2048 bytes at offset 4051968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4056064 ++wrote 2048/2048 bytes at offset 4056064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4060160 ++wrote 2048/2048 bytes at offset 4060160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4064256 ++wrote 2048/2048 bytes at offset 4064256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4068352 ++wrote 2048/2048 bytes at offset 4068352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4072448 ++wrote 2048/2048 bytes at offset 4072448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4076544 ++wrote 2048/2048 bytes at offset 4076544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4080640 ++wrote 2048/2048 bytes at offset 4080640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4084736 ++wrote 2048/2048 bytes at offset 4084736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4088832 ++wrote 2048/2048 bytes at offset 4088832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4092928 ++wrote 2048/2048 bytes at offset 4092928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4097024 ++wrote 2048/2048 bytes at offset 4097024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4101120 ++wrote 2048/2048 bytes at offset 4101120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4105216 ++wrote 2048/2048 bytes at offset 4105216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4109312 ++wrote 2048/2048 bytes at offset 4109312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4113408 ++wrote 2048/2048 bytes at offset 4113408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4117504 ++wrote 2048/2048 bytes at offset 4117504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4121600 ++wrote 2048/2048 bytes at offset 4121600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4125696 ++wrote 2048/2048 bytes at offset 4125696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4129792 ++wrote 2048/2048 bytes at offset 4129792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4133888 ++wrote 2048/2048 bytes at offset 4133888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4137984 ++wrote 2048/2048 bytes at offset 4137984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4142080 ++wrote 2048/2048 bytes at offset 4142080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4146176 ++wrote 2048/2048 bytes at offset 4146176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4150272 ++wrote 2048/2048 bytes at offset 4150272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4154368 ++wrote 2048/2048 bytes at offset 4154368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4158464 ++wrote 2048/2048 bytes at offset 4158464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4162560 ++wrote 2048/2048 bytes at offset 4162560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4166656 ++wrote 2048/2048 bytes at offset 4166656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4170752 ++wrote 2048/2048 bytes at offset 4170752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4174848 ++wrote 2048/2048 bytes at offset 4174848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4178944 ++wrote 2048/2048 bytes at offset 4178944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4183040 ++wrote 2048/2048 bytes at offset 4183040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4187136 ++wrote 2048/2048 bytes at offset 4187136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4191232 ++wrote 2048/2048 bytes at offset 4191232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 4 +-qemu-io> wrote 8192/8192 bytes at offset 4196352 ++=== IO: pattern 4 ++wrote 8192/8192 bytes at offset 4196352 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4208640 ++wrote 8192/8192 bytes at offset 4208640 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4220928 ++wrote 8192/8192 bytes at offset 4220928 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4233216 ++wrote 8192/8192 bytes at offset 4233216 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4245504 ++wrote 8192/8192 bytes at offset 4245504 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4257792 ++wrote 8192/8192 bytes at offset 4257792 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4270080 ++wrote 8192/8192 bytes at offset 4270080 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4282368 ++wrote 8192/8192 bytes at offset 4282368 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4294656 ++wrote 8192/8192 bytes at offset 4294656 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4306944 ++wrote 8192/8192 bytes at offset 4306944 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4319232 ++wrote 8192/8192 bytes at offset 4319232 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4331520 ++wrote 8192/8192 bytes at offset 4331520 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4343808 ++wrote 8192/8192 bytes at offset 4343808 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4356096 ++wrote 8192/8192 bytes at offset 4356096 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4368384 ++wrote 8192/8192 bytes at offset 4368384 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4380672 ++wrote 8192/8192 bytes at offset 4380672 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4392960 ++wrote 8192/8192 bytes at offset 4392960 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4405248 ++wrote 8192/8192 bytes at offset 4405248 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4417536 ++wrote 8192/8192 bytes at offset 4417536 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4429824 ++wrote 8192/8192 bytes at offset 4429824 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4442112 ++wrote 8192/8192 bytes at offset 4442112 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4454400 ++wrote 8192/8192 bytes at offset 4454400 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4466688 ++wrote 8192/8192 bytes at offset 4466688 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4478976 ++wrote 8192/8192 bytes at offset 4478976 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4491264 ++wrote 8192/8192 bytes at offset 4491264 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4503552 ++wrote 8192/8192 bytes at offset 4503552 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4515840 ++wrote 8192/8192 bytes at offset 4515840 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4528128 ++wrote 8192/8192 bytes at offset 4528128 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4540416 ++wrote 8192/8192 bytes at offset 4540416 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4552704 ++wrote 8192/8192 bytes at offset 4552704 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4564992 ++wrote 8192/8192 bytes at offset 4564992 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4577280 ++wrote 8192/8192 bytes at offset 4577280 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4589568 ++wrote 8192/8192 bytes at offset 4589568 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4601856 ++wrote 8192/8192 bytes at offset 4601856 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4614144 ++wrote 8192/8192 bytes at offset 4614144 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4626432 ++wrote 8192/8192 bytes at offset 4626432 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4638720 ++wrote 8192/8192 bytes at offset 4638720 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4651008 ++wrote 8192/8192 bytes at offset 4651008 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4663296 ++wrote 8192/8192 bytes at offset 4663296 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4675584 ++wrote 8192/8192 bytes at offset 4675584 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4687872 ++wrote 8192/8192 bytes at offset 4687872 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4700160 ++wrote 8192/8192 bytes at offset 4700160 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4712448 ++wrote 8192/8192 bytes at offset 4712448 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4724736 ++wrote 8192/8192 bytes at offset 4724736 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4737024 ++wrote 8192/8192 bytes at offset 4737024 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4749312 ++wrote 8192/8192 bytes at offset 4749312 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4761600 ++wrote 8192/8192 bytes at offset 4761600 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4773888 ++wrote 8192/8192 bytes at offset 4773888 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4786176 ++wrote 8192/8192 bytes at offset 4786176 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4798464 ++wrote 8192/8192 bytes at offset 4798464 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4810752 ++wrote 8192/8192 bytes at offset 4810752 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4823040 ++wrote 8192/8192 bytes at offset 4823040 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4835328 ++wrote 8192/8192 bytes at offset 4835328 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4847616 ++wrote 8192/8192 bytes at offset 4847616 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4859904 ++wrote 8192/8192 bytes at offset 4859904 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4872192 ++wrote 8192/8192 bytes at offset 4872192 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4884480 ++wrote 8192/8192 bytes at offset 4884480 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4896768 ++wrote 8192/8192 bytes at offset 4896768 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4909056 ++wrote 8192/8192 bytes at offset 4909056 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4921344 ++wrote 8192/8192 bytes at offset 4921344 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4933632 ++wrote 8192/8192 bytes at offset 4933632 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4945920 ++wrote 8192/8192 bytes at offset 4945920 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4958208 ++wrote 8192/8192 bytes at offset 4958208 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4970496 ++wrote 8192/8192 bytes at offset 4970496 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 244 +-qemu-io> wrote 12288/12288 bytes at offset 6285312 ++=== IO: pattern 244 ++wrote 12288/12288 bytes at offset 6285312 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 8384512 ++wrote 12288/12288 bytes at offset 8384512 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 10483712 ++wrote 12288/12288 bytes at offset 10483712 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 12582912 ++wrote 12288/12288 bytes at offset 12582912 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 14682112 ++wrote 12288/12288 bytes at offset 14682112 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 16781312 ++wrote 12288/12288 bytes at offset 16781312 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 18880512 ++wrote 12288/12288 bytes at offset 18880512 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 20979712 ++wrote 12288/12288 bytes at offset 20979712 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> read 4096/4096 bytes at offset 0 ++=== IO: pattern 0 ++read 4096/4096 bytes at offset 0 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4096 ++read 4096/4096 bytes at offset 4096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 8192 ++read 4096/4096 bytes at offset 8192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 12288 ++read 4096/4096 bytes at offset 12288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 16384 ++read 4096/4096 bytes at offset 16384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 20480 ++read 4096/4096 bytes at offset 20480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 24576 ++read 4096/4096 bytes at offset 24576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 28672 ++read 4096/4096 bytes at offset 28672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 32768 ++read 4096/4096 bytes at offset 32768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 36864 ++read 4096/4096 bytes at offset 36864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 40960 ++read 4096/4096 bytes at offset 40960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 45056 ++read 4096/4096 bytes at offset 45056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 49152 ++read 4096/4096 bytes at offset 49152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 53248 ++read 4096/4096 bytes at offset 53248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 57344 ++read 4096/4096 bytes at offset 57344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 61440 ++read 4096/4096 bytes at offset 61440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 65536 ++read 4096/4096 bytes at offset 65536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 69632 ++read 4096/4096 bytes at offset 69632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 73728 ++read 4096/4096 bytes at offset 73728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 77824 ++read 4096/4096 bytes at offset 77824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 81920 ++read 4096/4096 bytes at offset 81920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 86016 ++read 4096/4096 bytes at offset 86016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 90112 ++read 4096/4096 bytes at offset 90112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 94208 ++read 4096/4096 bytes at offset 94208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 98304 ++read 4096/4096 bytes at offset 98304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 102400 ++read 4096/4096 bytes at offset 102400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 106496 ++read 4096/4096 bytes at offset 106496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 110592 ++read 4096/4096 bytes at offset 110592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 114688 ++read 4096/4096 bytes at offset 114688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 118784 ++read 4096/4096 bytes at offset 118784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 122880 ++read 4096/4096 bytes at offset 122880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 126976 ++read 4096/4096 bytes at offset 126976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 131072 ++read 4096/4096 bytes at offset 131072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 135168 ++read 4096/4096 bytes at offset 135168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 139264 ++read 4096/4096 bytes at offset 139264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 143360 ++read 4096/4096 bytes at offset 143360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 147456 ++read 4096/4096 bytes at offset 147456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 151552 ++read 4096/4096 bytes at offset 151552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 155648 ++read 4096/4096 bytes at offset 155648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 159744 ++read 4096/4096 bytes at offset 159744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 163840 ++read 4096/4096 bytes at offset 163840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 167936 ++read 4096/4096 bytes at offset 167936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 172032 ++read 4096/4096 bytes at offset 172032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 176128 ++read 4096/4096 bytes at offset 176128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 180224 ++read 4096/4096 bytes at offset 180224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 184320 ++read 4096/4096 bytes at offset 184320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 188416 ++read 4096/4096 bytes at offset 188416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 192512 ++read 4096/4096 bytes at offset 192512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 196608 ++read 4096/4096 bytes at offset 196608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 200704 ++read 4096/4096 bytes at offset 200704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 204800 ++read 4096/4096 bytes at offset 204800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 208896 ++read 4096/4096 bytes at offset 208896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 212992 ++read 4096/4096 bytes at offset 212992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 217088 ++read 4096/4096 bytes at offset 217088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 221184 ++read 4096/4096 bytes at offset 221184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 225280 ++read 4096/4096 bytes at offset 225280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 229376 ++read 4096/4096 bytes at offset 229376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 233472 ++read 4096/4096 bytes at offset 233472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 237568 ++read 4096/4096 bytes at offset 237568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 241664 ++read 4096/4096 bytes at offset 241664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 245760 ++read 4096/4096 bytes at offset 245760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 249856 ++read 4096/4096 bytes at offset 249856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 253952 ++read 4096/4096 bytes at offset 253952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 258048 ++read 4096/4096 bytes at offset 258048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 262144 ++read 4096/4096 bytes at offset 262144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 266240 ++read 4096/4096 bytes at offset 266240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 270336 ++read 4096/4096 bytes at offset 270336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 274432 ++read 4096/4096 bytes at offset 274432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 278528 ++read 4096/4096 bytes at offset 278528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 282624 ++read 4096/4096 bytes at offset 282624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 286720 ++read 4096/4096 bytes at offset 286720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 290816 ++read 4096/4096 bytes at offset 290816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 294912 ++read 4096/4096 bytes at offset 294912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 299008 ++read 4096/4096 bytes at offset 299008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 303104 ++read 4096/4096 bytes at offset 303104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 307200 ++read 4096/4096 bytes at offset 307200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 311296 ++read 4096/4096 bytes at offset 311296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 315392 ++read 4096/4096 bytes at offset 315392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 319488 ++read 4096/4096 bytes at offset 319488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 323584 ++read 4096/4096 bytes at offset 323584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 327680 ++read 4096/4096 bytes at offset 327680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 331776 ++read 4096/4096 bytes at offset 331776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 335872 ++read 4096/4096 bytes at offset 335872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 339968 ++read 4096/4096 bytes at offset 339968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 344064 ++read 4096/4096 bytes at offset 344064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 348160 ++read 4096/4096 bytes at offset 348160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 352256 ++read 4096/4096 bytes at offset 352256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 356352 ++read 4096/4096 bytes at offset 356352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 360448 ++read 4096/4096 bytes at offset 360448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 364544 ++read 4096/4096 bytes at offset 364544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 368640 ++read 4096/4096 bytes at offset 368640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 372736 ++read 4096/4096 bytes at offset 372736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 376832 ++read 4096/4096 bytes at offset 376832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 380928 ++read 4096/4096 bytes at offset 380928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 385024 ++read 4096/4096 bytes at offset 385024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 389120 ++read 4096/4096 bytes at offset 389120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 393216 ++read 4096/4096 bytes at offset 393216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 397312 ++read 4096/4096 bytes at offset 397312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 401408 ++read 4096/4096 bytes at offset 401408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 405504 ++read 4096/4096 bytes at offset 405504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 409600 ++read 4096/4096 bytes at offset 409600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 413696 ++read 4096/4096 bytes at offset 413696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 417792 ++read 4096/4096 bytes at offset 417792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 421888 ++read 4096/4096 bytes at offset 421888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 425984 ++read 4096/4096 bytes at offset 425984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 430080 ++read 4096/4096 bytes at offset 430080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 434176 ++read 4096/4096 bytes at offset 434176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 438272 ++read 4096/4096 bytes at offset 438272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 442368 ++read 4096/4096 bytes at offset 442368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 446464 ++read 4096/4096 bytes at offset 446464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 450560 ++read 4096/4096 bytes at offset 450560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 454656 ++read 4096/4096 bytes at offset 454656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 458752 ++read 4096/4096 bytes at offset 458752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 462848 ++read 4096/4096 bytes at offset 462848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 466944 ++read 4096/4096 bytes at offset 466944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 471040 ++read 4096/4096 bytes at offset 471040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 475136 ++read 4096/4096 bytes at offset 475136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 479232 ++read 4096/4096 bytes at offset 479232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 483328 ++read 4096/4096 bytes at offset 483328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 487424 ++read 4096/4096 bytes at offset 487424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 491520 ++read 4096/4096 bytes at offset 491520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 495616 ++read 4096/4096 bytes at offset 495616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 499712 ++read 4096/4096 bytes at offset 499712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 503808 ++read 4096/4096 bytes at offset 503808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 507904 ++read 4096/4096 bytes at offset 507904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 512000 ++read 4096/4096 bytes at offset 512000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 516096 ++read 4096/4096 bytes at offset 516096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 520192 ++read 4096/4096 bytes at offset 520192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 524288 ++read 4096/4096 bytes at offset 524288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 528384 ++read 4096/4096 bytes at offset 528384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 532480 ++read 4096/4096 bytes at offset 532480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 536576 ++read 4096/4096 bytes at offset 536576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 540672 ++read 4096/4096 bytes at offset 540672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 544768 ++read 4096/4096 bytes at offset 544768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 548864 ++read 4096/4096 bytes at offset 548864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 552960 ++read 4096/4096 bytes at offset 552960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 557056 ++read 4096/4096 bytes at offset 557056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 561152 ++read 4096/4096 bytes at offset 561152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 565248 ++read 4096/4096 bytes at offset 565248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 569344 ++read 4096/4096 bytes at offset 569344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 573440 ++read 4096/4096 bytes at offset 573440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 577536 ++read 4096/4096 bytes at offset 577536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 581632 ++read 4096/4096 bytes at offset 581632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 585728 ++read 4096/4096 bytes at offset 585728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 589824 ++read 4096/4096 bytes at offset 589824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 593920 ++read 4096/4096 bytes at offset 593920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 598016 ++read 4096/4096 bytes at offset 598016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 602112 ++read 4096/4096 bytes at offset 602112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 606208 ++read 4096/4096 bytes at offset 606208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 610304 ++read 4096/4096 bytes at offset 610304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 614400 ++read 4096/4096 bytes at offset 614400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 618496 ++read 4096/4096 bytes at offset 618496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 622592 ++read 4096/4096 bytes at offset 622592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 626688 ++read 4096/4096 bytes at offset 626688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 630784 ++read 4096/4096 bytes at offset 630784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 634880 ++read 4096/4096 bytes at offset 634880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 638976 ++read 4096/4096 bytes at offset 638976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 643072 ++read 4096/4096 bytes at offset 643072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 647168 ++read 4096/4096 bytes at offset 647168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 651264 ++read 4096/4096 bytes at offset 651264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 655360 ++read 4096/4096 bytes at offset 655360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 659456 ++read 4096/4096 bytes at offset 659456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 663552 ++read 4096/4096 bytes at offset 663552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 667648 ++read 4096/4096 bytes at offset 667648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 671744 ++read 4096/4096 bytes at offset 671744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 675840 ++read 4096/4096 bytes at offset 675840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 679936 ++read 4096/4096 bytes at offset 679936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 684032 ++read 4096/4096 bytes at offset 684032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 688128 ++read 4096/4096 bytes at offset 688128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 692224 ++read 4096/4096 bytes at offset 692224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 696320 ++read 4096/4096 bytes at offset 696320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 700416 ++read 4096/4096 bytes at offset 700416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 704512 ++read 4096/4096 bytes at offset 704512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 708608 ++read 4096/4096 bytes at offset 708608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 712704 ++read 4096/4096 bytes at offset 712704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 716800 ++read 4096/4096 bytes at offset 716800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 720896 ++read 4096/4096 bytes at offset 720896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 724992 ++read 4096/4096 bytes at offset 724992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 729088 ++read 4096/4096 bytes at offset 729088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 733184 ++read 4096/4096 bytes at offset 733184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 737280 ++read 4096/4096 bytes at offset 737280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 741376 ++read 4096/4096 bytes at offset 741376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 745472 ++read 4096/4096 bytes at offset 745472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 749568 ++read 4096/4096 bytes at offset 749568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 753664 ++read 4096/4096 bytes at offset 753664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 757760 ++read 4096/4096 bytes at offset 757760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 761856 ++read 4096/4096 bytes at offset 761856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 765952 ++read 4096/4096 bytes at offset 765952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 770048 ++read 4096/4096 bytes at offset 770048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 774144 ++read 4096/4096 bytes at offset 774144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 778240 ++read 4096/4096 bytes at offset 778240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 782336 ++read 4096/4096 bytes at offset 782336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 786432 ++read 4096/4096 bytes at offset 786432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 790528 ++read 4096/4096 bytes at offset 790528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 794624 ++read 4096/4096 bytes at offset 794624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 798720 ++read 4096/4096 bytes at offset 798720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 802816 ++read 4096/4096 bytes at offset 802816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 806912 ++read 4096/4096 bytes at offset 806912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 811008 ++read 4096/4096 bytes at offset 811008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 815104 ++read 4096/4096 bytes at offset 815104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 819200 ++read 4096/4096 bytes at offset 819200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 823296 ++read 4096/4096 bytes at offset 823296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 827392 ++read 4096/4096 bytes at offset 827392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 831488 ++read 4096/4096 bytes at offset 831488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 835584 ++read 4096/4096 bytes at offset 835584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 839680 ++read 4096/4096 bytes at offset 839680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 843776 ++read 4096/4096 bytes at offset 843776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 847872 ++read 4096/4096 bytes at offset 847872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 851968 ++read 4096/4096 bytes at offset 851968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 856064 ++read 4096/4096 bytes at offset 856064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 860160 ++read 4096/4096 bytes at offset 860160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 864256 ++read 4096/4096 bytes at offset 864256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 868352 ++read 4096/4096 bytes at offset 868352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 872448 ++read 4096/4096 bytes at offset 872448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 876544 ++read 4096/4096 bytes at offset 876544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 880640 ++read 4096/4096 bytes at offset 880640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 884736 ++read 4096/4096 bytes at offset 884736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 888832 ++read 4096/4096 bytes at offset 888832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 892928 ++read 4096/4096 bytes at offset 892928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 897024 ++read 4096/4096 bytes at offset 897024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 901120 ++read 4096/4096 bytes at offset 901120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 905216 ++read 4096/4096 bytes at offset 905216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 909312 ++read 4096/4096 bytes at offset 909312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 913408 ++read 4096/4096 bytes at offset 913408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 917504 ++read 4096/4096 bytes at offset 917504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 921600 ++read 4096/4096 bytes at offset 921600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 925696 ++read 4096/4096 bytes at offset 925696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 929792 ++read 4096/4096 bytes at offset 929792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 933888 ++read 4096/4096 bytes at offset 933888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 937984 ++read 4096/4096 bytes at offset 937984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 942080 ++read 4096/4096 bytes at offset 942080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 946176 ++read 4096/4096 bytes at offset 946176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 950272 ++read 4096/4096 bytes at offset 950272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 954368 ++read 4096/4096 bytes at offset 954368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 958464 ++read 4096/4096 bytes at offset 958464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 962560 ++read 4096/4096 bytes at offset 962560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 966656 ++read 4096/4096 bytes at offset 966656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 970752 ++read 4096/4096 bytes at offset 970752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 974848 ++read 4096/4096 bytes at offset 974848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 978944 ++read 4096/4096 bytes at offset 978944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 983040 ++read 4096/4096 bytes at offset 983040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 987136 ++read 4096/4096 bytes at offset 987136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 991232 ++read 4096/4096 bytes at offset 991232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 995328 ++read 4096/4096 bytes at offset 995328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 999424 ++read 4096/4096 bytes at offset 999424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1003520 ++read 4096/4096 bytes at offset 1003520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1007616 ++read 4096/4096 bytes at offset 1007616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1011712 ++read 4096/4096 bytes at offset 1011712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1015808 ++read 4096/4096 bytes at offset 1015808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1019904 ++read 4096/4096 bytes at offset 1019904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1024000 ++read 4096/4096 bytes at offset 1024000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1028096 ++read 4096/4096 bytes at offset 1028096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1032192 ++read 4096/4096 bytes at offset 1032192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1036288 ++read 4096/4096 bytes at offset 1036288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1040384 ++read 4096/4096 bytes at offset 1040384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 1044480 ++read 4096/4096 bytes at offset 1044480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 4 +-qemu-io> read 2048/2048 bytes at offset 1050624 ++=== IO: pattern 4 ++read 2048/2048 bytes at offset 1050624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1054720 ++read 2048/2048 bytes at offset 1054720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1058816 ++read 2048/2048 bytes at offset 1058816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1062912 ++read 2048/2048 bytes at offset 1062912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1067008 ++read 2048/2048 bytes at offset 1067008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1071104 ++read 2048/2048 bytes at offset 1071104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1075200 ++read 2048/2048 bytes at offset 1075200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1079296 ++read 2048/2048 bytes at offset 1079296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1083392 ++read 2048/2048 bytes at offset 1083392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1087488 ++read 2048/2048 bytes at offset 1087488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1091584 ++read 2048/2048 bytes at offset 1091584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1095680 ++read 2048/2048 bytes at offset 1095680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1099776 ++read 2048/2048 bytes at offset 1099776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1103872 ++read 2048/2048 bytes at offset 1103872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1107968 ++read 2048/2048 bytes at offset 1107968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1112064 ++read 2048/2048 bytes at offset 1112064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1116160 ++read 2048/2048 bytes at offset 1116160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1120256 ++read 2048/2048 bytes at offset 1120256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1124352 ++read 2048/2048 bytes at offset 1124352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1128448 ++read 2048/2048 bytes at offset 1128448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1132544 ++read 2048/2048 bytes at offset 1132544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1136640 ++read 2048/2048 bytes at offset 1136640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1140736 ++read 2048/2048 bytes at offset 1140736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1144832 ++read 2048/2048 bytes at offset 1144832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1148928 ++read 2048/2048 bytes at offset 1148928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1153024 ++read 2048/2048 bytes at offset 1153024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1157120 ++read 2048/2048 bytes at offset 1157120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1161216 ++read 2048/2048 bytes at offset 1161216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1165312 ++read 2048/2048 bytes at offset 1165312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1169408 ++read 2048/2048 bytes at offset 1169408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1173504 ++read 2048/2048 bytes at offset 1173504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1177600 ++read 2048/2048 bytes at offset 1177600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1181696 ++read 2048/2048 bytes at offset 1181696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1185792 ++read 2048/2048 bytes at offset 1185792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1189888 ++read 2048/2048 bytes at offset 1189888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1193984 ++read 2048/2048 bytes at offset 1193984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1198080 ++read 2048/2048 bytes at offset 1198080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1202176 ++read 2048/2048 bytes at offset 1202176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1206272 ++read 2048/2048 bytes at offset 1206272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1210368 ++read 2048/2048 bytes at offset 1210368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1214464 ++read 2048/2048 bytes at offset 1214464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1218560 ++read 2048/2048 bytes at offset 1218560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1222656 ++read 2048/2048 bytes at offset 1222656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1226752 ++read 2048/2048 bytes at offset 1226752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1230848 ++read 2048/2048 bytes at offset 1230848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1234944 ++read 2048/2048 bytes at offset 1234944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1239040 ++read 2048/2048 bytes at offset 1239040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1243136 ++read 2048/2048 bytes at offset 1243136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1247232 ++read 2048/2048 bytes at offset 1247232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1251328 ++read 2048/2048 bytes at offset 1251328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1255424 ++read 2048/2048 bytes at offset 1255424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1259520 ++read 2048/2048 bytes at offset 1259520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1263616 ++read 2048/2048 bytes at offset 1263616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1267712 ++read 2048/2048 bytes at offset 1267712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1271808 ++read 2048/2048 bytes at offset 1271808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1275904 ++read 2048/2048 bytes at offset 1275904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1280000 ++read 2048/2048 bytes at offset 1280000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1284096 ++read 2048/2048 bytes at offset 1284096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1288192 ++read 2048/2048 bytes at offset 1288192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1292288 ++read 2048/2048 bytes at offset 1292288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1296384 ++read 2048/2048 bytes at offset 1296384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1300480 ++read 2048/2048 bytes at offset 1300480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1304576 ++read 2048/2048 bytes at offset 1304576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1308672 ++read 2048/2048 bytes at offset 1308672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1312768 ++read 2048/2048 bytes at offset 1312768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1316864 ++read 2048/2048 bytes at offset 1316864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1320960 ++read 2048/2048 bytes at offset 1320960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1325056 ++read 2048/2048 bytes at offset 1325056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1329152 ++read 2048/2048 bytes at offset 1329152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1333248 ++read 2048/2048 bytes at offset 1333248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1337344 ++read 2048/2048 bytes at offset 1337344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1341440 ++read 2048/2048 bytes at offset 1341440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1345536 ++read 2048/2048 bytes at offset 1345536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1349632 ++read 2048/2048 bytes at offset 1349632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1353728 ++read 2048/2048 bytes at offset 1353728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1357824 ++read 2048/2048 bytes at offset 1357824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1361920 ++read 2048/2048 bytes at offset 1361920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1366016 ++read 2048/2048 bytes at offset 1366016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1370112 ++read 2048/2048 bytes at offset 1370112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1374208 ++read 2048/2048 bytes at offset 1374208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1378304 ++read 2048/2048 bytes at offset 1378304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1382400 ++read 2048/2048 bytes at offset 1382400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1386496 ++read 2048/2048 bytes at offset 1386496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1390592 ++read 2048/2048 bytes at offset 1390592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1394688 ++read 2048/2048 bytes at offset 1394688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1398784 ++read 2048/2048 bytes at offset 1398784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1402880 ++read 2048/2048 bytes at offset 1402880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1406976 ++read 2048/2048 bytes at offset 1406976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1411072 ++read 2048/2048 bytes at offset 1411072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1415168 ++read 2048/2048 bytes at offset 1415168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1419264 ++read 2048/2048 bytes at offset 1419264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1423360 ++read 2048/2048 bytes at offset 1423360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1427456 ++read 2048/2048 bytes at offset 1427456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1431552 ++read 2048/2048 bytes at offset 1431552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1435648 ++read 2048/2048 bytes at offset 1435648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1439744 ++read 2048/2048 bytes at offset 1439744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1443840 ++read 2048/2048 bytes at offset 1443840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1447936 ++read 2048/2048 bytes at offset 1447936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1452032 ++read 2048/2048 bytes at offset 1452032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1456128 ++read 2048/2048 bytes at offset 1456128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1460224 ++read 2048/2048 bytes at offset 1460224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1464320 ++read 2048/2048 bytes at offset 1464320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1468416 ++read 2048/2048 bytes at offset 1468416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1472512 ++read 2048/2048 bytes at offset 1472512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1476608 ++read 2048/2048 bytes at offset 1476608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1480704 ++read 2048/2048 bytes at offset 1480704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1484800 ++read 2048/2048 bytes at offset 1484800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1488896 ++read 2048/2048 bytes at offset 1488896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1492992 ++read 2048/2048 bytes at offset 1492992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1497088 ++read 2048/2048 bytes at offset 1497088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1501184 ++read 2048/2048 bytes at offset 1501184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1505280 ++read 2048/2048 bytes at offset 1505280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1509376 ++read 2048/2048 bytes at offset 1509376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1513472 ++read 2048/2048 bytes at offset 1513472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1517568 ++read 2048/2048 bytes at offset 1517568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1521664 ++read 2048/2048 bytes at offset 1521664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1525760 ++read 2048/2048 bytes at offset 1525760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1529856 ++read 2048/2048 bytes at offset 1529856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1533952 ++read 2048/2048 bytes at offset 1533952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1538048 ++read 2048/2048 bytes at offset 1538048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1542144 ++read 2048/2048 bytes at offset 1542144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1546240 ++read 2048/2048 bytes at offset 1546240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1550336 ++read 2048/2048 bytes at offset 1550336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1554432 ++read 2048/2048 bytes at offset 1554432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1558528 ++read 2048/2048 bytes at offset 1558528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1562624 ++read 2048/2048 bytes at offset 1562624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1566720 ++read 2048/2048 bytes at offset 1566720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1570816 ++read 2048/2048 bytes at offset 1570816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1574912 ++read 2048/2048 bytes at offset 1574912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1579008 ++read 2048/2048 bytes at offset 1579008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1583104 ++read 2048/2048 bytes at offset 1583104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1587200 ++read 2048/2048 bytes at offset 1587200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1591296 ++read 2048/2048 bytes at offset 1591296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1595392 ++read 2048/2048 bytes at offset 1595392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1599488 ++read 2048/2048 bytes at offset 1599488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1603584 ++read 2048/2048 bytes at offset 1603584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1607680 ++read 2048/2048 bytes at offset 1607680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1611776 ++read 2048/2048 bytes at offset 1611776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1615872 ++read 2048/2048 bytes at offset 1615872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1619968 ++read 2048/2048 bytes at offset 1619968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1624064 ++read 2048/2048 bytes at offset 1624064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1628160 ++read 2048/2048 bytes at offset 1628160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1632256 ++read 2048/2048 bytes at offset 1632256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1636352 ++read 2048/2048 bytes at offset 1636352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1640448 ++read 2048/2048 bytes at offset 1640448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1644544 ++read 2048/2048 bytes at offset 1644544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1648640 ++read 2048/2048 bytes at offset 1648640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1652736 ++read 2048/2048 bytes at offset 1652736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1656832 ++read 2048/2048 bytes at offset 1656832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1660928 ++read 2048/2048 bytes at offset 1660928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1665024 ++read 2048/2048 bytes at offset 1665024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1669120 ++read 2048/2048 bytes at offset 1669120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1673216 ++read 2048/2048 bytes at offset 1673216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1677312 ++read 2048/2048 bytes at offset 1677312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1681408 ++read 2048/2048 bytes at offset 1681408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1685504 ++read 2048/2048 bytes at offset 1685504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1689600 ++read 2048/2048 bytes at offset 1689600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1693696 ++read 2048/2048 bytes at offset 1693696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1697792 ++read 2048/2048 bytes at offset 1697792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1701888 ++read 2048/2048 bytes at offset 1701888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1705984 ++read 2048/2048 bytes at offset 1705984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1710080 ++read 2048/2048 bytes at offset 1710080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1714176 ++read 2048/2048 bytes at offset 1714176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1718272 ++read 2048/2048 bytes at offset 1718272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1722368 ++read 2048/2048 bytes at offset 1722368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1726464 ++read 2048/2048 bytes at offset 1726464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1730560 ++read 2048/2048 bytes at offset 1730560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1734656 ++read 2048/2048 bytes at offset 1734656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1738752 ++read 2048/2048 bytes at offset 1738752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1742848 ++read 2048/2048 bytes at offset 1742848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1746944 ++read 2048/2048 bytes at offset 1746944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1751040 ++read 2048/2048 bytes at offset 1751040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1755136 ++read 2048/2048 bytes at offset 1755136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1759232 ++read 2048/2048 bytes at offset 1759232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1763328 ++read 2048/2048 bytes at offset 1763328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1767424 ++read 2048/2048 bytes at offset 1767424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1771520 ++read 2048/2048 bytes at offset 1771520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1775616 ++read 2048/2048 bytes at offset 1775616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1779712 ++read 2048/2048 bytes at offset 1779712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1783808 ++read 2048/2048 bytes at offset 1783808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1787904 ++read 2048/2048 bytes at offset 1787904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1792000 ++read 2048/2048 bytes at offset 1792000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1796096 ++read 2048/2048 bytes at offset 1796096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1800192 ++read 2048/2048 bytes at offset 1800192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1804288 ++read 2048/2048 bytes at offset 1804288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1808384 ++read 2048/2048 bytes at offset 1808384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1812480 ++read 2048/2048 bytes at offset 1812480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1816576 ++read 2048/2048 bytes at offset 1816576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1820672 ++read 2048/2048 bytes at offset 1820672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1824768 ++read 2048/2048 bytes at offset 1824768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1828864 ++read 2048/2048 bytes at offset 1828864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1832960 ++read 2048/2048 bytes at offset 1832960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1837056 ++read 2048/2048 bytes at offset 1837056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1841152 ++read 2048/2048 bytes at offset 1841152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1845248 ++read 2048/2048 bytes at offset 1845248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1849344 ++read 2048/2048 bytes at offset 1849344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1853440 ++read 2048/2048 bytes at offset 1853440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1857536 ++read 2048/2048 bytes at offset 1857536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1861632 ++read 2048/2048 bytes at offset 1861632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1865728 ++read 2048/2048 bytes at offset 1865728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1869824 ++read 2048/2048 bytes at offset 1869824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1873920 ++read 2048/2048 bytes at offset 1873920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1878016 ++read 2048/2048 bytes at offset 1878016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1882112 ++read 2048/2048 bytes at offset 1882112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1886208 ++read 2048/2048 bytes at offset 1886208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1890304 ++read 2048/2048 bytes at offset 1890304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1894400 ++read 2048/2048 bytes at offset 1894400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1898496 ++read 2048/2048 bytes at offset 1898496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1902592 ++read 2048/2048 bytes at offset 1902592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1906688 ++read 2048/2048 bytes at offset 1906688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1910784 ++read 2048/2048 bytes at offset 1910784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1914880 ++read 2048/2048 bytes at offset 1914880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1918976 ++read 2048/2048 bytes at offset 1918976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1923072 ++read 2048/2048 bytes at offset 1923072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1927168 ++read 2048/2048 bytes at offset 1927168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1931264 ++read 2048/2048 bytes at offset 1931264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1935360 ++read 2048/2048 bytes at offset 1935360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1939456 ++read 2048/2048 bytes at offset 1939456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1943552 ++read 2048/2048 bytes at offset 1943552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1947648 ++read 2048/2048 bytes at offset 1947648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1951744 ++read 2048/2048 bytes at offset 1951744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1955840 ++read 2048/2048 bytes at offset 1955840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1959936 ++read 2048/2048 bytes at offset 1959936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1964032 ++read 2048/2048 bytes at offset 1964032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1968128 ++read 2048/2048 bytes at offset 1968128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1972224 ++read 2048/2048 bytes at offset 1972224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1976320 ++read 2048/2048 bytes at offset 1976320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1980416 ++read 2048/2048 bytes at offset 1980416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1984512 ++read 2048/2048 bytes at offset 1984512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1988608 ++read 2048/2048 bytes at offset 1988608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1992704 ++read 2048/2048 bytes at offset 1992704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 1996800 ++read 2048/2048 bytes at offset 1996800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2000896 ++read 2048/2048 bytes at offset 2000896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2004992 ++read 2048/2048 bytes at offset 2004992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2009088 ++read 2048/2048 bytes at offset 2009088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2013184 ++read 2048/2048 bytes at offset 2013184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2017280 ++read 2048/2048 bytes at offset 2017280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2021376 ++read 2048/2048 bytes at offset 2021376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2025472 ++read 2048/2048 bytes at offset 2025472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2029568 ++read 2048/2048 bytes at offset 2029568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2033664 ++read 2048/2048 bytes at offset 2033664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2037760 ++read 2048/2048 bytes at offset 2037760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2041856 ++read 2048/2048 bytes at offset 2041856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2045952 ++read 2048/2048 bytes at offset 2045952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2050048 ++read 2048/2048 bytes at offset 2050048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2054144 ++read 2048/2048 bytes at offset 2054144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2058240 ++read 2048/2048 bytes at offset 2058240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2062336 ++read 2048/2048 bytes at offset 2062336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2066432 ++read 2048/2048 bytes at offset 2066432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2070528 ++read 2048/2048 bytes at offset 2070528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2074624 ++read 2048/2048 bytes at offset 2074624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2078720 ++read 2048/2048 bytes at offset 2078720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2082816 ++read 2048/2048 bytes at offset 2082816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2086912 ++read 2048/2048 bytes at offset 2086912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2091008 ++read 2048/2048 bytes at offset 2091008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2095104 ++read 2048/2048 bytes at offset 2095104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> read 2048/2048 bytes at offset 2097152 ++=== IO: pattern 0 ++read 2048/2048 bytes at offset 2097152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2101248 ++read 2048/2048 bytes at offset 2101248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2105344 ++read 2048/2048 bytes at offset 2105344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2109440 ++read 2048/2048 bytes at offset 2109440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2113536 ++read 2048/2048 bytes at offset 2113536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2117632 ++read 2048/2048 bytes at offset 2117632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2121728 ++read 2048/2048 bytes at offset 2121728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2125824 ++read 2048/2048 bytes at offset 2125824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2129920 ++read 2048/2048 bytes at offset 2129920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2134016 ++read 2048/2048 bytes at offset 2134016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2138112 ++read 2048/2048 bytes at offset 2138112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2142208 ++read 2048/2048 bytes at offset 2142208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2146304 ++read 2048/2048 bytes at offset 2146304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2150400 ++read 2048/2048 bytes at offset 2150400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2154496 ++read 2048/2048 bytes at offset 2154496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2158592 ++read 2048/2048 bytes at offset 2158592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2162688 ++read 2048/2048 bytes at offset 2162688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2166784 ++read 2048/2048 bytes at offset 2166784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2170880 ++read 2048/2048 bytes at offset 2170880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2174976 ++read 2048/2048 bytes at offset 2174976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2179072 ++read 2048/2048 bytes at offset 2179072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2183168 ++read 2048/2048 bytes at offset 2183168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2187264 ++read 2048/2048 bytes at offset 2187264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2191360 ++read 2048/2048 bytes at offset 2191360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2195456 ++read 2048/2048 bytes at offset 2195456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2199552 ++read 2048/2048 bytes at offset 2199552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2203648 ++read 2048/2048 bytes at offset 2203648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2207744 ++read 2048/2048 bytes at offset 2207744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2211840 ++read 2048/2048 bytes at offset 2211840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2215936 ++read 2048/2048 bytes at offset 2215936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2220032 ++read 2048/2048 bytes at offset 2220032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2224128 ++read 2048/2048 bytes at offset 2224128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2228224 ++read 2048/2048 bytes at offset 2228224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2232320 ++read 2048/2048 bytes at offset 2232320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2236416 ++read 2048/2048 bytes at offset 2236416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2240512 ++read 2048/2048 bytes at offset 2240512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2244608 ++read 2048/2048 bytes at offset 2244608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2248704 ++read 2048/2048 bytes at offset 2248704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2252800 ++read 2048/2048 bytes at offset 2252800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2256896 ++read 2048/2048 bytes at offset 2256896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2260992 ++read 2048/2048 bytes at offset 2260992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2265088 ++read 2048/2048 bytes at offset 2265088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2269184 ++read 2048/2048 bytes at offset 2269184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2273280 ++read 2048/2048 bytes at offset 2273280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2277376 ++read 2048/2048 bytes at offset 2277376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2281472 ++read 2048/2048 bytes at offset 2281472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2285568 ++read 2048/2048 bytes at offset 2285568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2289664 ++read 2048/2048 bytes at offset 2289664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2293760 ++read 2048/2048 bytes at offset 2293760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2297856 ++read 2048/2048 bytes at offset 2297856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2301952 ++read 2048/2048 bytes at offset 2301952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2306048 ++read 2048/2048 bytes at offset 2306048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2310144 ++read 2048/2048 bytes at offset 2310144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2314240 ++read 2048/2048 bytes at offset 2314240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2318336 ++read 2048/2048 bytes at offset 2318336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2322432 ++read 2048/2048 bytes at offset 2322432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2326528 ++read 2048/2048 bytes at offset 2326528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2330624 ++read 2048/2048 bytes at offset 2330624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2334720 ++read 2048/2048 bytes at offset 2334720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2338816 ++read 2048/2048 bytes at offset 2338816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2342912 ++read 2048/2048 bytes at offset 2342912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2347008 ++read 2048/2048 bytes at offset 2347008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2351104 ++read 2048/2048 bytes at offset 2351104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2355200 ++read 2048/2048 bytes at offset 2355200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2359296 ++read 2048/2048 bytes at offset 2359296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2363392 ++read 2048/2048 bytes at offset 2363392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2367488 ++read 2048/2048 bytes at offset 2367488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2371584 ++read 2048/2048 bytes at offset 2371584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2375680 ++read 2048/2048 bytes at offset 2375680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2379776 ++read 2048/2048 bytes at offset 2379776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2383872 ++read 2048/2048 bytes at offset 2383872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2387968 ++read 2048/2048 bytes at offset 2387968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2392064 ++read 2048/2048 bytes at offset 2392064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2396160 ++read 2048/2048 bytes at offset 2396160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2400256 ++read 2048/2048 bytes at offset 2400256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2404352 ++read 2048/2048 bytes at offset 2404352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2408448 ++read 2048/2048 bytes at offset 2408448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2412544 ++read 2048/2048 bytes at offset 2412544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2416640 ++read 2048/2048 bytes at offset 2416640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2420736 ++read 2048/2048 bytes at offset 2420736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2424832 ++read 2048/2048 bytes at offset 2424832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2428928 ++read 2048/2048 bytes at offset 2428928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2433024 ++read 2048/2048 bytes at offset 2433024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2437120 ++read 2048/2048 bytes at offset 2437120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2441216 ++read 2048/2048 bytes at offset 2441216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2445312 ++read 2048/2048 bytes at offset 2445312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2449408 ++read 2048/2048 bytes at offset 2449408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2453504 ++read 2048/2048 bytes at offset 2453504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2457600 ++read 2048/2048 bytes at offset 2457600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2461696 ++read 2048/2048 bytes at offset 2461696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2465792 ++read 2048/2048 bytes at offset 2465792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2469888 ++read 2048/2048 bytes at offset 2469888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2473984 ++read 2048/2048 bytes at offset 2473984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2478080 ++read 2048/2048 bytes at offset 2478080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2482176 ++read 2048/2048 bytes at offset 2482176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2486272 ++read 2048/2048 bytes at offset 2486272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2490368 ++read 2048/2048 bytes at offset 2490368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2494464 ++read 2048/2048 bytes at offset 2494464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2498560 ++read 2048/2048 bytes at offset 2498560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2502656 ++read 2048/2048 bytes at offset 2502656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2506752 ++read 2048/2048 bytes at offset 2506752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2510848 ++read 2048/2048 bytes at offset 2510848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2514944 ++read 2048/2048 bytes at offset 2514944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2519040 ++read 2048/2048 bytes at offset 2519040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2523136 ++read 2048/2048 bytes at offset 2523136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2527232 ++read 2048/2048 bytes at offset 2527232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2531328 ++read 2048/2048 bytes at offset 2531328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2535424 ++read 2048/2048 bytes at offset 2535424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2539520 ++read 2048/2048 bytes at offset 2539520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2543616 ++read 2048/2048 bytes at offset 2543616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2547712 ++read 2048/2048 bytes at offset 2547712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2551808 ++read 2048/2048 bytes at offset 2551808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2555904 ++read 2048/2048 bytes at offset 2555904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2560000 ++read 2048/2048 bytes at offset 2560000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2564096 ++read 2048/2048 bytes at offset 2564096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2568192 ++read 2048/2048 bytes at offset 2568192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2572288 ++read 2048/2048 bytes at offset 2572288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2576384 ++read 2048/2048 bytes at offset 2576384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2580480 ++read 2048/2048 bytes at offset 2580480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2584576 ++read 2048/2048 bytes at offset 2584576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2588672 ++read 2048/2048 bytes at offset 2588672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2592768 ++read 2048/2048 bytes at offset 2592768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2596864 ++read 2048/2048 bytes at offset 2596864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2600960 ++read 2048/2048 bytes at offset 2600960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2605056 ++read 2048/2048 bytes at offset 2605056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2609152 ++read 2048/2048 bytes at offset 2609152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2613248 ++read 2048/2048 bytes at offset 2613248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2617344 ++read 2048/2048 bytes at offset 2617344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2621440 ++read 2048/2048 bytes at offset 2621440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2625536 ++read 2048/2048 bytes at offset 2625536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2629632 ++read 2048/2048 bytes at offset 2629632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2633728 ++read 2048/2048 bytes at offset 2633728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2637824 ++read 2048/2048 bytes at offset 2637824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2641920 ++read 2048/2048 bytes at offset 2641920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2646016 ++read 2048/2048 bytes at offset 2646016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2650112 ++read 2048/2048 bytes at offset 2650112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2654208 ++read 2048/2048 bytes at offset 2654208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2658304 ++read 2048/2048 bytes at offset 2658304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2662400 ++read 2048/2048 bytes at offset 2662400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2666496 ++read 2048/2048 bytes at offset 2666496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2670592 ++read 2048/2048 bytes at offset 2670592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2674688 ++read 2048/2048 bytes at offset 2674688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2678784 ++read 2048/2048 bytes at offset 2678784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2682880 ++read 2048/2048 bytes at offset 2682880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2686976 ++read 2048/2048 bytes at offset 2686976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2691072 ++read 2048/2048 bytes at offset 2691072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2695168 ++read 2048/2048 bytes at offset 2695168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2699264 ++read 2048/2048 bytes at offset 2699264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2703360 ++read 2048/2048 bytes at offset 2703360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2707456 ++read 2048/2048 bytes at offset 2707456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2711552 ++read 2048/2048 bytes at offset 2711552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2715648 ++read 2048/2048 bytes at offset 2715648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2719744 ++read 2048/2048 bytes at offset 2719744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2723840 ++read 2048/2048 bytes at offset 2723840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2727936 ++read 2048/2048 bytes at offset 2727936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2732032 ++read 2048/2048 bytes at offset 2732032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2736128 ++read 2048/2048 bytes at offset 2736128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2740224 ++read 2048/2048 bytes at offset 2740224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2744320 ++read 2048/2048 bytes at offset 2744320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2748416 ++read 2048/2048 bytes at offset 2748416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2752512 ++read 2048/2048 bytes at offset 2752512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2756608 ++read 2048/2048 bytes at offset 2756608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2760704 ++read 2048/2048 bytes at offset 2760704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2764800 ++read 2048/2048 bytes at offset 2764800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2768896 ++read 2048/2048 bytes at offset 2768896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2772992 ++read 2048/2048 bytes at offset 2772992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2777088 ++read 2048/2048 bytes at offset 2777088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2781184 ++read 2048/2048 bytes at offset 2781184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2785280 ++read 2048/2048 bytes at offset 2785280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2789376 ++read 2048/2048 bytes at offset 2789376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2793472 ++read 2048/2048 bytes at offset 2793472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2797568 ++read 2048/2048 bytes at offset 2797568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2801664 ++read 2048/2048 bytes at offset 2801664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2805760 ++read 2048/2048 bytes at offset 2805760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2809856 ++read 2048/2048 bytes at offset 2809856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2813952 ++read 2048/2048 bytes at offset 2813952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2818048 ++read 2048/2048 bytes at offset 2818048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2822144 ++read 2048/2048 bytes at offset 2822144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2826240 ++read 2048/2048 bytes at offset 2826240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2830336 ++read 2048/2048 bytes at offset 2830336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2834432 ++read 2048/2048 bytes at offset 2834432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2838528 ++read 2048/2048 bytes at offset 2838528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2842624 ++read 2048/2048 bytes at offset 2842624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2846720 ++read 2048/2048 bytes at offset 2846720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2850816 ++read 2048/2048 bytes at offset 2850816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2854912 ++read 2048/2048 bytes at offset 2854912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2859008 ++read 2048/2048 bytes at offset 2859008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2863104 ++read 2048/2048 bytes at offset 2863104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2867200 ++read 2048/2048 bytes at offset 2867200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2871296 ++read 2048/2048 bytes at offset 2871296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2875392 ++read 2048/2048 bytes at offset 2875392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2879488 ++read 2048/2048 bytes at offset 2879488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2883584 ++read 2048/2048 bytes at offset 2883584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2887680 ++read 2048/2048 bytes at offset 2887680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2891776 ++read 2048/2048 bytes at offset 2891776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2895872 ++read 2048/2048 bytes at offset 2895872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2899968 ++read 2048/2048 bytes at offset 2899968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2904064 ++read 2048/2048 bytes at offset 2904064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2908160 ++read 2048/2048 bytes at offset 2908160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2912256 ++read 2048/2048 bytes at offset 2912256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2916352 ++read 2048/2048 bytes at offset 2916352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2920448 ++read 2048/2048 bytes at offset 2920448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2924544 ++read 2048/2048 bytes at offset 2924544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2928640 ++read 2048/2048 bytes at offset 2928640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2932736 ++read 2048/2048 bytes at offset 2932736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2936832 ++read 2048/2048 bytes at offset 2936832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2940928 ++read 2048/2048 bytes at offset 2940928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2945024 ++read 2048/2048 bytes at offset 2945024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2949120 ++read 2048/2048 bytes at offset 2949120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2953216 ++read 2048/2048 bytes at offset 2953216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2957312 ++read 2048/2048 bytes at offset 2957312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2961408 ++read 2048/2048 bytes at offset 2961408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2965504 ++read 2048/2048 bytes at offset 2965504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2969600 ++read 2048/2048 bytes at offset 2969600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2973696 ++read 2048/2048 bytes at offset 2973696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2977792 ++read 2048/2048 bytes at offset 2977792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2981888 ++read 2048/2048 bytes at offset 2981888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2985984 ++read 2048/2048 bytes at offset 2985984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2990080 ++read 2048/2048 bytes at offset 2990080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2994176 ++read 2048/2048 bytes at offset 2994176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 2998272 ++read 2048/2048 bytes at offset 2998272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3002368 ++read 2048/2048 bytes at offset 3002368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3006464 ++read 2048/2048 bytes at offset 3006464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3010560 ++read 2048/2048 bytes at offset 3010560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3014656 ++read 2048/2048 bytes at offset 3014656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3018752 ++read 2048/2048 bytes at offset 3018752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3022848 ++read 2048/2048 bytes at offset 3022848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3026944 ++read 2048/2048 bytes at offset 3026944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3031040 ++read 2048/2048 bytes at offset 3031040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3035136 ++read 2048/2048 bytes at offset 3035136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3039232 ++read 2048/2048 bytes at offset 3039232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3043328 ++read 2048/2048 bytes at offset 3043328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3047424 ++read 2048/2048 bytes at offset 3047424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3051520 ++read 2048/2048 bytes at offset 3051520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3055616 ++read 2048/2048 bytes at offset 3055616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3059712 ++read 2048/2048 bytes at offset 3059712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3063808 ++read 2048/2048 bytes at offset 3063808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3067904 ++read 2048/2048 bytes at offset 3067904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3072000 ++read 2048/2048 bytes at offset 3072000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3076096 ++read 2048/2048 bytes at offset 3076096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3080192 ++read 2048/2048 bytes at offset 3080192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3084288 ++read 2048/2048 bytes at offset 3084288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3088384 ++read 2048/2048 bytes at offset 3088384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3092480 ++read 2048/2048 bytes at offset 3092480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3096576 ++read 2048/2048 bytes at offset 3096576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3100672 ++read 2048/2048 bytes at offset 3100672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3104768 ++read 2048/2048 bytes at offset 3104768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3108864 ++read 2048/2048 bytes at offset 3108864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3112960 ++read 2048/2048 bytes at offset 3112960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3117056 ++read 2048/2048 bytes at offset 3117056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3121152 ++read 2048/2048 bytes at offset 3121152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3125248 ++read 2048/2048 bytes at offset 3125248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3129344 ++read 2048/2048 bytes at offset 3129344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3133440 ++read 2048/2048 bytes at offset 3133440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3137536 ++read 2048/2048 bytes at offset 3137536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3141632 ++read 2048/2048 bytes at offset 3141632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 2 +-qemu-io> read 2048/2048 bytes at offset 3146752 ++=== IO: pattern 2 ++read 2048/2048 bytes at offset 3146752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3150848 ++read 2048/2048 bytes at offset 3150848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3154944 ++read 2048/2048 bytes at offset 3154944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3159040 ++read 2048/2048 bytes at offset 3159040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3163136 ++read 2048/2048 bytes at offset 3163136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3167232 ++read 2048/2048 bytes at offset 3167232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3171328 ++read 2048/2048 bytes at offset 3171328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3175424 ++read 2048/2048 bytes at offset 3175424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3179520 ++read 2048/2048 bytes at offset 3179520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3183616 ++read 2048/2048 bytes at offset 3183616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3187712 ++read 2048/2048 bytes at offset 3187712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3191808 ++read 2048/2048 bytes at offset 3191808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3195904 ++read 2048/2048 bytes at offset 3195904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3200000 ++read 2048/2048 bytes at offset 3200000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3204096 ++read 2048/2048 bytes at offset 3204096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3208192 ++read 2048/2048 bytes at offset 3208192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3212288 ++read 2048/2048 bytes at offset 3212288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3216384 ++read 2048/2048 bytes at offset 3216384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3220480 ++read 2048/2048 bytes at offset 3220480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3224576 ++read 2048/2048 bytes at offset 3224576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3228672 ++read 2048/2048 bytes at offset 3228672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3232768 ++read 2048/2048 bytes at offset 3232768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3236864 ++read 2048/2048 bytes at offset 3236864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3240960 ++read 2048/2048 bytes at offset 3240960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3245056 ++read 2048/2048 bytes at offset 3245056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3249152 ++read 2048/2048 bytes at offset 3249152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3253248 ++read 2048/2048 bytes at offset 3253248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3257344 ++read 2048/2048 bytes at offset 3257344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3261440 ++read 2048/2048 bytes at offset 3261440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3265536 ++read 2048/2048 bytes at offset 3265536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3269632 ++read 2048/2048 bytes at offset 3269632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3273728 ++read 2048/2048 bytes at offset 3273728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3277824 ++read 2048/2048 bytes at offset 3277824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3281920 ++read 2048/2048 bytes at offset 3281920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3286016 ++read 2048/2048 bytes at offset 3286016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3290112 ++read 2048/2048 bytes at offset 3290112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3294208 ++read 2048/2048 bytes at offset 3294208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3298304 ++read 2048/2048 bytes at offset 3298304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3302400 ++read 2048/2048 bytes at offset 3302400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3306496 ++read 2048/2048 bytes at offset 3306496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3310592 ++read 2048/2048 bytes at offset 3310592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3314688 ++read 2048/2048 bytes at offset 3314688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3318784 ++read 2048/2048 bytes at offset 3318784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3322880 ++read 2048/2048 bytes at offset 3322880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3326976 ++read 2048/2048 bytes at offset 3326976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3331072 ++read 2048/2048 bytes at offset 3331072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3335168 ++read 2048/2048 bytes at offset 3335168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3339264 ++read 2048/2048 bytes at offset 3339264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3343360 ++read 2048/2048 bytes at offset 3343360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3347456 ++read 2048/2048 bytes at offset 3347456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3351552 ++read 2048/2048 bytes at offset 3351552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3355648 ++read 2048/2048 bytes at offset 3355648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3359744 ++read 2048/2048 bytes at offset 3359744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3363840 ++read 2048/2048 bytes at offset 3363840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3367936 ++read 2048/2048 bytes at offset 3367936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3372032 ++read 2048/2048 bytes at offset 3372032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3376128 ++read 2048/2048 bytes at offset 3376128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3380224 ++read 2048/2048 bytes at offset 3380224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3384320 ++read 2048/2048 bytes at offset 3384320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3388416 ++read 2048/2048 bytes at offset 3388416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3392512 ++read 2048/2048 bytes at offset 3392512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3396608 ++read 2048/2048 bytes at offset 3396608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3400704 ++read 2048/2048 bytes at offset 3400704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3404800 ++read 2048/2048 bytes at offset 3404800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3408896 ++read 2048/2048 bytes at offset 3408896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3412992 ++read 2048/2048 bytes at offset 3412992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3417088 ++read 2048/2048 bytes at offset 3417088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3421184 ++read 2048/2048 bytes at offset 3421184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3425280 ++read 2048/2048 bytes at offset 3425280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3429376 ++read 2048/2048 bytes at offset 3429376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3433472 ++read 2048/2048 bytes at offset 3433472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3437568 ++read 2048/2048 bytes at offset 3437568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3441664 ++read 2048/2048 bytes at offset 3441664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3445760 ++read 2048/2048 bytes at offset 3445760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3449856 ++read 2048/2048 bytes at offset 3449856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3453952 ++read 2048/2048 bytes at offset 3453952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3458048 ++read 2048/2048 bytes at offset 3458048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3462144 ++read 2048/2048 bytes at offset 3462144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3466240 ++read 2048/2048 bytes at offset 3466240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3470336 ++read 2048/2048 bytes at offset 3470336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3474432 ++read 2048/2048 bytes at offset 3474432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3478528 ++read 2048/2048 bytes at offset 3478528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3482624 ++read 2048/2048 bytes at offset 3482624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3486720 ++read 2048/2048 bytes at offset 3486720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3490816 ++read 2048/2048 bytes at offset 3490816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3494912 ++read 2048/2048 bytes at offset 3494912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3499008 ++read 2048/2048 bytes at offset 3499008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3503104 ++read 2048/2048 bytes at offset 3503104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3507200 ++read 2048/2048 bytes at offset 3507200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3511296 ++read 2048/2048 bytes at offset 3511296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3515392 ++read 2048/2048 bytes at offset 3515392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3519488 ++read 2048/2048 bytes at offset 3519488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3523584 ++read 2048/2048 bytes at offset 3523584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3527680 ++read 2048/2048 bytes at offset 3527680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3531776 ++read 2048/2048 bytes at offset 3531776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3535872 ++read 2048/2048 bytes at offset 3535872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3539968 ++read 2048/2048 bytes at offset 3539968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3544064 ++read 2048/2048 bytes at offset 3544064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3548160 ++read 2048/2048 bytes at offset 3548160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3552256 ++read 2048/2048 bytes at offset 3552256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3556352 ++read 2048/2048 bytes at offset 3556352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3560448 ++read 2048/2048 bytes at offset 3560448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3564544 ++read 2048/2048 bytes at offset 3564544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3568640 ++read 2048/2048 bytes at offset 3568640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3572736 ++read 2048/2048 bytes at offset 3572736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3576832 ++read 2048/2048 bytes at offset 3576832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3580928 ++read 2048/2048 bytes at offset 3580928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3585024 ++read 2048/2048 bytes at offset 3585024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3589120 ++read 2048/2048 bytes at offset 3589120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3593216 ++read 2048/2048 bytes at offset 3593216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3597312 ++read 2048/2048 bytes at offset 3597312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3601408 ++read 2048/2048 bytes at offset 3601408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3605504 ++read 2048/2048 bytes at offset 3605504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3609600 ++read 2048/2048 bytes at offset 3609600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3613696 ++read 2048/2048 bytes at offset 3613696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3617792 ++read 2048/2048 bytes at offset 3617792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3621888 ++read 2048/2048 bytes at offset 3621888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3625984 ++read 2048/2048 bytes at offset 3625984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3630080 ++read 2048/2048 bytes at offset 3630080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3634176 ++read 2048/2048 bytes at offset 3634176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3638272 ++read 2048/2048 bytes at offset 3638272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3642368 ++read 2048/2048 bytes at offset 3642368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3646464 ++read 2048/2048 bytes at offset 3646464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3650560 ++read 2048/2048 bytes at offset 3650560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3654656 ++read 2048/2048 bytes at offset 3654656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3658752 ++read 2048/2048 bytes at offset 3658752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3662848 ++read 2048/2048 bytes at offset 3662848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3666944 ++read 2048/2048 bytes at offset 3666944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3671040 ++read 2048/2048 bytes at offset 3671040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3675136 ++read 2048/2048 bytes at offset 3675136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3679232 ++read 2048/2048 bytes at offset 3679232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3683328 ++read 2048/2048 bytes at offset 3683328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3687424 ++read 2048/2048 bytes at offset 3687424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3691520 ++read 2048/2048 bytes at offset 3691520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3695616 ++read 2048/2048 bytes at offset 3695616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3699712 ++read 2048/2048 bytes at offset 3699712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3703808 ++read 2048/2048 bytes at offset 3703808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3707904 ++read 2048/2048 bytes at offset 3707904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3712000 ++read 2048/2048 bytes at offset 3712000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3716096 ++read 2048/2048 bytes at offset 3716096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3720192 ++read 2048/2048 bytes at offset 3720192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3724288 ++read 2048/2048 bytes at offset 3724288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3728384 ++read 2048/2048 bytes at offset 3728384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3732480 ++read 2048/2048 bytes at offset 3732480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3736576 ++read 2048/2048 bytes at offset 3736576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3740672 ++read 2048/2048 bytes at offset 3740672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3744768 ++read 2048/2048 bytes at offset 3744768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3748864 ++read 2048/2048 bytes at offset 3748864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3752960 ++read 2048/2048 bytes at offset 3752960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3757056 ++read 2048/2048 bytes at offset 3757056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3761152 ++read 2048/2048 bytes at offset 3761152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3765248 ++read 2048/2048 bytes at offset 3765248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3769344 ++read 2048/2048 bytes at offset 3769344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3773440 ++read 2048/2048 bytes at offset 3773440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3777536 ++read 2048/2048 bytes at offset 3777536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3781632 ++read 2048/2048 bytes at offset 3781632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3785728 ++read 2048/2048 bytes at offset 3785728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3789824 ++read 2048/2048 bytes at offset 3789824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3793920 ++read 2048/2048 bytes at offset 3793920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3798016 ++read 2048/2048 bytes at offset 3798016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3802112 ++read 2048/2048 bytes at offset 3802112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3806208 ++read 2048/2048 bytes at offset 3806208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3810304 ++read 2048/2048 bytes at offset 3810304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3814400 ++read 2048/2048 bytes at offset 3814400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3818496 ++read 2048/2048 bytes at offset 3818496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3822592 ++read 2048/2048 bytes at offset 3822592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3826688 ++read 2048/2048 bytes at offset 3826688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3830784 ++read 2048/2048 bytes at offset 3830784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3834880 ++read 2048/2048 bytes at offset 3834880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3838976 ++read 2048/2048 bytes at offset 3838976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3843072 ++read 2048/2048 bytes at offset 3843072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3847168 ++read 2048/2048 bytes at offset 3847168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3851264 ++read 2048/2048 bytes at offset 3851264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3855360 ++read 2048/2048 bytes at offset 3855360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3859456 ++read 2048/2048 bytes at offset 3859456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3863552 ++read 2048/2048 bytes at offset 3863552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3867648 ++read 2048/2048 bytes at offset 3867648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3871744 ++read 2048/2048 bytes at offset 3871744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3875840 ++read 2048/2048 bytes at offset 3875840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3879936 ++read 2048/2048 bytes at offset 3879936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3884032 ++read 2048/2048 bytes at offset 3884032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3888128 ++read 2048/2048 bytes at offset 3888128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3892224 ++read 2048/2048 bytes at offset 3892224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3896320 ++read 2048/2048 bytes at offset 3896320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3900416 ++read 2048/2048 bytes at offset 3900416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3904512 ++read 2048/2048 bytes at offset 3904512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3908608 ++read 2048/2048 bytes at offset 3908608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3912704 ++read 2048/2048 bytes at offset 3912704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3916800 ++read 2048/2048 bytes at offset 3916800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3920896 ++read 2048/2048 bytes at offset 3920896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3924992 ++read 2048/2048 bytes at offset 3924992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3929088 ++read 2048/2048 bytes at offset 3929088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3933184 ++read 2048/2048 bytes at offset 3933184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3937280 ++read 2048/2048 bytes at offset 3937280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3941376 ++read 2048/2048 bytes at offset 3941376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3945472 ++read 2048/2048 bytes at offset 3945472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3949568 ++read 2048/2048 bytes at offset 3949568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3953664 ++read 2048/2048 bytes at offset 3953664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3957760 ++read 2048/2048 bytes at offset 3957760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3961856 ++read 2048/2048 bytes at offset 3961856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3965952 ++read 2048/2048 bytes at offset 3965952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3970048 ++read 2048/2048 bytes at offset 3970048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3974144 ++read 2048/2048 bytes at offset 3974144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3978240 ++read 2048/2048 bytes at offset 3978240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3982336 ++read 2048/2048 bytes at offset 3982336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3986432 ++read 2048/2048 bytes at offset 3986432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3990528 ++read 2048/2048 bytes at offset 3990528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3994624 ++read 2048/2048 bytes at offset 3994624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 3998720 ++read 2048/2048 bytes at offset 3998720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4002816 ++read 2048/2048 bytes at offset 4002816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4006912 ++read 2048/2048 bytes at offset 4006912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4011008 ++read 2048/2048 bytes at offset 4011008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4015104 ++read 2048/2048 bytes at offset 4015104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4019200 ++read 2048/2048 bytes at offset 4019200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4023296 ++read 2048/2048 bytes at offset 4023296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4027392 ++read 2048/2048 bytes at offset 4027392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4031488 ++read 2048/2048 bytes at offset 4031488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4035584 ++read 2048/2048 bytes at offset 4035584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4039680 ++read 2048/2048 bytes at offset 4039680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4043776 ++read 2048/2048 bytes at offset 4043776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4047872 ++read 2048/2048 bytes at offset 4047872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4051968 ++read 2048/2048 bytes at offset 4051968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4056064 ++read 2048/2048 bytes at offset 4056064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4060160 ++read 2048/2048 bytes at offset 4060160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4064256 ++read 2048/2048 bytes at offset 4064256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4068352 ++read 2048/2048 bytes at offset 4068352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4072448 ++read 2048/2048 bytes at offset 4072448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4076544 ++read 2048/2048 bytes at offset 4076544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4080640 ++read 2048/2048 bytes at offset 4080640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4084736 ++read 2048/2048 bytes at offset 4084736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4088832 ++read 2048/2048 bytes at offset 4088832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4092928 ++read 2048/2048 bytes at offset 4092928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4097024 ++read 2048/2048 bytes at offset 4097024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4101120 ++read 2048/2048 bytes at offset 4101120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4105216 ++read 2048/2048 bytes at offset 4105216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4109312 ++read 2048/2048 bytes at offset 4109312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4113408 ++read 2048/2048 bytes at offset 4113408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4117504 ++read 2048/2048 bytes at offset 4117504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4121600 ++read 2048/2048 bytes at offset 4121600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4125696 ++read 2048/2048 bytes at offset 4125696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4129792 ++read 2048/2048 bytes at offset 4129792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4133888 ++read 2048/2048 bytes at offset 4133888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4137984 ++read 2048/2048 bytes at offset 4137984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4142080 ++read 2048/2048 bytes at offset 4142080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4146176 ++read 2048/2048 bytes at offset 4146176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4150272 ++read 2048/2048 bytes at offset 4150272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4154368 ++read 2048/2048 bytes at offset 4154368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4158464 ++read 2048/2048 bytes at offset 4158464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4162560 ++read 2048/2048 bytes at offset 4162560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4166656 ++read 2048/2048 bytes at offset 4166656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4170752 ++read 2048/2048 bytes at offset 4170752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4174848 ++read 2048/2048 bytes at offset 4174848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4178944 ++read 2048/2048 bytes at offset 4178944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4183040 ++read 2048/2048 bytes at offset 4183040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4187136 ++read 2048/2048 bytes at offset 4187136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4191232 ++read 2048/2048 bytes at offset 4191232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 4 +-qemu-io> read 8192/8192 bytes at offset 4196352 ++=== IO: pattern 4 ++read 8192/8192 bytes at offset 4196352 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4208640 ++read 8192/8192 bytes at offset 4208640 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4220928 ++read 8192/8192 bytes at offset 4220928 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4233216 ++read 8192/8192 bytes at offset 4233216 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4245504 ++read 8192/8192 bytes at offset 4245504 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4257792 ++read 8192/8192 bytes at offset 4257792 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4270080 ++read 8192/8192 bytes at offset 4270080 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4282368 ++read 8192/8192 bytes at offset 4282368 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4294656 ++read 8192/8192 bytes at offset 4294656 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4306944 ++read 8192/8192 bytes at offset 4306944 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4319232 ++read 8192/8192 bytes at offset 4319232 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4331520 ++read 8192/8192 bytes at offset 4331520 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4343808 ++read 8192/8192 bytes at offset 4343808 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4356096 ++read 8192/8192 bytes at offset 4356096 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4368384 ++read 8192/8192 bytes at offset 4368384 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4380672 ++read 8192/8192 bytes at offset 4380672 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4392960 ++read 8192/8192 bytes at offset 4392960 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4405248 ++read 8192/8192 bytes at offset 4405248 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4417536 ++read 8192/8192 bytes at offset 4417536 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4429824 ++read 8192/8192 bytes at offset 4429824 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4442112 ++read 8192/8192 bytes at offset 4442112 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4454400 ++read 8192/8192 bytes at offset 4454400 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4466688 ++read 8192/8192 bytes at offset 4466688 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4478976 ++read 8192/8192 bytes at offset 4478976 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4491264 ++read 8192/8192 bytes at offset 4491264 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4503552 ++read 8192/8192 bytes at offset 4503552 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4515840 ++read 8192/8192 bytes at offset 4515840 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4528128 ++read 8192/8192 bytes at offset 4528128 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4540416 ++read 8192/8192 bytes at offset 4540416 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4552704 ++read 8192/8192 bytes at offset 4552704 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4564992 ++read 8192/8192 bytes at offset 4564992 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4577280 ++read 8192/8192 bytes at offset 4577280 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4589568 ++read 8192/8192 bytes at offset 4589568 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4601856 ++read 8192/8192 bytes at offset 4601856 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4614144 ++read 8192/8192 bytes at offset 4614144 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4626432 ++read 8192/8192 bytes at offset 4626432 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4638720 ++read 8192/8192 bytes at offset 4638720 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4651008 ++read 8192/8192 bytes at offset 4651008 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4663296 ++read 8192/8192 bytes at offset 4663296 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4675584 ++read 8192/8192 bytes at offset 4675584 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4687872 ++read 8192/8192 bytes at offset 4687872 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4700160 ++read 8192/8192 bytes at offset 4700160 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4712448 ++read 8192/8192 bytes at offset 4712448 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4724736 ++read 8192/8192 bytes at offset 4724736 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4737024 ++read 8192/8192 bytes at offset 4737024 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4749312 ++read 8192/8192 bytes at offset 4749312 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4761600 ++read 8192/8192 bytes at offset 4761600 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4773888 ++read 8192/8192 bytes at offset 4773888 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4786176 ++read 8192/8192 bytes at offset 4786176 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4798464 ++read 8192/8192 bytes at offset 4798464 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4810752 ++read 8192/8192 bytes at offset 4810752 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4823040 ++read 8192/8192 bytes at offset 4823040 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4835328 ++read 8192/8192 bytes at offset 4835328 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4847616 ++read 8192/8192 bytes at offset 4847616 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4859904 ++read 8192/8192 bytes at offset 4859904 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4872192 ++read 8192/8192 bytes at offset 4872192 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4884480 ++read 8192/8192 bytes at offset 4884480 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4896768 ++read 8192/8192 bytes at offset 4896768 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4909056 ++read 8192/8192 bytes at offset 4909056 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4921344 ++read 8192/8192 bytes at offset 4921344 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4933632 ++read 8192/8192 bytes at offset 4933632 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4945920 ++read 8192/8192 bytes at offset 4945920 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4958208 ++read 8192/8192 bytes at offset 4958208 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4970496 ++read 8192/8192 bytes at offset 4970496 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 244 +-qemu-io> read 12288/12288 bytes at offset 6285312 ++=== IO: pattern 244 ++read 12288/12288 bytes at offset 6285312 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 8384512 ++read 12288/12288 bytes at offset 8384512 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 10483712 ++read 12288/12288 bytes at offset 10483712 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 12582912 ++read 12288/12288 bytes at offset 12582912 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 14682112 ++read 12288/12288 bytes at offset 14682112 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 16781312 ++read 12288/12288 bytes at offset 16781312 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 18880512 ++read 12288/12288 bytes at offset 18880512 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 20979712 ++read 12288/12288 bytes at offset 20979712 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> No errors were found on the image. ++No errors were found on the image. + With snapshot test3, offset 4294967296 + === IO: pattern 0 +-qemu-io> wrote 4096/4096 bytes at offset 4294967296 ++wrote 4096/4096 bytes at offset 4294967296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4294971392 ++wrote 4096/4096 bytes at offset 4294971392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4294975488 ++wrote 4096/4096 bytes at offset 4294975488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4294979584 ++wrote 4096/4096 bytes at offset 4294979584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4294983680 ++wrote 4096/4096 bytes at offset 4294983680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4294987776 ++wrote 4096/4096 bytes at offset 4294987776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4294991872 ++wrote 4096/4096 bytes at offset 4294991872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4294995968 ++wrote 4096/4096 bytes at offset 4294995968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295000064 ++wrote 4096/4096 bytes at offset 4295000064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295004160 ++wrote 4096/4096 bytes at offset 4295004160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295008256 ++wrote 4096/4096 bytes at offset 4295008256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295012352 ++wrote 4096/4096 bytes at offset 4295012352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295016448 ++wrote 4096/4096 bytes at offset 4295016448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295020544 ++wrote 4096/4096 bytes at offset 4295020544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295024640 ++wrote 4096/4096 bytes at offset 4295024640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295028736 ++wrote 4096/4096 bytes at offset 4295028736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295032832 ++wrote 4096/4096 bytes at offset 4295032832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295036928 ++wrote 4096/4096 bytes at offset 4295036928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295041024 ++wrote 4096/4096 bytes at offset 4295041024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295045120 ++wrote 4096/4096 bytes at offset 4295045120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295049216 ++wrote 4096/4096 bytes at offset 4295049216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295053312 ++wrote 4096/4096 bytes at offset 4295053312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295057408 ++wrote 4096/4096 bytes at offset 4295057408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295061504 ++wrote 4096/4096 bytes at offset 4295061504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295065600 ++wrote 4096/4096 bytes at offset 4295065600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295069696 ++wrote 4096/4096 bytes at offset 4295069696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295073792 ++wrote 4096/4096 bytes at offset 4295073792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295077888 ++wrote 4096/4096 bytes at offset 4295077888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295081984 ++wrote 4096/4096 bytes at offset 4295081984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295086080 ++wrote 4096/4096 bytes at offset 4295086080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295090176 ++wrote 4096/4096 bytes at offset 4295090176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295094272 ++wrote 4096/4096 bytes at offset 4295094272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295098368 ++wrote 4096/4096 bytes at offset 4295098368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295102464 ++wrote 4096/4096 bytes at offset 4295102464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295106560 ++wrote 4096/4096 bytes at offset 4295106560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295110656 ++wrote 4096/4096 bytes at offset 4295110656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295114752 ++wrote 4096/4096 bytes at offset 4295114752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295118848 ++wrote 4096/4096 bytes at offset 4295118848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295122944 ++wrote 4096/4096 bytes at offset 4295122944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295127040 ++wrote 4096/4096 bytes at offset 4295127040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295131136 ++wrote 4096/4096 bytes at offset 4295131136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295135232 ++wrote 4096/4096 bytes at offset 4295135232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295139328 ++wrote 4096/4096 bytes at offset 4295139328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295143424 ++wrote 4096/4096 bytes at offset 4295143424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295147520 ++wrote 4096/4096 bytes at offset 4295147520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295151616 ++wrote 4096/4096 bytes at offset 4295151616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295155712 ++wrote 4096/4096 bytes at offset 4295155712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295159808 ++wrote 4096/4096 bytes at offset 4295159808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295163904 ++wrote 4096/4096 bytes at offset 4295163904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295168000 ++wrote 4096/4096 bytes at offset 4295168000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295172096 ++wrote 4096/4096 bytes at offset 4295172096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295176192 ++wrote 4096/4096 bytes at offset 4295176192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295180288 ++wrote 4096/4096 bytes at offset 4295180288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295184384 ++wrote 4096/4096 bytes at offset 4295184384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295188480 ++wrote 4096/4096 bytes at offset 4295188480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295192576 ++wrote 4096/4096 bytes at offset 4295192576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295196672 ++wrote 4096/4096 bytes at offset 4295196672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295200768 ++wrote 4096/4096 bytes at offset 4295200768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295204864 ++wrote 4096/4096 bytes at offset 4295204864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295208960 ++wrote 4096/4096 bytes at offset 4295208960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295213056 ++wrote 4096/4096 bytes at offset 4295213056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295217152 ++wrote 4096/4096 bytes at offset 4295217152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295221248 ++wrote 4096/4096 bytes at offset 4295221248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295225344 ++wrote 4096/4096 bytes at offset 4295225344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295229440 ++wrote 4096/4096 bytes at offset 4295229440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295233536 ++wrote 4096/4096 bytes at offset 4295233536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295237632 ++wrote 4096/4096 bytes at offset 4295237632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295241728 ++wrote 4096/4096 bytes at offset 4295241728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295245824 ++wrote 4096/4096 bytes at offset 4295245824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295249920 ++wrote 4096/4096 bytes at offset 4295249920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295254016 ++wrote 4096/4096 bytes at offset 4295254016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295258112 ++wrote 4096/4096 bytes at offset 4295258112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295262208 ++wrote 4096/4096 bytes at offset 4295262208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295266304 ++wrote 4096/4096 bytes at offset 4295266304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295270400 ++wrote 4096/4096 bytes at offset 4295270400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295274496 ++wrote 4096/4096 bytes at offset 4295274496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295278592 ++wrote 4096/4096 bytes at offset 4295278592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295282688 ++wrote 4096/4096 bytes at offset 4295282688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295286784 ++wrote 4096/4096 bytes at offset 4295286784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295290880 ++wrote 4096/4096 bytes at offset 4295290880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295294976 ++wrote 4096/4096 bytes at offset 4295294976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295299072 ++wrote 4096/4096 bytes at offset 4295299072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295303168 ++wrote 4096/4096 bytes at offset 4295303168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295307264 ++wrote 4096/4096 bytes at offset 4295307264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295311360 ++wrote 4096/4096 bytes at offset 4295311360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295315456 ++wrote 4096/4096 bytes at offset 4295315456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295319552 ++wrote 4096/4096 bytes at offset 4295319552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295323648 ++wrote 4096/4096 bytes at offset 4295323648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295327744 ++wrote 4096/4096 bytes at offset 4295327744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295331840 ++wrote 4096/4096 bytes at offset 4295331840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295335936 ++wrote 4096/4096 bytes at offset 4295335936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295340032 ++wrote 4096/4096 bytes at offset 4295340032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295344128 ++wrote 4096/4096 bytes at offset 4295344128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295348224 ++wrote 4096/4096 bytes at offset 4295348224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295352320 ++wrote 4096/4096 bytes at offset 4295352320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295356416 ++wrote 4096/4096 bytes at offset 4295356416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295360512 ++wrote 4096/4096 bytes at offset 4295360512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295364608 ++wrote 4096/4096 bytes at offset 4295364608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295368704 ++wrote 4096/4096 bytes at offset 4295368704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295372800 ++wrote 4096/4096 bytes at offset 4295372800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295376896 ++wrote 4096/4096 bytes at offset 4295376896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295380992 ++wrote 4096/4096 bytes at offset 4295380992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295385088 ++wrote 4096/4096 bytes at offset 4295385088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295389184 ++wrote 4096/4096 bytes at offset 4295389184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295393280 ++wrote 4096/4096 bytes at offset 4295393280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295397376 ++wrote 4096/4096 bytes at offset 4295397376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295401472 ++wrote 4096/4096 bytes at offset 4295401472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295405568 ++wrote 4096/4096 bytes at offset 4295405568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295409664 ++wrote 4096/4096 bytes at offset 4295409664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295413760 ++wrote 4096/4096 bytes at offset 4295413760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295417856 ++wrote 4096/4096 bytes at offset 4295417856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295421952 ++wrote 4096/4096 bytes at offset 4295421952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295426048 ++wrote 4096/4096 bytes at offset 4295426048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295430144 ++wrote 4096/4096 bytes at offset 4295430144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295434240 ++wrote 4096/4096 bytes at offset 4295434240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295438336 ++wrote 4096/4096 bytes at offset 4295438336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295442432 ++wrote 4096/4096 bytes at offset 4295442432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295446528 ++wrote 4096/4096 bytes at offset 4295446528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295450624 ++wrote 4096/4096 bytes at offset 4295450624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295454720 ++wrote 4096/4096 bytes at offset 4295454720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295458816 ++wrote 4096/4096 bytes at offset 4295458816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295462912 ++wrote 4096/4096 bytes at offset 4295462912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295467008 ++wrote 4096/4096 bytes at offset 4295467008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295471104 ++wrote 4096/4096 bytes at offset 4295471104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295475200 ++wrote 4096/4096 bytes at offset 4295475200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295479296 ++wrote 4096/4096 bytes at offset 4295479296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295483392 ++wrote 4096/4096 bytes at offset 4295483392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295487488 ++wrote 4096/4096 bytes at offset 4295487488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295491584 ++wrote 4096/4096 bytes at offset 4295491584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295495680 ++wrote 4096/4096 bytes at offset 4295495680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295499776 ++wrote 4096/4096 bytes at offset 4295499776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295503872 ++wrote 4096/4096 bytes at offset 4295503872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295507968 ++wrote 4096/4096 bytes at offset 4295507968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295512064 ++wrote 4096/4096 bytes at offset 4295512064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295516160 ++wrote 4096/4096 bytes at offset 4295516160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295520256 ++wrote 4096/4096 bytes at offset 4295520256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295524352 ++wrote 4096/4096 bytes at offset 4295524352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295528448 ++wrote 4096/4096 bytes at offset 4295528448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295532544 ++wrote 4096/4096 bytes at offset 4295532544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295536640 ++wrote 4096/4096 bytes at offset 4295536640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295540736 ++wrote 4096/4096 bytes at offset 4295540736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295544832 ++wrote 4096/4096 bytes at offset 4295544832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295548928 ++wrote 4096/4096 bytes at offset 4295548928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295553024 ++wrote 4096/4096 bytes at offset 4295553024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295557120 ++wrote 4096/4096 bytes at offset 4295557120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295561216 ++wrote 4096/4096 bytes at offset 4295561216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295565312 ++wrote 4096/4096 bytes at offset 4295565312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295569408 ++wrote 4096/4096 bytes at offset 4295569408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295573504 ++wrote 4096/4096 bytes at offset 4295573504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295577600 ++wrote 4096/4096 bytes at offset 4295577600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295581696 ++wrote 4096/4096 bytes at offset 4295581696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295585792 ++wrote 4096/4096 bytes at offset 4295585792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295589888 ++wrote 4096/4096 bytes at offset 4295589888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295593984 ++wrote 4096/4096 bytes at offset 4295593984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295598080 ++wrote 4096/4096 bytes at offset 4295598080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295602176 ++wrote 4096/4096 bytes at offset 4295602176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295606272 ++wrote 4096/4096 bytes at offset 4295606272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295610368 ++wrote 4096/4096 bytes at offset 4295610368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295614464 ++wrote 4096/4096 bytes at offset 4295614464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295618560 ++wrote 4096/4096 bytes at offset 4295618560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295622656 ++wrote 4096/4096 bytes at offset 4295622656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295626752 ++wrote 4096/4096 bytes at offset 4295626752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295630848 ++wrote 4096/4096 bytes at offset 4295630848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295634944 ++wrote 4096/4096 bytes at offset 4295634944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295639040 ++wrote 4096/4096 bytes at offset 4295639040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295643136 ++wrote 4096/4096 bytes at offset 4295643136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295647232 ++wrote 4096/4096 bytes at offset 4295647232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295651328 ++wrote 4096/4096 bytes at offset 4295651328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295655424 ++wrote 4096/4096 bytes at offset 4295655424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295659520 ++wrote 4096/4096 bytes at offset 4295659520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295663616 ++wrote 4096/4096 bytes at offset 4295663616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295667712 ++wrote 4096/4096 bytes at offset 4295667712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295671808 ++wrote 4096/4096 bytes at offset 4295671808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295675904 ++wrote 4096/4096 bytes at offset 4295675904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295680000 ++wrote 4096/4096 bytes at offset 4295680000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295684096 ++wrote 4096/4096 bytes at offset 4295684096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295688192 ++wrote 4096/4096 bytes at offset 4295688192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295692288 ++wrote 4096/4096 bytes at offset 4295692288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295696384 ++wrote 4096/4096 bytes at offset 4295696384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295700480 ++wrote 4096/4096 bytes at offset 4295700480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295704576 ++wrote 4096/4096 bytes at offset 4295704576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295708672 ++wrote 4096/4096 bytes at offset 4295708672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295712768 ++wrote 4096/4096 bytes at offset 4295712768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295716864 ++wrote 4096/4096 bytes at offset 4295716864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295720960 ++wrote 4096/4096 bytes at offset 4295720960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295725056 ++wrote 4096/4096 bytes at offset 4295725056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295729152 ++wrote 4096/4096 bytes at offset 4295729152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295733248 ++wrote 4096/4096 bytes at offset 4295733248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295737344 ++wrote 4096/4096 bytes at offset 4295737344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295741440 ++wrote 4096/4096 bytes at offset 4295741440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295745536 ++wrote 4096/4096 bytes at offset 4295745536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295749632 ++wrote 4096/4096 bytes at offset 4295749632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295753728 ++wrote 4096/4096 bytes at offset 4295753728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295757824 ++wrote 4096/4096 bytes at offset 4295757824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295761920 ++wrote 4096/4096 bytes at offset 4295761920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295766016 ++wrote 4096/4096 bytes at offset 4295766016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295770112 ++wrote 4096/4096 bytes at offset 4295770112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295774208 ++wrote 4096/4096 bytes at offset 4295774208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295778304 ++wrote 4096/4096 bytes at offset 4295778304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295782400 ++wrote 4096/4096 bytes at offset 4295782400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295786496 ++wrote 4096/4096 bytes at offset 4295786496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295790592 ++wrote 4096/4096 bytes at offset 4295790592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295794688 ++wrote 4096/4096 bytes at offset 4295794688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295798784 ++wrote 4096/4096 bytes at offset 4295798784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295802880 ++wrote 4096/4096 bytes at offset 4295802880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295806976 ++wrote 4096/4096 bytes at offset 4295806976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295811072 ++wrote 4096/4096 bytes at offset 4295811072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295815168 ++wrote 4096/4096 bytes at offset 4295815168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295819264 ++wrote 4096/4096 bytes at offset 4295819264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295823360 ++wrote 4096/4096 bytes at offset 4295823360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295827456 ++wrote 4096/4096 bytes at offset 4295827456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295831552 ++wrote 4096/4096 bytes at offset 4295831552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295835648 ++wrote 4096/4096 bytes at offset 4295835648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295839744 ++wrote 4096/4096 bytes at offset 4295839744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295843840 ++wrote 4096/4096 bytes at offset 4295843840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295847936 ++wrote 4096/4096 bytes at offset 4295847936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295852032 ++wrote 4096/4096 bytes at offset 4295852032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295856128 ++wrote 4096/4096 bytes at offset 4295856128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295860224 ++wrote 4096/4096 bytes at offset 4295860224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295864320 ++wrote 4096/4096 bytes at offset 4295864320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295868416 ++wrote 4096/4096 bytes at offset 4295868416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295872512 ++wrote 4096/4096 bytes at offset 4295872512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295876608 ++wrote 4096/4096 bytes at offset 4295876608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295880704 ++wrote 4096/4096 bytes at offset 4295880704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295884800 ++wrote 4096/4096 bytes at offset 4295884800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295888896 ++wrote 4096/4096 bytes at offset 4295888896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295892992 ++wrote 4096/4096 bytes at offset 4295892992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295897088 ++wrote 4096/4096 bytes at offset 4295897088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295901184 ++wrote 4096/4096 bytes at offset 4295901184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295905280 ++wrote 4096/4096 bytes at offset 4295905280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295909376 ++wrote 4096/4096 bytes at offset 4295909376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295913472 ++wrote 4096/4096 bytes at offset 4295913472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295917568 ++wrote 4096/4096 bytes at offset 4295917568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295921664 ++wrote 4096/4096 bytes at offset 4295921664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295925760 ++wrote 4096/4096 bytes at offset 4295925760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295929856 ++wrote 4096/4096 bytes at offset 4295929856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295933952 ++wrote 4096/4096 bytes at offset 4295933952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295938048 ++wrote 4096/4096 bytes at offset 4295938048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295942144 ++wrote 4096/4096 bytes at offset 4295942144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295946240 ++wrote 4096/4096 bytes at offset 4295946240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295950336 ++wrote 4096/4096 bytes at offset 4295950336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295954432 ++wrote 4096/4096 bytes at offset 4295954432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295958528 ++wrote 4096/4096 bytes at offset 4295958528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295962624 ++wrote 4096/4096 bytes at offset 4295962624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295966720 ++wrote 4096/4096 bytes at offset 4295966720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295970816 ++wrote 4096/4096 bytes at offset 4295970816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295974912 ++wrote 4096/4096 bytes at offset 4295974912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295979008 ++wrote 4096/4096 bytes at offset 4295979008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295983104 ++wrote 4096/4096 bytes at offset 4295983104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295987200 ++wrote 4096/4096 bytes at offset 4295987200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295991296 ++wrote 4096/4096 bytes at offset 4295991296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295995392 ++wrote 4096/4096 bytes at offset 4295995392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295999488 ++wrote 4096/4096 bytes at offset 4295999488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296003584 ++wrote 4096/4096 bytes at offset 4296003584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296007680 ++wrote 4096/4096 bytes at offset 4296007680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296011776 ++wrote 4096/4096 bytes at offset 4296011776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 4 +-qemu-io> wrote 2048/2048 bytes at offset 4296017920 ++=== IO: pattern 4 ++wrote 2048/2048 bytes at offset 4296017920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296022016 ++wrote 2048/2048 bytes at offset 4296022016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296026112 ++wrote 2048/2048 bytes at offset 4296026112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296030208 ++wrote 2048/2048 bytes at offset 4296030208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296034304 ++wrote 2048/2048 bytes at offset 4296034304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296038400 ++wrote 2048/2048 bytes at offset 4296038400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296042496 ++wrote 2048/2048 bytes at offset 4296042496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296046592 ++wrote 2048/2048 bytes at offset 4296046592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296050688 ++wrote 2048/2048 bytes at offset 4296050688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296054784 ++wrote 2048/2048 bytes at offset 4296054784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296058880 ++wrote 2048/2048 bytes at offset 4296058880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296062976 ++wrote 2048/2048 bytes at offset 4296062976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296067072 ++wrote 2048/2048 bytes at offset 4296067072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296071168 ++wrote 2048/2048 bytes at offset 4296071168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296075264 ++wrote 2048/2048 bytes at offset 4296075264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296079360 ++wrote 2048/2048 bytes at offset 4296079360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296083456 ++wrote 2048/2048 bytes at offset 4296083456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296087552 ++wrote 2048/2048 bytes at offset 4296087552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296091648 ++wrote 2048/2048 bytes at offset 4296091648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296095744 ++wrote 2048/2048 bytes at offset 4296095744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296099840 ++wrote 2048/2048 bytes at offset 4296099840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296103936 ++wrote 2048/2048 bytes at offset 4296103936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296108032 ++wrote 2048/2048 bytes at offset 4296108032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296112128 ++wrote 2048/2048 bytes at offset 4296112128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296116224 ++wrote 2048/2048 bytes at offset 4296116224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296120320 ++wrote 2048/2048 bytes at offset 4296120320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296124416 ++wrote 2048/2048 bytes at offset 4296124416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296128512 ++wrote 2048/2048 bytes at offset 4296128512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296132608 ++wrote 2048/2048 bytes at offset 4296132608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296136704 ++wrote 2048/2048 bytes at offset 4296136704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296140800 ++wrote 2048/2048 bytes at offset 4296140800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296144896 ++wrote 2048/2048 bytes at offset 4296144896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296148992 ++wrote 2048/2048 bytes at offset 4296148992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296153088 ++wrote 2048/2048 bytes at offset 4296153088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296157184 ++wrote 2048/2048 bytes at offset 4296157184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296161280 ++wrote 2048/2048 bytes at offset 4296161280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296165376 ++wrote 2048/2048 bytes at offset 4296165376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296169472 ++wrote 2048/2048 bytes at offset 4296169472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296173568 ++wrote 2048/2048 bytes at offset 4296173568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296177664 ++wrote 2048/2048 bytes at offset 4296177664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296181760 ++wrote 2048/2048 bytes at offset 4296181760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296185856 ++wrote 2048/2048 bytes at offset 4296185856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296189952 ++wrote 2048/2048 bytes at offset 4296189952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296194048 ++wrote 2048/2048 bytes at offset 4296194048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296198144 ++wrote 2048/2048 bytes at offset 4296198144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296202240 ++wrote 2048/2048 bytes at offset 4296202240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296206336 ++wrote 2048/2048 bytes at offset 4296206336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296210432 ++wrote 2048/2048 bytes at offset 4296210432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296214528 ++wrote 2048/2048 bytes at offset 4296214528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296218624 ++wrote 2048/2048 bytes at offset 4296218624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296222720 ++wrote 2048/2048 bytes at offset 4296222720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296226816 ++wrote 2048/2048 bytes at offset 4296226816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296230912 ++wrote 2048/2048 bytes at offset 4296230912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296235008 ++wrote 2048/2048 bytes at offset 4296235008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296239104 ++wrote 2048/2048 bytes at offset 4296239104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296243200 ++wrote 2048/2048 bytes at offset 4296243200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296247296 ++wrote 2048/2048 bytes at offset 4296247296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296251392 ++wrote 2048/2048 bytes at offset 4296251392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296255488 ++wrote 2048/2048 bytes at offset 4296255488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296259584 ++wrote 2048/2048 bytes at offset 4296259584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296263680 ++wrote 2048/2048 bytes at offset 4296263680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296267776 ++wrote 2048/2048 bytes at offset 4296267776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296271872 ++wrote 2048/2048 bytes at offset 4296271872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296275968 ++wrote 2048/2048 bytes at offset 4296275968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296280064 ++wrote 2048/2048 bytes at offset 4296280064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296284160 ++wrote 2048/2048 bytes at offset 4296284160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296288256 ++wrote 2048/2048 bytes at offset 4296288256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296292352 ++wrote 2048/2048 bytes at offset 4296292352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296296448 ++wrote 2048/2048 bytes at offset 4296296448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296300544 ++wrote 2048/2048 bytes at offset 4296300544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296304640 ++wrote 2048/2048 bytes at offset 4296304640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296308736 ++wrote 2048/2048 bytes at offset 4296308736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296312832 ++wrote 2048/2048 bytes at offset 4296312832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296316928 ++wrote 2048/2048 bytes at offset 4296316928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296321024 ++wrote 2048/2048 bytes at offset 4296321024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296325120 ++wrote 2048/2048 bytes at offset 4296325120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296329216 ++wrote 2048/2048 bytes at offset 4296329216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296333312 ++wrote 2048/2048 bytes at offset 4296333312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296337408 ++wrote 2048/2048 bytes at offset 4296337408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296341504 ++wrote 2048/2048 bytes at offset 4296341504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296345600 ++wrote 2048/2048 bytes at offset 4296345600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296349696 ++wrote 2048/2048 bytes at offset 4296349696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296353792 ++wrote 2048/2048 bytes at offset 4296353792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296357888 ++wrote 2048/2048 bytes at offset 4296357888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296361984 ++wrote 2048/2048 bytes at offset 4296361984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296366080 ++wrote 2048/2048 bytes at offset 4296366080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296370176 ++wrote 2048/2048 bytes at offset 4296370176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296374272 ++wrote 2048/2048 bytes at offset 4296374272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296378368 ++wrote 2048/2048 bytes at offset 4296378368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296382464 ++wrote 2048/2048 bytes at offset 4296382464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296386560 ++wrote 2048/2048 bytes at offset 4296386560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296390656 ++wrote 2048/2048 bytes at offset 4296390656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296394752 ++wrote 2048/2048 bytes at offset 4296394752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296398848 ++wrote 2048/2048 bytes at offset 4296398848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296402944 ++wrote 2048/2048 bytes at offset 4296402944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296407040 ++wrote 2048/2048 bytes at offset 4296407040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296411136 ++wrote 2048/2048 bytes at offset 4296411136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296415232 ++wrote 2048/2048 bytes at offset 4296415232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296419328 ++wrote 2048/2048 bytes at offset 4296419328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296423424 ++wrote 2048/2048 bytes at offset 4296423424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296427520 ++wrote 2048/2048 bytes at offset 4296427520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296431616 ++wrote 2048/2048 bytes at offset 4296431616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296435712 ++wrote 2048/2048 bytes at offset 4296435712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296439808 ++wrote 2048/2048 bytes at offset 4296439808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296443904 ++wrote 2048/2048 bytes at offset 4296443904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296448000 ++wrote 2048/2048 bytes at offset 4296448000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296452096 ++wrote 2048/2048 bytes at offset 4296452096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296456192 ++wrote 2048/2048 bytes at offset 4296456192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296460288 ++wrote 2048/2048 bytes at offset 4296460288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296464384 ++wrote 2048/2048 bytes at offset 4296464384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296468480 ++wrote 2048/2048 bytes at offset 4296468480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296472576 ++wrote 2048/2048 bytes at offset 4296472576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296476672 ++wrote 2048/2048 bytes at offset 4296476672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296480768 ++wrote 2048/2048 bytes at offset 4296480768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296484864 ++wrote 2048/2048 bytes at offset 4296484864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296488960 ++wrote 2048/2048 bytes at offset 4296488960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296493056 ++wrote 2048/2048 bytes at offset 4296493056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296497152 ++wrote 2048/2048 bytes at offset 4296497152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296501248 ++wrote 2048/2048 bytes at offset 4296501248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296505344 ++wrote 2048/2048 bytes at offset 4296505344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296509440 ++wrote 2048/2048 bytes at offset 4296509440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296513536 ++wrote 2048/2048 bytes at offset 4296513536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296517632 ++wrote 2048/2048 bytes at offset 4296517632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296521728 ++wrote 2048/2048 bytes at offset 4296521728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296525824 ++wrote 2048/2048 bytes at offset 4296525824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296529920 ++wrote 2048/2048 bytes at offset 4296529920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296534016 ++wrote 2048/2048 bytes at offset 4296534016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296538112 ++wrote 2048/2048 bytes at offset 4296538112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296542208 ++wrote 2048/2048 bytes at offset 4296542208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296546304 ++wrote 2048/2048 bytes at offset 4296546304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296550400 ++wrote 2048/2048 bytes at offset 4296550400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296554496 ++wrote 2048/2048 bytes at offset 4296554496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296558592 ++wrote 2048/2048 bytes at offset 4296558592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296562688 ++wrote 2048/2048 bytes at offset 4296562688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296566784 ++wrote 2048/2048 bytes at offset 4296566784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296570880 ++wrote 2048/2048 bytes at offset 4296570880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296574976 ++wrote 2048/2048 bytes at offset 4296574976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296579072 ++wrote 2048/2048 bytes at offset 4296579072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296583168 ++wrote 2048/2048 bytes at offset 4296583168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296587264 ++wrote 2048/2048 bytes at offset 4296587264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296591360 ++wrote 2048/2048 bytes at offset 4296591360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296595456 ++wrote 2048/2048 bytes at offset 4296595456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296599552 ++wrote 2048/2048 bytes at offset 4296599552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296603648 ++wrote 2048/2048 bytes at offset 4296603648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296607744 ++wrote 2048/2048 bytes at offset 4296607744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296611840 ++wrote 2048/2048 bytes at offset 4296611840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296615936 ++wrote 2048/2048 bytes at offset 4296615936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296620032 ++wrote 2048/2048 bytes at offset 4296620032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296624128 ++wrote 2048/2048 bytes at offset 4296624128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296628224 ++wrote 2048/2048 bytes at offset 4296628224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296632320 ++wrote 2048/2048 bytes at offset 4296632320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296636416 ++wrote 2048/2048 bytes at offset 4296636416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296640512 ++wrote 2048/2048 bytes at offset 4296640512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296644608 ++wrote 2048/2048 bytes at offset 4296644608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296648704 ++wrote 2048/2048 bytes at offset 4296648704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296652800 ++wrote 2048/2048 bytes at offset 4296652800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296656896 ++wrote 2048/2048 bytes at offset 4296656896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296660992 ++wrote 2048/2048 bytes at offset 4296660992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296665088 ++wrote 2048/2048 bytes at offset 4296665088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296669184 ++wrote 2048/2048 bytes at offset 4296669184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296673280 ++wrote 2048/2048 bytes at offset 4296673280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296677376 ++wrote 2048/2048 bytes at offset 4296677376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296681472 ++wrote 2048/2048 bytes at offset 4296681472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296685568 ++wrote 2048/2048 bytes at offset 4296685568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296689664 ++wrote 2048/2048 bytes at offset 4296689664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296693760 ++wrote 2048/2048 bytes at offset 4296693760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296697856 ++wrote 2048/2048 bytes at offset 4296697856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296701952 ++wrote 2048/2048 bytes at offset 4296701952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296706048 ++wrote 2048/2048 bytes at offset 4296706048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296710144 ++wrote 2048/2048 bytes at offset 4296710144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296714240 ++wrote 2048/2048 bytes at offset 4296714240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296718336 ++wrote 2048/2048 bytes at offset 4296718336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296722432 ++wrote 2048/2048 bytes at offset 4296722432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296726528 ++wrote 2048/2048 bytes at offset 4296726528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296730624 ++wrote 2048/2048 bytes at offset 4296730624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296734720 ++wrote 2048/2048 bytes at offset 4296734720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296738816 ++wrote 2048/2048 bytes at offset 4296738816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296742912 ++wrote 2048/2048 bytes at offset 4296742912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296747008 ++wrote 2048/2048 bytes at offset 4296747008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296751104 ++wrote 2048/2048 bytes at offset 4296751104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296755200 ++wrote 2048/2048 bytes at offset 4296755200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296759296 ++wrote 2048/2048 bytes at offset 4296759296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296763392 ++wrote 2048/2048 bytes at offset 4296763392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296767488 ++wrote 2048/2048 bytes at offset 4296767488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296771584 ++wrote 2048/2048 bytes at offset 4296771584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296775680 ++wrote 2048/2048 bytes at offset 4296775680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296779776 ++wrote 2048/2048 bytes at offset 4296779776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296783872 ++wrote 2048/2048 bytes at offset 4296783872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296787968 ++wrote 2048/2048 bytes at offset 4296787968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296792064 ++wrote 2048/2048 bytes at offset 4296792064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296796160 ++wrote 2048/2048 bytes at offset 4296796160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296800256 ++wrote 2048/2048 bytes at offset 4296800256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296804352 ++wrote 2048/2048 bytes at offset 4296804352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296808448 ++wrote 2048/2048 bytes at offset 4296808448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296812544 ++wrote 2048/2048 bytes at offset 4296812544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296816640 ++wrote 2048/2048 bytes at offset 4296816640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296820736 ++wrote 2048/2048 bytes at offset 4296820736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296824832 ++wrote 2048/2048 bytes at offset 4296824832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296828928 ++wrote 2048/2048 bytes at offset 4296828928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296833024 ++wrote 2048/2048 bytes at offset 4296833024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296837120 ++wrote 2048/2048 bytes at offset 4296837120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296841216 ++wrote 2048/2048 bytes at offset 4296841216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296845312 ++wrote 2048/2048 bytes at offset 4296845312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296849408 ++wrote 2048/2048 bytes at offset 4296849408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296853504 ++wrote 2048/2048 bytes at offset 4296853504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296857600 ++wrote 2048/2048 bytes at offset 4296857600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296861696 ++wrote 2048/2048 bytes at offset 4296861696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296865792 ++wrote 2048/2048 bytes at offset 4296865792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296869888 ++wrote 2048/2048 bytes at offset 4296869888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296873984 ++wrote 2048/2048 bytes at offset 4296873984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296878080 ++wrote 2048/2048 bytes at offset 4296878080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296882176 ++wrote 2048/2048 bytes at offset 4296882176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296886272 ++wrote 2048/2048 bytes at offset 4296886272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296890368 ++wrote 2048/2048 bytes at offset 4296890368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296894464 ++wrote 2048/2048 bytes at offset 4296894464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296898560 ++wrote 2048/2048 bytes at offset 4296898560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296902656 ++wrote 2048/2048 bytes at offset 4296902656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296906752 ++wrote 2048/2048 bytes at offset 4296906752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296910848 ++wrote 2048/2048 bytes at offset 4296910848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296914944 ++wrote 2048/2048 bytes at offset 4296914944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296919040 ++wrote 2048/2048 bytes at offset 4296919040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296923136 ++wrote 2048/2048 bytes at offset 4296923136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296927232 ++wrote 2048/2048 bytes at offset 4296927232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296931328 ++wrote 2048/2048 bytes at offset 4296931328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296935424 ++wrote 2048/2048 bytes at offset 4296935424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296939520 ++wrote 2048/2048 bytes at offset 4296939520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296943616 ++wrote 2048/2048 bytes at offset 4296943616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296947712 ++wrote 2048/2048 bytes at offset 4296947712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296951808 ++wrote 2048/2048 bytes at offset 4296951808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296955904 ++wrote 2048/2048 bytes at offset 4296955904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296960000 ++wrote 2048/2048 bytes at offset 4296960000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296964096 ++wrote 2048/2048 bytes at offset 4296964096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296968192 ++wrote 2048/2048 bytes at offset 4296968192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296972288 ++wrote 2048/2048 bytes at offset 4296972288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296976384 ++wrote 2048/2048 bytes at offset 4296976384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296980480 ++wrote 2048/2048 bytes at offset 4296980480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296984576 ++wrote 2048/2048 bytes at offset 4296984576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296988672 ++wrote 2048/2048 bytes at offset 4296988672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296992768 ++wrote 2048/2048 bytes at offset 4296992768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296996864 ++wrote 2048/2048 bytes at offset 4296996864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297000960 ++wrote 2048/2048 bytes at offset 4297000960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297005056 ++wrote 2048/2048 bytes at offset 4297005056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297009152 ++wrote 2048/2048 bytes at offset 4297009152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297013248 ++wrote 2048/2048 bytes at offset 4297013248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297017344 ++wrote 2048/2048 bytes at offset 4297017344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297021440 ++wrote 2048/2048 bytes at offset 4297021440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297025536 ++wrote 2048/2048 bytes at offset 4297025536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297029632 ++wrote 2048/2048 bytes at offset 4297029632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297033728 ++wrote 2048/2048 bytes at offset 4297033728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297037824 ++wrote 2048/2048 bytes at offset 4297037824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297041920 ++wrote 2048/2048 bytes at offset 4297041920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297046016 ++wrote 2048/2048 bytes at offset 4297046016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297050112 ++wrote 2048/2048 bytes at offset 4297050112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297054208 ++wrote 2048/2048 bytes at offset 4297054208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297058304 ++wrote 2048/2048 bytes at offset 4297058304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297062400 ++wrote 2048/2048 bytes at offset 4297062400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> wrote 2048/2048 bytes at offset 4297064448 ++=== IO: pattern 0 ++wrote 2048/2048 bytes at offset 4297064448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297068544 ++wrote 2048/2048 bytes at offset 4297068544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297072640 ++wrote 2048/2048 bytes at offset 4297072640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297076736 ++wrote 2048/2048 bytes at offset 4297076736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297080832 ++wrote 2048/2048 bytes at offset 4297080832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297084928 ++wrote 2048/2048 bytes at offset 4297084928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297089024 ++wrote 2048/2048 bytes at offset 4297089024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297093120 ++wrote 2048/2048 bytes at offset 4297093120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297097216 ++wrote 2048/2048 bytes at offset 4297097216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297101312 ++wrote 2048/2048 bytes at offset 4297101312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297105408 ++wrote 2048/2048 bytes at offset 4297105408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297109504 ++wrote 2048/2048 bytes at offset 4297109504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297113600 ++wrote 2048/2048 bytes at offset 4297113600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297117696 ++wrote 2048/2048 bytes at offset 4297117696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297121792 ++wrote 2048/2048 bytes at offset 4297121792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297125888 ++wrote 2048/2048 bytes at offset 4297125888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297129984 ++wrote 2048/2048 bytes at offset 4297129984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297134080 ++wrote 2048/2048 bytes at offset 4297134080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297138176 ++wrote 2048/2048 bytes at offset 4297138176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297142272 ++wrote 2048/2048 bytes at offset 4297142272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297146368 ++wrote 2048/2048 bytes at offset 4297146368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297150464 ++wrote 2048/2048 bytes at offset 4297150464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297154560 ++wrote 2048/2048 bytes at offset 4297154560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297158656 ++wrote 2048/2048 bytes at offset 4297158656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297162752 ++wrote 2048/2048 bytes at offset 4297162752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297166848 ++wrote 2048/2048 bytes at offset 4297166848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297170944 ++wrote 2048/2048 bytes at offset 4297170944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297175040 ++wrote 2048/2048 bytes at offset 4297175040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297179136 ++wrote 2048/2048 bytes at offset 4297179136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297183232 ++wrote 2048/2048 bytes at offset 4297183232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297187328 ++wrote 2048/2048 bytes at offset 4297187328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297191424 ++wrote 2048/2048 bytes at offset 4297191424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297195520 ++wrote 2048/2048 bytes at offset 4297195520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297199616 ++wrote 2048/2048 bytes at offset 4297199616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297203712 ++wrote 2048/2048 bytes at offset 4297203712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297207808 ++wrote 2048/2048 bytes at offset 4297207808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297211904 ++wrote 2048/2048 bytes at offset 4297211904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297216000 ++wrote 2048/2048 bytes at offset 4297216000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297220096 ++wrote 2048/2048 bytes at offset 4297220096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297224192 ++wrote 2048/2048 bytes at offset 4297224192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297228288 ++wrote 2048/2048 bytes at offset 4297228288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297232384 ++wrote 2048/2048 bytes at offset 4297232384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297236480 ++wrote 2048/2048 bytes at offset 4297236480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297240576 ++wrote 2048/2048 bytes at offset 4297240576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297244672 ++wrote 2048/2048 bytes at offset 4297244672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297248768 ++wrote 2048/2048 bytes at offset 4297248768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297252864 ++wrote 2048/2048 bytes at offset 4297252864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297256960 ++wrote 2048/2048 bytes at offset 4297256960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297261056 ++wrote 2048/2048 bytes at offset 4297261056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297265152 ++wrote 2048/2048 bytes at offset 4297265152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297269248 ++wrote 2048/2048 bytes at offset 4297269248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297273344 ++wrote 2048/2048 bytes at offset 4297273344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297277440 ++wrote 2048/2048 bytes at offset 4297277440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297281536 ++wrote 2048/2048 bytes at offset 4297281536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297285632 ++wrote 2048/2048 bytes at offset 4297285632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297289728 ++wrote 2048/2048 bytes at offset 4297289728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297293824 ++wrote 2048/2048 bytes at offset 4297293824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297297920 ++wrote 2048/2048 bytes at offset 4297297920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297302016 ++wrote 2048/2048 bytes at offset 4297302016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297306112 ++wrote 2048/2048 bytes at offset 4297306112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297310208 ++wrote 2048/2048 bytes at offset 4297310208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297314304 ++wrote 2048/2048 bytes at offset 4297314304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297318400 ++wrote 2048/2048 bytes at offset 4297318400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297322496 ++wrote 2048/2048 bytes at offset 4297322496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297326592 ++wrote 2048/2048 bytes at offset 4297326592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297330688 ++wrote 2048/2048 bytes at offset 4297330688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297334784 ++wrote 2048/2048 bytes at offset 4297334784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297338880 ++wrote 2048/2048 bytes at offset 4297338880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297342976 ++wrote 2048/2048 bytes at offset 4297342976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297347072 ++wrote 2048/2048 bytes at offset 4297347072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297351168 ++wrote 2048/2048 bytes at offset 4297351168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297355264 ++wrote 2048/2048 bytes at offset 4297355264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297359360 ++wrote 2048/2048 bytes at offset 4297359360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297363456 ++wrote 2048/2048 bytes at offset 4297363456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297367552 ++wrote 2048/2048 bytes at offset 4297367552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297371648 ++wrote 2048/2048 bytes at offset 4297371648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297375744 ++wrote 2048/2048 bytes at offset 4297375744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297379840 ++wrote 2048/2048 bytes at offset 4297379840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297383936 ++wrote 2048/2048 bytes at offset 4297383936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297388032 ++wrote 2048/2048 bytes at offset 4297388032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297392128 ++wrote 2048/2048 bytes at offset 4297392128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297396224 ++wrote 2048/2048 bytes at offset 4297396224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297400320 ++wrote 2048/2048 bytes at offset 4297400320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297404416 ++wrote 2048/2048 bytes at offset 4297404416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297408512 ++wrote 2048/2048 bytes at offset 4297408512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297412608 ++wrote 2048/2048 bytes at offset 4297412608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297416704 ++wrote 2048/2048 bytes at offset 4297416704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297420800 ++wrote 2048/2048 bytes at offset 4297420800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297424896 ++wrote 2048/2048 bytes at offset 4297424896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297428992 ++wrote 2048/2048 bytes at offset 4297428992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297433088 ++wrote 2048/2048 bytes at offset 4297433088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297437184 ++wrote 2048/2048 bytes at offset 4297437184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297441280 ++wrote 2048/2048 bytes at offset 4297441280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297445376 ++wrote 2048/2048 bytes at offset 4297445376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297449472 ++wrote 2048/2048 bytes at offset 4297449472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297453568 ++wrote 2048/2048 bytes at offset 4297453568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297457664 ++wrote 2048/2048 bytes at offset 4297457664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297461760 ++wrote 2048/2048 bytes at offset 4297461760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297465856 ++wrote 2048/2048 bytes at offset 4297465856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297469952 ++wrote 2048/2048 bytes at offset 4297469952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297474048 ++wrote 2048/2048 bytes at offset 4297474048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297478144 ++wrote 2048/2048 bytes at offset 4297478144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297482240 ++wrote 2048/2048 bytes at offset 4297482240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297486336 ++wrote 2048/2048 bytes at offset 4297486336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297490432 ++wrote 2048/2048 bytes at offset 4297490432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297494528 ++wrote 2048/2048 bytes at offset 4297494528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297498624 ++wrote 2048/2048 bytes at offset 4297498624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297502720 ++wrote 2048/2048 bytes at offset 4297502720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297506816 ++wrote 2048/2048 bytes at offset 4297506816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297510912 ++wrote 2048/2048 bytes at offset 4297510912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297515008 ++wrote 2048/2048 bytes at offset 4297515008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297519104 ++wrote 2048/2048 bytes at offset 4297519104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297523200 ++wrote 2048/2048 bytes at offset 4297523200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297527296 ++wrote 2048/2048 bytes at offset 4297527296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297531392 ++wrote 2048/2048 bytes at offset 4297531392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297535488 ++wrote 2048/2048 bytes at offset 4297535488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297539584 ++wrote 2048/2048 bytes at offset 4297539584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297543680 ++wrote 2048/2048 bytes at offset 4297543680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297547776 ++wrote 2048/2048 bytes at offset 4297547776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297551872 ++wrote 2048/2048 bytes at offset 4297551872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297555968 ++wrote 2048/2048 bytes at offset 4297555968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297560064 ++wrote 2048/2048 bytes at offset 4297560064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297564160 ++wrote 2048/2048 bytes at offset 4297564160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297568256 ++wrote 2048/2048 bytes at offset 4297568256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297572352 ++wrote 2048/2048 bytes at offset 4297572352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297576448 ++wrote 2048/2048 bytes at offset 4297576448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297580544 ++wrote 2048/2048 bytes at offset 4297580544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297584640 ++wrote 2048/2048 bytes at offset 4297584640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297588736 ++wrote 2048/2048 bytes at offset 4297588736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297592832 ++wrote 2048/2048 bytes at offset 4297592832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297596928 ++wrote 2048/2048 bytes at offset 4297596928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297601024 ++wrote 2048/2048 bytes at offset 4297601024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297605120 ++wrote 2048/2048 bytes at offset 4297605120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297609216 ++wrote 2048/2048 bytes at offset 4297609216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297613312 ++wrote 2048/2048 bytes at offset 4297613312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297617408 ++wrote 2048/2048 bytes at offset 4297617408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297621504 ++wrote 2048/2048 bytes at offset 4297621504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297625600 ++wrote 2048/2048 bytes at offset 4297625600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297629696 ++wrote 2048/2048 bytes at offset 4297629696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297633792 ++wrote 2048/2048 bytes at offset 4297633792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297637888 ++wrote 2048/2048 bytes at offset 4297637888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297641984 ++wrote 2048/2048 bytes at offset 4297641984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297646080 ++wrote 2048/2048 bytes at offset 4297646080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297650176 ++wrote 2048/2048 bytes at offset 4297650176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297654272 ++wrote 2048/2048 bytes at offset 4297654272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297658368 ++wrote 2048/2048 bytes at offset 4297658368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297662464 ++wrote 2048/2048 bytes at offset 4297662464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297666560 ++wrote 2048/2048 bytes at offset 4297666560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297670656 ++wrote 2048/2048 bytes at offset 4297670656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297674752 ++wrote 2048/2048 bytes at offset 4297674752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297678848 ++wrote 2048/2048 bytes at offset 4297678848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297682944 ++wrote 2048/2048 bytes at offset 4297682944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297687040 ++wrote 2048/2048 bytes at offset 4297687040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297691136 ++wrote 2048/2048 bytes at offset 4297691136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297695232 ++wrote 2048/2048 bytes at offset 4297695232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297699328 ++wrote 2048/2048 bytes at offset 4297699328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297703424 ++wrote 2048/2048 bytes at offset 4297703424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297707520 ++wrote 2048/2048 bytes at offset 4297707520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297711616 ++wrote 2048/2048 bytes at offset 4297711616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297715712 ++wrote 2048/2048 bytes at offset 4297715712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297719808 ++wrote 2048/2048 bytes at offset 4297719808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297723904 ++wrote 2048/2048 bytes at offset 4297723904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297728000 ++wrote 2048/2048 bytes at offset 4297728000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297732096 ++wrote 2048/2048 bytes at offset 4297732096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297736192 ++wrote 2048/2048 bytes at offset 4297736192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297740288 ++wrote 2048/2048 bytes at offset 4297740288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297744384 ++wrote 2048/2048 bytes at offset 4297744384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297748480 ++wrote 2048/2048 bytes at offset 4297748480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297752576 ++wrote 2048/2048 bytes at offset 4297752576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297756672 ++wrote 2048/2048 bytes at offset 4297756672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297760768 ++wrote 2048/2048 bytes at offset 4297760768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297764864 ++wrote 2048/2048 bytes at offset 4297764864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297768960 ++wrote 2048/2048 bytes at offset 4297768960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297773056 ++wrote 2048/2048 bytes at offset 4297773056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297777152 ++wrote 2048/2048 bytes at offset 4297777152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297781248 ++wrote 2048/2048 bytes at offset 4297781248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297785344 ++wrote 2048/2048 bytes at offset 4297785344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297789440 ++wrote 2048/2048 bytes at offset 4297789440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297793536 ++wrote 2048/2048 bytes at offset 4297793536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297797632 ++wrote 2048/2048 bytes at offset 4297797632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297801728 ++wrote 2048/2048 bytes at offset 4297801728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297805824 ++wrote 2048/2048 bytes at offset 4297805824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297809920 ++wrote 2048/2048 bytes at offset 4297809920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297814016 ++wrote 2048/2048 bytes at offset 4297814016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297818112 ++wrote 2048/2048 bytes at offset 4297818112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297822208 ++wrote 2048/2048 bytes at offset 4297822208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297826304 ++wrote 2048/2048 bytes at offset 4297826304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297830400 ++wrote 2048/2048 bytes at offset 4297830400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297834496 ++wrote 2048/2048 bytes at offset 4297834496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297838592 ++wrote 2048/2048 bytes at offset 4297838592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297842688 ++wrote 2048/2048 bytes at offset 4297842688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297846784 ++wrote 2048/2048 bytes at offset 4297846784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297850880 ++wrote 2048/2048 bytes at offset 4297850880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297854976 ++wrote 2048/2048 bytes at offset 4297854976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297859072 ++wrote 2048/2048 bytes at offset 4297859072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297863168 ++wrote 2048/2048 bytes at offset 4297863168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297867264 ++wrote 2048/2048 bytes at offset 4297867264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297871360 ++wrote 2048/2048 bytes at offset 4297871360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297875456 ++wrote 2048/2048 bytes at offset 4297875456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297879552 ++wrote 2048/2048 bytes at offset 4297879552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297883648 ++wrote 2048/2048 bytes at offset 4297883648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297887744 ++wrote 2048/2048 bytes at offset 4297887744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297891840 ++wrote 2048/2048 bytes at offset 4297891840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297895936 ++wrote 2048/2048 bytes at offset 4297895936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297900032 ++wrote 2048/2048 bytes at offset 4297900032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297904128 ++wrote 2048/2048 bytes at offset 4297904128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297908224 ++wrote 2048/2048 bytes at offset 4297908224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297912320 ++wrote 2048/2048 bytes at offset 4297912320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297916416 ++wrote 2048/2048 bytes at offset 4297916416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297920512 ++wrote 2048/2048 bytes at offset 4297920512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297924608 ++wrote 2048/2048 bytes at offset 4297924608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297928704 ++wrote 2048/2048 bytes at offset 4297928704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297932800 ++wrote 2048/2048 bytes at offset 4297932800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297936896 ++wrote 2048/2048 bytes at offset 4297936896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297940992 ++wrote 2048/2048 bytes at offset 4297940992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297945088 ++wrote 2048/2048 bytes at offset 4297945088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297949184 ++wrote 2048/2048 bytes at offset 4297949184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297953280 ++wrote 2048/2048 bytes at offset 4297953280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297957376 ++wrote 2048/2048 bytes at offset 4297957376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297961472 ++wrote 2048/2048 bytes at offset 4297961472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297965568 ++wrote 2048/2048 bytes at offset 4297965568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297969664 ++wrote 2048/2048 bytes at offset 4297969664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297973760 ++wrote 2048/2048 bytes at offset 4297973760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297977856 ++wrote 2048/2048 bytes at offset 4297977856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297981952 ++wrote 2048/2048 bytes at offset 4297981952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297986048 ++wrote 2048/2048 bytes at offset 4297986048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297990144 ++wrote 2048/2048 bytes at offset 4297990144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297994240 ++wrote 2048/2048 bytes at offset 4297994240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297998336 ++wrote 2048/2048 bytes at offset 4297998336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298002432 ++wrote 2048/2048 bytes at offset 4298002432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298006528 ++wrote 2048/2048 bytes at offset 4298006528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298010624 ++wrote 2048/2048 bytes at offset 4298010624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298014720 ++wrote 2048/2048 bytes at offset 4298014720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298018816 ++wrote 2048/2048 bytes at offset 4298018816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298022912 ++wrote 2048/2048 bytes at offset 4298022912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298027008 ++wrote 2048/2048 bytes at offset 4298027008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298031104 ++wrote 2048/2048 bytes at offset 4298031104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298035200 ++wrote 2048/2048 bytes at offset 4298035200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298039296 ++wrote 2048/2048 bytes at offset 4298039296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298043392 ++wrote 2048/2048 bytes at offset 4298043392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298047488 ++wrote 2048/2048 bytes at offset 4298047488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298051584 ++wrote 2048/2048 bytes at offset 4298051584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298055680 ++wrote 2048/2048 bytes at offset 4298055680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298059776 ++wrote 2048/2048 bytes at offset 4298059776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298063872 ++wrote 2048/2048 bytes at offset 4298063872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298067968 ++wrote 2048/2048 bytes at offset 4298067968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298072064 ++wrote 2048/2048 bytes at offset 4298072064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298076160 ++wrote 2048/2048 bytes at offset 4298076160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298080256 ++wrote 2048/2048 bytes at offset 4298080256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298084352 ++wrote 2048/2048 bytes at offset 4298084352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298088448 ++wrote 2048/2048 bytes at offset 4298088448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298092544 ++wrote 2048/2048 bytes at offset 4298092544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298096640 ++wrote 2048/2048 bytes at offset 4298096640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298100736 ++wrote 2048/2048 bytes at offset 4298100736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298104832 ++wrote 2048/2048 bytes at offset 4298104832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298108928 ++wrote 2048/2048 bytes at offset 4298108928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 2 +-qemu-io> wrote 2048/2048 bytes at offset 4298114048 ++=== IO: pattern 2 ++wrote 2048/2048 bytes at offset 4298114048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298118144 ++wrote 2048/2048 bytes at offset 4298118144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298122240 ++wrote 2048/2048 bytes at offset 4298122240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298126336 ++wrote 2048/2048 bytes at offset 4298126336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298130432 ++wrote 2048/2048 bytes at offset 4298130432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298134528 ++wrote 2048/2048 bytes at offset 4298134528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298138624 ++wrote 2048/2048 bytes at offset 4298138624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298142720 ++wrote 2048/2048 bytes at offset 4298142720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298146816 ++wrote 2048/2048 bytes at offset 4298146816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298150912 ++wrote 2048/2048 bytes at offset 4298150912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298155008 ++wrote 2048/2048 bytes at offset 4298155008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298159104 ++wrote 2048/2048 bytes at offset 4298159104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298163200 ++wrote 2048/2048 bytes at offset 4298163200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298167296 ++wrote 2048/2048 bytes at offset 4298167296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298171392 ++wrote 2048/2048 bytes at offset 4298171392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298175488 ++wrote 2048/2048 bytes at offset 4298175488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298179584 ++wrote 2048/2048 bytes at offset 4298179584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298183680 ++wrote 2048/2048 bytes at offset 4298183680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298187776 ++wrote 2048/2048 bytes at offset 4298187776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298191872 ++wrote 2048/2048 bytes at offset 4298191872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298195968 ++wrote 2048/2048 bytes at offset 4298195968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298200064 ++wrote 2048/2048 bytes at offset 4298200064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298204160 ++wrote 2048/2048 bytes at offset 4298204160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298208256 ++wrote 2048/2048 bytes at offset 4298208256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298212352 ++wrote 2048/2048 bytes at offset 4298212352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298216448 ++wrote 2048/2048 bytes at offset 4298216448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298220544 ++wrote 2048/2048 bytes at offset 4298220544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298224640 ++wrote 2048/2048 bytes at offset 4298224640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298228736 ++wrote 2048/2048 bytes at offset 4298228736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298232832 ++wrote 2048/2048 bytes at offset 4298232832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298236928 ++wrote 2048/2048 bytes at offset 4298236928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298241024 ++wrote 2048/2048 bytes at offset 4298241024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298245120 ++wrote 2048/2048 bytes at offset 4298245120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298249216 ++wrote 2048/2048 bytes at offset 4298249216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298253312 ++wrote 2048/2048 bytes at offset 4298253312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298257408 ++wrote 2048/2048 bytes at offset 4298257408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298261504 ++wrote 2048/2048 bytes at offset 4298261504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298265600 ++wrote 2048/2048 bytes at offset 4298265600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298269696 ++wrote 2048/2048 bytes at offset 4298269696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298273792 ++wrote 2048/2048 bytes at offset 4298273792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298277888 ++wrote 2048/2048 bytes at offset 4298277888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298281984 ++wrote 2048/2048 bytes at offset 4298281984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298286080 ++wrote 2048/2048 bytes at offset 4298286080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298290176 ++wrote 2048/2048 bytes at offset 4298290176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298294272 ++wrote 2048/2048 bytes at offset 4298294272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298298368 ++wrote 2048/2048 bytes at offset 4298298368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298302464 ++wrote 2048/2048 bytes at offset 4298302464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298306560 ++wrote 2048/2048 bytes at offset 4298306560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298310656 ++wrote 2048/2048 bytes at offset 4298310656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298314752 ++wrote 2048/2048 bytes at offset 4298314752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298318848 ++wrote 2048/2048 bytes at offset 4298318848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298322944 ++wrote 2048/2048 bytes at offset 4298322944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298327040 ++wrote 2048/2048 bytes at offset 4298327040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298331136 ++wrote 2048/2048 bytes at offset 4298331136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298335232 ++wrote 2048/2048 bytes at offset 4298335232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298339328 ++wrote 2048/2048 bytes at offset 4298339328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298343424 ++wrote 2048/2048 bytes at offset 4298343424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298347520 ++wrote 2048/2048 bytes at offset 4298347520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298351616 ++wrote 2048/2048 bytes at offset 4298351616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298355712 ++wrote 2048/2048 bytes at offset 4298355712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298359808 ++wrote 2048/2048 bytes at offset 4298359808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298363904 ++wrote 2048/2048 bytes at offset 4298363904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298368000 ++wrote 2048/2048 bytes at offset 4298368000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298372096 ++wrote 2048/2048 bytes at offset 4298372096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298376192 ++wrote 2048/2048 bytes at offset 4298376192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298380288 ++wrote 2048/2048 bytes at offset 4298380288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298384384 ++wrote 2048/2048 bytes at offset 4298384384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298388480 ++wrote 2048/2048 bytes at offset 4298388480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298392576 ++wrote 2048/2048 bytes at offset 4298392576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298396672 ++wrote 2048/2048 bytes at offset 4298396672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298400768 ++wrote 2048/2048 bytes at offset 4298400768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298404864 ++wrote 2048/2048 bytes at offset 4298404864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298408960 ++wrote 2048/2048 bytes at offset 4298408960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298413056 ++wrote 2048/2048 bytes at offset 4298413056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298417152 ++wrote 2048/2048 bytes at offset 4298417152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298421248 ++wrote 2048/2048 bytes at offset 4298421248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298425344 ++wrote 2048/2048 bytes at offset 4298425344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298429440 ++wrote 2048/2048 bytes at offset 4298429440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298433536 ++wrote 2048/2048 bytes at offset 4298433536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298437632 ++wrote 2048/2048 bytes at offset 4298437632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298441728 ++wrote 2048/2048 bytes at offset 4298441728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298445824 ++wrote 2048/2048 bytes at offset 4298445824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298449920 ++wrote 2048/2048 bytes at offset 4298449920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298454016 ++wrote 2048/2048 bytes at offset 4298454016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298458112 ++wrote 2048/2048 bytes at offset 4298458112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298462208 ++wrote 2048/2048 bytes at offset 4298462208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298466304 ++wrote 2048/2048 bytes at offset 4298466304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298470400 ++wrote 2048/2048 bytes at offset 4298470400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298474496 ++wrote 2048/2048 bytes at offset 4298474496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298478592 ++wrote 2048/2048 bytes at offset 4298478592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298482688 ++wrote 2048/2048 bytes at offset 4298482688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298486784 ++wrote 2048/2048 bytes at offset 4298486784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298490880 ++wrote 2048/2048 bytes at offset 4298490880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298494976 ++wrote 2048/2048 bytes at offset 4298494976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298499072 ++wrote 2048/2048 bytes at offset 4298499072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298503168 ++wrote 2048/2048 bytes at offset 4298503168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298507264 ++wrote 2048/2048 bytes at offset 4298507264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298511360 ++wrote 2048/2048 bytes at offset 4298511360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298515456 ++wrote 2048/2048 bytes at offset 4298515456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298519552 ++wrote 2048/2048 bytes at offset 4298519552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298523648 ++wrote 2048/2048 bytes at offset 4298523648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298527744 ++wrote 2048/2048 bytes at offset 4298527744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298531840 ++wrote 2048/2048 bytes at offset 4298531840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298535936 ++wrote 2048/2048 bytes at offset 4298535936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298540032 ++wrote 2048/2048 bytes at offset 4298540032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298544128 ++wrote 2048/2048 bytes at offset 4298544128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298548224 ++wrote 2048/2048 bytes at offset 4298548224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298552320 ++wrote 2048/2048 bytes at offset 4298552320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298556416 ++wrote 2048/2048 bytes at offset 4298556416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298560512 ++wrote 2048/2048 bytes at offset 4298560512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298564608 ++wrote 2048/2048 bytes at offset 4298564608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298568704 ++wrote 2048/2048 bytes at offset 4298568704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298572800 ++wrote 2048/2048 bytes at offset 4298572800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298576896 ++wrote 2048/2048 bytes at offset 4298576896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298580992 ++wrote 2048/2048 bytes at offset 4298580992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298585088 ++wrote 2048/2048 bytes at offset 4298585088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298589184 ++wrote 2048/2048 bytes at offset 4298589184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298593280 ++wrote 2048/2048 bytes at offset 4298593280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298597376 ++wrote 2048/2048 bytes at offset 4298597376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298601472 ++wrote 2048/2048 bytes at offset 4298601472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298605568 ++wrote 2048/2048 bytes at offset 4298605568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298609664 ++wrote 2048/2048 bytes at offset 4298609664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298613760 ++wrote 2048/2048 bytes at offset 4298613760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298617856 ++wrote 2048/2048 bytes at offset 4298617856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298621952 ++wrote 2048/2048 bytes at offset 4298621952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298626048 ++wrote 2048/2048 bytes at offset 4298626048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298630144 ++wrote 2048/2048 bytes at offset 4298630144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298634240 ++wrote 2048/2048 bytes at offset 4298634240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298638336 ++wrote 2048/2048 bytes at offset 4298638336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298642432 ++wrote 2048/2048 bytes at offset 4298642432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298646528 ++wrote 2048/2048 bytes at offset 4298646528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298650624 ++wrote 2048/2048 bytes at offset 4298650624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298654720 ++wrote 2048/2048 bytes at offset 4298654720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298658816 ++wrote 2048/2048 bytes at offset 4298658816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298662912 ++wrote 2048/2048 bytes at offset 4298662912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298667008 ++wrote 2048/2048 bytes at offset 4298667008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298671104 ++wrote 2048/2048 bytes at offset 4298671104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298675200 ++wrote 2048/2048 bytes at offset 4298675200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298679296 ++wrote 2048/2048 bytes at offset 4298679296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298683392 ++wrote 2048/2048 bytes at offset 4298683392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298687488 ++wrote 2048/2048 bytes at offset 4298687488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298691584 ++wrote 2048/2048 bytes at offset 4298691584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298695680 ++wrote 2048/2048 bytes at offset 4298695680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298699776 ++wrote 2048/2048 bytes at offset 4298699776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298703872 ++wrote 2048/2048 bytes at offset 4298703872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298707968 ++wrote 2048/2048 bytes at offset 4298707968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298712064 ++wrote 2048/2048 bytes at offset 4298712064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298716160 ++wrote 2048/2048 bytes at offset 4298716160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298720256 ++wrote 2048/2048 bytes at offset 4298720256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298724352 ++wrote 2048/2048 bytes at offset 4298724352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298728448 ++wrote 2048/2048 bytes at offset 4298728448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298732544 ++wrote 2048/2048 bytes at offset 4298732544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298736640 ++wrote 2048/2048 bytes at offset 4298736640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298740736 ++wrote 2048/2048 bytes at offset 4298740736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298744832 ++wrote 2048/2048 bytes at offset 4298744832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298748928 ++wrote 2048/2048 bytes at offset 4298748928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298753024 ++wrote 2048/2048 bytes at offset 4298753024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298757120 ++wrote 2048/2048 bytes at offset 4298757120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298761216 ++wrote 2048/2048 bytes at offset 4298761216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298765312 ++wrote 2048/2048 bytes at offset 4298765312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298769408 ++wrote 2048/2048 bytes at offset 4298769408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298773504 ++wrote 2048/2048 bytes at offset 4298773504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298777600 ++wrote 2048/2048 bytes at offset 4298777600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298781696 ++wrote 2048/2048 bytes at offset 4298781696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298785792 ++wrote 2048/2048 bytes at offset 4298785792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298789888 ++wrote 2048/2048 bytes at offset 4298789888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298793984 ++wrote 2048/2048 bytes at offset 4298793984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298798080 ++wrote 2048/2048 bytes at offset 4298798080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298802176 ++wrote 2048/2048 bytes at offset 4298802176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298806272 ++wrote 2048/2048 bytes at offset 4298806272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298810368 ++wrote 2048/2048 bytes at offset 4298810368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298814464 ++wrote 2048/2048 bytes at offset 4298814464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298818560 ++wrote 2048/2048 bytes at offset 4298818560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298822656 ++wrote 2048/2048 bytes at offset 4298822656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298826752 ++wrote 2048/2048 bytes at offset 4298826752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298830848 ++wrote 2048/2048 bytes at offset 4298830848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298834944 ++wrote 2048/2048 bytes at offset 4298834944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298839040 ++wrote 2048/2048 bytes at offset 4298839040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298843136 ++wrote 2048/2048 bytes at offset 4298843136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298847232 ++wrote 2048/2048 bytes at offset 4298847232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298851328 ++wrote 2048/2048 bytes at offset 4298851328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298855424 ++wrote 2048/2048 bytes at offset 4298855424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298859520 ++wrote 2048/2048 bytes at offset 4298859520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298863616 ++wrote 2048/2048 bytes at offset 4298863616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298867712 ++wrote 2048/2048 bytes at offset 4298867712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298871808 ++wrote 2048/2048 bytes at offset 4298871808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298875904 ++wrote 2048/2048 bytes at offset 4298875904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298880000 ++wrote 2048/2048 bytes at offset 4298880000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298884096 ++wrote 2048/2048 bytes at offset 4298884096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298888192 ++wrote 2048/2048 bytes at offset 4298888192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298892288 ++wrote 2048/2048 bytes at offset 4298892288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298896384 ++wrote 2048/2048 bytes at offset 4298896384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298900480 ++wrote 2048/2048 bytes at offset 4298900480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298904576 ++wrote 2048/2048 bytes at offset 4298904576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298908672 ++wrote 2048/2048 bytes at offset 4298908672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298912768 ++wrote 2048/2048 bytes at offset 4298912768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298916864 ++wrote 2048/2048 bytes at offset 4298916864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298920960 ++wrote 2048/2048 bytes at offset 4298920960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298925056 ++wrote 2048/2048 bytes at offset 4298925056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298929152 ++wrote 2048/2048 bytes at offset 4298929152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298933248 ++wrote 2048/2048 bytes at offset 4298933248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298937344 ++wrote 2048/2048 bytes at offset 4298937344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298941440 ++wrote 2048/2048 bytes at offset 4298941440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298945536 ++wrote 2048/2048 bytes at offset 4298945536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298949632 ++wrote 2048/2048 bytes at offset 4298949632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298953728 ++wrote 2048/2048 bytes at offset 4298953728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298957824 ++wrote 2048/2048 bytes at offset 4298957824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298961920 ++wrote 2048/2048 bytes at offset 4298961920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298966016 ++wrote 2048/2048 bytes at offset 4298966016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298970112 ++wrote 2048/2048 bytes at offset 4298970112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298974208 ++wrote 2048/2048 bytes at offset 4298974208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298978304 ++wrote 2048/2048 bytes at offset 4298978304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298982400 ++wrote 2048/2048 bytes at offset 4298982400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298986496 ++wrote 2048/2048 bytes at offset 4298986496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298990592 ++wrote 2048/2048 bytes at offset 4298990592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298994688 ++wrote 2048/2048 bytes at offset 4298994688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298998784 ++wrote 2048/2048 bytes at offset 4298998784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299002880 ++wrote 2048/2048 bytes at offset 4299002880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299006976 ++wrote 2048/2048 bytes at offset 4299006976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299011072 ++wrote 2048/2048 bytes at offset 4299011072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299015168 ++wrote 2048/2048 bytes at offset 4299015168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299019264 ++wrote 2048/2048 bytes at offset 4299019264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299023360 ++wrote 2048/2048 bytes at offset 4299023360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299027456 ++wrote 2048/2048 bytes at offset 4299027456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299031552 ++wrote 2048/2048 bytes at offset 4299031552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299035648 ++wrote 2048/2048 bytes at offset 4299035648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299039744 ++wrote 2048/2048 bytes at offset 4299039744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299043840 ++wrote 2048/2048 bytes at offset 4299043840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299047936 ++wrote 2048/2048 bytes at offset 4299047936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299052032 ++wrote 2048/2048 bytes at offset 4299052032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299056128 ++wrote 2048/2048 bytes at offset 4299056128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299060224 ++wrote 2048/2048 bytes at offset 4299060224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299064320 ++wrote 2048/2048 bytes at offset 4299064320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299068416 ++wrote 2048/2048 bytes at offset 4299068416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299072512 ++wrote 2048/2048 bytes at offset 4299072512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299076608 ++wrote 2048/2048 bytes at offset 4299076608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299080704 ++wrote 2048/2048 bytes at offset 4299080704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299084800 ++wrote 2048/2048 bytes at offset 4299084800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299088896 ++wrote 2048/2048 bytes at offset 4299088896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299092992 ++wrote 2048/2048 bytes at offset 4299092992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299097088 ++wrote 2048/2048 bytes at offset 4299097088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299101184 ++wrote 2048/2048 bytes at offset 4299101184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299105280 ++wrote 2048/2048 bytes at offset 4299105280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299109376 ++wrote 2048/2048 bytes at offset 4299109376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299113472 ++wrote 2048/2048 bytes at offset 4299113472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299117568 ++wrote 2048/2048 bytes at offset 4299117568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299121664 ++wrote 2048/2048 bytes at offset 4299121664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299125760 ++wrote 2048/2048 bytes at offset 4299125760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299129856 ++wrote 2048/2048 bytes at offset 4299129856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299133952 ++wrote 2048/2048 bytes at offset 4299133952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299138048 ++wrote 2048/2048 bytes at offset 4299138048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299142144 ++wrote 2048/2048 bytes at offset 4299142144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299146240 ++wrote 2048/2048 bytes at offset 4299146240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299150336 ++wrote 2048/2048 bytes at offset 4299150336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299154432 ++wrote 2048/2048 bytes at offset 4299154432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299158528 ++wrote 2048/2048 bytes at offset 4299158528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 4 +-qemu-io> wrote 8192/8192 bytes at offset 4299163648 ++=== IO: pattern 4 ++wrote 8192/8192 bytes at offset 4299163648 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299175936 ++wrote 8192/8192 bytes at offset 4299175936 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299188224 ++wrote 8192/8192 bytes at offset 4299188224 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299200512 ++wrote 8192/8192 bytes at offset 4299200512 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299212800 ++wrote 8192/8192 bytes at offset 4299212800 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299225088 ++wrote 8192/8192 bytes at offset 4299225088 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299237376 ++wrote 8192/8192 bytes at offset 4299237376 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299249664 ++wrote 8192/8192 bytes at offset 4299249664 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299261952 ++wrote 8192/8192 bytes at offset 4299261952 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299274240 ++wrote 8192/8192 bytes at offset 4299274240 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299286528 ++wrote 8192/8192 bytes at offset 4299286528 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299298816 ++wrote 8192/8192 bytes at offset 4299298816 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299311104 ++wrote 8192/8192 bytes at offset 4299311104 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299323392 ++wrote 8192/8192 bytes at offset 4299323392 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299335680 ++wrote 8192/8192 bytes at offset 4299335680 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299347968 ++wrote 8192/8192 bytes at offset 4299347968 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299360256 ++wrote 8192/8192 bytes at offset 4299360256 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299372544 ++wrote 8192/8192 bytes at offset 4299372544 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299384832 ++wrote 8192/8192 bytes at offset 4299384832 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299397120 ++wrote 8192/8192 bytes at offset 4299397120 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299409408 ++wrote 8192/8192 bytes at offset 4299409408 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299421696 ++wrote 8192/8192 bytes at offset 4299421696 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299433984 ++wrote 8192/8192 bytes at offset 4299433984 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299446272 ++wrote 8192/8192 bytes at offset 4299446272 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299458560 ++wrote 8192/8192 bytes at offset 4299458560 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299470848 ++wrote 8192/8192 bytes at offset 4299470848 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299483136 ++wrote 8192/8192 bytes at offset 4299483136 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299495424 ++wrote 8192/8192 bytes at offset 4299495424 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299507712 ++wrote 8192/8192 bytes at offset 4299507712 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299520000 ++wrote 8192/8192 bytes at offset 4299520000 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299532288 ++wrote 8192/8192 bytes at offset 4299532288 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299544576 ++wrote 8192/8192 bytes at offset 4299544576 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299556864 ++wrote 8192/8192 bytes at offset 4299556864 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299569152 ++wrote 8192/8192 bytes at offset 4299569152 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299581440 ++wrote 8192/8192 bytes at offset 4299581440 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299593728 ++wrote 8192/8192 bytes at offset 4299593728 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299606016 ++wrote 8192/8192 bytes at offset 4299606016 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299618304 ++wrote 8192/8192 bytes at offset 4299618304 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299630592 ++wrote 8192/8192 bytes at offset 4299630592 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299642880 ++wrote 8192/8192 bytes at offset 4299642880 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299655168 ++wrote 8192/8192 bytes at offset 4299655168 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299667456 ++wrote 8192/8192 bytes at offset 4299667456 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299679744 ++wrote 8192/8192 bytes at offset 4299679744 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299692032 ++wrote 8192/8192 bytes at offset 4299692032 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299704320 ++wrote 8192/8192 bytes at offset 4299704320 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299716608 ++wrote 8192/8192 bytes at offset 4299716608 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299728896 ++wrote 8192/8192 bytes at offset 4299728896 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299741184 ++wrote 8192/8192 bytes at offset 4299741184 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299753472 ++wrote 8192/8192 bytes at offset 4299753472 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299765760 ++wrote 8192/8192 bytes at offset 4299765760 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299778048 ++wrote 8192/8192 bytes at offset 4299778048 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299790336 ++wrote 8192/8192 bytes at offset 4299790336 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299802624 ++wrote 8192/8192 bytes at offset 4299802624 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299814912 ++wrote 8192/8192 bytes at offset 4299814912 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299827200 ++wrote 8192/8192 bytes at offset 4299827200 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299839488 ++wrote 8192/8192 bytes at offset 4299839488 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299851776 ++wrote 8192/8192 bytes at offset 4299851776 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299864064 ++wrote 8192/8192 bytes at offset 4299864064 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299876352 ++wrote 8192/8192 bytes at offset 4299876352 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299888640 ++wrote 8192/8192 bytes at offset 4299888640 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299900928 ++wrote 8192/8192 bytes at offset 4299900928 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299913216 ++wrote 8192/8192 bytes at offset 4299913216 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299925504 ++wrote 8192/8192 bytes at offset 4299925504 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299937792 ++wrote 8192/8192 bytes at offset 4299937792 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 244 +-qemu-io> wrote 12288/12288 bytes at offset 4301252608 ++=== IO: pattern 244 ++wrote 12288/12288 bytes at offset 4301252608 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 4303351808 ++wrote 12288/12288 bytes at offset 4303351808 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 4305451008 ++wrote 12288/12288 bytes at offset 4305451008 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 4307550208 ++wrote 12288/12288 bytes at offset 4307550208 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 4309649408 ++wrote 12288/12288 bytes at offset 4309649408 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 4311748608 ++wrote 12288/12288 bytes at offset 4311748608 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 4313847808 ++wrote 12288/12288 bytes at offset 4313847808 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 4315947008 ++wrote 12288/12288 bytes at offset 4315947008 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> read 4096/4096 bytes at offset 4294967296 ++=== IO: pattern 0 ++read 4096/4096 bytes at offset 4294967296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294971392 ++read 4096/4096 bytes at offset 4294971392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294975488 ++read 4096/4096 bytes at offset 4294975488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294979584 ++read 4096/4096 bytes at offset 4294979584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294983680 ++read 4096/4096 bytes at offset 4294983680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294987776 ++read 4096/4096 bytes at offset 4294987776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294991872 ++read 4096/4096 bytes at offset 4294991872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294995968 ++read 4096/4096 bytes at offset 4294995968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295000064 ++read 4096/4096 bytes at offset 4295000064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295004160 ++read 4096/4096 bytes at offset 4295004160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295008256 ++read 4096/4096 bytes at offset 4295008256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295012352 ++read 4096/4096 bytes at offset 4295012352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295016448 ++read 4096/4096 bytes at offset 4295016448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295020544 ++read 4096/4096 bytes at offset 4295020544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295024640 ++read 4096/4096 bytes at offset 4295024640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295028736 ++read 4096/4096 bytes at offset 4295028736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295032832 ++read 4096/4096 bytes at offset 4295032832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295036928 ++read 4096/4096 bytes at offset 4295036928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295041024 ++read 4096/4096 bytes at offset 4295041024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295045120 ++read 4096/4096 bytes at offset 4295045120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295049216 ++read 4096/4096 bytes at offset 4295049216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295053312 ++read 4096/4096 bytes at offset 4295053312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295057408 ++read 4096/4096 bytes at offset 4295057408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295061504 ++read 4096/4096 bytes at offset 4295061504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295065600 ++read 4096/4096 bytes at offset 4295065600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295069696 ++read 4096/4096 bytes at offset 4295069696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295073792 ++read 4096/4096 bytes at offset 4295073792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295077888 ++read 4096/4096 bytes at offset 4295077888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295081984 ++read 4096/4096 bytes at offset 4295081984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295086080 ++read 4096/4096 bytes at offset 4295086080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295090176 ++read 4096/4096 bytes at offset 4295090176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295094272 ++read 4096/4096 bytes at offset 4295094272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295098368 ++read 4096/4096 bytes at offset 4295098368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295102464 ++read 4096/4096 bytes at offset 4295102464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295106560 ++read 4096/4096 bytes at offset 4295106560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295110656 ++read 4096/4096 bytes at offset 4295110656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295114752 ++read 4096/4096 bytes at offset 4295114752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295118848 ++read 4096/4096 bytes at offset 4295118848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295122944 ++read 4096/4096 bytes at offset 4295122944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295127040 ++read 4096/4096 bytes at offset 4295127040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295131136 ++read 4096/4096 bytes at offset 4295131136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295135232 ++read 4096/4096 bytes at offset 4295135232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295139328 ++read 4096/4096 bytes at offset 4295139328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295143424 ++read 4096/4096 bytes at offset 4295143424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295147520 ++read 4096/4096 bytes at offset 4295147520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295151616 ++read 4096/4096 bytes at offset 4295151616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295155712 ++read 4096/4096 bytes at offset 4295155712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295159808 ++read 4096/4096 bytes at offset 4295159808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295163904 ++read 4096/4096 bytes at offset 4295163904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295168000 ++read 4096/4096 bytes at offset 4295168000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295172096 ++read 4096/4096 bytes at offset 4295172096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295176192 ++read 4096/4096 bytes at offset 4295176192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295180288 ++read 4096/4096 bytes at offset 4295180288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295184384 ++read 4096/4096 bytes at offset 4295184384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295188480 ++read 4096/4096 bytes at offset 4295188480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295192576 ++read 4096/4096 bytes at offset 4295192576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295196672 ++read 4096/4096 bytes at offset 4295196672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295200768 ++read 4096/4096 bytes at offset 4295200768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295204864 ++read 4096/4096 bytes at offset 4295204864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295208960 ++read 4096/4096 bytes at offset 4295208960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295213056 ++read 4096/4096 bytes at offset 4295213056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295217152 ++read 4096/4096 bytes at offset 4295217152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295221248 ++read 4096/4096 bytes at offset 4295221248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295225344 ++read 4096/4096 bytes at offset 4295225344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295229440 ++read 4096/4096 bytes at offset 4295229440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295233536 ++read 4096/4096 bytes at offset 4295233536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295237632 ++read 4096/4096 bytes at offset 4295237632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295241728 ++read 4096/4096 bytes at offset 4295241728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295245824 ++read 4096/4096 bytes at offset 4295245824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295249920 ++read 4096/4096 bytes at offset 4295249920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295254016 ++read 4096/4096 bytes at offset 4295254016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295258112 ++read 4096/4096 bytes at offset 4295258112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295262208 ++read 4096/4096 bytes at offset 4295262208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295266304 ++read 4096/4096 bytes at offset 4295266304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295270400 ++read 4096/4096 bytes at offset 4295270400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295274496 ++read 4096/4096 bytes at offset 4295274496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295278592 ++read 4096/4096 bytes at offset 4295278592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295282688 ++read 4096/4096 bytes at offset 4295282688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295286784 ++read 4096/4096 bytes at offset 4295286784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295290880 ++read 4096/4096 bytes at offset 4295290880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295294976 ++read 4096/4096 bytes at offset 4295294976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295299072 ++read 4096/4096 bytes at offset 4295299072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295303168 ++read 4096/4096 bytes at offset 4295303168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295307264 ++read 4096/4096 bytes at offset 4295307264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295311360 ++read 4096/4096 bytes at offset 4295311360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295315456 ++read 4096/4096 bytes at offset 4295315456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295319552 ++read 4096/4096 bytes at offset 4295319552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295323648 ++read 4096/4096 bytes at offset 4295323648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295327744 ++read 4096/4096 bytes at offset 4295327744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295331840 ++read 4096/4096 bytes at offset 4295331840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295335936 ++read 4096/4096 bytes at offset 4295335936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295340032 ++read 4096/4096 bytes at offset 4295340032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295344128 ++read 4096/4096 bytes at offset 4295344128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295348224 ++read 4096/4096 bytes at offset 4295348224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295352320 ++read 4096/4096 bytes at offset 4295352320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295356416 ++read 4096/4096 bytes at offset 4295356416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295360512 ++read 4096/4096 bytes at offset 4295360512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295364608 ++read 4096/4096 bytes at offset 4295364608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295368704 ++read 4096/4096 bytes at offset 4295368704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295372800 ++read 4096/4096 bytes at offset 4295372800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295376896 ++read 4096/4096 bytes at offset 4295376896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295380992 ++read 4096/4096 bytes at offset 4295380992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295385088 ++read 4096/4096 bytes at offset 4295385088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295389184 ++read 4096/4096 bytes at offset 4295389184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295393280 ++read 4096/4096 bytes at offset 4295393280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295397376 ++read 4096/4096 bytes at offset 4295397376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295401472 ++read 4096/4096 bytes at offset 4295401472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295405568 ++read 4096/4096 bytes at offset 4295405568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295409664 ++read 4096/4096 bytes at offset 4295409664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295413760 ++read 4096/4096 bytes at offset 4295413760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295417856 ++read 4096/4096 bytes at offset 4295417856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295421952 ++read 4096/4096 bytes at offset 4295421952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295426048 ++read 4096/4096 bytes at offset 4295426048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295430144 ++read 4096/4096 bytes at offset 4295430144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295434240 ++read 4096/4096 bytes at offset 4295434240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295438336 ++read 4096/4096 bytes at offset 4295438336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295442432 ++read 4096/4096 bytes at offset 4295442432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295446528 ++read 4096/4096 bytes at offset 4295446528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295450624 ++read 4096/4096 bytes at offset 4295450624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295454720 ++read 4096/4096 bytes at offset 4295454720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295458816 ++read 4096/4096 bytes at offset 4295458816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295462912 ++read 4096/4096 bytes at offset 4295462912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295467008 ++read 4096/4096 bytes at offset 4295467008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295471104 ++read 4096/4096 bytes at offset 4295471104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295475200 ++read 4096/4096 bytes at offset 4295475200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295479296 ++read 4096/4096 bytes at offset 4295479296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295483392 ++read 4096/4096 bytes at offset 4295483392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295487488 ++read 4096/4096 bytes at offset 4295487488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295491584 ++read 4096/4096 bytes at offset 4295491584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295495680 ++read 4096/4096 bytes at offset 4295495680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295499776 ++read 4096/4096 bytes at offset 4295499776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295503872 ++read 4096/4096 bytes at offset 4295503872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295507968 ++read 4096/4096 bytes at offset 4295507968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295512064 ++read 4096/4096 bytes at offset 4295512064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295516160 ++read 4096/4096 bytes at offset 4295516160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295520256 ++read 4096/4096 bytes at offset 4295520256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295524352 ++read 4096/4096 bytes at offset 4295524352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295528448 ++read 4096/4096 bytes at offset 4295528448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295532544 ++read 4096/4096 bytes at offset 4295532544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295536640 ++read 4096/4096 bytes at offset 4295536640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295540736 ++read 4096/4096 bytes at offset 4295540736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295544832 ++read 4096/4096 bytes at offset 4295544832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295548928 ++read 4096/4096 bytes at offset 4295548928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295553024 ++read 4096/4096 bytes at offset 4295553024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295557120 ++read 4096/4096 bytes at offset 4295557120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295561216 ++read 4096/4096 bytes at offset 4295561216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295565312 ++read 4096/4096 bytes at offset 4295565312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295569408 ++read 4096/4096 bytes at offset 4295569408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295573504 ++read 4096/4096 bytes at offset 4295573504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295577600 ++read 4096/4096 bytes at offset 4295577600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295581696 ++read 4096/4096 bytes at offset 4295581696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295585792 ++read 4096/4096 bytes at offset 4295585792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295589888 ++read 4096/4096 bytes at offset 4295589888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295593984 ++read 4096/4096 bytes at offset 4295593984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295598080 ++read 4096/4096 bytes at offset 4295598080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295602176 ++read 4096/4096 bytes at offset 4295602176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295606272 ++read 4096/4096 bytes at offset 4295606272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295610368 ++read 4096/4096 bytes at offset 4295610368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295614464 ++read 4096/4096 bytes at offset 4295614464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295618560 ++read 4096/4096 bytes at offset 4295618560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295622656 ++read 4096/4096 bytes at offset 4295622656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295626752 ++read 4096/4096 bytes at offset 4295626752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295630848 ++read 4096/4096 bytes at offset 4295630848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295634944 ++read 4096/4096 bytes at offset 4295634944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295639040 ++read 4096/4096 bytes at offset 4295639040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295643136 ++read 4096/4096 bytes at offset 4295643136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295647232 ++read 4096/4096 bytes at offset 4295647232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295651328 ++read 4096/4096 bytes at offset 4295651328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295655424 ++read 4096/4096 bytes at offset 4295655424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295659520 ++read 4096/4096 bytes at offset 4295659520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295663616 ++read 4096/4096 bytes at offset 4295663616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295667712 ++read 4096/4096 bytes at offset 4295667712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295671808 ++read 4096/4096 bytes at offset 4295671808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295675904 ++read 4096/4096 bytes at offset 4295675904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295680000 ++read 4096/4096 bytes at offset 4295680000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295684096 ++read 4096/4096 bytes at offset 4295684096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295688192 ++read 4096/4096 bytes at offset 4295688192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295692288 ++read 4096/4096 bytes at offset 4295692288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295696384 ++read 4096/4096 bytes at offset 4295696384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295700480 ++read 4096/4096 bytes at offset 4295700480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295704576 ++read 4096/4096 bytes at offset 4295704576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295708672 ++read 4096/4096 bytes at offset 4295708672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295712768 ++read 4096/4096 bytes at offset 4295712768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295716864 ++read 4096/4096 bytes at offset 4295716864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295720960 ++read 4096/4096 bytes at offset 4295720960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295725056 ++read 4096/4096 bytes at offset 4295725056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295729152 ++read 4096/4096 bytes at offset 4295729152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295733248 ++read 4096/4096 bytes at offset 4295733248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295737344 ++read 4096/4096 bytes at offset 4295737344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295741440 ++read 4096/4096 bytes at offset 4295741440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295745536 ++read 4096/4096 bytes at offset 4295745536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295749632 ++read 4096/4096 bytes at offset 4295749632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295753728 ++read 4096/4096 bytes at offset 4295753728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295757824 ++read 4096/4096 bytes at offset 4295757824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295761920 ++read 4096/4096 bytes at offset 4295761920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295766016 ++read 4096/4096 bytes at offset 4295766016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295770112 ++read 4096/4096 bytes at offset 4295770112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295774208 ++read 4096/4096 bytes at offset 4295774208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295778304 ++read 4096/4096 bytes at offset 4295778304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295782400 ++read 4096/4096 bytes at offset 4295782400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295786496 ++read 4096/4096 bytes at offset 4295786496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295790592 ++read 4096/4096 bytes at offset 4295790592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295794688 ++read 4096/4096 bytes at offset 4295794688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295798784 ++read 4096/4096 bytes at offset 4295798784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295802880 ++read 4096/4096 bytes at offset 4295802880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295806976 ++read 4096/4096 bytes at offset 4295806976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295811072 ++read 4096/4096 bytes at offset 4295811072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295815168 ++read 4096/4096 bytes at offset 4295815168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295819264 ++read 4096/4096 bytes at offset 4295819264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295823360 ++read 4096/4096 bytes at offset 4295823360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295827456 ++read 4096/4096 bytes at offset 4295827456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295831552 ++read 4096/4096 bytes at offset 4295831552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295835648 ++read 4096/4096 bytes at offset 4295835648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295839744 ++read 4096/4096 bytes at offset 4295839744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295843840 ++read 4096/4096 bytes at offset 4295843840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295847936 ++read 4096/4096 bytes at offset 4295847936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295852032 ++read 4096/4096 bytes at offset 4295852032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295856128 ++read 4096/4096 bytes at offset 4295856128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295860224 ++read 4096/4096 bytes at offset 4295860224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295864320 ++read 4096/4096 bytes at offset 4295864320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295868416 ++read 4096/4096 bytes at offset 4295868416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295872512 ++read 4096/4096 bytes at offset 4295872512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295876608 ++read 4096/4096 bytes at offset 4295876608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295880704 ++read 4096/4096 bytes at offset 4295880704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295884800 ++read 4096/4096 bytes at offset 4295884800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295888896 ++read 4096/4096 bytes at offset 4295888896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295892992 ++read 4096/4096 bytes at offset 4295892992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295897088 ++read 4096/4096 bytes at offset 4295897088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295901184 ++read 4096/4096 bytes at offset 4295901184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295905280 ++read 4096/4096 bytes at offset 4295905280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295909376 ++read 4096/4096 bytes at offset 4295909376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295913472 ++read 4096/4096 bytes at offset 4295913472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295917568 ++read 4096/4096 bytes at offset 4295917568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295921664 ++read 4096/4096 bytes at offset 4295921664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295925760 ++read 4096/4096 bytes at offset 4295925760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295929856 ++read 4096/4096 bytes at offset 4295929856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295933952 ++read 4096/4096 bytes at offset 4295933952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295938048 ++read 4096/4096 bytes at offset 4295938048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295942144 ++read 4096/4096 bytes at offset 4295942144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295946240 ++read 4096/4096 bytes at offset 4295946240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295950336 ++read 4096/4096 bytes at offset 4295950336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295954432 ++read 4096/4096 bytes at offset 4295954432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295958528 ++read 4096/4096 bytes at offset 4295958528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295962624 ++read 4096/4096 bytes at offset 4295962624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295966720 ++read 4096/4096 bytes at offset 4295966720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295970816 ++read 4096/4096 bytes at offset 4295970816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295974912 ++read 4096/4096 bytes at offset 4295974912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295979008 ++read 4096/4096 bytes at offset 4295979008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295983104 ++read 4096/4096 bytes at offset 4295983104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295987200 ++read 4096/4096 bytes at offset 4295987200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295991296 ++read 4096/4096 bytes at offset 4295991296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295995392 ++read 4096/4096 bytes at offset 4295995392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295999488 ++read 4096/4096 bytes at offset 4295999488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4296003584 ++read 4096/4096 bytes at offset 4296003584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4296007680 ++read 4096/4096 bytes at offset 4296007680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4296011776 ++read 4096/4096 bytes at offset 4296011776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 4 +-qemu-io> read 2048/2048 bytes at offset 4296017920 ++=== IO: pattern 4 ++read 2048/2048 bytes at offset 4296017920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296022016 ++read 2048/2048 bytes at offset 4296022016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296026112 ++read 2048/2048 bytes at offset 4296026112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296030208 ++read 2048/2048 bytes at offset 4296030208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296034304 ++read 2048/2048 bytes at offset 4296034304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296038400 ++read 2048/2048 bytes at offset 4296038400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296042496 ++read 2048/2048 bytes at offset 4296042496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296046592 ++read 2048/2048 bytes at offset 4296046592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296050688 ++read 2048/2048 bytes at offset 4296050688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296054784 ++read 2048/2048 bytes at offset 4296054784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296058880 ++read 2048/2048 bytes at offset 4296058880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296062976 ++read 2048/2048 bytes at offset 4296062976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296067072 ++read 2048/2048 bytes at offset 4296067072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296071168 ++read 2048/2048 bytes at offset 4296071168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296075264 ++read 2048/2048 bytes at offset 4296075264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296079360 ++read 2048/2048 bytes at offset 4296079360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296083456 ++read 2048/2048 bytes at offset 4296083456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296087552 ++read 2048/2048 bytes at offset 4296087552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296091648 ++read 2048/2048 bytes at offset 4296091648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296095744 ++read 2048/2048 bytes at offset 4296095744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296099840 ++read 2048/2048 bytes at offset 4296099840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296103936 ++read 2048/2048 bytes at offset 4296103936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296108032 ++read 2048/2048 bytes at offset 4296108032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296112128 ++read 2048/2048 bytes at offset 4296112128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296116224 ++read 2048/2048 bytes at offset 4296116224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296120320 ++read 2048/2048 bytes at offset 4296120320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296124416 ++read 2048/2048 bytes at offset 4296124416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296128512 ++read 2048/2048 bytes at offset 4296128512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296132608 ++read 2048/2048 bytes at offset 4296132608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296136704 ++read 2048/2048 bytes at offset 4296136704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296140800 ++read 2048/2048 bytes at offset 4296140800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296144896 ++read 2048/2048 bytes at offset 4296144896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296148992 ++read 2048/2048 bytes at offset 4296148992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296153088 ++read 2048/2048 bytes at offset 4296153088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296157184 ++read 2048/2048 bytes at offset 4296157184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296161280 ++read 2048/2048 bytes at offset 4296161280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296165376 ++read 2048/2048 bytes at offset 4296165376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296169472 ++read 2048/2048 bytes at offset 4296169472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296173568 ++read 2048/2048 bytes at offset 4296173568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296177664 ++read 2048/2048 bytes at offset 4296177664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296181760 ++read 2048/2048 bytes at offset 4296181760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296185856 ++read 2048/2048 bytes at offset 4296185856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296189952 ++read 2048/2048 bytes at offset 4296189952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296194048 ++read 2048/2048 bytes at offset 4296194048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296198144 ++read 2048/2048 bytes at offset 4296198144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296202240 ++read 2048/2048 bytes at offset 4296202240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296206336 ++read 2048/2048 bytes at offset 4296206336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296210432 ++read 2048/2048 bytes at offset 4296210432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296214528 ++read 2048/2048 bytes at offset 4296214528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296218624 ++read 2048/2048 bytes at offset 4296218624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296222720 ++read 2048/2048 bytes at offset 4296222720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296226816 ++read 2048/2048 bytes at offset 4296226816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296230912 ++read 2048/2048 bytes at offset 4296230912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296235008 ++read 2048/2048 bytes at offset 4296235008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296239104 ++read 2048/2048 bytes at offset 4296239104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296243200 ++read 2048/2048 bytes at offset 4296243200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296247296 ++read 2048/2048 bytes at offset 4296247296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296251392 ++read 2048/2048 bytes at offset 4296251392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296255488 ++read 2048/2048 bytes at offset 4296255488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296259584 ++read 2048/2048 bytes at offset 4296259584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296263680 ++read 2048/2048 bytes at offset 4296263680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296267776 ++read 2048/2048 bytes at offset 4296267776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296271872 ++read 2048/2048 bytes at offset 4296271872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296275968 ++read 2048/2048 bytes at offset 4296275968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296280064 ++read 2048/2048 bytes at offset 4296280064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296284160 ++read 2048/2048 bytes at offset 4296284160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296288256 ++read 2048/2048 bytes at offset 4296288256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296292352 ++read 2048/2048 bytes at offset 4296292352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296296448 ++read 2048/2048 bytes at offset 4296296448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296300544 ++read 2048/2048 bytes at offset 4296300544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296304640 ++read 2048/2048 bytes at offset 4296304640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296308736 ++read 2048/2048 bytes at offset 4296308736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296312832 ++read 2048/2048 bytes at offset 4296312832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296316928 ++read 2048/2048 bytes at offset 4296316928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296321024 ++read 2048/2048 bytes at offset 4296321024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296325120 ++read 2048/2048 bytes at offset 4296325120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296329216 ++read 2048/2048 bytes at offset 4296329216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296333312 ++read 2048/2048 bytes at offset 4296333312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296337408 ++read 2048/2048 bytes at offset 4296337408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296341504 ++read 2048/2048 bytes at offset 4296341504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296345600 ++read 2048/2048 bytes at offset 4296345600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296349696 ++read 2048/2048 bytes at offset 4296349696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296353792 ++read 2048/2048 bytes at offset 4296353792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296357888 ++read 2048/2048 bytes at offset 4296357888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296361984 ++read 2048/2048 bytes at offset 4296361984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296366080 ++read 2048/2048 bytes at offset 4296366080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296370176 ++read 2048/2048 bytes at offset 4296370176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296374272 ++read 2048/2048 bytes at offset 4296374272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296378368 ++read 2048/2048 bytes at offset 4296378368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296382464 ++read 2048/2048 bytes at offset 4296382464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296386560 ++read 2048/2048 bytes at offset 4296386560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296390656 ++read 2048/2048 bytes at offset 4296390656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296394752 ++read 2048/2048 bytes at offset 4296394752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296398848 ++read 2048/2048 bytes at offset 4296398848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296402944 ++read 2048/2048 bytes at offset 4296402944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296407040 ++read 2048/2048 bytes at offset 4296407040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296411136 ++read 2048/2048 bytes at offset 4296411136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296415232 ++read 2048/2048 bytes at offset 4296415232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296419328 ++read 2048/2048 bytes at offset 4296419328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296423424 ++read 2048/2048 bytes at offset 4296423424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296427520 ++read 2048/2048 bytes at offset 4296427520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296431616 ++read 2048/2048 bytes at offset 4296431616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296435712 ++read 2048/2048 bytes at offset 4296435712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296439808 ++read 2048/2048 bytes at offset 4296439808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296443904 ++read 2048/2048 bytes at offset 4296443904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296448000 ++read 2048/2048 bytes at offset 4296448000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296452096 ++read 2048/2048 bytes at offset 4296452096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296456192 ++read 2048/2048 bytes at offset 4296456192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296460288 ++read 2048/2048 bytes at offset 4296460288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296464384 ++read 2048/2048 bytes at offset 4296464384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296468480 ++read 2048/2048 bytes at offset 4296468480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296472576 ++read 2048/2048 bytes at offset 4296472576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296476672 ++read 2048/2048 bytes at offset 4296476672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296480768 ++read 2048/2048 bytes at offset 4296480768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296484864 ++read 2048/2048 bytes at offset 4296484864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296488960 ++read 2048/2048 bytes at offset 4296488960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296493056 ++read 2048/2048 bytes at offset 4296493056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296497152 ++read 2048/2048 bytes at offset 4296497152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296501248 ++read 2048/2048 bytes at offset 4296501248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296505344 ++read 2048/2048 bytes at offset 4296505344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296509440 ++read 2048/2048 bytes at offset 4296509440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296513536 ++read 2048/2048 bytes at offset 4296513536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296517632 ++read 2048/2048 bytes at offset 4296517632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296521728 ++read 2048/2048 bytes at offset 4296521728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296525824 ++read 2048/2048 bytes at offset 4296525824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296529920 ++read 2048/2048 bytes at offset 4296529920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296534016 ++read 2048/2048 bytes at offset 4296534016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296538112 ++read 2048/2048 bytes at offset 4296538112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296542208 ++read 2048/2048 bytes at offset 4296542208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296546304 ++read 2048/2048 bytes at offset 4296546304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296550400 ++read 2048/2048 bytes at offset 4296550400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296554496 ++read 2048/2048 bytes at offset 4296554496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296558592 ++read 2048/2048 bytes at offset 4296558592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296562688 ++read 2048/2048 bytes at offset 4296562688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296566784 ++read 2048/2048 bytes at offset 4296566784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296570880 ++read 2048/2048 bytes at offset 4296570880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296574976 ++read 2048/2048 bytes at offset 4296574976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296579072 ++read 2048/2048 bytes at offset 4296579072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296583168 ++read 2048/2048 bytes at offset 4296583168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296587264 ++read 2048/2048 bytes at offset 4296587264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296591360 ++read 2048/2048 bytes at offset 4296591360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296595456 ++read 2048/2048 bytes at offset 4296595456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296599552 ++read 2048/2048 bytes at offset 4296599552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296603648 ++read 2048/2048 bytes at offset 4296603648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296607744 ++read 2048/2048 bytes at offset 4296607744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296611840 ++read 2048/2048 bytes at offset 4296611840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296615936 ++read 2048/2048 bytes at offset 4296615936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296620032 ++read 2048/2048 bytes at offset 4296620032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296624128 ++read 2048/2048 bytes at offset 4296624128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296628224 ++read 2048/2048 bytes at offset 4296628224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296632320 ++read 2048/2048 bytes at offset 4296632320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296636416 ++read 2048/2048 bytes at offset 4296636416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296640512 ++read 2048/2048 bytes at offset 4296640512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296644608 ++read 2048/2048 bytes at offset 4296644608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296648704 ++read 2048/2048 bytes at offset 4296648704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296652800 ++read 2048/2048 bytes at offset 4296652800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296656896 ++read 2048/2048 bytes at offset 4296656896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296660992 ++read 2048/2048 bytes at offset 4296660992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296665088 ++read 2048/2048 bytes at offset 4296665088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296669184 ++read 2048/2048 bytes at offset 4296669184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296673280 ++read 2048/2048 bytes at offset 4296673280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296677376 ++read 2048/2048 bytes at offset 4296677376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296681472 ++read 2048/2048 bytes at offset 4296681472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296685568 ++read 2048/2048 bytes at offset 4296685568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296689664 ++read 2048/2048 bytes at offset 4296689664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296693760 ++read 2048/2048 bytes at offset 4296693760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296697856 ++read 2048/2048 bytes at offset 4296697856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296701952 ++read 2048/2048 bytes at offset 4296701952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296706048 ++read 2048/2048 bytes at offset 4296706048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296710144 ++read 2048/2048 bytes at offset 4296710144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296714240 ++read 2048/2048 bytes at offset 4296714240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296718336 ++read 2048/2048 bytes at offset 4296718336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296722432 ++read 2048/2048 bytes at offset 4296722432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296726528 ++read 2048/2048 bytes at offset 4296726528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296730624 ++read 2048/2048 bytes at offset 4296730624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296734720 ++read 2048/2048 bytes at offset 4296734720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296738816 ++read 2048/2048 bytes at offset 4296738816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296742912 ++read 2048/2048 bytes at offset 4296742912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296747008 ++read 2048/2048 bytes at offset 4296747008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296751104 ++read 2048/2048 bytes at offset 4296751104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296755200 ++read 2048/2048 bytes at offset 4296755200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296759296 ++read 2048/2048 bytes at offset 4296759296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296763392 ++read 2048/2048 bytes at offset 4296763392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296767488 ++read 2048/2048 bytes at offset 4296767488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296771584 ++read 2048/2048 bytes at offset 4296771584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296775680 ++read 2048/2048 bytes at offset 4296775680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296779776 ++read 2048/2048 bytes at offset 4296779776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296783872 ++read 2048/2048 bytes at offset 4296783872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296787968 ++read 2048/2048 bytes at offset 4296787968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296792064 ++read 2048/2048 bytes at offset 4296792064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296796160 ++read 2048/2048 bytes at offset 4296796160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296800256 ++read 2048/2048 bytes at offset 4296800256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296804352 ++read 2048/2048 bytes at offset 4296804352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296808448 ++read 2048/2048 bytes at offset 4296808448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296812544 ++read 2048/2048 bytes at offset 4296812544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296816640 ++read 2048/2048 bytes at offset 4296816640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296820736 ++read 2048/2048 bytes at offset 4296820736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296824832 ++read 2048/2048 bytes at offset 4296824832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296828928 ++read 2048/2048 bytes at offset 4296828928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296833024 ++read 2048/2048 bytes at offset 4296833024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296837120 ++read 2048/2048 bytes at offset 4296837120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296841216 ++read 2048/2048 bytes at offset 4296841216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296845312 ++read 2048/2048 bytes at offset 4296845312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296849408 ++read 2048/2048 bytes at offset 4296849408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296853504 ++read 2048/2048 bytes at offset 4296853504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296857600 ++read 2048/2048 bytes at offset 4296857600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296861696 ++read 2048/2048 bytes at offset 4296861696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296865792 ++read 2048/2048 bytes at offset 4296865792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296869888 ++read 2048/2048 bytes at offset 4296869888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296873984 ++read 2048/2048 bytes at offset 4296873984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296878080 ++read 2048/2048 bytes at offset 4296878080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296882176 ++read 2048/2048 bytes at offset 4296882176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296886272 ++read 2048/2048 bytes at offset 4296886272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296890368 ++read 2048/2048 bytes at offset 4296890368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296894464 ++read 2048/2048 bytes at offset 4296894464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296898560 ++read 2048/2048 bytes at offset 4296898560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296902656 ++read 2048/2048 bytes at offset 4296902656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296906752 ++read 2048/2048 bytes at offset 4296906752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296910848 ++read 2048/2048 bytes at offset 4296910848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296914944 ++read 2048/2048 bytes at offset 4296914944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296919040 ++read 2048/2048 bytes at offset 4296919040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296923136 ++read 2048/2048 bytes at offset 4296923136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296927232 ++read 2048/2048 bytes at offset 4296927232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296931328 ++read 2048/2048 bytes at offset 4296931328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296935424 ++read 2048/2048 bytes at offset 4296935424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296939520 ++read 2048/2048 bytes at offset 4296939520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296943616 ++read 2048/2048 bytes at offset 4296943616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296947712 ++read 2048/2048 bytes at offset 4296947712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296951808 ++read 2048/2048 bytes at offset 4296951808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296955904 ++read 2048/2048 bytes at offset 4296955904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296960000 ++read 2048/2048 bytes at offset 4296960000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296964096 ++read 2048/2048 bytes at offset 4296964096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296968192 ++read 2048/2048 bytes at offset 4296968192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296972288 ++read 2048/2048 bytes at offset 4296972288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296976384 ++read 2048/2048 bytes at offset 4296976384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296980480 ++read 2048/2048 bytes at offset 4296980480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296984576 ++read 2048/2048 bytes at offset 4296984576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296988672 ++read 2048/2048 bytes at offset 4296988672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296992768 ++read 2048/2048 bytes at offset 4296992768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296996864 ++read 2048/2048 bytes at offset 4296996864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297000960 ++read 2048/2048 bytes at offset 4297000960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297005056 ++read 2048/2048 bytes at offset 4297005056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297009152 ++read 2048/2048 bytes at offset 4297009152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297013248 ++read 2048/2048 bytes at offset 4297013248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297017344 ++read 2048/2048 bytes at offset 4297017344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297021440 ++read 2048/2048 bytes at offset 4297021440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297025536 ++read 2048/2048 bytes at offset 4297025536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297029632 ++read 2048/2048 bytes at offset 4297029632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297033728 ++read 2048/2048 bytes at offset 4297033728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297037824 ++read 2048/2048 bytes at offset 4297037824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297041920 ++read 2048/2048 bytes at offset 4297041920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297046016 ++read 2048/2048 bytes at offset 4297046016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297050112 ++read 2048/2048 bytes at offset 4297050112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297054208 ++read 2048/2048 bytes at offset 4297054208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297058304 ++read 2048/2048 bytes at offset 4297058304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297062400 ++read 2048/2048 bytes at offset 4297062400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> read 2048/2048 bytes at offset 4297064448 ++=== IO: pattern 0 ++read 2048/2048 bytes at offset 4297064448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297068544 ++read 2048/2048 bytes at offset 4297068544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297072640 ++read 2048/2048 bytes at offset 4297072640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297076736 ++read 2048/2048 bytes at offset 4297076736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297080832 ++read 2048/2048 bytes at offset 4297080832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297084928 ++read 2048/2048 bytes at offset 4297084928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297089024 ++read 2048/2048 bytes at offset 4297089024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297093120 ++read 2048/2048 bytes at offset 4297093120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297097216 ++read 2048/2048 bytes at offset 4297097216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297101312 ++read 2048/2048 bytes at offset 4297101312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297105408 ++read 2048/2048 bytes at offset 4297105408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297109504 ++read 2048/2048 bytes at offset 4297109504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297113600 ++read 2048/2048 bytes at offset 4297113600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297117696 ++read 2048/2048 bytes at offset 4297117696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297121792 ++read 2048/2048 bytes at offset 4297121792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297125888 ++read 2048/2048 bytes at offset 4297125888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297129984 ++read 2048/2048 bytes at offset 4297129984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297134080 ++read 2048/2048 bytes at offset 4297134080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297138176 ++read 2048/2048 bytes at offset 4297138176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297142272 ++read 2048/2048 bytes at offset 4297142272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297146368 ++read 2048/2048 bytes at offset 4297146368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297150464 ++read 2048/2048 bytes at offset 4297150464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297154560 ++read 2048/2048 bytes at offset 4297154560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297158656 ++read 2048/2048 bytes at offset 4297158656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297162752 ++read 2048/2048 bytes at offset 4297162752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297166848 ++read 2048/2048 bytes at offset 4297166848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297170944 ++read 2048/2048 bytes at offset 4297170944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297175040 ++read 2048/2048 bytes at offset 4297175040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297179136 ++read 2048/2048 bytes at offset 4297179136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297183232 ++read 2048/2048 bytes at offset 4297183232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297187328 ++read 2048/2048 bytes at offset 4297187328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297191424 ++read 2048/2048 bytes at offset 4297191424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297195520 ++read 2048/2048 bytes at offset 4297195520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297199616 ++read 2048/2048 bytes at offset 4297199616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297203712 ++read 2048/2048 bytes at offset 4297203712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297207808 ++read 2048/2048 bytes at offset 4297207808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297211904 ++read 2048/2048 bytes at offset 4297211904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297216000 ++read 2048/2048 bytes at offset 4297216000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297220096 ++read 2048/2048 bytes at offset 4297220096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297224192 ++read 2048/2048 bytes at offset 4297224192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297228288 ++read 2048/2048 bytes at offset 4297228288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297232384 ++read 2048/2048 bytes at offset 4297232384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297236480 ++read 2048/2048 bytes at offset 4297236480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297240576 ++read 2048/2048 bytes at offset 4297240576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297244672 ++read 2048/2048 bytes at offset 4297244672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297248768 ++read 2048/2048 bytes at offset 4297248768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297252864 ++read 2048/2048 bytes at offset 4297252864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297256960 ++read 2048/2048 bytes at offset 4297256960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297261056 ++read 2048/2048 bytes at offset 4297261056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297265152 ++read 2048/2048 bytes at offset 4297265152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297269248 ++read 2048/2048 bytes at offset 4297269248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297273344 ++read 2048/2048 bytes at offset 4297273344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297277440 ++read 2048/2048 bytes at offset 4297277440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297281536 ++read 2048/2048 bytes at offset 4297281536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297285632 ++read 2048/2048 bytes at offset 4297285632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297289728 ++read 2048/2048 bytes at offset 4297289728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297293824 ++read 2048/2048 bytes at offset 4297293824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297297920 ++read 2048/2048 bytes at offset 4297297920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297302016 ++read 2048/2048 bytes at offset 4297302016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297306112 ++read 2048/2048 bytes at offset 4297306112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297310208 ++read 2048/2048 bytes at offset 4297310208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297314304 ++read 2048/2048 bytes at offset 4297314304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297318400 ++read 2048/2048 bytes at offset 4297318400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297322496 ++read 2048/2048 bytes at offset 4297322496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297326592 ++read 2048/2048 bytes at offset 4297326592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297330688 ++read 2048/2048 bytes at offset 4297330688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297334784 ++read 2048/2048 bytes at offset 4297334784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297338880 ++read 2048/2048 bytes at offset 4297338880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297342976 ++read 2048/2048 bytes at offset 4297342976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297347072 ++read 2048/2048 bytes at offset 4297347072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297351168 ++read 2048/2048 bytes at offset 4297351168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297355264 ++read 2048/2048 bytes at offset 4297355264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297359360 ++read 2048/2048 bytes at offset 4297359360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297363456 ++read 2048/2048 bytes at offset 4297363456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297367552 ++read 2048/2048 bytes at offset 4297367552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297371648 ++read 2048/2048 bytes at offset 4297371648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297375744 ++read 2048/2048 bytes at offset 4297375744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297379840 ++read 2048/2048 bytes at offset 4297379840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297383936 ++read 2048/2048 bytes at offset 4297383936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297388032 ++read 2048/2048 bytes at offset 4297388032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297392128 ++read 2048/2048 bytes at offset 4297392128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297396224 ++read 2048/2048 bytes at offset 4297396224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297400320 ++read 2048/2048 bytes at offset 4297400320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297404416 ++read 2048/2048 bytes at offset 4297404416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297408512 ++read 2048/2048 bytes at offset 4297408512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297412608 ++read 2048/2048 bytes at offset 4297412608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297416704 ++read 2048/2048 bytes at offset 4297416704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297420800 ++read 2048/2048 bytes at offset 4297420800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297424896 ++read 2048/2048 bytes at offset 4297424896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297428992 ++read 2048/2048 bytes at offset 4297428992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297433088 ++read 2048/2048 bytes at offset 4297433088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297437184 ++read 2048/2048 bytes at offset 4297437184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297441280 ++read 2048/2048 bytes at offset 4297441280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297445376 ++read 2048/2048 bytes at offset 4297445376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297449472 ++read 2048/2048 bytes at offset 4297449472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297453568 ++read 2048/2048 bytes at offset 4297453568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297457664 ++read 2048/2048 bytes at offset 4297457664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297461760 ++read 2048/2048 bytes at offset 4297461760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297465856 ++read 2048/2048 bytes at offset 4297465856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297469952 ++read 2048/2048 bytes at offset 4297469952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297474048 ++read 2048/2048 bytes at offset 4297474048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297478144 ++read 2048/2048 bytes at offset 4297478144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297482240 ++read 2048/2048 bytes at offset 4297482240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297486336 ++read 2048/2048 bytes at offset 4297486336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297490432 ++read 2048/2048 bytes at offset 4297490432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297494528 ++read 2048/2048 bytes at offset 4297494528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297498624 ++read 2048/2048 bytes at offset 4297498624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297502720 ++read 2048/2048 bytes at offset 4297502720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297506816 ++read 2048/2048 bytes at offset 4297506816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297510912 ++read 2048/2048 bytes at offset 4297510912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297515008 ++read 2048/2048 bytes at offset 4297515008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297519104 ++read 2048/2048 bytes at offset 4297519104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297523200 ++read 2048/2048 bytes at offset 4297523200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297527296 ++read 2048/2048 bytes at offset 4297527296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297531392 ++read 2048/2048 bytes at offset 4297531392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297535488 ++read 2048/2048 bytes at offset 4297535488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297539584 ++read 2048/2048 bytes at offset 4297539584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297543680 ++read 2048/2048 bytes at offset 4297543680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297547776 ++read 2048/2048 bytes at offset 4297547776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297551872 ++read 2048/2048 bytes at offset 4297551872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297555968 ++read 2048/2048 bytes at offset 4297555968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297560064 ++read 2048/2048 bytes at offset 4297560064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297564160 ++read 2048/2048 bytes at offset 4297564160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297568256 ++read 2048/2048 bytes at offset 4297568256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297572352 ++read 2048/2048 bytes at offset 4297572352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297576448 ++read 2048/2048 bytes at offset 4297576448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297580544 ++read 2048/2048 bytes at offset 4297580544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297584640 ++read 2048/2048 bytes at offset 4297584640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297588736 ++read 2048/2048 bytes at offset 4297588736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297592832 ++read 2048/2048 bytes at offset 4297592832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297596928 ++read 2048/2048 bytes at offset 4297596928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297601024 ++read 2048/2048 bytes at offset 4297601024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297605120 ++read 2048/2048 bytes at offset 4297605120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297609216 ++read 2048/2048 bytes at offset 4297609216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297613312 ++read 2048/2048 bytes at offset 4297613312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297617408 ++read 2048/2048 bytes at offset 4297617408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297621504 ++read 2048/2048 bytes at offset 4297621504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297625600 ++read 2048/2048 bytes at offset 4297625600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297629696 ++read 2048/2048 bytes at offset 4297629696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297633792 ++read 2048/2048 bytes at offset 4297633792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297637888 ++read 2048/2048 bytes at offset 4297637888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297641984 ++read 2048/2048 bytes at offset 4297641984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297646080 ++read 2048/2048 bytes at offset 4297646080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297650176 ++read 2048/2048 bytes at offset 4297650176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297654272 ++read 2048/2048 bytes at offset 4297654272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297658368 ++read 2048/2048 bytes at offset 4297658368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297662464 ++read 2048/2048 bytes at offset 4297662464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297666560 ++read 2048/2048 bytes at offset 4297666560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297670656 ++read 2048/2048 bytes at offset 4297670656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297674752 ++read 2048/2048 bytes at offset 4297674752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297678848 ++read 2048/2048 bytes at offset 4297678848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297682944 ++read 2048/2048 bytes at offset 4297682944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297687040 ++read 2048/2048 bytes at offset 4297687040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297691136 ++read 2048/2048 bytes at offset 4297691136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297695232 ++read 2048/2048 bytes at offset 4297695232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297699328 ++read 2048/2048 bytes at offset 4297699328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297703424 ++read 2048/2048 bytes at offset 4297703424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297707520 ++read 2048/2048 bytes at offset 4297707520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297711616 ++read 2048/2048 bytes at offset 4297711616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297715712 ++read 2048/2048 bytes at offset 4297715712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297719808 ++read 2048/2048 bytes at offset 4297719808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297723904 ++read 2048/2048 bytes at offset 4297723904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297728000 ++read 2048/2048 bytes at offset 4297728000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297732096 ++read 2048/2048 bytes at offset 4297732096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297736192 ++read 2048/2048 bytes at offset 4297736192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297740288 ++read 2048/2048 bytes at offset 4297740288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297744384 ++read 2048/2048 bytes at offset 4297744384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297748480 ++read 2048/2048 bytes at offset 4297748480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297752576 ++read 2048/2048 bytes at offset 4297752576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297756672 ++read 2048/2048 bytes at offset 4297756672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297760768 ++read 2048/2048 bytes at offset 4297760768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297764864 ++read 2048/2048 bytes at offset 4297764864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297768960 ++read 2048/2048 bytes at offset 4297768960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297773056 ++read 2048/2048 bytes at offset 4297773056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297777152 ++read 2048/2048 bytes at offset 4297777152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297781248 ++read 2048/2048 bytes at offset 4297781248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297785344 ++read 2048/2048 bytes at offset 4297785344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297789440 ++read 2048/2048 bytes at offset 4297789440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297793536 ++read 2048/2048 bytes at offset 4297793536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297797632 ++read 2048/2048 bytes at offset 4297797632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297801728 ++read 2048/2048 bytes at offset 4297801728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297805824 ++read 2048/2048 bytes at offset 4297805824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297809920 ++read 2048/2048 bytes at offset 4297809920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297814016 ++read 2048/2048 bytes at offset 4297814016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297818112 ++read 2048/2048 bytes at offset 4297818112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297822208 ++read 2048/2048 bytes at offset 4297822208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297826304 ++read 2048/2048 bytes at offset 4297826304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297830400 ++read 2048/2048 bytes at offset 4297830400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297834496 ++read 2048/2048 bytes at offset 4297834496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297838592 ++read 2048/2048 bytes at offset 4297838592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297842688 ++read 2048/2048 bytes at offset 4297842688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297846784 ++read 2048/2048 bytes at offset 4297846784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297850880 ++read 2048/2048 bytes at offset 4297850880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297854976 ++read 2048/2048 bytes at offset 4297854976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297859072 ++read 2048/2048 bytes at offset 4297859072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297863168 ++read 2048/2048 bytes at offset 4297863168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297867264 ++read 2048/2048 bytes at offset 4297867264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297871360 ++read 2048/2048 bytes at offset 4297871360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297875456 ++read 2048/2048 bytes at offset 4297875456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297879552 ++read 2048/2048 bytes at offset 4297879552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297883648 ++read 2048/2048 bytes at offset 4297883648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297887744 ++read 2048/2048 bytes at offset 4297887744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297891840 ++read 2048/2048 bytes at offset 4297891840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297895936 ++read 2048/2048 bytes at offset 4297895936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297900032 ++read 2048/2048 bytes at offset 4297900032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297904128 ++read 2048/2048 bytes at offset 4297904128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297908224 ++read 2048/2048 bytes at offset 4297908224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297912320 ++read 2048/2048 bytes at offset 4297912320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297916416 ++read 2048/2048 bytes at offset 4297916416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297920512 ++read 2048/2048 bytes at offset 4297920512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297924608 ++read 2048/2048 bytes at offset 4297924608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297928704 ++read 2048/2048 bytes at offset 4297928704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297932800 ++read 2048/2048 bytes at offset 4297932800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297936896 ++read 2048/2048 bytes at offset 4297936896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297940992 ++read 2048/2048 bytes at offset 4297940992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297945088 ++read 2048/2048 bytes at offset 4297945088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297949184 ++read 2048/2048 bytes at offset 4297949184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297953280 ++read 2048/2048 bytes at offset 4297953280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297957376 ++read 2048/2048 bytes at offset 4297957376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297961472 ++read 2048/2048 bytes at offset 4297961472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297965568 ++read 2048/2048 bytes at offset 4297965568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297969664 ++read 2048/2048 bytes at offset 4297969664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297973760 ++read 2048/2048 bytes at offset 4297973760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297977856 ++read 2048/2048 bytes at offset 4297977856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297981952 ++read 2048/2048 bytes at offset 4297981952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297986048 ++read 2048/2048 bytes at offset 4297986048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297990144 ++read 2048/2048 bytes at offset 4297990144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297994240 ++read 2048/2048 bytes at offset 4297994240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297998336 ++read 2048/2048 bytes at offset 4297998336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298002432 ++read 2048/2048 bytes at offset 4298002432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298006528 ++read 2048/2048 bytes at offset 4298006528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298010624 ++read 2048/2048 bytes at offset 4298010624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298014720 ++read 2048/2048 bytes at offset 4298014720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298018816 ++read 2048/2048 bytes at offset 4298018816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298022912 ++read 2048/2048 bytes at offset 4298022912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298027008 ++read 2048/2048 bytes at offset 4298027008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298031104 ++read 2048/2048 bytes at offset 4298031104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298035200 ++read 2048/2048 bytes at offset 4298035200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298039296 ++read 2048/2048 bytes at offset 4298039296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298043392 ++read 2048/2048 bytes at offset 4298043392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298047488 ++read 2048/2048 bytes at offset 4298047488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298051584 ++read 2048/2048 bytes at offset 4298051584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298055680 ++read 2048/2048 bytes at offset 4298055680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298059776 ++read 2048/2048 bytes at offset 4298059776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298063872 ++read 2048/2048 bytes at offset 4298063872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298067968 ++read 2048/2048 bytes at offset 4298067968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298072064 ++read 2048/2048 bytes at offset 4298072064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298076160 ++read 2048/2048 bytes at offset 4298076160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298080256 ++read 2048/2048 bytes at offset 4298080256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298084352 ++read 2048/2048 bytes at offset 4298084352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298088448 ++read 2048/2048 bytes at offset 4298088448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298092544 ++read 2048/2048 bytes at offset 4298092544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298096640 ++read 2048/2048 bytes at offset 4298096640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298100736 ++read 2048/2048 bytes at offset 4298100736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298104832 ++read 2048/2048 bytes at offset 4298104832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298108928 ++read 2048/2048 bytes at offset 4298108928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 2 +-qemu-io> read 2048/2048 bytes at offset 4298114048 ++=== IO: pattern 2 ++read 2048/2048 bytes at offset 4298114048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298118144 ++read 2048/2048 bytes at offset 4298118144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298122240 ++read 2048/2048 bytes at offset 4298122240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298126336 ++read 2048/2048 bytes at offset 4298126336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298130432 ++read 2048/2048 bytes at offset 4298130432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298134528 ++read 2048/2048 bytes at offset 4298134528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298138624 ++read 2048/2048 bytes at offset 4298138624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298142720 ++read 2048/2048 bytes at offset 4298142720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298146816 ++read 2048/2048 bytes at offset 4298146816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298150912 ++read 2048/2048 bytes at offset 4298150912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298155008 ++read 2048/2048 bytes at offset 4298155008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298159104 ++read 2048/2048 bytes at offset 4298159104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298163200 ++read 2048/2048 bytes at offset 4298163200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298167296 ++read 2048/2048 bytes at offset 4298167296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298171392 ++read 2048/2048 bytes at offset 4298171392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298175488 ++read 2048/2048 bytes at offset 4298175488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298179584 ++read 2048/2048 bytes at offset 4298179584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298183680 ++read 2048/2048 bytes at offset 4298183680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298187776 ++read 2048/2048 bytes at offset 4298187776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298191872 ++read 2048/2048 bytes at offset 4298191872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298195968 ++read 2048/2048 bytes at offset 4298195968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298200064 ++read 2048/2048 bytes at offset 4298200064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298204160 ++read 2048/2048 bytes at offset 4298204160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298208256 ++read 2048/2048 bytes at offset 4298208256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298212352 ++read 2048/2048 bytes at offset 4298212352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298216448 ++read 2048/2048 bytes at offset 4298216448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298220544 ++read 2048/2048 bytes at offset 4298220544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298224640 ++read 2048/2048 bytes at offset 4298224640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298228736 ++read 2048/2048 bytes at offset 4298228736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298232832 ++read 2048/2048 bytes at offset 4298232832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298236928 ++read 2048/2048 bytes at offset 4298236928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298241024 ++read 2048/2048 bytes at offset 4298241024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298245120 ++read 2048/2048 bytes at offset 4298245120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298249216 ++read 2048/2048 bytes at offset 4298249216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298253312 ++read 2048/2048 bytes at offset 4298253312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298257408 ++read 2048/2048 bytes at offset 4298257408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298261504 ++read 2048/2048 bytes at offset 4298261504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298265600 ++read 2048/2048 bytes at offset 4298265600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298269696 ++read 2048/2048 bytes at offset 4298269696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298273792 ++read 2048/2048 bytes at offset 4298273792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298277888 ++read 2048/2048 bytes at offset 4298277888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298281984 ++read 2048/2048 bytes at offset 4298281984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298286080 ++read 2048/2048 bytes at offset 4298286080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298290176 ++read 2048/2048 bytes at offset 4298290176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298294272 ++read 2048/2048 bytes at offset 4298294272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298298368 ++read 2048/2048 bytes at offset 4298298368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298302464 ++read 2048/2048 bytes at offset 4298302464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298306560 ++read 2048/2048 bytes at offset 4298306560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298310656 ++read 2048/2048 bytes at offset 4298310656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298314752 ++read 2048/2048 bytes at offset 4298314752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298318848 ++read 2048/2048 bytes at offset 4298318848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298322944 ++read 2048/2048 bytes at offset 4298322944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298327040 ++read 2048/2048 bytes at offset 4298327040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298331136 ++read 2048/2048 bytes at offset 4298331136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298335232 ++read 2048/2048 bytes at offset 4298335232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298339328 ++read 2048/2048 bytes at offset 4298339328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298343424 ++read 2048/2048 bytes at offset 4298343424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298347520 ++read 2048/2048 bytes at offset 4298347520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298351616 ++read 2048/2048 bytes at offset 4298351616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298355712 ++read 2048/2048 bytes at offset 4298355712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298359808 ++read 2048/2048 bytes at offset 4298359808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298363904 ++read 2048/2048 bytes at offset 4298363904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298368000 ++read 2048/2048 bytes at offset 4298368000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298372096 ++read 2048/2048 bytes at offset 4298372096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298376192 ++read 2048/2048 bytes at offset 4298376192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298380288 ++read 2048/2048 bytes at offset 4298380288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298384384 ++read 2048/2048 bytes at offset 4298384384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298388480 ++read 2048/2048 bytes at offset 4298388480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298392576 ++read 2048/2048 bytes at offset 4298392576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298396672 ++read 2048/2048 bytes at offset 4298396672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298400768 ++read 2048/2048 bytes at offset 4298400768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298404864 ++read 2048/2048 bytes at offset 4298404864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298408960 ++read 2048/2048 bytes at offset 4298408960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298413056 ++read 2048/2048 bytes at offset 4298413056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298417152 ++read 2048/2048 bytes at offset 4298417152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298421248 ++read 2048/2048 bytes at offset 4298421248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298425344 ++read 2048/2048 bytes at offset 4298425344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298429440 ++read 2048/2048 bytes at offset 4298429440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298433536 ++read 2048/2048 bytes at offset 4298433536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298437632 ++read 2048/2048 bytes at offset 4298437632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298441728 ++read 2048/2048 bytes at offset 4298441728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298445824 ++read 2048/2048 bytes at offset 4298445824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298449920 ++read 2048/2048 bytes at offset 4298449920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298454016 ++read 2048/2048 bytes at offset 4298454016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298458112 ++read 2048/2048 bytes at offset 4298458112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298462208 ++read 2048/2048 bytes at offset 4298462208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298466304 ++read 2048/2048 bytes at offset 4298466304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298470400 ++read 2048/2048 bytes at offset 4298470400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298474496 ++read 2048/2048 bytes at offset 4298474496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298478592 ++read 2048/2048 bytes at offset 4298478592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298482688 ++read 2048/2048 bytes at offset 4298482688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298486784 ++read 2048/2048 bytes at offset 4298486784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298490880 ++read 2048/2048 bytes at offset 4298490880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298494976 ++read 2048/2048 bytes at offset 4298494976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298499072 ++read 2048/2048 bytes at offset 4298499072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298503168 ++read 2048/2048 bytes at offset 4298503168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298507264 ++read 2048/2048 bytes at offset 4298507264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298511360 ++read 2048/2048 bytes at offset 4298511360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298515456 ++read 2048/2048 bytes at offset 4298515456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298519552 ++read 2048/2048 bytes at offset 4298519552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298523648 ++read 2048/2048 bytes at offset 4298523648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298527744 ++read 2048/2048 bytes at offset 4298527744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298531840 ++read 2048/2048 bytes at offset 4298531840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298535936 ++read 2048/2048 bytes at offset 4298535936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298540032 ++read 2048/2048 bytes at offset 4298540032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298544128 ++read 2048/2048 bytes at offset 4298544128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298548224 ++read 2048/2048 bytes at offset 4298548224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298552320 ++read 2048/2048 bytes at offset 4298552320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298556416 ++read 2048/2048 bytes at offset 4298556416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298560512 ++read 2048/2048 bytes at offset 4298560512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298564608 ++read 2048/2048 bytes at offset 4298564608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298568704 ++read 2048/2048 bytes at offset 4298568704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298572800 ++read 2048/2048 bytes at offset 4298572800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298576896 ++read 2048/2048 bytes at offset 4298576896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298580992 ++read 2048/2048 bytes at offset 4298580992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298585088 ++read 2048/2048 bytes at offset 4298585088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298589184 ++read 2048/2048 bytes at offset 4298589184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298593280 ++read 2048/2048 bytes at offset 4298593280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298597376 ++read 2048/2048 bytes at offset 4298597376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298601472 ++read 2048/2048 bytes at offset 4298601472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298605568 ++read 2048/2048 bytes at offset 4298605568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298609664 ++read 2048/2048 bytes at offset 4298609664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298613760 ++read 2048/2048 bytes at offset 4298613760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298617856 ++read 2048/2048 bytes at offset 4298617856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298621952 ++read 2048/2048 bytes at offset 4298621952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298626048 ++read 2048/2048 bytes at offset 4298626048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298630144 ++read 2048/2048 bytes at offset 4298630144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298634240 ++read 2048/2048 bytes at offset 4298634240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298638336 ++read 2048/2048 bytes at offset 4298638336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298642432 ++read 2048/2048 bytes at offset 4298642432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298646528 ++read 2048/2048 bytes at offset 4298646528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298650624 ++read 2048/2048 bytes at offset 4298650624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298654720 ++read 2048/2048 bytes at offset 4298654720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298658816 ++read 2048/2048 bytes at offset 4298658816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298662912 ++read 2048/2048 bytes at offset 4298662912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298667008 ++read 2048/2048 bytes at offset 4298667008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298671104 ++read 2048/2048 bytes at offset 4298671104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298675200 ++read 2048/2048 bytes at offset 4298675200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298679296 ++read 2048/2048 bytes at offset 4298679296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298683392 ++read 2048/2048 bytes at offset 4298683392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298687488 ++read 2048/2048 bytes at offset 4298687488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298691584 ++read 2048/2048 bytes at offset 4298691584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298695680 ++read 2048/2048 bytes at offset 4298695680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298699776 ++read 2048/2048 bytes at offset 4298699776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298703872 ++read 2048/2048 bytes at offset 4298703872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298707968 ++read 2048/2048 bytes at offset 4298707968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298712064 ++read 2048/2048 bytes at offset 4298712064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298716160 ++read 2048/2048 bytes at offset 4298716160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298720256 ++read 2048/2048 bytes at offset 4298720256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298724352 ++read 2048/2048 bytes at offset 4298724352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298728448 ++read 2048/2048 bytes at offset 4298728448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298732544 ++read 2048/2048 bytes at offset 4298732544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298736640 ++read 2048/2048 bytes at offset 4298736640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298740736 ++read 2048/2048 bytes at offset 4298740736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298744832 ++read 2048/2048 bytes at offset 4298744832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298748928 ++read 2048/2048 bytes at offset 4298748928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298753024 ++read 2048/2048 bytes at offset 4298753024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298757120 ++read 2048/2048 bytes at offset 4298757120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298761216 ++read 2048/2048 bytes at offset 4298761216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298765312 ++read 2048/2048 bytes at offset 4298765312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298769408 ++read 2048/2048 bytes at offset 4298769408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298773504 ++read 2048/2048 bytes at offset 4298773504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298777600 ++read 2048/2048 bytes at offset 4298777600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298781696 ++read 2048/2048 bytes at offset 4298781696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298785792 ++read 2048/2048 bytes at offset 4298785792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298789888 ++read 2048/2048 bytes at offset 4298789888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298793984 ++read 2048/2048 bytes at offset 4298793984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298798080 ++read 2048/2048 bytes at offset 4298798080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298802176 ++read 2048/2048 bytes at offset 4298802176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298806272 ++read 2048/2048 bytes at offset 4298806272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298810368 ++read 2048/2048 bytes at offset 4298810368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298814464 ++read 2048/2048 bytes at offset 4298814464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298818560 ++read 2048/2048 bytes at offset 4298818560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298822656 ++read 2048/2048 bytes at offset 4298822656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298826752 ++read 2048/2048 bytes at offset 4298826752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298830848 ++read 2048/2048 bytes at offset 4298830848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298834944 ++read 2048/2048 bytes at offset 4298834944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298839040 ++read 2048/2048 bytes at offset 4298839040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298843136 ++read 2048/2048 bytes at offset 4298843136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298847232 ++read 2048/2048 bytes at offset 4298847232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298851328 ++read 2048/2048 bytes at offset 4298851328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298855424 ++read 2048/2048 bytes at offset 4298855424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298859520 ++read 2048/2048 bytes at offset 4298859520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298863616 ++read 2048/2048 bytes at offset 4298863616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298867712 ++read 2048/2048 bytes at offset 4298867712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298871808 ++read 2048/2048 bytes at offset 4298871808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298875904 ++read 2048/2048 bytes at offset 4298875904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298880000 ++read 2048/2048 bytes at offset 4298880000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298884096 ++read 2048/2048 bytes at offset 4298884096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298888192 ++read 2048/2048 bytes at offset 4298888192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298892288 ++read 2048/2048 bytes at offset 4298892288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298896384 ++read 2048/2048 bytes at offset 4298896384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298900480 ++read 2048/2048 bytes at offset 4298900480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298904576 ++read 2048/2048 bytes at offset 4298904576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298908672 ++read 2048/2048 bytes at offset 4298908672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298912768 ++read 2048/2048 bytes at offset 4298912768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298916864 ++read 2048/2048 bytes at offset 4298916864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298920960 ++read 2048/2048 bytes at offset 4298920960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298925056 ++read 2048/2048 bytes at offset 4298925056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298929152 ++read 2048/2048 bytes at offset 4298929152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298933248 ++read 2048/2048 bytes at offset 4298933248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298937344 ++read 2048/2048 bytes at offset 4298937344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298941440 ++read 2048/2048 bytes at offset 4298941440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298945536 ++read 2048/2048 bytes at offset 4298945536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298949632 ++read 2048/2048 bytes at offset 4298949632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298953728 ++read 2048/2048 bytes at offset 4298953728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298957824 ++read 2048/2048 bytes at offset 4298957824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298961920 ++read 2048/2048 bytes at offset 4298961920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298966016 ++read 2048/2048 bytes at offset 4298966016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298970112 ++read 2048/2048 bytes at offset 4298970112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298974208 ++read 2048/2048 bytes at offset 4298974208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298978304 ++read 2048/2048 bytes at offset 4298978304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298982400 ++read 2048/2048 bytes at offset 4298982400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298986496 ++read 2048/2048 bytes at offset 4298986496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298990592 ++read 2048/2048 bytes at offset 4298990592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298994688 ++read 2048/2048 bytes at offset 4298994688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298998784 ++read 2048/2048 bytes at offset 4298998784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299002880 ++read 2048/2048 bytes at offset 4299002880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299006976 ++read 2048/2048 bytes at offset 4299006976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299011072 ++read 2048/2048 bytes at offset 4299011072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299015168 ++read 2048/2048 bytes at offset 4299015168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299019264 ++read 2048/2048 bytes at offset 4299019264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299023360 ++read 2048/2048 bytes at offset 4299023360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299027456 ++read 2048/2048 bytes at offset 4299027456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299031552 ++read 2048/2048 bytes at offset 4299031552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299035648 ++read 2048/2048 bytes at offset 4299035648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299039744 ++read 2048/2048 bytes at offset 4299039744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299043840 ++read 2048/2048 bytes at offset 4299043840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299047936 ++read 2048/2048 bytes at offset 4299047936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299052032 ++read 2048/2048 bytes at offset 4299052032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299056128 ++read 2048/2048 bytes at offset 4299056128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299060224 ++read 2048/2048 bytes at offset 4299060224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299064320 ++read 2048/2048 bytes at offset 4299064320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299068416 ++read 2048/2048 bytes at offset 4299068416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299072512 ++read 2048/2048 bytes at offset 4299072512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299076608 ++read 2048/2048 bytes at offset 4299076608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299080704 ++read 2048/2048 bytes at offset 4299080704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299084800 ++read 2048/2048 bytes at offset 4299084800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299088896 ++read 2048/2048 bytes at offset 4299088896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299092992 ++read 2048/2048 bytes at offset 4299092992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299097088 ++read 2048/2048 bytes at offset 4299097088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299101184 ++read 2048/2048 bytes at offset 4299101184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299105280 ++read 2048/2048 bytes at offset 4299105280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299109376 ++read 2048/2048 bytes at offset 4299109376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299113472 ++read 2048/2048 bytes at offset 4299113472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299117568 ++read 2048/2048 bytes at offset 4299117568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299121664 ++read 2048/2048 bytes at offset 4299121664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299125760 ++read 2048/2048 bytes at offset 4299125760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299129856 ++read 2048/2048 bytes at offset 4299129856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299133952 ++read 2048/2048 bytes at offset 4299133952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299138048 ++read 2048/2048 bytes at offset 4299138048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299142144 ++read 2048/2048 bytes at offset 4299142144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299146240 ++read 2048/2048 bytes at offset 4299146240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299150336 ++read 2048/2048 bytes at offset 4299150336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299154432 ++read 2048/2048 bytes at offset 4299154432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299158528 ++read 2048/2048 bytes at offset 4299158528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 4 +-qemu-io> read 8192/8192 bytes at offset 4299163648 ++=== IO: pattern 4 ++read 8192/8192 bytes at offset 4299163648 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299175936 ++read 8192/8192 bytes at offset 4299175936 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299188224 ++read 8192/8192 bytes at offset 4299188224 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299200512 ++read 8192/8192 bytes at offset 4299200512 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299212800 ++read 8192/8192 bytes at offset 4299212800 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299225088 ++read 8192/8192 bytes at offset 4299225088 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299237376 ++read 8192/8192 bytes at offset 4299237376 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299249664 ++read 8192/8192 bytes at offset 4299249664 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299261952 ++read 8192/8192 bytes at offset 4299261952 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299274240 ++read 8192/8192 bytes at offset 4299274240 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299286528 ++read 8192/8192 bytes at offset 4299286528 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299298816 ++read 8192/8192 bytes at offset 4299298816 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299311104 ++read 8192/8192 bytes at offset 4299311104 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299323392 ++read 8192/8192 bytes at offset 4299323392 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299335680 ++read 8192/8192 bytes at offset 4299335680 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299347968 ++read 8192/8192 bytes at offset 4299347968 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299360256 ++read 8192/8192 bytes at offset 4299360256 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299372544 ++read 8192/8192 bytes at offset 4299372544 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299384832 ++read 8192/8192 bytes at offset 4299384832 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299397120 ++read 8192/8192 bytes at offset 4299397120 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299409408 ++read 8192/8192 bytes at offset 4299409408 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299421696 ++read 8192/8192 bytes at offset 4299421696 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299433984 ++read 8192/8192 bytes at offset 4299433984 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299446272 ++read 8192/8192 bytes at offset 4299446272 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299458560 ++read 8192/8192 bytes at offset 4299458560 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299470848 ++read 8192/8192 bytes at offset 4299470848 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299483136 ++read 8192/8192 bytes at offset 4299483136 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299495424 ++read 8192/8192 bytes at offset 4299495424 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299507712 ++read 8192/8192 bytes at offset 4299507712 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299520000 ++read 8192/8192 bytes at offset 4299520000 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299532288 ++read 8192/8192 bytes at offset 4299532288 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299544576 ++read 8192/8192 bytes at offset 4299544576 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299556864 ++read 8192/8192 bytes at offset 4299556864 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299569152 ++read 8192/8192 bytes at offset 4299569152 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299581440 ++read 8192/8192 bytes at offset 4299581440 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299593728 ++read 8192/8192 bytes at offset 4299593728 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299606016 ++read 8192/8192 bytes at offset 4299606016 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299618304 ++read 8192/8192 bytes at offset 4299618304 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299630592 ++read 8192/8192 bytes at offset 4299630592 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299642880 ++read 8192/8192 bytes at offset 4299642880 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299655168 ++read 8192/8192 bytes at offset 4299655168 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299667456 ++read 8192/8192 bytes at offset 4299667456 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299679744 ++read 8192/8192 bytes at offset 4299679744 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299692032 ++read 8192/8192 bytes at offset 4299692032 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299704320 ++read 8192/8192 bytes at offset 4299704320 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299716608 ++read 8192/8192 bytes at offset 4299716608 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299728896 ++read 8192/8192 bytes at offset 4299728896 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299741184 ++read 8192/8192 bytes at offset 4299741184 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299753472 ++read 8192/8192 bytes at offset 4299753472 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299765760 ++read 8192/8192 bytes at offset 4299765760 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299778048 ++read 8192/8192 bytes at offset 4299778048 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299790336 ++read 8192/8192 bytes at offset 4299790336 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299802624 ++read 8192/8192 bytes at offset 4299802624 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299814912 ++read 8192/8192 bytes at offset 4299814912 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299827200 ++read 8192/8192 bytes at offset 4299827200 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299839488 ++read 8192/8192 bytes at offset 4299839488 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299851776 ++read 8192/8192 bytes at offset 4299851776 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299864064 ++read 8192/8192 bytes at offset 4299864064 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299876352 ++read 8192/8192 bytes at offset 4299876352 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299888640 ++read 8192/8192 bytes at offset 4299888640 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299900928 ++read 8192/8192 bytes at offset 4299900928 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299913216 ++read 8192/8192 bytes at offset 4299913216 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299925504 ++read 8192/8192 bytes at offset 4299925504 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299937792 ++read 8192/8192 bytes at offset 4299937792 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 244 +-qemu-io> read 12288/12288 bytes at offset 4301252608 ++=== IO: pattern 244 ++read 12288/12288 bytes at offset 4301252608 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4303351808 ++read 12288/12288 bytes at offset 4303351808 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4305451008 ++read 12288/12288 bytes at offset 4305451008 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4307550208 ++read 12288/12288 bytes at offset 4307550208 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4309649408 ++read 12288/12288 bytes at offset 4309649408 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4311748608 ++read 12288/12288 bytes at offset 4311748608 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4313847808 ++read 12288/12288 bytes at offset 4313847808 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4315947008 ++read 12288/12288 bytes at offset 4315947008 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> wrote 4096/4096 bytes at offset 4294967296 ++=== IO: pattern 0 ++wrote 4096/4096 bytes at offset 4294967296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4294971392 ++wrote 4096/4096 bytes at offset 4294971392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4294975488 ++wrote 4096/4096 bytes at offset 4294975488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4294979584 ++wrote 4096/4096 bytes at offset 4294979584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4294983680 ++wrote 4096/4096 bytes at offset 4294983680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4294987776 ++wrote 4096/4096 bytes at offset 4294987776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4294991872 ++wrote 4096/4096 bytes at offset 4294991872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4294995968 ++wrote 4096/4096 bytes at offset 4294995968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295000064 ++wrote 4096/4096 bytes at offset 4295000064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295004160 ++wrote 4096/4096 bytes at offset 4295004160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295008256 ++wrote 4096/4096 bytes at offset 4295008256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295012352 ++wrote 4096/4096 bytes at offset 4295012352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295016448 ++wrote 4096/4096 bytes at offset 4295016448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295020544 ++wrote 4096/4096 bytes at offset 4295020544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295024640 ++wrote 4096/4096 bytes at offset 4295024640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295028736 ++wrote 4096/4096 bytes at offset 4295028736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295032832 ++wrote 4096/4096 bytes at offset 4295032832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295036928 ++wrote 4096/4096 bytes at offset 4295036928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295041024 ++wrote 4096/4096 bytes at offset 4295041024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295045120 ++wrote 4096/4096 bytes at offset 4295045120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295049216 ++wrote 4096/4096 bytes at offset 4295049216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295053312 ++wrote 4096/4096 bytes at offset 4295053312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295057408 ++wrote 4096/4096 bytes at offset 4295057408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295061504 ++wrote 4096/4096 bytes at offset 4295061504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295065600 ++wrote 4096/4096 bytes at offset 4295065600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295069696 ++wrote 4096/4096 bytes at offset 4295069696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295073792 ++wrote 4096/4096 bytes at offset 4295073792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295077888 ++wrote 4096/4096 bytes at offset 4295077888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295081984 ++wrote 4096/4096 bytes at offset 4295081984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295086080 ++wrote 4096/4096 bytes at offset 4295086080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295090176 ++wrote 4096/4096 bytes at offset 4295090176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295094272 ++wrote 4096/4096 bytes at offset 4295094272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295098368 ++wrote 4096/4096 bytes at offset 4295098368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295102464 ++wrote 4096/4096 bytes at offset 4295102464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295106560 ++wrote 4096/4096 bytes at offset 4295106560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295110656 ++wrote 4096/4096 bytes at offset 4295110656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295114752 ++wrote 4096/4096 bytes at offset 4295114752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295118848 ++wrote 4096/4096 bytes at offset 4295118848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295122944 ++wrote 4096/4096 bytes at offset 4295122944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295127040 ++wrote 4096/4096 bytes at offset 4295127040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295131136 ++wrote 4096/4096 bytes at offset 4295131136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295135232 ++wrote 4096/4096 bytes at offset 4295135232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295139328 ++wrote 4096/4096 bytes at offset 4295139328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295143424 ++wrote 4096/4096 bytes at offset 4295143424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295147520 ++wrote 4096/4096 bytes at offset 4295147520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295151616 ++wrote 4096/4096 bytes at offset 4295151616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295155712 ++wrote 4096/4096 bytes at offset 4295155712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295159808 ++wrote 4096/4096 bytes at offset 4295159808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295163904 ++wrote 4096/4096 bytes at offset 4295163904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295168000 ++wrote 4096/4096 bytes at offset 4295168000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295172096 ++wrote 4096/4096 bytes at offset 4295172096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295176192 ++wrote 4096/4096 bytes at offset 4295176192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295180288 ++wrote 4096/4096 bytes at offset 4295180288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295184384 ++wrote 4096/4096 bytes at offset 4295184384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295188480 ++wrote 4096/4096 bytes at offset 4295188480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295192576 ++wrote 4096/4096 bytes at offset 4295192576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295196672 ++wrote 4096/4096 bytes at offset 4295196672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295200768 ++wrote 4096/4096 bytes at offset 4295200768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295204864 ++wrote 4096/4096 bytes at offset 4295204864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295208960 ++wrote 4096/4096 bytes at offset 4295208960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295213056 ++wrote 4096/4096 bytes at offset 4295213056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295217152 ++wrote 4096/4096 bytes at offset 4295217152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295221248 ++wrote 4096/4096 bytes at offset 4295221248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295225344 ++wrote 4096/4096 bytes at offset 4295225344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295229440 ++wrote 4096/4096 bytes at offset 4295229440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295233536 ++wrote 4096/4096 bytes at offset 4295233536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295237632 ++wrote 4096/4096 bytes at offset 4295237632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295241728 ++wrote 4096/4096 bytes at offset 4295241728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295245824 ++wrote 4096/4096 bytes at offset 4295245824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295249920 ++wrote 4096/4096 bytes at offset 4295249920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295254016 ++wrote 4096/4096 bytes at offset 4295254016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295258112 ++wrote 4096/4096 bytes at offset 4295258112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295262208 ++wrote 4096/4096 bytes at offset 4295262208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295266304 ++wrote 4096/4096 bytes at offset 4295266304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295270400 ++wrote 4096/4096 bytes at offset 4295270400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295274496 ++wrote 4096/4096 bytes at offset 4295274496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295278592 ++wrote 4096/4096 bytes at offset 4295278592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295282688 ++wrote 4096/4096 bytes at offset 4295282688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295286784 ++wrote 4096/4096 bytes at offset 4295286784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295290880 ++wrote 4096/4096 bytes at offset 4295290880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295294976 ++wrote 4096/4096 bytes at offset 4295294976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295299072 ++wrote 4096/4096 bytes at offset 4295299072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295303168 ++wrote 4096/4096 bytes at offset 4295303168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295307264 ++wrote 4096/4096 bytes at offset 4295307264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295311360 ++wrote 4096/4096 bytes at offset 4295311360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295315456 ++wrote 4096/4096 bytes at offset 4295315456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295319552 ++wrote 4096/4096 bytes at offset 4295319552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295323648 ++wrote 4096/4096 bytes at offset 4295323648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295327744 ++wrote 4096/4096 bytes at offset 4295327744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295331840 ++wrote 4096/4096 bytes at offset 4295331840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295335936 ++wrote 4096/4096 bytes at offset 4295335936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295340032 ++wrote 4096/4096 bytes at offset 4295340032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295344128 ++wrote 4096/4096 bytes at offset 4295344128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295348224 ++wrote 4096/4096 bytes at offset 4295348224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295352320 ++wrote 4096/4096 bytes at offset 4295352320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295356416 ++wrote 4096/4096 bytes at offset 4295356416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295360512 ++wrote 4096/4096 bytes at offset 4295360512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295364608 ++wrote 4096/4096 bytes at offset 4295364608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295368704 ++wrote 4096/4096 bytes at offset 4295368704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295372800 ++wrote 4096/4096 bytes at offset 4295372800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295376896 ++wrote 4096/4096 bytes at offset 4295376896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295380992 ++wrote 4096/4096 bytes at offset 4295380992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295385088 ++wrote 4096/4096 bytes at offset 4295385088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295389184 ++wrote 4096/4096 bytes at offset 4295389184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295393280 ++wrote 4096/4096 bytes at offset 4295393280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295397376 ++wrote 4096/4096 bytes at offset 4295397376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295401472 ++wrote 4096/4096 bytes at offset 4295401472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295405568 ++wrote 4096/4096 bytes at offset 4295405568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295409664 ++wrote 4096/4096 bytes at offset 4295409664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295413760 ++wrote 4096/4096 bytes at offset 4295413760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295417856 ++wrote 4096/4096 bytes at offset 4295417856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295421952 ++wrote 4096/4096 bytes at offset 4295421952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295426048 ++wrote 4096/4096 bytes at offset 4295426048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295430144 ++wrote 4096/4096 bytes at offset 4295430144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295434240 ++wrote 4096/4096 bytes at offset 4295434240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295438336 ++wrote 4096/4096 bytes at offset 4295438336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295442432 ++wrote 4096/4096 bytes at offset 4295442432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295446528 ++wrote 4096/4096 bytes at offset 4295446528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295450624 ++wrote 4096/4096 bytes at offset 4295450624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295454720 ++wrote 4096/4096 bytes at offset 4295454720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295458816 ++wrote 4096/4096 bytes at offset 4295458816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295462912 ++wrote 4096/4096 bytes at offset 4295462912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295467008 ++wrote 4096/4096 bytes at offset 4295467008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295471104 ++wrote 4096/4096 bytes at offset 4295471104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295475200 ++wrote 4096/4096 bytes at offset 4295475200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295479296 ++wrote 4096/4096 bytes at offset 4295479296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295483392 ++wrote 4096/4096 bytes at offset 4295483392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295487488 ++wrote 4096/4096 bytes at offset 4295487488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295491584 ++wrote 4096/4096 bytes at offset 4295491584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295495680 ++wrote 4096/4096 bytes at offset 4295495680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295499776 ++wrote 4096/4096 bytes at offset 4295499776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295503872 ++wrote 4096/4096 bytes at offset 4295503872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295507968 ++wrote 4096/4096 bytes at offset 4295507968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295512064 ++wrote 4096/4096 bytes at offset 4295512064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295516160 ++wrote 4096/4096 bytes at offset 4295516160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295520256 ++wrote 4096/4096 bytes at offset 4295520256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295524352 ++wrote 4096/4096 bytes at offset 4295524352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295528448 ++wrote 4096/4096 bytes at offset 4295528448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295532544 ++wrote 4096/4096 bytes at offset 4295532544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295536640 ++wrote 4096/4096 bytes at offset 4295536640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295540736 ++wrote 4096/4096 bytes at offset 4295540736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295544832 ++wrote 4096/4096 bytes at offset 4295544832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295548928 ++wrote 4096/4096 bytes at offset 4295548928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295553024 ++wrote 4096/4096 bytes at offset 4295553024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295557120 ++wrote 4096/4096 bytes at offset 4295557120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295561216 ++wrote 4096/4096 bytes at offset 4295561216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295565312 ++wrote 4096/4096 bytes at offset 4295565312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295569408 ++wrote 4096/4096 bytes at offset 4295569408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295573504 ++wrote 4096/4096 bytes at offset 4295573504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295577600 ++wrote 4096/4096 bytes at offset 4295577600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295581696 ++wrote 4096/4096 bytes at offset 4295581696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295585792 ++wrote 4096/4096 bytes at offset 4295585792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295589888 ++wrote 4096/4096 bytes at offset 4295589888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295593984 ++wrote 4096/4096 bytes at offset 4295593984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295598080 ++wrote 4096/4096 bytes at offset 4295598080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295602176 ++wrote 4096/4096 bytes at offset 4295602176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295606272 ++wrote 4096/4096 bytes at offset 4295606272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295610368 ++wrote 4096/4096 bytes at offset 4295610368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295614464 ++wrote 4096/4096 bytes at offset 4295614464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295618560 ++wrote 4096/4096 bytes at offset 4295618560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295622656 ++wrote 4096/4096 bytes at offset 4295622656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295626752 ++wrote 4096/4096 bytes at offset 4295626752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295630848 ++wrote 4096/4096 bytes at offset 4295630848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295634944 ++wrote 4096/4096 bytes at offset 4295634944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295639040 ++wrote 4096/4096 bytes at offset 4295639040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295643136 ++wrote 4096/4096 bytes at offset 4295643136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295647232 ++wrote 4096/4096 bytes at offset 4295647232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295651328 ++wrote 4096/4096 bytes at offset 4295651328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295655424 ++wrote 4096/4096 bytes at offset 4295655424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295659520 ++wrote 4096/4096 bytes at offset 4295659520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295663616 ++wrote 4096/4096 bytes at offset 4295663616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295667712 ++wrote 4096/4096 bytes at offset 4295667712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295671808 ++wrote 4096/4096 bytes at offset 4295671808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295675904 ++wrote 4096/4096 bytes at offset 4295675904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295680000 ++wrote 4096/4096 bytes at offset 4295680000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295684096 ++wrote 4096/4096 bytes at offset 4295684096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295688192 ++wrote 4096/4096 bytes at offset 4295688192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295692288 ++wrote 4096/4096 bytes at offset 4295692288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295696384 ++wrote 4096/4096 bytes at offset 4295696384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295700480 ++wrote 4096/4096 bytes at offset 4295700480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295704576 ++wrote 4096/4096 bytes at offset 4295704576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295708672 ++wrote 4096/4096 bytes at offset 4295708672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295712768 ++wrote 4096/4096 bytes at offset 4295712768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295716864 ++wrote 4096/4096 bytes at offset 4295716864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295720960 ++wrote 4096/4096 bytes at offset 4295720960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295725056 ++wrote 4096/4096 bytes at offset 4295725056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295729152 ++wrote 4096/4096 bytes at offset 4295729152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295733248 ++wrote 4096/4096 bytes at offset 4295733248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295737344 ++wrote 4096/4096 bytes at offset 4295737344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295741440 ++wrote 4096/4096 bytes at offset 4295741440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295745536 ++wrote 4096/4096 bytes at offset 4295745536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295749632 ++wrote 4096/4096 bytes at offset 4295749632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295753728 ++wrote 4096/4096 bytes at offset 4295753728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295757824 ++wrote 4096/4096 bytes at offset 4295757824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295761920 ++wrote 4096/4096 bytes at offset 4295761920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295766016 ++wrote 4096/4096 bytes at offset 4295766016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295770112 ++wrote 4096/4096 bytes at offset 4295770112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295774208 ++wrote 4096/4096 bytes at offset 4295774208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295778304 ++wrote 4096/4096 bytes at offset 4295778304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295782400 ++wrote 4096/4096 bytes at offset 4295782400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295786496 ++wrote 4096/4096 bytes at offset 4295786496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295790592 ++wrote 4096/4096 bytes at offset 4295790592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295794688 ++wrote 4096/4096 bytes at offset 4295794688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295798784 ++wrote 4096/4096 bytes at offset 4295798784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295802880 ++wrote 4096/4096 bytes at offset 4295802880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295806976 ++wrote 4096/4096 bytes at offset 4295806976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295811072 ++wrote 4096/4096 bytes at offset 4295811072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295815168 ++wrote 4096/4096 bytes at offset 4295815168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295819264 ++wrote 4096/4096 bytes at offset 4295819264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295823360 ++wrote 4096/4096 bytes at offset 4295823360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295827456 ++wrote 4096/4096 bytes at offset 4295827456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295831552 ++wrote 4096/4096 bytes at offset 4295831552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295835648 ++wrote 4096/4096 bytes at offset 4295835648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295839744 ++wrote 4096/4096 bytes at offset 4295839744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295843840 ++wrote 4096/4096 bytes at offset 4295843840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295847936 ++wrote 4096/4096 bytes at offset 4295847936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295852032 ++wrote 4096/4096 bytes at offset 4295852032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295856128 ++wrote 4096/4096 bytes at offset 4295856128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295860224 ++wrote 4096/4096 bytes at offset 4295860224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295864320 ++wrote 4096/4096 bytes at offset 4295864320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295868416 ++wrote 4096/4096 bytes at offset 4295868416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295872512 ++wrote 4096/4096 bytes at offset 4295872512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295876608 ++wrote 4096/4096 bytes at offset 4295876608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295880704 ++wrote 4096/4096 bytes at offset 4295880704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295884800 ++wrote 4096/4096 bytes at offset 4295884800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295888896 ++wrote 4096/4096 bytes at offset 4295888896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295892992 ++wrote 4096/4096 bytes at offset 4295892992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295897088 ++wrote 4096/4096 bytes at offset 4295897088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295901184 ++wrote 4096/4096 bytes at offset 4295901184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295905280 ++wrote 4096/4096 bytes at offset 4295905280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295909376 ++wrote 4096/4096 bytes at offset 4295909376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295913472 ++wrote 4096/4096 bytes at offset 4295913472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295917568 ++wrote 4096/4096 bytes at offset 4295917568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295921664 ++wrote 4096/4096 bytes at offset 4295921664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295925760 ++wrote 4096/4096 bytes at offset 4295925760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295929856 ++wrote 4096/4096 bytes at offset 4295929856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295933952 ++wrote 4096/4096 bytes at offset 4295933952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295938048 ++wrote 4096/4096 bytes at offset 4295938048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295942144 ++wrote 4096/4096 bytes at offset 4295942144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295946240 ++wrote 4096/4096 bytes at offset 4295946240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295950336 ++wrote 4096/4096 bytes at offset 4295950336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295954432 ++wrote 4096/4096 bytes at offset 4295954432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295958528 ++wrote 4096/4096 bytes at offset 4295958528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295962624 ++wrote 4096/4096 bytes at offset 4295962624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295966720 ++wrote 4096/4096 bytes at offset 4295966720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295970816 ++wrote 4096/4096 bytes at offset 4295970816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295974912 ++wrote 4096/4096 bytes at offset 4295974912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295979008 ++wrote 4096/4096 bytes at offset 4295979008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295983104 ++wrote 4096/4096 bytes at offset 4295983104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295987200 ++wrote 4096/4096 bytes at offset 4295987200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295991296 ++wrote 4096/4096 bytes at offset 4295991296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295995392 ++wrote 4096/4096 bytes at offset 4295995392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295999488 ++wrote 4096/4096 bytes at offset 4295999488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296003584 ++wrote 4096/4096 bytes at offset 4296003584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296007680 ++wrote 4096/4096 bytes at offset 4296007680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296011776 ++wrote 4096/4096 bytes at offset 4296011776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 4 +-qemu-io> wrote 2048/2048 bytes at offset 4296017920 ++=== IO: pattern 4 ++wrote 2048/2048 bytes at offset 4296017920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296022016 ++wrote 2048/2048 bytes at offset 4296022016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296026112 ++wrote 2048/2048 bytes at offset 4296026112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296030208 ++wrote 2048/2048 bytes at offset 4296030208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296034304 ++wrote 2048/2048 bytes at offset 4296034304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296038400 ++wrote 2048/2048 bytes at offset 4296038400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296042496 ++wrote 2048/2048 bytes at offset 4296042496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296046592 ++wrote 2048/2048 bytes at offset 4296046592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296050688 ++wrote 2048/2048 bytes at offset 4296050688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296054784 ++wrote 2048/2048 bytes at offset 4296054784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296058880 ++wrote 2048/2048 bytes at offset 4296058880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296062976 ++wrote 2048/2048 bytes at offset 4296062976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296067072 ++wrote 2048/2048 bytes at offset 4296067072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296071168 ++wrote 2048/2048 bytes at offset 4296071168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296075264 ++wrote 2048/2048 bytes at offset 4296075264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296079360 ++wrote 2048/2048 bytes at offset 4296079360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296083456 ++wrote 2048/2048 bytes at offset 4296083456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296087552 ++wrote 2048/2048 bytes at offset 4296087552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296091648 ++wrote 2048/2048 bytes at offset 4296091648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296095744 ++wrote 2048/2048 bytes at offset 4296095744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296099840 ++wrote 2048/2048 bytes at offset 4296099840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296103936 ++wrote 2048/2048 bytes at offset 4296103936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296108032 ++wrote 2048/2048 bytes at offset 4296108032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296112128 ++wrote 2048/2048 bytes at offset 4296112128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296116224 ++wrote 2048/2048 bytes at offset 4296116224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296120320 ++wrote 2048/2048 bytes at offset 4296120320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296124416 ++wrote 2048/2048 bytes at offset 4296124416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296128512 ++wrote 2048/2048 bytes at offset 4296128512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296132608 ++wrote 2048/2048 bytes at offset 4296132608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296136704 ++wrote 2048/2048 bytes at offset 4296136704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296140800 ++wrote 2048/2048 bytes at offset 4296140800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296144896 ++wrote 2048/2048 bytes at offset 4296144896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296148992 ++wrote 2048/2048 bytes at offset 4296148992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296153088 ++wrote 2048/2048 bytes at offset 4296153088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296157184 ++wrote 2048/2048 bytes at offset 4296157184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296161280 ++wrote 2048/2048 bytes at offset 4296161280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296165376 ++wrote 2048/2048 bytes at offset 4296165376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296169472 ++wrote 2048/2048 bytes at offset 4296169472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296173568 ++wrote 2048/2048 bytes at offset 4296173568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296177664 ++wrote 2048/2048 bytes at offset 4296177664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296181760 ++wrote 2048/2048 bytes at offset 4296181760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296185856 ++wrote 2048/2048 bytes at offset 4296185856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296189952 ++wrote 2048/2048 bytes at offset 4296189952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296194048 ++wrote 2048/2048 bytes at offset 4296194048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296198144 ++wrote 2048/2048 bytes at offset 4296198144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296202240 ++wrote 2048/2048 bytes at offset 4296202240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296206336 ++wrote 2048/2048 bytes at offset 4296206336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296210432 ++wrote 2048/2048 bytes at offset 4296210432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296214528 ++wrote 2048/2048 bytes at offset 4296214528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296218624 ++wrote 2048/2048 bytes at offset 4296218624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296222720 ++wrote 2048/2048 bytes at offset 4296222720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296226816 ++wrote 2048/2048 bytes at offset 4296226816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296230912 ++wrote 2048/2048 bytes at offset 4296230912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296235008 ++wrote 2048/2048 bytes at offset 4296235008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296239104 ++wrote 2048/2048 bytes at offset 4296239104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296243200 ++wrote 2048/2048 bytes at offset 4296243200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296247296 ++wrote 2048/2048 bytes at offset 4296247296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296251392 ++wrote 2048/2048 bytes at offset 4296251392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296255488 ++wrote 2048/2048 bytes at offset 4296255488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296259584 ++wrote 2048/2048 bytes at offset 4296259584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296263680 ++wrote 2048/2048 bytes at offset 4296263680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296267776 ++wrote 2048/2048 bytes at offset 4296267776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296271872 ++wrote 2048/2048 bytes at offset 4296271872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296275968 ++wrote 2048/2048 bytes at offset 4296275968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296280064 ++wrote 2048/2048 bytes at offset 4296280064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296284160 ++wrote 2048/2048 bytes at offset 4296284160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296288256 ++wrote 2048/2048 bytes at offset 4296288256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296292352 ++wrote 2048/2048 bytes at offset 4296292352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296296448 ++wrote 2048/2048 bytes at offset 4296296448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296300544 ++wrote 2048/2048 bytes at offset 4296300544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296304640 ++wrote 2048/2048 bytes at offset 4296304640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296308736 ++wrote 2048/2048 bytes at offset 4296308736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296312832 ++wrote 2048/2048 bytes at offset 4296312832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296316928 ++wrote 2048/2048 bytes at offset 4296316928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296321024 ++wrote 2048/2048 bytes at offset 4296321024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296325120 ++wrote 2048/2048 bytes at offset 4296325120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296329216 ++wrote 2048/2048 bytes at offset 4296329216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296333312 ++wrote 2048/2048 bytes at offset 4296333312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296337408 ++wrote 2048/2048 bytes at offset 4296337408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296341504 ++wrote 2048/2048 bytes at offset 4296341504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296345600 ++wrote 2048/2048 bytes at offset 4296345600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296349696 ++wrote 2048/2048 bytes at offset 4296349696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296353792 ++wrote 2048/2048 bytes at offset 4296353792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296357888 ++wrote 2048/2048 bytes at offset 4296357888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296361984 ++wrote 2048/2048 bytes at offset 4296361984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296366080 ++wrote 2048/2048 bytes at offset 4296366080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296370176 ++wrote 2048/2048 bytes at offset 4296370176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296374272 ++wrote 2048/2048 bytes at offset 4296374272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296378368 ++wrote 2048/2048 bytes at offset 4296378368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296382464 ++wrote 2048/2048 bytes at offset 4296382464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296386560 ++wrote 2048/2048 bytes at offset 4296386560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296390656 ++wrote 2048/2048 bytes at offset 4296390656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296394752 ++wrote 2048/2048 bytes at offset 4296394752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296398848 ++wrote 2048/2048 bytes at offset 4296398848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296402944 ++wrote 2048/2048 bytes at offset 4296402944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296407040 ++wrote 2048/2048 bytes at offset 4296407040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296411136 ++wrote 2048/2048 bytes at offset 4296411136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296415232 ++wrote 2048/2048 bytes at offset 4296415232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296419328 ++wrote 2048/2048 bytes at offset 4296419328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296423424 ++wrote 2048/2048 bytes at offset 4296423424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296427520 ++wrote 2048/2048 bytes at offset 4296427520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296431616 ++wrote 2048/2048 bytes at offset 4296431616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296435712 ++wrote 2048/2048 bytes at offset 4296435712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296439808 ++wrote 2048/2048 bytes at offset 4296439808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296443904 ++wrote 2048/2048 bytes at offset 4296443904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296448000 ++wrote 2048/2048 bytes at offset 4296448000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296452096 ++wrote 2048/2048 bytes at offset 4296452096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296456192 ++wrote 2048/2048 bytes at offset 4296456192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296460288 ++wrote 2048/2048 bytes at offset 4296460288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296464384 ++wrote 2048/2048 bytes at offset 4296464384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296468480 ++wrote 2048/2048 bytes at offset 4296468480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296472576 ++wrote 2048/2048 bytes at offset 4296472576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296476672 ++wrote 2048/2048 bytes at offset 4296476672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296480768 ++wrote 2048/2048 bytes at offset 4296480768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296484864 ++wrote 2048/2048 bytes at offset 4296484864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296488960 ++wrote 2048/2048 bytes at offset 4296488960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296493056 ++wrote 2048/2048 bytes at offset 4296493056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296497152 ++wrote 2048/2048 bytes at offset 4296497152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296501248 ++wrote 2048/2048 bytes at offset 4296501248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296505344 ++wrote 2048/2048 bytes at offset 4296505344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296509440 ++wrote 2048/2048 bytes at offset 4296509440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296513536 ++wrote 2048/2048 bytes at offset 4296513536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296517632 ++wrote 2048/2048 bytes at offset 4296517632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296521728 ++wrote 2048/2048 bytes at offset 4296521728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296525824 ++wrote 2048/2048 bytes at offset 4296525824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296529920 ++wrote 2048/2048 bytes at offset 4296529920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296534016 ++wrote 2048/2048 bytes at offset 4296534016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296538112 ++wrote 2048/2048 bytes at offset 4296538112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296542208 ++wrote 2048/2048 bytes at offset 4296542208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296546304 ++wrote 2048/2048 bytes at offset 4296546304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296550400 ++wrote 2048/2048 bytes at offset 4296550400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296554496 ++wrote 2048/2048 bytes at offset 4296554496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296558592 ++wrote 2048/2048 bytes at offset 4296558592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296562688 ++wrote 2048/2048 bytes at offset 4296562688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296566784 ++wrote 2048/2048 bytes at offset 4296566784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296570880 ++wrote 2048/2048 bytes at offset 4296570880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296574976 ++wrote 2048/2048 bytes at offset 4296574976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296579072 ++wrote 2048/2048 bytes at offset 4296579072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296583168 ++wrote 2048/2048 bytes at offset 4296583168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296587264 ++wrote 2048/2048 bytes at offset 4296587264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296591360 ++wrote 2048/2048 bytes at offset 4296591360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296595456 ++wrote 2048/2048 bytes at offset 4296595456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296599552 ++wrote 2048/2048 bytes at offset 4296599552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296603648 ++wrote 2048/2048 bytes at offset 4296603648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296607744 ++wrote 2048/2048 bytes at offset 4296607744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296611840 ++wrote 2048/2048 bytes at offset 4296611840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296615936 ++wrote 2048/2048 bytes at offset 4296615936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296620032 ++wrote 2048/2048 bytes at offset 4296620032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296624128 ++wrote 2048/2048 bytes at offset 4296624128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296628224 ++wrote 2048/2048 bytes at offset 4296628224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296632320 ++wrote 2048/2048 bytes at offset 4296632320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296636416 ++wrote 2048/2048 bytes at offset 4296636416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296640512 ++wrote 2048/2048 bytes at offset 4296640512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296644608 ++wrote 2048/2048 bytes at offset 4296644608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296648704 ++wrote 2048/2048 bytes at offset 4296648704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296652800 ++wrote 2048/2048 bytes at offset 4296652800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296656896 ++wrote 2048/2048 bytes at offset 4296656896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296660992 ++wrote 2048/2048 bytes at offset 4296660992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296665088 ++wrote 2048/2048 bytes at offset 4296665088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296669184 ++wrote 2048/2048 bytes at offset 4296669184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296673280 ++wrote 2048/2048 bytes at offset 4296673280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296677376 ++wrote 2048/2048 bytes at offset 4296677376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296681472 ++wrote 2048/2048 bytes at offset 4296681472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296685568 ++wrote 2048/2048 bytes at offset 4296685568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296689664 ++wrote 2048/2048 bytes at offset 4296689664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296693760 ++wrote 2048/2048 bytes at offset 4296693760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296697856 ++wrote 2048/2048 bytes at offset 4296697856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296701952 ++wrote 2048/2048 bytes at offset 4296701952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296706048 ++wrote 2048/2048 bytes at offset 4296706048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296710144 ++wrote 2048/2048 bytes at offset 4296710144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296714240 ++wrote 2048/2048 bytes at offset 4296714240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296718336 ++wrote 2048/2048 bytes at offset 4296718336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296722432 ++wrote 2048/2048 bytes at offset 4296722432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296726528 ++wrote 2048/2048 bytes at offset 4296726528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296730624 ++wrote 2048/2048 bytes at offset 4296730624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296734720 ++wrote 2048/2048 bytes at offset 4296734720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296738816 ++wrote 2048/2048 bytes at offset 4296738816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296742912 ++wrote 2048/2048 bytes at offset 4296742912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296747008 ++wrote 2048/2048 bytes at offset 4296747008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296751104 ++wrote 2048/2048 bytes at offset 4296751104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296755200 ++wrote 2048/2048 bytes at offset 4296755200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296759296 ++wrote 2048/2048 bytes at offset 4296759296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296763392 ++wrote 2048/2048 bytes at offset 4296763392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296767488 ++wrote 2048/2048 bytes at offset 4296767488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296771584 ++wrote 2048/2048 bytes at offset 4296771584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296775680 ++wrote 2048/2048 bytes at offset 4296775680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296779776 ++wrote 2048/2048 bytes at offset 4296779776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296783872 ++wrote 2048/2048 bytes at offset 4296783872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296787968 ++wrote 2048/2048 bytes at offset 4296787968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296792064 ++wrote 2048/2048 bytes at offset 4296792064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296796160 ++wrote 2048/2048 bytes at offset 4296796160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296800256 ++wrote 2048/2048 bytes at offset 4296800256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296804352 ++wrote 2048/2048 bytes at offset 4296804352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296808448 ++wrote 2048/2048 bytes at offset 4296808448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296812544 ++wrote 2048/2048 bytes at offset 4296812544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296816640 ++wrote 2048/2048 bytes at offset 4296816640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296820736 ++wrote 2048/2048 bytes at offset 4296820736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296824832 ++wrote 2048/2048 bytes at offset 4296824832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296828928 ++wrote 2048/2048 bytes at offset 4296828928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296833024 ++wrote 2048/2048 bytes at offset 4296833024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296837120 ++wrote 2048/2048 bytes at offset 4296837120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296841216 ++wrote 2048/2048 bytes at offset 4296841216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296845312 ++wrote 2048/2048 bytes at offset 4296845312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296849408 ++wrote 2048/2048 bytes at offset 4296849408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296853504 ++wrote 2048/2048 bytes at offset 4296853504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296857600 ++wrote 2048/2048 bytes at offset 4296857600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296861696 ++wrote 2048/2048 bytes at offset 4296861696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296865792 ++wrote 2048/2048 bytes at offset 4296865792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296869888 ++wrote 2048/2048 bytes at offset 4296869888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296873984 ++wrote 2048/2048 bytes at offset 4296873984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296878080 ++wrote 2048/2048 bytes at offset 4296878080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296882176 ++wrote 2048/2048 bytes at offset 4296882176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296886272 ++wrote 2048/2048 bytes at offset 4296886272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296890368 ++wrote 2048/2048 bytes at offset 4296890368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296894464 ++wrote 2048/2048 bytes at offset 4296894464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296898560 ++wrote 2048/2048 bytes at offset 4296898560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296902656 ++wrote 2048/2048 bytes at offset 4296902656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296906752 ++wrote 2048/2048 bytes at offset 4296906752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296910848 ++wrote 2048/2048 bytes at offset 4296910848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296914944 ++wrote 2048/2048 bytes at offset 4296914944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296919040 ++wrote 2048/2048 bytes at offset 4296919040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296923136 ++wrote 2048/2048 bytes at offset 4296923136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296927232 ++wrote 2048/2048 bytes at offset 4296927232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296931328 ++wrote 2048/2048 bytes at offset 4296931328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296935424 ++wrote 2048/2048 bytes at offset 4296935424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296939520 ++wrote 2048/2048 bytes at offset 4296939520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296943616 ++wrote 2048/2048 bytes at offset 4296943616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296947712 ++wrote 2048/2048 bytes at offset 4296947712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296951808 ++wrote 2048/2048 bytes at offset 4296951808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296955904 ++wrote 2048/2048 bytes at offset 4296955904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296960000 ++wrote 2048/2048 bytes at offset 4296960000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296964096 ++wrote 2048/2048 bytes at offset 4296964096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296968192 ++wrote 2048/2048 bytes at offset 4296968192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296972288 ++wrote 2048/2048 bytes at offset 4296972288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296976384 ++wrote 2048/2048 bytes at offset 4296976384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296980480 ++wrote 2048/2048 bytes at offset 4296980480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296984576 ++wrote 2048/2048 bytes at offset 4296984576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296988672 ++wrote 2048/2048 bytes at offset 4296988672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296992768 ++wrote 2048/2048 bytes at offset 4296992768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296996864 ++wrote 2048/2048 bytes at offset 4296996864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297000960 ++wrote 2048/2048 bytes at offset 4297000960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297005056 ++wrote 2048/2048 bytes at offset 4297005056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297009152 ++wrote 2048/2048 bytes at offset 4297009152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297013248 ++wrote 2048/2048 bytes at offset 4297013248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297017344 ++wrote 2048/2048 bytes at offset 4297017344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297021440 ++wrote 2048/2048 bytes at offset 4297021440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297025536 ++wrote 2048/2048 bytes at offset 4297025536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297029632 ++wrote 2048/2048 bytes at offset 4297029632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297033728 ++wrote 2048/2048 bytes at offset 4297033728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297037824 ++wrote 2048/2048 bytes at offset 4297037824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297041920 ++wrote 2048/2048 bytes at offset 4297041920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297046016 ++wrote 2048/2048 bytes at offset 4297046016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297050112 ++wrote 2048/2048 bytes at offset 4297050112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297054208 ++wrote 2048/2048 bytes at offset 4297054208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297058304 ++wrote 2048/2048 bytes at offset 4297058304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297062400 ++wrote 2048/2048 bytes at offset 4297062400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> wrote 2048/2048 bytes at offset 4297064448 ++=== IO: pattern 0 ++wrote 2048/2048 bytes at offset 4297064448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297068544 ++wrote 2048/2048 bytes at offset 4297068544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297072640 ++wrote 2048/2048 bytes at offset 4297072640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297076736 ++wrote 2048/2048 bytes at offset 4297076736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297080832 ++wrote 2048/2048 bytes at offset 4297080832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297084928 ++wrote 2048/2048 bytes at offset 4297084928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297089024 ++wrote 2048/2048 bytes at offset 4297089024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297093120 ++wrote 2048/2048 bytes at offset 4297093120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297097216 ++wrote 2048/2048 bytes at offset 4297097216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297101312 ++wrote 2048/2048 bytes at offset 4297101312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297105408 ++wrote 2048/2048 bytes at offset 4297105408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297109504 ++wrote 2048/2048 bytes at offset 4297109504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297113600 ++wrote 2048/2048 bytes at offset 4297113600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297117696 ++wrote 2048/2048 bytes at offset 4297117696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297121792 ++wrote 2048/2048 bytes at offset 4297121792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297125888 ++wrote 2048/2048 bytes at offset 4297125888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297129984 ++wrote 2048/2048 bytes at offset 4297129984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297134080 ++wrote 2048/2048 bytes at offset 4297134080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297138176 ++wrote 2048/2048 bytes at offset 4297138176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297142272 ++wrote 2048/2048 bytes at offset 4297142272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297146368 ++wrote 2048/2048 bytes at offset 4297146368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297150464 ++wrote 2048/2048 bytes at offset 4297150464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297154560 ++wrote 2048/2048 bytes at offset 4297154560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297158656 ++wrote 2048/2048 bytes at offset 4297158656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297162752 ++wrote 2048/2048 bytes at offset 4297162752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297166848 ++wrote 2048/2048 bytes at offset 4297166848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297170944 ++wrote 2048/2048 bytes at offset 4297170944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297175040 ++wrote 2048/2048 bytes at offset 4297175040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297179136 ++wrote 2048/2048 bytes at offset 4297179136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297183232 ++wrote 2048/2048 bytes at offset 4297183232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297187328 ++wrote 2048/2048 bytes at offset 4297187328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297191424 ++wrote 2048/2048 bytes at offset 4297191424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297195520 ++wrote 2048/2048 bytes at offset 4297195520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297199616 ++wrote 2048/2048 bytes at offset 4297199616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297203712 ++wrote 2048/2048 bytes at offset 4297203712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297207808 ++wrote 2048/2048 bytes at offset 4297207808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297211904 ++wrote 2048/2048 bytes at offset 4297211904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297216000 ++wrote 2048/2048 bytes at offset 4297216000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297220096 ++wrote 2048/2048 bytes at offset 4297220096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297224192 ++wrote 2048/2048 bytes at offset 4297224192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297228288 ++wrote 2048/2048 bytes at offset 4297228288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297232384 ++wrote 2048/2048 bytes at offset 4297232384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297236480 ++wrote 2048/2048 bytes at offset 4297236480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297240576 ++wrote 2048/2048 bytes at offset 4297240576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297244672 ++wrote 2048/2048 bytes at offset 4297244672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297248768 ++wrote 2048/2048 bytes at offset 4297248768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297252864 ++wrote 2048/2048 bytes at offset 4297252864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297256960 ++wrote 2048/2048 bytes at offset 4297256960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297261056 ++wrote 2048/2048 bytes at offset 4297261056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297265152 ++wrote 2048/2048 bytes at offset 4297265152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297269248 ++wrote 2048/2048 bytes at offset 4297269248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297273344 ++wrote 2048/2048 bytes at offset 4297273344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297277440 ++wrote 2048/2048 bytes at offset 4297277440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297281536 ++wrote 2048/2048 bytes at offset 4297281536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297285632 ++wrote 2048/2048 bytes at offset 4297285632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297289728 ++wrote 2048/2048 bytes at offset 4297289728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297293824 ++wrote 2048/2048 bytes at offset 4297293824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297297920 ++wrote 2048/2048 bytes at offset 4297297920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297302016 ++wrote 2048/2048 bytes at offset 4297302016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297306112 ++wrote 2048/2048 bytes at offset 4297306112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297310208 ++wrote 2048/2048 bytes at offset 4297310208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297314304 ++wrote 2048/2048 bytes at offset 4297314304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297318400 ++wrote 2048/2048 bytes at offset 4297318400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297322496 ++wrote 2048/2048 bytes at offset 4297322496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297326592 ++wrote 2048/2048 bytes at offset 4297326592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297330688 ++wrote 2048/2048 bytes at offset 4297330688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297334784 ++wrote 2048/2048 bytes at offset 4297334784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297338880 ++wrote 2048/2048 bytes at offset 4297338880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297342976 ++wrote 2048/2048 bytes at offset 4297342976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297347072 ++wrote 2048/2048 bytes at offset 4297347072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297351168 ++wrote 2048/2048 bytes at offset 4297351168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297355264 ++wrote 2048/2048 bytes at offset 4297355264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297359360 ++wrote 2048/2048 bytes at offset 4297359360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297363456 ++wrote 2048/2048 bytes at offset 4297363456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297367552 ++wrote 2048/2048 bytes at offset 4297367552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297371648 ++wrote 2048/2048 bytes at offset 4297371648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297375744 ++wrote 2048/2048 bytes at offset 4297375744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297379840 ++wrote 2048/2048 bytes at offset 4297379840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297383936 ++wrote 2048/2048 bytes at offset 4297383936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297388032 ++wrote 2048/2048 bytes at offset 4297388032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297392128 ++wrote 2048/2048 bytes at offset 4297392128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297396224 ++wrote 2048/2048 bytes at offset 4297396224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297400320 ++wrote 2048/2048 bytes at offset 4297400320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297404416 ++wrote 2048/2048 bytes at offset 4297404416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297408512 ++wrote 2048/2048 bytes at offset 4297408512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297412608 ++wrote 2048/2048 bytes at offset 4297412608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297416704 ++wrote 2048/2048 bytes at offset 4297416704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297420800 ++wrote 2048/2048 bytes at offset 4297420800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297424896 ++wrote 2048/2048 bytes at offset 4297424896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297428992 ++wrote 2048/2048 bytes at offset 4297428992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297433088 ++wrote 2048/2048 bytes at offset 4297433088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297437184 ++wrote 2048/2048 bytes at offset 4297437184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297441280 ++wrote 2048/2048 bytes at offset 4297441280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297445376 ++wrote 2048/2048 bytes at offset 4297445376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297449472 ++wrote 2048/2048 bytes at offset 4297449472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297453568 ++wrote 2048/2048 bytes at offset 4297453568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297457664 ++wrote 2048/2048 bytes at offset 4297457664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297461760 ++wrote 2048/2048 bytes at offset 4297461760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297465856 ++wrote 2048/2048 bytes at offset 4297465856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297469952 ++wrote 2048/2048 bytes at offset 4297469952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297474048 ++wrote 2048/2048 bytes at offset 4297474048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297478144 ++wrote 2048/2048 bytes at offset 4297478144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297482240 ++wrote 2048/2048 bytes at offset 4297482240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297486336 ++wrote 2048/2048 bytes at offset 4297486336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297490432 ++wrote 2048/2048 bytes at offset 4297490432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297494528 ++wrote 2048/2048 bytes at offset 4297494528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297498624 ++wrote 2048/2048 bytes at offset 4297498624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297502720 ++wrote 2048/2048 bytes at offset 4297502720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297506816 ++wrote 2048/2048 bytes at offset 4297506816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297510912 ++wrote 2048/2048 bytes at offset 4297510912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297515008 ++wrote 2048/2048 bytes at offset 4297515008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297519104 ++wrote 2048/2048 bytes at offset 4297519104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297523200 ++wrote 2048/2048 bytes at offset 4297523200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297527296 ++wrote 2048/2048 bytes at offset 4297527296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297531392 ++wrote 2048/2048 bytes at offset 4297531392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297535488 ++wrote 2048/2048 bytes at offset 4297535488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297539584 ++wrote 2048/2048 bytes at offset 4297539584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297543680 ++wrote 2048/2048 bytes at offset 4297543680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297547776 ++wrote 2048/2048 bytes at offset 4297547776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297551872 ++wrote 2048/2048 bytes at offset 4297551872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297555968 ++wrote 2048/2048 bytes at offset 4297555968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297560064 ++wrote 2048/2048 bytes at offset 4297560064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297564160 ++wrote 2048/2048 bytes at offset 4297564160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297568256 ++wrote 2048/2048 bytes at offset 4297568256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297572352 ++wrote 2048/2048 bytes at offset 4297572352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297576448 ++wrote 2048/2048 bytes at offset 4297576448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297580544 ++wrote 2048/2048 bytes at offset 4297580544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297584640 ++wrote 2048/2048 bytes at offset 4297584640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297588736 ++wrote 2048/2048 bytes at offset 4297588736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297592832 ++wrote 2048/2048 bytes at offset 4297592832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297596928 ++wrote 2048/2048 bytes at offset 4297596928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297601024 ++wrote 2048/2048 bytes at offset 4297601024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297605120 ++wrote 2048/2048 bytes at offset 4297605120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297609216 ++wrote 2048/2048 bytes at offset 4297609216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297613312 ++wrote 2048/2048 bytes at offset 4297613312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297617408 ++wrote 2048/2048 bytes at offset 4297617408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297621504 ++wrote 2048/2048 bytes at offset 4297621504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297625600 ++wrote 2048/2048 bytes at offset 4297625600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297629696 ++wrote 2048/2048 bytes at offset 4297629696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297633792 ++wrote 2048/2048 bytes at offset 4297633792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297637888 ++wrote 2048/2048 bytes at offset 4297637888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297641984 ++wrote 2048/2048 bytes at offset 4297641984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297646080 ++wrote 2048/2048 bytes at offset 4297646080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297650176 ++wrote 2048/2048 bytes at offset 4297650176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297654272 ++wrote 2048/2048 bytes at offset 4297654272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297658368 ++wrote 2048/2048 bytes at offset 4297658368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297662464 ++wrote 2048/2048 bytes at offset 4297662464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297666560 ++wrote 2048/2048 bytes at offset 4297666560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297670656 ++wrote 2048/2048 bytes at offset 4297670656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297674752 ++wrote 2048/2048 bytes at offset 4297674752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297678848 ++wrote 2048/2048 bytes at offset 4297678848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297682944 ++wrote 2048/2048 bytes at offset 4297682944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297687040 ++wrote 2048/2048 bytes at offset 4297687040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297691136 ++wrote 2048/2048 bytes at offset 4297691136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297695232 ++wrote 2048/2048 bytes at offset 4297695232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297699328 ++wrote 2048/2048 bytes at offset 4297699328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297703424 ++wrote 2048/2048 bytes at offset 4297703424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297707520 ++wrote 2048/2048 bytes at offset 4297707520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297711616 ++wrote 2048/2048 bytes at offset 4297711616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297715712 ++wrote 2048/2048 bytes at offset 4297715712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297719808 ++wrote 2048/2048 bytes at offset 4297719808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297723904 ++wrote 2048/2048 bytes at offset 4297723904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297728000 ++wrote 2048/2048 bytes at offset 4297728000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297732096 ++wrote 2048/2048 bytes at offset 4297732096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297736192 ++wrote 2048/2048 bytes at offset 4297736192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297740288 ++wrote 2048/2048 bytes at offset 4297740288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297744384 ++wrote 2048/2048 bytes at offset 4297744384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297748480 ++wrote 2048/2048 bytes at offset 4297748480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297752576 ++wrote 2048/2048 bytes at offset 4297752576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297756672 ++wrote 2048/2048 bytes at offset 4297756672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297760768 ++wrote 2048/2048 bytes at offset 4297760768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297764864 ++wrote 2048/2048 bytes at offset 4297764864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297768960 ++wrote 2048/2048 bytes at offset 4297768960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297773056 ++wrote 2048/2048 bytes at offset 4297773056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297777152 ++wrote 2048/2048 bytes at offset 4297777152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297781248 ++wrote 2048/2048 bytes at offset 4297781248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297785344 ++wrote 2048/2048 bytes at offset 4297785344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297789440 ++wrote 2048/2048 bytes at offset 4297789440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297793536 ++wrote 2048/2048 bytes at offset 4297793536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297797632 ++wrote 2048/2048 bytes at offset 4297797632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297801728 ++wrote 2048/2048 bytes at offset 4297801728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297805824 ++wrote 2048/2048 bytes at offset 4297805824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297809920 ++wrote 2048/2048 bytes at offset 4297809920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297814016 ++wrote 2048/2048 bytes at offset 4297814016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297818112 ++wrote 2048/2048 bytes at offset 4297818112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297822208 ++wrote 2048/2048 bytes at offset 4297822208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297826304 ++wrote 2048/2048 bytes at offset 4297826304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297830400 ++wrote 2048/2048 bytes at offset 4297830400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297834496 ++wrote 2048/2048 bytes at offset 4297834496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297838592 ++wrote 2048/2048 bytes at offset 4297838592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297842688 ++wrote 2048/2048 bytes at offset 4297842688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297846784 ++wrote 2048/2048 bytes at offset 4297846784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297850880 ++wrote 2048/2048 bytes at offset 4297850880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297854976 ++wrote 2048/2048 bytes at offset 4297854976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297859072 ++wrote 2048/2048 bytes at offset 4297859072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297863168 ++wrote 2048/2048 bytes at offset 4297863168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297867264 ++wrote 2048/2048 bytes at offset 4297867264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297871360 ++wrote 2048/2048 bytes at offset 4297871360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297875456 ++wrote 2048/2048 bytes at offset 4297875456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297879552 ++wrote 2048/2048 bytes at offset 4297879552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297883648 ++wrote 2048/2048 bytes at offset 4297883648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297887744 ++wrote 2048/2048 bytes at offset 4297887744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297891840 ++wrote 2048/2048 bytes at offset 4297891840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297895936 ++wrote 2048/2048 bytes at offset 4297895936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297900032 ++wrote 2048/2048 bytes at offset 4297900032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297904128 ++wrote 2048/2048 bytes at offset 4297904128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297908224 ++wrote 2048/2048 bytes at offset 4297908224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297912320 ++wrote 2048/2048 bytes at offset 4297912320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297916416 ++wrote 2048/2048 bytes at offset 4297916416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297920512 ++wrote 2048/2048 bytes at offset 4297920512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297924608 ++wrote 2048/2048 bytes at offset 4297924608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297928704 ++wrote 2048/2048 bytes at offset 4297928704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297932800 ++wrote 2048/2048 bytes at offset 4297932800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297936896 ++wrote 2048/2048 bytes at offset 4297936896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297940992 ++wrote 2048/2048 bytes at offset 4297940992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297945088 ++wrote 2048/2048 bytes at offset 4297945088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297949184 ++wrote 2048/2048 bytes at offset 4297949184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297953280 ++wrote 2048/2048 bytes at offset 4297953280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297957376 ++wrote 2048/2048 bytes at offset 4297957376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297961472 ++wrote 2048/2048 bytes at offset 4297961472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297965568 ++wrote 2048/2048 bytes at offset 4297965568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297969664 ++wrote 2048/2048 bytes at offset 4297969664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297973760 ++wrote 2048/2048 bytes at offset 4297973760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297977856 ++wrote 2048/2048 bytes at offset 4297977856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297981952 ++wrote 2048/2048 bytes at offset 4297981952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297986048 ++wrote 2048/2048 bytes at offset 4297986048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297990144 ++wrote 2048/2048 bytes at offset 4297990144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297994240 ++wrote 2048/2048 bytes at offset 4297994240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297998336 ++wrote 2048/2048 bytes at offset 4297998336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298002432 ++wrote 2048/2048 bytes at offset 4298002432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298006528 ++wrote 2048/2048 bytes at offset 4298006528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298010624 ++wrote 2048/2048 bytes at offset 4298010624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298014720 ++wrote 2048/2048 bytes at offset 4298014720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298018816 ++wrote 2048/2048 bytes at offset 4298018816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298022912 ++wrote 2048/2048 bytes at offset 4298022912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298027008 ++wrote 2048/2048 bytes at offset 4298027008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298031104 ++wrote 2048/2048 bytes at offset 4298031104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298035200 ++wrote 2048/2048 bytes at offset 4298035200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298039296 ++wrote 2048/2048 bytes at offset 4298039296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298043392 ++wrote 2048/2048 bytes at offset 4298043392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298047488 ++wrote 2048/2048 bytes at offset 4298047488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298051584 ++wrote 2048/2048 bytes at offset 4298051584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298055680 ++wrote 2048/2048 bytes at offset 4298055680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298059776 ++wrote 2048/2048 bytes at offset 4298059776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298063872 ++wrote 2048/2048 bytes at offset 4298063872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298067968 ++wrote 2048/2048 bytes at offset 4298067968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298072064 ++wrote 2048/2048 bytes at offset 4298072064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298076160 ++wrote 2048/2048 bytes at offset 4298076160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298080256 ++wrote 2048/2048 bytes at offset 4298080256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298084352 ++wrote 2048/2048 bytes at offset 4298084352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298088448 ++wrote 2048/2048 bytes at offset 4298088448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298092544 ++wrote 2048/2048 bytes at offset 4298092544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298096640 ++wrote 2048/2048 bytes at offset 4298096640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298100736 ++wrote 2048/2048 bytes at offset 4298100736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298104832 ++wrote 2048/2048 bytes at offset 4298104832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298108928 ++wrote 2048/2048 bytes at offset 4298108928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 2 +-qemu-io> wrote 2048/2048 bytes at offset 4298114048 ++=== IO: pattern 2 ++wrote 2048/2048 bytes at offset 4298114048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298118144 ++wrote 2048/2048 bytes at offset 4298118144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298122240 ++wrote 2048/2048 bytes at offset 4298122240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298126336 ++wrote 2048/2048 bytes at offset 4298126336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298130432 ++wrote 2048/2048 bytes at offset 4298130432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298134528 ++wrote 2048/2048 bytes at offset 4298134528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298138624 ++wrote 2048/2048 bytes at offset 4298138624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298142720 ++wrote 2048/2048 bytes at offset 4298142720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298146816 ++wrote 2048/2048 bytes at offset 4298146816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298150912 ++wrote 2048/2048 bytes at offset 4298150912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298155008 ++wrote 2048/2048 bytes at offset 4298155008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298159104 ++wrote 2048/2048 bytes at offset 4298159104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298163200 ++wrote 2048/2048 bytes at offset 4298163200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298167296 ++wrote 2048/2048 bytes at offset 4298167296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298171392 ++wrote 2048/2048 bytes at offset 4298171392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298175488 ++wrote 2048/2048 bytes at offset 4298175488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298179584 ++wrote 2048/2048 bytes at offset 4298179584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298183680 ++wrote 2048/2048 bytes at offset 4298183680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298187776 ++wrote 2048/2048 bytes at offset 4298187776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298191872 ++wrote 2048/2048 bytes at offset 4298191872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298195968 ++wrote 2048/2048 bytes at offset 4298195968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298200064 ++wrote 2048/2048 bytes at offset 4298200064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298204160 ++wrote 2048/2048 bytes at offset 4298204160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298208256 ++wrote 2048/2048 bytes at offset 4298208256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298212352 ++wrote 2048/2048 bytes at offset 4298212352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298216448 ++wrote 2048/2048 bytes at offset 4298216448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298220544 ++wrote 2048/2048 bytes at offset 4298220544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298224640 ++wrote 2048/2048 bytes at offset 4298224640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298228736 ++wrote 2048/2048 bytes at offset 4298228736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298232832 ++wrote 2048/2048 bytes at offset 4298232832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298236928 ++wrote 2048/2048 bytes at offset 4298236928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298241024 ++wrote 2048/2048 bytes at offset 4298241024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298245120 ++wrote 2048/2048 bytes at offset 4298245120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298249216 ++wrote 2048/2048 bytes at offset 4298249216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298253312 ++wrote 2048/2048 bytes at offset 4298253312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298257408 ++wrote 2048/2048 bytes at offset 4298257408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298261504 ++wrote 2048/2048 bytes at offset 4298261504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298265600 ++wrote 2048/2048 bytes at offset 4298265600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298269696 ++wrote 2048/2048 bytes at offset 4298269696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298273792 ++wrote 2048/2048 bytes at offset 4298273792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298277888 ++wrote 2048/2048 bytes at offset 4298277888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298281984 ++wrote 2048/2048 bytes at offset 4298281984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298286080 ++wrote 2048/2048 bytes at offset 4298286080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298290176 ++wrote 2048/2048 bytes at offset 4298290176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298294272 ++wrote 2048/2048 bytes at offset 4298294272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298298368 ++wrote 2048/2048 bytes at offset 4298298368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298302464 ++wrote 2048/2048 bytes at offset 4298302464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298306560 ++wrote 2048/2048 bytes at offset 4298306560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298310656 ++wrote 2048/2048 bytes at offset 4298310656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298314752 ++wrote 2048/2048 bytes at offset 4298314752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298318848 ++wrote 2048/2048 bytes at offset 4298318848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298322944 ++wrote 2048/2048 bytes at offset 4298322944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298327040 ++wrote 2048/2048 bytes at offset 4298327040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298331136 ++wrote 2048/2048 bytes at offset 4298331136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298335232 ++wrote 2048/2048 bytes at offset 4298335232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298339328 ++wrote 2048/2048 bytes at offset 4298339328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298343424 ++wrote 2048/2048 bytes at offset 4298343424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298347520 ++wrote 2048/2048 bytes at offset 4298347520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298351616 ++wrote 2048/2048 bytes at offset 4298351616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298355712 ++wrote 2048/2048 bytes at offset 4298355712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298359808 ++wrote 2048/2048 bytes at offset 4298359808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298363904 ++wrote 2048/2048 bytes at offset 4298363904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298368000 ++wrote 2048/2048 bytes at offset 4298368000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298372096 ++wrote 2048/2048 bytes at offset 4298372096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298376192 ++wrote 2048/2048 bytes at offset 4298376192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298380288 ++wrote 2048/2048 bytes at offset 4298380288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298384384 ++wrote 2048/2048 bytes at offset 4298384384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298388480 ++wrote 2048/2048 bytes at offset 4298388480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298392576 ++wrote 2048/2048 bytes at offset 4298392576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298396672 ++wrote 2048/2048 bytes at offset 4298396672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298400768 ++wrote 2048/2048 bytes at offset 4298400768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298404864 ++wrote 2048/2048 bytes at offset 4298404864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298408960 ++wrote 2048/2048 bytes at offset 4298408960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298413056 ++wrote 2048/2048 bytes at offset 4298413056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298417152 ++wrote 2048/2048 bytes at offset 4298417152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298421248 ++wrote 2048/2048 bytes at offset 4298421248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298425344 ++wrote 2048/2048 bytes at offset 4298425344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298429440 ++wrote 2048/2048 bytes at offset 4298429440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298433536 ++wrote 2048/2048 bytes at offset 4298433536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298437632 ++wrote 2048/2048 bytes at offset 4298437632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298441728 ++wrote 2048/2048 bytes at offset 4298441728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298445824 ++wrote 2048/2048 bytes at offset 4298445824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298449920 ++wrote 2048/2048 bytes at offset 4298449920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298454016 ++wrote 2048/2048 bytes at offset 4298454016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298458112 ++wrote 2048/2048 bytes at offset 4298458112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298462208 ++wrote 2048/2048 bytes at offset 4298462208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298466304 ++wrote 2048/2048 bytes at offset 4298466304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298470400 ++wrote 2048/2048 bytes at offset 4298470400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298474496 ++wrote 2048/2048 bytes at offset 4298474496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298478592 ++wrote 2048/2048 bytes at offset 4298478592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298482688 ++wrote 2048/2048 bytes at offset 4298482688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298486784 ++wrote 2048/2048 bytes at offset 4298486784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298490880 ++wrote 2048/2048 bytes at offset 4298490880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298494976 ++wrote 2048/2048 bytes at offset 4298494976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298499072 ++wrote 2048/2048 bytes at offset 4298499072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298503168 ++wrote 2048/2048 bytes at offset 4298503168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298507264 ++wrote 2048/2048 bytes at offset 4298507264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298511360 ++wrote 2048/2048 bytes at offset 4298511360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298515456 ++wrote 2048/2048 bytes at offset 4298515456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298519552 ++wrote 2048/2048 bytes at offset 4298519552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298523648 ++wrote 2048/2048 bytes at offset 4298523648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298527744 ++wrote 2048/2048 bytes at offset 4298527744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298531840 ++wrote 2048/2048 bytes at offset 4298531840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298535936 ++wrote 2048/2048 bytes at offset 4298535936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298540032 ++wrote 2048/2048 bytes at offset 4298540032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298544128 ++wrote 2048/2048 bytes at offset 4298544128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298548224 ++wrote 2048/2048 bytes at offset 4298548224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298552320 ++wrote 2048/2048 bytes at offset 4298552320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298556416 ++wrote 2048/2048 bytes at offset 4298556416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298560512 ++wrote 2048/2048 bytes at offset 4298560512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298564608 ++wrote 2048/2048 bytes at offset 4298564608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298568704 ++wrote 2048/2048 bytes at offset 4298568704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298572800 ++wrote 2048/2048 bytes at offset 4298572800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298576896 ++wrote 2048/2048 bytes at offset 4298576896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298580992 ++wrote 2048/2048 bytes at offset 4298580992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298585088 ++wrote 2048/2048 bytes at offset 4298585088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298589184 ++wrote 2048/2048 bytes at offset 4298589184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298593280 ++wrote 2048/2048 bytes at offset 4298593280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298597376 ++wrote 2048/2048 bytes at offset 4298597376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298601472 ++wrote 2048/2048 bytes at offset 4298601472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298605568 ++wrote 2048/2048 bytes at offset 4298605568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298609664 ++wrote 2048/2048 bytes at offset 4298609664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298613760 ++wrote 2048/2048 bytes at offset 4298613760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298617856 ++wrote 2048/2048 bytes at offset 4298617856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298621952 ++wrote 2048/2048 bytes at offset 4298621952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298626048 ++wrote 2048/2048 bytes at offset 4298626048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298630144 ++wrote 2048/2048 bytes at offset 4298630144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298634240 ++wrote 2048/2048 bytes at offset 4298634240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298638336 ++wrote 2048/2048 bytes at offset 4298638336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298642432 ++wrote 2048/2048 bytes at offset 4298642432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298646528 ++wrote 2048/2048 bytes at offset 4298646528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298650624 ++wrote 2048/2048 bytes at offset 4298650624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298654720 ++wrote 2048/2048 bytes at offset 4298654720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298658816 ++wrote 2048/2048 bytes at offset 4298658816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298662912 ++wrote 2048/2048 bytes at offset 4298662912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298667008 ++wrote 2048/2048 bytes at offset 4298667008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298671104 ++wrote 2048/2048 bytes at offset 4298671104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298675200 ++wrote 2048/2048 bytes at offset 4298675200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298679296 ++wrote 2048/2048 bytes at offset 4298679296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298683392 ++wrote 2048/2048 bytes at offset 4298683392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298687488 ++wrote 2048/2048 bytes at offset 4298687488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298691584 ++wrote 2048/2048 bytes at offset 4298691584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298695680 ++wrote 2048/2048 bytes at offset 4298695680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298699776 ++wrote 2048/2048 bytes at offset 4298699776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298703872 ++wrote 2048/2048 bytes at offset 4298703872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298707968 ++wrote 2048/2048 bytes at offset 4298707968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298712064 ++wrote 2048/2048 bytes at offset 4298712064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298716160 ++wrote 2048/2048 bytes at offset 4298716160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298720256 ++wrote 2048/2048 bytes at offset 4298720256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298724352 ++wrote 2048/2048 bytes at offset 4298724352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298728448 ++wrote 2048/2048 bytes at offset 4298728448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298732544 ++wrote 2048/2048 bytes at offset 4298732544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298736640 ++wrote 2048/2048 bytes at offset 4298736640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298740736 ++wrote 2048/2048 bytes at offset 4298740736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298744832 ++wrote 2048/2048 bytes at offset 4298744832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298748928 ++wrote 2048/2048 bytes at offset 4298748928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298753024 ++wrote 2048/2048 bytes at offset 4298753024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298757120 ++wrote 2048/2048 bytes at offset 4298757120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298761216 ++wrote 2048/2048 bytes at offset 4298761216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298765312 ++wrote 2048/2048 bytes at offset 4298765312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298769408 ++wrote 2048/2048 bytes at offset 4298769408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298773504 ++wrote 2048/2048 bytes at offset 4298773504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298777600 ++wrote 2048/2048 bytes at offset 4298777600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298781696 ++wrote 2048/2048 bytes at offset 4298781696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298785792 ++wrote 2048/2048 bytes at offset 4298785792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298789888 ++wrote 2048/2048 bytes at offset 4298789888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298793984 ++wrote 2048/2048 bytes at offset 4298793984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298798080 ++wrote 2048/2048 bytes at offset 4298798080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298802176 ++wrote 2048/2048 bytes at offset 4298802176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298806272 ++wrote 2048/2048 bytes at offset 4298806272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298810368 ++wrote 2048/2048 bytes at offset 4298810368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298814464 ++wrote 2048/2048 bytes at offset 4298814464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298818560 ++wrote 2048/2048 bytes at offset 4298818560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298822656 ++wrote 2048/2048 bytes at offset 4298822656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298826752 ++wrote 2048/2048 bytes at offset 4298826752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298830848 ++wrote 2048/2048 bytes at offset 4298830848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298834944 ++wrote 2048/2048 bytes at offset 4298834944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298839040 ++wrote 2048/2048 bytes at offset 4298839040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298843136 ++wrote 2048/2048 bytes at offset 4298843136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298847232 ++wrote 2048/2048 bytes at offset 4298847232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298851328 ++wrote 2048/2048 bytes at offset 4298851328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298855424 ++wrote 2048/2048 bytes at offset 4298855424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298859520 ++wrote 2048/2048 bytes at offset 4298859520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298863616 ++wrote 2048/2048 bytes at offset 4298863616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298867712 ++wrote 2048/2048 bytes at offset 4298867712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298871808 ++wrote 2048/2048 bytes at offset 4298871808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298875904 ++wrote 2048/2048 bytes at offset 4298875904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298880000 ++wrote 2048/2048 bytes at offset 4298880000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298884096 ++wrote 2048/2048 bytes at offset 4298884096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298888192 ++wrote 2048/2048 bytes at offset 4298888192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298892288 ++wrote 2048/2048 bytes at offset 4298892288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298896384 ++wrote 2048/2048 bytes at offset 4298896384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298900480 ++wrote 2048/2048 bytes at offset 4298900480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298904576 ++wrote 2048/2048 bytes at offset 4298904576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298908672 ++wrote 2048/2048 bytes at offset 4298908672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298912768 ++wrote 2048/2048 bytes at offset 4298912768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298916864 ++wrote 2048/2048 bytes at offset 4298916864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298920960 ++wrote 2048/2048 bytes at offset 4298920960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298925056 ++wrote 2048/2048 bytes at offset 4298925056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298929152 ++wrote 2048/2048 bytes at offset 4298929152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298933248 ++wrote 2048/2048 bytes at offset 4298933248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298937344 ++wrote 2048/2048 bytes at offset 4298937344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298941440 ++wrote 2048/2048 bytes at offset 4298941440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298945536 ++wrote 2048/2048 bytes at offset 4298945536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298949632 ++wrote 2048/2048 bytes at offset 4298949632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298953728 ++wrote 2048/2048 bytes at offset 4298953728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298957824 ++wrote 2048/2048 bytes at offset 4298957824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298961920 ++wrote 2048/2048 bytes at offset 4298961920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298966016 ++wrote 2048/2048 bytes at offset 4298966016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298970112 ++wrote 2048/2048 bytes at offset 4298970112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298974208 ++wrote 2048/2048 bytes at offset 4298974208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298978304 ++wrote 2048/2048 bytes at offset 4298978304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298982400 ++wrote 2048/2048 bytes at offset 4298982400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298986496 ++wrote 2048/2048 bytes at offset 4298986496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298990592 ++wrote 2048/2048 bytes at offset 4298990592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298994688 ++wrote 2048/2048 bytes at offset 4298994688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298998784 ++wrote 2048/2048 bytes at offset 4298998784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299002880 ++wrote 2048/2048 bytes at offset 4299002880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299006976 ++wrote 2048/2048 bytes at offset 4299006976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299011072 ++wrote 2048/2048 bytes at offset 4299011072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299015168 ++wrote 2048/2048 bytes at offset 4299015168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299019264 ++wrote 2048/2048 bytes at offset 4299019264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299023360 ++wrote 2048/2048 bytes at offset 4299023360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299027456 ++wrote 2048/2048 bytes at offset 4299027456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299031552 ++wrote 2048/2048 bytes at offset 4299031552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299035648 ++wrote 2048/2048 bytes at offset 4299035648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299039744 ++wrote 2048/2048 bytes at offset 4299039744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299043840 ++wrote 2048/2048 bytes at offset 4299043840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299047936 ++wrote 2048/2048 bytes at offset 4299047936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299052032 ++wrote 2048/2048 bytes at offset 4299052032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299056128 ++wrote 2048/2048 bytes at offset 4299056128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299060224 ++wrote 2048/2048 bytes at offset 4299060224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299064320 ++wrote 2048/2048 bytes at offset 4299064320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299068416 ++wrote 2048/2048 bytes at offset 4299068416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299072512 ++wrote 2048/2048 bytes at offset 4299072512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299076608 ++wrote 2048/2048 bytes at offset 4299076608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299080704 ++wrote 2048/2048 bytes at offset 4299080704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299084800 ++wrote 2048/2048 bytes at offset 4299084800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299088896 ++wrote 2048/2048 bytes at offset 4299088896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299092992 ++wrote 2048/2048 bytes at offset 4299092992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299097088 ++wrote 2048/2048 bytes at offset 4299097088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299101184 ++wrote 2048/2048 bytes at offset 4299101184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299105280 ++wrote 2048/2048 bytes at offset 4299105280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299109376 ++wrote 2048/2048 bytes at offset 4299109376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299113472 ++wrote 2048/2048 bytes at offset 4299113472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299117568 ++wrote 2048/2048 bytes at offset 4299117568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299121664 ++wrote 2048/2048 bytes at offset 4299121664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299125760 ++wrote 2048/2048 bytes at offset 4299125760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299129856 ++wrote 2048/2048 bytes at offset 4299129856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299133952 ++wrote 2048/2048 bytes at offset 4299133952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299138048 ++wrote 2048/2048 bytes at offset 4299138048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299142144 ++wrote 2048/2048 bytes at offset 4299142144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299146240 ++wrote 2048/2048 bytes at offset 4299146240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299150336 ++wrote 2048/2048 bytes at offset 4299150336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299154432 ++wrote 2048/2048 bytes at offset 4299154432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299158528 ++wrote 2048/2048 bytes at offset 4299158528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 4 +-qemu-io> wrote 8192/8192 bytes at offset 4299163648 ++=== IO: pattern 4 ++wrote 8192/8192 bytes at offset 4299163648 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299175936 ++wrote 8192/8192 bytes at offset 4299175936 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299188224 ++wrote 8192/8192 bytes at offset 4299188224 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299200512 ++wrote 8192/8192 bytes at offset 4299200512 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299212800 ++wrote 8192/8192 bytes at offset 4299212800 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299225088 ++wrote 8192/8192 bytes at offset 4299225088 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299237376 ++wrote 8192/8192 bytes at offset 4299237376 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299249664 ++wrote 8192/8192 bytes at offset 4299249664 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299261952 ++wrote 8192/8192 bytes at offset 4299261952 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299274240 ++wrote 8192/8192 bytes at offset 4299274240 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299286528 ++wrote 8192/8192 bytes at offset 4299286528 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299298816 ++wrote 8192/8192 bytes at offset 4299298816 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299311104 ++wrote 8192/8192 bytes at offset 4299311104 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299323392 ++wrote 8192/8192 bytes at offset 4299323392 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299335680 ++wrote 8192/8192 bytes at offset 4299335680 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299347968 ++wrote 8192/8192 bytes at offset 4299347968 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299360256 ++wrote 8192/8192 bytes at offset 4299360256 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299372544 ++wrote 8192/8192 bytes at offset 4299372544 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299384832 ++wrote 8192/8192 bytes at offset 4299384832 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299397120 ++wrote 8192/8192 bytes at offset 4299397120 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299409408 ++wrote 8192/8192 bytes at offset 4299409408 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299421696 ++wrote 8192/8192 bytes at offset 4299421696 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299433984 ++wrote 8192/8192 bytes at offset 4299433984 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299446272 ++wrote 8192/8192 bytes at offset 4299446272 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299458560 ++wrote 8192/8192 bytes at offset 4299458560 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299470848 ++wrote 8192/8192 bytes at offset 4299470848 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299483136 ++wrote 8192/8192 bytes at offset 4299483136 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299495424 ++wrote 8192/8192 bytes at offset 4299495424 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299507712 ++wrote 8192/8192 bytes at offset 4299507712 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299520000 ++wrote 8192/8192 bytes at offset 4299520000 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299532288 ++wrote 8192/8192 bytes at offset 4299532288 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299544576 ++wrote 8192/8192 bytes at offset 4299544576 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299556864 ++wrote 8192/8192 bytes at offset 4299556864 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299569152 ++wrote 8192/8192 bytes at offset 4299569152 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299581440 ++wrote 8192/8192 bytes at offset 4299581440 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299593728 ++wrote 8192/8192 bytes at offset 4299593728 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299606016 ++wrote 8192/8192 bytes at offset 4299606016 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299618304 ++wrote 8192/8192 bytes at offset 4299618304 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299630592 ++wrote 8192/8192 bytes at offset 4299630592 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299642880 ++wrote 8192/8192 bytes at offset 4299642880 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299655168 ++wrote 8192/8192 bytes at offset 4299655168 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299667456 ++wrote 8192/8192 bytes at offset 4299667456 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299679744 ++wrote 8192/8192 bytes at offset 4299679744 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299692032 ++wrote 8192/8192 bytes at offset 4299692032 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299704320 ++wrote 8192/8192 bytes at offset 4299704320 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299716608 ++wrote 8192/8192 bytes at offset 4299716608 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299728896 ++wrote 8192/8192 bytes at offset 4299728896 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299741184 ++wrote 8192/8192 bytes at offset 4299741184 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299753472 ++wrote 8192/8192 bytes at offset 4299753472 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299765760 ++wrote 8192/8192 bytes at offset 4299765760 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299778048 ++wrote 8192/8192 bytes at offset 4299778048 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299790336 ++wrote 8192/8192 bytes at offset 4299790336 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299802624 ++wrote 8192/8192 bytes at offset 4299802624 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299814912 ++wrote 8192/8192 bytes at offset 4299814912 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299827200 ++wrote 8192/8192 bytes at offset 4299827200 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299839488 ++wrote 8192/8192 bytes at offset 4299839488 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299851776 ++wrote 8192/8192 bytes at offset 4299851776 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299864064 ++wrote 8192/8192 bytes at offset 4299864064 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299876352 ++wrote 8192/8192 bytes at offset 4299876352 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299888640 ++wrote 8192/8192 bytes at offset 4299888640 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299900928 ++wrote 8192/8192 bytes at offset 4299900928 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299913216 ++wrote 8192/8192 bytes at offset 4299913216 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299925504 ++wrote 8192/8192 bytes at offset 4299925504 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299937792 ++wrote 8192/8192 bytes at offset 4299937792 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 244 +-qemu-io> wrote 12288/12288 bytes at offset 4301252608 ++=== IO: pattern 244 ++wrote 12288/12288 bytes at offset 4301252608 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 4303351808 ++wrote 12288/12288 bytes at offset 4303351808 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 4305451008 ++wrote 12288/12288 bytes at offset 4305451008 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 4307550208 ++wrote 12288/12288 bytes at offset 4307550208 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 4309649408 ++wrote 12288/12288 bytes at offset 4309649408 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 4311748608 ++wrote 12288/12288 bytes at offset 4311748608 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 4313847808 ++wrote 12288/12288 bytes at offset 4313847808 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 4315947008 ++wrote 12288/12288 bytes at offset 4315947008 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> read 4096/4096 bytes at offset 4294967296 ++=== IO: pattern 0 ++read 4096/4096 bytes at offset 4294967296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294971392 ++read 4096/4096 bytes at offset 4294971392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294975488 ++read 4096/4096 bytes at offset 4294975488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294979584 ++read 4096/4096 bytes at offset 4294979584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294983680 ++read 4096/4096 bytes at offset 4294983680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294987776 ++read 4096/4096 bytes at offset 4294987776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294991872 ++read 4096/4096 bytes at offset 4294991872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294995968 ++read 4096/4096 bytes at offset 4294995968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295000064 ++read 4096/4096 bytes at offset 4295000064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295004160 ++read 4096/4096 bytes at offset 4295004160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295008256 ++read 4096/4096 bytes at offset 4295008256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295012352 ++read 4096/4096 bytes at offset 4295012352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295016448 ++read 4096/4096 bytes at offset 4295016448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295020544 ++read 4096/4096 bytes at offset 4295020544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295024640 ++read 4096/4096 bytes at offset 4295024640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295028736 ++read 4096/4096 bytes at offset 4295028736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295032832 ++read 4096/4096 bytes at offset 4295032832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295036928 ++read 4096/4096 bytes at offset 4295036928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295041024 ++read 4096/4096 bytes at offset 4295041024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295045120 ++read 4096/4096 bytes at offset 4295045120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295049216 ++read 4096/4096 bytes at offset 4295049216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295053312 ++read 4096/4096 bytes at offset 4295053312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295057408 ++read 4096/4096 bytes at offset 4295057408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295061504 ++read 4096/4096 bytes at offset 4295061504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295065600 ++read 4096/4096 bytes at offset 4295065600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295069696 ++read 4096/4096 bytes at offset 4295069696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295073792 ++read 4096/4096 bytes at offset 4295073792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295077888 ++read 4096/4096 bytes at offset 4295077888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295081984 ++read 4096/4096 bytes at offset 4295081984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295086080 ++read 4096/4096 bytes at offset 4295086080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295090176 ++read 4096/4096 bytes at offset 4295090176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295094272 ++read 4096/4096 bytes at offset 4295094272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295098368 ++read 4096/4096 bytes at offset 4295098368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295102464 ++read 4096/4096 bytes at offset 4295102464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295106560 ++read 4096/4096 bytes at offset 4295106560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295110656 ++read 4096/4096 bytes at offset 4295110656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295114752 ++read 4096/4096 bytes at offset 4295114752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295118848 ++read 4096/4096 bytes at offset 4295118848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295122944 ++read 4096/4096 bytes at offset 4295122944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295127040 ++read 4096/4096 bytes at offset 4295127040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295131136 ++read 4096/4096 bytes at offset 4295131136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295135232 ++read 4096/4096 bytes at offset 4295135232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295139328 ++read 4096/4096 bytes at offset 4295139328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295143424 ++read 4096/4096 bytes at offset 4295143424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295147520 ++read 4096/4096 bytes at offset 4295147520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295151616 ++read 4096/4096 bytes at offset 4295151616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295155712 ++read 4096/4096 bytes at offset 4295155712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295159808 ++read 4096/4096 bytes at offset 4295159808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295163904 ++read 4096/4096 bytes at offset 4295163904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295168000 ++read 4096/4096 bytes at offset 4295168000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295172096 ++read 4096/4096 bytes at offset 4295172096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295176192 ++read 4096/4096 bytes at offset 4295176192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295180288 ++read 4096/4096 bytes at offset 4295180288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295184384 ++read 4096/4096 bytes at offset 4295184384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295188480 ++read 4096/4096 bytes at offset 4295188480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295192576 ++read 4096/4096 bytes at offset 4295192576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295196672 ++read 4096/4096 bytes at offset 4295196672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295200768 ++read 4096/4096 bytes at offset 4295200768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295204864 ++read 4096/4096 bytes at offset 4295204864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295208960 ++read 4096/4096 bytes at offset 4295208960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295213056 ++read 4096/4096 bytes at offset 4295213056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295217152 ++read 4096/4096 bytes at offset 4295217152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295221248 ++read 4096/4096 bytes at offset 4295221248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295225344 ++read 4096/4096 bytes at offset 4295225344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295229440 ++read 4096/4096 bytes at offset 4295229440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295233536 ++read 4096/4096 bytes at offset 4295233536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295237632 ++read 4096/4096 bytes at offset 4295237632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295241728 ++read 4096/4096 bytes at offset 4295241728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295245824 ++read 4096/4096 bytes at offset 4295245824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295249920 ++read 4096/4096 bytes at offset 4295249920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295254016 ++read 4096/4096 bytes at offset 4295254016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295258112 ++read 4096/4096 bytes at offset 4295258112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295262208 ++read 4096/4096 bytes at offset 4295262208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295266304 ++read 4096/4096 bytes at offset 4295266304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295270400 ++read 4096/4096 bytes at offset 4295270400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295274496 ++read 4096/4096 bytes at offset 4295274496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295278592 ++read 4096/4096 bytes at offset 4295278592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295282688 ++read 4096/4096 bytes at offset 4295282688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295286784 ++read 4096/4096 bytes at offset 4295286784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295290880 ++read 4096/4096 bytes at offset 4295290880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295294976 ++read 4096/4096 bytes at offset 4295294976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295299072 ++read 4096/4096 bytes at offset 4295299072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295303168 ++read 4096/4096 bytes at offset 4295303168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295307264 ++read 4096/4096 bytes at offset 4295307264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295311360 ++read 4096/4096 bytes at offset 4295311360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295315456 ++read 4096/4096 bytes at offset 4295315456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295319552 ++read 4096/4096 bytes at offset 4295319552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295323648 ++read 4096/4096 bytes at offset 4295323648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295327744 ++read 4096/4096 bytes at offset 4295327744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295331840 ++read 4096/4096 bytes at offset 4295331840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295335936 ++read 4096/4096 bytes at offset 4295335936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295340032 ++read 4096/4096 bytes at offset 4295340032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295344128 ++read 4096/4096 bytes at offset 4295344128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295348224 ++read 4096/4096 bytes at offset 4295348224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295352320 ++read 4096/4096 bytes at offset 4295352320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295356416 ++read 4096/4096 bytes at offset 4295356416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295360512 ++read 4096/4096 bytes at offset 4295360512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295364608 ++read 4096/4096 bytes at offset 4295364608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295368704 ++read 4096/4096 bytes at offset 4295368704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295372800 ++read 4096/4096 bytes at offset 4295372800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295376896 ++read 4096/4096 bytes at offset 4295376896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295380992 ++read 4096/4096 bytes at offset 4295380992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295385088 ++read 4096/4096 bytes at offset 4295385088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295389184 ++read 4096/4096 bytes at offset 4295389184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295393280 ++read 4096/4096 bytes at offset 4295393280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295397376 ++read 4096/4096 bytes at offset 4295397376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295401472 ++read 4096/4096 bytes at offset 4295401472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295405568 ++read 4096/4096 bytes at offset 4295405568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295409664 ++read 4096/4096 bytes at offset 4295409664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295413760 ++read 4096/4096 bytes at offset 4295413760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295417856 ++read 4096/4096 bytes at offset 4295417856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295421952 ++read 4096/4096 bytes at offset 4295421952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295426048 ++read 4096/4096 bytes at offset 4295426048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295430144 ++read 4096/4096 bytes at offset 4295430144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295434240 ++read 4096/4096 bytes at offset 4295434240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295438336 ++read 4096/4096 bytes at offset 4295438336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295442432 ++read 4096/4096 bytes at offset 4295442432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295446528 ++read 4096/4096 bytes at offset 4295446528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295450624 ++read 4096/4096 bytes at offset 4295450624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295454720 ++read 4096/4096 bytes at offset 4295454720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295458816 ++read 4096/4096 bytes at offset 4295458816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295462912 ++read 4096/4096 bytes at offset 4295462912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295467008 ++read 4096/4096 bytes at offset 4295467008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295471104 ++read 4096/4096 bytes at offset 4295471104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295475200 ++read 4096/4096 bytes at offset 4295475200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295479296 ++read 4096/4096 bytes at offset 4295479296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295483392 ++read 4096/4096 bytes at offset 4295483392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295487488 ++read 4096/4096 bytes at offset 4295487488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295491584 ++read 4096/4096 bytes at offset 4295491584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295495680 ++read 4096/4096 bytes at offset 4295495680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295499776 ++read 4096/4096 bytes at offset 4295499776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295503872 ++read 4096/4096 bytes at offset 4295503872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295507968 ++read 4096/4096 bytes at offset 4295507968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295512064 ++read 4096/4096 bytes at offset 4295512064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295516160 ++read 4096/4096 bytes at offset 4295516160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295520256 ++read 4096/4096 bytes at offset 4295520256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295524352 ++read 4096/4096 bytes at offset 4295524352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295528448 ++read 4096/4096 bytes at offset 4295528448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295532544 ++read 4096/4096 bytes at offset 4295532544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295536640 ++read 4096/4096 bytes at offset 4295536640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295540736 ++read 4096/4096 bytes at offset 4295540736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295544832 ++read 4096/4096 bytes at offset 4295544832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295548928 ++read 4096/4096 bytes at offset 4295548928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295553024 ++read 4096/4096 bytes at offset 4295553024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295557120 ++read 4096/4096 bytes at offset 4295557120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295561216 ++read 4096/4096 bytes at offset 4295561216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295565312 ++read 4096/4096 bytes at offset 4295565312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295569408 ++read 4096/4096 bytes at offset 4295569408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295573504 ++read 4096/4096 bytes at offset 4295573504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295577600 ++read 4096/4096 bytes at offset 4295577600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295581696 ++read 4096/4096 bytes at offset 4295581696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295585792 ++read 4096/4096 bytes at offset 4295585792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295589888 ++read 4096/4096 bytes at offset 4295589888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295593984 ++read 4096/4096 bytes at offset 4295593984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295598080 ++read 4096/4096 bytes at offset 4295598080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295602176 ++read 4096/4096 bytes at offset 4295602176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295606272 ++read 4096/4096 bytes at offset 4295606272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295610368 ++read 4096/4096 bytes at offset 4295610368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295614464 ++read 4096/4096 bytes at offset 4295614464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295618560 ++read 4096/4096 bytes at offset 4295618560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295622656 ++read 4096/4096 bytes at offset 4295622656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295626752 ++read 4096/4096 bytes at offset 4295626752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295630848 ++read 4096/4096 bytes at offset 4295630848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295634944 ++read 4096/4096 bytes at offset 4295634944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295639040 ++read 4096/4096 bytes at offset 4295639040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295643136 ++read 4096/4096 bytes at offset 4295643136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295647232 ++read 4096/4096 bytes at offset 4295647232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295651328 ++read 4096/4096 bytes at offset 4295651328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295655424 ++read 4096/4096 bytes at offset 4295655424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295659520 ++read 4096/4096 bytes at offset 4295659520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295663616 ++read 4096/4096 bytes at offset 4295663616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295667712 ++read 4096/4096 bytes at offset 4295667712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295671808 ++read 4096/4096 bytes at offset 4295671808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295675904 ++read 4096/4096 bytes at offset 4295675904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295680000 ++read 4096/4096 bytes at offset 4295680000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295684096 ++read 4096/4096 bytes at offset 4295684096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295688192 ++read 4096/4096 bytes at offset 4295688192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295692288 ++read 4096/4096 bytes at offset 4295692288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295696384 ++read 4096/4096 bytes at offset 4295696384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295700480 ++read 4096/4096 bytes at offset 4295700480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295704576 ++read 4096/4096 bytes at offset 4295704576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295708672 ++read 4096/4096 bytes at offset 4295708672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295712768 ++read 4096/4096 bytes at offset 4295712768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295716864 ++read 4096/4096 bytes at offset 4295716864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295720960 ++read 4096/4096 bytes at offset 4295720960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295725056 ++read 4096/4096 bytes at offset 4295725056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295729152 ++read 4096/4096 bytes at offset 4295729152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295733248 ++read 4096/4096 bytes at offset 4295733248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295737344 ++read 4096/4096 bytes at offset 4295737344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295741440 ++read 4096/4096 bytes at offset 4295741440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295745536 ++read 4096/4096 bytes at offset 4295745536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295749632 ++read 4096/4096 bytes at offset 4295749632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295753728 ++read 4096/4096 bytes at offset 4295753728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295757824 ++read 4096/4096 bytes at offset 4295757824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295761920 ++read 4096/4096 bytes at offset 4295761920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295766016 ++read 4096/4096 bytes at offset 4295766016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295770112 ++read 4096/4096 bytes at offset 4295770112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295774208 ++read 4096/4096 bytes at offset 4295774208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295778304 ++read 4096/4096 bytes at offset 4295778304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295782400 ++read 4096/4096 bytes at offset 4295782400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295786496 ++read 4096/4096 bytes at offset 4295786496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295790592 ++read 4096/4096 bytes at offset 4295790592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295794688 ++read 4096/4096 bytes at offset 4295794688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295798784 ++read 4096/4096 bytes at offset 4295798784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295802880 ++read 4096/4096 bytes at offset 4295802880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295806976 ++read 4096/4096 bytes at offset 4295806976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295811072 ++read 4096/4096 bytes at offset 4295811072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295815168 ++read 4096/4096 bytes at offset 4295815168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295819264 ++read 4096/4096 bytes at offset 4295819264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295823360 ++read 4096/4096 bytes at offset 4295823360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295827456 ++read 4096/4096 bytes at offset 4295827456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295831552 ++read 4096/4096 bytes at offset 4295831552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295835648 ++read 4096/4096 bytes at offset 4295835648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295839744 ++read 4096/4096 bytes at offset 4295839744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295843840 ++read 4096/4096 bytes at offset 4295843840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295847936 ++read 4096/4096 bytes at offset 4295847936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295852032 ++read 4096/4096 bytes at offset 4295852032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295856128 ++read 4096/4096 bytes at offset 4295856128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295860224 ++read 4096/4096 bytes at offset 4295860224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295864320 ++read 4096/4096 bytes at offset 4295864320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295868416 ++read 4096/4096 bytes at offset 4295868416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295872512 ++read 4096/4096 bytes at offset 4295872512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295876608 ++read 4096/4096 bytes at offset 4295876608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295880704 ++read 4096/4096 bytes at offset 4295880704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295884800 ++read 4096/4096 bytes at offset 4295884800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295888896 ++read 4096/4096 bytes at offset 4295888896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295892992 ++read 4096/4096 bytes at offset 4295892992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295897088 ++read 4096/4096 bytes at offset 4295897088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295901184 ++read 4096/4096 bytes at offset 4295901184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295905280 ++read 4096/4096 bytes at offset 4295905280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295909376 ++read 4096/4096 bytes at offset 4295909376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295913472 ++read 4096/4096 bytes at offset 4295913472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295917568 ++read 4096/4096 bytes at offset 4295917568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295921664 ++read 4096/4096 bytes at offset 4295921664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295925760 ++read 4096/4096 bytes at offset 4295925760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295929856 ++read 4096/4096 bytes at offset 4295929856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295933952 ++read 4096/4096 bytes at offset 4295933952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295938048 ++read 4096/4096 bytes at offset 4295938048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295942144 ++read 4096/4096 bytes at offset 4295942144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295946240 ++read 4096/4096 bytes at offset 4295946240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295950336 ++read 4096/4096 bytes at offset 4295950336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295954432 ++read 4096/4096 bytes at offset 4295954432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295958528 ++read 4096/4096 bytes at offset 4295958528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295962624 ++read 4096/4096 bytes at offset 4295962624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295966720 ++read 4096/4096 bytes at offset 4295966720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295970816 ++read 4096/4096 bytes at offset 4295970816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295974912 ++read 4096/4096 bytes at offset 4295974912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295979008 ++read 4096/4096 bytes at offset 4295979008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295983104 ++read 4096/4096 bytes at offset 4295983104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295987200 ++read 4096/4096 bytes at offset 4295987200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295991296 ++read 4096/4096 bytes at offset 4295991296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295995392 ++read 4096/4096 bytes at offset 4295995392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295999488 ++read 4096/4096 bytes at offset 4295999488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4296003584 ++read 4096/4096 bytes at offset 4296003584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4296007680 ++read 4096/4096 bytes at offset 4296007680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4296011776 ++read 4096/4096 bytes at offset 4296011776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 4 +-qemu-io> read 2048/2048 bytes at offset 4296017920 ++=== IO: pattern 4 ++read 2048/2048 bytes at offset 4296017920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296022016 ++read 2048/2048 bytes at offset 4296022016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296026112 ++read 2048/2048 bytes at offset 4296026112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296030208 ++read 2048/2048 bytes at offset 4296030208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296034304 ++read 2048/2048 bytes at offset 4296034304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296038400 ++read 2048/2048 bytes at offset 4296038400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296042496 ++read 2048/2048 bytes at offset 4296042496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296046592 ++read 2048/2048 bytes at offset 4296046592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296050688 ++read 2048/2048 bytes at offset 4296050688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296054784 ++read 2048/2048 bytes at offset 4296054784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296058880 ++read 2048/2048 bytes at offset 4296058880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296062976 ++read 2048/2048 bytes at offset 4296062976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296067072 ++read 2048/2048 bytes at offset 4296067072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296071168 ++read 2048/2048 bytes at offset 4296071168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296075264 ++read 2048/2048 bytes at offset 4296075264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296079360 ++read 2048/2048 bytes at offset 4296079360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296083456 ++read 2048/2048 bytes at offset 4296083456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296087552 ++read 2048/2048 bytes at offset 4296087552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296091648 ++read 2048/2048 bytes at offset 4296091648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296095744 ++read 2048/2048 bytes at offset 4296095744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296099840 ++read 2048/2048 bytes at offset 4296099840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296103936 ++read 2048/2048 bytes at offset 4296103936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296108032 ++read 2048/2048 bytes at offset 4296108032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296112128 ++read 2048/2048 bytes at offset 4296112128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296116224 ++read 2048/2048 bytes at offset 4296116224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296120320 ++read 2048/2048 bytes at offset 4296120320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296124416 ++read 2048/2048 bytes at offset 4296124416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296128512 ++read 2048/2048 bytes at offset 4296128512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296132608 ++read 2048/2048 bytes at offset 4296132608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296136704 ++read 2048/2048 bytes at offset 4296136704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296140800 ++read 2048/2048 bytes at offset 4296140800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296144896 ++read 2048/2048 bytes at offset 4296144896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296148992 ++read 2048/2048 bytes at offset 4296148992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296153088 ++read 2048/2048 bytes at offset 4296153088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296157184 ++read 2048/2048 bytes at offset 4296157184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296161280 ++read 2048/2048 bytes at offset 4296161280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296165376 ++read 2048/2048 bytes at offset 4296165376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296169472 ++read 2048/2048 bytes at offset 4296169472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296173568 ++read 2048/2048 bytes at offset 4296173568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296177664 ++read 2048/2048 bytes at offset 4296177664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296181760 ++read 2048/2048 bytes at offset 4296181760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296185856 ++read 2048/2048 bytes at offset 4296185856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296189952 ++read 2048/2048 bytes at offset 4296189952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296194048 ++read 2048/2048 bytes at offset 4296194048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296198144 ++read 2048/2048 bytes at offset 4296198144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296202240 ++read 2048/2048 bytes at offset 4296202240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296206336 ++read 2048/2048 bytes at offset 4296206336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296210432 ++read 2048/2048 bytes at offset 4296210432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296214528 ++read 2048/2048 bytes at offset 4296214528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296218624 ++read 2048/2048 bytes at offset 4296218624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296222720 ++read 2048/2048 bytes at offset 4296222720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296226816 ++read 2048/2048 bytes at offset 4296226816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296230912 ++read 2048/2048 bytes at offset 4296230912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296235008 ++read 2048/2048 bytes at offset 4296235008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296239104 ++read 2048/2048 bytes at offset 4296239104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296243200 ++read 2048/2048 bytes at offset 4296243200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296247296 ++read 2048/2048 bytes at offset 4296247296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296251392 ++read 2048/2048 bytes at offset 4296251392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296255488 ++read 2048/2048 bytes at offset 4296255488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296259584 ++read 2048/2048 bytes at offset 4296259584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296263680 ++read 2048/2048 bytes at offset 4296263680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296267776 ++read 2048/2048 bytes at offset 4296267776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296271872 ++read 2048/2048 bytes at offset 4296271872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296275968 ++read 2048/2048 bytes at offset 4296275968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296280064 ++read 2048/2048 bytes at offset 4296280064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296284160 ++read 2048/2048 bytes at offset 4296284160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296288256 ++read 2048/2048 bytes at offset 4296288256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296292352 ++read 2048/2048 bytes at offset 4296292352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296296448 ++read 2048/2048 bytes at offset 4296296448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296300544 ++read 2048/2048 bytes at offset 4296300544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296304640 ++read 2048/2048 bytes at offset 4296304640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296308736 ++read 2048/2048 bytes at offset 4296308736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296312832 ++read 2048/2048 bytes at offset 4296312832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296316928 ++read 2048/2048 bytes at offset 4296316928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296321024 ++read 2048/2048 bytes at offset 4296321024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296325120 ++read 2048/2048 bytes at offset 4296325120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296329216 ++read 2048/2048 bytes at offset 4296329216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296333312 ++read 2048/2048 bytes at offset 4296333312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296337408 ++read 2048/2048 bytes at offset 4296337408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296341504 ++read 2048/2048 bytes at offset 4296341504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296345600 ++read 2048/2048 bytes at offset 4296345600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296349696 ++read 2048/2048 bytes at offset 4296349696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296353792 ++read 2048/2048 bytes at offset 4296353792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296357888 ++read 2048/2048 bytes at offset 4296357888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296361984 ++read 2048/2048 bytes at offset 4296361984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296366080 ++read 2048/2048 bytes at offset 4296366080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296370176 ++read 2048/2048 bytes at offset 4296370176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296374272 ++read 2048/2048 bytes at offset 4296374272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296378368 ++read 2048/2048 bytes at offset 4296378368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296382464 ++read 2048/2048 bytes at offset 4296382464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296386560 ++read 2048/2048 bytes at offset 4296386560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296390656 ++read 2048/2048 bytes at offset 4296390656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296394752 ++read 2048/2048 bytes at offset 4296394752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296398848 ++read 2048/2048 bytes at offset 4296398848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296402944 ++read 2048/2048 bytes at offset 4296402944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296407040 ++read 2048/2048 bytes at offset 4296407040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296411136 ++read 2048/2048 bytes at offset 4296411136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296415232 ++read 2048/2048 bytes at offset 4296415232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296419328 ++read 2048/2048 bytes at offset 4296419328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296423424 ++read 2048/2048 bytes at offset 4296423424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296427520 ++read 2048/2048 bytes at offset 4296427520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296431616 ++read 2048/2048 bytes at offset 4296431616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296435712 ++read 2048/2048 bytes at offset 4296435712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296439808 ++read 2048/2048 bytes at offset 4296439808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296443904 ++read 2048/2048 bytes at offset 4296443904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296448000 ++read 2048/2048 bytes at offset 4296448000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296452096 ++read 2048/2048 bytes at offset 4296452096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296456192 ++read 2048/2048 bytes at offset 4296456192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296460288 ++read 2048/2048 bytes at offset 4296460288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296464384 ++read 2048/2048 bytes at offset 4296464384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296468480 ++read 2048/2048 bytes at offset 4296468480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296472576 ++read 2048/2048 bytes at offset 4296472576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296476672 ++read 2048/2048 bytes at offset 4296476672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296480768 ++read 2048/2048 bytes at offset 4296480768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296484864 ++read 2048/2048 bytes at offset 4296484864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296488960 ++read 2048/2048 bytes at offset 4296488960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296493056 ++read 2048/2048 bytes at offset 4296493056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296497152 ++read 2048/2048 bytes at offset 4296497152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296501248 ++read 2048/2048 bytes at offset 4296501248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296505344 ++read 2048/2048 bytes at offset 4296505344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296509440 ++read 2048/2048 bytes at offset 4296509440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296513536 ++read 2048/2048 bytes at offset 4296513536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296517632 ++read 2048/2048 bytes at offset 4296517632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296521728 ++read 2048/2048 bytes at offset 4296521728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296525824 ++read 2048/2048 bytes at offset 4296525824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296529920 ++read 2048/2048 bytes at offset 4296529920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296534016 ++read 2048/2048 bytes at offset 4296534016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296538112 ++read 2048/2048 bytes at offset 4296538112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296542208 ++read 2048/2048 bytes at offset 4296542208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296546304 ++read 2048/2048 bytes at offset 4296546304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296550400 ++read 2048/2048 bytes at offset 4296550400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296554496 ++read 2048/2048 bytes at offset 4296554496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296558592 ++read 2048/2048 bytes at offset 4296558592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296562688 ++read 2048/2048 bytes at offset 4296562688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296566784 ++read 2048/2048 bytes at offset 4296566784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296570880 ++read 2048/2048 bytes at offset 4296570880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296574976 ++read 2048/2048 bytes at offset 4296574976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296579072 ++read 2048/2048 bytes at offset 4296579072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296583168 ++read 2048/2048 bytes at offset 4296583168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296587264 ++read 2048/2048 bytes at offset 4296587264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296591360 ++read 2048/2048 bytes at offset 4296591360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296595456 ++read 2048/2048 bytes at offset 4296595456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296599552 ++read 2048/2048 bytes at offset 4296599552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296603648 ++read 2048/2048 bytes at offset 4296603648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296607744 ++read 2048/2048 bytes at offset 4296607744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296611840 ++read 2048/2048 bytes at offset 4296611840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296615936 ++read 2048/2048 bytes at offset 4296615936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296620032 ++read 2048/2048 bytes at offset 4296620032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296624128 ++read 2048/2048 bytes at offset 4296624128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296628224 ++read 2048/2048 bytes at offset 4296628224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296632320 ++read 2048/2048 bytes at offset 4296632320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296636416 ++read 2048/2048 bytes at offset 4296636416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296640512 ++read 2048/2048 bytes at offset 4296640512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296644608 ++read 2048/2048 bytes at offset 4296644608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296648704 ++read 2048/2048 bytes at offset 4296648704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296652800 ++read 2048/2048 bytes at offset 4296652800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296656896 ++read 2048/2048 bytes at offset 4296656896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296660992 ++read 2048/2048 bytes at offset 4296660992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296665088 ++read 2048/2048 bytes at offset 4296665088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296669184 ++read 2048/2048 bytes at offset 4296669184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296673280 ++read 2048/2048 bytes at offset 4296673280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296677376 ++read 2048/2048 bytes at offset 4296677376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296681472 ++read 2048/2048 bytes at offset 4296681472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296685568 ++read 2048/2048 bytes at offset 4296685568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296689664 ++read 2048/2048 bytes at offset 4296689664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296693760 ++read 2048/2048 bytes at offset 4296693760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296697856 ++read 2048/2048 bytes at offset 4296697856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296701952 ++read 2048/2048 bytes at offset 4296701952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296706048 ++read 2048/2048 bytes at offset 4296706048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296710144 ++read 2048/2048 bytes at offset 4296710144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296714240 ++read 2048/2048 bytes at offset 4296714240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296718336 ++read 2048/2048 bytes at offset 4296718336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296722432 ++read 2048/2048 bytes at offset 4296722432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296726528 ++read 2048/2048 bytes at offset 4296726528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296730624 ++read 2048/2048 bytes at offset 4296730624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296734720 ++read 2048/2048 bytes at offset 4296734720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296738816 ++read 2048/2048 bytes at offset 4296738816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296742912 ++read 2048/2048 bytes at offset 4296742912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296747008 ++read 2048/2048 bytes at offset 4296747008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296751104 ++read 2048/2048 bytes at offset 4296751104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296755200 ++read 2048/2048 bytes at offset 4296755200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296759296 ++read 2048/2048 bytes at offset 4296759296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296763392 ++read 2048/2048 bytes at offset 4296763392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296767488 ++read 2048/2048 bytes at offset 4296767488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296771584 ++read 2048/2048 bytes at offset 4296771584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296775680 ++read 2048/2048 bytes at offset 4296775680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296779776 ++read 2048/2048 bytes at offset 4296779776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296783872 ++read 2048/2048 bytes at offset 4296783872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296787968 ++read 2048/2048 bytes at offset 4296787968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296792064 ++read 2048/2048 bytes at offset 4296792064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296796160 ++read 2048/2048 bytes at offset 4296796160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296800256 ++read 2048/2048 bytes at offset 4296800256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296804352 ++read 2048/2048 bytes at offset 4296804352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296808448 ++read 2048/2048 bytes at offset 4296808448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296812544 ++read 2048/2048 bytes at offset 4296812544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296816640 ++read 2048/2048 bytes at offset 4296816640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296820736 ++read 2048/2048 bytes at offset 4296820736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296824832 ++read 2048/2048 bytes at offset 4296824832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296828928 ++read 2048/2048 bytes at offset 4296828928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296833024 ++read 2048/2048 bytes at offset 4296833024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296837120 ++read 2048/2048 bytes at offset 4296837120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296841216 ++read 2048/2048 bytes at offset 4296841216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296845312 ++read 2048/2048 bytes at offset 4296845312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296849408 ++read 2048/2048 bytes at offset 4296849408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296853504 ++read 2048/2048 bytes at offset 4296853504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296857600 ++read 2048/2048 bytes at offset 4296857600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296861696 ++read 2048/2048 bytes at offset 4296861696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296865792 ++read 2048/2048 bytes at offset 4296865792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296869888 ++read 2048/2048 bytes at offset 4296869888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296873984 ++read 2048/2048 bytes at offset 4296873984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296878080 ++read 2048/2048 bytes at offset 4296878080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296882176 ++read 2048/2048 bytes at offset 4296882176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296886272 ++read 2048/2048 bytes at offset 4296886272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296890368 ++read 2048/2048 bytes at offset 4296890368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296894464 ++read 2048/2048 bytes at offset 4296894464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296898560 ++read 2048/2048 bytes at offset 4296898560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296902656 ++read 2048/2048 bytes at offset 4296902656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296906752 ++read 2048/2048 bytes at offset 4296906752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296910848 ++read 2048/2048 bytes at offset 4296910848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296914944 ++read 2048/2048 bytes at offset 4296914944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296919040 ++read 2048/2048 bytes at offset 4296919040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296923136 ++read 2048/2048 bytes at offset 4296923136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296927232 ++read 2048/2048 bytes at offset 4296927232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296931328 ++read 2048/2048 bytes at offset 4296931328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296935424 ++read 2048/2048 bytes at offset 4296935424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296939520 ++read 2048/2048 bytes at offset 4296939520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296943616 ++read 2048/2048 bytes at offset 4296943616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296947712 ++read 2048/2048 bytes at offset 4296947712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296951808 ++read 2048/2048 bytes at offset 4296951808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296955904 ++read 2048/2048 bytes at offset 4296955904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296960000 ++read 2048/2048 bytes at offset 4296960000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296964096 ++read 2048/2048 bytes at offset 4296964096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296968192 ++read 2048/2048 bytes at offset 4296968192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296972288 ++read 2048/2048 bytes at offset 4296972288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296976384 ++read 2048/2048 bytes at offset 4296976384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296980480 ++read 2048/2048 bytes at offset 4296980480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296984576 ++read 2048/2048 bytes at offset 4296984576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296988672 ++read 2048/2048 bytes at offset 4296988672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296992768 ++read 2048/2048 bytes at offset 4296992768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296996864 ++read 2048/2048 bytes at offset 4296996864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297000960 ++read 2048/2048 bytes at offset 4297000960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297005056 ++read 2048/2048 bytes at offset 4297005056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297009152 ++read 2048/2048 bytes at offset 4297009152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297013248 ++read 2048/2048 bytes at offset 4297013248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297017344 ++read 2048/2048 bytes at offset 4297017344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297021440 ++read 2048/2048 bytes at offset 4297021440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297025536 ++read 2048/2048 bytes at offset 4297025536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297029632 ++read 2048/2048 bytes at offset 4297029632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297033728 ++read 2048/2048 bytes at offset 4297033728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297037824 ++read 2048/2048 bytes at offset 4297037824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297041920 ++read 2048/2048 bytes at offset 4297041920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297046016 ++read 2048/2048 bytes at offset 4297046016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297050112 ++read 2048/2048 bytes at offset 4297050112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297054208 ++read 2048/2048 bytes at offset 4297054208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297058304 ++read 2048/2048 bytes at offset 4297058304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297062400 ++read 2048/2048 bytes at offset 4297062400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> read 2048/2048 bytes at offset 4297064448 ++=== IO: pattern 0 ++read 2048/2048 bytes at offset 4297064448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297068544 ++read 2048/2048 bytes at offset 4297068544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297072640 ++read 2048/2048 bytes at offset 4297072640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297076736 ++read 2048/2048 bytes at offset 4297076736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297080832 ++read 2048/2048 bytes at offset 4297080832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297084928 ++read 2048/2048 bytes at offset 4297084928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297089024 ++read 2048/2048 bytes at offset 4297089024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297093120 ++read 2048/2048 bytes at offset 4297093120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297097216 ++read 2048/2048 bytes at offset 4297097216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297101312 ++read 2048/2048 bytes at offset 4297101312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297105408 ++read 2048/2048 bytes at offset 4297105408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297109504 ++read 2048/2048 bytes at offset 4297109504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297113600 ++read 2048/2048 bytes at offset 4297113600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297117696 ++read 2048/2048 bytes at offset 4297117696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297121792 ++read 2048/2048 bytes at offset 4297121792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297125888 ++read 2048/2048 bytes at offset 4297125888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297129984 ++read 2048/2048 bytes at offset 4297129984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297134080 ++read 2048/2048 bytes at offset 4297134080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297138176 ++read 2048/2048 bytes at offset 4297138176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297142272 ++read 2048/2048 bytes at offset 4297142272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297146368 ++read 2048/2048 bytes at offset 4297146368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297150464 ++read 2048/2048 bytes at offset 4297150464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297154560 ++read 2048/2048 bytes at offset 4297154560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297158656 ++read 2048/2048 bytes at offset 4297158656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297162752 ++read 2048/2048 bytes at offset 4297162752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297166848 ++read 2048/2048 bytes at offset 4297166848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297170944 ++read 2048/2048 bytes at offset 4297170944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297175040 ++read 2048/2048 bytes at offset 4297175040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297179136 ++read 2048/2048 bytes at offset 4297179136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297183232 ++read 2048/2048 bytes at offset 4297183232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297187328 ++read 2048/2048 bytes at offset 4297187328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297191424 ++read 2048/2048 bytes at offset 4297191424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297195520 ++read 2048/2048 bytes at offset 4297195520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297199616 ++read 2048/2048 bytes at offset 4297199616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297203712 ++read 2048/2048 bytes at offset 4297203712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297207808 ++read 2048/2048 bytes at offset 4297207808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297211904 ++read 2048/2048 bytes at offset 4297211904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297216000 ++read 2048/2048 bytes at offset 4297216000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297220096 ++read 2048/2048 bytes at offset 4297220096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297224192 ++read 2048/2048 bytes at offset 4297224192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297228288 ++read 2048/2048 bytes at offset 4297228288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297232384 ++read 2048/2048 bytes at offset 4297232384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297236480 ++read 2048/2048 bytes at offset 4297236480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297240576 ++read 2048/2048 bytes at offset 4297240576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297244672 ++read 2048/2048 bytes at offset 4297244672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297248768 ++read 2048/2048 bytes at offset 4297248768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297252864 ++read 2048/2048 bytes at offset 4297252864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297256960 ++read 2048/2048 bytes at offset 4297256960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297261056 ++read 2048/2048 bytes at offset 4297261056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297265152 ++read 2048/2048 bytes at offset 4297265152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297269248 ++read 2048/2048 bytes at offset 4297269248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297273344 ++read 2048/2048 bytes at offset 4297273344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297277440 ++read 2048/2048 bytes at offset 4297277440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297281536 ++read 2048/2048 bytes at offset 4297281536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297285632 ++read 2048/2048 bytes at offset 4297285632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297289728 ++read 2048/2048 bytes at offset 4297289728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297293824 ++read 2048/2048 bytes at offset 4297293824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297297920 ++read 2048/2048 bytes at offset 4297297920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297302016 ++read 2048/2048 bytes at offset 4297302016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297306112 ++read 2048/2048 bytes at offset 4297306112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297310208 ++read 2048/2048 bytes at offset 4297310208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297314304 ++read 2048/2048 bytes at offset 4297314304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297318400 ++read 2048/2048 bytes at offset 4297318400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297322496 ++read 2048/2048 bytes at offset 4297322496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297326592 ++read 2048/2048 bytes at offset 4297326592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297330688 ++read 2048/2048 bytes at offset 4297330688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297334784 ++read 2048/2048 bytes at offset 4297334784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297338880 ++read 2048/2048 bytes at offset 4297338880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297342976 ++read 2048/2048 bytes at offset 4297342976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297347072 ++read 2048/2048 bytes at offset 4297347072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297351168 ++read 2048/2048 bytes at offset 4297351168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297355264 ++read 2048/2048 bytes at offset 4297355264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297359360 ++read 2048/2048 bytes at offset 4297359360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297363456 ++read 2048/2048 bytes at offset 4297363456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297367552 ++read 2048/2048 bytes at offset 4297367552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297371648 ++read 2048/2048 bytes at offset 4297371648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297375744 ++read 2048/2048 bytes at offset 4297375744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297379840 ++read 2048/2048 bytes at offset 4297379840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297383936 ++read 2048/2048 bytes at offset 4297383936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297388032 ++read 2048/2048 bytes at offset 4297388032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297392128 ++read 2048/2048 bytes at offset 4297392128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297396224 ++read 2048/2048 bytes at offset 4297396224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297400320 ++read 2048/2048 bytes at offset 4297400320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297404416 ++read 2048/2048 bytes at offset 4297404416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297408512 ++read 2048/2048 bytes at offset 4297408512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297412608 ++read 2048/2048 bytes at offset 4297412608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297416704 ++read 2048/2048 bytes at offset 4297416704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297420800 ++read 2048/2048 bytes at offset 4297420800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297424896 ++read 2048/2048 bytes at offset 4297424896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297428992 ++read 2048/2048 bytes at offset 4297428992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297433088 ++read 2048/2048 bytes at offset 4297433088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297437184 ++read 2048/2048 bytes at offset 4297437184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297441280 ++read 2048/2048 bytes at offset 4297441280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297445376 ++read 2048/2048 bytes at offset 4297445376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297449472 ++read 2048/2048 bytes at offset 4297449472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297453568 ++read 2048/2048 bytes at offset 4297453568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297457664 ++read 2048/2048 bytes at offset 4297457664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297461760 ++read 2048/2048 bytes at offset 4297461760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297465856 ++read 2048/2048 bytes at offset 4297465856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297469952 ++read 2048/2048 bytes at offset 4297469952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297474048 ++read 2048/2048 bytes at offset 4297474048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297478144 ++read 2048/2048 bytes at offset 4297478144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297482240 ++read 2048/2048 bytes at offset 4297482240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297486336 ++read 2048/2048 bytes at offset 4297486336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297490432 ++read 2048/2048 bytes at offset 4297490432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297494528 ++read 2048/2048 bytes at offset 4297494528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297498624 ++read 2048/2048 bytes at offset 4297498624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297502720 ++read 2048/2048 bytes at offset 4297502720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297506816 ++read 2048/2048 bytes at offset 4297506816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297510912 ++read 2048/2048 bytes at offset 4297510912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297515008 ++read 2048/2048 bytes at offset 4297515008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297519104 ++read 2048/2048 bytes at offset 4297519104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297523200 ++read 2048/2048 bytes at offset 4297523200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297527296 ++read 2048/2048 bytes at offset 4297527296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297531392 ++read 2048/2048 bytes at offset 4297531392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297535488 ++read 2048/2048 bytes at offset 4297535488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297539584 ++read 2048/2048 bytes at offset 4297539584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297543680 ++read 2048/2048 bytes at offset 4297543680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297547776 ++read 2048/2048 bytes at offset 4297547776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297551872 ++read 2048/2048 bytes at offset 4297551872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297555968 ++read 2048/2048 bytes at offset 4297555968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297560064 ++read 2048/2048 bytes at offset 4297560064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297564160 ++read 2048/2048 bytes at offset 4297564160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297568256 ++read 2048/2048 bytes at offset 4297568256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297572352 ++read 2048/2048 bytes at offset 4297572352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297576448 ++read 2048/2048 bytes at offset 4297576448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297580544 ++read 2048/2048 bytes at offset 4297580544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297584640 ++read 2048/2048 bytes at offset 4297584640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297588736 ++read 2048/2048 bytes at offset 4297588736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297592832 ++read 2048/2048 bytes at offset 4297592832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297596928 ++read 2048/2048 bytes at offset 4297596928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297601024 ++read 2048/2048 bytes at offset 4297601024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297605120 ++read 2048/2048 bytes at offset 4297605120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297609216 ++read 2048/2048 bytes at offset 4297609216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297613312 ++read 2048/2048 bytes at offset 4297613312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297617408 ++read 2048/2048 bytes at offset 4297617408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297621504 ++read 2048/2048 bytes at offset 4297621504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297625600 ++read 2048/2048 bytes at offset 4297625600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297629696 ++read 2048/2048 bytes at offset 4297629696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297633792 ++read 2048/2048 bytes at offset 4297633792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297637888 ++read 2048/2048 bytes at offset 4297637888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297641984 ++read 2048/2048 bytes at offset 4297641984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297646080 ++read 2048/2048 bytes at offset 4297646080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297650176 ++read 2048/2048 bytes at offset 4297650176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297654272 ++read 2048/2048 bytes at offset 4297654272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297658368 ++read 2048/2048 bytes at offset 4297658368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297662464 ++read 2048/2048 bytes at offset 4297662464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297666560 ++read 2048/2048 bytes at offset 4297666560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297670656 ++read 2048/2048 bytes at offset 4297670656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297674752 ++read 2048/2048 bytes at offset 4297674752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297678848 ++read 2048/2048 bytes at offset 4297678848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297682944 ++read 2048/2048 bytes at offset 4297682944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297687040 ++read 2048/2048 bytes at offset 4297687040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297691136 ++read 2048/2048 bytes at offset 4297691136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297695232 ++read 2048/2048 bytes at offset 4297695232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297699328 ++read 2048/2048 bytes at offset 4297699328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297703424 ++read 2048/2048 bytes at offset 4297703424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297707520 ++read 2048/2048 bytes at offset 4297707520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297711616 ++read 2048/2048 bytes at offset 4297711616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297715712 ++read 2048/2048 bytes at offset 4297715712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297719808 ++read 2048/2048 bytes at offset 4297719808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297723904 ++read 2048/2048 bytes at offset 4297723904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297728000 ++read 2048/2048 bytes at offset 4297728000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297732096 ++read 2048/2048 bytes at offset 4297732096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297736192 ++read 2048/2048 bytes at offset 4297736192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297740288 ++read 2048/2048 bytes at offset 4297740288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297744384 ++read 2048/2048 bytes at offset 4297744384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297748480 ++read 2048/2048 bytes at offset 4297748480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297752576 ++read 2048/2048 bytes at offset 4297752576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297756672 ++read 2048/2048 bytes at offset 4297756672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297760768 ++read 2048/2048 bytes at offset 4297760768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297764864 ++read 2048/2048 bytes at offset 4297764864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297768960 ++read 2048/2048 bytes at offset 4297768960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297773056 ++read 2048/2048 bytes at offset 4297773056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297777152 ++read 2048/2048 bytes at offset 4297777152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297781248 ++read 2048/2048 bytes at offset 4297781248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297785344 ++read 2048/2048 bytes at offset 4297785344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297789440 ++read 2048/2048 bytes at offset 4297789440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297793536 ++read 2048/2048 bytes at offset 4297793536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297797632 ++read 2048/2048 bytes at offset 4297797632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297801728 ++read 2048/2048 bytes at offset 4297801728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297805824 ++read 2048/2048 bytes at offset 4297805824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297809920 ++read 2048/2048 bytes at offset 4297809920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297814016 ++read 2048/2048 bytes at offset 4297814016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297818112 ++read 2048/2048 bytes at offset 4297818112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297822208 ++read 2048/2048 bytes at offset 4297822208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297826304 ++read 2048/2048 bytes at offset 4297826304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297830400 ++read 2048/2048 bytes at offset 4297830400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297834496 ++read 2048/2048 bytes at offset 4297834496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297838592 ++read 2048/2048 bytes at offset 4297838592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297842688 ++read 2048/2048 bytes at offset 4297842688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297846784 ++read 2048/2048 bytes at offset 4297846784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297850880 ++read 2048/2048 bytes at offset 4297850880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297854976 ++read 2048/2048 bytes at offset 4297854976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297859072 ++read 2048/2048 bytes at offset 4297859072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297863168 ++read 2048/2048 bytes at offset 4297863168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297867264 ++read 2048/2048 bytes at offset 4297867264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297871360 ++read 2048/2048 bytes at offset 4297871360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297875456 ++read 2048/2048 bytes at offset 4297875456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297879552 ++read 2048/2048 bytes at offset 4297879552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297883648 ++read 2048/2048 bytes at offset 4297883648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297887744 ++read 2048/2048 bytes at offset 4297887744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297891840 ++read 2048/2048 bytes at offset 4297891840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297895936 ++read 2048/2048 bytes at offset 4297895936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297900032 ++read 2048/2048 bytes at offset 4297900032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297904128 ++read 2048/2048 bytes at offset 4297904128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297908224 ++read 2048/2048 bytes at offset 4297908224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297912320 ++read 2048/2048 bytes at offset 4297912320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297916416 ++read 2048/2048 bytes at offset 4297916416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297920512 ++read 2048/2048 bytes at offset 4297920512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297924608 ++read 2048/2048 bytes at offset 4297924608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297928704 ++read 2048/2048 bytes at offset 4297928704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297932800 ++read 2048/2048 bytes at offset 4297932800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297936896 ++read 2048/2048 bytes at offset 4297936896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297940992 ++read 2048/2048 bytes at offset 4297940992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297945088 ++read 2048/2048 bytes at offset 4297945088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297949184 ++read 2048/2048 bytes at offset 4297949184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297953280 ++read 2048/2048 bytes at offset 4297953280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297957376 ++read 2048/2048 bytes at offset 4297957376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297961472 ++read 2048/2048 bytes at offset 4297961472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297965568 ++read 2048/2048 bytes at offset 4297965568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297969664 ++read 2048/2048 bytes at offset 4297969664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297973760 ++read 2048/2048 bytes at offset 4297973760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297977856 ++read 2048/2048 bytes at offset 4297977856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297981952 ++read 2048/2048 bytes at offset 4297981952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297986048 ++read 2048/2048 bytes at offset 4297986048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297990144 ++read 2048/2048 bytes at offset 4297990144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297994240 ++read 2048/2048 bytes at offset 4297994240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297998336 ++read 2048/2048 bytes at offset 4297998336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298002432 ++read 2048/2048 bytes at offset 4298002432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298006528 ++read 2048/2048 bytes at offset 4298006528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298010624 ++read 2048/2048 bytes at offset 4298010624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298014720 ++read 2048/2048 bytes at offset 4298014720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298018816 ++read 2048/2048 bytes at offset 4298018816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298022912 ++read 2048/2048 bytes at offset 4298022912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298027008 ++read 2048/2048 bytes at offset 4298027008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298031104 ++read 2048/2048 bytes at offset 4298031104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298035200 ++read 2048/2048 bytes at offset 4298035200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298039296 ++read 2048/2048 bytes at offset 4298039296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298043392 ++read 2048/2048 bytes at offset 4298043392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298047488 ++read 2048/2048 bytes at offset 4298047488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298051584 ++read 2048/2048 bytes at offset 4298051584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298055680 ++read 2048/2048 bytes at offset 4298055680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298059776 ++read 2048/2048 bytes at offset 4298059776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298063872 ++read 2048/2048 bytes at offset 4298063872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298067968 ++read 2048/2048 bytes at offset 4298067968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298072064 ++read 2048/2048 bytes at offset 4298072064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298076160 ++read 2048/2048 bytes at offset 4298076160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298080256 ++read 2048/2048 bytes at offset 4298080256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298084352 ++read 2048/2048 bytes at offset 4298084352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298088448 ++read 2048/2048 bytes at offset 4298088448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298092544 ++read 2048/2048 bytes at offset 4298092544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298096640 ++read 2048/2048 bytes at offset 4298096640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298100736 ++read 2048/2048 bytes at offset 4298100736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298104832 ++read 2048/2048 bytes at offset 4298104832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298108928 ++read 2048/2048 bytes at offset 4298108928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 2 +-qemu-io> read 2048/2048 bytes at offset 4298114048 ++=== IO: pattern 2 ++read 2048/2048 bytes at offset 4298114048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298118144 ++read 2048/2048 bytes at offset 4298118144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298122240 ++read 2048/2048 bytes at offset 4298122240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298126336 ++read 2048/2048 bytes at offset 4298126336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298130432 ++read 2048/2048 bytes at offset 4298130432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298134528 ++read 2048/2048 bytes at offset 4298134528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298138624 ++read 2048/2048 bytes at offset 4298138624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298142720 ++read 2048/2048 bytes at offset 4298142720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298146816 ++read 2048/2048 bytes at offset 4298146816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298150912 ++read 2048/2048 bytes at offset 4298150912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298155008 ++read 2048/2048 bytes at offset 4298155008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298159104 ++read 2048/2048 bytes at offset 4298159104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298163200 ++read 2048/2048 bytes at offset 4298163200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298167296 ++read 2048/2048 bytes at offset 4298167296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298171392 ++read 2048/2048 bytes at offset 4298171392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298175488 ++read 2048/2048 bytes at offset 4298175488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298179584 ++read 2048/2048 bytes at offset 4298179584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298183680 ++read 2048/2048 bytes at offset 4298183680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298187776 ++read 2048/2048 bytes at offset 4298187776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298191872 ++read 2048/2048 bytes at offset 4298191872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298195968 ++read 2048/2048 bytes at offset 4298195968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298200064 ++read 2048/2048 bytes at offset 4298200064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298204160 ++read 2048/2048 bytes at offset 4298204160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298208256 ++read 2048/2048 bytes at offset 4298208256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298212352 ++read 2048/2048 bytes at offset 4298212352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298216448 ++read 2048/2048 bytes at offset 4298216448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298220544 ++read 2048/2048 bytes at offset 4298220544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298224640 ++read 2048/2048 bytes at offset 4298224640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298228736 ++read 2048/2048 bytes at offset 4298228736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298232832 ++read 2048/2048 bytes at offset 4298232832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298236928 ++read 2048/2048 bytes at offset 4298236928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298241024 ++read 2048/2048 bytes at offset 4298241024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298245120 ++read 2048/2048 bytes at offset 4298245120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298249216 ++read 2048/2048 bytes at offset 4298249216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298253312 ++read 2048/2048 bytes at offset 4298253312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298257408 ++read 2048/2048 bytes at offset 4298257408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298261504 ++read 2048/2048 bytes at offset 4298261504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298265600 ++read 2048/2048 bytes at offset 4298265600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298269696 ++read 2048/2048 bytes at offset 4298269696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298273792 ++read 2048/2048 bytes at offset 4298273792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298277888 ++read 2048/2048 bytes at offset 4298277888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298281984 ++read 2048/2048 bytes at offset 4298281984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298286080 ++read 2048/2048 bytes at offset 4298286080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298290176 ++read 2048/2048 bytes at offset 4298290176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298294272 ++read 2048/2048 bytes at offset 4298294272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298298368 ++read 2048/2048 bytes at offset 4298298368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298302464 ++read 2048/2048 bytes at offset 4298302464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298306560 ++read 2048/2048 bytes at offset 4298306560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298310656 ++read 2048/2048 bytes at offset 4298310656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298314752 ++read 2048/2048 bytes at offset 4298314752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298318848 ++read 2048/2048 bytes at offset 4298318848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298322944 ++read 2048/2048 bytes at offset 4298322944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298327040 ++read 2048/2048 bytes at offset 4298327040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298331136 ++read 2048/2048 bytes at offset 4298331136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298335232 ++read 2048/2048 bytes at offset 4298335232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298339328 ++read 2048/2048 bytes at offset 4298339328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298343424 ++read 2048/2048 bytes at offset 4298343424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298347520 ++read 2048/2048 bytes at offset 4298347520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298351616 ++read 2048/2048 bytes at offset 4298351616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298355712 ++read 2048/2048 bytes at offset 4298355712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298359808 ++read 2048/2048 bytes at offset 4298359808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298363904 ++read 2048/2048 bytes at offset 4298363904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298368000 ++read 2048/2048 bytes at offset 4298368000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298372096 ++read 2048/2048 bytes at offset 4298372096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298376192 ++read 2048/2048 bytes at offset 4298376192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298380288 ++read 2048/2048 bytes at offset 4298380288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298384384 ++read 2048/2048 bytes at offset 4298384384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298388480 ++read 2048/2048 bytes at offset 4298388480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298392576 ++read 2048/2048 bytes at offset 4298392576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298396672 ++read 2048/2048 bytes at offset 4298396672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298400768 ++read 2048/2048 bytes at offset 4298400768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298404864 ++read 2048/2048 bytes at offset 4298404864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298408960 ++read 2048/2048 bytes at offset 4298408960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298413056 ++read 2048/2048 bytes at offset 4298413056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298417152 ++read 2048/2048 bytes at offset 4298417152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298421248 ++read 2048/2048 bytes at offset 4298421248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298425344 ++read 2048/2048 bytes at offset 4298425344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298429440 ++read 2048/2048 bytes at offset 4298429440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298433536 ++read 2048/2048 bytes at offset 4298433536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298437632 ++read 2048/2048 bytes at offset 4298437632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298441728 ++read 2048/2048 bytes at offset 4298441728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298445824 ++read 2048/2048 bytes at offset 4298445824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298449920 ++read 2048/2048 bytes at offset 4298449920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298454016 ++read 2048/2048 bytes at offset 4298454016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298458112 ++read 2048/2048 bytes at offset 4298458112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298462208 ++read 2048/2048 bytes at offset 4298462208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298466304 ++read 2048/2048 bytes at offset 4298466304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298470400 ++read 2048/2048 bytes at offset 4298470400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298474496 ++read 2048/2048 bytes at offset 4298474496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298478592 ++read 2048/2048 bytes at offset 4298478592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298482688 ++read 2048/2048 bytes at offset 4298482688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298486784 ++read 2048/2048 bytes at offset 4298486784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298490880 ++read 2048/2048 bytes at offset 4298490880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298494976 ++read 2048/2048 bytes at offset 4298494976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298499072 ++read 2048/2048 bytes at offset 4298499072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298503168 ++read 2048/2048 bytes at offset 4298503168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298507264 ++read 2048/2048 bytes at offset 4298507264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298511360 ++read 2048/2048 bytes at offset 4298511360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298515456 ++read 2048/2048 bytes at offset 4298515456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298519552 ++read 2048/2048 bytes at offset 4298519552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298523648 ++read 2048/2048 bytes at offset 4298523648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298527744 ++read 2048/2048 bytes at offset 4298527744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298531840 ++read 2048/2048 bytes at offset 4298531840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298535936 ++read 2048/2048 bytes at offset 4298535936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298540032 ++read 2048/2048 bytes at offset 4298540032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298544128 ++read 2048/2048 bytes at offset 4298544128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298548224 ++read 2048/2048 bytes at offset 4298548224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298552320 ++read 2048/2048 bytes at offset 4298552320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298556416 ++read 2048/2048 bytes at offset 4298556416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298560512 ++read 2048/2048 bytes at offset 4298560512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298564608 ++read 2048/2048 bytes at offset 4298564608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298568704 ++read 2048/2048 bytes at offset 4298568704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298572800 ++read 2048/2048 bytes at offset 4298572800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298576896 ++read 2048/2048 bytes at offset 4298576896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298580992 ++read 2048/2048 bytes at offset 4298580992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298585088 ++read 2048/2048 bytes at offset 4298585088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298589184 ++read 2048/2048 bytes at offset 4298589184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298593280 ++read 2048/2048 bytes at offset 4298593280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298597376 ++read 2048/2048 bytes at offset 4298597376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298601472 ++read 2048/2048 bytes at offset 4298601472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298605568 ++read 2048/2048 bytes at offset 4298605568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298609664 ++read 2048/2048 bytes at offset 4298609664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298613760 ++read 2048/2048 bytes at offset 4298613760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298617856 ++read 2048/2048 bytes at offset 4298617856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298621952 ++read 2048/2048 bytes at offset 4298621952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298626048 ++read 2048/2048 bytes at offset 4298626048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298630144 ++read 2048/2048 bytes at offset 4298630144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298634240 ++read 2048/2048 bytes at offset 4298634240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298638336 ++read 2048/2048 bytes at offset 4298638336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298642432 ++read 2048/2048 bytes at offset 4298642432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298646528 ++read 2048/2048 bytes at offset 4298646528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298650624 ++read 2048/2048 bytes at offset 4298650624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298654720 ++read 2048/2048 bytes at offset 4298654720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298658816 ++read 2048/2048 bytes at offset 4298658816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298662912 ++read 2048/2048 bytes at offset 4298662912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298667008 ++read 2048/2048 bytes at offset 4298667008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298671104 ++read 2048/2048 bytes at offset 4298671104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298675200 ++read 2048/2048 bytes at offset 4298675200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298679296 ++read 2048/2048 bytes at offset 4298679296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298683392 ++read 2048/2048 bytes at offset 4298683392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298687488 ++read 2048/2048 bytes at offset 4298687488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298691584 ++read 2048/2048 bytes at offset 4298691584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298695680 ++read 2048/2048 bytes at offset 4298695680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298699776 ++read 2048/2048 bytes at offset 4298699776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298703872 ++read 2048/2048 bytes at offset 4298703872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298707968 ++read 2048/2048 bytes at offset 4298707968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298712064 ++read 2048/2048 bytes at offset 4298712064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298716160 ++read 2048/2048 bytes at offset 4298716160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298720256 ++read 2048/2048 bytes at offset 4298720256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298724352 ++read 2048/2048 bytes at offset 4298724352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298728448 ++read 2048/2048 bytes at offset 4298728448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298732544 ++read 2048/2048 bytes at offset 4298732544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298736640 ++read 2048/2048 bytes at offset 4298736640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298740736 ++read 2048/2048 bytes at offset 4298740736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298744832 ++read 2048/2048 bytes at offset 4298744832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298748928 ++read 2048/2048 bytes at offset 4298748928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298753024 ++read 2048/2048 bytes at offset 4298753024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298757120 ++read 2048/2048 bytes at offset 4298757120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298761216 ++read 2048/2048 bytes at offset 4298761216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298765312 ++read 2048/2048 bytes at offset 4298765312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298769408 ++read 2048/2048 bytes at offset 4298769408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298773504 ++read 2048/2048 bytes at offset 4298773504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298777600 ++read 2048/2048 bytes at offset 4298777600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298781696 ++read 2048/2048 bytes at offset 4298781696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298785792 ++read 2048/2048 bytes at offset 4298785792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298789888 ++read 2048/2048 bytes at offset 4298789888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298793984 ++read 2048/2048 bytes at offset 4298793984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298798080 ++read 2048/2048 bytes at offset 4298798080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298802176 ++read 2048/2048 bytes at offset 4298802176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298806272 ++read 2048/2048 bytes at offset 4298806272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298810368 ++read 2048/2048 bytes at offset 4298810368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298814464 ++read 2048/2048 bytes at offset 4298814464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298818560 ++read 2048/2048 bytes at offset 4298818560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298822656 ++read 2048/2048 bytes at offset 4298822656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298826752 ++read 2048/2048 bytes at offset 4298826752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298830848 ++read 2048/2048 bytes at offset 4298830848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298834944 ++read 2048/2048 bytes at offset 4298834944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298839040 ++read 2048/2048 bytes at offset 4298839040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298843136 ++read 2048/2048 bytes at offset 4298843136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298847232 ++read 2048/2048 bytes at offset 4298847232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298851328 ++read 2048/2048 bytes at offset 4298851328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298855424 ++read 2048/2048 bytes at offset 4298855424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298859520 ++read 2048/2048 bytes at offset 4298859520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298863616 ++read 2048/2048 bytes at offset 4298863616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298867712 ++read 2048/2048 bytes at offset 4298867712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298871808 ++read 2048/2048 bytes at offset 4298871808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298875904 ++read 2048/2048 bytes at offset 4298875904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298880000 ++read 2048/2048 bytes at offset 4298880000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298884096 ++read 2048/2048 bytes at offset 4298884096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298888192 ++read 2048/2048 bytes at offset 4298888192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298892288 ++read 2048/2048 bytes at offset 4298892288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298896384 ++read 2048/2048 bytes at offset 4298896384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298900480 ++read 2048/2048 bytes at offset 4298900480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298904576 ++read 2048/2048 bytes at offset 4298904576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298908672 ++read 2048/2048 bytes at offset 4298908672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298912768 ++read 2048/2048 bytes at offset 4298912768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298916864 ++read 2048/2048 bytes at offset 4298916864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298920960 ++read 2048/2048 bytes at offset 4298920960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298925056 ++read 2048/2048 bytes at offset 4298925056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298929152 ++read 2048/2048 bytes at offset 4298929152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298933248 ++read 2048/2048 bytes at offset 4298933248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298937344 ++read 2048/2048 bytes at offset 4298937344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298941440 ++read 2048/2048 bytes at offset 4298941440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298945536 ++read 2048/2048 bytes at offset 4298945536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298949632 ++read 2048/2048 bytes at offset 4298949632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298953728 ++read 2048/2048 bytes at offset 4298953728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298957824 ++read 2048/2048 bytes at offset 4298957824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298961920 ++read 2048/2048 bytes at offset 4298961920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298966016 ++read 2048/2048 bytes at offset 4298966016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298970112 ++read 2048/2048 bytes at offset 4298970112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298974208 ++read 2048/2048 bytes at offset 4298974208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298978304 ++read 2048/2048 bytes at offset 4298978304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298982400 ++read 2048/2048 bytes at offset 4298982400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298986496 ++read 2048/2048 bytes at offset 4298986496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298990592 ++read 2048/2048 bytes at offset 4298990592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298994688 ++read 2048/2048 bytes at offset 4298994688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298998784 ++read 2048/2048 bytes at offset 4298998784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299002880 ++read 2048/2048 bytes at offset 4299002880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299006976 ++read 2048/2048 bytes at offset 4299006976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299011072 ++read 2048/2048 bytes at offset 4299011072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299015168 ++read 2048/2048 bytes at offset 4299015168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299019264 ++read 2048/2048 bytes at offset 4299019264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299023360 ++read 2048/2048 bytes at offset 4299023360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299027456 ++read 2048/2048 bytes at offset 4299027456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299031552 ++read 2048/2048 bytes at offset 4299031552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299035648 ++read 2048/2048 bytes at offset 4299035648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299039744 ++read 2048/2048 bytes at offset 4299039744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299043840 ++read 2048/2048 bytes at offset 4299043840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299047936 ++read 2048/2048 bytes at offset 4299047936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299052032 ++read 2048/2048 bytes at offset 4299052032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299056128 ++read 2048/2048 bytes at offset 4299056128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299060224 ++read 2048/2048 bytes at offset 4299060224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299064320 ++read 2048/2048 bytes at offset 4299064320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299068416 ++read 2048/2048 bytes at offset 4299068416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299072512 ++read 2048/2048 bytes at offset 4299072512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299076608 ++read 2048/2048 bytes at offset 4299076608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299080704 ++read 2048/2048 bytes at offset 4299080704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299084800 ++read 2048/2048 bytes at offset 4299084800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299088896 ++read 2048/2048 bytes at offset 4299088896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299092992 ++read 2048/2048 bytes at offset 4299092992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299097088 ++read 2048/2048 bytes at offset 4299097088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299101184 ++read 2048/2048 bytes at offset 4299101184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299105280 ++read 2048/2048 bytes at offset 4299105280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299109376 ++read 2048/2048 bytes at offset 4299109376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299113472 ++read 2048/2048 bytes at offset 4299113472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299117568 ++read 2048/2048 bytes at offset 4299117568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299121664 ++read 2048/2048 bytes at offset 4299121664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299125760 ++read 2048/2048 bytes at offset 4299125760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299129856 ++read 2048/2048 bytes at offset 4299129856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299133952 ++read 2048/2048 bytes at offset 4299133952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299138048 ++read 2048/2048 bytes at offset 4299138048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299142144 ++read 2048/2048 bytes at offset 4299142144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299146240 ++read 2048/2048 bytes at offset 4299146240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299150336 ++read 2048/2048 bytes at offset 4299150336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299154432 ++read 2048/2048 bytes at offset 4299154432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299158528 ++read 2048/2048 bytes at offset 4299158528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 4 +-qemu-io> read 8192/8192 bytes at offset 4299163648 ++=== IO: pattern 4 ++read 8192/8192 bytes at offset 4299163648 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299175936 ++read 8192/8192 bytes at offset 4299175936 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299188224 ++read 8192/8192 bytes at offset 4299188224 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299200512 ++read 8192/8192 bytes at offset 4299200512 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299212800 ++read 8192/8192 bytes at offset 4299212800 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299225088 ++read 8192/8192 bytes at offset 4299225088 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299237376 ++read 8192/8192 bytes at offset 4299237376 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299249664 ++read 8192/8192 bytes at offset 4299249664 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299261952 ++read 8192/8192 bytes at offset 4299261952 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299274240 ++read 8192/8192 bytes at offset 4299274240 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299286528 ++read 8192/8192 bytes at offset 4299286528 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299298816 ++read 8192/8192 bytes at offset 4299298816 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299311104 ++read 8192/8192 bytes at offset 4299311104 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299323392 ++read 8192/8192 bytes at offset 4299323392 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299335680 ++read 8192/8192 bytes at offset 4299335680 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299347968 ++read 8192/8192 bytes at offset 4299347968 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299360256 ++read 8192/8192 bytes at offset 4299360256 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299372544 ++read 8192/8192 bytes at offset 4299372544 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299384832 ++read 8192/8192 bytes at offset 4299384832 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299397120 ++read 8192/8192 bytes at offset 4299397120 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299409408 ++read 8192/8192 bytes at offset 4299409408 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299421696 ++read 8192/8192 bytes at offset 4299421696 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299433984 ++read 8192/8192 bytes at offset 4299433984 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299446272 ++read 8192/8192 bytes at offset 4299446272 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299458560 ++read 8192/8192 bytes at offset 4299458560 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299470848 ++read 8192/8192 bytes at offset 4299470848 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299483136 ++read 8192/8192 bytes at offset 4299483136 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299495424 ++read 8192/8192 bytes at offset 4299495424 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299507712 ++read 8192/8192 bytes at offset 4299507712 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299520000 ++read 8192/8192 bytes at offset 4299520000 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299532288 ++read 8192/8192 bytes at offset 4299532288 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299544576 ++read 8192/8192 bytes at offset 4299544576 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299556864 ++read 8192/8192 bytes at offset 4299556864 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299569152 ++read 8192/8192 bytes at offset 4299569152 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299581440 ++read 8192/8192 bytes at offset 4299581440 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299593728 ++read 8192/8192 bytes at offset 4299593728 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299606016 ++read 8192/8192 bytes at offset 4299606016 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299618304 ++read 8192/8192 bytes at offset 4299618304 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299630592 ++read 8192/8192 bytes at offset 4299630592 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299642880 ++read 8192/8192 bytes at offset 4299642880 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299655168 ++read 8192/8192 bytes at offset 4299655168 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299667456 ++read 8192/8192 bytes at offset 4299667456 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299679744 ++read 8192/8192 bytes at offset 4299679744 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299692032 ++read 8192/8192 bytes at offset 4299692032 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299704320 ++read 8192/8192 bytes at offset 4299704320 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299716608 ++read 8192/8192 bytes at offset 4299716608 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299728896 ++read 8192/8192 bytes at offset 4299728896 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299741184 ++read 8192/8192 bytes at offset 4299741184 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299753472 ++read 8192/8192 bytes at offset 4299753472 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299765760 ++read 8192/8192 bytes at offset 4299765760 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299778048 ++read 8192/8192 bytes at offset 4299778048 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299790336 ++read 8192/8192 bytes at offset 4299790336 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299802624 ++read 8192/8192 bytes at offset 4299802624 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299814912 ++read 8192/8192 bytes at offset 4299814912 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299827200 ++read 8192/8192 bytes at offset 4299827200 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299839488 ++read 8192/8192 bytes at offset 4299839488 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299851776 ++read 8192/8192 bytes at offset 4299851776 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299864064 ++read 8192/8192 bytes at offset 4299864064 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299876352 ++read 8192/8192 bytes at offset 4299876352 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299888640 ++read 8192/8192 bytes at offset 4299888640 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299900928 ++read 8192/8192 bytes at offset 4299900928 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299913216 ++read 8192/8192 bytes at offset 4299913216 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299925504 ++read 8192/8192 bytes at offset 4299925504 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299937792 ++read 8192/8192 bytes at offset 4299937792 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 244 +-qemu-io> read 12288/12288 bytes at offset 4301252608 ++=== IO: pattern 244 ++read 12288/12288 bytes at offset 4301252608 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4303351808 ++read 12288/12288 bytes at offset 4303351808 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4305451008 ++read 12288/12288 bytes at offset 4305451008 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4307550208 ++read 12288/12288 bytes at offset 4307550208 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4309649408 ++read 12288/12288 bytes at offset 4309649408 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4311748608 ++read 12288/12288 bytes at offset 4311748608 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4313847808 ++read 12288/12288 bytes at offset 4313847808 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4315947008 ++read 12288/12288 bytes at offset 4315947008 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> No errors were found on the image. ++No errors were found on the image. + *** done +diff --git a/tests/qemu-iotests/017.out b/tests/qemu-iotests/017.out +index df34ee7..75ea614 100644 +--- a/tests/qemu-iotests/017.out ++++ b/tests/qemu-iotests/017.out +@@ -3,1075 +3,1075 @@ Formatting 'TEST_DIR/t.IMGFMT.base', fmt=IMGFMT size=6442450944 + Filling base image + + === IO: pattern 0 +-qemu-io> wrote 512/512 bytes at offset 0 ++wrote 512/512 bytes at offset 0 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 1024 ++wrote 512/512 bytes at offset 1024 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 2048 ++wrote 512/512 bytes at offset 2048 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 3072 ++wrote 512/512 bytes at offset 3072 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4096 ++wrote 512/512 bytes at offset 4096 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 5120 ++wrote 512/512 bytes at offset 5120 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 6144 ++wrote 512/512 bytes at offset 6144 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 7168 ++wrote 512/512 bytes at offset 7168 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 8192 ++wrote 512/512 bytes at offset 8192 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 9216 ++wrote 512/512 bytes at offset 9216 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 10240 ++wrote 512/512 bytes at offset 10240 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 11264 ++wrote 512/512 bytes at offset 11264 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 12288 ++wrote 512/512 bytes at offset 12288 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 13312 ++wrote 512/512 bytes at offset 13312 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 14336 ++wrote 512/512 bytes at offset 14336 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 15360 ++wrote 512/512 bytes at offset 15360 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 16384 ++wrote 512/512 bytes at offset 16384 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 17408 ++wrote 512/512 bytes at offset 17408 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 18432 ++wrote 512/512 bytes at offset 18432 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 19456 ++wrote 512/512 bytes at offset 19456 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 20480 ++wrote 512/512 bytes at offset 20480 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 21504 ++wrote 512/512 bytes at offset 21504 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 22528 ++wrote 512/512 bytes at offset 22528 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 23552 ++wrote 512/512 bytes at offset 23552 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 24576 ++wrote 512/512 bytes at offset 24576 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 25600 ++wrote 512/512 bytes at offset 25600 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 26624 ++wrote 512/512 bytes at offset 26624 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 27648 ++wrote 512/512 bytes at offset 27648 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 28672 ++wrote 512/512 bytes at offset 28672 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 29696 ++wrote 512/512 bytes at offset 29696 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 30720 ++wrote 512/512 bytes at offset 30720 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 31744 ++wrote 512/512 bytes at offset 31744 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 32768 ++wrote 512/512 bytes at offset 32768 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 33792 ++wrote 512/512 bytes at offset 33792 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 34816 ++wrote 512/512 bytes at offset 34816 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 35840 ++wrote 512/512 bytes at offset 35840 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 36864 ++wrote 512/512 bytes at offset 36864 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 37888 ++wrote 512/512 bytes at offset 37888 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 38912 ++wrote 512/512 bytes at offset 38912 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 39936 ++wrote 512/512 bytes at offset 39936 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 40960 ++wrote 512/512 bytes at offset 40960 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 41984 ++wrote 512/512 bytes at offset 41984 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 43008 ++wrote 512/512 bytes at offset 43008 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 44032 ++wrote 512/512 bytes at offset 44032 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 45056 ++wrote 512/512 bytes at offset 45056 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 46080 ++wrote 512/512 bytes at offset 46080 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 47104 ++wrote 512/512 bytes at offset 47104 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 48128 ++wrote 512/512 bytes at offset 48128 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 49152 ++wrote 512/512 bytes at offset 49152 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 50176 ++wrote 512/512 bytes at offset 50176 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 51200 ++wrote 512/512 bytes at offset 51200 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 52224 ++wrote 512/512 bytes at offset 52224 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 53248 ++wrote 512/512 bytes at offset 53248 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 54272 ++wrote 512/512 bytes at offset 54272 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 55296 ++wrote 512/512 bytes at offset 55296 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 56320 ++wrote 512/512 bytes at offset 56320 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 57344 ++wrote 512/512 bytes at offset 57344 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 58368 ++wrote 512/512 bytes at offset 58368 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 59392 ++wrote 512/512 bytes at offset 59392 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 60416 ++wrote 512/512 bytes at offset 60416 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 61440 ++wrote 512/512 bytes at offset 61440 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 62464 ++wrote 512/512 bytes at offset 62464 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 63488 ++wrote 512/512 bytes at offset 63488 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 64512 ++wrote 512/512 bytes at offset 64512 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 128 +-qemu-io> wrote 65536/65536 bytes at offset 65536 ++=== IO: pattern 128 ++wrote 65536/65536 bytes at offset 65536 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> wrote 512/512 bytes at offset 4294967296 ++=== IO: pattern 0 ++wrote 512/512 bytes at offset 4294967296 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294968320 ++wrote 512/512 bytes at offset 4294968320 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294969344 ++wrote 512/512 bytes at offset 4294969344 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294970368 ++wrote 512/512 bytes at offset 4294970368 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294971392 ++wrote 512/512 bytes at offset 4294971392 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294972416 ++wrote 512/512 bytes at offset 4294972416 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294973440 ++wrote 512/512 bytes at offset 4294973440 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294974464 ++wrote 512/512 bytes at offset 4294974464 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294975488 ++wrote 512/512 bytes at offset 4294975488 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294976512 ++wrote 512/512 bytes at offset 4294976512 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294977536 ++wrote 512/512 bytes at offset 4294977536 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294978560 ++wrote 512/512 bytes at offset 4294978560 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294979584 ++wrote 512/512 bytes at offset 4294979584 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294980608 ++wrote 512/512 bytes at offset 4294980608 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294981632 ++wrote 512/512 bytes at offset 4294981632 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294982656 ++wrote 512/512 bytes at offset 4294982656 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294983680 ++wrote 512/512 bytes at offset 4294983680 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294984704 ++wrote 512/512 bytes at offset 4294984704 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294985728 ++wrote 512/512 bytes at offset 4294985728 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294986752 ++wrote 512/512 bytes at offset 4294986752 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294987776 ++wrote 512/512 bytes at offset 4294987776 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294988800 ++wrote 512/512 bytes at offset 4294988800 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294989824 ++wrote 512/512 bytes at offset 4294989824 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294990848 ++wrote 512/512 bytes at offset 4294990848 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294991872 ++wrote 512/512 bytes at offset 4294991872 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294992896 ++wrote 512/512 bytes at offset 4294992896 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294993920 ++wrote 512/512 bytes at offset 4294993920 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294994944 ++wrote 512/512 bytes at offset 4294994944 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294995968 ++wrote 512/512 bytes at offset 4294995968 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294996992 ++wrote 512/512 bytes at offset 4294996992 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294998016 ++wrote 512/512 bytes at offset 4294998016 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294999040 ++wrote 512/512 bytes at offset 4294999040 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295000064 ++wrote 512/512 bytes at offset 4295000064 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295001088 ++wrote 512/512 bytes at offset 4295001088 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295002112 ++wrote 512/512 bytes at offset 4295002112 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295003136 ++wrote 512/512 bytes at offset 4295003136 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295004160 ++wrote 512/512 bytes at offset 4295004160 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295005184 ++wrote 512/512 bytes at offset 4295005184 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295006208 ++wrote 512/512 bytes at offset 4295006208 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295007232 ++wrote 512/512 bytes at offset 4295007232 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295008256 ++wrote 512/512 bytes at offset 4295008256 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295009280 ++wrote 512/512 bytes at offset 4295009280 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295010304 ++wrote 512/512 bytes at offset 4295010304 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295011328 ++wrote 512/512 bytes at offset 4295011328 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295012352 ++wrote 512/512 bytes at offset 4295012352 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295013376 ++wrote 512/512 bytes at offset 4295013376 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295014400 ++wrote 512/512 bytes at offset 4295014400 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295015424 ++wrote 512/512 bytes at offset 4295015424 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295016448 ++wrote 512/512 bytes at offset 4295016448 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295017472 ++wrote 512/512 bytes at offset 4295017472 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295018496 ++wrote 512/512 bytes at offset 4295018496 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295019520 ++wrote 512/512 bytes at offset 4295019520 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295020544 ++wrote 512/512 bytes at offset 4295020544 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295021568 ++wrote 512/512 bytes at offset 4295021568 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295022592 ++wrote 512/512 bytes at offset 4295022592 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295023616 ++wrote 512/512 bytes at offset 4295023616 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295024640 ++wrote 512/512 bytes at offset 4295024640 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295025664 ++wrote 512/512 bytes at offset 4295025664 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295026688 ++wrote 512/512 bytes at offset 4295026688 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295027712 ++wrote 512/512 bytes at offset 4295027712 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295028736 ++wrote 512/512 bytes at offset 4295028736 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295029760 ++wrote 512/512 bytes at offset 4295029760 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295030784 ++wrote 512/512 bytes at offset 4295030784 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295031808 ++wrote 512/512 bytes at offset 4295031808 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 128 +-qemu-io> wrote 65536/65536 bytes at offset 4295032832 ++=== IO: pattern 128 ++wrote 65536/65536 bytes at offset 4295032832 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> No errors were found on the image. ++No errors were found on the image. + Creating test image with backing file + + Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=6442450944 backing_file='TEST_DIR/t.IMGFMT.base' + Filling test image + + === IO: pattern 1 +-qemu-io> wrote 512/512 bytes at offset 512 ++wrote 512/512 bytes at offset 512 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 1536 ++wrote 512/512 bytes at offset 1536 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 2560 ++wrote 512/512 bytes at offset 2560 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 3584 ++wrote 512/512 bytes at offset 3584 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4608 ++wrote 512/512 bytes at offset 4608 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 5632 ++wrote 512/512 bytes at offset 5632 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 6656 ++wrote 512/512 bytes at offset 6656 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 7680 ++wrote 512/512 bytes at offset 7680 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 8704 ++wrote 512/512 bytes at offset 8704 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 9728 ++wrote 512/512 bytes at offset 9728 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 10752 ++wrote 512/512 bytes at offset 10752 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 11776 ++wrote 512/512 bytes at offset 11776 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 12800 ++wrote 512/512 bytes at offset 12800 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 13824 ++wrote 512/512 bytes at offset 13824 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 14848 ++wrote 512/512 bytes at offset 14848 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 15872 ++wrote 512/512 bytes at offset 15872 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 16896 ++wrote 512/512 bytes at offset 16896 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 17920 ++wrote 512/512 bytes at offset 17920 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 18944 ++wrote 512/512 bytes at offset 18944 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 19968 ++wrote 512/512 bytes at offset 19968 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 20992 ++wrote 512/512 bytes at offset 20992 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 22016 ++wrote 512/512 bytes at offset 22016 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 23040 ++wrote 512/512 bytes at offset 23040 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 24064 ++wrote 512/512 bytes at offset 24064 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 25088 ++wrote 512/512 bytes at offset 25088 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 26112 ++wrote 512/512 bytes at offset 26112 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 27136 ++wrote 512/512 bytes at offset 27136 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 28160 ++wrote 512/512 bytes at offset 28160 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 29184 ++wrote 512/512 bytes at offset 29184 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 30208 ++wrote 512/512 bytes at offset 30208 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 31232 ++wrote 512/512 bytes at offset 31232 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 32256 ++wrote 512/512 bytes at offset 32256 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 33280 ++wrote 512/512 bytes at offset 33280 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 34304 ++wrote 512/512 bytes at offset 34304 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 35328 ++wrote 512/512 bytes at offset 35328 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 36352 ++wrote 512/512 bytes at offset 36352 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 37376 ++wrote 512/512 bytes at offset 37376 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 38400 ++wrote 512/512 bytes at offset 38400 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 39424 ++wrote 512/512 bytes at offset 39424 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 40448 ++wrote 512/512 bytes at offset 40448 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 41472 ++wrote 512/512 bytes at offset 41472 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 42496 ++wrote 512/512 bytes at offset 42496 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 43520 ++wrote 512/512 bytes at offset 43520 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 44544 ++wrote 512/512 bytes at offset 44544 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 45568 ++wrote 512/512 bytes at offset 45568 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 46592 ++wrote 512/512 bytes at offset 46592 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 47616 ++wrote 512/512 bytes at offset 47616 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 48640 ++wrote 512/512 bytes at offset 48640 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 49664 ++wrote 512/512 bytes at offset 49664 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 50688 ++wrote 512/512 bytes at offset 50688 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 51712 ++wrote 512/512 bytes at offset 51712 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 52736 ++wrote 512/512 bytes at offset 52736 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 53760 ++wrote 512/512 bytes at offset 53760 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 54784 ++wrote 512/512 bytes at offset 54784 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 55808 ++wrote 512/512 bytes at offset 55808 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 56832 ++wrote 512/512 bytes at offset 56832 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 57856 ++wrote 512/512 bytes at offset 57856 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 58880 ++wrote 512/512 bytes at offset 58880 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 59904 ++wrote 512/512 bytes at offset 59904 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 60928 ++wrote 512/512 bytes at offset 60928 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 61952 ++wrote 512/512 bytes at offset 61952 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 62976 ++wrote 512/512 bytes at offset 62976 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 64000 ++wrote 512/512 bytes at offset 64000 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 65024 ++wrote 512/512 bytes at offset 65024 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> wrote 65536/65536 bytes at offset 131072 ++=== IO: pattern 0 ++wrote 65536/65536 bytes at offset 131072 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 1 +-qemu-io> wrote 512/512 bytes at offset 4294967808 ++=== IO: pattern 1 ++wrote 512/512 bytes at offset 4294967808 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294968832 ++wrote 512/512 bytes at offset 4294968832 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294969856 ++wrote 512/512 bytes at offset 4294969856 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294970880 ++wrote 512/512 bytes at offset 4294970880 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294971904 ++wrote 512/512 bytes at offset 4294971904 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294972928 ++wrote 512/512 bytes at offset 4294972928 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294973952 ++wrote 512/512 bytes at offset 4294973952 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294974976 ++wrote 512/512 bytes at offset 4294974976 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294976000 ++wrote 512/512 bytes at offset 4294976000 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294977024 ++wrote 512/512 bytes at offset 4294977024 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294978048 ++wrote 512/512 bytes at offset 4294978048 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294979072 ++wrote 512/512 bytes at offset 4294979072 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294980096 ++wrote 512/512 bytes at offset 4294980096 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294981120 ++wrote 512/512 bytes at offset 4294981120 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294982144 ++wrote 512/512 bytes at offset 4294982144 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294983168 ++wrote 512/512 bytes at offset 4294983168 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294984192 ++wrote 512/512 bytes at offset 4294984192 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294985216 ++wrote 512/512 bytes at offset 4294985216 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294986240 ++wrote 512/512 bytes at offset 4294986240 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294987264 ++wrote 512/512 bytes at offset 4294987264 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294988288 ++wrote 512/512 bytes at offset 4294988288 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294989312 ++wrote 512/512 bytes at offset 4294989312 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294990336 ++wrote 512/512 bytes at offset 4294990336 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294991360 ++wrote 512/512 bytes at offset 4294991360 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294992384 ++wrote 512/512 bytes at offset 4294992384 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294993408 ++wrote 512/512 bytes at offset 4294993408 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294994432 ++wrote 512/512 bytes at offset 4294994432 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294995456 ++wrote 512/512 bytes at offset 4294995456 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294996480 ++wrote 512/512 bytes at offset 4294996480 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294997504 ++wrote 512/512 bytes at offset 4294997504 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294998528 ++wrote 512/512 bytes at offset 4294998528 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294999552 ++wrote 512/512 bytes at offset 4294999552 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295000576 ++wrote 512/512 bytes at offset 4295000576 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295001600 ++wrote 512/512 bytes at offset 4295001600 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295002624 ++wrote 512/512 bytes at offset 4295002624 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295003648 ++wrote 512/512 bytes at offset 4295003648 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295004672 ++wrote 512/512 bytes at offset 4295004672 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295005696 ++wrote 512/512 bytes at offset 4295005696 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295006720 ++wrote 512/512 bytes at offset 4295006720 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295007744 ++wrote 512/512 bytes at offset 4295007744 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295008768 ++wrote 512/512 bytes at offset 4295008768 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295009792 ++wrote 512/512 bytes at offset 4295009792 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295010816 ++wrote 512/512 bytes at offset 4295010816 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295011840 ++wrote 512/512 bytes at offset 4295011840 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295012864 ++wrote 512/512 bytes at offset 4295012864 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295013888 ++wrote 512/512 bytes at offset 4295013888 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295014912 ++wrote 512/512 bytes at offset 4295014912 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295015936 ++wrote 512/512 bytes at offset 4295015936 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295016960 ++wrote 512/512 bytes at offset 4295016960 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295017984 ++wrote 512/512 bytes at offset 4295017984 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295019008 ++wrote 512/512 bytes at offset 4295019008 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295020032 ++wrote 512/512 bytes at offset 4295020032 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295021056 ++wrote 512/512 bytes at offset 4295021056 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295022080 ++wrote 512/512 bytes at offset 4295022080 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295023104 ++wrote 512/512 bytes at offset 4295023104 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295024128 ++wrote 512/512 bytes at offset 4295024128 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295025152 ++wrote 512/512 bytes at offset 4295025152 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295026176 ++wrote 512/512 bytes at offset 4295026176 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295027200 ++wrote 512/512 bytes at offset 4295027200 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295028224 ++wrote 512/512 bytes at offset 4295028224 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295029248 ++wrote 512/512 bytes at offset 4295029248 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295030272 ++wrote 512/512 bytes at offset 4295030272 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295031296 ++wrote 512/512 bytes at offset 4295031296 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295032320 ++wrote 512/512 bytes at offset 4295032320 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> wrote 65536/65536 bytes at offset 4295098368 ++=== IO: pattern 0 ++wrote 65536/65536 bytes at offset 4295098368 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> No errors were found on the image. ++No errors were found on the image. + Reading + + === IO: pattern 0 +-qemu-io> read 512/512 bytes at offset 0 ++read 512/512 bytes at offset 0 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 1024 ++read 512/512 bytes at offset 1024 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 2048 ++read 512/512 bytes at offset 2048 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3072 ++read 512/512 bytes at offset 3072 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4096 ++read 512/512 bytes at offset 4096 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 5120 ++read 512/512 bytes at offset 5120 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 6144 ++read 512/512 bytes at offset 6144 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 7168 ++read 512/512 bytes at offset 7168 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 8192 ++read 512/512 bytes at offset 8192 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 9216 ++read 512/512 bytes at offset 9216 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 10240 ++read 512/512 bytes at offset 10240 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 11264 ++read 512/512 bytes at offset 11264 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 12288 ++read 512/512 bytes at offset 12288 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 13312 ++read 512/512 bytes at offset 13312 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 14336 ++read 512/512 bytes at offset 14336 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 15360 ++read 512/512 bytes at offset 15360 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 16384 ++read 512/512 bytes at offset 16384 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 17408 ++read 512/512 bytes at offset 17408 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 18432 ++read 512/512 bytes at offset 18432 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 19456 ++read 512/512 bytes at offset 19456 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 20480 ++read 512/512 bytes at offset 20480 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 21504 ++read 512/512 bytes at offset 21504 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 22528 ++read 512/512 bytes at offset 22528 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 23552 ++read 512/512 bytes at offset 23552 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 24576 ++read 512/512 bytes at offset 24576 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 25600 ++read 512/512 bytes at offset 25600 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 26624 ++read 512/512 bytes at offset 26624 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 27648 ++read 512/512 bytes at offset 27648 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 28672 ++read 512/512 bytes at offset 28672 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 29696 ++read 512/512 bytes at offset 29696 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 30720 ++read 512/512 bytes at offset 30720 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 31744 ++read 512/512 bytes at offset 31744 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 32768 ++read 512/512 bytes at offset 32768 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 33792 ++read 512/512 bytes at offset 33792 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 34816 ++read 512/512 bytes at offset 34816 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 35840 ++read 512/512 bytes at offset 35840 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 36864 ++read 512/512 bytes at offset 36864 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 37888 ++read 512/512 bytes at offset 37888 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 38912 ++read 512/512 bytes at offset 38912 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 39936 ++read 512/512 bytes at offset 39936 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 40960 ++read 512/512 bytes at offset 40960 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 41984 ++read 512/512 bytes at offset 41984 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 43008 ++read 512/512 bytes at offset 43008 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 44032 ++read 512/512 bytes at offset 44032 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 45056 ++read 512/512 bytes at offset 45056 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 46080 ++read 512/512 bytes at offset 46080 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 47104 ++read 512/512 bytes at offset 47104 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 48128 ++read 512/512 bytes at offset 48128 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 49152 ++read 512/512 bytes at offset 49152 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 50176 ++read 512/512 bytes at offset 50176 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 51200 ++read 512/512 bytes at offset 51200 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 52224 ++read 512/512 bytes at offset 52224 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 53248 ++read 512/512 bytes at offset 53248 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 54272 ++read 512/512 bytes at offset 54272 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 55296 ++read 512/512 bytes at offset 55296 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 56320 ++read 512/512 bytes at offset 56320 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 57344 ++read 512/512 bytes at offset 57344 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 58368 ++read 512/512 bytes at offset 58368 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 59392 ++read 512/512 bytes at offset 59392 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 60416 ++read 512/512 bytes at offset 60416 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 61440 ++read 512/512 bytes at offset 61440 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 62464 ++read 512/512 bytes at offset 62464 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 63488 ++read 512/512 bytes at offset 63488 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 64512 ++read 512/512 bytes at offset 64512 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 1 +-qemu-io> read 512/512 bytes at offset 512 ++=== IO: pattern 1 ++read 512/512 bytes at offset 512 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 1536 ++read 512/512 bytes at offset 1536 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 2560 ++read 512/512 bytes at offset 2560 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3584 ++read 512/512 bytes at offset 3584 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4608 ++read 512/512 bytes at offset 4608 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 5632 ++read 512/512 bytes at offset 5632 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 6656 ++read 512/512 bytes at offset 6656 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 7680 ++read 512/512 bytes at offset 7680 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 8704 ++read 512/512 bytes at offset 8704 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 9728 ++read 512/512 bytes at offset 9728 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 10752 ++read 512/512 bytes at offset 10752 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 11776 ++read 512/512 bytes at offset 11776 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 12800 ++read 512/512 bytes at offset 12800 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 13824 ++read 512/512 bytes at offset 13824 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 14848 ++read 512/512 bytes at offset 14848 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 15872 ++read 512/512 bytes at offset 15872 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 16896 ++read 512/512 bytes at offset 16896 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 17920 ++read 512/512 bytes at offset 17920 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 18944 ++read 512/512 bytes at offset 18944 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 19968 ++read 512/512 bytes at offset 19968 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 20992 ++read 512/512 bytes at offset 20992 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 22016 ++read 512/512 bytes at offset 22016 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 23040 ++read 512/512 bytes at offset 23040 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 24064 ++read 512/512 bytes at offset 24064 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 25088 ++read 512/512 bytes at offset 25088 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 26112 ++read 512/512 bytes at offset 26112 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 27136 ++read 512/512 bytes at offset 27136 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 28160 ++read 512/512 bytes at offset 28160 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 29184 ++read 512/512 bytes at offset 29184 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 30208 ++read 512/512 bytes at offset 30208 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 31232 ++read 512/512 bytes at offset 31232 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 32256 ++read 512/512 bytes at offset 32256 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 33280 ++read 512/512 bytes at offset 33280 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 34304 ++read 512/512 bytes at offset 34304 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 35328 ++read 512/512 bytes at offset 35328 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 36352 ++read 512/512 bytes at offset 36352 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 37376 ++read 512/512 bytes at offset 37376 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 38400 ++read 512/512 bytes at offset 38400 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 39424 ++read 512/512 bytes at offset 39424 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 40448 ++read 512/512 bytes at offset 40448 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 41472 ++read 512/512 bytes at offset 41472 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 42496 ++read 512/512 bytes at offset 42496 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 43520 ++read 512/512 bytes at offset 43520 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 44544 ++read 512/512 bytes at offset 44544 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 45568 ++read 512/512 bytes at offset 45568 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 46592 ++read 512/512 bytes at offset 46592 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 47616 ++read 512/512 bytes at offset 47616 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 48640 ++read 512/512 bytes at offset 48640 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 49664 ++read 512/512 bytes at offset 49664 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 50688 ++read 512/512 bytes at offset 50688 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 51712 ++read 512/512 bytes at offset 51712 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 52736 ++read 512/512 bytes at offset 52736 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 53760 ++read 512/512 bytes at offset 53760 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 54784 ++read 512/512 bytes at offset 54784 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 55808 ++read 512/512 bytes at offset 55808 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 56832 ++read 512/512 bytes at offset 56832 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 57856 ++read 512/512 bytes at offset 57856 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 58880 ++read 512/512 bytes at offset 58880 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 59904 ++read 512/512 bytes at offset 59904 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 60928 ++read 512/512 bytes at offset 60928 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 61952 ++read 512/512 bytes at offset 61952 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 62976 ++read 512/512 bytes at offset 62976 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 64000 ++read 512/512 bytes at offset 64000 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 65024 ++read 512/512 bytes at offset 65024 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 128 +-qemu-io> read 65536/65536 bytes at offset 65536 ++=== IO: pattern 128 ++read 65536/65536 bytes at offset 65536 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> read 65536/65536 bytes at offset 131072 ++=== IO: pattern 0 ++read 65536/65536 bytes at offset 131072 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> read 65536/65536 bytes at offset 327680 ++=== IO: pattern 0 ++read 65536/65536 bytes at offset 327680 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> read 512/512 bytes at offset 4294967296 ++=== IO: pattern 0 ++read 512/512 bytes at offset 4294967296 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294968320 ++read 512/512 bytes at offset 4294968320 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294969344 ++read 512/512 bytes at offset 4294969344 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294970368 ++read 512/512 bytes at offset 4294970368 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294971392 ++read 512/512 bytes at offset 4294971392 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294972416 ++read 512/512 bytes at offset 4294972416 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294973440 ++read 512/512 bytes at offset 4294973440 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294974464 ++read 512/512 bytes at offset 4294974464 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294975488 ++read 512/512 bytes at offset 4294975488 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294976512 ++read 512/512 bytes at offset 4294976512 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294977536 ++read 512/512 bytes at offset 4294977536 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294978560 ++read 512/512 bytes at offset 4294978560 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294979584 ++read 512/512 bytes at offset 4294979584 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294980608 ++read 512/512 bytes at offset 4294980608 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294981632 ++read 512/512 bytes at offset 4294981632 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294982656 ++read 512/512 bytes at offset 4294982656 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294983680 ++read 512/512 bytes at offset 4294983680 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294984704 ++read 512/512 bytes at offset 4294984704 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294985728 ++read 512/512 bytes at offset 4294985728 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294986752 ++read 512/512 bytes at offset 4294986752 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294987776 ++read 512/512 bytes at offset 4294987776 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294988800 ++read 512/512 bytes at offset 4294988800 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294989824 ++read 512/512 bytes at offset 4294989824 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294990848 ++read 512/512 bytes at offset 4294990848 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294991872 ++read 512/512 bytes at offset 4294991872 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294992896 ++read 512/512 bytes at offset 4294992896 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294993920 ++read 512/512 bytes at offset 4294993920 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294994944 ++read 512/512 bytes at offset 4294994944 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294995968 ++read 512/512 bytes at offset 4294995968 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294996992 ++read 512/512 bytes at offset 4294996992 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294998016 ++read 512/512 bytes at offset 4294998016 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294999040 ++read 512/512 bytes at offset 4294999040 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295000064 ++read 512/512 bytes at offset 4295000064 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295001088 ++read 512/512 bytes at offset 4295001088 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295002112 ++read 512/512 bytes at offset 4295002112 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295003136 ++read 512/512 bytes at offset 4295003136 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295004160 ++read 512/512 bytes at offset 4295004160 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295005184 ++read 512/512 bytes at offset 4295005184 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295006208 ++read 512/512 bytes at offset 4295006208 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295007232 ++read 512/512 bytes at offset 4295007232 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295008256 ++read 512/512 bytes at offset 4295008256 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295009280 ++read 512/512 bytes at offset 4295009280 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295010304 ++read 512/512 bytes at offset 4295010304 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295011328 ++read 512/512 bytes at offset 4295011328 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295012352 ++read 512/512 bytes at offset 4295012352 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295013376 ++read 512/512 bytes at offset 4295013376 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295014400 ++read 512/512 bytes at offset 4295014400 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295015424 ++read 512/512 bytes at offset 4295015424 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295016448 ++read 512/512 bytes at offset 4295016448 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295017472 ++read 512/512 bytes at offset 4295017472 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295018496 ++read 512/512 bytes at offset 4295018496 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295019520 ++read 512/512 bytes at offset 4295019520 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295020544 ++read 512/512 bytes at offset 4295020544 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295021568 ++read 512/512 bytes at offset 4295021568 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295022592 ++read 512/512 bytes at offset 4295022592 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295023616 ++read 512/512 bytes at offset 4295023616 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295024640 ++read 512/512 bytes at offset 4295024640 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295025664 ++read 512/512 bytes at offset 4295025664 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295026688 ++read 512/512 bytes at offset 4295026688 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295027712 ++read 512/512 bytes at offset 4295027712 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295028736 ++read 512/512 bytes at offset 4295028736 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295029760 ++read 512/512 bytes at offset 4295029760 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295030784 ++read 512/512 bytes at offset 4295030784 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295031808 ++read 512/512 bytes at offset 4295031808 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 1 +-qemu-io> read 512/512 bytes at offset 4294967808 ++=== IO: pattern 1 ++read 512/512 bytes at offset 4294967808 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294968832 ++read 512/512 bytes at offset 4294968832 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294969856 ++read 512/512 bytes at offset 4294969856 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294970880 ++read 512/512 bytes at offset 4294970880 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294971904 ++read 512/512 bytes at offset 4294971904 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294972928 ++read 512/512 bytes at offset 4294972928 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294973952 ++read 512/512 bytes at offset 4294973952 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294974976 ++read 512/512 bytes at offset 4294974976 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294976000 ++read 512/512 bytes at offset 4294976000 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294977024 ++read 512/512 bytes at offset 4294977024 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294978048 ++read 512/512 bytes at offset 4294978048 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294979072 ++read 512/512 bytes at offset 4294979072 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294980096 ++read 512/512 bytes at offset 4294980096 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294981120 ++read 512/512 bytes at offset 4294981120 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294982144 ++read 512/512 bytes at offset 4294982144 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294983168 ++read 512/512 bytes at offset 4294983168 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294984192 ++read 512/512 bytes at offset 4294984192 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294985216 ++read 512/512 bytes at offset 4294985216 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294986240 ++read 512/512 bytes at offset 4294986240 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294987264 ++read 512/512 bytes at offset 4294987264 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294988288 ++read 512/512 bytes at offset 4294988288 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294989312 ++read 512/512 bytes at offset 4294989312 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294990336 ++read 512/512 bytes at offset 4294990336 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294991360 ++read 512/512 bytes at offset 4294991360 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294992384 ++read 512/512 bytes at offset 4294992384 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294993408 ++read 512/512 bytes at offset 4294993408 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294994432 ++read 512/512 bytes at offset 4294994432 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294995456 ++read 512/512 bytes at offset 4294995456 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294996480 ++read 512/512 bytes at offset 4294996480 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294997504 ++read 512/512 bytes at offset 4294997504 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294998528 ++read 512/512 bytes at offset 4294998528 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294999552 ++read 512/512 bytes at offset 4294999552 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295000576 ++read 512/512 bytes at offset 4295000576 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295001600 ++read 512/512 bytes at offset 4295001600 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295002624 ++read 512/512 bytes at offset 4295002624 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295003648 ++read 512/512 bytes at offset 4295003648 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295004672 ++read 512/512 bytes at offset 4295004672 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295005696 ++read 512/512 bytes at offset 4295005696 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295006720 ++read 512/512 bytes at offset 4295006720 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295007744 ++read 512/512 bytes at offset 4295007744 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295008768 ++read 512/512 bytes at offset 4295008768 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295009792 ++read 512/512 bytes at offset 4295009792 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295010816 ++read 512/512 bytes at offset 4295010816 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295011840 ++read 512/512 bytes at offset 4295011840 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295012864 ++read 512/512 bytes at offset 4295012864 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295013888 ++read 512/512 bytes at offset 4295013888 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295014912 ++read 512/512 bytes at offset 4295014912 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295015936 ++read 512/512 bytes at offset 4295015936 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295016960 ++read 512/512 bytes at offset 4295016960 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295017984 ++read 512/512 bytes at offset 4295017984 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295019008 ++read 512/512 bytes at offset 4295019008 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295020032 ++read 512/512 bytes at offset 4295020032 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295021056 ++read 512/512 bytes at offset 4295021056 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295022080 ++read 512/512 bytes at offset 4295022080 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295023104 ++read 512/512 bytes at offset 4295023104 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295024128 ++read 512/512 bytes at offset 4295024128 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295025152 ++read 512/512 bytes at offset 4295025152 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295026176 ++read 512/512 bytes at offset 4295026176 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295027200 ++read 512/512 bytes at offset 4295027200 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295028224 ++read 512/512 bytes at offset 4295028224 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295029248 ++read 512/512 bytes at offset 4295029248 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295030272 ++read 512/512 bytes at offset 4295030272 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295031296 ++read 512/512 bytes at offset 4295031296 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295032320 ++read 512/512 bytes at offset 4295032320 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 128 +-qemu-io> read 65536/65536 bytes at offset 4295032832 ++=== IO: pattern 128 ++read 65536/65536 bytes at offset 4295032832 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> read 65536/65536 bytes at offset 4295098368 ++=== IO: pattern 0 ++read 65536/65536 bytes at offset 4295098368 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> read 65536/65536 bytes at offset 4295294976 ++=== IO: pattern 0 ++read 65536/65536 bytes at offset 4295294976 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> No errors were found on the image. ++No errors were found on the image. + *** done +diff --git a/tests/qemu-iotests/018.out b/tests/qemu-iotests/018.out +index 3ddb8d8..25e7b95 100644 +--- a/tests/qemu-iotests/018.out ++++ b/tests/qemu-iotests/018.out +@@ -3,1075 +3,1075 @@ Formatting 'TEST_DIR/t.IMGFMT.base', fmt=IMGFMT size=6442450944 + Filling base image + + === IO: pattern 0 +-qemu-io> wrote 512/512 bytes at offset 0 ++wrote 512/512 bytes at offset 0 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 1024 ++wrote 512/512 bytes at offset 1024 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 2048 ++wrote 512/512 bytes at offset 2048 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 3072 ++wrote 512/512 bytes at offset 3072 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4096 ++wrote 512/512 bytes at offset 4096 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 5120 ++wrote 512/512 bytes at offset 5120 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 6144 ++wrote 512/512 bytes at offset 6144 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 7168 ++wrote 512/512 bytes at offset 7168 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 8192 ++wrote 512/512 bytes at offset 8192 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 9216 ++wrote 512/512 bytes at offset 9216 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 10240 ++wrote 512/512 bytes at offset 10240 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 11264 ++wrote 512/512 bytes at offset 11264 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 12288 ++wrote 512/512 bytes at offset 12288 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 13312 ++wrote 512/512 bytes at offset 13312 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 14336 ++wrote 512/512 bytes at offset 14336 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 15360 ++wrote 512/512 bytes at offset 15360 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 16384 ++wrote 512/512 bytes at offset 16384 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 17408 ++wrote 512/512 bytes at offset 17408 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 18432 ++wrote 512/512 bytes at offset 18432 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 19456 ++wrote 512/512 bytes at offset 19456 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 20480 ++wrote 512/512 bytes at offset 20480 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 21504 ++wrote 512/512 bytes at offset 21504 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 22528 ++wrote 512/512 bytes at offset 22528 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 23552 ++wrote 512/512 bytes at offset 23552 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 24576 ++wrote 512/512 bytes at offset 24576 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 25600 ++wrote 512/512 bytes at offset 25600 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 26624 ++wrote 512/512 bytes at offset 26624 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 27648 ++wrote 512/512 bytes at offset 27648 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 28672 ++wrote 512/512 bytes at offset 28672 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 29696 ++wrote 512/512 bytes at offset 29696 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 30720 ++wrote 512/512 bytes at offset 30720 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 31744 ++wrote 512/512 bytes at offset 31744 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 32768 ++wrote 512/512 bytes at offset 32768 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 33792 ++wrote 512/512 bytes at offset 33792 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 34816 ++wrote 512/512 bytes at offset 34816 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 35840 ++wrote 512/512 bytes at offset 35840 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 36864 ++wrote 512/512 bytes at offset 36864 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 37888 ++wrote 512/512 bytes at offset 37888 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 38912 ++wrote 512/512 bytes at offset 38912 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 39936 ++wrote 512/512 bytes at offset 39936 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 40960 ++wrote 512/512 bytes at offset 40960 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 41984 ++wrote 512/512 bytes at offset 41984 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 43008 ++wrote 512/512 bytes at offset 43008 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 44032 ++wrote 512/512 bytes at offset 44032 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 45056 ++wrote 512/512 bytes at offset 45056 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 46080 ++wrote 512/512 bytes at offset 46080 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 47104 ++wrote 512/512 bytes at offset 47104 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 48128 ++wrote 512/512 bytes at offset 48128 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 49152 ++wrote 512/512 bytes at offset 49152 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 50176 ++wrote 512/512 bytes at offset 50176 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 51200 ++wrote 512/512 bytes at offset 51200 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 52224 ++wrote 512/512 bytes at offset 52224 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 53248 ++wrote 512/512 bytes at offset 53248 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 54272 ++wrote 512/512 bytes at offset 54272 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 55296 ++wrote 512/512 bytes at offset 55296 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 56320 ++wrote 512/512 bytes at offset 56320 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 57344 ++wrote 512/512 bytes at offset 57344 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 58368 ++wrote 512/512 bytes at offset 58368 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 59392 ++wrote 512/512 bytes at offset 59392 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 60416 ++wrote 512/512 bytes at offset 60416 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 61440 ++wrote 512/512 bytes at offset 61440 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 62464 ++wrote 512/512 bytes at offset 62464 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 63488 ++wrote 512/512 bytes at offset 63488 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 64512 ++wrote 512/512 bytes at offset 64512 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 128 +-qemu-io> wrote 65536/65536 bytes at offset 65536 ++=== IO: pattern 128 ++wrote 65536/65536 bytes at offset 65536 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> wrote 512/512 bytes at offset 4294967296 ++=== IO: pattern 0 ++wrote 512/512 bytes at offset 4294967296 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294968320 ++wrote 512/512 bytes at offset 4294968320 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294969344 ++wrote 512/512 bytes at offset 4294969344 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294970368 ++wrote 512/512 bytes at offset 4294970368 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294971392 ++wrote 512/512 bytes at offset 4294971392 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294972416 ++wrote 512/512 bytes at offset 4294972416 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294973440 ++wrote 512/512 bytes at offset 4294973440 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294974464 ++wrote 512/512 bytes at offset 4294974464 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294975488 ++wrote 512/512 bytes at offset 4294975488 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294976512 ++wrote 512/512 bytes at offset 4294976512 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294977536 ++wrote 512/512 bytes at offset 4294977536 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294978560 ++wrote 512/512 bytes at offset 4294978560 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294979584 ++wrote 512/512 bytes at offset 4294979584 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294980608 ++wrote 512/512 bytes at offset 4294980608 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294981632 ++wrote 512/512 bytes at offset 4294981632 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294982656 ++wrote 512/512 bytes at offset 4294982656 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294983680 ++wrote 512/512 bytes at offset 4294983680 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294984704 ++wrote 512/512 bytes at offset 4294984704 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294985728 ++wrote 512/512 bytes at offset 4294985728 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294986752 ++wrote 512/512 bytes at offset 4294986752 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294987776 ++wrote 512/512 bytes at offset 4294987776 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294988800 ++wrote 512/512 bytes at offset 4294988800 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294989824 ++wrote 512/512 bytes at offset 4294989824 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294990848 ++wrote 512/512 bytes at offset 4294990848 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294991872 ++wrote 512/512 bytes at offset 4294991872 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294992896 ++wrote 512/512 bytes at offset 4294992896 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294993920 ++wrote 512/512 bytes at offset 4294993920 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294994944 ++wrote 512/512 bytes at offset 4294994944 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294995968 ++wrote 512/512 bytes at offset 4294995968 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294996992 ++wrote 512/512 bytes at offset 4294996992 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294998016 ++wrote 512/512 bytes at offset 4294998016 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294999040 ++wrote 512/512 bytes at offset 4294999040 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295000064 ++wrote 512/512 bytes at offset 4295000064 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295001088 ++wrote 512/512 bytes at offset 4295001088 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295002112 ++wrote 512/512 bytes at offset 4295002112 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295003136 ++wrote 512/512 bytes at offset 4295003136 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295004160 ++wrote 512/512 bytes at offset 4295004160 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295005184 ++wrote 512/512 bytes at offset 4295005184 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295006208 ++wrote 512/512 bytes at offset 4295006208 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295007232 ++wrote 512/512 bytes at offset 4295007232 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295008256 ++wrote 512/512 bytes at offset 4295008256 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295009280 ++wrote 512/512 bytes at offset 4295009280 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295010304 ++wrote 512/512 bytes at offset 4295010304 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295011328 ++wrote 512/512 bytes at offset 4295011328 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295012352 ++wrote 512/512 bytes at offset 4295012352 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295013376 ++wrote 512/512 bytes at offset 4295013376 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295014400 ++wrote 512/512 bytes at offset 4295014400 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295015424 ++wrote 512/512 bytes at offset 4295015424 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295016448 ++wrote 512/512 bytes at offset 4295016448 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295017472 ++wrote 512/512 bytes at offset 4295017472 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295018496 ++wrote 512/512 bytes at offset 4295018496 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295019520 ++wrote 512/512 bytes at offset 4295019520 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295020544 ++wrote 512/512 bytes at offset 4295020544 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295021568 ++wrote 512/512 bytes at offset 4295021568 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295022592 ++wrote 512/512 bytes at offset 4295022592 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295023616 ++wrote 512/512 bytes at offset 4295023616 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295024640 ++wrote 512/512 bytes at offset 4295024640 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295025664 ++wrote 512/512 bytes at offset 4295025664 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295026688 ++wrote 512/512 bytes at offset 4295026688 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295027712 ++wrote 512/512 bytes at offset 4295027712 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295028736 ++wrote 512/512 bytes at offset 4295028736 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295029760 ++wrote 512/512 bytes at offset 4295029760 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295030784 ++wrote 512/512 bytes at offset 4295030784 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295031808 ++wrote 512/512 bytes at offset 4295031808 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 128 +-qemu-io> wrote 65536/65536 bytes at offset 4295032832 ++=== IO: pattern 128 ++wrote 65536/65536 bytes at offset 4295032832 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> No errors were found on the image. ++No errors were found on the image. + Creating test image with backing file + + Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=6442450944 backing_file='TEST_DIR/t.IMGFMT.base' + Filling test image + + === IO: pattern 1 +-qemu-io> wrote 512/512 bytes at offset 512 ++wrote 512/512 bytes at offset 512 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 1536 ++wrote 512/512 bytes at offset 1536 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 2560 ++wrote 512/512 bytes at offset 2560 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 3584 ++wrote 512/512 bytes at offset 3584 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4608 ++wrote 512/512 bytes at offset 4608 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 5632 ++wrote 512/512 bytes at offset 5632 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 6656 ++wrote 512/512 bytes at offset 6656 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 7680 ++wrote 512/512 bytes at offset 7680 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 8704 ++wrote 512/512 bytes at offset 8704 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 9728 ++wrote 512/512 bytes at offset 9728 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 10752 ++wrote 512/512 bytes at offset 10752 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 11776 ++wrote 512/512 bytes at offset 11776 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 12800 ++wrote 512/512 bytes at offset 12800 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 13824 ++wrote 512/512 bytes at offset 13824 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 14848 ++wrote 512/512 bytes at offset 14848 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 15872 ++wrote 512/512 bytes at offset 15872 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 16896 ++wrote 512/512 bytes at offset 16896 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 17920 ++wrote 512/512 bytes at offset 17920 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 18944 ++wrote 512/512 bytes at offset 18944 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 19968 ++wrote 512/512 bytes at offset 19968 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 20992 ++wrote 512/512 bytes at offset 20992 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 22016 ++wrote 512/512 bytes at offset 22016 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 23040 ++wrote 512/512 bytes at offset 23040 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 24064 ++wrote 512/512 bytes at offset 24064 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 25088 ++wrote 512/512 bytes at offset 25088 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 26112 ++wrote 512/512 bytes at offset 26112 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 27136 ++wrote 512/512 bytes at offset 27136 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 28160 ++wrote 512/512 bytes at offset 28160 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 29184 ++wrote 512/512 bytes at offset 29184 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 30208 ++wrote 512/512 bytes at offset 30208 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 31232 ++wrote 512/512 bytes at offset 31232 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 32256 ++wrote 512/512 bytes at offset 32256 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 33280 ++wrote 512/512 bytes at offset 33280 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 34304 ++wrote 512/512 bytes at offset 34304 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 35328 ++wrote 512/512 bytes at offset 35328 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 36352 ++wrote 512/512 bytes at offset 36352 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 37376 ++wrote 512/512 bytes at offset 37376 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 38400 ++wrote 512/512 bytes at offset 38400 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 39424 ++wrote 512/512 bytes at offset 39424 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 40448 ++wrote 512/512 bytes at offset 40448 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 41472 ++wrote 512/512 bytes at offset 41472 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 42496 ++wrote 512/512 bytes at offset 42496 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 43520 ++wrote 512/512 bytes at offset 43520 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 44544 ++wrote 512/512 bytes at offset 44544 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 45568 ++wrote 512/512 bytes at offset 45568 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 46592 ++wrote 512/512 bytes at offset 46592 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 47616 ++wrote 512/512 bytes at offset 47616 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 48640 ++wrote 512/512 bytes at offset 48640 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 49664 ++wrote 512/512 bytes at offset 49664 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 50688 ++wrote 512/512 bytes at offset 50688 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 51712 ++wrote 512/512 bytes at offset 51712 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 52736 ++wrote 512/512 bytes at offset 52736 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 53760 ++wrote 512/512 bytes at offset 53760 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 54784 ++wrote 512/512 bytes at offset 54784 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 55808 ++wrote 512/512 bytes at offset 55808 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 56832 ++wrote 512/512 bytes at offset 56832 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 57856 ++wrote 512/512 bytes at offset 57856 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 58880 ++wrote 512/512 bytes at offset 58880 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 59904 ++wrote 512/512 bytes at offset 59904 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 60928 ++wrote 512/512 bytes at offset 60928 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 61952 ++wrote 512/512 bytes at offset 61952 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 62976 ++wrote 512/512 bytes at offset 62976 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 64000 ++wrote 512/512 bytes at offset 64000 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 65024 ++wrote 512/512 bytes at offset 65024 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> wrote 65536/65536 bytes at offset 131072 ++=== IO: pattern 0 ++wrote 65536/65536 bytes at offset 131072 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 1 +-qemu-io> wrote 512/512 bytes at offset 4294967808 ++=== IO: pattern 1 ++wrote 512/512 bytes at offset 4294967808 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294968832 ++wrote 512/512 bytes at offset 4294968832 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294969856 ++wrote 512/512 bytes at offset 4294969856 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294970880 ++wrote 512/512 bytes at offset 4294970880 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294971904 ++wrote 512/512 bytes at offset 4294971904 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294972928 ++wrote 512/512 bytes at offset 4294972928 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294973952 ++wrote 512/512 bytes at offset 4294973952 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294974976 ++wrote 512/512 bytes at offset 4294974976 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294976000 ++wrote 512/512 bytes at offset 4294976000 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294977024 ++wrote 512/512 bytes at offset 4294977024 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294978048 ++wrote 512/512 bytes at offset 4294978048 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294979072 ++wrote 512/512 bytes at offset 4294979072 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294980096 ++wrote 512/512 bytes at offset 4294980096 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294981120 ++wrote 512/512 bytes at offset 4294981120 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294982144 ++wrote 512/512 bytes at offset 4294982144 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294983168 ++wrote 512/512 bytes at offset 4294983168 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294984192 ++wrote 512/512 bytes at offset 4294984192 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294985216 ++wrote 512/512 bytes at offset 4294985216 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294986240 ++wrote 512/512 bytes at offset 4294986240 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294987264 ++wrote 512/512 bytes at offset 4294987264 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294988288 ++wrote 512/512 bytes at offset 4294988288 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294989312 ++wrote 512/512 bytes at offset 4294989312 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294990336 ++wrote 512/512 bytes at offset 4294990336 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294991360 ++wrote 512/512 bytes at offset 4294991360 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294992384 ++wrote 512/512 bytes at offset 4294992384 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294993408 ++wrote 512/512 bytes at offset 4294993408 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294994432 ++wrote 512/512 bytes at offset 4294994432 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294995456 ++wrote 512/512 bytes at offset 4294995456 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294996480 ++wrote 512/512 bytes at offset 4294996480 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294997504 ++wrote 512/512 bytes at offset 4294997504 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294998528 ++wrote 512/512 bytes at offset 4294998528 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294999552 ++wrote 512/512 bytes at offset 4294999552 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295000576 ++wrote 512/512 bytes at offset 4295000576 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295001600 ++wrote 512/512 bytes at offset 4295001600 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295002624 ++wrote 512/512 bytes at offset 4295002624 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295003648 ++wrote 512/512 bytes at offset 4295003648 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295004672 ++wrote 512/512 bytes at offset 4295004672 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295005696 ++wrote 512/512 bytes at offset 4295005696 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295006720 ++wrote 512/512 bytes at offset 4295006720 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295007744 ++wrote 512/512 bytes at offset 4295007744 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295008768 ++wrote 512/512 bytes at offset 4295008768 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295009792 ++wrote 512/512 bytes at offset 4295009792 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295010816 ++wrote 512/512 bytes at offset 4295010816 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295011840 ++wrote 512/512 bytes at offset 4295011840 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295012864 ++wrote 512/512 bytes at offset 4295012864 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295013888 ++wrote 512/512 bytes at offset 4295013888 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295014912 ++wrote 512/512 bytes at offset 4295014912 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295015936 ++wrote 512/512 bytes at offset 4295015936 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295016960 ++wrote 512/512 bytes at offset 4295016960 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295017984 ++wrote 512/512 bytes at offset 4295017984 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295019008 ++wrote 512/512 bytes at offset 4295019008 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295020032 ++wrote 512/512 bytes at offset 4295020032 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295021056 ++wrote 512/512 bytes at offset 4295021056 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295022080 ++wrote 512/512 bytes at offset 4295022080 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295023104 ++wrote 512/512 bytes at offset 4295023104 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295024128 ++wrote 512/512 bytes at offset 4295024128 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295025152 ++wrote 512/512 bytes at offset 4295025152 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295026176 ++wrote 512/512 bytes at offset 4295026176 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295027200 ++wrote 512/512 bytes at offset 4295027200 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295028224 ++wrote 512/512 bytes at offset 4295028224 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295029248 ++wrote 512/512 bytes at offset 4295029248 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295030272 ++wrote 512/512 bytes at offset 4295030272 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295031296 ++wrote 512/512 bytes at offset 4295031296 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295032320 ++wrote 512/512 bytes at offset 4295032320 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> wrote 65536/65536 bytes at offset 4295098368 ++=== IO: pattern 0 ++wrote 65536/65536 bytes at offset 4295098368 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> No errors were found on the image. ++No errors were found on the image. + Reading + + === IO: pattern 0 +-qemu-io> read 512/512 bytes at offset 0 ++read 512/512 bytes at offset 0 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 1024 ++read 512/512 bytes at offset 1024 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 2048 ++read 512/512 bytes at offset 2048 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3072 ++read 512/512 bytes at offset 3072 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4096 ++read 512/512 bytes at offset 4096 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 5120 ++read 512/512 bytes at offset 5120 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 6144 ++read 512/512 bytes at offset 6144 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 7168 ++read 512/512 bytes at offset 7168 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 8192 ++read 512/512 bytes at offset 8192 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 9216 ++read 512/512 bytes at offset 9216 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 10240 ++read 512/512 bytes at offset 10240 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 11264 ++read 512/512 bytes at offset 11264 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 12288 ++read 512/512 bytes at offset 12288 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 13312 ++read 512/512 bytes at offset 13312 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 14336 ++read 512/512 bytes at offset 14336 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 15360 ++read 512/512 bytes at offset 15360 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 16384 ++read 512/512 bytes at offset 16384 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 17408 ++read 512/512 bytes at offset 17408 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 18432 ++read 512/512 bytes at offset 18432 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 19456 ++read 512/512 bytes at offset 19456 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 20480 ++read 512/512 bytes at offset 20480 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 21504 ++read 512/512 bytes at offset 21504 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 22528 ++read 512/512 bytes at offset 22528 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 23552 ++read 512/512 bytes at offset 23552 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 24576 ++read 512/512 bytes at offset 24576 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 25600 ++read 512/512 bytes at offset 25600 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 26624 ++read 512/512 bytes at offset 26624 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 27648 ++read 512/512 bytes at offset 27648 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 28672 ++read 512/512 bytes at offset 28672 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 29696 ++read 512/512 bytes at offset 29696 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 30720 ++read 512/512 bytes at offset 30720 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 31744 ++read 512/512 bytes at offset 31744 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 32768 ++read 512/512 bytes at offset 32768 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 33792 ++read 512/512 bytes at offset 33792 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 34816 ++read 512/512 bytes at offset 34816 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 35840 ++read 512/512 bytes at offset 35840 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 36864 ++read 512/512 bytes at offset 36864 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 37888 ++read 512/512 bytes at offset 37888 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 38912 ++read 512/512 bytes at offset 38912 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 39936 ++read 512/512 bytes at offset 39936 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 40960 ++read 512/512 bytes at offset 40960 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 41984 ++read 512/512 bytes at offset 41984 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 43008 ++read 512/512 bytes at offset 43008 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 44032 ++read 512/512 bytes at offset 44032 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 45056 ++read 512/512 bytes at offset 45056 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 46080 ++read 512/512 bytes at offset 46080 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 47104 ++read 512/512 bytes at offset 47104 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 48128 ++read 512/512 bytes at offset 48128 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 49152 ++read 512/512 bytes at offset 49152 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 50176 ++read 512/512 bytes at offset 50176 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 51200 ++read 512/512 bytes at offset 51200 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 52224 ++read 512/512 bytes at offset 52224 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 53248 ++read 512/512 bytes at offset 53248 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 54272 ++read 512/512 bytes at offset 54272 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 55296 ++read 512/512 bytes at offset 55296 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 56320 ++read 512/512 bytes at offset 56320 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 57344 ++read 512/512 bytes at offset 57344 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 58368 ++read 512/512 bytes at offset 58368 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 59392 ++read 512/512 bytes at offset 59392 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 60416 ++read 512/512 bytes at offset 60416 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 61440 ++read 512/512 bytes at offset 61440 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 62464 ++read 512/512 bytes at offset 62464 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 63488 ++read 512/512 bytes at offset 63488 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 64512 ++read 512/512 bytes at offset 64512 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 1 +-qemu-io> read 512/512 bytes at offset 512 ++=== IO: pattern 1 ++read 512/512 bytes at offset 512 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 1536 ++read 512/512 bytes at offset 1536 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 2560 ++read 512/512 bytes at offset 2560 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3584 ++read 512/512 bytes at offset 3584 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4608 ++read 512/512 bytes at offset 4608 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 5632 ++read 512/512 bytes at offset 5632 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 6656 ++read 512/512 bytes at offset 6656 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 7680 ++read 512/512 bytes at offset 7680 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 8704 ++read 512/512 bytes at offset 8704 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 9728 ++read 512/512 bytes at offset 9728 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 10752 ++read 512/512 bytes at offset 10752 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 11776 ++read 512/512 bytes at offset 11776 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 12800 ++read 512/512 bytes at offset 12800 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 13824 ++read 512/512 bytes at offset 13824 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 14848 ++read 512/512 bytes at offset 14848 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 15872 ++read 512/512 bytes at offset 15872 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 16896 ++read 512/512 bytes at offset 16896 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 17920 ++read 512/512 bytes at offset 17920 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 18944 ++read 512/512 bytes at offset 18944 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 19968 ++read 512/512 bytes at offset 19968 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 20992 ++read 512/512 bytes at offset 20992 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 22016 ++read 512/512 bytes at offset 22016 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 23040 ++read 512/512 bytes at offset 23040 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 24064 ++read 512/512 bytes at offset 24064 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 25088 ++read 512/512 bytes at offset 25088 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 26112 ++read 512/512 bytes at offset 26112 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 27136 ++read 512/512 bytes at offset 27136 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 28160 ++read 512/512 bytes at offset 28160 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 29184 ++read 512/512 bytes at offset 29184 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 30208 ++read 512/512 bytes at offset 30208 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 31232 ++read 512/512 bytes at offset 31232 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 32256 ++read 512/512 bytes at offset 32256 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 33280 ++read 512/512 bytes at offset 33280 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 34304 ++read 512/512 bytes at offset 34304 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 35328 ++read 512/512 bytes at offset 35328 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 36352 ++read 512/512 bytes at offset 36352 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 37376 ++read 512/512 bytes at offset 37376 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 38400 ++read 512/512 bytes at offset 38400 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 39424 ++read 512/512 bytes at offset 39424 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 40448 ++read 512/512 bytes at offset 40448 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 41472 ++read 512/512 bytes at offset 41472 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 42496 ++read 512/512 bytes at offset 42496 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 43520 ++read 512/512 bytes at offset 43520 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 44544 ++read 512/512 bytes at offset 44544 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 45568 ++read 512/512 bytes at offset 45568 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 46592 ++read 512/512 bytes at offset 46592 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 47616 ++read 512/512 bytes at offset 47616 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 48640 ++read 512/512 bytes at offset 48640 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 49664 ++read 512/512 bytes at offset 49664 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 50688 ++read 512/512 bytes at offset 50688 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 51712 ++read 512/512 bytes at offset 51712 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 52736 ++read 512/512 bytes at offset 52736 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 53760 ++read 512/512 bytes at offset 53760 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 54784 ++read 512/512 bytes at offset 54784 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 55808 ++read 512/512 bytes at offset 55808 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 56832 ++read 512/512 bytes at offset 56832 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 57856 ++read 512/512 bytes at offset 57856 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 58880 ++read 512/512 bytes at offset 58880 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 59904 ++read 512/512 bytes at offset 59904 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 60928 ++read 512/512 bytes at offset 60928 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 61952 ++read 512/512 bytes at offset 61952 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 62976 ++read 512/512 bytes at offset 62976 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 64000 ++read 512/512 bytes at offset 64000 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 65024 ++read 512/512 bytes at offset 65024 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 128 +-qemu-io> read 65536/65536 bytes at offset 65536 ++=== IO: pattern 128 ++read 65536/65536 bytes at offset 65536 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> read 65536/65536 bytes at offset 131072 ++=== IO: pattern 0 ++read 65536/65536 bytes at offset 131072 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> read 65536/65536 bytes at offset 327680 ++=== IO: pattern 0 ++read 65536/65536 bytes at offset 327680 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> read 512/512 bytes at offset 4294967296 ++=== IO: pattern 0 ++read 512/512 bytes at offset 4294967296 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294968320 ++read 512/512 bytes at offset 4294968320 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294969344 ++read 512/512 bytes at offset 4294969344 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294970368 ++read 512/512 bytes at offset 4294970368 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294971392 ++read 512/512 bytes at offset 4294971392 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294972416 ++read 512/512 bytes at offset 4294972416 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294973440 ++read 512/512 bytes at offset 4294973440 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294974464 ++read 512/512 bytes at offset 4294974464 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294975488 ++read 512/512 bytes at offset 4294975488 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294976512 ++read 512/512 bytes at offset 4294976512 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294977536 ++read 512/512 bytes at offset 4294977536 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294978560 ++read 512/512 bytes at offset 4294978560 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294979584 ++read 512/512 bytes at offset 4294979584 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294980608 ++read 512/512 bytes at offset 4294980608 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294981632 ++read 512/512 bytes at offset 4294981632 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294982656 ++read 512/512 bytes at offset 4294982656 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294983680 ++read 512/512 bytes at offset 4294983680 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294984704 ++read 512/512 bytes at offset 4294984704 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294985728 ++read 512/512 bytes at offset 4294985728 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294986752 ++read 512/512 bytes at offset 4294986752 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294987776 ++read 512/512 bytes at offset 4294987776 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294988800 ++read 512/512 bytes at offset 4294988800 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294989824 ++read 512/512 bytes at offset 4294989824 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294990848 ++read 512/512 bytes at offset 4294990848 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294991872 ++read 512/512 bytes at offset 4294991872 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294992896 ++read 512/512 bytes at offset 4294992896 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294993920 ++read 512/512 bytes at offset 4294993920 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294994944 ++read 512/512 bytes at offset 4294994944 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294995968 ++read 512/512 bytes at offset 4294995968 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294996992 ++read 512/512 bytes at offset 4294996992 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294998016 ++read 512/512 bytes at offset 4294998016 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294999040 ++read 512/512 bytes at offset 4294999040 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295000064 ++read 512/512 bytes at offset 4295000064 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295001088 ++read 512/512 bytes at offset 4295001088 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295002112 ++read 512/512 bytes at offset 4295002112 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295003136 ++read 512/512 bytes at offset 4295003136 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295004160 ++read 512/512 bytes at offset 4295004160 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295005184 ++read 512/512 bytes at offset 4295005184 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295006208 ++read 512/512 bytes at offset 4295006208 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295007232 ++read 512/512 bytes at offset 4295007232 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295008256 ++read 512/512 bytes at offset 4295008256 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295009280 ++read 512/512 bytes at offset 4295009280 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295010304 ++read 512/512 bytes at offset 4295010304 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295011328 ++read 512/512 bytes at offset 4295011328 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295012352 ++read 512/512 bytes at offset 4295012352 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295013376 ++read 512/512 bytes at offset 4295013376 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295014400 ++read 512/512 bytes at offset 4295014400 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295015424 ++read 512/512 bytes at offset 4295015424 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295016448 ++read 512/512 bytes at offset 4295016448 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295017472 ++read 512/512 bytes at offset 4295017472 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295018496 ++read 512/512 bytes at offset 4295018496 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295019520 ++read 512/512 bytes at offset 4295019520 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295020544 ++read 512/512 bytes at offset 4295020544 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295021568 ++read 512/512 bytes at offset 4295021568 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295022592 ++read 512/512 bytes at offset 4295022592 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295023616 ++read 512/512 bytes at offset 4295023616 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295024640 ++read 512/512 bytes at offset 4295024640 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295025664 ++read 512/512 bytes at offset 4295025664 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295026688 ++read 512/512 bytes at offset 4295026688 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295027712 ++read 512/512 bytes at offset 4295027712 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295028736 ++read 512/512 bytes at offset 4295028736 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295029760 ++read 512/512 bytes at offset 4295029760 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295030784 ++read 512/512 bytes at offset 4295030784 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295031808 ++read 512/512 bytes at offset 4295031808 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 1 +-qemu-io> read 512/512 bytes at offset 4294967808 ++=== IO: pattern 1 ++read 512/512 bytes at offset 4294967808 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294968832 ++read 512/512 bytes at offset 4294968832 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294969856 ++read 512/512 bytes at offset 4294969856 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294970880 ++read 512/512 bytes at offset 4294970880 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294971904 ++read 512/512 bytes at offset 4294971904 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294972928 ++read 512/512 bytes at offset 4294972928 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294973952 ++read 512/512 bytes at offset 4294973952 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294974976 ++read 512/512 bytes at offset 4294974976 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294976000 ++read 512/512 bytes at offset 4294976000 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294977024 ++read 512/512 bytes at offset 4294977024 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294978048 ++read 512/512 bytes at offset 4294978048 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294979072 ++read 512/512 bytes at offset 4294979072 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294980096 ++read 512/512 bytes at offset 4294980096 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294981120 ++read 512/512 bytes at offset 4294981120 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294982144 ++read 512/512 bytes at offset 4294982144 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294983168 ++read 512/512 bytes at offset 4294983168 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294984192 ++read 512/512 bytes at offset 4294984192 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294985216 ++read 512/512 bytes at offset 4294985216 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294986240 ++read 512/512 bytes at offset 4294986240 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294987264 ++read 512/512 bytes at offset 4294987264 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294988288 ++read 512/512 bytes at offset 4294988288 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294989312 ++read 512/512 bytes at offset 4294989312 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294990336 ++read 512/512 bytes at offset 4294990336 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294991360 ++read 512/512 bytes at offset 4294991360 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294992384 ++read 512/512 bytes at offset 4294992384 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294993408 ++read 512/512 bytes at offset 4294993408 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294994432 ++read 512/512 bytes at offset 4294994432 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294995456 ++read 512/512 bytes at offset 4294995456 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294996480 ++read 512/512 bytes at offset 4294996480 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294997504 ++read 512/512 bytes at offset 4294997504 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294998528 ++read 512/512 bytes at offset 4294998528 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294999552 ++read 512/512 bytes at offset 4294999552 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295000576 ++read 512/512 bytes at offset 4295000576 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295001600 ++read 512/512 bytes at offset 4295001600 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295002624 ++read 512/512 bytes at offset 4295002624 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295003648 ++read 512/512 bytes at offset 4295003648 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295004672 ++read 512/512 bytes at offset 4295004672 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295005696 ++read 512/512 bytes at offset 4295005696 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295006720 ++read 512/512 bytes at offset 4295006720 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295007744 ++read 512/512 bytes at offset 4295007744 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295008768 ++read 512/512 bytes at offset 4295008768 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295009792 ++read 512/512 bytes at offset 4295009792 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295010816 ++read 512/512 bytes at offset 4295010816 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295011840 ++read 512/512 bytes at offset 4295011840 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295012864 ++read 512/512 bytes at offset 4295012864 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295013888 ++read 512/512 bytes at offset 4295013888 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295014912 ++read 512/512 bytes at offset 4295014912 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295015936 ++read 512/512 bytes at offset 4295015936 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295016960 ++read 512/512 bytes at offset 4295016960 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295017984 ++read 512/512 bytes at offset 4295017984 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295019008 ++read 512/512 bytes at offset 4295019008 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295020032 ++read 512/512 bytes at offset 4295020032 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295021056 ++read 512/512 bytes at offset 4295021056 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295022080 ++read 512/512 bytes at offset 4295022080 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295023104 ++read 512/512 bytes at offset 4295023104 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295024128 ++read 512/512 bytes at offset 4295024128 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295025152 ++read 512/512 bytes at offset 4295025152 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295026176 ++read 512/512 bytes at offset 4295026176 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295027200 ++read 512/512 bytes at offset 4295027200 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295028224 ++read 512/512 bytes at offset 4295028224 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295029248 ++read 512/512 bytes at offset 4295029248 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295030272 ++read 512/512 bytes at offset 4295030272 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295031296 ++read 512/512 bytes at offset 4295031296 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295032320 ++read 512/512 bytes at offset 4295032320 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 128 +-qemu-io> read 65536/65536 bytes at offset 4295032832 ++=== IO: pattern 128 ++read 65536/65536 bytes at offset 4295032832 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> read 65536/65536 bytes at offset 4295098368 ++=== IO: pattern 0 ++read 65536/65536 bytes at offset 4295098368 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> read 65536/65536 bytes at offset 4295294976 ++=== IO: pattern 0 ++read 65536/65536 bytes at offset 4295294976 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> No errors were found on the image. ++No errors were found on the image. + *** done +diff --git a/tests/qemu-iotests/019.out b/tests/qemu-iotests/019.out +index 5f9a5f2..f0c6e63 100644 +--- a/tests/qemu-iotests/019.out ++++ b/tests/qemu-iotests/019.out +@@ -3,1626 +3,1626 @@ Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=6442450944 + Filling base image + + === IO: pattern 42 +-qemu-io> wrote 512/512 bytes at offset 0 ++wrote 512/512 bytes at offset 0 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 1024 ++wrote 512/512 bytes at offset 1024 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 2048 ++wrote 512/512 bytes at offset 2048 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 3072 ++wrote 512/512 bytes at offset 3072 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4096 ++wrote 512/512 bytes at offset 4096 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 5120 ++wrote 512/512 bytes at offset 5120 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 6144 ++wrote 512/512 bytes at offset 6144 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 7168 ++wrote 512/512 bytes at offset 7168 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 8192 ++wrote 512/512 bytes at offset 8192 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 9216 ++wrote 512/512 bytes at offset 9216 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 10240 ++wrote 512/512 bytes at offset 10240 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 11264 ++wrote 512/512 bytes at offset 11264 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 12288 ++wrote 512/512 bytes at offset 12288 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 13312 ++wrote 512/512 bytes at offset 13312 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 14336 ++wrote 512/512 bytes at offset 14336 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 15360 ++wrote 512/512 bytes at offset 15360 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 16384 ++wrote 512/512 bytes at offset 16384 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 17408 ++wrote 512/512 bytes at offset 17408 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 18432 ++wrote 512/512 bytes at offset 18432 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 19456 ++wrote 512/512 bytes at offset 19456 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 20480 ++wrote 512/512 bytes at offset 20480 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 21504 ++wrote 512/512 bytes at offset 21504 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 22528 ++wrote 512/512 bytes at offset 22528 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 23552 ++wrote 512/512 bytes at offset 23552 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 24576 ++wrote 512/512 bytes at offset 24576 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 25600 ++wrote 512/512 bytes at offset 25600 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 26624 ++wrote 512/512 bytes at offset 26624 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 27648 ++wrote 512/512 bytes at offset 27648 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 28672 ++wrote 512/512 bytes at offset 28672 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 29696 ++wrote 512/512 bytes at offset 29696 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 30720 ++wrote 512/512 bytes at offset 30720 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 31744 ++wrote 512/512 bytes at offset 31744 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 32768 ++wrote 512/512 bytes at offset 32768 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 33792 ++wrote 512/512 bytes at offset 33792 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 34816 ++wrote 512/512 bytes at offset 34816 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 35840 ++wrote 512/512 bytes at offset 35840 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 36864 ++wrote 512/512 bytes at offset 36864 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 37888 ++wrote 512/512 bytes at offset 37888 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 38912 ++wrote 512/512 bytes at offset 38912 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 39936 ++wrote 512/512 bytes at offset 39936 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 40960 ++wrote 512/512 bytes at offset 40960 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 41984 ++wrote 512/512 bytes at offset 41984 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 43008 ++wrote 512/512 bytes at offset 43008 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 44032 ++wrote 512/512 bytes at offset 44032 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 45056 ++wrote 512/512 bytes at offset 45056 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 46080 ++wrote 512/512 bytes at offset 46080 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 47104 ++wrote 512/512 bytes at offset 47104 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 48128 ++wrote 512/512 bytes at offset 48128 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 49152 ++wrote 512/512 bytes at offset 49152 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 50176 ++wrote 512/512 bytes at offset 50176 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 51200 ++wrote 512/512 bytes at offset 51200 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 52224 ++wrote 512/512 bytes at offset 52224 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 53248 ++wrote 512/512 bytes at offset 53248 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 54272 ++wrote 512/512 bytes at offset 54272 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 55296 ++wrote 512/512 bytes at offset 55296 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 56320 ++wrote 512/512 bytes at offset 56320 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 57344 ++wrote 512/512 bytes at offset 57344 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 58368 ++wrote 512/512 bytes at offset 58368 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 59392 ++wrote 512/512 bytes at offset 59392 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 60416 ++wrote 512/512 bytes at offset 60416 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 61440 ++wrote 512/512 bytes at offset 61440 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 62464 ++wrote 512/512 bytes at offset 62464 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 63488 ++wrote 512/512 bytes at offset 63488 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 64512 ++wrote 512/512 bytes at offset 64512 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 42 +-qemu-io> wrote 65536/65536 bytes at offset 1048576 ++=== IO: pattern 42 ++wrote 65536/65536 bytes at offset 1048576 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 42 +-qemu-io> wrote 512/512 bytes at offset 4294967296 ++=== IO: pattern 42 ++wrote 512/512 bytes at offset 4294967296 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294968320 ++wrote 512/512 bytes at offset 4294968320 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294969344 ++wrote 512/512 bytes at offset 4294969344 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294970368 ++wrote 512/512 bytes at offset 4294970368 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294971392 ++wrote 512/512 bytes at offset 4294971392 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294972416 ++wrote 512/512 bytes at offset 4294972416 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294973440 ++wrote 512/512 bytes at offset 4294973440 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294974464 ++wrote 512/512 bytes at offset 4294974464 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294975488 ++wrote 512/512 bytes at offset 4294975488 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294976512 ++wrote 512/512 bytes at offset 4294976512 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294977536 ++wrote 512/512 bytes at offset 4294977536 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294978560 ++wrote 512/512 bytes at offset 4294978560 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294979584 ++wrote 512/512 bytes at offset 4294979584 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294980608 ++wrote 512/512 bytes at offset 4294980608 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294981632 ++wrote 512/512 bytes at offset 4294981632 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294982656 ++wrote 512/512 bytes at offset 4294982656 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294983680 ++wrote 512/512 bytes at offset 4294983680 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294984704 ++wrote 512/512 bytes at offset 4294984704 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294985728 ++wrote 512/512 bytes at offset 4294985728 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294986752 ++wrote 512/512 bytes at offset 4294986752 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294987776 ++wrote 512/512 bytes at offset 4294987776 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294988800 ++wrote 512/512 bytes at offset 4294988800 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294989824 ++wrote 512/512 bytes at offset 4294989824 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294990848 ++wrote 512/512 bytes at offset 4294990848 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294991872 ++wrote 512/512 bytes at offset 4294991872 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294992896 ++wrote 512/512 bytes at offset 4294992896 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294993920 ++wrote 512/512 bytes at offset 4294993920 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294994944 ++wrote 512/512 bytes at offset 4294994944 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294995968 ++wrote 512/512 bytes at offset 4294995968 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294996992 ++wrote 512/512 bytes at offset 4294996992 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294998016 ++wrote 512/512 bytes at offset 4294998016 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294999040 ++wrote 512/512 bytes at offset 4294999040 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295000064 ++wrote 512/512 bytes at offset 4295000064 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295001088 ++wrote 512/512 bytes at offset 4295001088 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295002112 ++wrote 512/512 bytes at offset 4295002112 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295003136 ++wrote 512/512 bytes at offset 4295003136 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295004160 ++wrote 512/512 bytes at offset 4295004160 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295005184 ++wrote 512/512 bytes at offset 4295005184 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295006208 ++wrote 512/512 bytes at offset 4295006208 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295007232 ++wrote 512/512 bytes at offset 4295007232 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295008256 ++wrote 512/512 bytes at offset 4295008256 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295009280 ++wrote 512/512 bytes at offset 4295009280 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295010304 ++wrote 512/512 bytes at offset 4295010304 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295011328 ++wrote 512/512 bytes at offset 4295011328 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295012352 ++wrote 512/512 bytes at offset 4295012352 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295013376 ++wrote 512/512 bytes at offset 4295013376 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295014400 ++wrote 512/512 bytes at offset 4295014400 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295015424 ++wrote 512/512 bytes at offset 4295015424 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295016448 ++wrote 512/512 bytes at offset 4295016448 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295017472 ++wrote 512/512 bytes at offset 4295017472 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295018496 ++wrote 512/512 bytes at offset 4295018496 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295019520 ++wrote 512/512 bytes at offset 4295019520 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295020544 ++wrote 512/512 bytes at offset 4295020544 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295021568 ++wrote 512/512 bytes at offset 4295021568 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295022592 ++wrote 512/512 bytes at offset 4295022592 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295023616 ++wrote 512/512 bytes at offset 4295023616 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295024640 ++wrote 512/512 bytes at offset 4295024640 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295025664 ++wrote 512/512 bytes at offset 4295025664 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295026688 ++wrote 512/512 bytes at offset 4295026688 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295027712 ++wrote 512/512 bytes at offset 4295027712 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295028736 ++wrote 512/512 bytes at offset 4295028736 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295029760 ++wrote 512/512 bytes at offset 4295029760 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295030784 ++wrote 512/512 bytes at offset 4295030784 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295031808 ++wrote 512/512 bytes at offset 4295031808 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 42 +-qemu-io> wrote 65536/65536 bytes at offset 4296015872 ++=== IO: pattern 42 ++wrote 65536/65536 bytes at offset 4296015872 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> No errors were found on the image. ++No errors were found on the image. + Creating test image with backing file + + Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=6442450944 backing_file='TEST_DIR/t.IMGFMT.base' + Filling test image + + === IO: pattern 43 +-qemu-io> wrote 512/512 bytes at offset 512 ++wrote 512/512 bytes at offset 512 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 1536 ++wrote 512/512 bytes at offset 1536 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 2560 ++wrote 512/512 bytes at offset 2560 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 3584 ++wrote 512/512 bytes at offset 3584 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4608 ++wrote 512/512 bytes at offset 4608 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 5632 ++wrote 512/512 bytes at offset 5632 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 6656 ++wrote 512/512 bytes at offset 6656 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 7680 ++wrote 512/512 bytes at offset 7680 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 8704 ++wrote 512/512 bytes at offset 8704 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 9728 ++wrote 512/512 bytes at offset 9728 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 10752 ++wrote 512/512 bytes at offset 10752 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 11776 ++wrote 512/512 bytes at offset 11776 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 12800 ++wrote 512/512 bytes at offset 12800 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 13824 ++wrote 512/512 bytes at offset 13824 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 14848 ++wrote 512/512 bytes at offset 14848 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 15872 ++wrote 512/512 bytes at offset 15872 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 16896 ++wrote 512/512 bytes at offset 16896 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 17920 ++wrote 512/512 bytes at offset 17920 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 18944 ++wrote 512/512 bytes at offset 18944 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 19968 ++wrote 512/512 bytes at offset 19968 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 20992 ++wrote 512/512 bytes at offset 20992 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 22016 ++wrote 512/512 bytes at offset 22016 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 23040 ++wrote 512/512 bytes at offset 23040 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 24064 ++wrote 512/512 bytes at offset 24064 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 25088 ++wrote 512/512 bytes at offset 25088 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 26112 ++wrote 512/512 bytes at offset 26112 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 27136 ++wrote 512/512 bytes at offset 27136 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 28160 ++wrote 512/512 bytes at offset 28160 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 29184 ++wrote 512/512 bytes at offset 29184 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 30208 ++wrote 512/512 bytes at offset 30208 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 31232 ++wrote 512/512 bytes at offset 31232 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 32256 ++wrote 512/512 bytes at offset 32256 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 33280 ++wrote 512/512 bytes at offset 33280 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 34304 ++wrote 512/512 bytes at offset 34304 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 35328 ++wrote 512/512 bytes at offset 35328 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 36352 ++wrote 512/512 bytes at offset 36352 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 37376 ++wrote 512/512 bytes at offset 37376 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 38400 ++wrote 512/512 bytes at offset 38400 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 39424 ++wrote 512/512 bytes at offset 39424 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 40448 ++wrote 512/512 bytes at offset 40448 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 41472 ++wrote 512/512 bytes at offset 41472 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 42496 ++wrote 512/512 bytes at offset 42496 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 43520 ++wrote 512/512 bytes at offset 43520 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 44544 ++wrote 512/512 bytes at offset 44544 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 45568 ++wrote 512/512 bytes at offset 45568 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 46592 ++wrote 512/512 bytes at offset 46592 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 47616 ++wrote 512/512 bytes at offset 47616 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 48640 ++wrote 512/512 bytes at offset 48640 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 49664 ++wrote 512/512 bytes at offset 49664 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 50688 ++wrote 512/512 bytes at offset 50688 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 51712 ++wrote 512/512 bytes at offset 51712 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 52736 ++wrote 512/512 bytes at offset 52736 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 53760 ++wrote 512/512 bytes at offset 53760 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 54784 ++wrote 512/512 bytes at offset 54784 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 55808 ++wrote 512/512 bytes at offset 55808 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 56832 ++wrote 512/512 bytes at offset 56832 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 57856 ++wrote 512/512 bytes at offset 57856 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 58880 ++wrote 512/512 bytes at offset 58880 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 59904 ++wrote 512/512 bytes at offset 59904 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 60928 ++wrote 512/512 bytes at offset 60928 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 61952 ++wrote 512/512 bytes at offset 61952 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 62976 ++wrote 512/512 bytes at offset 62976 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 64000 ++wrote 512/512 bytes at offset 64000 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 65024 ++wrote 512/512 bytes at offset 65024 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 43 +-qemu-io> wrote 65536/65536 bytes at offset 1114112 ++=== IO: pattern 43 ++wrote 65536/65536 bytes at offset 1114112 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 43 +-qemu-io> wrote 512/512 bytes at offset 4294967808 ++=== IO: pattern 43 ++wrote 512/512 bytes at offset 4294967808 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294968832 ++wrote 512/512 bytes at offset 4294968832 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294969856 ++wrote 512/512 bytes at offset 4294969856 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294970880 ++wrote 512/512 bytes at offset 4294970880 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294971904 ++wrote 512/512 bytes at offset 4294971904 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294972928 ++wrote 512/512 bytes at offset 4294972928 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294973952 ++wrote 512/512 bytes at offset 4294973952 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294974976 ++wrote 512/512 bytes at offset 4294974976 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294976000 ++wrote 512/512 bytes at offset 4294976000 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294977024 ++wrote 512/512 bytes at offset 4294977024 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294978048 ++wrote 512/512 bytes at offset 4294978048 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294979072 ++wrote 512/512 bytes at offset 4294979072 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294980096 ++wrote 512/512 bytes at offset 4294980096 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294981120 ++wrote 512/512 bytes at offset 4294981120 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294982144 ++wrote 512/512 bytes at offset 4294982144 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294983168 ++wrote 512/512 bytes at offset 4294983168 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294984192 ++wrote 512/512 bytes at offset 4294984192 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294985216 ++wrote 512/512 bytes at offset 4294985216 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294986240 ++wrote 512/512 bytes at offset 4294986240 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294987264 ++wrote 512/512 bytes at offset 4294987264 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294988288 ++wrote 512/512 bytes at offset 4294988288 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294989312 ++wrote 512/512 bytes at offset 4294989312 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294990336 ++wrote 512/512 bytes at offset 4294990336 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294991360 ++wrote 512/512 bytes at offset 4294991360 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294992384 ++wrote 512/512 bytes at offset 4294992384 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294993408 ++wrote 512/512 bytes at offset 4294993408 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294994432 ++wrote 512/512 bytes at offset 4294994432 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294995456 ++wrote 512/512 bytes at offset 4294995456 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294996480 ++wrote 512/512 bytes at offset 4294996480 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294997504 ++wrote 512/512 bytes at offset 4294997504 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294998528 ++wrote 512/512 bytes at offset 4294998528 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294999552 ++wrote 512/512 bytes at offset 4294999552 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295000576 ++wrote 512/512 bytes at offset 4295000576 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295001600 ++wrote 512/512 bytes at offset 4295001600 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295002624 ++wrote 512/512 bytes at offset 4295002624 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295003648 ++wrote 512/512 bytes at offset 4295003648 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295004672 ++wrote 512/512 bytes at offset 4295004672 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295005696 ++wrote 512/512 bytes at offset 4295005696 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295006720 ++wrote 512/512 bytes at offset 4295006720 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295007744 ++wrote 512/512 bytes at offset 4295007744 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295008768 ++wrote 512/512 bytes at offset 4295008768 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295009792 ++wrote 512/512 bytes at offset 4295009792 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295010816 ++wrote 512/512 bytes at offset 4295010816 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295011840 ++wrote 512/512 bytes at offset 4295011840 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295012864 ++wrote 512/512 bytes at offset 4295012864 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295013888 ++wrote 512/512 bytes at offset 4295013888 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295014912 ++wrote 512/512 bytes at offset 4295014912 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295015936 ++wrote 512/512 bytes at offset 4295015936 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295016960 ++wrote 512/512 bytes at offset 4295016960 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295017984 ++wrote 512/512 bytes at offset 4295017984 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295019008 ++wrote 512/512 bytes at offset 4295019008 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295020032 ++wrote 512/512 bytes at offset 4295020032 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295021056 ++wrote 512/512 bytes at offset 4295021056 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295022080 ++wrote 512/512 bytes at offset 4295022080 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295023104 ++wrote 512/512 bytes at offset 4295023104 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295024128 ++wrote 512/512 bytes at offset 4295024128 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295025152 ++wrote 512/512 bytes at offset 4295025152 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295026176 ++wrote 512/512 bytes at offset 4295026176 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295027200 ++wrote 512/512 bytes at offset 4295027200 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295028224 ++wrote 512/512 bytes at offset 4295028224 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295029248 ++wrote 512/512 bytes at offset 4295029248 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295030272 ++wrote 512/512 bytes at offset 4295030272 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295031296 ++wrote 512/512 bytes at offset 4295031296 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295032320 ++wrote 512/512 bytes at offset 4295032320 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 43 +-qemu-io> wrote 65536/65536 bytes at offset 4296081408 ++=== IO: pattern 43 ++wrote 65536/65536 bytes at offset 4296081408 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> No errors were found on the image. ++No errors were found on the image. + + Testing conversion with -B TEST_DIR/t.IMGFMT.base + + Checking if backing clusters are allocated when they shouldn't + +-qemu-io> 0/128 sectors allocated at offset 1 MiB +-qemu-io> qemu-io> 0/128 sectors allocated at offset 4.001 GiB +-qemu-io> Reading ++0/128 sectors allocated at offset 1 MiB ++0/128 sectors allocated at offset 4.001 GiB ++Reading + + === IO: pattern 42 +-qemu-io> read 512/512 bytes at offset 0 ++read 512/512 bytes at offset 0 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 1024 ++read 512/512 bytes at offset 1024 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 2048 ++read 512/512 bytes at offset 2048 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3072 ++read 512/512 bytes at offset 3072 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4096 ++read 512/512 bytes at offset 4096 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 5120 ++read 512/512 bytes at offset 5120 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 6144 ++read 512/512 bytes at offset 6144 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 7168 ++read 512/512 bytes at offset 7168 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 8192 ++read 512/512 bytes at offset 8192 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 9216 ++read 512/512 bytes at offset 9216 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 10240 ++read 512/512 bytes at offset 10240 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 11264 ++read 512/512 bytes at offset 11264 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 12288 ++read 512/512 bytes at offset 12288 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 13312 ++read 512/512 bytes at offset 13312 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 14336 ++read 512/512 bytes at offset 14336 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 15360 ++read 512/512 bytes at offset 15360 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 16384 ++read 512/512 bytes at offset 16384 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 17408 ++read 512/512 bytes at offset 17408 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 18432 ++read 512/512 bytes at offset 18432 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 19456 ++read 512/512 bytes at offset 19456 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 20480 ++read 512/512 bytes at offset 20480 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 21504 ++read 512/512 bytes at offset 21504 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 22528 ++read 512/512 bytes at offset 22528 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 23552 ++read 512/512 bytes at offset 23552 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 24576 ++read 512/512 bytes at offset 24576 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 25600 ++read 512/512 bytes at offset 25600 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 26624 ++read 512/512 bytes at offset 26624 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 27648 ++read 512/512 bytes at offset 27648 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 28672 ++read 512/512 bytes at offset 28672 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 29696 ++read 512/512 bytes at offset 29696 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 30720 ++read 512/512 bytes at offset 30720 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 31744 ++read 512/512 bytes at offset 31744 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 32768 ++read 512/512 bytes at offset 32768 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 33792 ++read 512/512 bytes at offset 33792 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 34816 ++read 512/512 bytes at offset 34816 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 35840 ++read 512/512 bytes at offset 35840 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 36864 ++read 512/512 bytes at offset 36864 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 37888 ++read 512/512 bytes at offset 37888 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 38912 ++read 512/512 bytes at offset 38912 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 39936 ++read 512/512 bytes at offset 39936 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 40960 ++read 512/512 bytes at offset 40960 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 41984 ++read 512/512 bytes at offset 41984 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 43008 ++read 512/512 bytes at offset 43008 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 44032 ++read 512/512 bytes at offset 44032 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 45056 ++read 512/512 bytes at offset 45056 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 46080 ++read 512/512 bytes at offset 46080 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 47104 ++read 512/512 bytes at offset 47104 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 48128 ++read 512/512 bytes at offset 48128 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 49152 ++read 512/512 bytes at offset 49152 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 50176 ++read 512/512 bytes at offset 50176 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 51200 ++read 512/512 bytes at offset 51200 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 52224 ++read 512/512 bytes at offset 52224 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 53248 ++read 512/512 bytes at offset 53248 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 54272 ++read 512/512 bytes at offset 54272 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 55296 ++read 512/512 bytes at offset 55296 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 56320 ++read 512/512 bytes at offset 56320 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 57344 ++read 512/512 bytes at offset 57344 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 58368 ++read 512/512 bytes at offset 58368 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 59392 ++read 512/512 bytes at offset 59392 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 60416 ++read 512/512 bytes at offset 60416 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 61440 ++read 512/512 bytes at offset 61440 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 62464 ++read 512/512 bytes at offset 62464 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 63488 ++read 512/512 bytes at offset 63488 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 64512 ++read 512/512 bytes at offset 64512 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 43 +-qemu-io> read 512/512 bytes at offset 512 ++=== IO: pattern 43 ++read 512/512 bytes at offset 512 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 1536 ++read 512/512 bytes at offset 1536 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 2560 ++read 512/512 bytes at offset 2560 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3584 ++read 512/512 bytes at offset 3584 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4608 ++read 512/512 bytes at offset 4608 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 5632 ++read 512/512 bytes at offset 5632 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 6656 ++read 512/512 bytes at offset 6656 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 7680 ++read 512/512 bytes at offset 7680 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 8704 ++read 512/512 bytes at offset 8704 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 9728 ++read 512/512 bytes at offset 9728 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 10752 ++read 512/512 bytes at offset 10752 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 11776 ++read 512/512 bytes at offset 11776 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 12800 ++read 512/512 bytes at offset 12800 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 13824 ++read 512/512 bytes at offset 13824 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 14848 ++read 512/512 bytes at offset 14848 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 15872 ++read 512/512 bytes at offset 15872 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 16896 ++read 512/512 bytes at offset 16896 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 17920 ++read 512/512 bytes at offset 17920 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 18944 ++read 512/512 bytes at offset 18944 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 19968 ++read 512/512 bytes at offset 19968 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 20992 ++read 512/512 bytes at offset 20992 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 22016 ++read 512/512 bytes at offset 22016 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 23040 ++read 512/512 bytes at offset 23040 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 24064 ++read 512/512 bytes at offset 24064 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 25088 ++read 512/512 bytes at offset 25088 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 26112 ++read 512/512 bytes at offset 26112 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 27136 ++read 512/512 bytes at offset 27136 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 28160 ++read 512/512 bytes at offset 28160 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 29184 ++read 512/512 bytes at offset 29184 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 30208 ++read 512/512 bytes at offset 30208 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 31232 ++read 512/512 bytes at offset 31232 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 32256 ++read 512/512 bytes at offset 32256 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 33280 ++read 512/512 bytes at offset 33280 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 34304 ++read 512/512 bytes at offset 34304 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 35328 ++read 512/512 bytes at offset 35328 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 36352 ++read 512/512 bytes at offset 36352 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 37376 ++read 512/512 bytes at offset 37376 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 38400 ++read 512/512 bytes at offset 38400 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 39424 ++read 512/512 bytes at offset 39424 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 40448 ++read 512/512 bytes at offset 40448 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 41472 ++read 512/512 bytes at offset 41472 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 42496 ++read 512/512 bytes at offset 42496 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 43520 ++read 512/512 bytes at offset 43520 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 44544 ++read 512/512 bytes at offset 44544 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 45568 ++read 512/512 bytes at offset 45568 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 46592 ++read 512/512 bytes at offset 46592 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 47616 ++read 512/512 bytes at offset 47616 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 48640 ++read 512/512 bytes at offset 48640 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 49664 ++read 512/512 bytes at offset 49664 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 50688 ++read 512/512 bytes at offset 50688 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 51712 ++read 512/512 bytes at offset 51712 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 52736 ++read 512/512 bytes at offset 52736 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 53760 ++read 512/512 bytes at offset 53760 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 54784 ++read 512/512 bytes at offset 54784 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 55808 ++read 512/512 bytes at offset 55808 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 56832 ++read 512/512 bytes at offset 56832 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 57856 ++read 512/512 bytes at offset 57856 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 58880 ++read 512/512 bytes at offset 58880 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 59904 ++read 512/512 bytes at offset 59904 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 60928 ++read 512/512 bytes at offset 60928 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 61952 ++read 512/512 bytes at offset 61952 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 62976 ++read 512/512 bytes at offset 62976 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 64000 ++read 512/512 bytes at offset 64000 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 65024 ++read 512/512 bytes at offset 65024 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 42 +-qemu-io> read 65536/65536 bytes at offset 1048576 ++=== IO: pattern 42 ++read 65536/65536 bytes at offset 1048576 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 43 +-qemu-io> read 65536/65536 bytes at offset 1114112 ++=== IO: pattern 43 ++read 65536/65536 bytes at offset 1114112 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> read 65536/65536 bytes at offset 1310720 ++=== IO: pattern 0 ++read 65536/65536 bytes at offset 1310720 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 42 +-qemu-io> read 512/512 bytes at offset 4294967296 ++=== IO: pattern 42 ++read 512/512 bytes at offset 4294967296 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294968320 ++read 512/512 bytes at offset 4294968320 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294969344 ++read 512/512 bytes at offset 4294969344 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294970368 ++read 512/512 bytes at offset 4294970368 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294971392 ++read 512/512 bytes at offset 4294971392 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294972416 ++read 512/512 bytes at offset 4294972416 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294973440 ++read 512/512 bytes at offset 4294973440 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294974464 ++read 512/512 bytes at offset 4294974464 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294975488 ++read 512/512 bytes at offset 4294975488 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294976512 ++read 512/512 bytes at offset 4294976512 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294977536 ++read 512/512 bytes at offset 4294977536 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294978560 ++read 512/512 bytes at offset 4294978560 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294979584 ++read 512/512 bytes at offset 4294979584 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294980608 ++read 512/512 bytes at offset 4294980608 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294981632 ++read 512/512 bytes at offset 4294981632 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294982656 ++read 512/512 bytes at offset 4294982656 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294983680 ++read 512/512 bytes at offset 4294983680 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294984704 ++read 512/512 bytes at offset 4294984704 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294985728 ++read 512/512 bytes at offset 4294985728 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294986752 ++read 512/512 bytes at offset 4294986752 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294987776 ++read 512/512 bytes at offset 4294987776 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294988800 ++read 512/512 bytes at offset 4294988800 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294989824 ++read 512/512 bytes at offset 4294989824 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294990848 ++read 512/512 bytes at offset 4294990848 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294991872 ++read 512/512 bytes at offset 4294991872 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294992896 ++read 512/512 bytes at offset 4294992896 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294993920 ++read 512/512 bytes at offset 4294993920 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294994944 ++read 512/512 bytes at offset 4294994944 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294995968 ++read 512/512 bytes at offset 4294995968 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294996992 ++read 512/512 bytes at offset 4294996992 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294998016 ++read 512/512 bytes at offset 4294998016 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294999040 ++read 512/512 bytes at offset 4294999040 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295000064 ++read 512/512 bytes at offset 4295000064 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295001088 ++read 512/512 bytes at offset 4295001088 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295002112 ++read 512/512 bytes at offset 4295002112 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295003136 ++read 512/512 bytes at offset 4295003136 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295004160 ++read 512/512 bytes at offset 4295004160 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295005184 ++read 512/512 bytes at offset 4295005184 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295006208 ++read 512/512 bytes at offset 4295006208 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295007232 ++read 512/512 bytes at offset 4295007232 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295008256 ++read 512/512 bytes at offset 4295008256 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295009280 ++read 512/512 bytes at offset 4295009280 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295010304 ++read 512/512 bytes at offset 4295010304 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295011328 ++read 512/512 bytes at offset 4295011328 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295012352 ++read 512/512 bytes at offset 4295012352 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295013376 ++read 512/512 bytes at offset 4295013376 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295014400 ++read 512/512 bytes at offset 4295014400 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295015424 ++read 512/512 bytes at offset 4295015424 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295016448 ++read 512/512 bytes at offset 4295016448 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295017472 ++read 512/512 bytes at offset 4295017472 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295018496 ++read 512/512 bytes at offset 4295018496 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295019520 ++read 512/512 bytes at offset 4295019520 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295020544 ++read 512/512 bytes at offset 4295020544 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295021568 ++read 512/512 bytes at offset 4295021568 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295022592 ++read 512/512 bytes at offset 4295022592 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295023616 ++read 512/512 bytes at offset 4295023616 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295024640 ++read 512/512 bytes at offset 4295024640 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295025664 ++read 512/512 bytes at offset 4295025664 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295026688 ++read 512/512 bytes at offset 4295026688 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295027712 ++read 512/512 bytes at offset 4295027712 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295028736 ++read 512/512 bytes at offset 4295028736 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295029760 ++read 512/512 bytes at offset 4295029760 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295030784 ++read 512/512 bytes at offset 4295030784 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295031808 ++read 512/512 bytes at offset 4295031808 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 43 +-qemu-io> read 512/512 bytes at offset 4294967808 ++=== IO: pattern 43 ++read 512/512 bytes at offset 4294967808 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294968832 ++read 512/512 bytes at offset 4294968832 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294969856 ++read 512/512 bytes at offset 4294969856 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294970880 ++read 512/512 bytes at offset 4294970880 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294971904 ++read 512/512 bytes at offset 4294971904 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294972928 ++read 512/512 bytes at offset 4294972928 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294973952 ++read 512/512 bytes at offset 4294973952 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294974976 ++read 512/512 bytes at offset 4294974976 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294976000 ++read 512/512 bytes at offset 4294976000 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294977024 ++read 512/512 bytes at offset 4294977024 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294978048 ++read 512/512 bytes at offset 4294978048 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294979072 ++read 512/512 bytes at offset 4294979072 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294980096 ++read 512/512 bytes at offset 4294980096 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294981120 ++read 512/512 bytes at offset 4294981120 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294982144 ++read 512/512 bytes at offset 4294982144 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294983168 ++read 512/512 bytes at offset 4294983168 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294984192 ++read 512/512 bytes at offset 4294984192 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294985216 ++read 512/512 bytes at offset 4294985216 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294986240 ++read 512/512 bytes at offset 4294986240 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294987264 ++read 512/512 bytes at offset 4294987264 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294988288 ++read 512/512 bytes at offset 4294988288 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294989312 ++read 512/512 bytes at offset 4294989312 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294990336 ++read 512/512 bytes at offset 4294990336 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294991360 ++read 512/512 bytes at offset 4294991360 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294992384 ++read 512/512 bytes at offset 4294992384 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294993408 ++read 512/512 bytes at offset 4294993408 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294994432 ++read 512/512 bytes at offset 4294994432 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294995456 ++read 512/512 bytes at offset 4294995456 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294996480 ++read 512/512 bytes at offset 4294996480 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294997504 ++read 512/512 bytes at offset 4294997504 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294998528 ++read 512/512 bytes at offset 4294998528 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294999552 ++read 512/512 bytes at offset 4294999552 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295000576 ++read 512/512 bytes at offset 4295000576 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295001600 ++read 512/512 bytes at offset 4295001600 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295002624 ++read 512/512 bytes at offset 4295002624 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295003648 ++read 512/512 bytes at offset 4295003648 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295004672 ++read 512/512 bytes at offset 4295004672 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295005696 ++read 512/512 bytes at offset 4295005696 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295006720 ++read 512/512 bytes at offset 4295006720 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295007744 ++read 512/512 bytes at offset 4295007744 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295008768 ++read 512/512 bytes at offset 4295008768 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295009792 ++read 512/512 bytes at offset 4295009792 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295010816 ++read 512/512 bytes at offset 4295010816 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295011840 ++read 512/512 bytes at offset 4295011840 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295012864 ++read 512/512 bytes at offset 4295012864 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295013888 ++read 512/512 bytes at offset 4295013888 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295014912 ++read 512/512 bytes at offset 4295014912 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295015936 ++read 512/512 bytes at offset 4295015936 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295016960 ++read 512/512 bytes at offset 4295016960 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295017984 ++read 512/512 bytes at offset 4295017984 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295019008 ++read 512/512 bytes at offset 4295019008 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295020032 ++read 512/512 bytes at offset 4295020032 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295021056 ++read 512/512 bytes at offset 4295021056 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295022080 ++read 512/512 bytes at offset 4295022080 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295023104 ++read 512/512 bytes at offset 4295023104 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295024128 ++read 512/512 bytes at offset 4295024128 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295025152 ++read 512/512 bytes at offset 4295025152 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295026176 ++read 512/512 bytes at offset 4295026176 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295027200 ++read 512/512 bytes at offset 4295027200 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295028224 ++read 512/512 bytes at offset 4295028224 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295029248 ++read 512/512 bytes at offset 4295029248 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295030272 ++read 512/512 bytes at offset 4295030272 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295031296 ++read 512/512 bytes at offset 4295031296 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295032320 ++read 512/512 bytes at offset 4295032320 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 42 +-qemu-io> read 65536/65536 bytes at offset 4296015872 ++=== IO: pattern 42 ++read 65536/65536 bytes at offset 4296015872 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 43 +-qemu-io> read 65536/65536 bytes at offset 4296081408 ++=== IO: pattern 43 ++read 65536/65536 bytes at offset 4296081408 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> read 65536/65536 bytes at offset 4296278016 ++=== IO: pattern 0 ++read 65536/65536 bytes at offset 4296278016 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> No errors were found on the image. ++No errors were found on the image. + + Testing conversion with -o backing_file=TEST_DIR/t.IMGFMT.base + + Checking if backing clusters are allocated when they shouldn't + +-qemu-io> 0/128 sectors allocated at offset 1 MiB +-qemu-io> qemu-io> 0/128 sectors allocated at offset 4.001 GiB +-qemu-io> Reading ++0/128 sectors allocated at offset 1 MiB ++0/128 sectors allocated at offset 4.001 GiB ++Reading + + === IO: pattern 42 +-qemu-io> read 512/512 bytes at offset 0 ++read 512/512 bytes at offset 0 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 1024 ++read 512/512 bytes at offset 1024 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 2048 ++read 512/512 bytes at offset 2048 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3072 ++read 512/512 bytes at offset 3072 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4096 ++read 512/512 bytes at offset 4096 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 5120 ++read 512/512 bytes at offset 5120 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 6144 ++read 512/512 bytes at offset 6144 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 7168 ++read 512/512 bytes at offset 7168 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 8192 ++read 512/512 bytes at offset 8192 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 9216 ++read 512/512 bytes at offset 9216 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 10240 ++read 512/512 bytes at offset 10240 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 11264 ++read 512/512 bytes at offset 11264 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 12288 ++read 512/512 bytes at offset 12288 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 13312 ++read 512/512 bytes at offset 13312 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 14336 ++read 512/512 bytes at offset 14336 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 15360 ++read 512/512 bytes at offset 15360 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 16384 ++read 512/512 bytes at offset 16384 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 17408 ++read 512/512 bytes at offset 17408 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 18432 ++read 512/512 bytes at offset 18432 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 19456 ++read 512/512 bytes at offset 19456 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 20480 ++read 512/512 bytes at offset 20480 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 21504 ++read 512/512 bytes at offset 21504 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 22528 ++read 512/512 bytes at offset 22528 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 23552 ++read 512/512 bytes at offset 23552 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 24576 ++read 512/512 bytes at offset 24576 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 25600 ++read 512/512 bytes at offset 25600 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 26624 ++read 512/512 bytes at offset 26624 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 27648 ++read 512/512 bytes at offset 27648 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 28672 ++read 512/512 bytes at offset 28672 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 29696 ++read 512/512 bytes at offset 29696 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 30720 ++read 512/512 bytes at offset 30720 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 31744 ++read 512/512 bytes at offset 31744 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 32768 ++read 512/512 bytes at offset 32768 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 33792 ++read 512/512 bytes at offset 33792 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 34816 ++read 512/512 bytes at offset 34816 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 35840 ++read 512/512 bytes at offset 35840 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 36864 ++read 512/512 bytes at offset 36864 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 37888 ++read 512/512 bytes at offset 37888 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 38912 ++read 512/512 bytes at offset 38912 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 39936 ++read 512/512 bytes at offset 39936 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 40960 ++read 512/512 bytes at offset 40960 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 41984 ++read 512/512 bytes at offset 41984 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 43008 ++read 512/512 bytes at offset 43008 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 44032 ++read 512/512 bytes at offset 44032 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 45056 ++read 512/512 bytes at offset 45056 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 46080 ++read 512/512 bytes at offset 46080 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 47104 ++read 512/512 bytes at offset 47104 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 48128 ++read 512/512 bytes at offset 48128 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 49152 ++read 512/512 bytes at offset 49152 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 50176 ++read 512/512 bytes at offset 50176 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 51200 ++read 512/512 bytes at offset 51200 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 52224 ++read 512/512 bytes at offset 52224 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 53248 ++read 512/512 bytes at offset 53248 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 54272 ++read 512/512 bytes at offset 54272 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 55296 ++read 512/512 bytes at offset 55296 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 56320 ++read 512/512 bytes at offset 56320 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 57344 ++read 512/512 bytes at offset 57344 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 58368 ++read 512/512 bytes at offset 58368 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 59392 ++read 512/512 bytes at offset 59392 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 60416 ++read 512/512 bytes at offset 60416 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 61440 ++read 512/512 bytes at offset 61440 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 62464 ++read 512/512 bytes at offset 62464 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 63488 ++read 512/512 bytes at offset 63488 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 64512 ++read 512/512 bytes at offset 64512 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 43 +-qemu-io> read 512/512 bytes at offset 512 ++=== IO: pattern 43 ++read 512/512 bytes at offset 512 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 1536 ++read 512/512 bytes at offset 1536 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 2560 ++read 512/512 bytes at offset 2560 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3584 ++read 512/512 bytes at offset 3584 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4608 ++read 512/512 bytes at offset 4608 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 5632 ++read 512/512 bytes at offset 5632 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 6656 ++read 512/512 bytes at offset 6656 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 7680 ++read 512/512 bytes at offset 7680 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 8704 ++read 512/512 bytes at offset 8704 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 9728 ++read 512/512 bytes at offset 9728 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 10752 ++read 512/512 bytes at offset 10752 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 11776 ++read 512/512 bytes at offset 11776 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 12800 ++read 512/512 bytes at offset 12800 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 13824 ++read 512/512 bytes at offset 13824 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 14848 ++read 512/512 bytes at offset 14848 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 15872 ++read 512/512 bytes at offset 15872 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 16896 ++read 512/512 bytes at offset 16896 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 17920 ++read 512/512 bytes at offset 17920 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 18944 ++read 512/512 bytes at offset 18944 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 19968 ++read 512/512 bytes at offset 19968 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 20992 ++read 512/512 bytes at offset 20992 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 22016 ++read 512/512 bytes at offset 22016 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 23040 ++read 512/512 bytes at offset 23040 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 24064 ++read 512/512 bytes at offset 24064 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 25088 ++read 512/512 bytes at offset 25088 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 26112 ++read 512/512 bytes at offset 26112 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 27136 ++read 512/512 bytes at offset 27136 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 28160 ++read 512/512 bytes at offset 28160 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 29184 ++read 512/512 bytes at offset 29184 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 30208 ++read 512/512 bytes at offset 30208 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 31232 ++read 512/512 bytes at offset 31232 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 32256 ++read 512/512 bytes at offset 32256 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 33280 ++read 512/512 bytes at offset 33280 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 34304 ++read 512/512 bytes at offset 34304 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 35328 ++read 512/512 bytes at offset 35328 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 36352 ++read 512/512 bytes at offset 36352 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 37376 ++read 512/512 bytes at offset 37376 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 38400 ++read 512/512 bytes at offset 38400 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 39424 ++read 512/512 bytes at offset 39424 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 40448 ++read 512/512 bytes at offset 40448 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 41472 ++read 512/512 bytes at offset 41472 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 42496 ++read 512/512 bytes at offset 42496 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 43520 ++read 512/512 bytes at offset 43520 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 44544 ++read 512/512 bytes at offset 44544 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 45568 ++read 512/512 bytes at offset 45568 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 46592 ++read 512/512 bytes at offset 46592 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 47616 ++read 512/512 bytes at offset 47616 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 48640 ++read 512/512 bytes at offset 48640 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 49664 ++read 512/512 bytes at offset 49664 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 50688 ++read 512/512 bytes at offset 50688 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 51712 ++read 512/512 bytes at offset 51712 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 52736 ++read 512/512 bytes at offset 52736 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 53760 ++read 512/512 bytes at offset 53760 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 54784 ++read 512/512 bytes at offset 54784 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 55808 ++read 512/512 bytes at offset 55808 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 56832 ++read 512/512 bytes at offset 56832 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 57856 ++read 512/512 bytes at offset 57856 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 58880 ++read 512/512 bytes at offset 58880 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 59904 ++read 512/512 bytes at offset 59904 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 60928 ++read 512/512 bytes at offset 60928 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 61952 ++read 512/512 bytes at offset 61952 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 62976 ++read 512/512 bytes at offset 62976 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 64000 ++read 512/512 bytes at offset 64000 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 65024 ++read 512/512 bytes at offset 65024 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 42 +-qemu-io> read 65536/65536 bytes at offset 1048576 ++=== IO: pattern 42 ++read 65536/65536 bytes at offset 1048576 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 43 +-qemu-io> read 65536/65536 bytes at offset 1114112 ++=== IO: pattern 43 ++read 65536/65536 bytes at offset 1114112 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> read 65536/65536 bytes at offset 1310720 ++=== IO: pattern 0 ++read 65536/65536 bytes at offset 1310720 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 42 +-qemu-io> read 512/512 bytes at offset 4294967296 ++=== IO: pattern 42 ++read 512/512 bytes at offset 4294967296 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294968320 ++read 512/512 bytes at offset 4294968320 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294969344 ++read 512/512 bytes at offset 4294969344 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294970368 ++read 512/512 bytes at offset 4294970368 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294971392 ++read 512/512 bytes at offset 4294971392 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294972416 ++read 512/512 bytes at offset 4294972416 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294973440 ++read 512/512 bytes at offset 4294973440 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294974464 ++read 512/512 bytes at offset 4294974464 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294975488 ++read 512/512 bytes at offset 4294975488 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294976512 ++read 512/512 bytes at offset 4294976512 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294977536 ++read 512/512 bytes at offset 4294977536 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294978560 ++read 512/512 bytes at offset 4294978560 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294979584 ++read 512/512 bytes at offset 4294979584 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294980608 ++read 512/512 bytes at offset 4294980608 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294981632 ++read 512/512 bytes at offset 4294981632 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294982656 ++read 512/512 bytes at offset 4294982656 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294983680 ++read 512/512 bytes at offset 4294983680 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294984704 ++read 512/512 bytes at offset 4294984704 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294985728 ++read 512/512 bytes at offset 4294985728 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294986752 ++read 512/512 bytes at offset 4294986752 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294987776 ++read 512/512 bytes at offset 4294987776 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294988800 ++read 512/512 bytes at offset 4294988800 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294989824 ++read 512/512 bytes at offset 4294989824 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294990848 ++read 512/512 bytes at offset 4294990848 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294991872 ++read 512/512 bytes at offset 4294991872 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294992896 ++read 512/512 bytes at offset 4294992896 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294993920 ++read 512/512 bytes at offset 4294993920 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294994944 ++read 512/512 bytes at offset 4294994944 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294995968 ++read 512/512 bytes at offset 4294995968 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294996992 ++read 512/512 bytes at offset 4294996992 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294998016 ++read 512/512 bytes at offset 4294998016 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294999040 ++read 512/512 bytes at offset 4294999040 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295000064 ++read 512/512 bytes at offset 4295000064 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295001088 ++read 512/512 bytes at offset 4295001088 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295002112 ++read 512/512 bytes at offset 4295002112 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295003136 ++read 512/512 bytes at offset 4295003136 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295004160 ++read 512/512 bytes at offset 4295004160 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295005184 ++read 512/512 bytes at offset 4295005184 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295006208 ++read 512/512 bytes at offset 4295006208 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295007232 ++read 512/512 bytes at offset 4295007232 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295008256 ++read 512/512 bytes at offset 4295008256 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295009280 ++read 512/512 bytes at offset 4295009280 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295010304 ++read 512/512 bytes at offset 4295010304 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295011328 ++read 512/512 bytes at offset 4295011328 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295012352 ++read 512/512 bytes at offset 4295012352 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295013376 ++read 512/512 bytes at offset 4295013376 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295014400 ++read 512/512 bytes at offset 4295014400 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295015424 ++read 512/512 bytes at offset 4295015424 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295016448 ++read 512/512 bytes at offset 4295016448 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295017472 ++read 512/512 bytes at offset 4295017472 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295018496 ++read 512/512 bytes at offset 4295018496 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295019520 ++read 512/512 bytes at offset 4295019520 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295020544 ++read 512/512 bytes at offset 4295020544 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295021568 ++read 512/512 bytes at offset 4295021568 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295022592 ++read 512/512 bytes at offset 4295022592 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295023616 ++read 512/512 bytes at offset 4295023616 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295024640 ++read 512/512 bytes at offset 4295024640 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295025664 ++read 512/512 bytes at offset 4295025664 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295026688 ++read 512/512 bytes at offset 4295026688 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295027712 ++read 512/512 bytes at offset 4295027712 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295028736 ++read 512/512 bytes at offset 4295028736 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295029760 ++read 512/512 bytes at offset 4295029760 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295030784 ++read 512/512 bytes at offset 4295030784 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295031808 ++read 512/512 bytes at offset 4295031808 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 43 +-qemu-io> read 512/512 bytes at offset 4294967808 ++=== IO: pattern 43 ++read 512/512 bytes at offset 4294967808 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294968832 ++read 512/512 bytes at offset 4294968832 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294969856 ++read 512/512 bytes at offset 4294969856 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294970880 ++read 512/512 bytes at offset 4294970880 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294971904 ++read 512/512 bytes at offset 4294971904 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294972928 ++read 512/512 bytes at offset 4294972928 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294973952 ++read 512/512 bytes at offset 4294973952 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294974976 ++read 512/512 bytes at offset 4294974976 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294976000 ++read 512/512 bytes at offset 4294976000 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294977024 ++read 512/512 bytes at offset 4294977024 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294978048 ++read 512/512 bytes at offset 4294978048 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294979072 ++read 512/512 bytes at offset 4294979072 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294980096 ++read 512/512 bytes at offset 4294980096 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294981120 ++read 512/512 bytes at offset 4294981120 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294982144 ++read 512/512 bytes at offset 4294982144 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294983168 ++read 512/512 bytes at offset 4294983168 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294984192 ++read 512/512 bytes at offset 4294984192 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294985216 ++read 512/512 bytes at offset 4294985216 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294986240 ++read 512/512 bytes at offset 4294986240 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294987264 ++read 512/512 bytes at offset 4294987264 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294988288 ++read 512/512 bytes at offset 4294988288 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294989312 ++read 512/512 bytes at offset 4294989312 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294990336 ++read 512/512 bytes at offset 4294990336 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294991360 ++read 512/512 bytes at offset 4294991360 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294992384 ++read 512/512 bytes at offset 4294992384 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294993408 ++read 512/512 bytes at offset 4294993408 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294994432 ++read 512/512 bytes at offset 4294994432 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294995456 ++read 512/512 bytes at offset 4294995456 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294996480 ++read 512/512 bytes at offset 4294996480 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294997504 ++read 512/512 bytes at offset 4294997504 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294998528 ++read 512/512 bytes at offset 4294998528 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294999552 ++read 512/512 bytes at offset 4294999552 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295000576 ++read 512/512 bytes at offset 4295000576 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295001600 ++read 512/512 bytes at offset 4295001600 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295002624 ++read 512/512 bytes at offset 4295002624 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295003648 ++read 512/512 bytes at offset 4295003648 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295004672 ++read 512/512 bytes at offset 4295004672 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295005696 ++read 512/512 bytes at offset 4295005696 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295006720 ++read 512/512 bytes at offset 4295006720 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295007744 ++read 512/512 bytes at offset 4295007744 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295008768 ++read 512/512 bytes at offset 4295008768 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295009792 ++read 512/512 bytes at offset 4295009792 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295010816 ++read 512/512 bytes at offset 4295010816 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295011840 ++read 512/512 bytes at offset 4295011840 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295012864 ++read 512/512 bytes at offset 4295012864 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295013888 ++read 512/512 bytes at offset 4295013888 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295014912 ++read 512/512 bytes at offset 4295014912 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295015936 ++read 512/512 bytes at offset 4295015936 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295016960 ++read 512/512 bytes at offset 4295016960 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295017984 ++read 512/512 bytes at offset 4295017984 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295019008 ++read 512/512 bytes at offset 4295019008 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295020032 ++read 512/512 bytes at offset 4295020032 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295021056 ++read 512/512 bytes at offset 4295021056 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295022080 ++read 512/512 bytes at offset 4295022080 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295023104 ++read 512/512 bytes at offset 4295023104 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295024128 ++read 512/512 bytes at offset 4295024128 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295025152 ++read 512/512 bytes at offset 4295025152 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295026176 ++read 512/512 bytes at offset 4295026176 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295027200 ++read 512/512 bytes at offset 4295027200 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295028224 ++read 512/512 bytes at offset 4295028224 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295029248 ++read 512/512 bytes at offset 4295029248 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295030272 ++read 512/512 bytes at offset 4295030272 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295031296 ++read 512/512 bytes at offset 4295031296 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295032320 ++read 512/512 bytes at offset 4295032320 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 42 +-qemu-io> read 65536/65536 bytes at offset 4296015872 ++=== IO: pattern 42 ++read 65536/65536 bytes at offset 4296015872 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 43 +-qemu-io> read 65536/65536 bytes at offset 4296081408 ++=== IO: pattern 43 ++read 65536/65536 bytes at offset 4296081408 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> read 65536/65536 bytes at offset 4296278016 ++=== IO: pattern 0 ++read 65536/65536 bytes at offset 4296278016 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> No errors were found on the image. ++No errors were found on the image. + *** done +diff --git a/tests/qemu-iotests/020.out b/tests/qemu-iotests/020.out +index 4ba56bd..fc9a63c 100644 +--- a/tests/qemu-iotests/020.out ++++ b/tests/qemu-iotests/020.out +@@ -3,1076 +3,1076 @@ Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=6442450944 + Filling base image + + === IO: pattern 0 +-qemu-io> wrote 512/512 bytes at offset 0 ++wrote 512/512 bytes at offset 0 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 1024 ++wrote 512/512 bytes at offset 1024 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 2048 ++wrote 512/512 bytes at offset 2048 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 3072 ++wrote 512/512 bytes at offset 3072 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4096 ++wrote 512/512 bytes at offset 4096 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 5120 ++wrote 512/512 bytes at offset 5120 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 6144 ++wrote 512/512 bytes at offset 6144 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 7168 ++wrote 512/512 bytes at offset 7168 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 8192 ++wrote 512/512 bytes at offset 8192 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 9216 ++wrote 512/512 bytes at offset 9216 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 10240 ++wrote 512/512 bytes at offset 10240 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 11264 ++wrote 512/512 bytes at offset 11264 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 12288 ++wrote 512/512 bytes at offset 12288 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 13312 ++wrote 512/512 bytes at offset 13312 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 14336 ++wrote 512/512 bytes at offset 14336 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 15360 ++wrote 512/512 bytes at offset 15360 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 16384 ++wrote 512/512 bytes at offset 16384 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 17408 ++wrote 512/512 bytes at offset 17408 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 18432 ++wrote 512/512 bytes at offset 18432 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 19456 ++wrote 512/512 bytes at offset 19456 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 20480 ++wrote 512/512 bytes at offset 20480 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 21504 ++wrote 512/512 bytes at offset 21504 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 22528 ++wrote 512/512 bytes at offset 22528 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 23552 ++wrote 512/512 bytes at offset 23552 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 24576 ++wrote 512/512 bytes at offset 24576 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 25600 ++wrote 512/512 bytes at offset 25600 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 26624 ++wrote 512/512 bytes at offset 26624 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 27648 ++wrote 512/512 bytes at offset 27648 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 28672 ++wrote 512/512 bytes at offset 28672 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 29696 ++wrote 512/512 bytes at offset 29696 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 30720 ++wrote 512/512 bytes at offset 30720 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 31744 ++wrote 512/512 bytes at offset 31744 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 32768 ++wrote 512/512 bytes at offset 32768 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 33792 ++wrote 512/512 bytes at offset 33792 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 34816 ++wrote 512/512 bytes at offset 34816 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 35840 ++wrote 512/512 bytes at offset 35840 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 36864 ++wrote 512/512 bytes at offset 36864 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 37888 ++wrote 512/512 bytes at offset 37888 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 38912 ++wrote 512/512 bytes at offset 38912 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 39936 ++wrote 512/512 bytes at offset 39936 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 40960 ++wrote 512/512 bytes at offset 40960 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 41984 ++wrote 512/512 bytes at offset 41984 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 43008 ++wrote 512/512 bytes at offset 43008 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 44032 ++wrote 512/512 bytes at offset 44032 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 45056 ++wrote 512/512 bytes at offset 45056 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 46080 ++wrote 512/512 bytes at offset 46080 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 47104 ++wrote 512/512 bytes at offset 47104 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 48128 ++wrote 512/512 bytes at offset 48128 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 49152 ++wrote 512/512 bytes at offset 49152 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 50176 ++wrote 512/512 bytes at offset 50176 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 51200 ++wrote 512/512 bytes at offset 51200 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 52224 ++wrote 512/512 bytes at offset 52224 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 53248 ++wrote 512/512 bytes at offset 53248 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 54272 ++wrote 512/512 bytes at offset 54272 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 55296 ++wrote 512/512 bytes at offset 55296 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 56320 ++wrote 512/512 bytes at offset 56320 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 57344 ++wrote 512/512 bytes at offset 57344 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 58368 ++wrote 512/512 bytes at offset 58368 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 59392 ++wrote 512/512 bytes at offset 59392 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 60416 ++wrote 512/512 bytes at offset 60416 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 61440 ++wrote 512/512 bytes at offset 61440 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 62464 ++wrote 512/512 bytes at offset 62464 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 63488 ++wrote 512/512 bytes at offset 63488 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 64512 ++wrote 512/512 bytes at offset 64512 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 128 +-qemu-io> wrote 65536/65536 bytes at offset 65536 ++=== IO: pattern 128 ++wrote 65536/65536 bytes at offset 65536 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> wrote 512/512 bytes at offset 4294967296 ++=== IO: pattern 0 ++wrote 512/512 bytes at offset 4294967296 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294968320 ++wrote 512/512 bytes at offset 4294968320 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294969344 ++wrote 512/512 bytes at offset 4294969344 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294970368 ++wrote 512/512 bytes at offset 4294970368 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294971392 ++wrote 512/512 bytes at offset 4294971392 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294972416 ++wrote 512/512 bytes at offset 4294972416 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294973440 ++wrote 512/512 bytes at offset 4294973440 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294974464 ++wrote 512/512 bytes at offset 4294974464 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294975488 ++wrote 512/512 bytes at offset 4294975488 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294976512 ++wrote 512/512 bytes at offset 4294976512 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294977536 ++wrote 512/512 bytes at offset 4294977536 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294978560 ++wrote 512/512 bytes at offset 4294978560 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294979584 ++wrote 512/512 bytes at offset 4294979584 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294980608 ++wrote 512/512 bytes at offset 4294980608 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294981632 ++wrote 512/512 bytes at offset 4294981632 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294982656 ++wrote 512/512 bytes at offset 4294982656 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294983680 ++wrote 512/512 bytes at offset 4294983680 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294984704 ++wrote 512/512 bytes at offset 4294984704 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294985728 ++wrote 512/512 bytes at offset 4294985728 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294986752 ++wrote 512/512 bytes at offset 4294986752 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294987776 ++wrote 512/512 bytes at offset 4294987776 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294988800 ++wrote 512/512 bytes at offset 4294988800 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294989824 ++wrote 512/512 bytes at offset 4294989824 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294990848 ++wrote 512/512 bytes at offset 4294990848 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294991872 ++wrote 512/512 bytes at offset 4294991872 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294992896 ++wrote 512/512 bytes at offset 4294992896 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294993920 ++wrote 512/512 bytes at offset 4294993920 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294994944 ++wrote 512/512 bytes at offset 4294994944 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294995968 ++wrote 512/512 bytes at offset 4294995968 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294996992 ++wrote 512/512 bytes at offset 4294996992 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294998016 ++wrote 512/512 bytes at offset 4294998016 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294999040 ++wrote 512/512 bytes at offset 4294999040 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295000064 ++wrote 512/512 bytes at offset 4295000064 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295001088 ++wrote 512/512 bytes at offset 4295001088 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295002112 ++wrote 512/512 bytes at offset 4295002112 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295003136 ++wrote 512/512 bytes at offset 4295003136 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295004160 ++wrote 512/512 bytes at offset 4295004160 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295005184 ++wrote 512/512 bytes at offset 4295005184 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295006208 ++wrote 512/512 bytes at offset 4295006208 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295007232 ++wrote 512/512 bytes at offset 4295007232 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295008256 ++wrote 512/512 bytes at offset 4295008256 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295009280 ++wrote 512/512 bytes at offset 4295009280 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295010304 ++wrote 512/512 bytes at offset 4295010304 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295011328 ++wrote 512/512 bytes at offset 4295011328 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295012352 ++wrote 512/512 bytes at offset 4295012352 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295013376 ++wrote 512/512 bytes at offset 4295013376 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295014400 ++wrote 512/512 bytes at offset 4295014400 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295015424 ++wrote 512/512 bytes at offset 4295015424 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295016448 ++wrote 512/512 bytes at offset 4295016448 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295017472 ++wrote 512/512 bytes at offset 4295017472 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295018496 ++wrote 512/512 bytes at offset 4295018496 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295019520 ++wrote 512/512 bytes at offset 4295019520 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295020544 ++wrote 512/512 bytes at offset 4295020544 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295021568 ++wrote 512/512 bytes at offset 4295021568 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295022592 ++wrote 512/512 bytes at offset 4295022592 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295023616 ++wrote 512/512 bytes at offset 4295023616 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295024640 ++wrote 512/512 bytes at offset 4295024640 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295025664 ++wrote 512/512 bytes at offset 4295025664 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295026688 ++wrote 512/512 bytes at offset 4295026688 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295027712 ++wrote 512/512 bytes at offset 4295027712 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295028736 ++wrote 512/512 bytes at offset 4295028736 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295029760 ++wrote 512/512 bytes at offset 4295029760 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295030784 ++wrote 512/512 bytes at offset 4295030784 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295031808 ++wrote 512/512 bytes at offset 4295031808 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 128 +-qemu-io> wrote 65536/65536 bytes at offset 4295032832 ++=== IO: pattern 128 ++wrote 65536/65536 bytes at offset 4295032832 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> No errors were found on the image. ++No errors were found on the image. + Creating test image with backing file + + Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=6442450944 backing_file='TEST_DIR/t.IMGFMT.base' + Filling test image + + === IO: pattern 1 +-qemu-io> wrote 512/512 bytes at offset 512 ++wrote 512/512 bytes at offset 512 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 1536 ++wrote 512/512 bytes at offset 1536 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 2560 ++wrote 512/512 bytes at offset 2560 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 3584 ++wrote 512/512 bytes at offset 3584 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4608 ++wrote 512/512 bytes at offset 4608 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 5632 ++wrote 512/512 bytes at offset 5632 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 6656 ++wrote 512/512 bytes at offset 6656 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 7680 ++wrote 512/512 bytes at offset 7680 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 8704 ++wrote 512/512 bytes at offset 8704 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 9728 ++wrote 512/512 bytes at offset 9728 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 10752 ++wrote 512/512 bytes at offset 10752 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 11776 ++wrote 512/512 bytes at offset 11776 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 12800 ++wrote 512/512 bytes at offset 12800 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 13824 ++wrote 512/512 bytes at offset 13824 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 14848 ++wrote 512/512 bytes at offset 14848 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 15872 ++wrote 512/512 bytes at offset 15872 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 16896 ++wrote 512/512 bytes at offset 16896 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 17920 ++wrote 512/512 bytes at offset 17920 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 18944 ++wrote 512/512 bytes at offset 18944 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 19968 ++wrote 512/512 bytes at offset 19968 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 20992 ++wrote 512/512 bytes at offset 20992 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 22016 ++wrote 512/512 bytes at offset 22016 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 23040 ++wrote 512/512 bytes at offset 23040 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 24064 ++wrote 512/512 bytes at offset 24064 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 25088 ++wrote 512/512 bytes at offset 25088 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 26112 ++wrote 512/512 bytes at offset 26112 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 27136 ++wrote 512/512 bytes at offset 27136 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 28160 ++wrote 512/512 bytes at offset 28160 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 29184 ++wrote 512/512 bytes at offset 29184 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 30208 ++wrote 512/512 bytes at offset 30208 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 31232 ++wrote 512/512 bytes at offset 31232 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 32256 ++wrote 512/512 bytes at offset 32256 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 33280 ++wrote 512/512 bytes at offset 33280 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 34304 ++wrote 512/512 bytes at offset 34304 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 35328 ++wrote 512/512 bytes at offset 35328 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 36352 ++wrote 512/512 bytes at offset 36352 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 37376 ++wrote 512/512 bytes at offset 37376 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 38400 ++wrote 512/512 bytes at offset 38400 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 39424 ++wrote 512/512 bytes at offset 39424 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 40448 ++wrote 512/512 bytes at offset 40448 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 41472 ++wrote 512/512 bytes at offset 41472 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 42496 ++wrote 512/512 bytes at offset 42496 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 43520 ++wrote 512/512 bytes at offset 43520 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 44544 ++wrote 512/512 bytes at offset 44544 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 45568 ++wrote 512/512 bytes at offset 45568 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 46592 ++wrote 512/512 bytes at offset 46592 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 47616 ++wrote 512/512 bytes at offset 47616 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 48640 ++wrote 512/512 bytes at offset 48640 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 49664 ++wrote 512/512 bytes at offset 49664 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 50688 ++wrote 512/512 bytes at offset 50688 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 51712 ++wrote 512/512 bytes at offset 51712 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 52736 ++wrote 512/512 bytes at offset 52736 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 53760 ++wrote 512/512 bytes at offset 53760 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 54784 ++wrote 512/512 bytes at offset 54784 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 55808 ++wrote 512/512 bytes at offset 55808 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 56832 ++wrote 512/512 bytes at offset 56832 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 57856 ++wrote 512/512 bytes at offset 57856 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 58880 ++wrote 512/512 bytes at offset 58880 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 59904 ++wrote 512/512 bytes at offset 59904 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 60928 ++wrote 512/512 bytes at offset 60928 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 61952 ++wrote 512/512 bytes at offset 61952 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 62976 ++wrote 512/512 bytes at offset 62976 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 64000 ++wrote 512/512 bytes at offset 64000 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 65024 ++wrote 512/512 bytes at offset 65024 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> wrote 65536/65536 bytes at offset 131072 ++=== IO: pattern 0 ++wrote 65536/65536 bytes at offset 131072 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 1 +-qemu-io> wrote 512/512 bytes at offset 4294967808 ++=== IO: pattern 1 ++wrote 512/512 bytes at offset 4294967808 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294968832 ++wrote 512/512 bytes at offset 4294968832 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294969856 ++wrote 512/512 bytes at offset 4294969856 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294970880 ++wrote 512/512 bytes at offset 4294970880 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294971904 ++wrote 512/512 bytes at offset 4294971904 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294972928 ++wrote 512/512 bytes at offset 4294972928 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294973952 ++wrote 512/512 bytes at offset 4294973952 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294974976 ++wrote 512/512 bytes at offset 4294974976 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294976000 ++wrote 512/512 bytes at offset 4294976000 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294977024 ++wrote 512/512 bytes at offset 4294977024 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294978048 ++wrote 512/512 bytes at offset 4294978048 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294979072 ++wrote 512/512 bytes at offset 4294979072 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294980096 ++wrote 512/512 bytes at offset 4294980096 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294981120 ++wrote 512/512 bytes at offset 4294981120 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294982144 ++wrote 512/512 bytes at offset 4294982144 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294983168 ++wrote 512/512 bytes at offset 4294983168 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294984192 ++wrote 512/512 bytes at offset 4294984192 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294985216 ++wrote 512/512 bytes at offset 4294985216 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294986240 ++wrote 512/512 bytes at offset 4294986240 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294987264 ++wrote 512/512 bytes at offset 4294987264 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294988288 ++wrote 512/512 bytes at offset 4294988288 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294989312 ++wrote 512/512 bytes at offset 4294989312 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294990336 ++wrote 512/512 bytes at offset 4294990336 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294991360 ++wrote 512/512 bytes at offset 4294991360 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294992384 ++wrote 512/512 bytes at offset 4294992384 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294993408 ++wrote 512/512 bytes at offset 4294993408 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294994432 ++wrote 512/512 bytes at offset 4294994432 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294995456 ++wrote 512/512 bytes at offset 4294995456 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294996480 ++wrote 512/512 bytes at offset 4294996480 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294997504 ++wrote 512/512 bytes at offset 4294997504 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294998528 ++wrote 512/512 bytes at offset 4294998528 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4294999552 ++wrote 512/512 bytes at offset 4294999552 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295000576 ++wrote 512/512 bytes at offset 4295000576 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295001600 ++wrote 512/512 bytes at offset 4295001600 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295002624 ++wrote 512/512 bytes at offset 4295002624 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295003648 ++wrote 512/512 bytes at offset 4295003648 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295004672 ++wrote 512/512 bytes at offset 4295004672 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295005696 ++wrote 512/512 bytes at offset 4295005696 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295006720 ++wrote 512/512 bytes at offset 4295006720 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295007744 ++wrote 512/512 bytes at offset 4295007744 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295008768 ++wrote 512/512 bytes at offset 4295008768 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295009792 ++wrote 512/512 bytes at offset 4295009792 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295010816 ++wrote 512/512 bytes at offset 4295010816 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295011840 ++wrote 512/512 bytes at offset 4295011840 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295012864 ++wrote 512/512 bytes at offset 4295012864 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295013888 ++wrote 512/512 bytes at offset 4295013888 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295014912 ++wrote 512/512 bytes at offset 4295014912 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295015936 ++wrote 512/512 bytes at offset 4295015936 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295016960 ++wrote 512/512 bytes at offset 4295016960 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295017984 ++wrote 512/512 bytes at offset 4295017984 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295019008 ++wrote 512/512 bytes at offset 4295019008 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295020032 ++wrote 512/512 bytes at offset 4295020032 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295021056 ++wrote 512/512 bytes at offset 4295021056 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295022080 ++wrote 512/512 bytes at offset 4295022080 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295023104 ++wrote 512/512 bytes at offset 4295023104 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295024128 ++wrote 512/512 bytes at offset 4295024128 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295025152 ++wrote 512/512 bytes at offset 4295025152 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295026176 ++wrote 512/512 bytes at offset 4295026176 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295027200 ++wrote 512/512 bytes at offset 4295027200 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295028224 ++wrote 512/512 bytes at offset 4295028224 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295029248 ++wrote 512/512 bytes at offset 4295029248 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295030272 ++wrote 512/512 bytes at offset 4295030272 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295031296 ++wrote 512/512 bytes at offset 4295031296 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295032320 ++wrote 512/512 bytes at offset 4295032320 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> wrote 65536/65536 bytes at offset 4295098368 ++=== IO: pattern 0 ++wrote 65536/65536 bytes at offset 4295098368 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> No errors were found on the image. ++No errors were found on the image. + Image committed. + Reading from the backing file + + === IO: pattern 0 +-qemu-io> read 512/512 bytes at offset 0 ++read 512/512 bytes at offset 0 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 1024 ++read 512/512 bytes at offset 1024 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 2048 ++read 512/512 bytes at offset 2048 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3072 ++read 512/512 bytes at offset 3072 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4096 ++read 512/512 bytes at offset 4096 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 5120 ++read 512/512 bytes at offset 5120 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 6144 ++read 512/512 bytes at offset 6144 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 7168 ++read 512/512 bytes at offset 7168 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 8192 ++read 512/512 bytes at offset 8192 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 9216 ++read 512/512 bytes at offset 9216 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 10240 ++read 512/512 bytes at offset 10240 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 11264 ++read 512/512 bytes at offset 11264 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 12288 ++read 512/512 bytes at offset 12288 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 13312 ++read 512/512 bytes at offset 13312 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 14336 ++read 512/512 bytes at offset 14336 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 15360 ++read 512/512 bytes at offset 15360 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 16384 ++read 512/512 bytes at offset 16384 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 17408 ++read 512/512 bytes at offset 17408 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 18432 ++read 512/512 bytes at offset 18432 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 19456 ++read 512/512 bytes at offset 19456 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 20480 ++read 512/512 bytes at offset 20480 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 21504 ++read 512/512 bytes at offset 21504 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 22528 ++read 512/512 bytes at offset 22528 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 23552 ++read 512/512 bytes at offset 23552 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 24576 ++read 512/512 bytes at offset 24576 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 25600 ++read 512/512 bytes at offset 25600 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 26624 ++read 512/512 bytes at offset 26624 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 27648 ++read 512/512 bytes at offset 27648 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 28672 ++read 512/512 bytes at offset 28672 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 29696 ++read 512/512 bytes at offset 29696 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 30720 ++read 512/512 bytes at offset 30720 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 31744 ++read 512/512 bytes at offset 31744 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 32768 ++read 512/512 bytes at offset 32768 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 33792 ++read 512/512 bytes at offset 33792 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 34816 ++read 512/512 bytes at offset 34816 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 35840 ++read 512/512 bytes at offset 35840 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 36864 ++read 512/512 bytes at offset 36864 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 37888 ++read 512/512 bytes at offset 37888 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 38912 ++read 512/512 bytes at offset 38912 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 39936 ++read 512/512 bytes at offset 39936 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 40960 ++read 512/512 bytes at offset 40960 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 41984 ++read 512/512 bytes at offset 41984 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 43008 ++read 512/512 bytes at offset 43008 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 44032 ++read 512/512 bytes at offset 44032 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 45056 ++read 512/512 bytes at offset 45056 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 46080 ++read 512/512 bytes at offset 46080 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 47104 ++read 512/512 bytes at offset 47104 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 48128 ++read 512/512 bytes at offset 48128 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 49152 ++read 512/512 bytes at offset 49152 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 50176 ++read 512/512 bytes at offset 50176 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 51200 ++read 512/512 bytes at offset 51200 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 52224 ++read 512/512 bytes at offset 52224 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 53248 ++read 512/512 bytes at offset 53248 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 54272 ++read 512/512 bytes at offset 54272 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 55296 ++read 512/512 bytes at offset 55296 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 56320 ++read 512/512 bytes at offset 56320 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 57344 ++read 512/512 bytes at offset 57344 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 58368 ++read 512/512 bytes at offset 58368 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 59392 ++read 512/512 bytes at offset 59392 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 60416 ++read 512/512 bytes at offset 60416 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 61440 ++read 512/512 bytes at offset 61440 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 62464 ++read 512/512 bytes at offset 62464 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 63488 ++read 512/512 bytes at offset 63488 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 64512 ++read 512/512 bytes at offset 64512 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 1 +-qemu-io> read 512/512 bytes at offset 512 ++=== IO: pattern 1 ++read 512/512 bytes at offset 512 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 1536 ++read 512/512 bytes at offset 1536 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 2560 ++read 512/512 bytes at offset 2560 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3584 ++read 512/512 bytes at offset 3584 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4608 ++read 512/512 bytes at offset 4608 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 5632 ++read 512/512 bytes at offset 5632 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 6656 ++read 512/512 bytes at offset 6656 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 7680 ++read 512/512 bytes at offset 7680 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 8704 ++read 512/512 bytes at offset 8704 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 9728 ++read 512/512 bytes at offset 9728 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 10752 ++read 512/512 bytes at offset 10752 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 11776 ++read 512/512 bytes at offset 11776 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 12800 ++read 512/512 bytes at offset 12800 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 13824 ++read 512/512 bytes at offset 13824 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 14848 ++read 512/512 bytes at offset 14848 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 15872 ++read 512/512 bytes at offset 15872 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 16896 ++read 512/512 bytes at offset 16896 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 17920 ++read 512/512 bytes at offset 17920 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 18944 ++read 512/512 bytes at offset 18944 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 19968 ++read 512/512 bytes at offset 19968 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 20992 ++read 512/512 bytes at offset 20992 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 22016 ++read 512/512 bytes at offset 22016 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 23040 ++read 512/512 bytes at offset 23040 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 24064 ++read 512/512 bytes at offset 24064 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 25088 ++read 512/512 bytes at offset 25088 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 26112 ++read 512/512 bytes at offset 26112 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 27136 ++read 512/512 bytes at offset 27136 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 28160 ++read 512/512 bytes at offset 28160 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 29184 ++read 512/512 bytes at offset 29184 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 30208 ++read 512/512 bytes at offset 30208 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 31232 ++read 512/512 bytes at offset 31232 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 32256 ++read 512/512 bytes at offset 32256 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 33280 ++read 512/512 bytes at offset 33280 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 34304 ++read 512/512 bytes at offset 34304 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 35328 ++read 512/512 bytes at offset 35328 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 36352 ++read 512/512 bytes at offset 36352 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 37376 ++read 512/512 bytes at offset 37376 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 38400 ++read 512/512 bytes at offset 38400 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 39424 ++read 512/512 bytes at offset 39424 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 40448 ++read 512/512 bytes at offset 40448 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 41472 ++read 512/512 bytes at offset 41472 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 42496 ++read 512/512 bytes at offset 42496 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 43520 ++read 512/512 bytes at offset 43520 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 44544 ++read 512/512 bytes at offset 44544 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 45568 ++read 512/512 bytes at offset 45568 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 46592 ++read 512/512 bytes at offset 46592 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 47616 ++read 512/512 bytes at offset 47616 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 48640 ++read 512/512 bytes at offset 48640 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 49664 ++read 512/512 bytes at offset 49664 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 50688 ++read 512/512 bytes at offset 50688 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 51712 ++read 512/512 bytes at offset 51712 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 52736 ++read 512/512 bytes at offset 52736 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 53760 ++read 512/512 bytes at offset 53760 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 54784 ++read 512/512 bytes at offset 54784 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 55808 ++read 512/512 bytes at offset 55808 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 56832 ++read 512/512 bytes at offset 56832 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 57856 ++read 512/512 bytes at offset 57856 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 58880 ++read 512/512 bytes at offset 58880 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 59904 ++read 512/512 bytes at offset 59904 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 60928 ++read 512/512 bytes at offset 60928 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 61952 ++read 512/512 bytes at offset 61952 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 62976 ++read 512/512 bytes at offset 62976 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 64000 ++read 512/512 bytes at offset 64000 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 65024 ++read 512/512 bytes at offset 65024 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 128 +-qemu-io> read 65536/65536 bytes at offset 65536 ++=== IO: pattern 128 ++read 65536/65536 bytes at offset 65536 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> read 65536/65536 bytes at offset 131072 ++=== IO: pattern 0 ++read 65536/65536 bytes at offset 131072 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> read 65536/65536 bytes at offset 327680 ++=== IO: pattern 0 ++read 65536/65536 bytes at offset 327680 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> read 512/512 bytes at offset 4294967296 ++=== IO: pattern 0 ++read 512/512 bytes at offset 4294967296 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294968320 ++read 512/512 bytes at offset 4294968320 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294969344 ++read 512/512 bytes at offset 4294969344 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294970368 ++read 512/512 bytes at offset 4294970368 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294971392 ++read 512/512 bytes at offset 4294971392 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294972416 ++read 512/512 bytes at offset 4294972416 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294973440 ++read 512/512 bytes at offset 4294973440 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294974464 ++read 512/512 bytes at offset 4294974464 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294975488 ++read 512/512 bytes at offset 4294975488 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294976512 ++read 512/512 bytes at offset 4294976512 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294977536 ++read 512/512 bytes at offset 4294977536 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294978560 ++read 512/512 bytes at offset 4294978560 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294979584 ++read 512/512 bytes at offset 4294979584 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294980608 ++read 512/512 bytes at offset 4294980608 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294981632 ++read 512/512 bytes at offset 4294981632 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294982656 ++read 512/512 bytes at offset 4294982656 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294983680 ++read 512/512 bytes at offset 4294983680 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294984704 ++read 512/512 bytes at offset 4294984704 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294985728 ++read 512/512 bytes at offset 4294985728 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294986752 ++read 512/512 bytes at offset 4294986752 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294987776 ++read 512/512 bytes at offset 4294987776 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294988800 ++read 512/512 bytes at offset 4294988800 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294989824 ++read 512/512 bytes at offset 4294989824 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294990848 ++read 512/512 bytes at offset 4294990848 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294991872 ++read 512/512 bytes at offset 4294991872 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294992896 ++read 512/512 bytes at offset 4294992896 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294993920 ++read 512/512 bytes at offset 4294993920 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294994944 ++read 512/512 bytes at offset 4294994944 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294995968 ++read 512/512 bytes at offset 4294995968 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294996992 ++read 512/512 bytes at offset 4294996992 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294998016 ++read 512/512 bytes at offset 4294998016 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294999040 ++read 512/512 bytes at offset 4294999040 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295000064 ++read 512/512 bytes at offset 4295000064 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295001088 ++read 512/512 bytes at offset 4295001088 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295002112 ++read 512/512 bytes at offset 4295002112 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295003136 ++read 512/512 bytes at offset 4295003136 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295004160 ++read 512/512 bytes at offset 4295004160 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295005184 ++read 512/512 bytes at offset 4295005184 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295006208 ++read 512/512 bytes at offset 4295006208 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295007232 ++read 512/512 bytes at offset 4295007232 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295008256 ++read 512/512 bytes at offset 4295008256 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295009280 ++read 512/512 bytes at offset 4295009280 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295010304 ++read 512/512 bytes at offset 4295010304 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295011328 ++read 512/512 bytes at offset 4295011328 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295012352 ++read 512/512 bytes at offset 4295012352 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295013376 ++read 512/512 bytes at offset 4295013376 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295014400 ++read 512/512 bytes at offset 4295014400 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295015424 ++read 512/512 bytes at offset 4295015424 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295016448 ++read 512/512 bytes at offset 4295016448 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295017472 ++read 512/512 bytes at offset 4295017472 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295018496 ++read 512/512 bytes at offset 4295018496 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295019520 ++read 512/512 bytes at offset 4295019520 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295020544 ++read 512/512 bytes at offset 4295020544 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295021568 ++read 512/512 bytes at offset 4295021568 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295022592 ++read 512/512 bytes at offset 4295022592 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295023616 ++read 512/512 bytes at offset 4295023616 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295024640 ++read 512/512 bytes at offset 4295024640 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295025664 ++read 512/512 bytes at offset 4295025664 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295026688 ++read 512/512 bytes at offset 4295026688 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295027712 ++read 512/512 bytes at offset 4295027712 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295028736 ++read 512/512 bytes at offset 4295028736 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295029760 ++read 512/512 bytes at offset 4295029760 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295030784 ++read 512/512 bytes at offset 4295030784 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295031808 ++read 512/512 bytes at offset 4295031808 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 1 +-qemu-io> read 512/512 bytes at offset 4294967808 ++=== IO: pattern 1 ++read 512/512 bytes at offset 4294967808 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294968832 ++read 512/512 bytes at offset 4294968832 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294969856 ++read 512/512 bytes at offset 4294969856 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294970880 ++read 512/512 bytes at offset 4294970880 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294971904 ++read 512/512 bytes at offset 4294971904 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294972928 ++read 512/512 bytes at offset 4294972928 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294973952 ++read 512/512 bytes at offset 4294973952 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294974976 ++read 512/512 bytes at offset 4294974976 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294976000 ++read 512/512 bytes at offset 4294976000 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294977024 ++read 512/512 bytes at offset 4294977024 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294978048 ++read 512/512 bytes at offset 4294978048 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294979072 ++read 512/512 bytes at offset 4294979072 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294980096 ++read 512/512 bytes at offset 4294980096 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294981120 ++read 512/512 bytes at offset 4294981120 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294982144 ++read 512/512 bytes at offset 4294982144 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294983168 ++read 512/512 bytes at offset 4294983168 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294984192 ++read 512/512 bytes at offset 4294984192 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294985216 ++read 512/512 bytes at offset 4294985216 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294986240 ++read 512/512 bytes at offset 4294986240 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294987264 ++read 512/512 bytes at offset 4294987264 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294988288 ++read 512/512 bytes at offset 4294988288 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294989312 ++read 512/512 bytes at offset 4294989312 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294990336 ++read 512/512 bytes at offset 4294990336 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294991360 ++read 512/512 bytes at offset 4294991360 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294992384 ++read 512/512 bytes at offset 4294992384 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294993408 ++read 512/512 bytes at offset 4294993408 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294994432 ++read 512/512 bytes at offset 4294994432 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294995456 ++read 512/512 bytes at offset 4294995456 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294996480 ++read 512/512 bytes at offset 4294996480 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294997504 ++read 512/512 bytes at offset 4294997504 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294998528 ++read 512/512 bytes at offset 4294998528 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4294999552 ++read 512/512 bytes at offset 4294999552 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295000576 ++read 512/512 bytes at offset 4295000576 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295001600 ++read 512/512 bytes at offset 4295001600 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295002624 ++read 512/512 bytes at offset 4295002624 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295003648 ++read 512/512 bytes at offset 4295003648 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295004672 ++read 512/512 bytes at offset 4295004672 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295005696 ++read 512/512 bytes at offset 4295005696 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295006720 ++read 512/512 bytes at offset 4295006720 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295007744 ++read 512/512 bytes at offset 4295007744 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295008768 ++read 512/512 bytes at offset 4295008768 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295009792 ++read 512/512 bytes at offset 4295009792 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295010816 ++read 512/512 bytes at offset 4295010816 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295011840 ++read 512/512 bytes at offset 4295011840 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295012864 ++read 512/512 bytes at offset 4295012864 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295013888 ++read 512/512 bytes at offset 4295013888 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295014912 ++read 512/512 bytes at offset 4295014912 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295015936 ++read 512/512 bytes at offset 4295015936 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295016960 ++read 512/512 bytes at offset 4295016960 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295017984 ++read 512/512 bytes at offset 4295017984 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295019008 ++read 512/512 bytes at offset 4295019008 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295020032 ++read 512/512 bytes at offset 4295020032 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295021056 ++read 512/512 bytes at offset 4295021056 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295022080 ++read 512/512 bytes at offset 4295022080 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295023104 ++read 512/512 bytes at offset 4295023104 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295024128 ++read 512/512 bytes at offset 4295024128 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295025152 ++read 512/512 bytes at offset 4295025152 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295026176 ++read 512/512 bytes at offset 4295026176 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295027200 ++read 512/512 bytes at offset 4295027200 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295028224 ++read 512/512 bytes at offset 4295028224 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295029248 ++read 512/512 bytes at offset 4295029248 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295030272 ++read 512/512 bytes at offset 4295030272 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295031296 ++read 512/512 bytes at offset 4295031296 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295032320 ++read 512/512 bytes at offset 4295032320 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 128 +-qemu-io> read 65536/65536 bytes at offset 4295032832 ++=== IO: pattern 128 ++read 65536/65536 bytes at offset 4295032832 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> read 65536/65536 bytes at offset 4295098368 ++=== IO: pattern 0 ++read 65536/65536 bytes at offset 4295098368 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> read 65536/65536 bytes at offset 4295294976 ++=== IO: pattern 0 ++read 65536/65536 bytes at offset 4295294976 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> No errors were found on the image. ++No errors were found on the image. + *** done +diff --git a/tests/qemu-iotests/022.out b/tests/qemu-iotests/022.out +index aed86d5..5a729e0 100644 +--- a/tests/qemu-iotests/022.out ++++ b/tests/qemu-iotests/022.out +@@ -4,8798 +4,8798 @@ Testing empty image + + At offset 10485760: + === IO: pattern 0 +-qemu-io> wrote 4096/4096 bytes at offset 10485760 ++wrote 4096/4096 bytes at offset 10485760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10489856 ++wrote 4096/4096 bytes at offset 10489856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10493952 ++wrote 4096/4096 bytes at offset 10493952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10498048 ++wrote 4096/4096 bytes at offset 10498048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10502144 ++wrote 4096/4096 bytes at offset 10502144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10506240 ++wrote 4096/4096 bytes at offset 10506240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10510336 ++wrote 4096/4096 bytes at offset 10510336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10514432 ++wrote 4096/4096 bytes at offset 10514432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10518528 ++wrote 4096/4096 bytes at offset 10518528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10522624 ++wrote 4096/4096 bytes at offset 10522624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10526720 ++wrote 4096/4096 bytes at offset 10526720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10530816 ++wrote 4096/4096 bytes at offset 10530816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10534912 ++wrote 4096/4096 bytes at offset 10534912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10539008 ++wrote 4096/4096 bytes at offset 10539008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10543104 ++wrote 4096/4096 bytes at offset 10543104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10547200 ++wrote 4096/4096 bytes at offset 10547200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10551296 ++wrote 4096/4096 bytes at offset 10551296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10555392 ++wrote 4096/4096 bytes at offset 10555392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10559488 ++wrote 4096/4096 bytes at offset 10559488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10563584 ++wrote 4096/4096 bytes at offset 10563584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10567680 ++wrote 4096/4096 bytes at offset 10567680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10571776 ++wrote 4096/4096 bytes at offset 10571776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10575872 ++wrote 4096/4096 bytes at offset 10575872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10579968 ++wrote 4096/4096 bytes at offset 10579968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10584064 ++wrote 4096/4096 bytes at offset 10584064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10588160 ++wrote 4096/4096 bytes at offset 10588160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10592256 ++wrote 4096/4096 bytes at offset 10592256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10596352 ++wrote 4096/4096 bytes at offset 10596352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10600448 ++wrote 4096/4096 bytes at offset 10600448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10604544 ++wrote 4096/4096 bytes at offset 10604544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10608640 ++wrote 4096/4096 bytes at offset 10608640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10612736 ++wrote 4096/4096 bytes at offset 10612736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10616832 ++wrote 4096/4096 bytes at offset 10616832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10620928 ++wrote 4096/4096 bytes at offset 10620928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10625024 ++wrote 4096/4096 bytes at offset 10625024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10629120 ++wrote 4096/4096 bytes at offset 10629120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10633216 ++wrote 4096/4096 bytes at offset 10633216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10637312 ++wrote 4096/4096 bytes at offset 10637312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10641408 ++wrote 4096/4096 bytes at offset 10641408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10645504 ++wrote 4096/4096 bytes at offset 10645504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10649600 ++wrote 4096/4096 bytes at offset 10649600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10653696 ++wrote 4096/4096 bytes at offset 10653696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10657792 ++wrote 4096/4096 bytes at offset 10657792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10661888 ++wrote 4096/4096 bytes at offset 10661888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10665984 ++wrote 4096/4096 bytes at offset 10665984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10670080 ++wrote 4096/4096 bytes at offset 10670080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10674176 ++wrote 4096/4096 bytes at offset 10674176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10678272 ++wrote 4096/4096 bytes at offset 10678272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10682368 ++wrote 4096/4096 bytes at offset 10682368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10686464 ++wrote 4096/4096 bytes at offset 10686464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10690560 ++wrote 4096/4096 bytes at offset 10690560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10694656 ++wrote 4096/4096 bytes at offset 10694656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10698752 ++wrote 4096/4096 bytes at offset 10698752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10702848 ++wrote 4096/4096 bytes at offset 10702848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10706944 ++wrote 4096/4096 bytes at offset 10706944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10711040 ++wrote 4096/4096 bytes at offset 10711040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10715136 ++wrote 4096/4096 bytes at offset 10715136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10719232 ++wrote 4096/4096 bytes at offset 10719232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10723328 ++wrote 4096/4096 bytes at offset 10723328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10727424 ++wrote 4096/4096 bytes at offset 10727424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10731520 ++wrote 4096/4096 bytes at offset 10731520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10735616 ++wrote 4096/4096 bytes at offset 10735616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10739712 ++wrote 4096/4096 bytes at offset 10739712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10743808 ++wrote 4096/4096 bytes at offset 10743808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10747904 ++wrote 4096/4096 bytes at offset 10747904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10752000 ++wrote 4096/4096 bytes at offset 10752000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10756096 ++wrote 4096/4096 bytes at offset 10756096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10760192 ++wrote 4096/4096 bytes at offset 10760192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10764288 ++wrote 4096/4096 bytes at offset 10764288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10768384 ++wrote 4096/4096 bytes at offset 10768384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10772480 ++wrote 4096/4096 bytes at offset 10772480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10776576 ++wrote 4096/4096 bytes at offset 10776576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10780672 ++wrote 4096/4096 bytes at offset 10780672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10784768 ++wrote 4096/4096 bytes at offset 10784768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10788864 ++wrote 4096/4096 bytes at offset 10788864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10792960 ++wrote 4096/4096 bytes at offset 10792960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10797056 ++wrote 4096/4096 bytes at offset 10797056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10801152 ++wrote 4096/4096 bytes at offset 10801152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10805248 ++wrote 4096/4096 bytes at offset 10805248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10809344 ++wrote 4096/4096 bytes at offset 10809344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10813440 ++wrote 4096/4096 bytes at offset 10813440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10817536 ++wrote 4096/4096 bytes at offset 10817536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10821632 ++wrote 4096/4096 bytes at offset 10821632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10825728 ++wrote 4096/4096 bytes at offset 10825728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10829824 ++wrote 4096/4096 bytes at offset 10829824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10833920 ++wrote 4096/4096 bytes at offset 10833920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10838016 ++wrote 4096/4096 bytes at offset 10838016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10842112 ++wrote 4096/4096 bytes at offset 10842112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10846208 ++wrote 4096/4096 bytes at offset 10846208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10850304 ++wrote 4096/4096 bytes at offset 10850304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10854400 ++wrote 4096/4096 bytes at offset 10854400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10858496 ++wrote 4096/4096 bytes at offset 10858496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10862592 ++wrote 4096/4096 bytes at offset 10862592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10866688 ++wrote 4096/4096 bytes at offset 10866688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10870784 ++wrote 4096/4096 bytes at offset 10870784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10874880 ++wrote 4096/4096 bytes at offset 10874880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10878976 ++wrote 4096/4096 bytes at offset 10878976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10883072 ++wrote 4096/4096 bytes at offset 10883072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10887168 ++wrote 4096/4096 bytes at offset 10887168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10891264 ++wrote 4096/4096 bytes at offset 10891264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10895360 ++wrote 4096/4096 bytes at offset 10895360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10899456 ++wrote 4096/4096 bytes at offset 10899456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10903552 ++wrote 4096/4096 bytes at offset 10903552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10907648 ++wrote 4096/4096 bytes at offset 10907648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10911744 ++wrote 4096/4096 bytes at offset 10911744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10915840 ++wrote 4096/4096 bytes at offset 10915840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10919936 ++wrote 4096/4096 bytes at offset 10919936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10924032 ++wrote 4096/4096 bytes at offset 10924032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10928128 ++wrote 4096/4096 bytes at offset 10928128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10932224 ++wrote 4096/4096 bytes at offset 10932224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10936320 ++wrote 4096/4096 bytes at offset 10936320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10940416 ++wrote 4096/4096 bytes at offset 10940416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10944512 ++wrote 4096/4096 bytes at offset 10944512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10948608 ++wrote 4096/4096 bytes at offset 10948608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10952704 ++wrote 4096/4096 bytes at offset 10952704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10956800 ++wrote 4096/4096 bytes at offset 10956800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10960896 ++wrote 4096/4096 bytes at offset 10960896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10964992 ++wrote 4096/4096 bytes at offset 10964992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10969088 ++wrote 4096/4096 bytes at offset 10969088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10973184 ++wrote 4096/4096 bytes at offset 10973184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10977280 ++wrote 4096/4096 bytes at offset 10977280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10981376 ++wrote 4096/4096 bytes at offset 10981376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10985472 ++wrote 4096/4096 bytes at offset 10985472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10989568 ++wrote 4096/4096 bytes at offset 10989568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10993664 ++wrote 4096/4096 bytes at offset 10993664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 10997760 ++wrote 4096/4096 bytes at offset 10997760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11001856 ++wrote 4096/4096 bytes at offset 11001856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11005952 ++wrote 4096/4096 bytes at offset 11005952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11010048 ++wrote 4096/4096 bytes at offset 11010048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11014144 ++wrote 4096/4096 bytes at offset 11014144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11018240 ++wrote 4096/4096 bytes at offset 11018240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11022336 ++wrote 4096/4096 bytes at offset 11022336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11026432 ++wrote 4096/4096 bytes at offset 11026432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11030528 ++wrote 4096/4096 bytes at offset 11030528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11034624 ++wrote 4096/4096 bytes at offset 11034624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11038720 ++wrote 4096/4096 bytes at offset 11038720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11042816 ++wrote 4096/4096 bytes at offset 11042816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11046912 ++wrote 4096/4096 bytes at offset 11046912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11051008 ++wrote 4096/4096 bytes at offset 11051008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11055104 ++wrote 4096/4096 bytes at offset 11055104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11059200 ++wrote 4096/4096 bytes at offset 11059200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11063296 ++wrote 4096/4096 bytes at offset 11063296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11067392 ++wrote 4096/4096 bytes at offset 11067392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11071488 ++wrote 4096/4096 bytes at offset 11071488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11075584 ++wrote 4096/4096 bytes at offset 11075584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11079680 ++wrote 4096/4096 bytes at offset 11079680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11083776 ++wrote 4096/4096 bytes at offset 11083776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11087872 ++wrote 4096/4096 bytes at offset 11087872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11091968 ++wrote 4096/4096 bytes at offset 11091968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11096064 ++wrote 4096/4096 bytes at offset 11096064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11100160 ++wrote 4096/4096 bytes at offset 11100160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11104256 ++wrote 4096/4096 bytes at offset 11104256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11108352 ++wrote 4096/4096 bytes at offset 11108352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11112448 ++wrote 4096/4096 bytes at offset 11112448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11116544 ++wrote 4096/4096 bytes at offset 11116544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11120640 ++wrote 4096/4096 bytes at offset 11120640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11124736 ++wrote 4096/4096 bytes at offset 11124736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11128832 ++wrote 4096/4096 bytes at offset 11128832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11132928 ++wrote 4096/4096 bytes at offset 11132928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11137024 ++wrote 4096/4096 bytes at offset 11137024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11141120 ++wrote 4096/4096 bytes at offset 11141120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11145216 ++wrote 4096/4096 bytes at offset 11145216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11149312 ++wrote 4096/4096 bytes at offset 11149312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11153408 ++wrote 4096/4096 bytes at offset 11153408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11157504 ++wrote 4096/4096 bytes at offset 11157504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11161600 ++wrote 4096/4096 bytes at offset 11161600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11165696 ++wrote 4096/4096 bytes at offset 11165696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11169792 ++wrote 4096/4096 bytes at offset 11169792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11173888 ++wrote 4096/4096 bytes at offset 11173888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11177984 ++wrote 4096/4096 bytes at offset 11177984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11182080 ++wrote 4096/4096 bytes at offset 11182080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11186176 ++wrote 4096/4096 bytes at offset 11186176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11190272 ++wrote 4096/4096 bytes at offset 11190272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11194368 ++wrote 4096/4096 bytes at offset 11194368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11198464 ++wrote 4096/4096 bytes at offset 11198464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11202560 ++wrote 4096/4096 bytes at offset 11202560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11206656 ++wrote 4096/4096 bytes at offset 11206656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11210752 ++wrote 4096/4096 bytes at offset 11210752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11214848 ++wrote 4096/4096 bytes at offset 11214848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11218944 ++wrote 4096/4096 bytes at offset 11218944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11223040 ++wrote 4096/4096 bytes at offset 11223040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11227136 ++wrote 4096/4096 bytes at offset 11227136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11231232 ++wrote 4096/4096 bytes at offset 11231232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11235328 ++wrote 4096/4096 bytes at offset 11235328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11239424 ++wrote 4096/4096 bytes at offset 11239424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11243520 ++wrote 4096/4096 bytes at offset 11243520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11247616 ++wrote 4096/4096 bytes at offset 11247616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11251712 ++wrote 4096/4096 bytes at offset 11251712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11255808 ++wrote 4096/4096 bytes at offset 11255808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11259904 ++wrote 4096/4096 bytes at offset 11259904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11264000 ++wrote 4096/4096 bytes at offset 11264000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11268096 ++wrote 4096/4096 bytes at offset 11268096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11272192 ++wrote 4096/4096 bytes at offset 11272192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11276288 ++wrote 4096/4096 bytes at offset 11276288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11280384 ++wrote 4096/4096 bytes at offset 11280384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11284480 ++wrote 4096/4096 bytes at offset 11284480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11288576 ++wrote 4096/4096 bytes at offset 11288576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11292672 ++wrote 4096/4096 bytes at offset 11292672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11296768 ++wrote 4096/4096 bytes at offset 11296768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11300864 ++wrote 4096/4096 bytes at offset 11300864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11304960 ++wrote 4096/4096 bytes at offset 11304960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11309056 ++wrote 4096/4096 bytes at offset 11309056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11313152 ++wrote 4096/4096 bytes at offset 11313152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11317248 ++wrote 4096/4096 bytes at offset 11317248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11321344 ++wrote 4096/4096 bytes at offset 11321344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11325440 ++wrote 4096/4096 bytes at offset 11325440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11329536 ++wrote 4096/4096 bytes at offset 11329536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11333632 ++wrote 4096/4096 bytes at offset 11333632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11337728 ++wrote 4096/4096 bytes at offset 11337728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11341824 ++wrote 4096/4096 bytes at offset 11341824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11345920 ++wrote 4096/4096 bytes at offset 11345920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11350016 ++wrote 4096/4096 bytes at offset 11350016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11354112 ++wrote 4096/4096 bytes at offset 11354112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11358208 ++wrote 4096/4096 bytes at offset 11358208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11362304 ++wrote 4096/4096 bytes at offset 11362304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11366400 ++wrote 4096/4096 bytes at offset 11366400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11370496 ++wrote 4096/4096 bytes at offset 11370496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11374592 ++wrote 4096/4096 bytes at offset 11374592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11378688 ++wrote 4096/4096 bytes at offset 11378688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11382784 ++wrote 4096/4096 bytes at offset 11382784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11386880 ++wrote 4096/4096 bytes at offset 11386880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11390976 ++wrote 4096/4096 bytes at offset 11390976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11395072 ++wrote 4096/4096 bytes at offset 11395072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11399168 ++wrote 4096/4096 bytes at offset 11399168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11403264 ++wrote 4096/4096 bytes at offset 11403264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11407360 ++wrote 4096/4096 bytes at offset 11407360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11411456 ++wrote 4096/4096 bytes at offset 11411456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11415552 ++wrote 4096/4096 bytes at offset 11415552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11419648 ++wrote 4096/4096 bytes at offset 11419648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11423744 ++wrote 4096/4096 bytes at offset 11423744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11427840 ++wrote 4096/4096 bytes at offset 11427840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11431936 ++wrote 4096/4096 bytes at offset 11431936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11436032 ++wrote 4096/4096 bytes at offset 11436032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11440128 ++wrote 4096/4096 bytes at offset 11440128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11444224 ++wrote 4096/4096 bytes at offset 11444224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11448320 ++wrote 4096/4096 bytes at offset 11448320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11452416 ++wrote 4096/4096 bytes at offset 11452416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11456512 ++wrote 4096/4096 bytes at offset 11456512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11460608 ++wrote 4096/4096 bytes at offset 11460608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11464704 ++wrote 4096/4096 bytes at offset 11464704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11468800 ++wrote 4096/4096 bytes at offset 11468800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11472896 ++wrote 4096/4096 bytes at offset 11472896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11476992 ++wrote 4096/4096 bytes at offset 11476992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11481088 ++wrote 4096/4096 bytes at offset 11481088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11485184 ++wrote 4096/4096 bytes at offset 11485184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11489280 ++wrote 4096/4096 bytes at offset 11489280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11493376 ++wrote 4096/4096 bytes at offset 11493376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11497472 ++wrote 4096/4096 bytes at offset 11497472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11501568 ++wrote 4096/4096 bytes at offset 11501568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11505664 ++wrote 4096/4096 bytes at offset 11505664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11509760 ++wrote 4096/4096 bytes at offset 11509760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11513856 ++wrote 4096/4096 bytes at offset 11513856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11517952 ++wrote 4096/4096 bytes at offset 11517952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11522048 ++wrote 4096/4096 bytes at offset 11522048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11526144 ++wrote 4096/4096 bytes at offset 11526144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 11530240 ++wrote 4096/4096 bytes at offset 11530240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 4 +-qemu-io> wrote 2048/2048 bytes at offset 11536384 ++=== IO: pattern 4 ++wrote 2048/2048 bytes at offset 11536384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 11540480 ++wrote 2048/2048 bytes at offset 11540480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 11544576 ++wrote 2048/2048 bytes at offset 11544576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 11548672 ++wrote 2048/2048 bytes at offset 11548672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 11552768 ++wrote 2048/2048 bytes at offset 11552768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 11556864 ++wrote 2048/2048 bytes at offset 11556864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 11560960 ++wrote 2048/2048 bytes at offset 11560960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 11565056 ++wrote 2048/2048 bytes at offset 11565056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 11569152 ++wrote 2048/2048 bytes at offset 11569152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 11573248 ++wrote 2048/2048 bytes at offset 11573248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 11577344 ++wrote 2048/2048 bytes at offset 11577344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 11581440 ++wrote 2048/2048 bytes at offset 11581440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 11585536 ++wrote 2048/2048 bytes at offset 11585536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 11589632 ++wrote 2048/2048 bytes at offset 11589632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 11593728 ++wrote 2048/2048 bytes at offset 11593728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 11597824 ++wrote 2048/2048 bytes at offset 11597824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 11601920 ++wrote 2048/2048 bytes at offset 11601920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 11606016 ++wrote 2048/2048 bytes at offset 11606016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 11610112 ++wrote 2048/2048 bytes at offset 11610112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 11614208 ++wrote 2048/2048 bytes at offset 11614208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 11618304 ++wrote 2048/2048 bytes at offset 11618304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 11622400 ++wrote 2048/2048 bytes at offset 11622400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 11626496 ++wrote 2048/2048 bytes at offset 11626496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 11630592 ++wrote 2048/2048 bytes at offset 11630592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 11634688 ++wrote 2048/2048 bytes at offset 11634688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 11638784 ++wrote 2048/2048 bytes at offset 11638784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 11642880 ++wrote 2048/2048 bytes at offset 11642880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 11646976 ++wrote 2048/2048 bytes at offset 11646976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 11651072 ++wrote 2048/2048 bytes at offset 11651072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 11655168 ++wrote 2048/2048 bytes at offset 11655168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 11659264 ++wrote 2048/2048 bytes at offset 11659264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 11663360 ++wrote 2048/2048 bytes at offset 11663360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 11667456 ++wrote 2048/2048 bytes at offset 11667456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 11671552 ++wrote 2048/2048 bytes at offset 11671552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 11675648 ++wrote 2048/2048 bytes at offset 11675648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 11679744 ++wrote 2048/2048 bytes at offset 11679744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 11683840 ++wrote 2048/2048 bytes at offset 11683840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 11687936 ++wrote 2048/2048 bytes at offset 11687936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 11692032 ++wrote 2048/2048 bytes at offset 11692032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 11696128 ++wrote 2048/2048 bytes at offset 11696128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 11700224 ++wrote 2048/2048 bytes at offset 11700224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 11704320 ++wrote 2048/2048 bytes at offset 11704320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 11708416 ++wrote 2048/2048 bytes at offset 11708416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 11712512 ++wrote 2048/2048 bytes at offset 11712512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 11716608 ++wrote 2048/2048 bytes at offset 11716608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 11720704 ++wrote 2048/2048 bytes at offset 11720704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 11724800 ++wrote 2048/2048 bytes at offset 11724800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 11728896 ++wrote 2048/2048 bytes at offset 11728896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 11732992 ++wrote 2048/2048 bytes at offset 11732992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 11737088 ++wrote 2048/2048 bytes at offset 11737088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 11741184 ++wrote 2048/2048 bytes at offset 11741184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 11745280 ++wrote 2048/2048 bytes at offset 11745280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 11749376 ++wrote 2048/2048 bytes at offset 11749376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 11753472 ++wrote 2048/2048 bytes at offset 11753472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 11757568 ++wrote 2048/2048 bytes at offset 11757568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 11761664 ++wrote 2048/2048 bytes at offset 11761664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 11765760 ++wrote 2048/2048 bytes at offset 11765760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 11769856 ++wrote 2048/2048 bytes at offset 11769856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 11773952 ++wrote 2048/2048 bytes at offset 11773952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 11778048 ++wrote 2048/2048 bytes at offset 11778048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 11782144 ++wrote 2048/2048 bytes at offset 11782144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 11786240 ++wrote 2048/2048 bytes at offset 11786240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 11790336 ++wrote 2048/2048 bytes at offset 11790336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 11794432 ++wrote 2048/2048 bytes at offset 11794432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 11798528 ++wrote 2048/2048 bytes at offset 11798528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 11802624 ++wrote 2048/2048 bytes at offset 11802624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 11806720 ++wrote 2048/2048 bytes at offset 11806720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 11810816 ++wrote 2048/2048 bytes at offset 11810816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 11814912 ++wrote 2048/2048 bytes at offset 11814912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 11819008 ++wrote 2048/2048 bytes at offset 11819008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 11823104 ++wrote 2048/2048 bytes at offset 11823104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 11827200 ++wrote 2048/2048 bytes at offset 11827200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 11831296 ++wrote 2048/2048 bytes at offset 11831296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 11835392 ++wrote 2048/2048 bytes at offset 11835392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 11839488 ++wrote 2048/2048 bytes at offset 11839488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 11843584 ++wrote 2048/2048 bytes at offset 11843584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 11847680 ++wrote 2048/2048 bytes at offset 11847680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 11851776 ++wrote 2048/2048 bytes at offset 11851776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 11855872 ++wrote 2048/2048 bytes at offset 11855872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 11859968 ++wrote 2048/2048 bytes at offset 11859968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 11864064 ++wrote 2048/2048 bytes at offset 11864064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 11868160 ++wrote 2048/2048 bytes at offset 11868160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 11872256 ++wrote 2048/2048 bytes at offset 11872256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 11876352 ++wrote 2048/2048 bytes at offset 11876352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 11880448 ++wrote 2048/2048 bytes at offset 11880448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 11884544 ++wrote 2048/2048 bytes at offset 11884544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 11888640 ++wrote 2048/2048 bytes at offset 11888640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 11892736 ++wrote 2048/2048 bytes at offset 11892736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 11896832 ++wrote 2048/2048 bytes at offset 11896832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 11900928 ++wrote 2048/2048 bytes at offset 11900928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 11905024 ++wrote 2048/2048 bytes at offset 11905024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 11909120 ++wrote 2048/2048 bytes at offset 11909120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 11913216 ++wrote 2048/2048 bytes at offset 11913216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 11917312 ++wrote 2048/2048 bytes at offset 11917312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 11921408 ++wrote 2048/2048 bytes at offset 11921408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 11925504 ++wrote 2048/2048 bytes at offset 11925504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 11929600 ++wrote 2048/2048 bytes at offset 11929600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 11933696 ++wrote 2048/2048 bytes at offset 11933696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 11937792 ++wrote 2048/2048 bytes at offset 11937792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 11941888 ++wrote 2048/2048 bytes at offset 11941888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 11945984 ++wrote 2048/2048 bytes at offset 11945984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 11950080 ++wrote 2048/2048 bytes at offset 11950080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 11954176 ++wrote 2048/2048 bytes at offset 11954176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 11958272 ++wrote 2048/2048 bytes at offset 11958272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 11962368 ++wrote 2048/2048 bytes at offset 11962368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 11966464 ++wrote 2048/2048 bytes at offset 11966464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 11970560 ++wrote 2048/2048 bytes at offset 11970560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 11974656 ++wrote 2048/2048 bytes at offset 11974656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 11978752 ++wrote 2048/2048 bytes at offset 11978752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 11982848 ++wrote 2048/2048 bytes at offset 11982848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 11986944 ++wrote 2048/2048 bytes at offset 11986944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 11991040 ++wrote 2048/2048 bytes at offset 11991040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 11995136 ++wrote 2048/2048 bytes at offset 11995136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 11999232 ++wrote 2048/2048 bytes at offset 11999232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12003328 ++wrote 2048/2048 bytes at offset 12003328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12007424 ++wrote 2048/2048 bytes at offset 12007424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12011520 ++wrote 2048/2048 bytes at offset 12011520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12015616 ++wrote 2048/2048 bytes at offset 12015616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12019712 ++wrote 2048/2048 bytes at offset 12019712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12023808 ++wrote 2048/2048 bytes at offset 12023808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12027904 ++wrote 2048/2048 bytes at offset 12027904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12032000 ++wrote 2048/2048 bytes at offset 12032000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12036096 ++wrote 2048/2048 bytes at offset 12036096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12040192 ++wrote 2048/2048 bytes at offset 12040192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12044288 ++wrote 2048/2048 bytes at offset 12044288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12048384 ++wrote 2048/2048 bytes at offset 12048384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12052480 ++wrote 2048/2048 bytes at offset 12052480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12056576 ++wrote 2048/2048 bytes at offset 12056576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12060672 ++wrote 2048/2048 bytes at offset 12060672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12064768 ++wrote 2048/2048 bytes at offset 12064768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12068864 ++wrote 2048/2048 bytes at offset 12068864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12072960 ++wrote 2048/2048 bytes at offset 12072960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12077056 ++wrote 2048/2048 bytes at offset 12077056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12081152 ++wrote 2048/2048 bytes at offset 12081152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12085248 ++wrote 2048/2048 bytes at offset 12085248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12089344 ++wrote 2048/2048 bytes at offset 12089344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12093440 ++wrote 2048/2048 bytes at offset 12093440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12097536 ++wrote 2048/2048 bytes at offset 12097536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12101632 ++wrote 2048/2048 bytes at offset 12101632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12105728 ++wrote 2048/2048 bytes at offset 12105728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12109824 ++wrote 2048/2048 bytes at offset 12109824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12113920 ++wrote 2048/2048 bytes at offset 12113920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12118016 ++wrote 2048/2048 bytes at offset 12118016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12122112 ++wrote 2048/2048 bytes at offset 12122112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12126208 ++wrote 2048/2048 bytes at offset 12126208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12130304 ++wrote 2048/2048 bytes at offset 12130304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12134400 ++wrote 2048/2048 bytes at offset 12134400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12138496 ++wrote 2048/2048 bytes at offset 12138496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12142592 ++wrote 2048/2048 bytes at offset 12142592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12146688 ++wrote 2048/2048 bytes at offset 12146688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12150784 ++wrote 2048/2048 bytes at offset 12150784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12154880 ++wrote 2048/2048 bytes at offset 12154880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12158976 ++wrote 2048/2048 bytes at offset 12158976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12163072 ++wrote 2048/2048 bytes at offset 12163072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12167168 ++wrote 2048/2048 bytes at offset 12167168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12171264 ++wrote 2048/2048 bytes at offset 12171264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12175360 ++wrote 2048/2048 bytes at offset 12175360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12179456 ++wrote 2048/2048 bytes at offset 12179456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12183552 ++wrote 2048/2048 bytes at offset 12183552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12187648 ++wrote 2048/2048 bytes at offset 12187648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12191744 ++wrote 2048/2048 bytes at offset 12191744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12195840 ++wrote 2048/2048 bytes at offset 12195840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12199936 ++wrote 2048/2048 bytes at offset 12199936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12204032 ++wrote 2048/2048 bytes at offset 12204032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12208128 ++wrote 2048/2048 bytes at offset 12208128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12212224 ++wrote 2048/2048 bytes at offset 12212224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12216320 ++wrote 2048/2048 bytes at offset 12216320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12220416 ++wrote 2048/2048 bytes at offset 12220416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12224512 ++wrote 2048/2048 bytes at offset 12224512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12228608 ++wrote 2048/2048 bytes at offset 12228608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12232704 ++wrote 2048/2048 bytes at offset 12232704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12236800 ++wrote 2048/2048 bytes at offset 12236800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12240896 ++wrote 2048/2048 bytes at offset 12240896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12244992 ++wrote 2048/2048 bytes at offset 12244992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12249088 ++wrote 2048/2048 bytes at offset 12249088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12253184 ++wrote 2048/2048 bytes at offset 12253184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12257280 ++wrote 2048/2048 bytes at offset 12257280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12261376 ++wrote 2048/2048 bytes at offset 12261376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12265472 ++wrote 2048/2048 bytes at offset 12265472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12269568 ++wrote 2048/2048 bytes at offset 12269568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12273664 ++wrote 2048/2048 bytes at offset 12273664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12277760 ++wrote 2048/2048 bytes at offset 12277760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12281856 ++wrote 2048/2048 bytes at offset 12281856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12285952 ++wrote 2048/2048 bytes at offset 12285952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12290048 ++wrote 2048/2048 bytes at offset 12290048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12294144 ++wrote 2048/2048 bytes at offset 12294144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12298240 ++wrote 2048/2048 bytes at offset 12298240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12302336 ++wrote 2048/2048 bytes at offset 12302336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12306432 ++wrote 2048/2048 bytes at offset 12306432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12310528 ++wrote 2048/2048 bytes at offset 12310528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12314624 ++wrote 2048/2048 bytes at offset 12314624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12318720 ++wrote 2048/2048 bytes at offset 12318720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12322816 ++wrote 2048/2048 bytes at offset 12322816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12326912 ++wrote 2048/2048 bytes at offset 12326912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12331008 ++wrote 2048/2048 bytes at offset 12331008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12335104 ++wrote 2048/2048 bytes at offset 12335104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12339200 ++wrote 2048/2048 bytes at offset 12339200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12343296 ++wrote 2048/2048 bytes at offset 12343296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12347392 ++wrote 2048/2048 bytes at offset 12347392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12351488 ++wrote 2048/2048 bytes at offset 12351488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12355584 ++wrote 2048/2048 bytes at offset 12355584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12359680 ++wrote 2048/2048 bytes at offset 12359680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12363776 ++wrote 2048/2048 bytes at offset 12363776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12367872 ++wrote 2048/2048 bytes at offset 12367872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12371968 ++wrote 2048/2048 bytes at offset 12371968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12376064 ++wrote 2048/2048 bytes at offset 12376064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12380160 ++wrote 2048/2048 bytes at offset 12380160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12384256 ++wrote 2048/2048 bytes at offset 12384256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12388352 ++wrote 2048/2048 bytes at offset 12388352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12392448 ++wrote 2048/2048 bytes at offset 12392448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12396544 ++wrote 2048/2048 bytes at offset 12396544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12400640 ++wrote 2048/2048 bytes at offset 12400640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12404736 ++wrote 2048/2048 bytes at offset 12404736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12408832 ++wrote 2048/2048 bytes at offset 12408832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12412928 ++wrote 2048/2048 bytes at offset 12412928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12417024 ++wrote 2048/2048 bytes at offset 12417024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12421120 ++wrote 2048/2048 bytes at offset 12421120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12425216 ++wrote 2048/2048 bytes at offset 12425216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12429312 ++wrote 2048/2048 bytes at offset 12429312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12433408 ++wrote 2048/2048 bytes at offset 12433408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12437504 ++wrote 2048/2048 bytes at offset 12437504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12441600 ++wrote 2048/2048 bytes at offset 12441600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12445696 ++wrote 2048/2048 bytes at offset 12445696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12449792 ++wrote 2048/2048 bytes at offset 12449792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12453888 ++wrote 2048/2048 bytes at offset 12453888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12457984 ++wrote 2048/2048 bytes at offset 12457984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12462080 ++wrote 2048/2048 bytes at offset 12462080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12466176 ++wrote 2048/2048 bytes at offset 12466176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12470272 ++wrote 2048/2048 bytes at offset 12470272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12474368 ++wrote 2048/2048 bytes at offset 12474368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12478464 ++wrote 2048/2048 bytes at offset 12478464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12482560 ++wrote 2048/2048 bytes at offset 12482560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12486656 ++wrote 2048/2048 bytes at offset 12486656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12490752 ++wrote 2048/2048 bytes at offset 12490752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12494848 ++wrote 2048/2048 bytes at offset 12494848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12498944 ++wrote 2048/2048 bytes at offset 12498944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12503040 ++wrote 2048/2048 bytes at offset 12503040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12507136 ++wrote 2048/2048 bytes at offset 12507136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12511232 ++wrote 2048/2048 bytes at offset 12511232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12515328 ++wrote 2048/2048 bytes at offset 12515328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12519424 ++wrote 2048/2048 bytes at offset 12519424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12523520 ++wrote 2048/2048 bytes at offset 12523520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12527616 ++wrote 2048/2048 bytes at offset 12527616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12531712 ++wrote 2048/2048 bytes at offset 12531712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12535808 ++wrote 2048/2048 bytes at offset 12535808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12539904 ++wrote 2048/2048 bytes at offset 12539904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12544000 ++wrote 2048/2048 bytes at offset 12544000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12548096 ++wrote 2048/2048 bytes at offset 12548096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12552192 ++wrote 2048/2048 bytes at offset 12552192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12556288 ++wrote 2048/2048 bytes at offset 12556288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12560384 ++wrote 2048/2048 bytes at offset 12560384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12564480 ++wrote 2048/2048 bytes at offset 12564480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12568576 ++wrote 2048/2048 bytes at offset 12568576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12572672 ++wrote 2048/2048 bytes at offset 12572672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12576768 ++wrote 2048/2048 bytes at offset 12576768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12580864 ++wrote 2048/2048 bytes at offset 12580864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> wrote 2048/2048 bytes at offset 12582912 ++=== IO: pattern 0 ++wrote 2048/2048 bytes at offset 12582912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12587008 ++wrote 2048/2048 bytes at offset 12587008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12591104 ++wrote 2048/2048 bytes at offset 12591104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12595200 ++wrote 2048/2048 bytes at offset 12595200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12599296 ++wrote 2048/2048 bytes at offset 12599296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12603392 ++wrote 2048/2048 bytes at offset 12603392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12607488 ++wrote 2048/2048 bytes at offset 12607488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12611584 ++wrote 2048/2048 bytes at offset 12611584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12615680 ++wrote 2048/2048 bytes at offset 12615680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12619776 ++wrote 2048/2048 bytes at offset 12619776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12623872 ++wrote 2048/2048 bytes at offset 12623872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12627968 ++wrote 2048/2048 bytes at offset 12627968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12632064 ++wrote 2048/2048 bytes at offset 12632064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12636160 ++wrote 2048/2048 bytes at offset 12636160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12640256 ++wrote 2048/2048 bytes at offset 12640256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12644352 ++wrote 2048/2048 bytes at offset 12644352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12648448 ++wrote 2048/2048 bytes at offset 12648448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12652544 ++wrote 2048/2048 bytes at offset 12652544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12656640 ++wrote 2048/2048 bytes at offset 12656640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12660736 ++wrote 2048/2048 bytes at offset 12660736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12664832 ++wrote 2048/2048 bytes at offset 12664832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12668928 ++wrote 2048/2048 bytes at offset 12668928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12673024 ++wrote 2048/2048 bytes at offset 12673024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12677120 ++wrote 2048/2048 bytes at offset 12677120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12681216 ++wrote 2048/2048 bytes at offset 12681216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12685312 ++wrote 2048/2048 bytes at offset 12685312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12689408 ++wrote 2048/2048 bytes at offset 12689408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12693504 ++wrote 2048/2048 bytes at offset 12693504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12697600 ++wrote 2048/2048 bytes at offset 12697600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12701696 ++wrote 2048/2048 bytes at offset 12701696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12705792 ++wrote 2048/2048 bytes at offset 12705792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12709888 ++wrote 2048/2048 bytes at offset 12709888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12713984 ++wrote 2048/2048 bytes at offset 12713984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12718080 ++wrote 2048/2048 bytes at offset 12718080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12722176 ++wrote 2048/2048 bytes at offset 12722176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12726272 ++wrote 2048/2048 bytes at offset 12726272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12730368 ++wrote 2048/2048 bytes at offset 12730368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12734464 ++wrote 2048/2048 bytes at offset 12734464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12738560 ++wrote 2048/2048 bytes at offset 12738560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12742656 ++wrote 2048/2048 bytes at offset 12742656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12746752 ++wrote 2048/2048 bytes at offset 12746752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12750848 ++wrote 2048/2048 bytes at offset 12750848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12754944 ++wrote 2048/2048 bytes at offset 12754944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12759040 ++wrote 2048/2048 bytes at offset 12759040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12763136 ++wrote 2048/2048 bytes at offset 12763136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12767232 ++wrote 2048/2048 bytes at offset 12767232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12771328 ++wrote 2048/2048 bytes at offset 12771328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12775424 ++wrote 2048/2048 bytes at offset 12775424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12779520 ++wrote 2048/2048 bytes at offset 12779520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12783616 ++wrote 2048/2048 bytes at offset 12783616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12787712 ++wrote 2048/2048 bytes at offset 12787712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12791808 ++wrote 2048/2048 bytes at offset 12791808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12795904 ++wrote 2048/2048 bytes at offset 12795904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12800000 ++wrote 2048/2048 bytes at offset 12800000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12804096 ++wrote 2048/2048 bytes at offset 12804096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12808192 ++wrote 2048/2048 bytes at offset 12808192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12812288 ++wrote 2048/2048 bytes at offset 12812288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12816384 ++wrote 2048/2048 bytes at offset 12816384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12820480 ++wrote 2048/2048 bytes at offset 12820480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12824576 ++wrote 2048/2048 bytes at offset 12824576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12828672 ++wrote 2048/2048 bytes at offset 12828672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12832768 ++wrote 2048/2048 bytes at offset 12832768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12836864 ++wrote 2048/2048 bytes at offset 12836864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12840960 ++wrote 2048/2048 bytes at offset 12840960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12845056 ++wrote 2048/2048 bytes at offset 12845056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12849152 ++wrote 2048/2048 bytes at offset 12849152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12853248 ++wrote 2048/2048 bytes at offset 12853248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12857344 ++wrote 2048/2048 bytes at offset 12857344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12861440 ++wrote 2048/2048 bytes at offset 12861440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12865536 ++wrote 2048/2048 bytes at offset 12865536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12869632 ++wrote 2048/2048 bytes at offset 12869632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12873728 ++wrote 2048/2048 bytes at offset 12873728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12877824 ++wrote 2048/2048 bytes at offset 12877824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12881920 ++wrote 2048/2048 bytes at offset 12881920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12886016 ++wrote 2048/2048 bytes at offset 12886016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12890112 ++wrote 2048/2048 bytes at offset 12890112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12894208 ++wrote 2048/2048 bytes at offset 12894208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12898304 ++wrote 2048/2048 bytes at offset 12898304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12902400 ++wrote 2048/2048 bytes at offset 12902400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12906496 ++wrote 2048/2048 bytes at offset 12906496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12910592 ++wrote 2048/2048 bytes at offset 12910592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12914688 ++wrote 2048/2048 bytes at offset 12914688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12918784 ++wrote 2048/2048 bytes at offset 12918784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12922880 ++wrote 2048/2048 bytes at offset 12922880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12926976 ++wrote 2048/2048 bytes at offset 12926976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12931072 ++wrote 2048/2048 bytes at offset 12931072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12935168 ++wrote 2048/2048 bytes at offset 12935168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12939264 ++wrote 2048/2048 bytes at offset 12939264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12943360 ++wrote 2048/2048 bytes at offset 12943360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12947456 ++wrote 2048/2048 bytes at offset 12947456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12951552 ++wrote 2048/2048 bytes at offset 12951552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12955648 ++wrote 2048/2048 bytes at offset 12955648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12959744 ++wrote 2048/2048 bytes at offset 12959744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12963840 ++wrote 2048/2048 bytes at offset 12963840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12967936 ++wrote 2048/2048 bytes at offset 12967936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12972032 ++wrote 2048/2048 bytes at offset 12972032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12976128 ++wrote 2048/2048 bytes at offset 12976128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12980224 ++wrote 2048/2048 bytes at offset 12980224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12984320 ++wrote 2048/2048 bytes at offset 12984320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12988416 ++wrote 2048/2048 bytes at offset 12988416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12992512 ++wrote 2048/2048 bytes at offset 12992512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 12996608 ++wrote 2048/2048 bytes at offset 12996608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13000704 ++wrote 2048/2048 bytes at offset 13000704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13004800 ++wrote 2048/2048 bytes at offset 13004800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13008896 ++wrote 2048/2048 bytes at offset 13008896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13012992 ++wrote 2048/2048 bytes at offset 13012992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13017088 ++wrote 2048/2048 bytes at offset 13017088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13021184 ++wrote 2048/2048 bytes at offset 13021184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13025280 ++wrote 2048/2048 bytes at offset 13025280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13029376 ++wrote 2048/2048 bytes at offset 13029376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13033472 ++wrote 2048/2048 bytes at offset 13033472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13037568 ++wrote 2048/2048 bytes at offset 13037568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13041664 ++wrote 2048/2048 bytes at offset 13041664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13045760 ++wrote 2048/2048 bytes at offset 13045760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13049856 ++wrote 2048/2048 bytes at offset 13049856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13053952 ++wrote 2048/2048 bytes at offset 13053952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13058048 ++wrote 2048/2048 bytes at offset 13058048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13062144 ++wrote 2048/2048 bytes at offset 13062144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13066240 ++wrote 2048/2048 bytes at offset 13066240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13070336 ++wrote 2048/2048 bytes at offset 13070336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13074432 ++wrote 2048/2048 bytes at offset 13074432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13078528 ++wrote 2048/2048 bytes at offset 13078528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13082624 ++wrote 2048/2048 bytes at offset 13082624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13086720 ++wrote 2048/2048 bytes at offset 13086720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13090816 ++wrote 2048/2048 bytes at offset 13090816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13094912 ++wrote 2048/2048 bytes at offset 13094912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13099008 ++wrote 2048/2048 bytes at offset 13099008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13103104 ++wrote 2048/2048 bytes at offset 13103104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13107200 ++wrote 2048/2048 bytes at offset 13107200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13111296 ++wrote 2048/2048 bytes at offset 13111296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13115392 ++wrote 2048/2048 bytes at offset 13115392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13119488 ++wrote 2048/2048 bytes at offset 13119488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13123584 ++wrote 2048/2048 bytes at offset 13123584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13127680 ++wrote 2048/2048 bytes at offset 13127680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13131776 ++wrote 2048/2048 bytes at offset 13131776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13135872 ++wrote 2048/2048 bytes at offset 13135872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13139968 ++wrote 2048/2048 bytes at offset 13139968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13144064 ++wrote 2048/2048 bytes at offset 13144064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13148160 ++wrote 2048/2048 bytes at offset 13148160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13152256 ++wrote 2048/2048 bytes at offset 13152256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13156352 ++wrote 2048/2048 bytes at offset 13156352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13160448 ++wrote 2048/2048 bytes at offset 13160448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13164544 ++wrote 2048/2048 bytes at offset 13164544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13168640 ++wrote 2048/2048 bytes at offset 13168640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13172736 ++wrote 2048/2048 bytes at offset 13172736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13176832 ++wrote 2048/2048 bytes at offset 13176832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13180928 ++wrote 2048/2048 bytes at offset 13180928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13185024 ++wrote 2048/2048 bytes at offset 13185024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13189120 ++wrote 2048/2048 bytes at offset 13189120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13193216 ++wrote 2048/2048 bytes at offset 13193216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13197312 ++wrote 2048/2048 bytes at offset 13197312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13201408 ++wrote 2048/2048 bytes at offset 13201408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13205504 ++wrote 2048/2048 bytes at offset 13205504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13209600 ++wrote 2048/2048 bytes at offset 13209600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13213696 ++wrote 2048/2048 bytes at offset 13213696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13217792 ++wrote 2048/2048 bytes at offset 13217792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13221888 ++wrote 2048/2048 bytes at offset 13221888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13225984 ++wrote 2048/2048 bytes at offset 13225984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13230080 ++wrote 2048/2048 bytes at offset 13230080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13234176 ++wrote 2048/2048 bytes at offset 13234176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13238272 ++wrote 2048/2048 bytes at offset 13238272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13242368 ++wrote 2048/2048 bytes at offset 13242368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13246464 ++wrote 2048/2048 bytes at offset 13246464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13250560 ++wrote 2048/2048 bytes at offset 13250560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13254656 ++wrote 2048/2048 bytes at offset 13254656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13258752 ++wrote 2048/2048 bytes at offset 13258752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13262848 ++wrote 2048/2048 bytes at offset 13262848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13266944 ++wrote 2048/2048 bytes at offset 13266944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13271040 ++wrote 2048/2048 bytes at offset 13271040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13275136 ++wrote 2048/2048 bytes at offset 13275136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13279232 ++wrote 2048/2048 bytes at offset 13279232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13283328 ++wrote 2048/2048 bytes at offset 13283328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13287424 ++wrote 2048/2048 bytes at offset 13287424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13291520 ++wrote 2048/2048 bytes at offset 13291520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13295616 ++wrote 2048/2048 bytes at offset 13295616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13299712 ++wrote 2048/2048 bytes at offset 13299712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13303808 ++wrote 2048/2048 bytes at offset 13303808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13307904 ++wrote 2048/2048 bytes at offset 13307904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13312000 ++wrote 2048/2048 bytes at offset 13312000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13316096 ++wrote 2048/2048 bytes at offset 13316096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13320192 ++wrote 2048/2048 bytes at offset 13320192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13324288 ++wrote 2048/2048 bytes at offset 13324288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13328384 ++wrote 2048/2048 bytes at offset 13328384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13332480 ++wrote 2048/2048 bytes at offset 13332480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13336576 ++wrote 2048/2048 bytes at offset 13336576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13340672 ++wrote 2048/2048 bytes at offset 13340672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13344768 ++wrote 2048/2048 bytes at offset 13344768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13348864 ++wrote 2048/2048 bytes at offset 13348864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13352960 ++wrote 2048/2048 bytes at offset 13352960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13357056 ++wrote 2048/2048 bytes at offset 13357056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13361152 ++wrote 2048/2048 bytes at offset 13361152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13365248 ++wrote 2048/2048 bytes at offset 13365248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13369344 ++wrote 2048/2048 bytes at offset 13369344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13373440 ++wrote 2048/2048 bytes at offset 13373440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13377536 ++wrote 2048/2048 bytes at offset 13377536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13381632 ++wrote 2048/2048 bytes at offset 13381632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13385728 ++wrote 2048/2048 bytes at offset 13385728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13389824 ++wrote 2048/2048 bytes at offset 13389824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13393920 ++wrote 2048/2048 bytes at offset 13393920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13398016 ++wrote 2048/2048 bytes at offset 13398016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13402112 ++wrote 2048/2048 bytes at offset 13402112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13406208 ++wrote 2048/2048 bytes at offset 13406208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13410304 ++wrote 2048/2048 bytes at offset 13410304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13414400 ++wrote 2048/2048 bytes at offset 13414400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13418496 ++wrote 2048/2048 bytes at offset 13418496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13422592 ++wrote 2048/2048 bytes at offset 13422592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13426688 ++wrote 2048/2048 bytes at offset 13426688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13430784 ++wrote 2048/2048 bytes at offset 13430784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13434880 ++wrote 2048/2048 bytes at offset 13434880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13438976 ++wrote 2048/2048 bytes at offset 13438976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13443072 ++wrote 2048/2048 bytes at offset 13443072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13447168 ++wrote 2048/2048 bytes at offset 13447168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13451264 ++wrote 2048/2048 bytes at offset 13451264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13455360 ++wrote 2048/2048 bytes at offset 13455360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13459456 ++wrote 2048/2048 bytes at offset 13459456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13463552 ++wrote 2048/2048 bytes at offset 13463552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13467648 ++wrote 2048/2048 bytes at offset 13467648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13471744 ++wrote 2048/2048 bytes at offset 13471744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13475840 ++wrote 2048/2048 bytes at offset 13475840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13479936 ++wrote 2048/2048 bytes at offset 13479936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13484032 ++wrote 2048/2048 bytes at offset 13484032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13488128 ++wrote 2048/2048 bytes at offset 13488128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13492224 ++wrote 2048/2048 bytes at offset 13492224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13496320 ++wrote 2048/2048 bytes at offset 13496320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13500416 ++wrote 2048/2048 bytes at offset 13500416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13504512 ++wrote 2048/2048 bytes at offset 13504512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13508608 ++wrote 2048/2048 bytes at offset 13508608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13512704 ++wrote 2048/2048 bytes at offset 13512704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13516800 ++wrote 2048/2048 bytes at offset 13516800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13520896 ++wrote 2048/2048 bytes at offset 13520896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13524992 ++wrote 2048/2048 bytes at offset 13524992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13529088 ++wrote 2048/2048 bytes at offset 13529088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13533184 ++wrote 2048/2048 bytes at offset 13533184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13537280 ++wrote 2048/2048 bytes at offset 13537280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13541376 ++wrote 2048/2048 bytes at offset 13541376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13545472 ++wrote 2048/2048 bytes at offset 13545472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13549568 ++wrote 2048/2048 bytes at offset 13549568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13553664 ++wrote 2048/2048 bytes at offset 13553664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13557760 ++wrote 2048/2048 bytes at offset 13557760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13561856 ++wrote 2048/2048 bytes at offset 13561856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13565952 ++wrote 2048/2048 bytes at offset 13565952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13570048 ++wrote 2048/2048 bytes at offset 13570048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13574144 ++wrote 2048/2048 bytes at offset 13574144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13578240 ++wrote 2048/2048 bytes at offset 13578240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13582336 ++wrote 2048/2048 bytes at offset 13582336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13586432 ++wrote 2048/2048 bytes at offset 13586432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13590528 ++wrote 2048/2048 bytes at offset 13590528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13594624 ++wrote 2048/2048 bytes at offset 13594624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13598720 ++wrote 2048/2048 bytes at offset 13598720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13602816 ++wrote 2048/2048 bytes at offset 13602816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13606912 ++wrote 2048/2048 bytes at offset 13606912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13611008 ++wrote 2048/2048 bytes at offset 13611008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13615104 ++wrote 2048/2048 bytes at offset 13615104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13619200 ++wrote 2048/2048 bytes at offset 13619200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13623296 ++wrote 2048/2048 bytes at offset 13623296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13627392 ++wrote 2048/2048 bytes at offset 13627392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 2 +-qemu-io> wrote 2048/2048 bytes at offset 13632512 ++=== IO: pattern 2 ++wrote 2048/2048 bytes at offset 13632512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13636608 ++wrote 2048/2048 bytes at offset 13636608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13640704 ++wrote 2048/2048 bytes at offset 13640704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13644800 ++wrote 2048/2048 bytes at offset 13644800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13648896 ++wrote 2048/2048 bytes at offset 13648896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13652992 ++wrote 2048/2048 bytes at offset 13652992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13657088 ++wrote 2048/2048 bytes at offset 13657088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13661184 ++wrote 2048/2048 bytes at offset 13661184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13665280 ++wrote 2048/2048 bytes at offset 13665280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13669376 ++wrote 2048/2048 bytes at offset 13669376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13673472 ++wrote 2048/2048 bytes at offset 13673472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13677568 ++wrote 2048/2048 bytes at offset 13677568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13681664 ++wrote 2048/2048 bytes at offset 13681664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13685760 ++wrote 2048/2048 bytes at offset 13685760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13689856 ++wrote 2048/2048 bytes at offset 13689856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13693952 ++wrote 2048/2048 bytes at offset 13693952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13698048 ++wrote 2048/2048 bytes at offset 13698048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13702144 ++wrote 2048/2048 bytes at offset 13702144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13706240 ++wrote 2048/2048 bytes at offset 13706240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13710336 ++wrote 2048/2048 bytes at offset 13710336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13714432 ++wrote 2048/2048 bytes at offset 13714432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13718528 ++wrote 2048/2048 bytes at offset 13718528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13722624 ++wrote 2048/2048 bytes at offset 13722624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13726720 ++wrote 2048/2048 bytes at offset 13726720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13730816 ++wrote 2048/2048 bytes at offset 13730816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13734912 ++wrote 2048/2048 bytes at offset 13734912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13739008 ++wrote 2048/2048 bytes at offset 13739008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13743104 ++wrote 2048/2048 bytes at offset 13743104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13747200 ++wrote 2048/2048 bytes at offset 13747200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13751296 ++wrote 2048/2048 bytes at offset 13751296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13755392 ++wrote 2048/2048 bytes at offset 13755392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13759488 ++wrote 2048/2048 bytes at offset 13759488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13763584 ++wrote 2048/2048 bytes at offset 13763584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13767680 ++wrote 2048/2048 bytes at offset 13767680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13771776 ++wrote 2048/2048 bytes at offset 13771776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13775872 ++wrote 2048/2048 bytes at offset 13775872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13779968 ++wrote 2048/2048 bytes at offset 13779968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13784064 ++wrote 2048/2048 bytes at offset 13784064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13788160 ++wrote 2048/2048 bytes at offset 13788160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13792256 ++wrote 2048/2048 bytes at offset 13792256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13796352 ++wrote 2048/2048 bytes at offset 13796352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13800448 ++wrote 2048/2048 bytes at offset 13800448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13804544 ++wrote 2048/2048 bytes at offset 13804544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13808640 ++wrote 2048/2048 bytes at offset 13808640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13812736 ++wrote 2048/2048 bytes at offset 13812736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13816832 ++wrote 2048/2048 bytes at offset 13816832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13820928 ++wrote 2048/2048 bytes at offset 13820928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13825024 ++wrote 2048/2048 bytes at offset 13825024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13829120 ++wrote 2048/2048 bytes at offset 13829120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13833216 ++wrote 2048/2048 bytes at offset 13833216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13837312 ++wrote 2048/2048 bytes at offset 13837312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13841408 ++wrote 2048/2048 bytes at offset 13841408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13845504 ++wrote 2048/2048 bytes at offset 13845504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13849600 ++wrote 2048/2048 bytes at offset 13849600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13853696 ++wrote 2048/2048 bytes at offset 13853696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13857792 ++wrote 2048/2048 bytes at offset 13857792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13861888 ++wrote 2048/2048 bytes at offset 13861888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13865984 ++wrote 2048/2048 bytes at offset 13865984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13870080 ++wrote 2048/2048 bytes at offset 13870080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13874176 ++wrote 2048/2048 bytes at offset 13874176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13878272 ++wrote 2048/2048 bytes at offset 13878272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13882368 ++wrote 2048/2048 bytes at offset 13882368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13886464 ++wrote 2048/2048 bytes at offset 13886464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13890560 ++wrote 2048/2048 bytes at offset 13890560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13894656 ++wrote 2048/2048 bytes at offset 13894656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13898752 ++wrote 2048/2048 bytes at offset 13898752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13902848 ++wrote 2048/2048 bytes at offset 13902848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13906944 ++wrote 2048/2048 bytes at offset 13906944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13911040 ++wrote 2048/2048 bytes at offset 13911040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13915136 ++wrote 2048/2048 bytes at offset 13915136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13919232 ++wrote 2048/2048 bytes at offset 13919232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13923328 ++wrote 2048/2048 bytes at offset 13923328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13927424 ++wrote 2048/2048 bytes at offset 13927424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13931520 ++wrote 2048/2048 bytes at offset 13931520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13935616 ++wrote 2048/2048 bytes at offset 13935616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13939712 ++wrote 2048/2048 bytes at offset 13939712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13943808 ++wrote 2048/2048 bytes at offset 13943808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13947904 ++wrote 2048/2048 bytes at offset 13947904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13952000 ++wrote 2048/2048 bytes at offset 13952000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13956096 ++wrote 2048/2048 bytes at offset 13956096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13960192 ++wrote 2048/2048 bytes at offset 13960192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13964288 ++wrote 2048/2048 bytes at offset 13964288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13968384 ++wrote 2048/2048 bytes at offset 13968384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13972480 ++wrote 2048/2048 bytes at offset 13972480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13976576 ++wrote 2048/2048 bytes at offset 13976576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13980672 ++wrote 2048/2048 bytes at offset 13980672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13984768 ++wrote 2048/2048 bytes at offset 13984768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13988864 ++wrote 2048/2048 bytes at offset 13988864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13992960 ++wrote 2048/2048 bytes at offset 13992960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 13997056 ++wrote 2048/2048 bytes at offset 13997056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14001152 ++wrote 2048/2048 bytes at offset 14001152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14005248 ++wrote 2048/2048 bytes at offset 14005248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14009344 ++wrote 2048/2048 bytes at offset 14009344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14013440 ++wrote 2048/2048 bytes at offset 14013440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14017536 ++wrote 2048/2048 bytes at offset 14017536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14021632 ++wrote 2048/2048 bytes at offset 14021632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14025728 ++wrote 2048/2048 bytes at offset 14025728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14029824 ++wrote 2048/2048 bytes at offset 14029824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14033920 ++wrote 2048/2048 bytes at offset 14033920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14038016 ++wrote 2048/2048 bytes at offset 14038016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14042112 ++wrote 2048/2048 bytes at offset 14042112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14046208 ++wrote 2048/2048 bytes at offset 14046208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14050304 ++wrote 2048/2048 bytes at offset 14050304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14054400 ++wrote 2048/2048 bytes at offset 14054400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14058496 ++wrote 2048/2048 bytes at offset 14058496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14062592 ++wrote 2048/2048 bytes at offset 14062592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14066688 ++wrote 2048/2048 bytes at offset 14066688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14070784 ++wrote 2048/2048 bytes at offset 14070784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14074880 ++wrote 2048/2048 bytes at offset 14074880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14078976 ++wrote 2048/2048 bytes at offset 14078976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14083072 ++wrote 2048/2048 bytes at offset 14083072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14087168 ++wrote 2048/2048 bytes at offset 14087168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14091264 ++wrote 2048/2048 bytes at offset 14091264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14095360 ++wrote 2048/2048 bytes at offset 14095360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14099456 ++wrote 2048/2048 bytes at offset 14099456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14103552 ++wrote 2048/2048 bytes at offset 14103552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14107648 ++wrote 2048/2048 bytes at offset 14107648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14111744 ++wrote 2048/2048 bytes at offset 14111744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14115840 ++wrote 2048/2048 bytes at offset 14115840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14119936 ++wrote 2048/2048 bytes at offset 14119936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14124032 ++wrote 2048/2048 bytes at offset 14124032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14128128 ++wrote 2048/2048 bytes at offset 14128128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14132224 ++wrote 2048/2048 bytes at offset 14132224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14136320 ++wrote 2048/2048 bytes at offset 14136320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14140416 ++wrote 2048/2048 bytes at offset 14140416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14144512 ++wrote 2048/2048 bytes at offset 14144512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14148608 ++wrote 2048/2048 bytes at offset 14148608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14152704 ++wrote 2048/2048 bytes at offset 14152704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14156800 ++wrote 2048/2048 bytes at offset 14156800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14160896 ++wrote 2048/2048 bytes at offset 14160896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14164992 ++wrote 2048/2048 bytes at offset 14164992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14169088 ++wrote 2048/2048 bytes at offset 14169088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14173184 ++wrote 2048/2048 bytes at offset 14173184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14177280 ++wrote 2048/2048 bytes at offset 14177280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14181376 ++wrote 2048/2048 bytes at offset 14181376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14185472 ++wrote 2048/2048 bytes at offset 14185472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14189568 ++wrote 2048/2048 bytes at offset 14189568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14193664 ++wrote 2048/2048 bytes at offset 14193664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14197760 ++wrote 2048/2048 bytes at offset 14197760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14201856 ++wrote 2048/2048 bytes at offset 14201856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14205952 ++wrote 2048/2048 bytes at offset 14205952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14210048 ++wrote 2048/2048 bytes at offset 14210048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14214144 ++wrote 2048/2048 bytes at offset 14214144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14218240 ++wrote 2048/2048 bytes at offset 14218240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14222336 ++wrote 2048/2048 bytes at offset 14222336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14226432 ++wrote 2048/2048 bytes at offset 14226432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14230528 ++wrote 2048/2048 bytes at offset 14230528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14234624 ++wrote 2048/2048 bytes at offset 14234624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14238720 ++wrote 2048/2048 bytes at offset 14238720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14242816 ++wrote 2048/2048 bytes at offset 14242816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14246912 ++wrote 2048/2048 bytes at offset 14246912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14251008 ++wrote 2048/2048 bytes at offset 14251008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14255104 ++wrote 2048/2048 bytes at offset 14255104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14259200 ++wrote 2048/2048 bytes at offset 14259200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14263296 ++wrote 2048/2048 bytes at offset 14263296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14267392 ++wrote 2048/2048 bytes at offset 14267392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14271488 ++wrote 2048/2048 bytes at offset 14271488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14275584 ++wrote 2048/2048 bytes at offset 14275584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14279680 ++wrote 2048/2048 bytes at offset 14279680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14283776 ++wrote 2048/2048 bytes at offset 14283776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14287872 ++wrote 2048/2048 bytes at offset 14287872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14291968 ++wrote 2048/2048 bytes at offset 14291968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14296064 ++wrote 2048/2048 bytes at offset 14296064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14300160 ++wrote 2048/2048 bytes at offset 14300160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14304256 ++wrote 2048/2048 bytes at offset 14304256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14308352 ++wrote 2048/2048 bytes at offset 14308352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14312448 ++wrote 2048/2048 bytes at offset 14312448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14316544 ++wrote 2048/2048 bytes at offset 14316544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14320640 ++wrote 2048/2048 bytes at offset 14320640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14324736 ++wrote 2048/2048 bytes at offset 14324736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14328832 ++wrote 2048/2048 bytes at offset 14328832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14332928 ++wrote 2048/2048 bytes at offset 14332928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14337024 ++wrote 2048/2048 bytes at offset 14337024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14341120 ++wrote 2048/2048 bytes at offset 14341120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14345216 ++wrote 2048/2048 bytes at offset 14345216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14349312 ++wrote 2048/2048 bytes at offset 14349312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14353408 ++wrote 2048/2048 bytes at offset 14353408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14357504 ++wrote 2048/2048 bytes at offset 14357504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14361600 ++wrote 2048/2048 bytes at offset 14361600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14365696 ++wrote 2048/2048 bytes at offset 14365696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14369792 ++wrote 2048/2048 bytes at offset 14369792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14373888 ++wrote 2048/2048 bytes at offset 14373888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14377984 ++wrote 2048/2048 bytes at offset 14377984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14382080 ++wrote 2048/2048 bytes at offset 14382080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14386176 ++wrote 2048/2048 bytes at offset 14386176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14390272 ++wrote 2048/2048 bytes at offset 14390272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14394368 ++wrote 2048/2048 bytes at offset 14394368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14398464 ++wrote 2048/2048 bytes at offset 14398464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14402560 ++wrote 2048/2048 bytes at offset 14402560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14406656 ++wrote 2048/2048 bytes at offset 14406656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14410752 ++wrote 2048/2048 bytes at offset 14410752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14414848 ++wrote 2048/2048 bytes at offset 14414848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14418944 ++wrote 2048/2048 bytes at offset 14418944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14423040 ++wrote 2048/2048 bytes at offset 14423040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14427136 ++wrote 2048/2048 bytes at offset 14427136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14431232 ++wrote 2048/2048 bytes at offset 14431232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14435328 ++wrote 2048/2048 bytes at offset 14435328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14439424 ++wrote 2048/2048 bytes at offset 14439424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14443520 ++wrote 2048/2048 bytes at offset 14443520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14447616 ++wrote 2048/2048 bytes at offset 14447616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14451712 ++wrote 2048/2048 bytes at offset 14451712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14455808 ++wrote 2048/2048 bytes at offset 14455808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14459904 ++wrote 2048/2048 bytes at offset 14459904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14464000 ++wrote 2048/2048 bytes at offset 14464000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14468096 ++wrote 2048/2048 bytes at offset 14468096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14472192 ++wrote 2048/2048 bytes at offset 14472192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14476288 ++wrote 2048/2048 bytes at offset 14476288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14480384 ++wrote 2048/2048 bytes at offset 14480384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14484480 ++wrote 2048/2048 bytes at offset 14484480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14488576 ++wrote 2048/2048 bytes at offset 14488576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14492672 ++wrote 2048/2048 bytes at offset 14492672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14496768 ++wrote 2048/2048 bytes at offset 14496768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14500864 ++wrote 2048/2048 bytes at offset 14500864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14504960 ++wrote 2048/2048 bytes at offset 14504960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14509056 ++wrote 2048/2048 bytes at offset 14509056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14513152 ++wrote 2048/2048 bytes at offset 14513152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14517248 ++wrote 2048/2048 bytes at offset 14517248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14521344 ++wrote 2048/2048 bytes at offset 14521344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14525440 ++wrote 2048/2048 bytes at offset 14525440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14529536 ++wrote 2048/2048 bytes at offset 14529536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14533632 ++wrote 2048/2048 bytes at offset 14533632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14537728 ++wrote 2048/2048 bytes at offset 14537728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14541824 ++wrote 2048/2048 bytes at offset 14541824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14545920 ++wrote 2048/2048 bytes at offset 14545920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14550016 ++wrote 2048/2048 bytes at offset 14550016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14554112 ++wrote 2048/2048 bytes at offset 14554112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14558208 ++wrote 2048/2048 bytes at offset 14558208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14562304 ++wrote 2048/2048 bytes at offset 14562304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14566400 ++wrote 2048/2048 bytes at offset 14566400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14570496 ++wrote 2048/2048 bytes at offset 14570496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14574592 ++wrote 2048/2048 bytes at offset 14574592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14578688 ++wrote 2048/2048 bytes at offset 14578688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14582784 ++wrote 2048/2048 bytes at offset 14582784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14586880 ++wrote 2048/2048 bytes at offset 14586880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14590976 ++wrote 2048/2048 bytes at offset 14590976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14595072 ++wrote 2048/2048 bytes at offset 14595072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14599168 ++wrote 2048/2048 bytes at offset 14599168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14603264 ++wrote 2048/2048 bytes at offset 14603264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14607360 ++wrote 2048/2048 bytes at offset 14607360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14611456 ++wrote 2048/2048 bytes at offset 14611456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14615552 ++wrote 2048/2048 bytes at offset 14615552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14619648 ++wrote 2048/2048 bytes at offset 14619648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14623744 ++wrote 2048/2048 bytes at offset 14623744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14627840 ++wrote 2048/2048 bytes at offset 14627840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14631936 ++wrote 2048/2048 bytes at offset 14631936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14636032 ++wrote 2048/2048 bytes at offset 14636032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14640128 ++wrote 2048/2048 bytes at offset 14640128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14644224 ++wrote 2048/2048 bytes at offset 14644224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14648320 ++wrote 2048/2048 bytes at offset 14648320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14652416 ++wrote 2048/2048 bytes at offset 14652416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14656512 ++wrote 2048/2048 bytes at offset 14656512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14660608 ++wrote 2048/2048 bytes at offset 14660608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14664704 ++wrote 2048/2048 bytes at offset 14664704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14668800 ++wrote 2048/2048 bytes at offset 14668800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14672896 ++wrote 2048/2048 bytes at offset 14672896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 14676992 ++wrote 2048/2048 bytes at offset 14676992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 4 +-qemu-io> wrote 8192/8192 bytes at offset 14682112 ++=== IO: pattern 4 ++wrote 8192/8192 bytes at offset 14682112 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 14694400 ++wrote 8192/8192 bytes at offset 14694400 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 14706688 ++wrote 8192/8192 bytes at offset 14706688 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 14718976 ++wrote 8192/8192 bytes at offset 14718976 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 14731264 ++wrote 8192/8192 bytes at offset 14731264 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 14743552 ++wrote 8192/8192 bytes at offset 14743552 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 14755840 ++wrote 8192/8192 bytes at offset 14755840 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 14768128 ++wrote 8192/8192 bytes at offset 14768128 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 14780416 ++wrote 8192/8192 bytes at offset 14780416 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 14792704 ++wrote 8192/8192 bytes at offset 14792704 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 14804992 ++wrote 8192/8192 bytes at offset 14804992 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 14817280 ++wrote 8192/8192 bytes at offset 14817280 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 14829568 ++wrote 8192/8192 bytes at offset 14829568 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 14841856 ++wrote 8192/8192 bytes at offset 14841856 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 14854144 ++wrote 8192/8192 bytes at offset 14854144 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 14866432 ++wrote 8192/8192 bytes at offset 14866432 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 14878720 ++wrote 8192/8192 bytes at offset 14878720 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 14891008 ++wrote 8192/8192 bytes at offset 14891008 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 14903296 ++wrote 8192/8192 bytes at offset 14903296 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 14915584 ++wrote 8192/8192 bytes at offset 14915584 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 14927872 ++wrote 8192/8192 bytes at offset 14927872 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 14940160 ++wrote 8192/8192 bytes at offset 14940160 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 14952448 ++wrote 8192/8192 bytes at offset 14952448 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 14964736 ++wrote 8192/8192 bytes at offset 14964736 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 14977024 ++wrote 8192/8192 bytes at offset 14977024 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 14989312 ++wrote 8192/8192 bytes at offset 14989312 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 15001600 ++wrote 8192/8192 bytes at offset 15001600 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 15013888 ++wrote 8192/8192 bytes at offset 15013888 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 15026176 ++wrote 8192/8192 bytes at offset 15026176 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 15038464 ++wrote 8192/8192 bytes at offset 15038464 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 15050752 ++wrote 8192/8192 bytes at offset 15050752 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 15063040 ++wrote 8192/8192 bytes at offset 15063040 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 15075328 ++wrote 8192/8192 bytes at offset 15075328 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 15087616 ++wrote 8192/8192 bytes at offset 15087616 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 15099904 ++wrote 8192/8192 bytes at offset 15099904 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 15112192 ++wrote 8192/8192 bytes at offset 15112192 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 15124480 ++wrote 8192/8192 bytes at offset 15124480 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 15136768 ++wrote 8192/8192 bytes at offset 15136768 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 15149056 ++wrote 8192/8192 bytes at offset 15149056 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 15161344 ++wrote 8192/8192 bytes at offset 15161344 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 15173632 ++wrote 8192/8192 bytes at offset 15173632 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 15185920 ++wrote 8192/8192 bytes at offset 15185920 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 15198208 ++wrote 8192/8192 bytes at offset 15198208 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 15210496 ++wrote 8192/8192 bytes at offset 15210496 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 15222784 ++wrote 8192/8192 bytes at offset 15222784 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 15235072 ++wrote 8192/8192 bytes at offset 15235072 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 15247360 ++wrote 8192/8192 bytes at offset 15247360 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 15259648 ++wrote 8192/8192 bytes at offset 15259648 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 15271936 ++wrote 8192/8192 bytes at offset 15271936 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 15284224 ++wrote 8192/8192 bytes at offset 15284224 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 15296512 ++wrote 8192/8192 bytes at offset 15296512 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 15308800 ++wrote 8192/8192 bytes at offset 15308800 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 15321088 ++wrote 8192/8192 bytes at offset 15321088 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 15333376 ++wrote 8192/8192 bytes at offset 15333376 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 15345664 ++wrote 8192/8192 bytes at offset 15345664 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 15357952 ++wrote 8192/8192 bytes at offset 15357952 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 15370240 ++wrote 8192/8192 bytes at offset 15370240 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 15382528 ++wrote 8192/8192 bytes at offset 15382528 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 15394816 ++wrote 8192/8192 bytes at offset 15394816 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 15407104 ++wrote 8192/8192 bytes at offset 15407104 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 15419392 ++wrote 8192/8192 bytes at offset 15419392 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 15431680 ++wrote 8192/8192 bytes at offset 15431680 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 15443968 ++wrote 8192/8192 bytes at offset 15443968 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 15456256 ++wrote 8192/8192 bytes at offset 15456256 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 244 +-qemu-io> wrote 12288/12288 bytes at offset 16771072 ++=== IO: pattern 244 ++wrote 12288/12288 bytes at offset 16771072 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 18870272 ++wrote 12288/12288 bytes at offset 18870272 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 20969472 ++wrote 12288/12288 bytes at offset 20969472 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 23068672 ++wrote 12288/12288 bytes at offset 23068672 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 25167872 ++wrote 12288/12288 bytes at offset 25167872 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 27267072 ++wrote 12288/12288 bytes at offset 27267072 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 29366272 ++wrote 12288/12288 bytes at offset 29366272 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 31465472 ++wrote 12288/12288 bytes at offset 31465472 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> read 4096/4096 bytes at offset 10485760 ++=== IO: pattern 0 ++read 4096/4096 bytes at offset 10485760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10489856 ++read 4096/4096 bytes at offset 10489856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10493952 ++read 4096/4096 bytes at offset 10493952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10498048 ++read 4096/4096 bytes at offset 10498048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10502144 ++read 4096/4096 bytes at offset 10502144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10506240 ++read 4096/4096 bytes at offset 10506240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10510336 ++read 4096/4096 bytes at offset 10510336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10514432 ++read 4096/4096 bytes at offset 10514432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10518528 ++read 4096/4096 bytes at offset 10518528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10522624 ++read 4096/4096 bytes at offset 10522624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10526720 ++read 4096/4096 bytes at offset 10526720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10530816 ++read 4096/4096 bytes at offset 10530816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10534912 ++read 4096/4096 bytes at offset 10534912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10539008 ++read 4096/4096 bytes at offset 10539008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10543104 ++read 4096/4096 bytes at offset 10543104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10547200 ++read 4096/4096 bytes at offset 10547200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10551296 ++read 4096/4096 bytes at offset 10551296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10555392 ++read 4096/4096 bytes at offset 10555392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10559488 ++read 4096/4096 bytes at offset 10559488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10563584 ++read 4096/4096 bytes at offset 10563584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10567680 ++read 4096/4096 bytes at offset 10567680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10571776 ++read 4096/4096 bytes at offset 10571776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10575872 ++read 4096/4096 bytes at offset 10575872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10579968 ++read 4096/4096 bytes at offset 10579968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10584064 ++read 4096/4096 bytes at offset 10584064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10588160 ++read 4096/4096 bytes at offset 10588160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10592256 ++read 4096/4096 bytes at offset 10592256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10596352 ++read 4096/4096 bytes at offset 10596352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10600448 ++read 4096/4096 bytes at offset 10600448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10604544 ++read 4096/4096 bytes at offset 10604544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10608640 ++read 4096/4096 bytes at offset 10608640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10612736 ++read 4096/4096 bytes at offset 10612736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10616832 ++read 4096/4096 bytes at offset 10616832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10620928 ++read 4096/4096 bytes at offset 10620928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10625024 ++read 4096/4096 bytes at offset 10625024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10629120 ++read 4096/4096 bytes at offset 10629120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10633216 ++read 4096/4096 bytes at offset 10633216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10637312 ++read 4096/4096 bytes at offset 10637312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10641408 ++read 4096/4096 bytes at offset 10641408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10645504 ++read 4096/4096 bytes at offset 10645504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10649600 ++read 4096/4096 bytes at offset 10649600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10653696 ++read 4096/4096 bytes at offset 10653696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10657792 ++read 4096/4096 bytes at offset 10657792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10661888 ++read 4096/4096 bytes at offset 10661888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10665984 ++read 4096/4096 bytes at offset 10665984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10670080 ++read 4096/4096 bytes at offset 10670080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10674176 ++read 4096/4096 bytes at offset 10674176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10678272 ++read 4096/4096 bytes at offset 10678272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10682368 ++read 4096/4096 bytes at offset 10682368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10686464 ++read 4096/4096 bytes at offset 10686464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10690560 ++read 4096/4096 bytes at offset 10690560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10694656 ++read 4096/4096 bytes at offset 10694656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10698752 ++read 4096/4096 bytes at offset 10698752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10702848 ++read 4096/4096 bytes at offset 10702848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10706944 ++read 4096/4096 bytes at offset 10706944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10711040 ++read 4096/4096 bytes at offset 10711040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10715136 ++read 4096/4096 bytes at offset 10715136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10719232 ++read 4096/4096 bytes at offset 10719232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10723328 ++read 4096/4096 bytes at offset 10723328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10727424 ++read 4096/4096 bytes at offset 10727424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10731520 ++read 4096/4096 bytes at offset 10731520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10735616 ++read 4096/4096 bytes at offset 10735616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10739712 ++read 4096/4096 bytes at offset 10739712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10743808 ++read 4096/4096 bytes at offset 10743808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10747904 ++read 4096/4096 bytes at offset 10747904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10752000 ++read 4096/4096 bytes at offset 10752000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10756096 ++read 4096/4096 bytes at offset 10756096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10760192 ++read 4096/4096 bytes at offset 10760192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10764288 ++read 4096/4096 bytes at offset 10764288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10768384 ++read 4096/4096 bytes at offset 10768384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10772480 ++read 4096/4096 bytes at offset 10772480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10776576 ++read 4096/4096 bytes at offset 10776576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10780672 ++read 4096/4096 bytes at offset 10780672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10784768 ++read 4096/4096 bytes at offset 10784768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10788864 ++read 4096/4096 bytes at offset 10788864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10792960 ++read 4096/4096 bytes at offset 10792960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10797056 ++read 4096/4096 bytes at offset 10797056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10801152 ++read 4096/4096 bytes at offset 10801152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10805248 ++read 4096/4096 bytes at offset 10805248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10809344 ++read 4096/4096 bytes at offset 10809344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10813440 ++read 4096/4096 bytes at offset 10813440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10817536 ++read 4096/4096 bytes at offset 10817536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10821632 ++read 4096/4096 bytes at offset 10821632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10825728 ++read 4096/4096 bytes at offset 10825728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10829824 ++read 4096/4096 bytes at offset 10829824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10833920 ++read 4096/4096 bytes at offset 10833920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10838016 ++read 4096/4096 bytes at offset 10838016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10842112 ++read 4096/4096 bytes at offset 10842112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10846208 ++read 4096/4096 bytes at offset 10846208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10850304 ++read 4096/4096 bytes at offset 10850304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10854400 ++read 4096/4096 bytes at offset 10854400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10858496 ++read 4096/4096 bytes at offset 10858496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10862592 ++read 4096/4096 bytes at offset 10862592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10866688 ++read 4096/4096 bytes at offset 10866688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10870784 ++read 4096/4096 bytes at offset 10870784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10874880 ++read 4096/4096 bytes at offset 10874880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10878976 ++read 4096/4096 bytes at offset 10878976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10883072 ++read 4096/4096 bytes at offset 10883072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10887168 ++read 4096/4096 bytes at offset 10887168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10891264 ++read 4096/4096 bytes at offset 10891264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10895360 ++read 4096/4096 bytes at offset 10895360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10899456 ++read 4096/4096 bytes at offset 10899456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10903552 ++read 4096/4096 bytes at offset 10903552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10907648 ++read 4096/4096 bytes at offset 10907648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10911744 ++read 4096/4096 bytes at offset 10911744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10915840 ++read 4096/4096 bytes at offset 10915840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10919936 ++read 4096/4096 bytes at offset 10919936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10924032 ++read 4096/4096 bytes at offset 10924032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10928128 ++read 4096/4096 bytes at offset 10928128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10932224 ++read 4096/4096 bytes at offset 10932224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10936320 ++read 4096/4096 bytes at offset 10936320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10940416 ++read 4096/4096 bytes at offset 10940416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10944512 ++read 4096/4096 bytes at offset 10944512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10948608 ++read 4096/4096 bytes at offset 10948608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10952704 ++read 4096/4096 bytes at offset 10952704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10956800 ++read 4096/4096 bytes at offset 10956800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10960896 ++read 4096/4096 bytes at offset 10960896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10964992 ++read 4096/4096 bytes at offset 10964992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10969088 ++read 4096/4096 bytes at offset 10969088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10973184 ++read 4096/4096 bytes at offset 10973184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10977280 ++read 4096/4096 bytes at offset 10977280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10981376 ++read 4096/4096 bytes at offset 10981376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10985472 ++read 4096/4096 bytes at offset 10985472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10989568 ++read 4096/4096 bytes at offset 10989568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10993664 ++read 4096/4096 bytes at offset 10993664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 10997760 ++read 4096/4096 bytes at offset 10997760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11001856 ++read 4096/4096 bytes at offset 11001856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11005952 ++read 4096/4096 bytes at offset 11005952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11010048 ++read 4096/4096 bytes at offset 11010048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11014144 ++read 4096/4096 bytes at offset 11014144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11018240 ++read 4096/4096 bytes at offset 11018240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11022336 ++read 4096/4096 bytes at offset 11022336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11026432 ++read 4096/4096 bytes at offset 11026432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11030528 ++read 4096/4096 bytes at offset 11030528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11034624 ++read 4096/4096 bytes at offset 11034624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11038720 ++read 4096/4096 bytes at offset 11038720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11042816 ++read 4096/4096 bytes at offset 11042816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11046912 ++read 4096/4096 bytes at offset 11046912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11051008 ++read 4096/4096 bytes at offset 11051008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11055104 ++read 4096/4096 bytes at offset 11055104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11059200 ++read 4096/4096 bytes at offset 11059200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11063296 ++read 4096/4096 bytes at offset 11063296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11067392 ++read 4096/4096 bytes at offset 11067392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11071488 ++read 4096/4096 bytes at offset 11071488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11075584 ++read 4096/4096 bytes at offset 11075584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11079680 ++read 4096/4096 bytes at offset 11079680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11083776 ++read 4096/4096 bytes at offset 11083776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11087872 ++read 4096/4096 bytes at offset 11087872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11091968 ++read 4096/4096 bytes at offset 11091968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11096064 ++read 4096/4096 bytes at offset 11096064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11100160 ++read 4096/4096 bytes at offset 11100160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11104256 ++read 4096/4096 bytes at offset 11104256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11108352 ++read 4096/4096 bytes at offset 11108352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11112448 ++read 4096/4096 bytes at offset 11112448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11116544 ++read 4096/4096 bytes at offset 11116544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11120640 ++read 4096/4096 bytes at offset 11120640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11124736 ++read 4096/4096 bytes at offset 11124736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11128832 ++read 4096/4096 bytes at offset 11128832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11132928 ++read 4096/4096 bytes at offset 11132928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11137024 ++read 4096/4096 bytes at offset 11137024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11141120 ++read 4096/4096 bytes at offset 11141120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11145216 ++read 4096/4096 bytes at offset 11145216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11149312 ++read 4096/4096 bytes at offset 11149312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11153408 ++read 4096/4096 bytes at offset 11153408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11157504 ++read 4096/4096 bytes at offset 11157504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11161600 ++read 4096/4096 bytes at offset 11161600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11165696 ++read 4096/4096 bytes at offset 11165696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11169792 ++read 4096/4096 bytes at offset 11169792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11173888 ++read 4096/4096 bytes at offset 11173888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11177984 ++read 4096/4096 bytes at offset 11177984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11182080 ++read 4096/4096 bytes at offset 11182080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11186176 ++read 4096/4096 bytes at offset 11186176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11190272 ++read 4096/4096 bytes at offset 11190272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11194368 ++read 4096/4096 bytes at offset 11194368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11198464 ++read 4096/4096 bytes at offset 11198464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11202560 ++read 4096/4096 bytes at offset 11202560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11206656 ++read 4096/4096 bytes at offset 11206656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11210752 ++read 4096/4096 bytes at offset 11210752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11214848 ++read 4096/4096 bytes at offset 11214848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11218944 ++read 4096/4096 bytes at offset 11218944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11223040 ++read 4096/4096 bytes at offset 11223040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11227136 ++read 4096/4096 bytes at offset 11227136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11231232 ++read 4096/4096 bytes at offset 11231232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11235328 ++read 4096/4096 bytes at offset 11235328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11239424 ++read 4096/4096 bytes at offset 11239424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11243520 ++read 4096/4096 bytes at offset 11243520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11247616 ++read 4096/4096 bytes at offset 11247616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11251712 ++read 4096/4096 bytes at offset 11251712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11255808 ++read 4096/4096 bytes at offset 11255808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11259904 ++read 4096/4096 bytes at offset 11259904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11264000 ++read 4096/4096 bytes at offset 11264000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11268096 ++read 4096/4096 bytes at offset 11268096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11272192 ++read 4096/4096 bytes at offset 11272192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11276288 ++read 4096/4096 bytes at offset 11276288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11280384 ++read 4096/4096 bytes at offset 11280384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11284480 ++read 4096/4096 bytes at offset 11284480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11288576 ++read 4096/4096 bytes at offset 11288576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11292672 ++read 4096/4096 bytes at offset 11292672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11296768 ++read 4096/4096 bytes at offset 11296768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11300864 ++read 4096/4096 bytes at offset 11300864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11304960 ++read 4096/4096 bytes at offset 11304960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11309056 ++read 4096/4096 bytes at offset 11309056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11313152 ++read 4096/4096 bytes at offset 11313152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11317248 ++read 4096/4096 bytes at offset 11317248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11321344 ++read 4096/4096 bytes at offset 11321344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11325440 ++read 4096/4096 bytes at offset 11325440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11329536 ++read 4096/4096 bytes at offset 11329536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11333632 ++read 4096/4096 bytes at offset 11333632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11337728 ++read 4096/4096 bytes at offset 11337728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11341824 ++read 4096/4096 bytes at offset 11341824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11345920 ++read 4096/4096 bytes at offset 11345920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11350016 ++read 4096/4096 bytes at offset 11350016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11354112 ++read 4096/4096 bytes at offset 11354112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11358208 ++read 4096/4096 bytes at offset 11358208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11362304 ++read 4096/4096 bytes at offset 11362304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11366400 ++read 4096/4096 bytes at offset 11366400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11370496 ++read 4096/4096 bytes at offset 11370496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11374592 ++read 4096/4096 bytes at offset 11374592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11378688 ++read 4096/4096 bytes at offset 11378688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11382784 ++read 4096/4096 bytes at offset 11382784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11386880 ++read 4096/4096 bytes at offset 11386880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11390976 ++read 4096/4096 bytes at offset 11390976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11395072 ++read 4096/4096 bytes at offset 11395072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11399168 ++read 4096/4096 bytes at offset 11399168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11403264 ++read 4096/4096 bytes at offset 11403264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11407360 ++read 4096/4096 bytes at offset 11407360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11411456 ++read 4096/4096 bytes at offset 11411456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11415552 ++read 4096/4096 bytes at offset 11415552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11419648 ++read 4096/4096 bytes at offset 11419648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11423744 ++read 4096/4096 bytes at offset 11423744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11427840 ++read 4096/4096 bytes at offset 11427840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11431936 ++read 4096/4096 bytes at offset 11431936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11436032 ++read 4096/4096 bytes at offset 11436032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11440128 ++read 4096/4096 bytes at offset 11440128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11444224 ++read 4096/4096 bytes at offset 11444224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11448320 ++read 4096/4096 bytes at offset 11448320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11452416 ++read 4096/4096 bytes at offset 11452416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11456512 ++read 4096/4096 bytes at offset 11456512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11460608 ++read 4096/4096 bytes at offset 11460608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11464704 ++read 4096/4096 bytes at offset 11464704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11468800 ++read 4096/4096 bytes at offset 11468800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11472896 ++read 4096/4096 bytes at offset 11472896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11476992 ++read 4096/4096 bytes at offset 11476992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11481088 ++read 4096/4096 bytes at offset 11481088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11485184 ++read 4096/4096 bytes at offset 11485184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11489280 ++read 4096/4096 bytes at offset 11489280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11493376 ++read 4096/4096 bytes at offset 11493376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11497472 ++read 4096/4096 bytes at offset 11497472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11501568 ++read 4096/4096 bytes at offset 11501568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11505664 ++read 4096/4096 bytes at offset 11505664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11509760 ++read 4096/4096 bytes at offset 11509760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11513856 ++read 4096/4096 bytes at offset 11513856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11517952 ++read 4096/4096 bytes at offset 11517952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11522048 ++read 4096/4096 bytes at offset 11522048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11526144 ++read 4096/4096 bytes at offset 11526144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 11530240 ++read 4096/4096 bytes at offset 11530240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 4 +-qemu-io> read 2048/2048 bytes at offset 11536384 ++=== IO: pattern 4 ++read 2048/2048 bytes at offset 11536384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 11540480 ++read 2048/2048 bytes at offset 11540480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 11544576 ++read 2048/2048 bytes at offset 11544576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 11548672 ++read 2048/2048 bytes at offset 11548672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 11552768 ++read 2048/2048 bytes at offset 11552768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 11556864 ++read 2048/2048 bytes at offset 11556864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 11560960 ++read 2048/2048 bytes at offset 11560960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 11565056 ++read 2048/2048 bytes at offset 11565056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 11569152 ++read 2048/2048 bytes at offset 11569152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 11573248 ++read 2048/2048 bytes at offset 11573248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 11577344 ++read 2048/2048 bytes at offset 11577344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 11581440 ++read 2048/2048 bytes at offset 11581440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 11585536 ++read 2048/2048 bytes at offset 11585536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 11589632 ++read 2048/2048 bytes at offset 11589632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 11593728 ++read 2048/2048 bytes at offset 11593728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 11597824 ++read 2048/2048 bytes at offset 11597824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 11601920 ++read 2048/2048 bytes at offset 11601920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 11606016 ++read 2048/2048 bytes at offset 11606016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 11610112 ++read 2048/2048 bytes at offset 11610112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 11614208 ++read 2048/2048 bytes at offset 11614208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 11618304 ++read 2048/2048 bytes at offset 11618304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 11622400 ++read 2048/2048 bytes at offset 11622400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 11626496 ++read 2048/2048 bytes at offset 11626496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 11630592 ++read 2048/2048 bytes at offset 11630592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 11634688 ++read 2048/2048 bytes at offset 11634688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 11638784 ++read 2048/2048 bytes at offset 11638784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 11642880 ++read 2048/2048 bytes at offset 11642880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 11646976 ++read 2048/2048 bytes at offset 11646976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 11651072 ++read 2048/2048 bytes at offset 11651072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 11655168 ++read 2048/2048 bytes at offset 11655168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 11659264 ++read 2048/2048 bytes at offset 11659264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 11663360 ++read 2048/2048 bytes at offset 11663360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 11667456 ++read 2048/2048 bytes at offset 11667456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 11671552 ++read 2048/2048 bytes at offset 11671552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 11675648 ++read 2048/2048 bytes at offset 11675648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 11679744 ++read 2048/2048 bytes at offset 11679744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 11683840 ++read 2048/2048 bytes at offset 11683840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 11687936 ++read 2048/2048 bytes at offset 11687936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 11692032 ++read 2048/2048 bytes at offset 11692032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 11696128 ++read 2048/2048 bytes at offset 11696128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 11700224 ++read 2048/2048 bytes at offset 11700224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 11704320 ++read 2048/2048 bytes at offset 11704320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 11708416 ++read 2048/2048 bytes at offset 11708416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 11712512 ++read 2048/2048 bytes at offset 11712512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 11716608 ++read 2048/2048 bytes at offset 11716608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 11720704 ++read 2048/2048 bytes at offset 11720704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 11724800 ++read 2048/2048 bytes at offset 11724800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 11728896 ++read 2048/2048 bytes at offset 11728896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 11732992 ++read 2048/2048 bytes at offset 11732992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 11737088 ++read 2048/2048 bytes at offset 11737088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 11741184 ++read 2048/2048 bytes at offset 11741184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 11745280 ++read 2048/2048 bytes at offset 11745280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 11749376 ++read 2048/2048 bytes at offset 11749376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 11753472 ++read 2048/2048 bytes at offset 11753472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 11757568 ++read 2048/2048 bytes at offset 11757568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 11761664 ++read 2048/2048 bytes at offset 11761664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 11765760 ++read 2048/2048 bytes at offset 11765760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 11769856 ++read 2048/2048 bytes at offset 11769856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 11773952 ++read 2048/2048 bytes at offset 11773952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 11778048 ++read 2048/2048 bytes at offset 11778048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 11782144 ++read 2048/2048 bytes at offset 11782144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 11786240 ++read 2048/2048 bytes at offset 11786240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 11790336 ++read 2048/2048 bytes at offset 11790336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 11794432 ++read 2048/2048 bytes at offset 11794432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 11798528 ++read 2048/2048 bytes at offset 11798528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 11802624 ++read 2048/2048 bytes at offset 11802624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 11806720 ++read 2048/2048 bytes at offset 11806720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 11810816 ++read 2048/2048 bytes at offset 11810816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 11814912 ++read 2048/2048 bytes at offset 11814912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 11819008 ++read 2048/2048 bytes at offset 11819008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 11823104 ++read 2048/2048 bytes at offset 11823104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 11827200 ++read 2048/2048 bytes at offset 11827200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 11831296 ++read 2048/2048 bytes at offset 11831296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 11835392 ++read 2048/2048 bytes at offset 11835392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 11839488 ++read 2048/2048 bytes at offset 11839488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 11843584 ++read 2048/2048 bytes at offset 11843584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 11847680 ++read 2048/2048 bytes at offset 11847680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 11851776 ++read 2048/2048 bytes at offset 11851776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 11855872 ++read 2048/2048 bytes at offset 11855872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 11859968 ++read 2048/2048 bytes at offset 11859968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 11864064 ++read 2048/2048 bytes at offset 11864064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 11868160 ++read 2048/2048 bytes at offset 11868160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 11872256 ++read 2048/2048 bytes at offset 11872256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 11876352 ++read 2048/2048 bytes at offset 11876352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 11880448 ++read 2048/2048 bytes at offset 11880448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 11884544 ++read 2048/2048 bytes at offset 11884544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 11888640 ++read 2048/2048 bytes at offset 11888640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 11892736 ++read 2048/2048 bytes at offset 11892736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 11896832 ++read 2048/2048 bytes at offset 11896832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 11900928 ++read 2048/2048 bytes at offset 11900928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 11905024 ++read 2048/2048 bytes at offset 11905024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 11909120 ++read 2048/2048 bytes at offset 11909120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 11913216 ++read 2048/2048 bytes at offset 11913216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 11917312 ++read 2048/2048 bytes at offset 11917312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 11921408 ++read 2048/2048 bytes at offset 11921408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 11925504 ++read 2048/2048 bytes at offset 11925504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 11929600 ++read 2048/2048 bytes at offset 11929600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 11933696 ++read 2048/2048 bytes at offset 11933696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 11937792 ++read 2048/2048 bytes at offset 11937792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 11941888 ++read 2048/2048 bytes at offset 11941888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 11945984 ++read 2048/2048 bytes at offset 11945984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 11950080 ++read 2048/2048 bytes at offset 11950080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 11954176 ++read 2048/2048 bytes at offset 11954176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 11958272 ++read 2048/2048 bytes at offset 11958272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 11962368 ++read 2048/2048 bytes at offset 11962368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 11966464 ++read 2048/2048 bytes at offset 11966464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 11970560 ++read 2048/2048 bytes at offset 11970560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 11974656 ++read 2048/2048 bytes at offset 11974656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 11978752 ++read 2048/2048 bytes at offset 11978752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 11982848 ++read 2048/2048 bytes at offset 11982848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 11986944 ++read 2048/2048 bytes at offset 11986944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 11991040 ++read 2048/2048 bytes at offset 11991040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 11995136 ++read 2048/2048 bytes at offset 11995136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 11999232 ++read 2048/2048 bytes at offset 11999232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12003328 ++read 2048/2048 bytes at offset 12003328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12007424 ++read 2048/2048 bytes at offset 12007424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12011520 ++read 2048/2048 bytes at offset 12011520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12015616 ++read 2048/2048 bytes at offset 12015616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12019712 ++read 2048/2048 bytes at offset 12019712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12023808 ++read 2048/2048 bytes at offset 12023808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12027904 ++read 2048/2048 bytes at offset 12027904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12032000 ++read 2048/2048 bytes at offset 12032000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12036096 ++read 2048/2048 bytes at offset 12036096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12040192 ++read 2048/2048 bytes at offset 12040192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12044288 ++read 2048/2048 bytes at offset 12044288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12048384 ++read 2048/2048 bytes at offset 12048384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12052480 ++read 2048/2048 bytes at offset 12052480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12056576 ++read 2048/2048 bytes at offset 12056576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12060672 ++read 2048/2048 bytes at offset 12060672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12064768 ++read 2048/2048 bytes at offset 12064768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12068864 ++read 2048/2048 bytes at offset 12068864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12072960 ++read 2048/2048 bytes at offset 12072960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12077056 ++read 2048/2048 bytes at offset 12077056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12081152 ++read 2048/2048 bytes at offset 12081152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12085248 ++read 2048/2048 bytes at offset 12085248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12089344 ++read 2048/2048 bytes at offset 12089344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12093440 ++read 2048/2048 bytes at offset 12093440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12097536 ++read 2048/2048 bytes at offset 12097536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12101632 ++read 2048/2048 bytes at offset 12101632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12105728 ++read 2048/2048 bytes at offset 12105728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12109824 ++read 2048/2048 bytes at offset 12109824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12113920 ++read 2048/2048 bytes at offset 12113920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12118016 ++read 2048/2048 bytes at offset 12118016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12122112 ++read 2048/2048 bytes at offset 12122112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12126208 ++read 2048/2048 bytes at offset 12126208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12130304 ++read 2048/2048 bytes at offset 12130304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12134400 ++read 2048/2048 bytes at offset 12134400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12138496 ++read 2048/2048 bytes at offset 12138496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12142592 ++read 2048/2048 bytes at offset 12142592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12146688 ++read 2048/2048 bytes at offset 12146688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12150784 ++read 2048/2048 bytes at offset 12150784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12154880 ++read 2048/2048 bytes at offset 12154880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12158976 ++read 2048/2048 bytes at offset 12158976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12163072 ++read 2048/2048 bytes at offset 12163072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12167168 ++read 2048/2048 bytes at offset 12167168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12171264 ++read 2048/2048 bytes at offset 12171264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12175360 ++read 2048/2048 bytes at offset 12175360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12179456 ++read 2048/2048 bytes at offset 12179456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12183552 ++read 2048/2048 bytes at offset 12183552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12187648 ++read 2048/2048 bytes at offset 12187648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12191744 ++read 2048/2048 bytes at offset 12191744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12195840 ++read 2048/2048 bytes at offset 12195840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12199936 ++read 2048/2048 bytes at offset 12199936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12204032 ++read 2048/2048 bytes at offset 12204032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12208128 ++read 2048/2048 bytes at offset 12208128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12212224 ++read 2048/2048 bytes at offset 12212224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12216320 ++read 2048/2048 bytes at offset 12216320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12220416 ++read 2048/2048 bytes at offset 12220416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12224512 ++read 2048/2048 bytes at offset 12224512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12228608 ++read 2048/2048 bytes at offset 12228608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12232704 ++read 2048/2048 bytes at offset 12232704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12236800 ++read 2048/2048 bytes at offset 12236800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12240896 ++read 2048/2048 bytes at offset 12240896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12244992 ++read 2048/2048 bytes at offset 12244992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12249088 ++read 2048/2048 bytes at offset 12249088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12253184 ++read 2048/2048 bytes at offset 12253184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12257280 ++read 2048/2048 bytes at offset 12257280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12261376 ++read 2048/2048 bytes at offset 12261376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12265472 ++read 2048/2048 bytes at offset 12265472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12269568 ++read 2048/2048 bytes at offset 12269568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12273664 ++read 2048/2048 bytes at offset 12273664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12277760 ++read 2048/2048 bytes at offset 12277760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12281856 ++read 2048/2048 bytes at offset 12281856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12285952 ++read 2048/2048 bytes at offset 12285952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12290048 ++read 2048/2048 bytes at offset 12290048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12294144 ++read 2048/2048 bytes at offset 12294144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12298240 ++read 2048/2048 bytes at offset 12298240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12302336 ++read 2048/2048 bytes at offset 12302336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12306432 ++read 2048/2048 bytes at offset 12306432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12310528 ++read 2048/2048 bytes at offset 12310528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12314624 ++read 2048/2048 bytes at offset 12314624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12318720 ++read 2048/2048 bytes at offset 12318720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12322816 ++read 2048/2048 bytes at offset 12322816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12326912 ++read 2048/2048 bytes at offset 12326912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12331008 ++read 2048/2048 bytes at offset 12331008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12335104 ++read 2048/2048 bytes at offset 12335104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12339200 ++read 2048/2048 bytes at offset 12339200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12343296 ++read 2048/2048 bytes at offset 12343296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12347392 ++read 2048/2048 bytes at offset 12347392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12351488 ++read 2048/2048 bytes at offset 12351488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12355584 ++read 2048/2048 bytes at offset 12355584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12359680 ++read 2048/2048 bytes at offset 12359680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12363776 ++read 2048/2048 bytes at offset 12363776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12367872 ++read 2048/2048 bytes at offset 12367872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12371968 ++read 2048/2048 bytes at offset 12371968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12376064 ++read 2048/2048 bytes at offset 12376064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12380160 ++read 2048/2048 bytes at offset 12380160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12384256 ++read 2048/2048 bytes at offset 12384256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12388352 ++read 2048/2048 bytes at offset 12388352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12392448 ++read 2048/2048 bytes at offset 12392448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12396544 ++read 2048/2048 bytes at offset 12396544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12400640 ++read 2048/2048 bytes at offset 12400640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12404736 ++read 2048/2048 bytes at offset 12404736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12408832 ++read 2048/2048 bytes at offset 12408832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12412928 ++read 2048/2048 bytes at offset 12412928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12417024 ++read 2048/2048 bytes at offset 12417024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12421120 ++read 2048/2048 bytes at offset 12421120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12425216 ++read 2048/2048 bytes at offset 12425216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12429312 ++read 2048/2048 bytes at offset 12429312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12433408 ++read 2048/2048 bytes at offset 12433408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12437504 ++read 2048/2048 bytes at offset 12437504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12441600 ++read 2048/2048 bytes at offset 12441600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12445696 ++read 2048/2048 bytes at offset 12445696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12449792 ++read 2048/2048 bytes at offset 12449792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12453888 ++read 2048/2048 bytes at offset 12453888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12457984 ++read 2048/2048 bytes at offset 12457984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12462080 ++read 2048/2048 bytes at offset 12462080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12466176 ++read 2048/2048 bytes at offset 12466176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12470272 ++read 2048/2048 bytes at offset 12470272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12474368 ++read 2048/2048 bytes at offset 12474368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12478464 ++read 2048/2048 bytes at offset 12478464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12482560 ++read 2048/2048 bytes at offset 12482560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12486656 ++read 2048/2048 bytes at offset 12486656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12490752 ++read 2048/2048 bytes at offset 12490752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12494848 ++read 2048/2048 bytes at offset 12494848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12498944 ++read 2048/2048 bytes at offset 12498944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12503040 ++read 2048/2048 bytes at offset 12503040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12507136 ++read 2048/2048 bytes at offset 12507136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12511232 ++read 2048/2048 bytes at offset 12511232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12515328 ++read 2048/2048 bytes at offset 12515328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12519424 ++read 2048/2048 bytes at offset 12519424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12523520 ++read 2048/2048 bytes at offset 12523520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12527616 ++read 2048/2048 bytes at offset 12527616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12531712 ++read 2048/2048 bytes at offset 12531712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12535808 ++read 2048/2048 bytes at offset 12535808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12539904 ++read 2048/2048 bytes at offset 12539904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12544000 ++read 2048/2048 bytes at offset 12544000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12548096 ++read 2048/2048 bytes at offset 12548096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12552192 ++read 2048/2048 bytes at offset 12552192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12556288 ++read 2048/2048 bytes at offset 12556288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12560384 ++read 2048/2048 bytes at offset 12560384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12564480 ++read 2048/2048 bytes at offset 12564480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12568576 ++read 2048/2048 bytes at offset 12568576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12572672 ++read 2048/2048 bytes at offset 12572672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12576768 ++read 2048/2048 bytes at offset 12576768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12580864 ++read 2048/2048 bytes at offset 12580864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> read 2048/2048 bytes at offset 12582912 ++=== IO: pattern 0 ++read 2048/2048 bytes at offset 12582912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12587008 ++read 2048/2048 bytes at offset 12587008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12591104 ++read 2048/2048 bytes at offset 12591104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12595200 ++read 2048/2048 bytes at offset 12595200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12599296 ++read 2048/2048 bytes at offset 12599296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12603392 ++read 2048/2048 bytes at offset 12603392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12607488 ++read 2048/2048 bytes at offset 12607488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12611584 ++read 2048/2048 bytes at offset 12611584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12615680 ++read 2048/2048 bytes at offset 12615680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12619776 ++read 2048/2048 bytes at offset 12619776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12623872 ++read 2048/2048 bytes at offset 12623872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12627968 ++read 2048/2048 bytes at offset 12627968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12632064 ++read 2048/2048 bytes at offset 12632064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12636160 ++read 2048/2048 bytes at offset 12636160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12640256 ++read 2048/2048 bytes at offset 12640256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12644352 ++read 2048/2048 bytes at offset 12644352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12648448 ++read 2048/2048 bytes at offset 12648448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12652544 ++read 2048/2048 bytes at offset 12652544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12656640 ++read 2048/2048 bytes at offset 12656640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12660736 ++read 2048/2048 bytes at offset 12660736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12664832 ++read 2048/2048 bytes at offset 12664832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12668928 ++read 2048/2048 bytes at offset 12668928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12673024 ++read 2048/2048 bytes at offset 12673024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12677120 ++read 2048/2048 bytes at offset 12677120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12681216 ++read 2048/2048 bytes at offset 12681216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12685312 ++read 2048/2048 bytes at offset 12685312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12689408 ++read 2048/2048 bytes at offset 12689408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12693504 ++read 2048/2048 bytes at offset 12693504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12697600 ++read 2048/2048 bytes at offset 12697600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12701696 ++read 2048/2048 bytes at offset 12701696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12705792 ++read 2048/2048 bytes at offset 12705792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12709888 ++read 2048/2048 bytes at offset 12709888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12713984 ++read 2048/2048 bytes at offset 12713984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12718080 ++read 2048/2048 bytes at offset 12718080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12722176 ++read 2048/2048 bytes at offset 12722176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12726272 ++read 2048/2048 bytes at offset 12726272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12730368 ++read 2048/2048 bytes at offset 12730368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12734464 ++read 2048/2048 bytes at offset 12734464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12738560 ++read 2048/2048 bytes at offset 12738560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12742656 ++read 2048/2048 bytes at offset 12742656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12746752 ++read 2048/2048 bytes at offset 12746752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12750848 ++read 2048/2048 bytes at offset 12750848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12754944 ++read 2048/2048 bytes at offset 12754944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12759040 ++read 2048/2048 bytes at offset 12759040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12763136 ++read 2048/2048 bytes at offset 12763136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12767232 ++read 2048/2048 bytes at offset 12767232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12771328 ++read 2048/2048 bytes at offset 12771328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12775424 ++read 2048/2048 bytes at offset 12775424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12779520 ++read 2048/2048 bytes at offset 12779520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12783616 ++read 2048/2048 bytes at offset 12783616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12787712 ++read 2048/2048 bytes at offset 12787712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12791808 ++read 2048/2048 bytes at offset 12791808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12795904 ++read 2048/2048 bytes at offset 12795904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12800000 ++read 2048/2048 bytes at offset 12800000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12804096 ++read 2048/2048 bytes at offset 12804096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12808192 ++read 2048/2048 bytes at offset 12808192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12812288 ++read 2048/2048 bytes at offset 12812288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12816384 ++read 2048/2048 bytes at offset 12816384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12820480 ++read 2048/2048 bytes at offset 12820480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12824576 ++read 2048/2048 bytes at offset 12824576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12828672 ++read 2048/2048 bytes at offset 12828672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12832768 ++read 2048/2048 bytes at offset 12832768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12836864 ++read 2048/2048 bytes at offset 12836864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12840960 ++read 2048/2048 bytes at offset 12840960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12845056 ++read 2048/2048 bytes at offset 12845056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12849152 ++read 2048/2048 bytes at offset 12849152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12853248 ++read 2048/2048 bytes at offset 12853248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12857344 ++read 2048/2048 bytes at offset 12857344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12861440 ++read 2048/2048 bytes at offset 12861440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12865536 ++read 2048/2048 bytes at offset 12865536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12869632 ++read 2048/2048 bytes at offset 12869632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12873728 ++read 2048/2048 bytes at offset 12873728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12877824 ++read 2048/2048 bytes at offset 12877824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12881920 ++read 2048/2048 bytes at offset 12881920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12886016 ++read 2048/2048 bytes at offset 12886016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12890112 ++read 2048/2048 bytes at offset 12890112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12894208 ++read 2048/2048 bytes at offset 12894208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12898304 ++read 2048/2048 bytes at offset 12898304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12902400 ++read 2048/2048 bytes at offset 12902400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12906496 ++read 2048/2048 bytes at offset 12906496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12910592 ++read 2048/2048 bytes at offset 12910592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12914688 ++read 2048/2048 bytes at offset 12914688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12918784 ++read 2048/2048 bytes at offset 12918784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12922880 ++read 2048/2048 bytes at offset 12922880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12926976 ++read 2048/2048 bytes at offset 12926976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12931072 ++read 2048/2048 bytes at offset 12931072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12935168 ++read 2048/2048 bytes at offset 12935168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12939264 ++read 2048/2048 bytes at offset 12939264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12943360 ++read 2048/2048 bytes at offset 12943360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12947456 ++read 2048/2048 bytes at offset 12947456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12951552 ++read 2048/2048 bytes at offset 12951552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12955648 ++read 2048/2048 bytes at offset 12955648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12959744 ++read 2048/2048 bytes at offset 12959744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12963840 ++read 2048/2048 bytes at offset 12963840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12967936 ++read 2048/2048 bytes at offset 12967936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12972032 ++read 2048/2048 bytes at offset 12972032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12976128 ++read 2048/2048 bytes at offset 12976128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12980224 ++read 2048/2048 bytes at offset 12980224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12984320 ++read 2048/2048 bytes at offset 12984320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12988416 ++read 2048/2048 bytes at offset 12988416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12992512 ++read 2048/2048 bytes at offset 12992512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 12996608 ++read 2048/2048 bytes at offset 12996608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13000704 ++read 2048/2048 bytes at offset 13000704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13004800 ++read 2048/2048 bytes at offset 13004800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13008896 ++read 2048/2048 bytes at offset 13008896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13012992 ++read 2048/2048 bytes at offset 13012992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13017088 ++read 2048/2048 bytes at offset 13017088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13021184 ++read 2048/2048 bytes at offset 13021184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13025280 ++read 2048/2048 bytes at offset 13025280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13029376 ++read 2048/2048 bytes at offset 13029376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13033472 ++read 2048/2048 bytes at offset 13033472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13037568 ++read 2048/2048 bytes at offset 13037568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13041664 ++read 2048/2048 bytes at offset 13041664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13045760 ++read 2048/2048 bytes at offset 13045760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13049856 ++read 2048/2048 bytes at offset 13049856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13053952 ++read 2048/2048 bytes at offset 13053952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13058048 ++read 2048/2048 bytes at offset 13058048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13062144 ++read 2048/2048 bytes at offset 13062144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13066240 ++read 2048/2048 bytes at offset 13066240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13070336 ++read 2048/2048 bytes at offset 13070336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13074432 ++read 2048/2048 bytes at offset 13074432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13078528 ++read 2048/2048 bytes at offset 13078528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13082624 ++read 2048/2048 bytes at offset 13082624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13086720 ++read 2048/2048 bytes at offset 13086720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13090816 ++read 2048/2048 bytes at offset 13090816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13094912 ++read 2048/2048 bytes at offset 13094912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13099008 ++read 2048/2048 bytes at offset 13099008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13103104 ++read 2048/2048 bytes at offset 13103104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13107200 ++read 2048/2048 bytes at offset 13107200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13111296 ++read 2048/2048 bytes at offset 13111296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13115392 ++read 2048/2048 bytes at offset 13115392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13119488 ++read 2048/2048 bytes at offset 13119488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13123584 ++read 2048/2048 bytes at offset 13123584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13127680 ++read 2048/2048 bytes at offset 13127680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13131776 ++read 2048/2048 bytes at offset 13131776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13135872 ++read 2048/2048 bytes at offset 13135872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13139968 ++read 2048/2048 bytes at offset 13139968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13144064 ++read 2048/2048 bytes at offset 13144064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13148160 ++read 2048/2048 bytes at offset 13148160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13152256 ++read 2048/2048 bytes at offset 13152256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13156352 ++read 2048/2048 bytes at offset 13156352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13160448 ++read 2048/2048 bytes at offset 13160448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13164544 ++read 2048/2048 bytes at offset 13164544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13168640 ++read 2048/2048 bytes at offset 13168640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13172736 ++read 2048/2048 bytes at offset 13172736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13176832 ++read 2048/2048 bytes at offset 13176832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13180928 ++read 2048/2048 bytes at offset 13180928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13185024 ++read 2048/2048 bytes at offset 13185024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13189120 ++read 2048/2048 bytes at offset 13189120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13193216 ++read 2048/2048 bytes at offset 13193216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13197312 ++read 2048/2048 bytes at offset 13197312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13201408 ++read 2048/2048 bytes at offset 13201408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13205504 ++read 2048/2048 bytes at offset 13205504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13209600 ++read 2048/2048 bytes at offset 13209600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13213696 ++read 2048/2048 bytes at offset 13213696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13217792 ++read 2048/2048 bytes at offset 13217792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13221888 ++read 2048/2048 bytes at offset 13221888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13225984 ++read 2048/2048 bytes at offset 13225984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13230080 ++read 2048/2048 bytes at offset 13230080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13234176 ++read 2048/2048 bytes at offset 13234176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13238272 ++read 2048/2048 bytes at offset 13238272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13242368 ++read 2048/2048 bytes at offset 13242368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13246464 ++read 2048/2048 bytes at offset 13246464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13250560 ++read 2048/2048 bytes at offset 13250560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13254656 ++read 2048/2048 bytes at offset 13254656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13258752 ++read 2048/2048 bytes at offset 13258752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13262848 ++read 2048/2048 bytes at offset 13262848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13266944 ++read 2048/2048 bytes at offset 13266944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13271040 ++read 2048/2048 bytes at offset 13271040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13275136 ++read 2048/2048 bytes at offset 13275136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13279232 ++read 2048/2048 bytes at offset 13279232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13283328 ++read 2048/2048 bytes at offset 13283328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13287424 ++read 2048/2048 bytes at offset 13287424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13291520 ++read 2048/2048 bytes at offset 13291520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13295616 ++read 2048/2048 bytes at offset 13295616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13299712 ++read 2048/2048 bytes at offset 13299712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13303808 ++read 2048/2048 bytes at offset 13303808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13307904 ++read 2048/2048 bytes at offset 13307904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13312000 ++read 2048/2048 bytes at offset 13312000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13316096 ++read 2048/2048 bytes at offset 13316096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13320192 ++read 2048/2048 bytes at offset 13320192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13324288 ++read 2048/2048 bytes at offset 13324288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13328384 ++read 2048/2048 bytes at offset 13328384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13332480 ++read 2048/2048 bytes at offset 13332480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13336576 ++read 2048/2048 bytes at offset 13336576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13340672 ++read 2048/2048 bytes at offset 13340672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13344768 ++read 2048/2048 bytes at offset 13344768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13348864 ++read 2048/2048 bytes at offset 13348864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13352960 ++read 2048/2048 bytes at offset 13352960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13357056 ++read 2048/2048 bytes at offset 13357056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13361152 ++read 2048/2048 bytes at offset 13361152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13365248 ++read 2048/2048 bytes at offset 13365248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13369344 ++read 2048/2048 bytes at offset 13369344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13373440 ++read 2048/2048 bytes at offset 13373440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13377536 ++read 2048/2048 bytes at offset 13377536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13381632 ++read 2048/2048 bytes at offset 13381632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13385728 ++read 2048/2048 bytes at offset 13385728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13389824 ++read 2048/2048 bytes at offset 13389824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13393920 ++read 2048/2048 bytes at offset 13393920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13398016 ++read 2048/2048 bytes at offset 13398016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13402112 ++read 2048/2048 bytes at offset 13402112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13406208 ++read 2048/2048 bytes at offset 13406208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13410304 ++read 2048/2048 bytes at offset 13410304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13414400 ++read 2048/2048 bytes at offset 13414400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13418496 ++read 2048/2048 bytes at offset 13418496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13422592 ++read 2048/2048 bytes at offset 13422592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13426688 ++read 2048/2048 bytes at offset 13426688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13430784 ++read 2048/2048 bytes at offset 13430784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13434880 ++read 2048/2048 bytes at offset 13434880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13438976 ++read 2048/2048 bytes at offset 13438976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13443072 ++read 2048/2048 bytes at offset 13443072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13447168 ++read 2048/2048 bytes at offset 13447168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13451264 ++read 2048/2048 bytes at offset 13451264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13455360 ++read 2048/2048 bytes at offset 13455360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13459456 ++read 2048/2048 bytes at offset 13459456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13463552 ++read 2048/2048 bytes at offset 13463552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13467648 ++read 2048/2048 bytes at offset 13467648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13471744 ++read 2048/2048 bytes at offset 13471744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13475840 ++read 2048/2048 bytes at offset 13475840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13479936 ++read 2048/2048 bytes at offset 13479936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13484032 ++read 2048/2048 bytes at offset 13484032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13488128 ++read 2048/2048 bytes at offset 13488128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13492224 ++read 2048/2048 bytes at offset 13492224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13496320 ++read 2048/2048 bytes at offset 13496320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13500416 ++read 2048/2048 bytes at offset 13500416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13504512 ++read 2048/2048 bytes at offset 13504512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13508608 ++read 2048/2048 bytes at offset 13508608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13512704 ++read 2048/2048 bytes at offset 13512704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13516800 ++read 2048/2048 bytes at offset 13516800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13520896 ++read 2048/2048 bytes at offset 13520896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13524992 ++read 2048/2048 bytes at offset 13524992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13529088 ++read 2048/2048 bytes at offset 13529088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13533184 ++read 2048/2048 bytes at offset 13533184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13537280 ++read 2048/2048 bytes at offset 13537280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13541376 ++read 2048/2048 bytes at offset 13541376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13545472 ++read 2048/2048 bytes at offset 13545472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13549568 ++read 2048/2048 bytes at offset 13549568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13553664 ++read 2048/2048 bytes at offset 13553664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13557760 ++read 2048/2048 bytes at offset 13557760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13561856 ++read 2048/2048 bytes at offset 13561856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13565952 ++read 2048/2048 bytes at offset 13565952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13570048 ++read 2048/2048 bytes at offset 13570048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13574144 ++read 2048/2048 bytes at offset 13574144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13578240 ++read 2048/2048 bytes at offset 13578240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13582336 ++read 2048/2048 bytes at offset 13582336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13586432 ++read 2048/2048 bytes at offset 13586432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13590528 ++read 2048/2048 bytes at offset 13590528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13594624 ++read 2048/2048 bytes at offset 13594624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13598720 ++read 2048/2048 bytes at offset 13598720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13602816 ++read 2048/2048 bytes at offset 13602816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13606912 ++read 2048/2048 bytes at offset 13606912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13611008 ++read 2048/2048 bytes at offset 13611008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13615104 ++read 2048/2048 bytes at offset 13615104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13619200 ++read 2048/2048 bytes at offset 13619200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13623296 ++read 2048/2048 bytes at offset 13623296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13627392 ++read 2048/2048 bytes at offset 13627392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 2 +-qemu-io> read 2048/2048 bytes at offset 13632512 ++=== IO: pattern 2 ++read 2048/2048 bytes at offset 13632512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13636608 ++read 2048/2048 bytes at offset 13636608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13640704 ++read 2048/2048 bytes at offset 13640704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13644800 ++read 2048/2048 bytes at offset 13644800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13648896 ++read 2048/2048 bytes at offset 13648896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13652992 ++read 2048/2048 bytes at offset 13652992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13657088 ++read 2048/2048 bytes at offset 13657088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13661184 ++read 2048/2048 bytes at offset 13661184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13665280 ++read 2048/2048 bytes at offset 13665280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13669376 ++read 2048/2048 bytes at offset 13669376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13673472 ++read 2048/2048 bytes at offset 13673472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13677568 ++read 2048/2048 bytes at offset 13677568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13681664 ++read 2048/2048 bytes at offset 13681664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13685760 ++read 2048/2048 bytes at offset 13685760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13689856 ++read 2048/2048 bytes at offset 13689856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13693952 ++read 2048/2048 bytes at offset 13693952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13698048 ++read 2048/2048 bytes at offset 13698048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13702144 ++read 2048/2048 bytes at offset 13702144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13706240 ++read 2048/2048 bytes at offset 13706240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13710336 ++read 2048/2048 bytes at offset 13710336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13714432 ++read 2048/2048 bytes at offset 13714432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13718528 ++read 2048/2048 bytes at offset 13718528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13722624 ++read 2048/2048 bytes at offset 13722624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13726720 ++read 2048/2048 bytes at offset 13726720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13730816 ++read 2048/2048 bytes at offset 13730816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13734912 ++read 2048/2048 bytes at offset 13734912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13739008 ++read 2048/2048 bytes at offset 13739008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13743104 ++read 2048/2048 bytes at offset 13743104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13747200 ++read 2048/2048 bytes at offset 13747200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13751296 ++read 2048/2048 bytes at offset 13751296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13755392 ++read 2048/2048 bytes at offset 13755392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13759488 ++read 2048/2048 bytes at offset 13759488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13763584 ++read 2048/2048 bytes at offset 13763584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13767680 ++read 2048/2048 bytes at offset 13767680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13771776 ++read 2048/2048 bytes at offset 13771776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13775872 ++read 2048/2048 bytes at offset 13775872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13779968 ++read 2048/2048 bytes at offset 13779968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13784064 ++read 2048/2048 bytes at offset 13784064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13788160 ++read 2048/2048 bytes at offset 13788160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13792256 ++read 2048/2048 bytes at offset 13792256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13796352 ++read 2048/2048 bytes at offset 13796352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13800448 ++read 2048/2048 bytes at offset 13800448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13804544 ++read 2048/2048 bytes at offset 13804544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13808640 ++read 2048/2048 bytes at offset 13808640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13812736 ++read 2048/2048 bytes at offset 13812736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13816832 ++read 2048/2048 bytes at offset 13816832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13820928 ++read 2048/2048 bytes at offset 13820928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13825024 ++read 2048/2048 bytes at offset 13825024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13829120 ++read 2048/2048 bytes at offset 13829120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13833216 ++read 2048/2048 bytes at offset 13833216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13837312 ++read 2048/2048 bytes at offset 13837312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13841408 ++read 2048/2048 bytes at offset 13841408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13845504 ++read 2048/2048 bytes at offset 13845504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13849600 ++read 2048/2048 bytes at offset 13849600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13853696 ++read 2048/2048 bytes at offset 13853696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13857792 ++read 2048/2048 bytes at offset 13857792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13861888 ++read 2048/2048 bytes at offset 13861888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13865984 ++read 2048/2048 bytes at offset 13865984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13870080 ++read 2048/2048 bytes at offset 13870080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13874176 ++read 2048/2048 bytes at offset 13874176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13878272 ++read 2048/2048 bytes at offset 13878272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13882368 ++read 2048/2048 bytes at offset 13882368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13886464 ++read 2048/2048 bytes at offset 13886464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13890560 ++read 2048/2048 bytes at offset 13890560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13894656 ++read 2048/2048 bytes at offset 13894656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13898752 ++read 2048/2048 bytes at offset 13898752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13902848 ++read 2048/2048 bytes at offset 13902848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13906944 ++read 2048/2048 bytes at offset 13906944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13911040 ++read 2048/2048 bytes at offset 13911040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13915136 ++read 2048/2048 bytes at offset 13915136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13919232 ++read 2048/2048 bytes at offset 13919232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13923328 ++read 2048/2048 bytes at offset 13923328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13927424 ++read 2048/2048 bytes at offset 13927424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13931520 ++read 2048/2048 bytes at offset 13931520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13935616 ++read 2048/2048 bytes at offset 13935616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13939712 ++read 2048/2048 bytes at offset 13939712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13943808 ++read 2048/2048 bytes at offset 13943808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13947904 ++read 2048/2048 bytes at offset 13947904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13952000 ++read 2048/2048 bytes at offset 13952000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13956096 ++read 2048/2048 bytes at offset 13956096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13960192 ++read 2048/2048 bytes at offset 13960192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13964288 ++read 2048/2048 bytes at offset 13964288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13968384 ++read 2048/2048 bytes at offset 13968384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13972480 ++read 2048/2048 bytes at offset 13972480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13976576 ++read 2048/2048 bytes at offset 13976576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13980672 ++read 2048/2048 bytes at offset 13980672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13984768 ++read 2048/2048 bytes at offset 13984768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13988864 ++read 2048/2048 bytes at offset 13988864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13992960 ++read 2048/2048 bytes at offset 13992960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 13997056 ++read 2048/2048 bytes at offset 13997056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14001152 ++read 2048/2048 bytes at offset 14001152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14005248 ++read 2048/2048 bytes at offset 14005248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14009344 ++read 2048/2048 bytes at offset 14009344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14013440 ++read 2048/2048 bytes at offset 14013440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14017536 ++read 2048/2048 bytes at offset 14017536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14021632 ++read 2048/2048 bytes at offset 14021632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14025728 ++read 2048/2048 bytes at offset 14025728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14029824 ++read 2048/2048 bytes at offset 14029824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14033920 ++read 2048/2048 bytes at offset 14033920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14038016 ++read 2048/2048 bytes at offset 14038016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14042112 ++read 2048/2048 bytes at offset 14042112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14046208 ++read 2048/2048 bytes at offset 14046208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14050304 ++read 2048/2048 bytes at offset 14050304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14054400 ++read 2048/2048 bytes at offset 14054400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14058496 ++read 2048/2048 bytes at offset 14058496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14062592 ++read 2048/2048 bytes at offset 14062592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14066688 ++read 2048/2048 bytes at offset 14066688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14070784 ++read 2048/2048 bytes at offset 14070784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14074880 ++read 2048/2048 bytes at offset 14074880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14078976 ++read 2048/2048 bytes at offset 14078976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14083072 ++read 2048/2048 bytes at offset 14083072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14087168 ++read 2048/2048 bytes at offset 14087168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14091264 ++read 2048/2048 bytes at offset 14091264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14095360 ++read 2048/2048 bytes at offset 14095360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14099456 ++read 2048/2048 bytes at offset 14099456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14103552 ++read 2048/2048 bytes at offset 14103552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14107648 ++read 2048/2048 bytes at offset 14107648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14111744 ++read 2048/2048 bytes at offset 14111744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14115840 ++read 2048/2048 bytes at offset 14115840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14119936 ++read 2048/2048 bytes at offset 14119936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14124032 ++read 2048/2048 bytes at offset 14124032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14128128 ++read 2048/2048 bytes at offset 14128128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14132224 ++read 2048/2048 bytes at offset 14132224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14136320 ++read 2048/2048 bytes at offset 14136320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14140416 ++read 2048/2048 bytes at offset 14140416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14144512 ++read 2048/2048 bytes at offset 14144512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14148608 ++read 2048/2048 bytes at offset 14148608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14152704 ++read 2048/2048 bytes at offset 14152704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14156800 ++read 2048/2048 bytes at offset 14156800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14160896 ++read 2048/2048 bytes at offset 14160896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14164992 ++read 2048/2048 bytes at offset 14164992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14169088 ++read 2048/2048 bytes at offset 14169088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14173184 ++read 2048/2048 bytes at offset 14173184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14177280 ++read 2048/2048 bytes at offset 14177280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14181376 ++read 2048/2048 bytes at offset 14181376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14185472 ++read 2048/2048 bytes at offset 14185472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14189568 ++read 2048/2048 bytes at offset 14189568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14193664 ++read 2048/2048 bytes at offset 14193664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14197760 ++read 2048/2048 bytes at offset 14197760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14201856 ++read 2048/2048 bytes at offset 14201856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14205952 ++read 2048/2048 bytes at offset 14205952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14210048 ++read 2048/2048 bytes at offset 14210048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14214144 ++read 2048/2048 bytes at offset 14214144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14218240 ++read 2048/2048 bytes at offset 14218240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14222336 ++read 2048/2048 bytes at offset 14222336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14226432 ++read 2048/2048 bytes at offset 14226432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14230528 ++read 2048/2048 bytes at offset 14230528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14234624 ++read 2048/2048 bytes at offset 14234624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14238720 ++read 2048/2048 bytes at offset 14238720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14242816 ++read 2048/2048 bytes at offset 14242816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14246912 ++read 2048/2048 bytes at offset 14246912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14251008 ++read 2048/2048 bytes at offset 14251008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14255104 ++read 2048/2048 bytes at offset 14255104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14259200 ++read 2048/2048 bytes at offset 14259200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14263296 ++read 2048/2048 bytes at offset 14263296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14267392 ++read 2048/2048 bytes at offset 14267392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14271488 ++read 2048/2048 bytes at offset 14271488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14275584 ++read 2048/2048 bytes at offset 14275584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14279680 ++read 2048/2048 bytes at offset 14279680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14283776 ++read 2048/2048 bytes at offset 14283776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14287872 ++read 2048/2048 bytes at offset 14287872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14291968 ++read 2048/2048 bytes at offset 14291968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14296064 ++read 2048/2048 bytes at offset 14296064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14300160 ++read 2048/2048 bytes at offset 14300160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14304256 ++read 2048/2048 bytes at offset 14304256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14308352 ++read 2048/2048 bytes at offset 14308352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14312448 ++read 2048/2048 bytes at offset 14312448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14316544 ++read 2048/2048 bytes at offset 14316544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14320640 ++read 2048/2048 bytes at offset 14320640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14324736 ++read 2048/2048 bytes at offset 14324736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14328832 ++read 2048/2048 bytes at offset 14328832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14332928 ++read 2048/2048 bytes at offset 14332928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14337024 ++read 2048/2048 bytes at offset 14337024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14341120 ++read 2048/2048 bytes at offset 14341120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14345216 ++read 2048/2048 bytes at offset 14345216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14349312 ++read 2048/2048 bytes at offset 14349312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14353408 ++read 2048/2048 bytes at offset 14353408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14357504 ++read 2048/2048 bytes at offset 14357504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14361600 ++read 2048/2048 bytes at offset 14361600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14365696 ++read 2048/2048 bytes at offset 14365696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14369792 ++read 2048/2048 bytes at offset 14369792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14373888 ++read 2048/2048 bytes at offset 14373888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14377984 ++read 2048/2048 bytes at offset 14377984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14382080 ++read 2048/2048 bytes at offset 14382080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14386176 ++read 2048/2048 bytes at offset 14386176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14390272 ++read 2048/2048 bytes at offset 14390272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14394368 ++read 2048/2048 bytes at offset 14394368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14398464 ++read 2048/2048 bytes at offset 14398464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14402560 ++read 2048/2048 bytes at offset 14402560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14406656 ++read 2048/2048 bytes at offset 14406656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14410752 ++read 2048/2048 bytes at offset 14410752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14414848 ++read 2048/2048 bytes at offset 14414848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14418944 ++read 2048/2048 bytes at offset 14418944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14423040 ++read 2048/2048 bytes at offset 14423040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14427136 ++read 2048/2048 bytes at offset 14427136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14431232 ++read 2048/2048 bytes at offset 14431232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14435328 ++read 2048/2048 bytes at offset 14435328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14439424 ++read 2048/2048 bytes at offset 14439424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14443520 ++read 2048/2048 bytes at offset 14443520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14447616 ++read 2048/2048 bytes at offset 14447616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14451712 ++read 2048/2048 bytes at offset 14451712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14455808 ++read 2048/2048 bytes at offset 14455808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14459904 ++read 2048/2048 bytes at offset 14459904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14464000 ++read 2048/2048 bytes at offset 14464000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14468096 ++read 2048/2048 bytes at offset 14468096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14472192 ++read 2048/2048 bytes at offset 14472192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14476288 ++read 2048/2048 bytes at offset 14476288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14480384 ++read 2048/2048 bytes at offset 14480384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14484480 ++read 2048/2048 bytes at offset 14484480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14488576 ++read 2048/2048 bytes at offset 14488576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14492672 ++read 2048/2048 bytes at offset 14492672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14496768 ++read 2048/2048 bytes at offset 14496768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14500864 ++read 2048/2048 bytes at offset 14500864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14504960 ++read 2048/2048 bytes at offset 14504960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14509056 ++read 2048/2048 bytes at offset 14509056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14513152 ++read 2048/2048 bytes at offset 14513152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14517248 ++read 2048/2048 bytes at offset 14517248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14521344 ++read 2048/2048 bytes at offset 14521344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14525440 ++read 2048/2048 bytes at offset 14525440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14529536 ++read 2048/2048 bytes at offset 14529536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14533632 ++read 2048/2048 bytes at offset 14533632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14537728 ++read 2048/2048 bytes at offset 14537728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14541824 ++read 2048/2048 bytes at offset 14541824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14545920 ++read 2048/2048 bytes at offset 14545920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14550016 ++read 2048/2048 bytes at offset 14550016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14554112 ++read 2048/2048 bytes at offset 14554112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14558208 ++read 2048/2048 bytes at offset 14558208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14562304 ++read 2048/2048 bytes at offset 14562304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14566400 ++read 2048/2048 bytes at offset 14566400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14570496 ++read 2048/2048 bytes at offset 14570496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14574592 ++read 2048/2048 bytes at offset 14574592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14578688 ++read 2048/2048 bytes at offset 14578688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14582784 ++read 2048/2048 bytes at offset 14582784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14586880 ++read 2048/2048 bytes at offset 14586880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14590976 ++read 2048/2048 bytes at offset 14590976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14595072 ++read 2048/2048 bytes at offset 14595072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14599168 ++read 2048/2048 bytes at offset 14599168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14603264 ++read 2048/2048 bytes at offset 14603264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14607360 ++read 2048/2048 bytes at offset 14607360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14611456 ++read 2048/2048 bytes at offset 14611456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14615552 ++read 2048/2048 bytes at offset 14615552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14619648 ++read 2048/2048 bytes at offset 14619648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14623744 ++read 2048/2048 bytes at offset 14623744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14627840 ++read 2048/2048 bytes at offset 14627840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14631936 ++read 2048/2048 bytes at offset 14631936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14636032 ++read 2048/2048 bytes at offset 14636032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14640128 ++read 2048/2048 bytes at offset 14640128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14644224 ++read 2048/2048 bytes at offset 14644224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14648320 ++read 2048/2048 bytes at offset 14648320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14652416 ++read 2048/2048 bytes at offset 14652416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14656512 ++read 2048/2048 bytes at offset 14656512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14660608 ++read 2048/2048 bytes at offset 14660608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14664704 ++read 2048/2048 bytes at offset 14664704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14668800 ++read 2048/2048 bytes at offset 14668800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14672896 ++read 2048/2048 bytes at offset 14672896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 14676992 ++read 2048/2048 bytes at offset 14676992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 4 +-qemu-io> read 8192/8192 bytes at offset 14682112 ++=== IO: pattern 4 ++read 8192/8192 bytes at offset 14682112 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 14694400 ++read 8192/8192 bytes at offset 14694400 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 14706688 ++read 8192/8192 bytes at offset 14706688 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 14718976 ++read 8192/8192 bytes at offset 14718976 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 14731264 ++read 8192/8192 bytes at offset 14731264 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 14743552 ++read 8192/8192 bytes at offset 14743552 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 14755840 ++read 8192/8192 bytes at offset 14755840 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 14768128 ++read 8192/8192 bytes at offset 14768128 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 14780416 ++read 8192/8192 bytes at offset 14780416 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 14792704 ++read 8192/8192 bytes at offset 14792704 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 14804992 ++read 8192/8192 bytes at offset 14804992 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 14817280 ++read 8192/8192 bytes at offset 14817280 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 14829568 ++read 8192/8192 bytes at offset 14829568 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 14841856 ++read 8192/8192 bytes at offset 14841856 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 14854144 ++read 8192/8192 bytes at offset 14854144 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 14866432 ++read 8192/8192 bytes at offset 14866432 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 14878720 ++read 8192/8192 bytes at offset 14878720 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 14891008 ++read 8192/8192 bytes at offset 14891008 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 14903296 ++read 8192/8192 bytes at offset 14903296 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 14915584 ++read 8192/8192 bytes at offset 14915584 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 14927872 ++read 8192/8192 bytes at offset 14927872 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 14940160 ++read 8192/8192 bytes at offset 14940160 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 14952448 ++read 8192/8192 bytes at offset 14952448 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 14964736 ++read 8192/8192 bytes at offset 14964736 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 14977024 ++read 8192/8192 bytes at offset 14977024 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 14989312 ++read 8192/8192 bytes at offset 14989312 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 15001600 ++read 8192/8192 bytes at offset 15001600 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 15013888 ++read 8192/8192 bytes at offset 15013888 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 15026176 ++read 8192/8192 bytes at offset 15026176 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 15038464 ++read 8192/8192 bytes at offset 15038464 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 15050752 ++read 8192/8192 bytes at offset 15050752 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 15063040 ++read 8192/8192 bytes at offset 15063040 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 15075328 ++read 8192/8192 bytes at offset 15075328 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 15087616 ++read 8192/8192 bytes at offset 15087616 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 15099904 ++read 8192/8192 bytes at offset 15099904 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 15112192 ++read 8192/8192 bytes at offset 15112192 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 15124480 ++read 8192/8192 bytes at offset 15124480 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 15136768 ++read 8192/8192 bytes at offset 15136768 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 15149056 ++read 8192/8192 bytes at offset 15149056 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 15161344 ++read 8192/8192 bytes at offset 15161344 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 15173632 ++read 8192/8192 bytes at offset 15173632 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 15185920 ++read 8192/8192 bytes at offset 15185920 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 15198208 ++read 8192/8192 bytes at offset 15198208 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 15210496 ++read 8192/8192 bytes at offset 15210496 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 15222784 ++read 8192/8192 bytes at offset 15222784 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 15235072 ++read 8192/8192 bytes at offset 15235072 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 15247360 ++read 8192/8192 bytes at offset 15247360 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 15259648 ++read 8192/8192 bytes at offset 15259648 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 15271936 ++read 8192/8192 bytes at offset 15271936 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 15284224 ++read 8192/8192 bytes at offset 15284224 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 15296512 ++read 8192/8192 bytes at offset 15296512 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 15308800 ++read 8192/8192 bytes at offset 15308800 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 15321088 ++read 8192/8192 bytes at offset 15321088 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 15333376 ++read 8192/8192 bytes at offset 15333376 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 15345664 ++read 8192/8192 bytes at offset 15345664 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 15357952 ++read 8192/8192 bytes at offset 15357952 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 15370240 ++read 8192/8192 bytes at offset 15370240 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 15382528 ++read 8192/8192 bytes at offset 15382528 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 15394816 ++read 8192/8192 bytes at offset 15394816 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 15407104 ++read 8192/8192 bytes at offset 15407104 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 15419392 ++read 8192/8192 bytes at offset 15419392 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 15431680 ++read 8192/8192 bytes at offset 15431680 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 15443968 ++read 8192/8192 bytes at offset 15443968 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 15456256 ++read 8192/8192 bytes at offset 15456256 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 244 +-qemu-io> read 12288/12288 bytes at offset 16771072 ++=== IO: pattern 244 ++read 12288/12288 bytes at offset 16771072 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 18870272 ++read 12288/12288 bytes at offset 18870272 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 20969472 ++read 12288/12288 bytes at offset 20969472 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 23068672 ++read 12288/12288 bytes at offset 23068672 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 25167872 ++read 12288/12288 bytes at offset 25167872 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 27267072 ++read 12288/12288 bytes at offset 27267072 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 29366272 ++read 12288/12288 bytes at offset 29366272 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 31465472 ++read 12288/12288 bytes at offset 31465472 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> No errors were found on the image. ++No errors were found on the image. + At offset 4294967296: + === IO: pattern 0 +-qemu-io> wrote 4096/4096 bytes at offset 4294967296 ++wrote 4096/4096 bytes at offset 4294967296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4294971392 ++wrote 4096/4096 bytes at offset 4294971392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4294975488 ++wrote 4096/4096 bytes at offset 4294975488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4294979584 ++wrote 4096/4096 bytes at offset 4294979584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4294983680 ++wrote 4096/4096 bytes at offset 4294983680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4294987776 ++wrote 4096/4096 bytes at offset 4294987776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4294991872 ++wrote 4096/4096 bytes at offset 4294991872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4294995968 ++wrote 4096/4096 bytes at offset 4294995968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295000064 ++wrote 4096/4096 bytes at offset 4295000064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295004160 ++wrote 4096/4096 bytes at offset 4295004160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295008256 ++wrote 4096/4096 bytes at offset 4295008256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295012352 ++wrote 4096/4096 bytes at offset 4295012352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295016448 ++wrote 4096/4096 bytes at offset 4295016448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295020544 ++wrote 4096/4096 bytes at offset 4295020544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295024640 ++wrote 4096/4096 bytes at offset 4295024640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295028736 ++wrote 4096/4096 bytes at offset 4295028736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295032832 ++wrote 4096/4096 bytes at offset 4295032832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295036928 ++wrote 4096/4096 bytes at offset 4295036928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295041024 ++wrote 4096/4096 bytes at offset 4295041024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295045120 ++wrote 4096/4096 bytes at offset 4295045120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295049216 ++wrote 4096/4096 bytes at offset 4295049216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295053312 ++wrote 4096/4096 bytes at offset 4295053312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295057408 ++wrote 4096/4096 bytes at offset 4295057408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295061504 ++wrote 4096/4096 bytes at offset 4295061504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295065600 ++wrote 4096/4096 bytes at offset 4295065600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295069696 ++wrote 4096/4096 bytes at offset 4295069696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295073792 ++wrote 4096/4096 bytes at offset 4295073792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295077888 ++wrote 4096/4096 bytes at offset 4295077888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295081984 ++wrote 4096/4096 bytes at offset 4295081984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295086080 ++wrote 4096/4096 bytes at offset 4295086080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295090176 ++wrote 4096/4096 bytes at offset 4295090176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295094272 ++wrote 4096/4096 bytes at offset 4295094272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295098368 ++wrote 4096/4096 bytes at offset 4295098368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295102464 ++wrote 4096/4096 bytes at offset 4295102464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295106560 ++wrote 4096/4096 bytes at offset 4295106560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295110656 ++wrote 4096/4096 bytes at offset 4295110656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295114752 ++wrote 4096/4096 bytes at offset 4295114752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295118848 ++wrote 4096/4096 bytes at offset 4295118848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295122944 ++wrote 4096/4096 bytes at offset 4295122944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295127040 ++wrote 4096/4096 bytes at offset 4295127040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295131136 ++wrote 4096/4096 bytes at offset 4295131136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295135232 ++wrote 4096/4096 bytes at offset 4295135232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295139328 ++wrote 4096/4096 bytes at offset 4295139328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295143424 ++wrote 4096/4096 bytes at offset 4295143424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295147520 ++wrote 4096/4096 bytes at offset 4295147520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295151616 ++wrote 4096/4096 bytes at offset 4295151616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295155712 ++wrote 4096/4096 bytes at offset 4295155712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295159808 ++wrote 4096/4096 bytes at offset 4295159808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295163904 ++wrote 4096/4096 bytes at offset 4295163904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295168000 ++wrote 4096/4096 bytes at offset 4295168000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295172096 ++wrote 4096/4096 bytes at offset 4295172096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295176192 ++wrote 4096/4096 bytes at offset 4295176192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295180288 ++wrote 4096/4096 bytes at offset 4295180288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295184384 ++wrote 4096/4096 bytes at offset 4295184384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295188480 ++wrote 4096/4096 bytes at offset 4295188480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295192576 ++wrote 4096/4096 bytes at offset 4295192576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295196672 ++wrote 4096/4096 bytes at offset 4295196672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295200768 ++wrote 4096/4096 bytes at offset 4295200768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295204864 ++wrote 4096/4096 bytes at offset 4295204864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295208960 ++wrote 4096/4096 bytes at offset 4295208960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295213056 ++wrote 4096/4096 bytes at offset 4295213056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295217152 ++wrote 4096/4096 bytes at offset 4295217152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295221248 ++wrote 4096/4096 bytes at offset 4295221248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295225344 ++wrote 4096/4096 bytes at offset 4295225344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295229440 ++wrote 4096/4096 bytes at offset 4295229440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295233536 ++wrote 4096/4096 bytes at offset 4295233536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295237632 ++wrote 4096/4096 bytes at offset 4295237632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295241728 ++wrote 4096/4096 bytes at offset 4295241728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295245824 ++wrote 4096/4096 bytes at offset 4295245824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295249920 ++wrote 4096/4096 bytes at offset 4295249920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295254016 ++wrote 4096/4096 bytes at offset 4295254016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295258112 ++wrote 4096/4096 bytes at offset 4295258112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295262208 ++wrote 4096/4096 bytes at offset 4295262208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295266304 ++wrote 4096/4096 bytes at offset 4295266304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295270400 ++wrote 4096/4096 bytes at offset 4295270400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295274496 ++wrote 4096/4096 bytes at offset 4295274496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295278592 ++wrote 4096/4096 bytes at offset 4295278592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295282688 ++wrote 4096/4096 bytes at offset 4295282688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295286784 ++wrote 4096/4096 bytes at offset 4295286784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295290880 ++wrote 4096/4096 bytes at offset 4295290880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295294976 ++wrote 4096/4096 bytes at offset 4295294976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295299072 ++wrote 4096/4096 bytes at offset 4295299072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295303168 ++wrote 4096/4096 bytes at offset 4295303168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295307264 ++wrote 4096/4096 bytes at offset 4295307264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295311360 ++wrote 4096/4096 bytes at offset 4295311360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295315456 ++wrote 4096/4096 bytes at offset 4295315456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295319552 ++wrote 4096/4096 bytes at offset 4295319552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295323648 ++wrote 4096/4096 bytes at offset 4295323648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295327744 ++wrote 4096/4096 bytes at offset 4295327744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295331840 ++wrote 4096/4096 bytes at offset 4295331840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295335936 ++wrote 4096/4096 bytes at offset 4295335936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295340032 ++wrote 4096/4096 bytes at offset 4295340032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295344128 ++wrote 4096/4096 bytes at offset 4295344128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295348224 ++wrote 4096/4096 bytes at offset 4295348224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295352320 ++wrote 4096/4096 bytes at offset 4295352320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295356416 ++wrote 4096/4096 bytes at offset 4295356416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295360512 ++wrote 4096/4096 bytes at offset 4295360512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295364608 ++wrote 4096/4096 bytes at offset 4295364608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295368704 ++wrote 4096/4096 bytes at offset 4295368704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295372800 ++wrote 4096/4096 bytes at offset 4295372800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295376896 ++wrote 4096/4096 bytes at offset 4295376896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295380992 ++wrote 4096/4096 bytes at offset 4295380992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295385088 ++wrote 4096/4096 bytes at offset 4295385088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295389184 ++wrote 4096/4096 bytes at offset 4295389184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295393280 ++wrote 4096/4096 bytes at offset 4295393280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295397376 ++wrote 4096/4096 bytes at offset 4295397376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295401472 ++wrote 4096/4096 bytes at offset 4295401472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295405568 ++wrote 4096/4096 bytes at offset 4295405568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295409664 ++wrote 4096/4096 bytes at offset 4295409664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295413760 ++wrote 4096/4096 bytes at offset 4295413760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295417856 ++wrote 4096/4096 bytes at offset 4295417856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295421952 ++wrote 4096/4096 bytes at offset 4295421952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295426048 ++wrote 4096/4096 bytes at offset 4295426048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295430144 ++wrote 4096/4096 bytes at offset 4295430144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295434240 ++wrote 4096/4096 bytes at offset 4295434240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295438336 ++wrote 4096/4096 bytes at offset 4295438336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295442432 ++wrote 4096/4096 bytes at offset 4295442432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295446528 ++wrote 4096/4096 bytes at offset 4295446528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295450624 ++wrote 4096/4096 bytes at offset 4295450624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295454720 ++wrote 4096/4096 bytes at offset 4295454720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295458816 ++wrote 4096/4096 bytes at offset 4295458816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295462912 ++wrote 4096/4096 bytes at offset 4295462912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295467008 ++wrote 4096/4096 bytes at offset 4295467008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295471104 ++wrote 4096/4096 bytes at offset 4295471104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295475200 ++wrote 4096/4096 bytes at offset 4295475200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295479296 ++wrote 4096/4096 bytes at offset 4295479296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295483392 ++wrote 4096/4096 bytes at offset 4295483392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295487488 ++wrote 4096/4096 bytes at offset 4295487488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295491584 ++wrote 4096/4096 bytes at offset 4295491584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295495680 ++wrote 4096/4096 bytes at offset 4295495680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295499776 ++wrote 4096/4096 bytes at offset 4295499776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295503872 ++wrote 4096/4096 bytes at offset 4295503872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295507968 ++wrote 4096/4096 bytes at offset 4295507968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295512064 ++wrote 4096/4096 bytes at offset 4295512064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295516160 ++wrote 4096/4096 bytes at offset 4295516160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295520256 ++wrote 4096/4096 bytes at offset 4295520256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295524352 ++wrote 4096/4096 bytes at offset 4295524352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295528448 ++wrote 4096/4096 bytes at offset 4295528448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295532544 ++wrote 4096/4096 bytes at offset 4295532544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295536640 ++wrote 4096/4096 bytes at offset 4295536640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295540736 ++wrote 4096/4096 bytes at offset 4295540736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295544832 ++wrote 4096/4096 bytes at offset 4295544832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295548928 ++wrote 4096/4096 bytes at offset 4295548928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295553024 ++wrote 4096/4096 bytes at offset 4295553024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295557120 ++wrote 4096/4096 bytes at offset 4295557120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295561216 ++wrote 4096/4096 bytes at offset 4295561216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295565312 ++wrote 4096/4096 bytes at offset 4295565312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295569408 ++wrote 4096/4096 bytes at offset 4295569408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295573504 ++wrote 4096/4096 bytes at offset 4295573504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295577600 ++wrote 4096/4096 bytes at offset 4295577600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295581696 ++wrote 4096/4096 bytes at offset 4295581696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295585792 ++wrote 4096/4096 bytes at offset 4295585792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295589888 ++wrote 4096/4096 bytes at offset 4295589888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295593984 ++wrote 4096/4096 bytes at offset 4295593984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295598080 ++wrote 4096/4096 bytes at offset 4295598080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295602176 ++wrote 4096/4096 bytes at offset 4295602176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295606272 ++wrote 4096/4096 bytes at offset 4295606272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295610368 ++wrote 4096/4096 bytes at offset 4295610368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295614464 ++wrote 4096/4096 bytes at offset 4295614464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295618560 ++wrote 4096/4096 bytes at offset 4295618560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295622656 ++wrote 4096/4096 bytes at offset 4295622656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295626752 ++wrote 4096/4096 bytes at offset 4295626752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295630848 ++wrote 4096/4096 bytes at offset 4295630848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295634944 ++wrote 4096/4096 bytes at offset 4295634944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295639040 ++wrote 4096/4096 bytes at offset 4295639040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295643136 ++wrote 4096/4096 bytes at offset 4295643136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295647232 ++wrote 4096/4096 bytes at offset 4295647232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295651328 ++wrote 4096/4096 bytes at offset 4295651328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295655424 ++wrote 4096/4096 bytes at offset 4295655424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295659520 ++wrote 4096/4096 bytes at offset 4295659520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295663616 ++wrote 4096/4096 bytes at offset 4295663616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295667712 ++wrote 4096/4096 bytes at offset 4295667712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295671808 ++wrote 4096/4096 bytes at offset 4295671808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295675904 ++wrote 4096/4096 bytes at offset 4295675904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295680000 ++wrote 4096/4096 bytes at offset 4295680000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295684096 ++wrote 4096/4096 bytes at offset 4295684096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295688192 ++wrote 4096/4096 bytes at offset 4295688192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295692288 ++wrote 4096/4096 bytes at offset 4295692288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295696384 ++wrote 4096/4096 bytes at offset 4295696384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295700480 ++wrote 4096/4096 bytes at offset 4295700480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295704576 ++wrote 4096/4096 bytes at offset 4295704576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295708672 ++wrote 4096/4096 bytes at offset 4295708672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295712768 ++wrote 4096/4096 bytes at offset 4295712768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295716864 ++wrote 4096/4096 bytes at offset 4295716864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295720960 ++wrote 4096/4096 bytes at offset 4295720960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295725056 ++wrote 4096/4096 bytes at offset 4295725056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295729152 ++wrote 4096/4096 bytes at offset 4295729152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295733248 ++wrote 4096/4096 bytes at offset 4295733248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295737344 ++wrote 4096/4096 bytes at offset 4295737344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295741440 ++wrote 4096/4096 bytes at offset 4295741440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295745536 ++wrote 4096/4096 bytes at offset 4295745536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295749632 ++wrote 4096/4096 bytes at offset 4295749632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295753728 ++wrote 4096/4096 bytes at offset 4295753728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295757824 ++wrote 4096/4096 bytes at offset 4295757824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295761920 ++wrote 4096/4096 bytes at offset 4295761920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295766016 ++wrote 4096/4096 bytes at offset 4295766016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295770112 ++wrote 4096/4096 bytes at offset 4295770112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295774208 ++wrote 4096/4096 bytes at offset 4295774208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295778304 ++wrote 4096/4096 bytes at offset 4295778304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295782400 ++wrote 4096/4096 bytes at offset 4295782400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295786496 ++wrote 4096/4096 bytes at offset 4295786496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295790592 ++wrote 4096/4096 bytes at offset 4295790592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295794688 ++wrote 4096/4096 bytes at offset 4295794688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295798784 ++wrote 4096/4096 bytes at offset 4295798784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295802880 ++wrote 4096/4096 bytes at offset 4295802880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295806976 ++wrote 4096/4096 bytes at offset 4295806976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295811072 ++wrote 4096/4096 bytes at offset 4295811072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295815168 ++wrote 4096/4096 bytes at offset 4295815168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295819264 ++wrote 4096/4096 bytes at offset 4295819264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295823360 ++wrote 4096/4096 bytes at offset 4295823360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295827456 ++wrote 4096/4096 bytes at offset 4295827456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295831552 ++wrote 4096/4096 bytes at offset 4295831552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295835648 ++wrote 4096/4096 bytes at offset 4295835648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295839744 ++wrote 4096/4096 bytes at offset 4295839744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295843840 ++wrote 4096/4096 bytes at offset 4295843840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295847936 ++wrote 4096/4096 bytes at offset 4295847936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295852032 ++wrote 4096/4096 bytes at offset 4295852032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295856128 ++wrote 4096/4096 bytes at offset 4295856128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295860224 ++wrote 4096/4096 bytes at offset 4295860224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295864320 ++wrote 4096/4096 bytes at offset 4295864320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295868416 ++wrote 4096/4096 bytes at offset 4295868416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295872512 ++wrote 4096/4096 bytes at offset 4295872512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295876608 ++wrote 4096/4096 bytes at offset 4295876608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295880704 ++wrote 4096/4096 bytes at offset 4295880704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295884800 ++wrote 4096/4096 bytes at offset 4295884800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295888896 ++wrote 4096/4096 bytes at offset 4295888896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295892992 ++wrote 4096/4096 bytes at offset 4295892992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295897088 ++wrote 4096/4096 bytes at offset 4295897088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295901184 ++wrote 4096/4096 bytes at offset 4295901184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295905280 ++wrote 4096/4096 bytes at offset 4295905280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295909376 ++wrote 4096/4096 bytes at offset 4295909376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295913472 ++wrote 4096/4096 bytes at offset 4295913472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295917568 ++wrote 4096/4096 bytes at offset 4295917568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295921664 ++wrote 4096/4096 bytes at offset 4295921664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295925760 ++wrote 4096/4096 bytes at offset 4295925760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295929856 ++wrote 4096/4096 bytes at offset 4295929856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295933952 ++wrote 4096/4096 bytes at offset 4295933952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295938048 ++wrote 4096/4096 bytes at offset 4295938048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295942144 ++wrote 4096/4096 bytes at offset 4295942144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295946240 ++wrote 4096/4096 bytes at offset 4295946240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295950336 ++wrote 4096/4096 bytes at offset 4295950336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295954432 ++wrote 4096/4096 bytes at offset 4295954432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295958528 ++wrote 4096/4096 bytes at offset 4295958528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295962624 ++wrote 4096/4096 bytes at offset 4295962624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295966720 ++wrote 4096/4096 bytes at offset 4295966720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295970816 ++wrote 4096/4096 bytes at offset 4295970816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295974912 ++wrote 4096/4096 bytes at offset 4295974912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295979008 ++wrote 4096/4096 bytes at offset 4295979008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295983104 ++wrote 4096/4096 bytes at offset 4295983104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295987200 ++wrote 4096/4096 bytes at offset 4295987200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295991296 ++wrote 4096/4096 bytes at offset 4295991296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295995392 ++wrote 4096/4096 bytes at offset 4295995392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295999488 ++wrote 4096/4096 bytes at offset 4295999488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296003584 ++wrote 4096/4096 bytes at offset 4296003584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296007680 ++wrote 4096/4096 bytes at offset 4296007680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4296011776 ++wrote 4096/4096 bytes at offset 4296011776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 4 +-qemu-io> wrote 2048/2048 bytes at offset 4296017920 ++=== IO: pattern 4 ++wrote 2048/2048 bytes at offset 4296017920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296022016 ++wrote 2048/2048 bytes at offset 4296022016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296026112 ++wrote 2048/2048 bytes at offset 4296026112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296030208 ++wrote 2048/2048 bytes at offset 4296030208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296034304 ++wrote 2048/2048 bytes at offset 4296034304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296038400 ++wrote 2048/2048 bytes at offset 4296038400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296042496 ++wrote 2048/2048 bytes at offset 4296042496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296046592 ++wrote 2048/2048 bytes at offset 4296046592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296050688 ++wrote 2048/2048 bytes at offset 4296050688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296054784 ++wrote 2048/2048 bytes at offset 4296054784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296058880 ++wrote 2048/2048 bytes at offset 4296058880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296062976 ++wrote 2048/2048 bytes at offset 4296062976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296067072 ++wrote 2048/2048 bytes at offset 4296067072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296071168 ++wrote 2048/2048 bytes at offset 4296071168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296075264 ++wrote 2048/2048 bytes at offset 4296075264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296079360 ++wrote 2048/2048 bytes at offset 4296079360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296083456 ++wrote 2048/2048 bytes at offset 4296083456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296087552 ++wrote 2048/2048 bytes at offset 4296087552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296091648 ++wrote 2048/2048 bytes at offset 4296091648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296095744 ++wrote 2048/2048 bytes at offset 4296095744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296099840 ++wrote 2048/2048 bytes at offset 4296099840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296103936 ++wrote 2048/2048 bytes at offset 4296103936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296108032 ++wrote 2048/2048 bytes at offset 4296108032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296112128 ++wrote 2048/2048 bytes at offset 4296112128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296116224 ++wrote 2048/2048 bytes at offset 4296116224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296120320 ++wrote 2048/2048 bytes at offset 4296120320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296124416 ++wrote 2048/2048 bytes at offset 4296124416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296128512 ++wrote 2048/2048 bytes at offset 4296128512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296132608 ++wrote 2048/2048 bytes at offset 4296132608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296136704 ++wrote 2048/2048 bytes at offset 4296136704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296140800 ++wrote 2048/2048 bytes at offset 4296140800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296144896 ++wrote 2048/2048 bytes at offset 4296144896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296148992 ++wrote 2048/2048 bytes at offset 4296148992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296153088 ++wrote 2048/2048 bytes at offset 4296153088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296157184 ++wrote 2048/2048 bytes at offset 4296157184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296161280 ++wrote 2048/2048 bytes at offset 4296161280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296165376 ++wrote 2048/2048 bytes at offset 4296165376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296169472 ++wrote 2048/2048 bytes at offset 4296169472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296173568 ++wrote 2048/2048 bytes at offset 4296173568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296177664 ++wrote 2048/2048 bytes at offset 4296177664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296181760 ++wrote 2048/2048 bytes at offset 4296181760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296185856 ++wrote 2048/2048 bytes at offset 4296185856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296189952 ++wrote 2048/2048 bytes at offset 4296189952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296194048 ++wrote 2048/2048 bytes at offset 4296194048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296198144 ++wrote 2048/2048 bytes at offset 4296198144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296202240 ++wrote 2048/2048 bytes at offset 4296202240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296206336 ++wrote 2048/2048 bytes at offset 4296206336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296210432 ++wrote 2048/2048 bytes at offset 4296210432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296214528 ++wrote 2048/2048 bytes at offset 4296214528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296218624 ++wrote 2048/2048 bytes at offset 4296218624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296222720 ++wrote 2048/2048 bytes at offset 4296222720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296226816 ++wrote 2048/2048 bytes at offset 4296226816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296230912 ++wrote 2048/2048 bytes at offset 4296230912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296235008 ++wrote 2048/2048 bytes at offset 4296235008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296239104 ++wrote 2048/2048 bytes at offset 4296239104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296243200 ++wrote 2048/2048 bytes at offset 4296243200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296247296 ++wrote 2048/2048 bytes at offset 4296247296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296251392 ++wrote 2048/2048 bytes at offset 4296251392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296255488 ++wrote 2048/2048 bytes at offset 4296255488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296259584 ++wrote 2048/2048 bytes at offset 4296259584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296263680 ++wrote 2048/2048 bytes at offset 4296263680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296267776 ++wrote 2048/2048 bytes at offset 4296267776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296271872 ++wrote 2048/2048 bytes at offset 4296271872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296275968 ++wrote 2048/2048 bytes at offset 4296275968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296280064 ++wrote 2048/2048 bytes at offset 4296280064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296284160 ++wrote 2048/2048 bytes at offset 4296284160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296288256 ++wrote 2048/2048 bytes at offset 4296288256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296292352 ++wrote 2048/2048 bytes at offset 4296292352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296296448 ++wrote 2048/2048 bytes at offset 4296296448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296300544 ++wrote 2048/2048 bytes at offset 4296300544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296304640 ++wrote 2048/2048 bytes at offset 4296304640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296308736 ++wrote 2048/2048 bytes at offset 4296308736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296312832 ++wrote 2048/2048 bytes at offset 4296312832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296316928 ++wrote 2048/2048 bytes at offset 4296316928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296321024 ++wrote 2048/2048 bytes at offset 4296321024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296325120 ++wrote 2048/2048 bytes at offset 4296325120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296329216 ++wrote 2048/2048 bytes at offset 4296329216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296333312 ++wrote 2048/2048 bytes at offset 4296333312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296337408 ++wrote 2048/2048 bytes at offset 4296337408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296341504 ++wrote 2048/2048 bytes at offset 4296341504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296345600 ++wrote 2048/2048 bytes at offset 4296345600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296349696 ++wrote 2048/2048 bytes at offset 4296349696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296353792 ++wrote 2048/2048 bytes at offset 4296353792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296357888 ++wrote 2048/2048 bytes at offset 4296357888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296361984 ++wrote 2048/2048 bytes at offset 4296361984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296366080 ++wrote 2048/2048 bytes at offset 4296366080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296370176 ++wrote 2048/2048 bytes at offset 4296370176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296374272 ++wrote 2048/2048 bytes at offset 4296374272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296378368 ++wrote 2048/2048 bytes at offset 4296378368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296382464 ++wrote 2048/2048 bytes at offset 4296382464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296386560 ++wrote 2048/2048 bytes at offset 4296386560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296390656 ++wrote 2048/2048 bytes at offset 4296390656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296394752 ++wrote 2048/2048 bytes at offset 4296394752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296398848 ++wrote 2048/2048 bytes at offset 4296398848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296402944 ++wrote 2048/2048 bytes at offset 4296402944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296407040 ++wrote 2048/2048 bytes at offset 4296407040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296411136 ++wrote 2048/2048 bytes at offset 4296411136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296415232 ++wrote 2048/2048 bytes at offset 4296415232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296419328 ++wrote 2048/2048 bytes at offset 4296419328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296423424 ++wrote 2048/2048 bytes at offset 4296423424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296427520 ++wrote 2048/2048 bytes at offset 4296427520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296431616 ++wrote 2048/2048 bytes at offset 4296431616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296435712 ++wrote 2048/2048 bytes at offset 4296435712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296439808 ++wrote 2048/2048 bytes at offset 4296439808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296443904 ++wrote 2048/2048 bytes at offset 4296443904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296448000 ++wrote 2048/2048 bytes at offset 4296448000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296452096 ++wrote 2048/2048 bytes at offset 4296452096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296456192 ++wrote 2048/2048 bytes at offset 4296456192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296460288 ++wrote 2048/2048 bytes at offset 4296460288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296464384 ++wrote 2048/2048 bytes at offset 4296464384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296468480 ++wrote 2048/2048 bytes at offset 4296468480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296472576 ++wrote 2048/2048 bytes at offset 4296472576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296476672 ++wrote 2048/2048 bytes at offset 4296476672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296480768 ++wrote 2048/2048 bytes at offset 4296480768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296484864 ++wrote 2048/2048 bytes at offset 4296484864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296488960 ++wrote 2048/2048 bytes at offset 4296488960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296493056 ++wrote 2048/2048 bytes at offset 4296493056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296497152 ++wrote 2048/2048 bytes at offset 4296497152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296501248 ++wrote 2048/2048 bytes at offset 4296501248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296505344 ++wrote 2048/2048 bytes at offset 4296505344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296509440 ++wrote 2048/2048 bytes at offset 4296509440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296513536 ++wrote 2048/2048 bytes at offset 4296513536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296517632 ++wrote 2048/2048 bytes at offset 4296517632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296521728 ++wrote 2048/2048 bytes at offset 4296521728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296525824 ++wrote 2048/2048 bytes at offset 4296525824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296529920 ++wrote 2048/2048 bytes at offset 4296529920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296534016 ++wrote 2048/2048 bytes at offset 4296534016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296538112 ++wrote 2048/2048 bytes at offset 4296538112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296542208 ++wrote 2048/2048 bytes at offset 4296542208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296546304 ++wrote 2048/2048 bytes at offset 4296546304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296550400 ++wrote 2048/2048 bytes at offset 4296550400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296554496 ++wrote 2048/2048 bytes at offset 4296554496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296558592 ++wrote 2048/2048 bytes at offset 4296558592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296562688 ++wrote 2048/2048 bytes at offset 4296562688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296566784 ++wrote 2048/2048 bytes at offset 4296566784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296570880 ++wrote 2048/2048 bytes at offset 4296570880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296574976 ++wrote 2048/2048 bytes at offset 4296574976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296579072 ++wrote 2048/2048 bytes at offset 4296579072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296583168 ++wrote 2048/2048 bytes at offset 4296583168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296587264 ++wrote 2048/2048 bytes at offset 4296587264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296591360 ++wrote 2048/2048 bytes at offset 4296591360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296595456 ++wrote 2048/2048 bytes at offset 4296595456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296599552 ++wrote 2048/2048 bytes at offset 4296599552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296603648 ++wrote 2048/2048 bytes at offset 4296603648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296607744 ++wrote 2048/2048 bytes at offset 4296607744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296611840 ++wrote 2048/2048 bytes at offset 4296611840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296615936 ++wrote 2048/2048 bytes at offset 4296615936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296620032 ++wrote 2048/2048 bytes at offset 4296620032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296624128 ++wrote 2048/2048 bytes at offset 4296624128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296628224 ++wrote 2048/2048 bytes at offset 4296628224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296632320 ++wrote 2048/2048 bytes at offset 4296632320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296636416 ++wrote 2048/2048 bytes at offset 4296636416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296640512 ++wrote 2048/2048 bytes at offset 4296640512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296644608 ++wrote 2048/2048 bytes at offset 4296644608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296648704 ++wrote 2048/2048 bytes at offset 4296648704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296652800 ++wrote 2048/2048 bytes at offset 4296652800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296656896 ++wrote 2048/2048 bytes at offset 4296656896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296660992 ++wrote 2048/2048 bytes at offset 4296660992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296665088 ++wrote 2048/2048 bytes at offset 4296665088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296669184 ++wrote 2048/2048 bytes at offset 4296669184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296673280 ++wrote 2048/2048 bytes at offset 4296673280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296677376 ++wrote 2048/2048 bytes at offset 4296677376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296681472 ++wrote 2048/2048 bytes at offset 4296681472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296685568 ++wrote 2048/2048 bytes at offset 4296685568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296689664 ++wrote 2048/2048 bytes at offset 4296689664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296693760 ++wrote 2048/2048 bytes at offset 4296693760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296697856 ++wrote 2048/2048 bytes at offset 4296697856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296701952 ++wrote 2048/2048 bytes at offset 4296701952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296706048 ++wrote 2048/2048 bytes at offset 4296706048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296710144 ++wrote 2048/2048 bytes at offset 4296710144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296714240 ++wrote 2048/2048 bytes at offset 4296714240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296718336 ++wrote 2048/2048 bytes at offset 4296718336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296722432 ++wrote 2048/2048 bytes at offset 4296722432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296726528 ++wrote 2048/2048 bytes at offset 4296726528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296730624 ++wrote 2048/2048 bytes at offset 4296730624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296734720 ++wrote 2048/2048 bytes at offset 4296734720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296738816 ++wrote 2048/2048 bytes at offset 4296738816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296742912 ++wrote 2048/2048 bytes at offset 4296742912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296747008 ++wrote 2048/2048 bytes at offset 4296747008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296751104 ++wrote 2048/2048 bytes at offset 4296751104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296755200 ++wrote 2048/2048 bytes at offset 4296755200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296759296 ++wrote 2048/2048 bytes at offset 4296759296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296763392 ++wrote 2048/2048 bytes at offset 4296763392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296767488 ++wrote 2048/2048 bytes at offset 4296767488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296771584 ++wrote 2048/2048 bytes at offset 4296771584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296775680 ++wrote 2048/2048 bytes at offset 4296775680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296779776 ++wrote 2048/2048 bytes at offset 4296779776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296783872 ++wrote 2048/2048 bytes at offset 4296783872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296787968 ++wrote 2048/2048 bytes at offset 4296787968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296792064 ++wrote 2048/2048 bytes at offset 4296792064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296796160 ++wrote 2048/2048 bytes at offset 4296796160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296800256 ++wrote 2048/2048 bytes at offset 4296800256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296804352 ++wrote 2048/2048 bytes at offset 4296804352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296808448 ++wrote 2048/2048 bytes at offset 4296808448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296812544 ++wrote 2048/2048 bytes at offset 4296812544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296816640 ++wrote 2048/2048 bytes at offset 4296816640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296820736 ++wrote 2048/2048 bytes at offset 4296820736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296824832 ++wrote 2048/2048 bytes at offset 4296824832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296828928 ++wrote 2048/2048 bytes at offset 4296828928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296833024 ++wrote 2048/2048 bytes at offset 4296833024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296837120 ++wrote 2048/2048 bytes at offset 4296837120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296841216 ++wrote 2048/2048 bytes at offset 4296841216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296845312 ++wrote 2048/2048 bytes at offset 4296845312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296849408 ++wrote 2048/2048 bytes at offset 4296849408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296853504 ++wrote 2048/2048 bytes at offset 4296853504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296857600 ++wrote 2048/2048 bytes at offset 4296857600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296861696 ++wrote 2048/2048 bytes at offset 4296861696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296865792 ++wrote 2048/2048 bytes at offset 4296865792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296869888 ++wrote 2048/2048 bytes at offset 4296869888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296873984 ++wrote 2048/2048 bytes at offset 4296873984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296878080 ++wrote 2048/2048 bytes at offset 4296878080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296882176 ++wrote 2048/2048 bytes at offset 4296882176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296886272 ++wrote 2048/2048 bytes at offset 4296886272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296890368 ++wrote 2048/2048 bytes at offset 4296890368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296894464 ++wrote 2048/2048 bytes at offset 4296894464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296898560 ++wrote 2048/2048 bytes at offset 4296898560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296902656 ++wrote 2048/2048 bytes at offset 4296902656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296906752 ++wrote 2048/2048 bytes at offset 4296906752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296910848 ++wrote 2048/2048 bytes at offset 4296910848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296914944 ++wrote 2048/2048 bytes at offset 4296914944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296919040 ++wrote 2048/2048 bytes at offset 4296919040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296923136 ++wrote 2048/2048 bytes at offset 4296923136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296927232 ++wrote 2048/2048 bytes at offset 4296927232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296931328 ++wrote 2048/2048 bytes at offset 4296931328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296935424 ++wrote 2048/2048 bytes at offset 4296935424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296939520 ++wrote 2048/2048 bytes at offset 4296939520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296943616 ++wrote 2048/2048 bytes at offset 4296943616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296947712 ++wrote 2048/2048 bytes at offset 4296947712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296951808 ++wrote 2048/2048 bytes at offset 4296951808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296955904 ++wrote 2048/2048 bytes at offset 4296955904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296960000 ++wrote 2048/2048 bytes at offset 4296960000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296964096 ++wrote 2048/2048 bytes at offset 4296964096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296968192 ++wrote 2048/2048 bytes at offset 4296968192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296972288 ++wrote 2048/2048 bytes at offset 4296972288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296976384 ++wrote 2048/2048 bytes at offset 4296976384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296980480 ++wrote 2048/2048 bytes at offset 4296980480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296984576 ++wrote 2048/2048 bytes at offset 4296984576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296988672 ++wrote 2048/2048 bytes at offset 4296988672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296992768 ++wrote 2048/2048 bytes at offset 4296992768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4296996864 ++wrote 2048/2048 bytes at offset 4296996864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297000960 ++wrote 2048/2048 bytes at offset 4297000960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297005056 ++wrote 2048/2048 bytes at offset 4297005056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297009152 ++wrote 2048/2048 bytes at offset 4297009152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297013248 ++wrote 2048/2048 bytes at offset 4297013248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297017344 ++wrote 2048/2048 bytes at offset 4297017344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297021440 ++wrote 2048/2048 bytes at offset 4297021440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297025536 ++wrote 2048/2048 bytes at offset 4297025536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297029632 ++wrote 2048/2048 bytes at offset 4297029632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297033728 ++wrote 2048/2048 bytes at offset 4297033728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297037824 ++wrote 2048/2048 bytes at offset 4297037824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297041920 ++wrote 2048/2048 bytes at offset 4297041920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297046016 ++wrote 2048/2048 bytes at offset 4297046016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297050112 ++wrote 2048/2048 bytes at offset 4297050112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297054208 ++wrote 2048/2048 bytes at offset 4297054208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297058304 ++wrote 2048/2048 bytes at offset 4297058304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297062400 ++wrote 2048/2048 bytes at offset 4297062400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> wrote 2048/2048 bytes at offset 4297064448 ++=== IO: pattern 0 ++wrote 2048/2048 bytes at offset 4297064448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297068544 ++wrote 2048/2048 bytes at offset 4297068544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297072640 ++wrote 2048/2048 bytes at offset 4297072640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297076736 ++wrote 2048/2048 bytes at offset 4297076736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297080832 ++wrote 2048/2048 bytes at offset 4297080832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297084928 ++wrote 2048/2048 bytes at offset 4297084928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297089024 ++wrote 2048/2048 bytes at offset 4297089024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297093120 ++wrote 2048/2048 bytes at offset 4297093120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297097216 ++wrote 2048/2048 bytes at offset 4297097216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297101312 ++wrote 2048/2048 bytes at offset 4297101312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297105408 ++wrote 2048/2048 bytes at offset 4297105408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297109504 ++wrote 2048/2048 bytes at offset 4297109504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297113600 ++wrote 2048/2048 bytes at offset 4297113600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297117696 ++wrote 2048/2048 bytes at offset 4297117696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297121792 ++wrote 2048/2048 bytes at offset 4297121792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297125888 ++wrote 2048/2048 bytes at offset 4297125888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297129984 ++wrote 2048/2048 bytes at offset 4297129984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297134080 ++wrote 2048/2048 bytes at offset 4297134080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297138176 ++wrote 2048/2048 bytes at offset 4297138176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297142272 ++wrote 2048/2048 bytes at offset 4297142272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297146368 ++wrote 2048/2048 bytes at offset 4297146368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297150464 ++wrote 2048/2048 bytes at offset 4297150464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297154560 ++wrote 2048/2048 bytes at offset 4297154560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297158656 ++wrote 2048/2048 bytes at offset 4297158656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297162752 ++wrote 2048/2048 bytes at offset 4297162752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297166848 ++wrote 2048/2048 bytes at offset 4297166848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297170944 ++wrote 2048/2048 bytes at offset 4297170944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297175040 ++wrote 2048/2048 bytes at offset 4297175040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297179136 ++wrote 2048/2048 bytes at offset 4297179136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297183232 ++wrote 2048/2048 bytes at offset 4297183232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297187328 ++wrote 2048/2048 bytes at offset 4297187328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297191424 ++wrote 2048/2048 bytes at offset 4297191424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297195520 ++wrote 2048/2048 bytes at offset 4297195520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297199616 ++wrote 2048/2048 bytes at offset 4297199616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297203712 ++wrote 2048/2048 bytes at offset 4297203712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297207808 ++wrote 2048/2048 bytes at offset 4297207808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297211904 ++wrote 2048/2048 bytes at offset 4297211904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297216000 ++wrote 2048/2048 bytes at offset 4297216000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297220096 ++wrote 2048/2048 bytes at offset 4297220096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297224192 ++wrote 2048/2048 bytes at offset 4297224192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297228288 ++wrote 2048/2048 bytes at offset 4297228288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297232384 ++wrote 2048/2048 bytes at offset 4297232384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297236480 ++wrote 2048/2048 bytes at offset 4297236480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297240576 ++wrote 2048/2048 bytes at offset 4297240576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297244672 ++wrote 2048/2048 bytes at offset 4297244672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297248768 ++wrote 2048/2048 bytes at offset 4297248768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297252864 ++wrote 2048/2048 bytes at offset 4297252864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297256960 ++wrote 2048/2048 bytes at offset 4297256960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297261056 ++wrote 2048/2048 bytes at offset 4297261056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297265152 ++wrote 2048/2048 bytes at offset 4297265152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297269248 ++wrote 2048/2048 bytes at offset 4297269248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297273344 ++wrote 2048/2048 bytes at offset 4297273344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297277440 ++wrote 2048/2048 bytes at offset 4297277440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297281536 ++wrote 2048/2048 bytes at offset 4297281536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297285632 ++wrote 2048/2048 bytes at offset 4297285632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297289728 ++wrote 2048/2048 bytes at offset 4297289728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297293824 ++wrote 2048/2048 bytes at offset 4297293824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297297920 ++wrote 2048/2048 bytes at offset 4297297920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297302016 ++wrote 2048/2048 bytes at offset 4297302016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297306112 ++wrote 2048/2048 bytes at offset 4297306112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297310208 ++wrote 2048/2048 bytes at offset 4297310208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297314304 ++wrote 2048/2048 bytes at offset 4297314304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297318400 ++wrote 2048/2048 bytes at offset 4297318400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297322496 ++wrote 2048/2048 bytes at offset 4297322496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297326592 ++wrote 2048/2048 bytes at offset 4297326592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297330688 ++wrote 2048/2048 bytes at offset 4297330688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297334784 ++wrote 2048/2048 bytes at offset 4297334784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297338880 ++wrote 2048/2048 bytes at offset 4297338880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297342976 ++wrote 2048/2048 bytes at offset 4297342976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297347072 ++wrote 2048/2048 bytes at offset 4297347072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297351168 ++wrote 2048/2048 bytes at offset 4297351168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297355264 ++wrote 2048/2048 bytes at offset 4297355264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297359360 ++wrote 2048/2048 bytes at offset 4297359360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297363456 ++wrote 2048/2048 bytes at offset 4297363456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297367552 ++wrote 2048/2048 bytes at offset 4297367552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297371648 ++wrote 2048/2048 bytes at offset 4297371648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297375744 ++wrote 2048/2048 bytes at offset 4297375744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297379840 ++wrote 2048/2048 bytes at offset 4297379840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297383936 ++wrote 2048/2048 bytes at offset 4297383936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297388032 ++wrote 2048/2048 bytes at offset 4297388032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297392128 ++wrote 2048/2048 bytes at offset 4297392128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297396224 ++wrote 2048/2048 bytes at offset 4297396224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297400320 ++wrote 2048/2048 bytes at offset 4297400320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297404416 ++wrote 2048/2048 bytes at offset 4297404416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297408512 ++wrote 2048/2048 bytes at offset 4297408512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297412608 ++wrote 2048/2048 bytes at offset 4297412608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297416704 ++wrote 2048/2048 bytes at offset 4297416704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297420800 ++wrote 2048/2048 bytes at offset 4297420800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297424896 ++wrote 2048/2048 bytes at offset 4297424896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297428992 ++wrote 2048/2048 bytes at offset 4297428992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297433088 ++wrote 2048/2048 bytes at offset 4297433088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297437184 ++wrote 2048/2048 bytes at offset 4297437184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297441280 ++wrote 2048/2048 bytes at offset 4297441280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297445376 ++wrote 2048/2048 bytes at offset 4297445376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297449472 ++wrote 2048/2048 bytes at offset 4297449472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297453568 ++wrote 2048/2048 bytes at offset 4297453568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297457664 ++wrote 2048/2048 bytes at offset 4297457664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297461760 ++wrote 2048/2048 bytes at offset 4297461760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297465856 ++wrote 2048/2048 bytes at offset 4297465856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297469952 ++wrote 2048/2048 bytes at offset 4297469952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297474048 ++wrote 2048/2048 bytes at offset 4297474048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297478144 ++wrote 2048/2048 bytes at offset 4297478144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297482240 ++wrote 2048/2048 bytes at offset 4297482240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297486336 ++wrote 2048/2048 bytes at offset 4297486336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297490432 ++wrote 2048/2048 bytes at offset 4297490432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297494528 ++wrote 2048/2048 bytes at offset 4297494528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297498624 ++wrote 2048/2048 bytes at offset 4297498624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297502720 ++wrote 2048/2048 bytes at offset 4297502720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297506816 ++wrote 2048/2048 bytes at offset 4297506816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297510912 ++wrote 2048/2048 bytes at offset 4297510912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297515008 ++wrote 2048/2048 bytes at offset 4297515008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297519104 ++wrote 2048/2048 bytes at offset 4297519104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297523200 ++wrote 2048/2048 bytes at offset 4297523200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297527296 ++wrote 2048/2048 bytes at offset 4297527296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297531392 ++wrote 2048/2048 bytes at offset 4297531392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297535488 ++wrote 2048/2048 bytes at offset 4297535488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297539584 ++wrote 2048/2048 bytes at offset 4297539584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297543680 ++wrote 2048/2048 bytes at offset 4297543680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297547776 ++wrote 2048/2048 bytes at offset 4297547776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297551872 ++wrote 2048/2048 bytes at offset 4297551872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297555968 ++wrote 2048/2048 bytes at offset 4297555968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297560064 ++wrote 2048/2048 bytes at offset 4297560064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297564160 ++wrote 2048/2048 bytes at offset 4297564160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297568256 ++wrote 2048/2048 bytes at offset 4297568256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297572352 ++wrote 2048/2048 bytes at offset 4297572352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297576448 ++wrote 2048/2048 bytes at offset 4297576448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297580544 ++wrote 2048/2048 bytes at offset 4297580544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297584640 ++wrote 2048/2048 bytes at offset 4297584640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297588736 ++wrote 2048/2048 bytes at offset 4297588736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297592832 ++wrote 2048/2048 bytes at offset 4297592832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297596928 ++wrote 2048/2048 bytes at offset 4297596928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297601024 ++wrote 2048/2048 bytes at offset 4297601024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297605120 ++wrote 2048/2048 bytes at offset 4297605120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297609216 ++wrote 2048/2048 bytes at offset 4297609216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297613312 ++wrote 2048/2048 bytes at offset 4297613312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297617408 ++wrote 2048/2048 bytes at offset 4297617408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297621504 ++wrote 2048/2048 bytes at offset 4297621504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297625600 ++wrote 2048/2048 bytes at offset 4297625600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297629696 ++wrote 2048/2048 bytes at offset 4297629696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297633792 ++wrote 2048/2048 bytes at offset 4297633792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297637888 ++wrote 2048/2048 bytes at offset 4297637888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297641984 ++wrote 2048/2048 bytes at offset 4297641984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297646080 ++wrote 2048/2048 bytes at offset 4297646080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297650176 ++wrote 2048/2048 bytes at offset 4297650176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297654272 ++wrote 2048/2048 bytes at offset 4297654272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297658368 ++wrote 2048/2048 bytes at offset 4297658368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297662464 ++wrote 2048/2048 bytes at offset 4297662464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297666560 ++wrote 2048/2048 bytes at offset 4297666560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297670656 ++wrote 2048/2048 bytes at offset 4297670656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297674752 ++wrote 2048/2048 bytes at offset 4297674752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297678848 ++wrote 2048/2048 bytes at offset 4297678848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297682944 ++wrote 2048/2048 bytes at offset 4297682944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297687040 ++wrote 2048/2048 bytes at offset 4297687040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297691136 ++wrote 2048/2048 bytes at offset 4297691136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297695232 ++wrote 2048/2048 bytes at offset 4297695232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297699328 ++wrote 2048/2048 bytes at offset 4297699328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297703424 ++wrote 2048/2048 bytes at offset 4297703424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297707520 ++wrote 2048/2048 bytes at offset 4297707520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297711616 ++wrote 2048/2048 bytes at offset 4297711616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297715712 ++wrote 2048/2048 bytes at offset 4297715712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297719808 ++wrote 2048/2048 bytes at offset 4297719808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297723904 ++wrote 2048/2048 bytes at offset 4297723904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297728000 ++wrote 2048/2048 bytes at offset 4297728000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297732096 ++wrote 2048/2048 bytes at offset 4297732096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297736192 ++wrote 2048/2048 bytes at offset 4297736192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297740288 ++wrote 2048/2048 bytes at offset 4297740288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297744384 ++wrote 2048/2048 bytes at offset 4297744384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297748480 ++wrote 2048/2048 bytes at offset 4297748480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297752576 ++wrote 2048/2048 bytes at offset 4297752576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297756672 ++wrote 2048/2048 bytes at offset 4297756672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297760768 ++wrote 2048/2048 bytes at offset 4297760768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297764864 ++wrote 2048/2048 bytes at offset 4297764864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297768960 ++wrote 2048/2048 bytes at offset 4297768960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297773056 ++wrote 2048/2048 bytes at offset 4297773056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297777152 ++wrote 2048/2048 bytes at offset 4297777152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297781248 ++wrote 2048/2048 bytes at offset 4297781248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297785344 ++wrote 2048/2048 bytes at offset 4297785344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297789440 ++wrote 2048/2048 bytes at offset 4297789440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297793536 ++wrote 2048/2048 bytes at offset 4297793536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297797632 ++wrote 2048/2048 bytes at offset 4297797632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297801728 ++wrote 2048/2048 bytes at offset 4297801728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297805824 ++wrote 2048/2048 bytes at offset 4297805824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297809920 ++wrote 2048/2048 bytes at offset 4297809920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297814016 ++wrote 2048/2048 bytes at offset 4297814016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297818112 ++wrote 2048/2048 bytes at offset 4297818112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297822208 ++wrote 2048/2048 bytes at offset 4297822208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297826304 ++wrote 2048/2048 bytes at offset 4297826304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297830400 ++wrote 2048/2048 bytes at offset 4297830400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297834496 ++wrote 2048/2048 bytes at offset 4297834496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297838592 ++wrote 2048/2048 bytes at offset 4297838592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297842688 ++wrote 2048/2048 bytes at offset 4297842688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297846784 ++wrote 2048/2048 bytes at offset 4297846784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297850880 ++wrote 2048/2048 bytes at offset 4297850880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297854976 ++wrote 2048/2048 bytes at offset 4297854976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297859072 ++wrote 2048/2048 bytes at offset 4297859072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297863168 ++wrote 2048/2048 bytes at offset 4297863168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297867264 ++wrote 2048/2048 bytes at offset 4297867264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297871360 ++wrote 2048/2048 bytes at offset 4297871360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297875456 ++wrote 2048/2048 bytes at offset 4297875456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297879552 ++wrote 2048/2048 bytes at offset 4297879552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297883648 ++wrote 2048/2048 bytes at offset 4297883648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297887744 ++wrote 2048/2048 bytes at offset 4297887744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297891840 ++wrote 2048/2048 bytes at offset 4297891840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297895936 ++wrote 2048/2048 bytes at offset 4297895936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297900032 ++wrote 2048/2048 bytes at offset 4297900032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297904128 ++wrote 2048/2048 bytes at offset 4297904128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297908224 ++wrote 2048/2048 bytes at offset 4297908224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297912320 ++wrote 2048/2048 bytes at offset 4297912320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297916416 ++wrote 2048/2048 bytes at offset 4297916416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297920512 ++wrote 2048/2048 bytes at offset 4297920512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297924608 ++wrote 2048/2048 bytes at offset 4297924608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297928704 ++wrote 2048/2048 bytes at offset 4297928704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297932800 ++wrote 2048/2048 bytes at offset 4297932800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297936896 ++wrote 2048/2048 bytes at offset 4297936896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297940992 ++wrote 2048/2048 bytes at offset 4297940992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297945088 ++wrote 2048/2048 bytes at offset 4297945088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297949184 ++wrote 2048/2048 bytes at offset 4297949184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297953280 ++wrote 2048/2048 bytes at offset 4297953280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297957376 ++wrote 2048/2048 bytes at offset 4297957376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297961472 ++wrote 2048/2048 bytes at offset 4297961472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297965568 ++wrote 2048/2048 bytes at offset 4297965568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297969664 ++wrote 2048/2048 bytes at offset 4297969664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297973760 ++wrote 2048/2048 bytes at offset 4297973760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297977856 ++wrote 2048/2048 bytes at offset 4297977856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297981952 ++wrote 2048/2048 bytes at offset 4297981952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297986048 ++wrote 2048/2048 bytes at offset 4297986048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297990144 ++wrote 2048/2048 bytes at offset 4297990144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297994240 ++wrote 2048/2048 bytes at offset 4297994240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4297998336 ++wrote 2048/2048 bytes at offset 4297998336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298002432 ++wrote 2048/2048 bytes at offset 4298002432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298006528 ++wrote 2048/2048 bytes at offset 4298006528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298010624 ++wrote 2048/2048 bytes at offset 4298010624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298014720 ++wrote 2048/2048 bytes at offset 4298014720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298018816 ++wrote 2048/2048 bytes at offset 4298018816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298022912 ++wrote 2048/2048 bytes at offset 4298022912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298027008 ++wrote 2048/2048 bytes at offset 4298027008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298031104 ++wrote 2048/2048 bytes at offset 4298031104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298035200 ++wrote 2048/2048 bytes at offset 4298035200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298039296 ++wrote 2048/2048 bytes at offset 4298039296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298043392 ++wrote 2048/2048 bytes at offset 4298043392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298047488 ++wrote 2048/2048 bytes at offset 4298047488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298051584 ++wrote 2048/2048 bytes at offset 4298051584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298055680 ++wrote 2048/2048 bytes at offset 4298055680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298059776 ++wrote 2048/2048 bytes at offset 4298059776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298063872 ++wrote 2048/2048 bytes at offset 4298063872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298067968 ++wrote 2048/2048 bytes at offset 4298067968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298072064 ++wrote 2048/2048 bytes at offset 4298072064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298076160 ++wrote 2048/2048 bytes at offset 4298076160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298080256 ++wrote 2048/2048 bytes at offset 4298080256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298084352 ++wrote 2048/2048 bytes at offset 4298084352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298088448 ++wrote 2048/2048 bytes at offset 4298088448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298092544 ++wrote 2048/2048 bytes at offset 4298092544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298096640 ++wrote 2048/2048 bytes at offset 4298096640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298100736 ++wrote 2048/2048 bytes at offset 4298100736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298104832 ++wrote 2048/2048 bytes at offset 4298104832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298108928 ++wrote 2048/2048 bytes at offset 4298108928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 2 +-qemu-io> wrote 2048/2048 bytes at offset 4298114048 ++=== IO: pattern 2 ++wrote 2048/2048 bytes at offset 4298114048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298118144 ++wrote 2048/2048 bytes at offset 4298118144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298122240 ++wrote 2048/2048 bytes at offset 4298122240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298126336 ++wrote 2048/2048 bytes at offset 4298126336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298130432 ++wrote 2048/2048 bytes at offset 4298130432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298134528 ++wrote 2048/2048 bytes at offset 4298134528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298138624 ++wrote 2048/2048 bytes at offset 4298138624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298142720 ++wrote 2048/2048 bytes at offset 4298142720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298146816 ++wrote 2048/2048 bytes at offset 4298146816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298150912 ++wrote 2048/2048 bytes at offset 4298150912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298155008 ++wrote 2048/2048 bytes at offset 4298155008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298159104 ++wrote 2048/2048 bytes at offset 4298159104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298163200 ++wrote 2048/2048 bytes at offset 4298163200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298167296 ++wrote 2048/2048 bytes at offset 4298167296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298171392 ++wrote 2048/2048 bytes at offset 4298171392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298175488 ++wrote 2048/2048 bytes at offset 4298175488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298179584 ++wrote 2048/2048 bytes at offset 4298179584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298183680 ++wrote 2048/2048 bytes at offset 4298183680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298187776 ++wrote 2048/2048 bytes at offset 4298187776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298191872 ++wrote 2048/2048 bytes at offset 4298191872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298195968 ++wrote 2048/2048 bytes at offset 4298195968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298200064 ++wrote 2048/2048 bytes at offset 4298200064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298204160 ++wrote 2048/2048 bytes at offset 4298204160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298208256 ++wrote 2048/2048 bytes at offset 4298208256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298212352 ++wrote 2048/2048 bytes at offset 4298212352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298216448 ++wrote 2048/2048 bytes at offset 4298216448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298220544 ++wrote 2048/2048 bytes at offset 4298220544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298224640 ++wrote 2048/2048 bytes at offset 4298224640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298228736 ++wrote 2048/2048 bytes at offset 4298228736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298232832 ++wrote 2048/2048 bytes at offset 4298232832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298236928 ++wrote 2048/2048 bytes at offset 4298236928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298241024 ++wrote 2048/2048 bytes at offset 4298241024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298245120 ++wrote 2048/2048 bytes at offset 4298245120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298249216 ++wrote 2048/2048 bytes at offset 4298249216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298253312 ++wrote 2048/2048 bytes at offset 4298253312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298257408 ++wrote 2048/2048 bytes at offset 4298257408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298261504 ++wrote 2048/2048 bytes at offset 4298261504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298265600 ++wrote 2048/2048 bytes at offset 4298265600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298269696 ++wrote 2048/2048 bytes at offset 4298269696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298273792 ++wrote 2048/2048 bytes at offset 4298273792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298277888 ++wrote 2048/2048 bytes at offset 4298277888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298281984 ++wrote 2048/2048 bytes at offset 4298281984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298286080 ++wrote 2048/2048 bytes at offset 4298286080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298290176 ++wrote 2048/2048 bytes at offset 4298290176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298294272 ++wrote 2048/2048 bytes at offset 4298294272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298298368 ++wrote 2048/2048 bytes at offset 4298298368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298302464 ++wrote 2048/2048 bytes at offset 4298302464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298306560 ++wrote 2048/2048 bytes at offset 4298306560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298310656 ++wrote 2048/2048 bytes at offset 4298310656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298314752 ++wrote 2048/2048 bytes at offset 4298314752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298318848 ++wrote 2048/2048 bytes at offset 4298318848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298322944 ++wrote 2048/2048 bytes at offset 4298322944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298327040 ++wrote 2048/2048 bytes at offset 4298327040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298331136 ++wrote 2048/2048 bytes at offset 4298331136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298335232 ++wrote 2048/2048 bytes at offset 4298335232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298339328 ++wrote 2048/2048 bytes at offset 4298339328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298343424 ++wrote 2048/2048 bytes at offset 4298343424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298347520 ++wrote 2048/2048 bytes at offset 4298347520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298351616 ++wrote 2048/2048 bytes at offset 4298351616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298355712 ++wrote 2048/2048 bytes at offset 4298355712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298359808 ++wrote 2048/2048 bytes at offset 4298359808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298363904 ++wrote 2048/2048 bytes at offset 4298363904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298368000 ++wrote 2048/2048 bytes at offset 4298368000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298372096 ++wrote 2048/2048 bytes at offset 4298372096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298376192 ++wrote 2048/2048 bytes at offset 4298376192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298380288 ++wrote 2048/2048 bytes at offset 4298380288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298384384 ++wrote 2048/2048 bytes at offset 4298384384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298388480 ++wrote 2048/2048 bytes at offset 4298388480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298392576 ++wrote 2048/2048 bytes at offset 4298392576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298396672 ++wrote 2048/2048 bytes at offset 4298396672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298400768 ++wrote 2048/2048 bytes at offset 4298400768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298404864 ++wrote 2048/2048 bytes at offset 4298404864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298408960 ++wrote 2048/2048 bytes at offset 4298408960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298413056 ++wrote 2048/2048 bytes at offset 4298413056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298417152 ++wrote 2048/2048 bytes at offset 4298417152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298421248 ++wrote 2048/2048 bytes at offset 4298421248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298425344 ++wrote 2048/2048 bytes at offset 4298425344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298429440 ++wrote 2048/2048 bytes at offset 4298429440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298433536 ++wrote 2048/2048 bytes at offset 4298433536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298437632 ++wrote 2048/2048 bytes at offset 4298437632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298441728 ++wrote 2048/2048 bytes at offset 4298441728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298445824 ++wrote 2048/2048 bytes at offset 4298445824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298449920 ++wrote 2048/2048 bytes at offset 4298449920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298454016 ++wrote 2048/2048 bytes at offset 4298454016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298458112 ++wrote 2048/2048 bytes at offset 4298458112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298462208 ++wrote 2048/2048 bytes at offset 4298462208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298466304 ++wrote 2048/2048 bytes at offset 4298466304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298470400 ++wrote 2048/2048 bytes at offset 4298470400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298474496 ++wrote 2048/2048 bytes at offset 4298474496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298478592 ++wrote 2048/2048 bytes at offset 4298478592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298482688 ++wrote 2048/2048 bytes at offset 4298482688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298486784 ++wrote 2048/2048 bytes at offset 4298486784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298490880 ++wrote 2048/2048 bytes at offset 4298490880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298494976 ++wrote 2048/2048 bytes at offset 4298494976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298499072 ++wrote 2048/2048 bytes at offset 4298499072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298503168 ++wrote 2048/2048 bytes at offset 4298503168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298507264 ++wrote 2048/2048 bytes at offset 4298507264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298511360 ++wrote 2048/2048 bytes at offset 4298511360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298515456 ++wrote 2048/2048 bytes at offset 4298515456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298519552 ++wrote 2048/2048 bytes at offset 4298519552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298523648 ++wrote 2048/2048 bytes at offset 4298523648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298527744 ++wrote 2048/2048 bytes at offset 4298527744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298531840 ++wrote 2048/2048 bytes at offset 4298531840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298535936 ++wrote 2048/2048 bytes at offset 4298535936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298540032 ++wrote 2048/2048 bytes at offset 4298540032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298544128 ++wrote 2048/2048 bytes at offset 4298544128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298548224 ++wrote 2048/2048 bytes at offset 4298548224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298552320 ++wrote 2048/2048 bytes at offset 4298552320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298556416 ++wrote 2048/2048 bytes at offset 4298556416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298560512 ++wrote 2048/2048 bytes at offset 4298560512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298564608 ++wrote 2048/2048 bytes at offset 4298564608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298568704 ++wrote 2048/2048 bytes at offset 4298568704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298572800 ++wrote 2048/2048 bytes at offset 4298572800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298576896 ++wrote 2048/2048 bytes at offset 4298576896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298580992 ++wrote 2048/2048 bytes at offset 4298580992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298585088 ++wrote 2048/2048 bytes at offset 4298585088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298589184 ++wrote 2048/2048 bytes at offset 4298589184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298593280 ++wrote 2048/2048 bytes at offset 4298593280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298597376 ++wrote 2048/2048 bytes at offset 4298597376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298601472 ++wrote 2048/2048 bytes at offset 4298601472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298605568 ++wrote 2048/2048 bytes at offset 4298605568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298609664 ++wrote 2048/2048 bytes at offset 4298609664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298613760 ++wrote 2048/2048 bytes at offset 4298613760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298617856 ++wrote 2048/2048 bytes at offset 4298617856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298621952 ++wrote 2048/2048 bytes at offset 4298621952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298626048 ++wrote 2048/2048 bytes at offset 4298626048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298630144 ++wrote 2048/2048 bytes at offset 4298630144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298634240 ++wrote 2048/2048 bytes at offset 4298634240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298638336 ++wrote 2048/2048 bytes at offset 4298638336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298642432 ++wrote 2048/2048 bytes at offset 4298642432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298646528 ++wrote 2048/2048 bytes at offset 4298646528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298650624 ++wrote 2048/2048 bytes at offset 4298650624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298654720 ++wrote 2048/2048 bytes at offset 4298654720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298658816 ++wrote 2048/2048 bytes at offset 4298658816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298662912 ++wrote 2048/2048 bytes at offset 4298662912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298667008 ++wrote 2048/2048 bytes at offset 4298667008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298671104 ++wrote 2048/2048 bytes at offset 4298671104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298675200 ++wrote 2048/2048 bytes at offset 4298675200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298679296 ++wrote 2048/2048 bytes at offset 4298679296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298683392 ++wrote 2048/2048 bytes at offset 4298683392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298687488 ++wrote 2048/2048 bytes at offset 4298687488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298691584 ++wrote 2048/2048 bytes at offset 4298691584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298695680 ++wrote 2048/2048 bytes at offset 4298695680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298699776 ++wrote 2048/2048 bytes at offset 4298699776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298703872 ++wrote 2048/2048 bytes at offset 4298703872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298707968 ++wrote 2048/2048 bytes at offset 4298707968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298712064 ++wrote 2048/2048 bytes at offset 4298712064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298716160 ++wrote 2048/2048 bytes at offset 4298716160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298720256 ++wrote 2048/2048 bytes at offset 4298720256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298724352 ++wrote 2048/2048 bytes at offset 4298724352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298728448 ++wrote 2048/2048 bytes at offset 4298728448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298732544 ++wrote 2048/2048 bytes at offset 4298732544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298736640 ++wrote 2048/2048 bytes at offset 4298736640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298740736 ++wrote 2048/2048 bytes at offset 4298740736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298744832 ++wrote 2048/2048 bytes at offset 4298744832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298748928 ++wrote 2048/2048 bytes at offset 4298748928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298753024 ++wrote 2048/2048 bytes at offset 4298753024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298757120 ++wrote 2048/2048 bytes at offset 4298757120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298761216 ++wrote 2048/2048 bytes at offset 4298761216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298765312 ++wrote 2048/2048 bytes at offset 4298765312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298769408 ++wrote 2048/2048 bytes at offset 4298769408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298773504 ++wrote 2048/2048 bytes at offset 4298773504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298777600 ++wrote 2048/2048 bytes at offset 4298777600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298781696 ++wrote 2048/2048 bytes at offset 4298781696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298785792 ++wrote 2048/2048 bytes at offset 4298785792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298789888 ++wrote 2048/2048 bytes at offset 4298789888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298793984 ++wrote 2048/2048 bytes at offset 4298793984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298798080 ++wrote 2048/2048 bytes at offset 4298798080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298802176 ++wrote 2048/2048 bytes at offset 4298802176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298806272 ++wrote 2048/2048 bytes at offset 4298806272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298810368 ++wrote 2048/2048 bytes at offset 4298810368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298814464 ++wrote 2048/2048 bytes at offset 4298814464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298818560 ++wrote 2048/2048 bytes at offset 4298818560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298822656 ++wrote 2048/2048 bytes at offset 4298822656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298826752 ++wrote 2048/2048 bytes at offset 4298826752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298830848 ++wrote 2048/2048 bytes at offset 4298830848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298834944 ++wrote 2048/2048 bytes at offset 4298834944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298839040 ++wrote 2048/2048 bytes at offset 4298839040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298843136 ++wrote 2048/2048 bytes at offset 4298843136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298847232 ++wrote 2048/2048 bytes at offset 4298847232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298851328 ++wrote 2048/2048 bytes at offset 4298851328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298855424 ++wrote 2048/2048 bytes at offset 4298855424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298859520 ++wrote 2048/2048 bytes at offset 4298859520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298863616 ++wrote 2048/2048 bytes at offset 4298863616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298867712 ++wrote 2048/2048 bytes at offset 4298867712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298871808 ++wrote 2048/2048 bytes at offset 4298871808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298875904 ++wrote 2048/2048 bytes at offset 4298875904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298880000 ++wrote 2048/2048 bytes at offset 4298880000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298884096 ++wrote 2048/2048 bytes at offset 4298884096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298888192 ++wrote 2048/2048 bytes at offset 4298888192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298892288 ++wrote 2048/2048 bytes at offset 4298892288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298896384 ++wrote 2048/2048 bytes at offset 4298896384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298900480 ++wrote 2048/2048 bytes at offset 4298900480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298904576 ++wrote 2048/2048 bytes at offset 4298904576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298908672 ++wrote 2048/2048 bytes at offset 4298908672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298912768 ++wrote 2048/2048 bytes at offset 4298912768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298916864 ++wrote 2048/2048 bytes at offset 4298916864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298920960 ++wrote 2048/2048 bytes at offset 4298920960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298925056 ++wrote 2048/2048 bytes at offset 4298925056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298929152 ++wrote 2048/2048 bytes at offset 4298929152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298933248 ++wrote 2048/2048 bytes at offset 4298933248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298937344 ++wrote 2048/2048 bytes at offset 4298937344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298941440 ++wrote 2048/2048 bytes at offset 4298941440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298945536 ++wrote 2048/2048 bytes at offset 4298945536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298949632 ++wrote 2048/2048 bytes at offset 4298949632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298953728 ++wrote 2048/2048 bytes at offset 4298953728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298957824 ++wrote 2048/2048 bytes at offset 4298957824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298961920 ++wrote 2048/2048 bytes at offset 4298961920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298966016 ++wrote 2048/2048 bytes at offset 4298966016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298970112 ++wrote 2048/2048 bytes at offset 4298970112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298974208 ++wrote 2048/2048 bytes at offset 4298974208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298978304 ++wrote 2048/2048 bytes at offset 4298978304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298982400 ++wrote 2048/2048 bytes at offset 4298982400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298986496 ++wrote 2048/2048 bytes at offset 4298986496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298990592 ++wrote 2048/2048 bytes at offset 4298990592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298994688 ++wrote 2048/2048 bytes at offset 4298994688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4298998784 ++wrote 2048/2048 bytes at offset 4298998784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299002880 ++wrote 2048/2048 bytes at offset 4299002880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299006976 ++wrote 2048/2048 bytes at offset 4299006976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299011072 ++wrote 2048/2048 bytes at offset 4299011072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299015168 ++wrote 2048/2048 bytes at offset 4299015168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299019264 ++wrote 2048/2048 bytes at offset 4299019264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299023360 ++wrote 2048/2048 bytes at offset 4299023360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299027456 ++wrote 2048/2048 bytes at offset 4299027456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299031552 ++wrote 2048/2048 bytes at offset 4299031552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299035648 ++wrote 2048/2048 bytes at offset 4299035648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299039744 ++wrote 2048/2048 bytes at offset 4299039744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299043840 ++wrote 2048/2048 bytes at offset 4299043840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299047936 ++wrote 2048/2048 bytes at offset 4299047936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299052032 ++wrote 2048/2048 bytes at offset 4299052032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299056128 ++wrote 2048/2048 bytes at offset 4299056128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299060224 ++wrote 2048/2048 bytes at offset 4299060224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299064320 ++wrote 2048/2048 bytes at offset 4299064320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299068416 ++wrote 2048/2048 bytes at offset 4299068416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299072512 ++wrote 2048/2048 bytes at offset 4299072512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299076608 ++wrote 2048/2048 bytes at offset 4299076608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299080704 ++wrote 2048/2048 bytes at offset 4299080704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299084800 ++wrote 2048/2048 bytes at offset 4299084800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299088896 ++wrote 2048/2048 bytes at offset 4299088896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299092992 ++wrote 2048/2048 bytes at offset 4299092992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299097088 ++wrote 2048/2048 bytes at offset 4299097088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299101184 ++wrote 2048/2048 bytes at offset 4299101184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299105280 ++wrote 2048/2048 bytes at offset 4299105280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299109376 ++wrote 2048/2048 bytes at offset 4299109376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299113472 ++wrote 2048/2048 bytes at offset 4299113472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299117568 ++wrote 2048/2048 bytes at offset 4299117568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299121664 ++wrote 2048/2048 bytes at offset 4299121664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299125760 ++wrote 2048/2048 bytes at offset 4299125760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299129856 ++wrote 2048/2048 bytes at offset 4299129856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299133952 ++wrote 2048/2048 bytes at offset 4299133952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299138048 ++wrote 2048/2048 bytes at offset 4299138048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299142144 ++wrote 2048/2048 bytes at offset 4299142144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299146240 ++wrote 2048/2048 bytes at offset 4299146240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299150336 ++wrote 2048/2048 bytes at offset 4299150336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299154432 ++wrote 2048/2048 bytes at offset 4299154432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4299158528 ++wrote 2048/2048 bytes at offset 4299158528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 4 +-qemu-io> wrote 8192/8192 bytes at offset 4299163648 ++=== IO: pattern 4 ++wrote 8192/8192 bytes at offset 4299163648 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299175936 ++wrote 8192/8192 bytes at offset 4299175936 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299188224 ++wrote 8192/8192 bytes at offset 4299188224 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299200512 ++wrote 8192/8192 bytes at offset 4299200512 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299212800 ++wrote 8192/8192 bytes at offset 4299212800 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299225088 ++wrote 8192/8192 bytes at offset 4299225088 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299237376 ++wrote 8192/8192 bytes at offset 4299237376 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299249664 ++wrote 8192/8192 bytes at offset 4299249664 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299261952 ++wrote 8192/8192 bytes at offset 4299261952 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299274240 ++wrote 8192/8192 bytes at offset 4299274240 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299286528 ++wrote 8192/8192 bytes at offset 4299286528 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299298816 ++wrote 8192/8192 bytes at offset 4299298816 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299311104 ++wrote 8192/8192 bytes at offset 4299311104 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299323392 ++wrote 8192/8192 bytes at offset 4299323392 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299335680 ++wrote 8192/8192 bytes at offset 4299335680 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299347968 ++wrote 8192/8192 bytes at offset 4299347968 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299360256 ++wrote 8192/8192 bytes at offset 4299360256 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299372544 ++wrote 8192/8192 bytes at offset 4299372544 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299384832 ++wrote 8192/8192 bytes at offset 4299384832 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299397120 ++wrote 8192/8192 bytes at offset 4299397120 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299409408 ++wrote 8192/8192 bytes at offset 4299409408 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299421696 ++wrote 8192/8192 bytes at offset 4299421696 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299433984 ++wrote 8192/8192 bytes at offset 4299433984 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299446272 ++wrote 8192/8192 bytes at offset 4299446272 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299458560 ++wrote 8192/8192 bytes at offset 4299458560 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299470848 ++wrote 8192/8192 bytes at offset 4299470848 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299483136 ++wrote 8192/8192 bytes at offset 4299483136 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299495424 ++wrote 8192/8192 bytes at offset 4299495424 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299507712 ++wrote 8192/8192 bytes at offset 4299507712 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299520000 ++wrote 8192/8192 bytes at offset 4299520000 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299532288 ++wrote 8192/8192 bytes at offset 4299532288 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299544576 ++wrote 8192/8192 bytes at offset 4299544576 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299556864 ++wrote 8192/8192 bytes at offset 4299556864 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299569152 ++wrote 8192/8192 bytes at offset 4299569152 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299581440 ++wrote 8192/8192 bytes at offset 4299581440 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299593728 ++wrote 8192/8192 bytes at offset 4299593728 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299606016 ++wrote 8192/8192 bytes at offset 4299606016 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299618304 ++wrote 8192/8192 bytes at offset 4299618304 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299630592 ++wrote 8192/8192 bytes at offset 4299630592 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299642880 ++wrote 8192/8192 bytes at offset 4299642880 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299655168 ++wrote 8192/8192 bytes at offset 4299655168 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299667456 ++wrote 8192/8192 bytes at offset 4299667456 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299679744 ++wrote 8192/8192 bytes at offset 4299679744 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299692032 ++wrote 8192/8192 bytes at offset 4299692032 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299704320 ++wrote 8192/8192 bytes at offset 4299704320 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299716608 ++wrote 8192/8192 bytes at offset 4299716608 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299728896 ++wrote 8192/8192 bytes at offset 4299728896 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299741184 ++wrote 8192/8192 bytes at offset 4299741184 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299753472 ++wrote 8192/8192 bytes at offset 4299753472 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299765760 ++wrote 8192/8192 bytes at offset 4299765760 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299778048 ++wrote 8192/8192 bytes at offset 4299778048 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299790336 ++wrote 8192/8192 bytes at offset 4299790336 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299802624 ++wrote 8192/8192 bytes at offset 4299802624 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299814912 ++wrote 8192/8192 bytes at offset 4299814912 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299827200 ++wrote 8192/8192 bytes at offset 4299827200 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299839488 ++wrote 8192/8192 bytes at offset 4299839488 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299851776 ++wrote 8192/8192 bytes at offset 4299851776 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299864064 ++wrote 8192/8192 bytes at offset 4299864064 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299876352 ++wrote 8192/8192 bytes at offset 4299876352 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299888640 ++wrote 8192/8192 bytes at offset 4299888640 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299900928 ++wrote 8192/8192 bytes at offset 4299900928 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299913216 ++wrote 8192/8192 bytes at offset 4299913216 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299925504 ++wrote 8192/8192 bytes at offset 4299925504 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4299937792 ++wrote 8192/8192 bytes at offset 4299937792 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 244 +-qemu-io> wrote 12288/12288 bytes at offset 4301252608 ++=== IO: pattern 244 ++wrote 12288/12288 bytes at offset 4301252608 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 4303351808 ++wrote 12288/12288 bytes at offset 4303351808 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 4305451008 ++wrote 12288/12288 bytes at offset 4305451008 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 4307550208 ++wrote 12288/12288 bytes at offset 4307550208 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 4309649408 ++wrote 12288/12288 bytes at offset 4309649408 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 4311748608 ++wrote 12288/12288 bytes at offset 4311748608 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 4313847808 ++wrote 12288/12288 bytes at offset 4313847808 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 4315947008 ++wrote 12288/12288 bytes at offset 4315947008 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> read 4096/4096 bytes at offset 4294967296 ++=== IO: pattern 0 ++read 4096/4096 bytes at offset 4294967296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294971392 ++read 4096/4096 bytes at offset 4294971392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294975488 ++read 4096/4096 bytes at offset 4294975488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294979584 ++read 4096/4096 bytes at offset 4294979584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294983680 ++read 4096/4096 bytes at offset 4294983680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294987776 ++read 4096/4096 bytes at offset 4294987776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294991872 ++read 4096/4096 bytes at offset 4294991872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294995968 ++read 4096/4096 bytes at offset 4294995968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295000064 ++read 4096/4096 bytes at offset 4295000064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295004160 ++read 4096/4096 bytes at offset 4295004160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295008256 ++read 4096/4096 bytes at offset 4295008256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295012352 ++read 4096/4096 bytes at offset 4295012352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295016448 ++read 4096/4096 bytes at offset 4295016448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295020544 ++read 4096/4096 bytes at offset 4295020544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295024640 ++read 4096/4096 bytes at offset 4295024640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295028736 ++read 4096/4096 bytes at offset 4295028736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295032832 ++read 4096/4096 bytes at offset 4295032832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295036928 ++read 4096/4096 bytes at offset 4295036928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295041024 ++read 4096/4096 bytes at offset 4295041024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295045120 ++read 4096/4096 bytes at offset 4295045120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295049216 ++read 4096/4096 bytes at offset 4295049216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295053312 ++read 4096/4096 bytes at offset 4295053312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295057408 ++read 4096/4096 bytes at offset 4295057408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295061504 ++read 4096/4096 bytes at offset 4295061504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295065600 ++read 4096/4096 bytes at offset 4295065600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295069696 ++read 4096/4096 bytes at offset 4295069696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295073792 ++read 4096/4096 bytes at offset 4295073792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295077888 ++read 4096/4096 bytes at offset 4295077888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295081984 ++read 4096/4096 bytes at offset 4295081984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295086080 ++read 4096/4096 bytes at offset 4295086080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295090176 ++read 4096/4096 bytes at offset 4295090176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295094272 ++read 4096/4096 bytes at offset 4295094272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295098368 ++read 4096/4096 bytes at offset 4295098368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295102464 ++read 4096/4096 bytes at offset 4295102464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295106560 ++read 4096/4096 bytes at offset 4295106560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295110656 ++read 4096/4096 bytes at offset 4295110656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295114752 ++read 4096/4096 bytes at offset 4295114752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295118848 ++read 4096/4096 bytes at offset 4295118848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295122944 ++read 4096/4096 bytes at offset 4295122944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295127040 ++read 4096/4096 bytes at offset 4295127040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295131136 ++read 4096/4096 bytes at offset 4295131136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295135232 ++read 4096/4096 bytes at offset 4295135232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295139328 ++read 4096/4096 bytes at offset 4295139328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295143424 ++read 4096/4096 bytes at offset 4295143424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295147520 ++read 4096/4096 bytes at offset 4295147520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295151616 ++read 4096/4096 bytes at offset 4295151616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295155712 ++read 4096/4096 bytes at offset 4295155712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295159808 ++read 4096/4096 bytes at offset 4295159808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295163904 ++read 4096/4096 bytes at offset 4295163904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295168000 ++read 4096/4096 bytes at offset 4295168000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295172096 ++read 4096/4096 bytes at offset 4295172096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295176192 ++read 4096/4096 bytes at offset 4295176192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295180288 ++read 4096/4096 bytes at offset 4295180288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295184384 ++read 4096/4096 bytes at offset 4295184384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295188480 ++read 4096/4096 bytes at offset 4295188480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295192576 ++read 4096/4096 bytes at offset 4295192576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295196672 ++read 4096/4096 bytes at offset 4295196672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295200768 ++read 4096/4096 bytes at offset 4295200768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295204864 ++read 4096/4096 bytes at offset 4295204864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295208960 ++read 4096/4096 bytes at offset 4295208960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295213056 ++read 4096/4096 bytes at offset 4295213056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295217152 ++read 4096/4096 bytes at offset 4295217152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295221248 ++read 4096/4096 bytes at offset 4295221248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295225344 ++read 4096/4096 bytes at offset 4295225344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295229440 ++read 4096/4096 bytes at offset 4295229440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295233536 ++read 4096/4096 bytes at offset 4295233536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295237632 ++read 4096/4096 bytes at offset 4295237632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295241728 ++read 4096/4096 bytes at offset 4295241728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295245824 ++read 4096/4096 bytes at offset 4295245824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295249920 ++read 4096/4096 bytes at offset 4295249920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295254016 ++read 4096/4096 bytes at offset 4295254016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295258112 ++read 4096/4096 bytes at offset 4295258112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295262208 ++read 4096/4096 bytes at offset 4295262208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295266304 ++read 4096/4096 bytes at offset 4295266304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295270400 ++read 4096/4096 bytes at offset 4295270400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295274496 ++read 4096/4096 bytes at offset 4295274496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295278592 ++read 4096/4096 bytes at offset 4295278592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295282688 ++read 4096/4096 bytes at offset 4295282688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295286784 ++read 4096/4096 bytes at offset 4295286784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295290880 ++read 4096/4096 bytes at offset 4295290880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295294976 ++read 4096/4096 bytes at offset 4295294976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295299072 ++read 4096/4096 bytes at offset 4295299072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295303168 ++read 4096/4096 bytes at offset 4295303168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295307264 ++read 4096/4096 bytes at offset 4295307264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295311360 ++read 4096/4096 bytes at offset 4295311360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295315456 ++read 4096/4096 bytes at offset 4295315456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295319552 ++read 4096/4096 bytes at offset 4295319552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295323648 ++read 4096/4096 bytes at offset 4295323648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295327744 ++read 4096/4096 bytes at offset 4295327744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295331840 ++read 4096/4096 bytes at offset 4295331840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295335936 ++read 4096/4096 bytes at offset 4295335936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295340032 ++read 4096/4096 bytes at offset 4295340032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295344128 ++read 4096/4096 bytes at offset 4295344128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295348224 ++read 4096/4096 bytes at offset 4295348224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295352320 ++read 4096/4096 bytes at offset 4295352320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295356416 ++read 4096/4096 bytes at offset 4295356416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295360512 ++read 4096/4096 bytes at offset 4295360512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295364608 ++read 4096/4096 bytes at offset 4295364608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295368704 ++read 4096/4096 bytes at offset 4295368704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295372800 ++read 4096/4096 bytes at offset 4295372800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295376896 ++read 4096/4096 bytes at offset 4295376896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295380992 ++read 4096/4096 bytes at offset 4295380992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295385088 ++read 4096/4096 bytes at offset 4295385088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295389184 ++read 4096/4096 bytes at offset 4295389184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295393280 ++read 4096/4096 bytes at offset 4295393280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295397376 ++read 4096/4096 bytes at offset 4295397376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295401472 ++read 4096/4096 bytes at offset 4295401472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295405568 ++read 4096/4096 bytes at offset 4295405568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295409664 ++read 4096/4096 bytes at offset 4295409664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295413760 ++read 4096/4096 bytes at offset 4295413760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295417856 ++read 4096/4096 bytes at offset 4295417856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295421952 ++read 4096/4096 bytes at offset 4295421952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295426048 ++read 4096/4096 bytes at offset 4295426048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295430144 ++read 4096/4096 bytes at offset 4295430144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295434240 ++read 4096/4096 bytes at offset 4295434240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295438336 ++read 4096/4096 bytes at offset 4295438336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295442432 ++read 4096/4096 bytes at offset 4295442432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295446528 ++read 4096/4096 bytes at offset 4295446528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295450624 ++read 4096/4096 bytes at offset 4295450624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295454720 ++read 4096/4096 bytes at offset 4295454720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295458816 ++read 4096/4096 bytes at offset 4295458816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295462912 ++read 4096/4096 bytes at offset 4295462912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295467008 ++read 4096/4096 bytes at offset 4295467008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295471104 ++read 4096/4096 bytes at offset 4295471104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295475200 ++read 4096/4096 bytes at offset 4295475200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295479296 ++read 4096/4096 bytes at offset 4295479296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295483392 ++read 4096/4096 bytes at offset 4295483392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295487488 ++read 4096/4096 bytes at offset 4295487488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295491584 ++read 4096/4096 bytes at offset 4295491584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295495680 ++read 4096/4096 bytes at offset 4295495680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295499776 ++read 4096/4096 bytes at offset 4295499776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295503872 ++read 4096/4096 bytes at offset 4295503872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295507968 ++read 4096/4096 bytes at offset 4295507968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295512064 ++read 4096/4096 bytes at offset 4295512064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295516160 ++read 4096/4096 bytes at offset 4295516160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295520256 ++read 4096/4096 bytes at offset 4295520256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295524352 ++read 4096/4096 bytes at offset 4295524352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295528448 ++read 4096/4096 bytes at offset 4295528448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295532544 ++read 4096/4096 bytes at offset 4295532544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295536640 ++read 4096/4096 bytes at offset 4295536640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295540736 ++read 4096/4096 bytes at offset 4295540736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295544832 ++read 4096/4096 bytes at offset 4295544832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295548928 ++read 4096/4096 bytes at offset 4295548928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295553024 ++read 4096/4096 bytes at offset 4295553024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295557120 ++read 4096/4096 bytes at offset 4295557120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295561216 ++read 4096/4096 bytes at offset 4295561216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295565312 ++read 4096/4096 bytes at offset 4295565312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295569408 ++read 4096/4096 bytes at offset 4295569408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295573504 ++read 4096/4096 bytes at offset 4295573504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295577600 ++read 4096/4096 bytes at offset 4295577600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295581696 ++read 4096/4096 bytes at offset 4295581696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295585792 ++read 4096/4096 bytes at offset 4295585792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295589888 ++read 4096/4096 bytes at offset 4295589888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295593984 ++read 4096/4096 bytes at offset 4295593984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295598080 ++read 4096/4096 bytes at offset 4295598080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295602176 ++read 4096/4096 bytes at offset 4295602176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295606272 ++read 4096/4096 bytes at offset 4295606272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295610368 ++read 4096/4096 bytes at offset 4295610368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295614464 ++read 4096/4096 bytes at offset 4295614464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295618560 ++read 4096/4096 bytes at offset 4295618560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295622656 ++read 4096/4096 bytes at offset 4295622656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295626752 ++read 4096/4096 bytes at offset 4295626752 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295630848 ++read 4096/4096 bytes at offset 4295630848 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295634944 ++read 4096/4096 bytes at offset 4295634944 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295639040 ++read 4096/4096 bytes at offset 4295639040 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295643136 ++read 4096/4096 bytes at offset 4295643136 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295647232 ++read 4096/4096 bytes at offset 4295647232 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295651328 ++read 4096/4096 bytes at offset 4295651328 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295655424 ++read 4096/4096 bytes at offset 4295655424 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295659520 ++read 4096/4096 bytes at offset 4295659520 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295663616 ++read 4096/4096 bytes at offset 4295663616 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295667712 ++read 4096/4096 bytes at offset 4295667712 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295671808 ++read 4096/4096 bytes at offset 4295671808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295675904 ++read 4096/4096 bytes at offset 4295675904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295680000 ++read 4096/4096 bytes at offset 4295680000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295684096 ++read 4096/4096 bytes at offset 4295684096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295688192 ++read 4096/4096 bytes at offset 4295688192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295692288 ++read 4096/4096 bytes at offset 4295692288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295696384 ++read 4096/4096 bytes at offset 4295696384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295700480 ++read 4096/4096 bytes at offset 4295700480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295704576 ++read 4096/4096 bytes at offset 4295704576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295708672 ++read 4096/4096 bytes at offset 4295708672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295712768 ++read 4096/4096 bytes at offset 4295712768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295716864 ++read 4096/4096 bytes at offset 4295716864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295720960 ++read 4096/4096 bytes at offset 4295720960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295725056 ++read 4096/4096 bytes at offset 4295725056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295729152 ++read 4096/4096 bytes at offset 4295729152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295733248 ++read 4096/4096 bytes at offset 4295733248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295737344 ++read 4096/4096 bytes at offset 4295737344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295741440 ++read 4096/4096 bytes at offset 4295741440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295745536 ++read 4096/4096 bytes at offset 4295745536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295749632 ++read 4096/4096 bytes at offset 4295749632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295753728 ++read 4096/4096 bytes at offset 4295753728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295757824 ++read 4096/4096 bytes at offset 4295757824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295761920 ++read 4096/4096 bytes at offset 4295761920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295766016 ++read 4096/4096 bytes at offset 4295766016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295770112 ++read 4096/4096 bytes at offset 4295770112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295774208 ++read 4096/4096 bytes at offset 4295774208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295778304 ++read 4096/4096 bytes at offset 4295778304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295782400 ++read 4096/4096 bytes at offset 4295782400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295786496 ++read 4096/4096 bytes at offset 4295786496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295790592 ++read 4096/4096 bytes at offset 4295790592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295794688 ++read 4096/4096 bytes at offset 4295794688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295798784 ++read 4096/4096 bytes at offset 4295798784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295802880 ++read 4096/4096 bytes at offset 4295802880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295806976 ++read 4096/4096 bytes at offset 4295806976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295811072 ++read 4096/4096 bytes at offset 4295811072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295815168 ++read 4096/4096 bytes at offset 4295815168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295819264 ++read 4096/4096 bytes at offset 4295819264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295823360 ++read 4096/4096 bytes at offset 4295823360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295827456 ++read 4096/4096 bytes at offset 4295827456 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295831552 ++read 4096/4096 bytes at offset 4295831552 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295835648 ++read 4096/4096 bytes at offset 4295835648 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295839744 ++read 4096/4096 bytes at offset 4295839744 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295843840 ++read 4096/4096 bytes at offset 4295843840 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295847936 ++read 4096/4096 bytes at offset 4295847936 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295852032 ++read 4096/4096 bytes at offset 4295852032 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295856128 ++read 4096/4096 bytes at offset 4295856128 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295860224 ++read 4096/4096 bytes at offset 4295860224 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295864320 ++read 4096/4096 bytes at offset 4295864320 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295868416 ++read 4096/4096 bytes at offset 4295868416 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295872512 ++read 4096/4096 bytes at offset 4295872512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295876608 ++read 4096/4096 bytes at offset 4295876608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295880704 ++read 4096/4096 bytes at offset 4295880704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295884800 ++read 4096/4096 bytes at offset 4295884800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295888896 ++read 4096/4096 bytes at offset 4295888896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295892992 ++read 4096/4096 bytes at offset 4295892992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295897088 ++read 4096/4096 bytes at offset 4295897088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295901184 ++read 4096/4096 bytes at offset 4295901184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295905280 ++read 4096/4096 bytes at offset 4295905280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295909376 ++read 4096/4096 bytes at offset 4295909376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295913472 ++read 4096/4096 bytes at offset 4295913472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295917568 ++read 4096/4096 bytes at offset 4295917568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295921664 ++read 4096/4096 bytes at offset 4295921664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295925760 ++read 4096/4096 bytes at offset 4295925760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295929856 ++read 4096/4096 bytes at offset 4295929856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295933952 ++read 4096/4096 bytes at offset 4295933952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295938048 ++read 4096/4096 bytes at offset 4295938048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295942144 ++read 4096/4096 bytes at offset 4295942144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295946240 ++read 4096/4096 bytes at offset 4295946240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295950336 ++read 4096/4096 bytes at offset 4295950336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295954432 ++read 4096/4096 bytes at offset 4295954432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295958528 ++read 4096/4096 bytes at offset 4295958528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295962624 ++read 4096/4096 bytes at offset 4295962624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295966720 ++read 4096/4096 bytes at offset 4295966720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295970816 ++read 4096/4096 bytes at offset 4295970816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295974912 ++read 4096/4096 bytes at offset 4295974912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295979008 ++read 4096/4096 bytes at offset 4295979008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295983104 ++read 4096/4096 bytes at offset 4295983104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295987200 ++read 4096/4096 bytes at offset 4295987200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295991296 ++read 4096/4096 bytes at offset 4295991296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295995392 ++read 4096/4096 bytes at offset 4295995392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295999488 ++read 4096/4096 bytes at offset 4295999488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4296003584 ++read 4096/4096 bytes at offset 4296003584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4296007680 ++read 4096/4096 bytes at offset 4296007680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4296011776 ++read 4096/4096 bytes at offset 4296011776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 4 +-qemu-io> read 2048/2048 bytes at offset 4296017920 ++=== IO: pattern 4 ++read 2048/2048 bytes at offset 4296017920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296022016 ++read 2048/2048 bytes at offset 4296022016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296026112 ++read 2048/2048 bytes at offset 4296026112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296030208 ++read 2048/2048 bytes at offset 4296030208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296034304 ++read 2048/2048 bytes at offset 4296034304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296038400 ++read 2048/2048 bytes at offset 4296038400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296042496 ++read 2048/2048 bytes at offset 4296042496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296046592 ++read 2048/2048 bytes at offset 4296046592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296050688 ++read 2048/2048 bytes at offset 4296050688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296054784 ++read 2048/2048 bytes at offset 4296054784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296058880 ++read 2048/2048 bytes at offset 4296058880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296062976 ++read 2048/2048 bytes at offset 4296062976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296067072 ++read 2048/2048 bytes at offset 4296067072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296071168 ++read 2048/2048 bytes at offset 4296071168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296075264 ++read 2048/2048 bytes at offset 4296075264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296079360 ++read 2048/2048 bytes at offset 4296079360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296083456 ++read 2048/2048 bytes at offset 4296083456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296087552 ++read 2048/2048 bytes at offset 4296087552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296091648 ++read 2048/2048 bytes at offset 4296091648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296095744 ++read 2048/2048 bytes at offset 4296095744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296099840 ++read 2048/2048 bytes at offset 4296099840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296103936 ++read 2048/2048 bytes at offset 4296103936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296108032 ++read 2048/2048 bytes at offset 4296108032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296112128 ++read 2048/2048 bytes at offset 4296112128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296116224 ++read 2048/2048 bytes at offset 4296116224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296120320 ++read 2048/2048 bytes at offset 4296120320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296124416 ++read 2048/2048 bytes at offset 4296124416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296128512 ++read 2048/2048 bytes at offset 4296128512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296132608 ++read 2048/2048 bytes at offset 4296132608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296136704 ++read 2048/2048 bytes at offset 4296136704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296140800 ++read 2048/2048 bytes at offset 4296140800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296144896 ++read 2048/2048 bytes at offset 4296144896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296148992 ++read 2048/2048 bytes at offset 4296148992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296153088 ++read 2048/2048 bytes at offset 4296153088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296157184 ++read 2048/2048 bytes at offset 4296157184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296161280 ++read 2048/2048 bytes at offset 4296161280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296165376 ++read 2048/2048 bytes at offset 4296165376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296169472 ++read 2048/2048 bytes at offset 4296169472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296173568 ++read 2048/2048 bytes at offset 4296173568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296177664 ++read 2048/2048 bytes at offset 4296177664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296181760 ++read 2048/2048 bytes at offset 4296181760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296185856 ++read 2048/2048 bytes at offset 4296185856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296189952 ++read 2048/2048 bytes at offset 4296189952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296194048 ++read 2048/2048 bytes at offset 4296194048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296198144 ++read 2048/2048 bytes at offset 4296198144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296202240 ++read 2048/2048 bytes at offset 4296202240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296206336 ++read 2048/2048 bytes at offset 4296206336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296210432 ++read 2048/2048 bytes at offset 4296210432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296214528 ++read 2048/2048 bytes at offset 4296214528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296218624 ++read 2048/2048 bytes at offset 4296218624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296222720 ++read 2048/2048 bytes at offset 4296222720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296226816 ++read 2048/2048 bytes at offset 4296226816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296230912 ++read 2048/2048 bytes at offset 4296230912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296235008 ++read 2048/2048 bytes at offset 4296235008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296239104 ++read 2048/2048 bytes at offset 4296239104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296243200 ++read 2048/2048 bytes at offset 4296243200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296247296 ++read 2048/2048 bytes at offset 4296247296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296251392 ++read 2048/2048 bytes at offset 4296251392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296255488 ++read 2048/2048 bytes at offset 4296255488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296259584 ++read 2048/2048 bytes at offset 4296259584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296263680 ++read 2048/2048 bytes at offset 4296263680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296267776 ++read 2048/2048 bytes at offset 4296267776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296271872 ++read 2048/2048 bytes at offset 4296271872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296275968 ++read 2048/2048 bytes at offset 4296275968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296280064 ++read 2048/2048 bytes at offset 4296280064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296284160 ++read 2048/2048 bytes at offset 4296284160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296288256 ++read 2048/2048 bytes at offset 4296288256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296292352 ++read 2048/2048 bytes at offset 4296292352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296296448 ++read 2048/2048 bytes at offset 4296296448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296300544 ++read 2048/2048 bytes at offset 4296300544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296304640 ++read 2048/2048 bytes at offset 4296304640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296308736 ++read 2048/2048 bytes at offset 4296308736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296312832 ++read 2048/2048 bytes at offset 4296312832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296316928 ++read 2048/2048 bytes at offset 4296316928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296321024 ++read 2048/2048 bytes at offset 4296321024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296325120 ++read 2048/2048 bytes at offset 4296325120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296329216 ++read 2048/2048 bytes at offset 4296329216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296333312 ++read 2048/2048 bytes at offset 4296333312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296337408 ++read 2048/2048 bytes at offset 4296337408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296341504 ++read 2048/2048 bytes at offset 4296341504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296345600 ++read 2048/2048 bytes at offset 4296345600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296349696 ++read 2048/2048 bytes at offset 4296349696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296353792 ++read 2048/2048 bytes at offset 4296353792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296357888 ++read 2048/2048 bytes at offset 4296357888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296361984 ++read 2048/2048 bytes at offset 4296361984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296366080 ++read 2048/2048 bytes at offset 4296366080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296370176 ++read 2048/2048 bytes at offset 4296370176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296374272 ++read 2048/2048 bytes at offset 4296374272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296378368 ++read 2048/2048 bytes at offset 4296378368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296382464 ++read 2048/2048 bytes at offset 4296382464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296386560 ++read 2048/2048 bytes at offset 4296386560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296390656 ++read 2048/2048 bytes at offset 4296390656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296394752 ++read 2048/2048 bytes at offset 4296394752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296398848 ++read 2048/2048 bytes at offset 4296398848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296402944 ++read 2048/2048 bytes at offset 4296402944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296407040 ++read 2048/2048 bytes at offset 4296407040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296411136 ++read 2048/2048 bytes at offset 4296411136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296415232 ++read 2048/2048 bytes at offset 4296415232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296419328 ++read 2048/2048 bytes at offset 4296419328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296423424 ++read 2048/2048 bytes at offset 4296423424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296427520 ++read 2048/2048 bytes at offset 4296427520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296431616 ++read 2048/2048 bytes at offset 4296431616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296435712 ++read 2048/2048 bytes at offset 4296435712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296439808 ++read 2048/2048 bytes at offset 4296439808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296443904 ++read 2048/2048 bytes at offset 4296443904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296448000 ++read 2048/2048 bytes at offset 4296448000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296452096 ++read 2048/2048 bytes at offset 4296452096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296456192 ++read 2048/2048 bytes at offset 4296456192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296460288 ++read 2048/2048 bytes at offset 4296460288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296464384 ++read 2048/2048 bytes at offset 4296464384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296468480 ++read 2048/2048 bytes at offset 4296468480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296472576 ++read 2048/2048 bytes at offset 4296472576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296476672 ++read 2048/2048 bytes at offset 4296476672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296480768 ++read 2048/2048 bytes at offset 4296480768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296484864 ++read 2048/2048 bytes at offset 4296484864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296488960 ++read 2048/2048 bytes at offset 4296488960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296493056 ++read 2048/2048 bytes at offset 4296493056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296497152 ++read 2048/2048 bytes at offset 4296497152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296501248 ++read 2048/2048 bytes at offset 4296501248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296505344 ++read 2048/2048 bytes at offset 4296505344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296509440 ++read 2048/2048 bytes at offset 4296509440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296513536 ++read 2048/2048 bytes at offset 4296513536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296517632 ++read 2048/2048 bytes at offset 4296517632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296521728 ++read 2048/2048 bytes at offset 4296521728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296525824 ++read 2048/2048 bytes at offset 4296525824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296529920 ++read 2048/2048 bytes at offset 4296529920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296534016 ++read 2048/2048 bytes at offset 4296534016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296538112 ++read 2048/2048 bytes at offset 4296538112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296542208 ++read 2048/2048 bytes at offset 4296542208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296546304 ++read 2048/2048 bytes at offset 4296546304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296550400 ++read 2048/2048 bytes at offset 4296550400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296554496 ++read 2048/2048 bytes at offset 4296554496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296558592 ++read 2048/2048 bytes at offset 4296558592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296562688 ++read 2048/2048 bytes at offset 4296562688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296566784 ++read 2048/2048 bytes at offset 4296566784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296570880 ++read 2048/2048 bytes at offset 4296570880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296574976 ++read 2048/2048 bytes at offset 4296574976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296579072 ++read 2048/2048 bytes at offset 4296579072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296583168 ++read 2048/2048 bytes at offset 4296583168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296587264 ++read 2048/2048 bytes at offset 4296587264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296591360 ++read 2048/2048 bytes at offset 4296591360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296595456 ++read 2048/2048 bytes at offset 4296595456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296599552 ++read 2048/2048 bytes at offset 4296599552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296603648 ++read 2048/2048 bytes at offset 4296603648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296607744 ++read 2048/2048 bytes at offset 4296607744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296611840 ++read 2048/2048 bytes at offset 4296611840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296615936 ++read 2048/2048 bytes at offset 4296615936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296620032 ++read 2048/2048 bytes at offset 4296620032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296624128 ++read 2048/2048 bytes at offset 4296624128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296628224 ++read 2048/2048 bytes at offset 4296628224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296632320 ++read 2048/2048 bytes at offset 4296632320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296636416 ++read 2048/2048 bytes at offset 4296636416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296640512 ++read 2048/2048 bytes at offset 4296640512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296644608 ++read 2048/2048 bytes at offset 4296644608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296648704 ++read 2048/2048 bytes at offset 4296648704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296652800 ++read 2048/2048 bytes at offset 4296652800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296656896 ++read 2048/2048 bytes at offset 4296656896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296660992 ++read 2048/2048 bytes at offset 4296660992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296665088 ++read 2048/2048 bytes at offset 4296665088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296669184 ++read 2048/2048 bytes at offset 4296669184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296673280 ++read 2048/2048 bytes at offset 4296673280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296677376 ++read 2048/2048 bytes at offset 4296677376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296681472 ++read 2048/2048 bytes at offset 4296681472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296685568 ++read 2048/2048 bytes at offset 4296685568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296689664 ++read 2048/2048 bytes at offset 4296689664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296693760 ++read 2048/2048 bytes at offset 4296693760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296697856 ++read 2048/2048 bytes at offset 4296697856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296701952 ++read 2048/2048 bytes at offset 4296701952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296706048 ++read 2048/2048 bytes at offset 4296706048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296710144 ++read 2048/2048 bytes at offset 4296710144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296714240 ++read 2048/2048 bytes at offset 4296714240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296718336 ++read 2048/2048 bytes at offset 4296718336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296722432 ++read 2048/2048 bytes at offset 4296722432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296726528 ++read 2048/2048 bytes at offset 4296726528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296730624 ++read 2048/2048 bytes at offset 4296730624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296734720 ++read 2048/2048 bytes at offset 4296734720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296738816 ++read 2048/2048 bytes at offset 4296738816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296742912 ++read 2048/2048 bytes at offset 4296742912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296747008 ++read 2048/2048 bytes at offset 4296747008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296751104 ++read 2048/2048 bytes at offset 4296751104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296755200 ++read 2048/2048 bytes at offset 4296755200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296759296 ++read 2048/2048 bytes at offset 4296759296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296763392 ++read 2048/2048 bytes at offset 4296763392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296767488 ++read 2048/2048 bytes at offset 4296767488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296771584 ++read 2048/2048 bytes at offset 4296771584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296775680 ++read 2048/2048 bytes at offset 4296775680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296779776 ++read 2048/2048 bytes at offset 4296779776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296783872 ++read 2048/2048 bytes at offset 4296783872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296787968 ++read 2048/2048 bytes at offset 4296787968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296792064 ++read 2048/2048 bytes at offset 4296792064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296796160 ++read 2048/2048 bytes at offset 4296796160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296800256 ++read 2048/2048 bytes at offset 4296800256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296804352 ++read 2048/2048 bytes at offset 4296804352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296808448 ++read 2048/2048 bytes at offset 4296808448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296812544 ++read 2048/2048 bytes at offset 4296812544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296816640 ++read 2048/2048 bytes at offset 4296816640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296820736 ++read 2048/2048 bytes at offset 4296820736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296824832 ++read 2048/2048 bytes at offset 4296824832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296828928 ++read 2048/2048 bytes at offset 4296828928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296833024 ++read 2048/2048 bytes at offset 4296833024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296837120 ++read 2048/2048 bytes at offset 4296837120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296841216 ++read 2048/2048 bytes at offset 4296841216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296845312 ++read 2048/2048 bytes at offset 4296845312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296849408 ++read 2048/2048 bytes at offset 4296849408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296853504 ++read 2048/2048 bytes at offset 4296853504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296857600 ++read 2048/2048 bytes at offset 4296857600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296861696 ++read 2048/2048 bytes at offset 4296861696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296865792 ++read 2048/2048 bytes at offset 4296865792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296869888 ++read 2048/2048 bytes at offset 4296869888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296873984 ++read 2048/2048 bytes at offset 4296873984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296878080 ++read 2048/2048 bytes at offset 4296878080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296882176 ++read 2048/2048 bytes at offset 4296882176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296886272 ++read 2048/2048 bytes at offset 4296886272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296890368 ++read 2048/2048 bytes at offset 4296890368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296894464 ++read 2048/2048 bytes at offset 4296894464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296898560 ++read 2048/2048 bytes at offset 4296898560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296902656 ++read 2048/2048 bytes at offset 4296902656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296906752 ++read 2048/2048 bytes at offset 4296906752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296910848 ++read 2048/2048 bytes at offset 4296910848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296914944 ++read 2048/2048 bytes at offset 4296914944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296919040 ++read 2048/2048 bytes at offset 4296919040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296923136 ++read 2048/2048 bytes at offset 4296923136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296927232 ++read 2048/2048 bytes at offset 4296927232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296931328 ++read 2048/2048 bytes at offset 4296931328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296935424 ++read 2048/2048 bytes at offset 4296935424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296939520 ++read 2048/2048 bytes at offset 4296939520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296943616 ++read 2048/2048 bytes at offset 4296943616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296947712 ++read 2048/2048 bytes at offset 4296947712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296951808 ++read 2048/2048 bytes at offset 4296951808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296955904 ++read 2048/2048 bytes at offset 4296955904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296960000 ++read 2048/2048 bytes at offset 4296960000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296964096 ++read 2048/2048 bytes at offset 4296964096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296968192 ++read 2048/2048 bytes at offset 4296968192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296972288 ++read 2048/2048 bytes at offset 4296972288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296976384 ++read 2048/2048 bytes at offset 4296976384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296980480 ++read 2048/2048 bytes at offset 4296980480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296984576 ++read 2048/2048 bytes at offset 4296984576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296988672 ++read 2048/2048 bytes at offset 4296988672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296992768 ++read 2048/2048 bytes at offset 4296992768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4296996864 ++read 2048/2048 bytes at offset 4296996864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297000960 ++read 2048/2048 bytes at offset 4297000960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297005056 ++read 2048/2048 bytes at offset 4297005056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297009152 ++read 2048/2048 bytes at offset 4297009152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297013248 ++read 2048/2048 bytes at offset 4297013248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297017344 ++read 2048/2048 bytes at offset 4297017344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297021440 ++read 2048/2048 bytes at offset 4297021440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297025536 ++read 2048/2048 bytes at offset 4297025536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297029632 ++read 2048/2048 bytes at offset 4297029632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297033728 ++read 2048/2048 bytes at offset 4297033728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297037824 ++read 2048/2048 bytes at offset 4297037824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297041920 ++read 2048/2048 bytes at offset 4297041920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297046016 ++read 2048/2048 bytes at offset 4297046016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297050112 ++read 2048/2048 bytes at offset 4297050112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297054208 ++read 2048/2048 bytes at offset 4297054208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297058304 ++read 2048/2048 bytes at offset 4297058304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297062400 ++read 2048/2048 bytes at offset 4297062400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> read 2048/2048 bytes at offset 4297064448 ++=== IO: pattern 0 ++read 2048/2048 bytes at offset 4297064448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297068544 ++read 2048/2048 bytes at offset 4297068544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297072640 ++read 2048/2048 bytes at offset 4297072640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297076736 ++read 2048/2048 bytes at offset 4297076736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297080832 ++read 2048/2048 bytes at offset 4297080832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297084928 ++read 2048/2048 bytes at offset 4297084928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297089024 ++read 2048/2048 bytes at offset 4297089024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297093120 ++read 2048/2048 bytes at offset 4297093120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297097216 ++read 2048/2048 bytes at offset 4297097216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297101312 ++read 2048/2048 bytes at offset 4297101312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297105408 ++read 2048/2048 bytes at offset 4297105408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297109504 ++read 2048/2048 bytes at offset 4297109504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297113600 ++read 2048/2048 bytes at offset 4297113600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297117696 ++read 2048/2048 bytes at offset 4297117696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297121792 ++read 2048/2048 bytes at offset 4297121792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297125888 ++read 2048/2048 bytes at offset 4297125888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297129984 ++read 2048/2048 bytes at offset 4297129984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297134080 ++read 2048/2048 bytes at offset 4297134080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297138176 ++read 2048/2048 bytes at offset 4297138176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297142272 ++read 2048/2048 bytes at offset 4297142272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297146368 ++read 2048/2048 bytes at offset 4297146368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297150464 ++read 2048/2048 bytes at offset 4297150464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297154560 ++read 2048/2048 bytes at offset 4297154560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297158656 ++read 2048/2048 bytes at offset 4297158656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297162752 ++read 2048/2048 bytes at offset 4297162752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297166848 ++read 2048/2048 bytes at offset 4297166848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297170944 ++read 2048/2048 bytes at offset 4297170944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297175040 ++read 2048/2048 bytes at offset 4297175040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297179136 ++read 2048/2048 bytes at offset 4297179136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297183232 ++read 2048/2048 bytes at offset 4297183232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297187328 ++read 2048/2048 bytes at offset 4297187328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297191424 ++read 2048/2048 bytes at offset 4297191424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297195520 ++read 2048/2048 bytes at offset 4297195520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297199616 ++read 2048/2048 bytes at offset 4297199616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297203712 ++read 2048/2048 bytes at offset 4297203712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297207808 ++read 2048/2048 bytes at offset 4297207808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297211904 ++read 2048/2048 bytes at offset 4297211904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297216000 ++read 2048/2048 bytes at offset 4297216000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297220096 ++read 2048/2048 bytes at offset 4297220096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297224192 ++read 2048/2048 bytes at offset 4297224192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297228288 ++read 2048/2048 bytes at offset 4297228288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297232384 ++read 2048/2048 bytes at offset 4297232384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297236480 ++read 2048/2048 bytes at offset 4297236480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297240576 ++read 2048/2048 bytes at offset 4297240576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297244672 ++read 2048/2048 bytes at offset 4297244672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297248768 ++read 2048/2048 bytes at offset 4297248768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297252864 ++read 2048/2048 bytes at offset 4297252864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297256960 ++read 2048/2048 bytes at offset 4297256960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297261056 ++read 2048/2048 bytes at offset 4297261056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297265152 ++read 2048/2048 bytes at offset 4297265152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297269248 ++read 2048/2048 bytes at offset 4297269248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297273344 ++read 2048/2048 bytes at offset 4297273344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297277440 ++read 2048/2048 bytes at offset 4297277440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297281536 ++read 2048/2048 bytes at offset 4297281536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297285632 ++read 2048/2048 bytes at offset 4297285632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297289728 ++read 2048/2048 bytes at offset 4297289728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297293824 ++read 2048/2048 bytes at offset 4297293824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297297920 ++read 2048/2048 bytes at offset 4297297920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297302016 ++read 2048/2048 bytes at offset 4297302016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297306112 ++read 2048/2048 bytes at offset 4297306112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297310208 ++read 2048/2048 bytes at offset 4297310208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297314304 ++read 2048/2048 bytes at offset 4297314304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297318400 ++read 2048/2048 bytes at offset 4297318400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297322496 ++read 2048/2048 bytes at offset 4297322496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297326592 ++read 2048/2048 bytes at offset 4297326592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297330688 ++read 2048/2048 bytes at offset 4297330688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297334784 ++read 2048/2048 bytes at offset 4297334784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297338880 ++read 2048/2048 bytes at offset 4297338880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297342976 ++read 2048/2048 bytes at offset 4297342976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297347072 ++read 2048/2048 bytes at offset 4297347072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297351168 ++read 2048/2048 bytes at offset 4297351168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297355264 ++read 2048/2048 bytes at offset 4297355264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297359360 ++read 2048/2048 bytes at offset 4297359360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297363456 ++read 2048/2048 bytes at offset 4297363456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297367552 ++read 2048/2048 bytes at offset 4297367552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297371648 ++read 2048/2048 bytes at offset 4297371648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297375744 ++read 2048/2048 bytes at offset 4297375744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297379840 ++read 2048/2048 bytes at offset 4297379840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297383936 ++read 2048/2048 bytes at offset 4297383936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297388032 ++read 2048/2048 bytes at offset 4297388032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297392128 ++read 2048/2048 bytes at offset 4297392128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297396224 ++read 2048/2048 bytes at offset 4297396224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297400320 ++read 2048/2048 bytes at offset 4297400320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297404416 ++read 2048/2048 bytes at offset 4297404416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297408512 ++read 2048/2048 bytes at offset 4297408512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297412608 ++read 2048/2048 bytes at offset 4297412608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297416704 ++read 2048/2048 bytes at offset 4297416704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297420800 ++read 2048/2048 bytes at offset 4297420800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297424896 ++read 2048/2048 bytes at offset 4297424896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297428992 ++read 2048/2048 bytes at offset 4297428992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297433088 ++read 2048/2048 bytes at offset 4297433088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297437184 ++read 2048/2048 bytes at offset 4297437184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297441280 ++read 2048/2048 bytes at offset 4297441280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297445376 ++read 2048/2048 bytes at offset 4297445376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297449472 ++read 2048/2048 bytes at offset 4297449472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297453568 ++read 2048/2048 bytes at offset 4297453568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297457664 ++read 2048/2048 bytes at offset 4297457664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297461760 ++read 2048/2048 bytes at offset 4297461760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297465856 ++read 2048/2048 bytes at offset 4297465856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297469952 ++read 2048/2048 bytes at offset 4297469952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297474048 ++read 2048/2048 bytes at offset 4297474048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297478144 ++read 2048/2048 bytes at offset 4297478144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297482240 ++read 2048/2048 bytes at offset 4297482240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297486336 ++read 2048/2048 bytes at offset 4297486336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297490432 ++read 2048/2048 bytes at offset 4297490432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297494528 ++read 2048/2048 bytes at offset 4297494528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297498624 ++read 2048/2048 bytes at offset 4297498624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297502720 ++read 2048/2048 bytes at offset 4297502720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297506816 ++read 2048/2048 bytes at offset 4297506816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297510912 ++read 2048/2048 bytes at offset 4297510912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297515008 ++read 2048/2048 bytes at offset 4297515008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297519104 ++read 2048/2048 bytes at offset 4297519104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297523200 ++read 2048/2048 bytes at offset 4297523200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297527296 ++read 2048/2048 bytes at offset 4297527296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297531392 ++read 2048/2048 bytes at offset 4297531392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297535488 ++read 2048/2048 bytes at offset 4297535488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297539584 ++read 2048/2048 bytes at offset 4297539584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297543680 ++read 2048/2048 bytes at offset 4297543680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297547776 ++read 2048/2048 bytes at offset 4297547776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297551872 ++read 2048/2048 bytes at offset 4297551872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297555968 ++read 2048/2048 bytes at offset 4297555968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297560064 ++read 2048/2048 bytes at offset 4297560064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297564160 ++read 2048/2048 bytes at offset 4297564160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297568256 ++read 2048/2048 bytes at offset 4297568256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297572352 ++read 2048/2048 bytes at offset 4297572352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297576448 ++read 2048/2048 bytes at offset 4297576448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297580544 ++read 2048/2048 bytes at offset 4297580544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297584640 ++read 2048/2048 bytes at offset 4297584640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297588736 ++read 2048/2048 bytes at offset 4297588736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297592832 ++read 2048/2048 bytes at offset 4297592832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297596928 ++read 2048/2048 bytes at offset 4297596928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297601024 ++read 2048/2048 bytes at offset 4297601024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297605120 ++read 2048/2048 bytes at offset 4297605120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297609216 ++read 2048/2048 bytes at offset 4297609216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297613312 ++read 2048/2048 bytes at offset 4297613312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297617408 ++read 2048/2048 bytes at offset 4297617408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297621504 ++read 2048/2048 bytes at offset 4297621504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297625600 ++read 2048/2048 bytes at offset 4297625600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297629696 ++read 2048/2048 bytes at offset 4297629696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297633792 ++read 2048/2048 bytes at offset 4297633792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297637888 ++read 2048/2048 bytes at offset 4297637888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297641984 ++read 2048/2048 bytes at offset 4297641984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297646080 ++read 2048/2048 bytes at offset 4297646080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297650176 ++read 2048/2048 bytes at offset 4297650176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297654272 ++read 2048/2048 bytes at offset 4297654272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297658368 ++read 2048/2048 bytes at offset 4297658368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297662464 ++read 2048/2048 bytes at offset 4297662464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297666560 ++read 2048/2048 bytes at offset 4297666560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297670656 ++read 2048/2048 bytes at offset 4297670656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297674752 ++read 2048/2048 bytes at offset 4297674752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297678848 ++read 2048/2048 bytes at offset 4297678848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297682944 ++read 2048/2048 bytes at offset 4297682944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297687040 ++read 2048/2048 bytes at offset 4297687040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297691136 ++read 2048/2048 bytes at offset 4297691136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297695232 ++read 2048/2048 bytes at offset 4297695232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297699328 ++read 2048/2048 bytes at offset 4297699328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297703424 ++read 2048/2048 bytes at offset 4297703424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297707520 ++read 2048/2048 bytes at offset 4297707520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297711616 ++read 2048/2048 bytes at offset 4297711616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297715712 ++read 2048/2048 bytes at offset 4297715712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297719808 ++read 2048/2048 bytes at offset 4297719808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297723904 ++read 2048/2048 bytes at offset 4297723904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297728000 ++read 2048/2048 bytes at offset 4297728000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297732096 ++read 2048/2048 bytes at offset 4297732096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297736192 ++read 2048/2048 bytes at offset 4297736192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297740288 ++read 2048/2048 bytes at offset 4297740288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297744384 ++read 2048/2048 bytes at offset 4297744384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297748480 ++read 2048/2048 bytes at offset 4297748480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297752576 ++read 2048/2048 bytes at offset 4297752576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297756672 ++read 2048/2048 bytes at offset 4297756672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297760768 ++read 2048/2048 bytes at offset 4297760768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297764864 ++read 2048/2048 bytes at offset 4297764864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297768960 ++read 2048/2048 bytes at offset 4297768960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297773056 ++read 2048/2048 bytes at offset 4297773056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297777152 ++read 2048/2048 bytes at offset 4297777152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297781248 ++read 2048/2048 bytes at offset 4297781248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297785344 ++read 2048/2048 bytes at offset 4297785344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297789440 ++read 2048/2048 bytes at offset 4297789440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297793536 ++read 2048/2048 bytes at offset 4297793536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297797632 ++read 2048/2048 bytes at offset 4297797632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297801728 ++read 2048/2048 bytes at offset 4297801728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297805824 ++read 2048/2048 bytes at offset 4297805824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297809920 ++read 2048/2048 bytes at offset 4297809920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297814016 ++read 2048/2048 bytes at offset 4297814016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297818112 ++read 2048/2048 bytes at offset 4297818112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297822208 ++read 2048/2048 bytes at offset 4297822208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297826304 ++read 2048/2048 bytes at offset 4297826304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297830400 ++read 2048/2048 bytes at offset 4297830400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297834496 ++read 2048/2048 bytes at offset 4297834496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297838592 ++read 2048/2048 bytes at offset 4297838592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297842688 ++read 2048/2048 bytes at offset 4297842688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297846784 ++read 2048/2048 bytes at offset 4297846784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297850880 ++read 2048/2048 bytes at offset 4297850880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297854976 ++read 2048/2048 bytes at offset 4297854976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297859072 ++read 2048/2048 bytes at offset 4297859072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297863168 ++read 2048/2048 bytes at offset 4297863168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297867264 ++read 2048/2048 bytes at offset 4297867264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297871360 ++read 2048/2048 bytes at offset 4297871360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297875456 ++read 2048/2048 bytes at offset 4297875456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297879552 ++read 2048/2048 bytes at offset 4297879552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297883648 ++read 2048/2048 bytes at offset 4297883648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297887744 ++read 2048/2048 bytes at offset 4297887744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297891840 ++read 2048/2048 bytes at offset 4297891840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297895936 ++read 2048/2048 bytes at offset 4297895936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297900032 ++read 2048/2048 bytes at offset 4297900032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297904128 ++read 2048/2048 bytes at offset 4297904128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297908224 ++read 2048/2048 bytes at offset 4297908224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297912320 ++read 2048/2048 bytes at offset 4297912320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297916416 ++read 2048/2048 bytes at offset 4297916416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297920512 ++read 2048/2048 bytes at offset 4297920512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297924608 ++read 2048/2048 bytes at offset 4297924608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297928704 ++read 2048/2048 bytes at offset 4297928704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297932800 ++read 2048/2048 bytes at offset 4297932800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297936896 ++read 2048/2048 bytes at offset 4297936896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297940992 ++read 2048/2048 bytes at offset 4297940992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297945088 ++read 2048/2048 bytes at offset 4297945088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297949184 ++read 2048/2048 bytes at offset 4297949184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297953280 ++read 2048/2048 bytes at offset 4297953280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297957376 ++read 2048/2048 bytes at offset 4297957376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297961472 ++read 2048/2048 bytes at offset 4297961472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297965568 ++read 2048/2048 bytes at offset 4297965568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297969664 ++read 2048/2048 bytes at offset 4297969664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297973760 ++read 2048/2048 bytes at offset 4297973760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297977856 ++read 2048/2048 bytes at offset 4297977856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297981952 ++read 2048/2048 bytes at offset 4297981952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297986048 ++read 2048/2048 bytes at offset 4297986048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297990144 ++read 2048/2048 bytes at offset 4297990144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297994240 ++read 2048/2048 bytes at offset 4297994240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4297998336 ++read 2048/2048 bytes at offset 4297998336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298002432 ++read 2048/2048 bytes at offset 4298002432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298006528 ++read 2048/2048 bytes at offset 4298006528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298010624 ++read 2048/2048 bytes at offset 4298010624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298014720 ++read 2048/2048 bytes at offset 4298014720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298018816 ++read 2048/2048 bytes at offset 4298018816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298022912 ++read 2048/2048 bytes at offset 4298022912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298027008 ++read 2048/2048 bytes at offset 4298027008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298031104 ++read 2048/2048 bytes at offset 4298031104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298035200 ++read 2048/2048 bytes at offset 4298035200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298039296 ++read 2048/2048 bytes at offset 4298039296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298043392 ++read 2048/2048 bytes at offset 4298043392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298047488 ++read 2048/2048 bytes at offset 4298047488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298051584 ++read 2048/2048 bytes at offset 4298051584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298055680 ++read 2048/2048 bytes at offset 4298055680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298059776 ++read 2048/2048 bytes at offset 4298059776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298063872 ++read 2048/2048 bytes at offset 4298063872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298067968 ++read 2048/2048 bytes at offset 4298067968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298072064 ++read 2048/2048 bytes at offset 4298072064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298076160 ++read 2048/2048 bytes at offset 4298076160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298080256 ++read 2048/2048 bytes at offset 4298080256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298084352 ++read 2048/2048 bytes at offset 4298084352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298088448 ++read 2048/2048 bytes at offset 4298088448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298092544 ++read 2048/2048 bytes at offset 4298092544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298096640 ++read 2048/2048 bytes at offset 4298096640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298100736 ++read 2048/2048 bytes at offset 4298100736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298104832 ++read 2048/2048 bytes at offset 4298104832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298108928 ++read 2048/2048 bytes at offset 4298108928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 2 +-qemu-io> read 2048/2048 bytes at offset 4298114048 ++=== IO: pattern 2 ++read 2048/2048 bytes at offset 4298114048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298118144 ++read 2048/2048 bytes at offset 4298118144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298122240 ++read 2048/2048 bytes at offset 4298122240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298126336 ++read 2048/2048 bytes at offset 4298126336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298130432 ++read 2048/2048 bytes at offset 4298130432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298134528 ++read 2048/2048 bytes at offset 4298134528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298138624 ++read 2048/2048 bytes at offset 4298138624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298142720 ++read 2048/2048 bytes at offset 4298142720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298146816 ++read 2048/2048 bytes at offset 4298146816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298150912 ++read 2048/2048 bytes at offset 4298150912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298155008 ++read 2048/2048 bytes at offset 4298155008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298159104 ++read 2048/2048 bytes at offset 4298159104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298163200 ++read 2048/2048 bytes at offset 4298163200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298167296 ++read 2048/2048 bytes at offset 4298167296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298171392 ++read 2048/2048 bytes at offset 4298171392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298175488 ++read 2048/2048 bytes at offset 4298175488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298179584 ++read 2048/2048 bytes at offset 4298179584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298183680 ++read 2048/2048 bytes at offset 4298183680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298187776 ++read 2048/2048 bytes at offset 4298187776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298191872 ++read 2048/2048 bytes at offset 4298191872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298195968 ++read 2048/2048 bytes at offset 4298195968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298200064 ++read 2048/2048 bytes at offset 4298200064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298204160 ++read 2048/2048 bytes at offset 4298204160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298208256 ++read 2048/2048 bytes at offset 4298208256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298212352 ++read 2048/2048 bytes at offset 4298212352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298216448 ++read 2048/2048 bytes at offset 4298216448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298220544 ++read 2048/2048 bytes at offset 4298220544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298224640 ++read 2048/2048 bytes at offset 4298224640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298228736 ++read 2048/2048 bytes at offset 4298228736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298232832 ++read 2048/2048 bytes at offset 4298232832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298236928 ++read 2048/2048 bytes at offset 4298236928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298241024 ++read 2048/2048 bytes at offset 4298241024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298245120 ++read 2048/2048 bytes at offset 4298245120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298249216 ++read 2048/2048 bytes at offset 4298249216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298253312 ++read 2048/2048 bytes at offset 4298253312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298257408 ++read 2048/2048 bytes at offset 4298257408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298261504 ++read 2048/2048 bytes at offset 4298261504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298265600 ++read 2048/2048 bytes at offset 4298265600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298269696 ++read 2048/2048 bytes at offset 4298269696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298273792 ++read 2048/2048 bytes at offset 4298273792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298277888 ++read 2048/2048 bytes at offset 4298277888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298281984 ++read 2048/2048 bytes at offset 4298281984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298286080 ++read 2048/2048 bytes at offset 4298286080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298290176 ++read 2048/2048 bytes at offset 4298290176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298294272 ++read 2048/2048 bytes at offset 4298294272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298298368 ++read 2048/2048 bytes at offset 4298298368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298302464 ++read 2048/2048 bytes at offset 4298302464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298306560 ++read 2048/2048 bytes at offset 4298306560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298310656 ++read 2048/2048 bytes at offset 4298310656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298314752 ++read 2048/2048 bytes at offset 4298314752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298318848 ++read 2048/2048 bytes at offset 4298318848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298322944 ++read 2048/2048 bytes at offset 4298322944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298327040 ++read 2048/2048 bytes at offset 4298327040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298331136 ++read 2048/2048 bytes at offset 4298331136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298335232 ++read 2048/2048 bytes at offset 4298335232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298339328 ++read 2048/2048 bytes at offset 4298339328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298343424 ++read 2048/2048 bytes at offset 4298343424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298347520 ++read 2048/2048 bytes at offset 4298347520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298351616 ++read 2048/2048 bytes at offset 4298351616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298355712 ++read 2048/2048 bytes at offset 4298355712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298359808 ++read 2048/2048 bytes at offset 4298359808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298363904 ++read 2048/2048 bytes at offset 4298363904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298368000 ++read 2048/2048 bytes at offset 4298368000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298372096 ++read 2048/2048 bytes at offset 4298372096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298376192 ++read 2048/2048 bytes at offset 4298376192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298380288 ++read 2048/2048 bytes at offset 4298380288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298384384 ++read 2048/2048 bytes at offset 4298384384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298388480 ++read 2048/2048 bytes at offset 4298388480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298392576 ++read 2048/2048 bytes at offset 4298392576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298396672 ++read 2048/2048 bytes at offset 4298396672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298400768 ++read 2048/2048 bytes at offset 4298400768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298404864 ++read 2048/2048 bytes at offset 4298404864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298408960 ++read 2048/2048 bytes at offset 4298408960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298413056 ++read 2048/2048 bytes at offset 4298413056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298417152 ++read 2048/2048 bytes at offset 4298417152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298421248 ++read 2048/2048 bytes at offset 4298421248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298425344 ++read 2048/2048 bytes at offset 4298425344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298429440 ++read 2048/2048 bytes at offset 4298429440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298433536 ++read 2048/2048 bytes at offset 4298433536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298437632 ++read 2048/2048 bytes at offset 4298437632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298441728 ++read 2048/2048 bytes at offset 4298441728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298445824 ++read 2048/2048 bytes at offset 4298445824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298449920 ++read 2048/2048 bytes at offset 4298449920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298454016 ++read 2048/2048 bytes at offset 4298454016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298458112 ++read 2048/2048 bytes at offset 4298458112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298462208 ++read 2048/2048 bytes at offset 4298462208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298466304 ++read 2048/2048 bytes at offset 4298466304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298470400 ++read 2048/2048 bytes at offset 4298470400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298474496 ++read 2048/2048 bytes at offset 4298474496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298478592 ++read 2048/2048 bytes at offset 4298478592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298482688 ++read 2048/2048 bytes at offset 4298482688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298486784 ++read 2048/2048 bytes at offset 4298486784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298490880 ++read 2048/2048 bytes at offset 4298490880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298494976 ++read 2048/2048 bytes at offset 4298494976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298499072 ++read 2048/2048 bytes at offset 4298499072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298503168 ++read 2048/2048 bytes at offset 4298503168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298507264 ++read 2048/2048 bytes at offset 4298507264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298511360 ++read 2048/2048 bytes at offset 4298511360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298515456 ++read 2048/2048 bytes at offset 4298515456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298519552 ++read 2048/2048 bytes at offset 4298519552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298523648 ++read 2048/2048 bytes at offset 4298523648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298527744 ++read 2048/2048 bytes at offset 4298527744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298531840 ++read 2048/2048 bytes at offset 4298531840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298535936 ++read 2048/2048 bytes at offset 4298535936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298540032 ++read 2048/2048 bytes at offset 4298540032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298544128 ++read 2048/2048 bytes at offset 4298544128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298548224 ++read 2048/2048 bytes at offset 4298548224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298552320 ++read 2048/2048 bytes at offset 4298552320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298556416 ++read 2048/2048 bytes at offset 4298556416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298560512 ++read 2048/2048 bytes at offset 4298560512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298564608 ++read 2048/2048 bytes at offset 4298564608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298568704 ++read 2048/2048 bytes at offset 4298568704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298572800 ++read 2048/2048 bytes at offset 4298572800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298576896 ++read 2048/2048 bytes at offset 4298576896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298580992 ++read 2048/2048 bytes at offset 4298580992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298585088 ++read 2048/2048 bytes at offset 4298585088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298589184 ++read 2048/2048 bytes at offset 4298589184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298593280 ++read 2048/2048 bytes at offset 4298593280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298597376 ++read 2048/2048 bytes at offset 4298597376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298601472 ++read 2048/2048 bytes at offset 4298601472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298605568 ++read 2048/2048 bytes at offset 4298605568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298609664 ++read 2048/2048 bytes at offset 4298609664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298613760 ++read 2048/2048 bytes at offset 4298613760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298617856 ++read 2048/2048 bytes at offset 4298617856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298621952 ++read 2048/2048 bytes at offset 4298621952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298626048 ++read 2048/2048 bytes at offset 4298626048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298630144 ++read 2048/2048 bytes at offset 4298630144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298634240 ++read 2048/2048 bytes at offset 4298634240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298638336 ++read 2048/2048 bytes at offset 4298638336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298642432 ++read 2048/2048 bytes at offset 4298642432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298646528 ++read 2048/2048 bytes at offset 4298646528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298650624 ++read 2048/2048 bytes at offset 4298650624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298654720 ++read 2048/2048 bytes at offset 4298654720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298658816 ++read 2048/2048 bytes at offset 4298658816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298662912 ++read 2048/2048 bytes at offset 4298662912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298667008 ++read 2048/2048 bytes at offset 4298667008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298671104 ++read 2048/2048 bytes at offset 4298671104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298675200 ++read 2048/2048 bytes at offset 4298675200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298679296 ++read 2048/2048 bytes at offset 4298679296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298683392 ++read 2048/2048 bytes at offset 4298683392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298687488 ++read 2048/2048 bytes at offset 4298687488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298691584 ++read 2048/2048 bytes at offset 4298691584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298695680 ++read 2048/2048 bytes at offset 4298695680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298699776 ++read 2048/2048 bytes at offset 4298699776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298703872 ++read 2048/2048 bytes at offset 4298703872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298707968 ++read 2048/2048 bytes at offset 4298707968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298712064 ++read 2048/2048 bytes at offset 4298712064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298716160 ++read 2048/2048 bytes at offset 4298716160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298720256 ++read 2048/2048 bytes at offset 4298720256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298724352 ++read 2048/2048 bytes at offset 4298724352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298728448 ++read 2048/2048 bytes at offset 4298728448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298732544 ++read 2048/2048 bytes at offset 4298732544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298736640 ++read 2048/2048 bytes at offset 4298736640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298740736 ++read 2048/2048 bytes at offset 4298740736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298744832 ++read 2048/2048 bytes at offset 4298744832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298748928 ++read 2048/2048 bytes at offset 4298748928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298753024 ++read 2048/2048 bytes at offset 4298753024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298757120 ++read 2048/2048 bytes at offset 4298757120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298761216 ++read 2048/2048 bytes at offset 4298761216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298765312 ++read 2048/2048 bytes at offset 4298765312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298769408 ++read 2048/2048 bytes at offset 4298769408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298773504 ++read 2048/2048 bytes at offset 4298773504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298777600 ++read 2048/2048 bytes at offset 4298777600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298781696 ++read 2048/2048 bytes at offset 4298781696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298785792 ++read 2048/2048 bytes at offset 4298785792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298789888 ++read 2048/2048 bytes at offset 4298789888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298793984 ++read 2048/2048 bytes at offset 4298793984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298798080 ++read 2048/2048 bytes at offset 4298798080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298802176 ++read 2048/2048 bytes at offset 4298802176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298806272 ++read 2048/2048 bytes at offset 4298806272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298810368 ++read 2048/2048 bytes at offset 4298810368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298814464 ++read 2048/2048 bytes at offset 4298814464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298818560 ++read 2048/2048 bytes at offset 4298818560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298822656 ++read 2048/2048 bytes at offset 4298822656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298826752 ++read 2048/2048 bytes at offset 4298826752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298830848 ++read 2048/2048 bytes at offset 4298830848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298834944 ++read 2048/2048 bytes at offset 4298834944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298839040 ++read 2048/2048 bytes at offset 4298839040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298843136 ++read 2048/2048 bytes at offset 4298843136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298847232 ++read 2048/2048 bytes at offset 4298847232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298851328 ++read 2048/2048 bytes at offset 4298851328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298855424 ++read 2048/2048 bytes at offset 4298855424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298859520 ++read 2048/2048 bytes at offset 4298859520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298863616 ++read 2048/2048 bytes at offset 4298863616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298867712 ++read 2048/2048 bytes at offset 4298867712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298871808 ++read 2048/2048 bytes at offset 4298871808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298875904 ++read 2048/2048 bytes at offset 4298875904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298880000 ++read 2048/2048 bytes at offset 4298880000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298884096 ++read 2048/2048 bytes at offset 4298884096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298888192 ++read 2048/2048 bytes at offset 4298888192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298892288 ++read 2048/2048 bytes at offset 4298892288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298896384 ++read 2048/2048 bytes at offset 4298896384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298900480 ++read 2048/2048 bytes at offset 4298900480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298904576 ++read 2048/2048 bytes at offset 4298904576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298908672 ++read 2048/2048 bytes at offset 4298908672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298912768 ++read 2048/2048 bytes at offset 4298912768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298916864 ++read 2048/2048 bytes at offset 4298916864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298920960 ++read 2048/2048 bytes at offset 4298920960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298925056 ++read 2048/2048 bytes at offset 4298925056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298929152 ++read 2048/2048 bytes at offset 4298929152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298933248 ++read 2048/2048 bytes at offset 4298933248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298937344 ++read 2048/2048 bytes at offset 4298937344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298941440 ++read 2048/2048 bytes at offset 4298941440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298945536 ++read 2048/2048 bytes at offset 4298945536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298949632 ++read 2048/2048 bytes at offset 4298949632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298953728 ++read 2048/2048 bytes at offset 4298953728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298957824 ++read 2048/2048 bytes at offset 4298957824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298961920 ++read 2048/2048 bytes at offset 4298961920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298966016 ++read 2048/2048 bytes at offset 4298966016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298970112 ++read 2048/2048 bytes at offset 4298970112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298974208 ++read 2048/2048 bytes at offset 4298974208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298978304 ++read 2048/2048 bytes at offset 4298978304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298982400 ++read 2048/2048 bytes at offset 4298982400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298986496 ++read 2048/2048 bytes at offset 4298986496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298990592 ++read 2048/2048 bytes at offset 4298990592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298994688 ++read 2048/2048 bytes at offset 4298994688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4298998784 ++read 2048/2048 bytes at offset 4298998784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299002880 ++read 2048/2048 bytes at offset 4299002880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299006976 ++read 2048/2048 bytes at offset 4299006976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299011072 ++read 2048/2048 bytes at offset 4299011072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299015168 ++read 2048/2048 bytes at offset 4299015168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299019264 ++read 2048/2048 bytes at offset 4299019264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299023360 ++read 2048/2048 bytes at offset 4299023360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299027456 ++read 2048/2048 bytes at offset 4299027456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299031552 ++read 2048/2048 bytes at offset 4299031552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299035648 ++read 2048/2048 bytes at offset 4299035648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299039744 ++read 2048/2048 bytes at offset 4299039744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299043840 ++read 2048/2048 bytes at offset 4299043840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299047936 ++read 2048/2048 bytes at offset 4299047936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299052032 ++read 2048/2048 bytes at offset 4299052032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299056128 ++read 2048/2048 bytes at offset 4299056128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299060224 ++read 2048/2048 bytes at offset 4299060224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299064320 ++read 2048/2048 bytes at offset 4299064320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299068416 ++read 2048/2048 bytes at offset 4299068416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299072512 ++read 2048/2048 bytes at offset 4299072512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299076608 ++read 2048/2048 bytes at offset 4299076608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299080704 ++read 2048/2048 bytes at offset 4299080704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299084800 ++read 2048/2048 bytes at offset 4299084800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299088896 ++read 2048/2048 bytes at offset 4299088896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299092992 ++read 2048/2048 bytes at offset 4299092992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299097088 ++read 2048/2048 bytes at offset 4299097088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299101184 ++read 2048/2048 bytes at offset 4299101184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299105280 ++read 2048/2048 bytes at offset 4299105280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299109376 ++read 2048/2048 bytes at offset 4299109376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299113472 ++read 2048/2048 bytes at offset 4299113472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299117568 ++read 2048/2048 bytes at offset 4299117568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299121664 ++read 2048/2048 bytes at offset 4299121664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299125760 ++read 2048/2048 bytes at offset 4299125760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299129856 ++read 2048/2048 bytes at offset 4299129856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299133952 ++read 2048/2048 bytes at offset 4299133952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299138048 ++read 2048/2048 bytes at offset 4299138048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299142144 ++read 2048/2048 bytes at offset 4299142144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299146240 ++read 2048/2048 bytes at offset 4299146240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299150336 ++read 2048/2048 bytes at offset 4299150336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299154432 ++read 2048/2048 bytes at offset 4299154432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4299158528 ++read 2048/2048 bytes at offset 4299158528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 4 +-qemu-io> read 8192/8192 bytes at offset 4299163648 ++=== IO: pattern 4 ++read 8192/8192 bytes at offset 4299163648 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299175936 ++read 8192/8192 bytes at offset 4299175936 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299188224 ++read 8192/8192 bytes at offset 4299188224 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299200512 ++read 8192/8192 bytes at offset 4299200512 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299212800 ++read 8192/8192 bytes at offset 4299212800 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299225088 ++read 8192/8192 bytes at offset 4299225088 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299237376 ++read 8192/8192 bytes at offset 4299237376 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299249664 ++read 8192/8192 bytes at offset 4299249664 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299261952 ++read 8192/8192 bytes at offset 4299261952 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299274240 ++read 8192/8192 bytes at offset 4299274240 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299286528 ++read 8192/8192 bytes at offset 4299286528 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299298816 ++read 8192/8192 bytes at offset 4299298816 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299311104 ++read 8192/8192 bytes at offset 4299311104 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299323392 ++read 8192/8192 bytes at offset 4299323392 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299335680 ++read 8192/8192 bytes at offset 4299335680 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299347968 ++read 8192/8192 bytes at offset 4299347968 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299360256 ++read 8192/8192 bytes at offset 4299360256 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299372544 ++read 8192/8192 bytes at offset 4299372544 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299384832 ++read 8192/8192 bytes at offset 4299384832 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299397120 ++read 8192/8192 bytes at offset 4299397120 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299409408 ++read 8192/8192 bytes at offset 4299409408 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299421696 ++read 8192/8192 bytes at offset 4299421696 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299433984 ++read 8192/8192 bytes at offset 4299433984 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299446272 ++read 8192/8192 bytes at offset 4299446272 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299458560 ++read 8192/8192 bytes at offset 4299458560 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299470848 ++read 8192/8192 bytes at offset 4299470848 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299483136 ++read 8192/8192 bytes at offset 4299483136 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299495424 ++read 8192/8192 bytes at offset 4299495424 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299507712 ++read 8192/8192 bytes at offset 4299507712 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299520000 ++read 8192/8192 bytes at offset 4299520000 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299532288 ++read 8192/8192 bytes at offset 4299532288 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299544576 ++read 8192/8192 bytes at offset 4299544576 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299556864 ++read 8192/8192 bytes at offset 4299556864 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299569152 ++read 8192/8192 bytes at offset 4299569152 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299581440 ++read 8192/8192 bytes at offset 4299581440 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299593728 ++read 8192/8192 bytes at offset 4299593728 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299606016 ++read 8192/8192 bytes at offset 4299606016 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299618304 ++read 8192/8192 bytes at offset 4299618304 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299630592 ++read 8192/8192 bytes at offset 4299630592 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299642880 ++read 8192/8192 bytes at offset 4299642880 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299655168 ++read 8192/8192 bytes at offset 4299655168 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299667456 ++read 8192/8192 bytes at offset 4299667456 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299679744 ++read 8192/8192 bytes at offset 4299679744 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299692032 ++read 8192/8192 bytes at offset 4299692032 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299704320 ++read 8192/8192 bytes at offset 4299704320 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299716608 ++read 8192/8192 bytes at offset 4299716608 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299728896 ++read 8192/8192 bytes at offset 4299728896 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299741184 ++read 8192/8192 bytes at offset 4299741184 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299753472 ++read 8192/8192 bytes at offset 4299753472 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299765760 ++read 8192/8192 bytes at offset 4299765760 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299778048 ++read 8192/8192 bytes at offset 4299778048 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299790336 ++read 8192/8192 bytes at offset 4299790336 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299802624 ++read 8192/8192 bytes at offset 4299802624 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299814912 ++read 8192/8192 bytes at offset 4299814912 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299827200 ++read 8192/8192 bytes at offset 4299827200 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299839488 ++read 8192/8192 bytes at offset 4299839488 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299851776 ++read 8192/8192 bytes at offset 4299851776 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299864064 ++read 8192/8192 bytes at offset 4299864064 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299876352 ++read 8192/8192 bytes at offset 4299876352 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299888640 ++read 8192/8192 bytes at offset 4299888640 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299900928 ++read 8192/8192 bytes at offset 4299900928 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299913216 ++read 8192/8192 bytes at offset 4299913216 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299925504 ++read 8192/8192 bytes at offset 4299925504 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4299937792 ++read 8192/8192 bytes at offset 4299937792 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 244 +-qemu-io> read 12288/12288 bytes at offset 4301252608 ++=== IO: pattern 244 ++read 12288/12288 bytes at offset 4301252608 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4303351808 ++read 12288/12288 bytes at offset 4303351808 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4305451008 ++read 12288/12288 bytes at offset 4305451008 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4307550208 ++read 12288/12288 bytes at offset 4307550208 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4309649408 ++read 12288/12288 bytes at offset 4309649408 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4311748608 ++read 12288/12288 bytes at offset 4311748608 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4313847808 ++read 12288/12288 bytes at offset 4313847808 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4315947008 ++read 12288/12288 bytes at offset 4315947008 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> No errors were found on the image. ++No errors were found on the image. + *** done +diff --git a/tests/qemu-iotests/023.out b/tests/qemu-iotests/023.out +index 10c5684..ec32341 100644 +--- a/tests/qemu-iotests/023.out ++++ b/tests/qemu-iotests/023.out +@@ -6,5662 +6,5662 @@ Testing empty image + + At offset 0: + === IO: pattern 0 +-qemu-io> wrote 1024/1024 bytes at offset 0 ++wrote 1024/1024 bytes at offset 0 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 1024 ++wrote 1024/1024 bytes at offset 1024 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 2048 ++wrote 1024/1024 bytes at offset 2048 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 3072 ++wrote 1024/1024 bytes at offset 3072 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4096 ++wrote 1024/1024 bytes at offset 4096 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 5120 ++wrote 1024/1024 bytes at offset 5120 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 6144 ++wrote 1024/1024 bytes at offset 6144 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 7168 ++wrote 1024/1024 bytes at offset 7168 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 8192 ++wrote 1024/1024 bytes at offset 8192 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 9216 ++wrote 1024/1024 bytes at offset 9216 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 10240 ++wrote 1024/1024 bytes at offset 10240 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 11264 ++wrote 1024/1024 bytes at offset 11264 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 12288 ++wrote 1024/1024 bytes at offset 12288 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 13312 ++wrote 1024/1024 bytes at offset 13312 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 14336 ++wrote 1024/1024 bytes at offset 14336 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 15360 ++wrote 1024/1024 bytes at offset 15360 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 16384 ++wrote 1024/1024 bytes at offset 16384 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 17408 ++wrote 1024/1024 bytes at offset 17408 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 18432 ++wrote 1024/1024 bytes at offset 18432 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 19456 ++wrote 1024/1024 bytes at offset 19456 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 20480 ++wrote 1024/1024 bytes at offset 20480 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 21504 ++wrote 1024/1024 bytes at offset 21504 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 22528 ++wrote 1024/1024 bytes at offset 22528 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 23552 ++wrote 1024/1024 bytes at offset 23552 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 24576 ++wrote 1024/1024 bytes at offset 24576 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 25600 ++wrote 1024/1024 bytes at offset 25600 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 26624 ++wrote 1024/1024 bytes at offset 26624 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 27648 ++wrote 1024/1024 bytes at offset 27648 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 28672 ++wrote 1024/1024 bytes at offset 28672 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 29696 ++wrote 1024/1024 bytes at offset 29696 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 30720 ++wrote 1024/1024 bytes at offset 30720 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 31744 ++wrote 1024/1024 bytes at offset 31744 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 32768 ++wrote 1024/1024 bytes at offset 32768 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 33792 ++wrote 1024/1024 bytes at offset 33792 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 34816 ++wrote 1024/1024 bytes at offset 34816 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 35840 ++wrote 1024/1024 bytes at offset 35840 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 73 +-qemu-io> wrote 512/512 bytes at offset 37376 ++=== IO: pattern 73 ++wrote 512/512 bytes at offset 37376 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 38400 ++wrote 512/512 bytes at offset 38400 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 39424 ++wrote 512/512 bytes at offset 39424 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 40448 ++wrote 512/512 bytes at offset 40448 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 41472 ++wrote 512/512 bytes at offset 41472 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 42496 ++wrote 512/512 bytes at offset 42496 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 43520 ++wrote 512/512 bytes at offset 43520 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 44544 ++wrote 512/512 bytes at offset 44544 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 45568 ++wrote 512/512 bytes at offset 45568 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 46592 ++wrote 512/512 bytes at offset 46592 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 47616 ++wrote 512/512 bytes at offset 47616 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 48640 ++wrote 512/512 bytes at offset 48640 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 49664 ++wrote 512/512 bytes at offset 49664 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 50688 ++wrote 512/512 bytes at offset 50688 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 51712 ++wrote 512/512 bytes at offset 51712 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 52736 ++wrote 512/512 bytes at offset 52736 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 53760 ++wrote 512/512 bytes at offset 53760 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 54784 ++wrote 512/512 bytes at offset 54784 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 55808 ++wrote 512/512 bytes at offset 55808 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 56832 ++wrote 512/512 bytes at offset 56832 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 57856 ++wrote 512/512 bytes at offset 57856 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 58880 ++wrote 512/512 bytes at offset 58880 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 59904 ++wrote 512/512 bytes at offset 59904 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 60928 ++wrote 512/512 bytes at offset 60928 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 61952 ++wrote 512/512 bytes at offset 61952 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 62976 ++wrote 512/512 bytes at offset 62976 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 64000 ++wrote 512/512 bytes at offset 64000 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 65024 ++wrote 512/512 bytes at offset 65024 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 66048 ++wrote 512/512 bytes at offset 66048 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 67072 ++wrote 512/512 bytes at offset 67072 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 68096 ++wrote 512/512 bytes at offset 68096 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 69120 ++wrote 512/512 bytes at offset 69120 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 70144 ++wrote 512/512 bytes at offset 70144 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 71168 ++wrote 512/512 bytes at offset 71168 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 72192 ++wrote 512/512 bytes at offset 72192 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 73216 ++wrote 512/512 bytes at offset 73216 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 144 +-qemu-io> wrote 512/512 bytes at offset 73728 ++=== IO: pattern 144 ++wrote 512/512 bytes at offset 73728 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 74752 ++wrote 512/512 bytes at offset 74752 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 75776 ++wrote 512/512 bytes at offset 75776 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 76800 ++wrote 512/512 bytes at offset 76800 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 77824 ++wrote 512/512 bytes at offset 77824 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 78848 ++wrote 512/512 bytes at offset 78848 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 79872 ++wrote 512/512 bytes at offset 79872 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 80896 ++wrote 512/512 bytes at offset 80896 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 81920 ++wrote 512/512 bytes at offset 81920 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 82944 ++wrote 512/512 bytes at offset 82944 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 83968 ++wrote 512/512 bytes at offset 83968 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 84992 ++wrote 512/512 bytes at offset 84992 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 86016 ++wrote 512/512 bytes at offset 86016 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 87040 ++wrote 512/512 bytes at offset 87040 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 88064 ++wrote 512/512 bytes at offset 88064 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 89088 ++wrote 512/512 bytes at offset 89088 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 90112 ++wrote 512/512 bytes at offset 90112 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 91136 ++wrote 512/512 bytes at offset 91136 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 92160 ++wrote 512/512 bytes at offset 92160 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 93184 ++wrote 512/512 bytes at offset 93184 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 94208 ++wrote 512/512 bytes at offset 94208 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 95232 ++wrote 512/512 bytes at offset 95232 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 96256 ++wrote 512/512 bytes at offset 96256 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 97280 ++wrote 512/512 bytes at offset 97280 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 98304 ++wrote 512/512 bytes at offset 98304 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 99328 ++wrote 512/512 bytes at offset 99328 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 100352 ++wrote 512/512 bytes at offset 100352 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 101376 ++wrote 512/512 bytes at offset 101376 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 102400 ++wrote 512/512 bytes at offset 102400 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 103424 ++wrote 512/512 bytes at offset 103424 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 104448 ++wrote 512/512 bytes at offset 104448 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 105472 ++wrote 512/512 bytes at offset 105472 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 106496 ++wrote 512/512 bytes at offset 106496 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 107520 ++wrote 512/512 bytes at offset 107520 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 108544 ++wrote 512/512 bytes at offset 108544 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 109568 ++wrote 512/512 bytes at offset 109568 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 216 +-qemu-io> offset 110848 is not sector aligned +-qemu-io> offset 111872 is not sector aligned +-qemu-io> offset 112896 is not sector aligned +-qemu-io> offset 113920 is not sector aligned +-qemu-io> offset 114944 is not sector aligned +-qemu-io> offset 115968 is not sector aligned +-qemu-io> offset 116992 is not sector aligned +-qemu-io> offset 118016 is not sector aligned +-qemu-io> offset 119040 is not sector aligned +-qemu-io> offset 120064 is not sector aligned +-qemu-io> offset 121088 is not sector aligned +-qemu-io> offset 122112 is not sector aligned +-qemu-io> offset 123136 is not sector aligned +-qemu-io> offset 124160 is not sector aligned +-qemu-io> offset 125184 is not sector aligned +-qemu-io> offset 126208 is not sector aligned +-qemu-io> offset 127232 is not sector aligned +-qemu-io> offset 128256 is not sector aligned +-qemu-io> offset 129280 is not sector aligned +-qemu-io> offset 130304 is not sector aligned +-qemu-io> offset 131328 is not sector aligned +-qemu-io> offset 132352 is not sector aligned +-qemu-io> offset 133376 is not sector aligned +-qemu-io> offset 134400 is not sector aligned +-qemu-io> offset 135424 is not sector aligned +-qemu-io> offset 136448 is not sector aligned +-qemu-io> offset 137472 is not sector aligned +-qemu-io> offset 138496 is not sector aligned +-qemu-io> offset 139520 is not sector aligned +-qemu-io> offset 140544 is not sector aligned +-qemu-io> offset 141568 is not sector aligned +-qemu-io> offset 142592 is not sector aligned +-qemu-io> offset 143616 is not sector aligned +-qemu-io> offset 144640 is not sector aligned +-qemu-io> offset 145664 is not sector aligned +-qemu-io> offset 146688 is not sector aligned +-qemu-io> === IO: pattern 33 +-qemu-io> wrote 2048/2048 bytes at offset 147968 ++=== IO: pattern 216 ++offset 110848 is not sector aligned ++offset 111872 is not sector aligned ++offset 112896 is not sector aligned ++offset 113920 is not sector aligned ++offset 114944 is not sector aligned ++offset 115968 is not sector aligned ++offset 116992 is not sector aligned ++offset 118016 is not sector aligned ++offset 119040 is not sector aligned ++offset 120064 is not sector aligned ++offset 121088 is not sector aligned ++offset 122112 is not sector aligned ++offset 123136 is not sector aligned ++offset 124160 is not sector aligned ++offset 125184 is not sector aligned ++offset 126208 is not sector aligned ++offset 127232 is not sector aligned ++offset 128256 is not sector aligned ++offset 129280 is not sector aligned ++offset 130304 is not sector aligned ++offset 131328 is not sector aligned ++offset 132352 is not sector aligned ++offset 133376 is not sector aligned ++offset 134400 is not sector aligned ++offset 135424 is not sector aligned ++offset 136448 is not sector aligned ++offset 137472 is not sector aligned ++offset 138496 is not sector aligned ++offset 139520 is not sector aligned ++offset 140544 is not sector aligned ++offset 141568 is not sector aligned ++offset 142592 is not sector aligned ++offset 143616 is not sector aligned ++offset 144640 is not sector aligned ++offset 145664 is not sector aligned ++offset 146688 is not sector aligned ++=== IO: pattern 33 ++wrote 2048/2048 bytes at offset 147968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 151040 ++wrote 2048/2048 bytes at offset 151040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 154112 ++wrote 2048/2048 bytes at offset 154112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 157184 ++wrote 2048/2048 bytes at offset 157184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 160256 ++wrote 2048/2048 bytes at offset 160256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 163328 ++wrote 2048/2048 bytes at offset 163328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 166400 ++wrote 2048/2048 bytes at offset 166400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 169472 ++wrote 2048/2048 bytes at offset 169472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 172544 ++wrote 2048/2048 bytes at offset 172544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 253 +-qemu-io> wrote 3072/3072 bytes at offset 260608 ++=== IO: pattern 253 ++wrote 3072/3072 bytes at offset 260608 + 3 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 3072/3072 bytes at offset 392192 ++wrote 3072/3072 bytes at offset 392192 + 3 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 3072/3072 bytes at offset 523776 ++wrote 3072/3072 bytes at offset 523776 + 3 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> read 1024/1024 bytes at offset 0 ++=== IO: pattern 0 ++read 1024/1024 bytes at offset 0 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 1024 ++read 1024/1024 bytes at offset 1024 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 2048 ++read 1024/1024 bytes at offset 2048 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 3072 ++read 1024/1024 bytes at offset 3072 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4096 ++read 1024/1024 bytes at offset 4096 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 5120 ++read 1024/1024 bytes at offset 5120 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 6144 ++read 1024/1024 bytes at offset 6144 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 7168 ++read 1024/1024 bytes at offset 7168 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 8192 ++read 1024/1024 bytes at offset 8192 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 9216 ++read 1024/1024 bytes at offset 9216 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 10240 ++read 1024/1024 bytes at offset 10240 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 11264 ++read 1024/1024 bytes at offset 11264 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 12288 ++read 1024/1024 bytes at offset 12288 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 13312 ++read 1024/1024 bytes at offset 13312 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 14336 ++read 1024/1024 bytes at offset 14336 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 15360 ++read 1024/1024 bytes at offset 15360 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 16384 ++read 1024/1024 bytes at offset 16384 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 17408 ++read 1024/1024 bytes at offset 17408 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 18432 ++read 1024/1024 bytes at offset 18432 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 19456 ++read 1024/1024 bytes at offset 19456 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 20480 ++read 1024/1024 bytes at offset 20480 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 21504 ++read 1024/1024 bytes at offset 21504 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 22528 ++read 1024/1024 bytes at offset 22528 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 23552 ++read 1024/1024 bytes at offset 23552 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 24576 ++read 1024/1024 bytes at offset 24576 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 25600 ++read 1024/1024 bytes at offset 25600 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 26624 ++read 1024/1024 bytes at offset 26624 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 27648 ++read 1024/1024 bytes at offset 27648 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 28672 ++read 1024/1024 bytes at offset 28672 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 29696 ++read 1024/1024 bytes at offset 29696 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 30720 ++read 1024/1024 bytes at offset 30720 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 31744 ++read 1024/1024 bytes at offset 31744 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 32768 ++read 1024/1024 bytes at offset 32768 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 33792 ++read 1024/1024 bytes at offset 33792 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 34816 ++read 1024/1024 bytes at offset 34816 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 35840 ++read 1024/1024 bytes at offset 35840 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 73 +-qemu-io> read 512/512 bytes at offset 37376 ++=== IO: pattern 73 ++read 512/512 bytes at offset 37376 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 38400 ++read 512/512 bytes at offset 38400 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 39424 ++read 512/512 bytes at offset 39424 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 40448 ++read 512/512 bytes at offset 40448 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 41472 ++read 512/512 bytes at offset 41472 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 42496 ++read 512/512 bytes at offset 42496 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 43520 ++read 512/512 bytes at offset 43520 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 44544 ++read 512/512 bytes at offset 44544 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 45568 ++read 512/512 bytes at offset 45568 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 46592 ++read 512/512 bytes at offset 46592 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 47616 ++read 512/512 bytes at offset 47616 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 48640 ++read 512/512 bytes at offset 48640 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 49664 ++read 512/512 bytes at offset 49664 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 50688 ++read 512/512 bytes at offset 50688 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 51712 ++read 512/512 bytes at offset 51712 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 52736 ++read 512/512 bytes at offset 52736 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 53760 ++read 512/512 bytes at offset 53760 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 54784 ++read 512/512 bytes at offset 54784 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 55808 ++read 512/512 bytes at offset 55808 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 56832 ++read 512/512 bytes at offset 56832 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 57856 ++read 512/512 bytes at offset 57856 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 58880 ++read 512/512 bytes at offset 58880 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 59904 ++read 512/512 bytes at offset 59904 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 60928 ++read 512/512 bytes at offset 60928 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 61952 ++read 512/512 bytes at offset 61952 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 62976 ++read 512/512 bytes at offset 62976 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 64000 ++read 512/512 bytes at offset 64000 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 65024 ++read 512/512 bytes at offset 65024 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 66048 ++read 512/512 bytes at offset 66048 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 67072 ++read 512/512 bytes at offset 67072 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 68096 ++read 512/512 bytes at offset 68096 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 69120 ++read 512/512 bytes at offset 69120 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 70144 ++read 512/512 bytes at offset 70144 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 71168 ++read 512/512 bytes at offset 71168 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 72192 ++read 512/512 bytes at offset 72192 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 73216 ++read 512/512 bytes at offset 73216 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 144 +-qemu-io> read 512/512 bytes at offset 73728 ++=== IO: pattern 144 ++read 512/512 bytes at offset 73728 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 74752 ++read 512/512 bytes at offset 74752 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 75776 ++read 512/512 bytes at offset 75776 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 76800 ++read 512/512 bytes at offset 76800 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 77824 ++read 512/512 bytes at offset 77824 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 78848 ++read 512/512 bytes at offset 78848 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 79872 ++read 512/512 bytes at offset 79872 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 80896 ++read 512/512 bytes at offset 80896 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 81920 ++read 512/512 bytes at offset 81920 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 82944 ++read 512/512 bytes at offset 82944 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 83968 ++read 512/512 bytes at offset 83968 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 84992 ++read 512/512 bytes at offset 84992 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 86016 ++read 512/512 bytes at offset 86016 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 87040 ++read 512/512 bytes at offset 87040 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 88064 ++read 512/512 bytes at offset 88064 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 89088 ++read 512/512 bytes at offset 89088 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 90112 ++read 512/512 bytes at offset 90112 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 91136 ++read 512/512 bytes at offset 91136 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 92160 ++read 512/512 bytes at offset 92160 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 93184 ++read 512/512 bytes at offset 93184 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 94208 ++read 512/512 bytes at offset 94208 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 95232 ++read 512/512 bytes at offset 95232 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 96256 ++read 512/512 bytes at offset 96256 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 97280 ++read 512/512 bytes at offset 97280 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 98304 ++read 512/512 bytes at offset 98304 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 99328 ++read 512/512 bytes at offset 99328 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 100352 ++read 512/512 bytes at offset 100352 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 101376 ++read 512/512 bytes at offset 101376 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 102400 ++read 512/512 bytes at offset 102400 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 103424 ++read 512/512 bytes at offset 103424 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 104448 ++read 512/512 bytes at offset 104448 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 105472 ++read 512/512 bytes at offset 105472 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 106496 ++read 512/512 bytes at offset 106496 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 107520 ++read 512/512 bytes at offset 107520 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 108544 ++read 512/512 bytes at offset 108544 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 109568 ++read 512/512 bytes at offset 109568 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 216 +-qemu-io> offset 110848 is not sector aligned +-qemu-io> offset 111872 is not sector aligned +-qemu-io> offset 112896 is not sector aligned +-qemu-io> offset 113920 is not sector aligned +-qemu-io> offset 114944 is not sector aligned +-qemu-io> offset 115968 is not sector aligned +-qemu-io> offset 116992 is not sector aligned +-qemu-io> offset 118016 is not sector aligned +-qemu-io> offset 119040 is not sector aligned +-qemu-io> offset 120064 is not sector aligned +-qemu-io> offset 121088 is not sector aligned +-qemu-io> offset 122112 is not sector aligned +-qemu-io> offset 123136 is not sector aligned +-qemu-io> offset 124160 is not sector aligned +-qemu-io> offset 125184 is not sector aligned +-qemu-io> offset 126208 is not sector aligned +-qemu-io> offset 127232 is not sector aligned +-qemu-io> offset 128256 is not sector aligned +-qemu-io> offset 129280 is not sector aligned +-qemu-io> offset 130304 is not sector aligned +-qemu-io> offset 131328 is not sector aligned +-qemu-io> offset 132352 is not sector aligned +-qemu-io> offset 133376 is not sector aligned +-qemu-io> offset 134400 is not sector aligned +-qemu-io> offset 135424 is not sector aligned +-qemu-io> offset 136448 is not sector aligned +-qemu-io> offset 137472 is not sector aligned +-qemu-io> offset 138496 is not sector aligned +-qemu-io> offset 139520 is not sector aligned +-qemu-io> offset 140544 is not sector aligned +-qemu-io> offset 141568 is not sector aligned +-qemu-io> offset 142592 is not sector aligned +-qemu-io> offset 143616 is not sector aligned +-qemu-io> offset 144640 is not sector aligned +-qemu-io> offset 145664 is not sector aligned +-qemu-io> offset 146688 is not sector aligned +-qemu-io> === IO: pattern 33 +-qemu-io> read 2048/2048 bytes at offset 147968 ++=== IO: pattern 216 ++offset 110848 is not sector aligned ++offset 111872 is not sector aligned ++offset 112896 is not sector aligned ++offset 113920 is not sector aligned ++offset 114944 is not sector aligned ++offset 115968 is not sector aligned ++offset 116992 is not sector aligned ++offset 118016 is not sector aligned ++offset 119040 is not sector aligned ++offset 120064 is not sector aligned ++offset 121088 is not sector aligned ++offset 122112 is not sector aligned ++offset 123136 is not sector aligned ++offset 124160 is not sector aligned ++offset 125184 is not sector aligned ++offset 126208 is not sector aligned ++offset 127232 is not sector aligned ++offset 128256 is not sector aligned ++offset 129280 is not sector aligned ++offset 130304 is not sector aligned ++offset 131328 is not sector aligned ++offset 132352 is not sector aligned ++offset 133376 is not sector aligned ++offset 134400 is not sector aligned ++offset 135424 is not sector aligned ++offset 136448 is not sector aligned ++offset 137472 is not sector aligned ++offset 138496 is not sector aligned ++offset 139520 is not sector aligned ++offset 140544 is not sector aligned ++offset 141568 is not sector aligned ++offset 142592 is not sector aligned ++offset 143616 is not sector aligned ++offset 144640 is not sector aligned ++offset 145664 is not sector aligned ++offset 146688 is not sector aligned ++=== IO: pattern 33 ++read 2048/2048 bytes at offset 147968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 151040 ++read 2048/2048 bytes at offset 151040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 154112 ++read 2048/2048 bytes at offset 154112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 157184 ++read 2048/2048 bytes at offset 157184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 160256 ++read 2048/2048 bytes at offset 160256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 163328 ++read 2048/2048 bytes at offset 163328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 166400 ++read 2048/2048 bytes at offset 166400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 169472 ++read 2048/2048 bytes at offset 169472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 172544 ++read 2048/2048 bytes at offset 172544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 253 +-qemu-io> read 3072/3072 bytes at offset 260608 ++=== IO: pattern 253 ++read 3072/3072 bytes at offset 260608 + 3 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 3072/3072 bytes at offset 392192 ++read 3072/3072 bytes at offset 392192 + 3 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 3072/3072 bytes at offset 523776 ++read 3072/3072 bytes at offset 523776 + 3 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> wrote 1024/1024 bytes at offset 0 ++=== IO: pattern 0 ++wrote 1024/1024 bytes at offset 0 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 1024 ++wrote 1024/1024 bytes at offset 1024 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 2048 ++wrote 1024/1024 bytes at offset 2048 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 3072 ++wrote 1024/1024 bytes at offset 3072 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4096 ++wrote 1024/1024 bytes at offset 4096 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 5120 ++wrote 1024/1024 bytes at offset 5120 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 6144 ++wrote 1024/1024 bytes at offset 6144 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 7168 ++wrote 1024/1024 bytes at offset 7168 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 8192 ++wrote 1024/1024 bytes at offset 8192 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 9216 ++wrote 1024/1024 bytes at offset 9216 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 10240 ++wrote 1024/1024 bytes at offset 10240 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 11264 ++wrote 1024/1024 bytes at offset 11264 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 12288 ++wrote 1024/1024 bytes at offset 12288 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 13312 ++wrote 1024/1024 bytes at offset 13312 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 14336 ++wrote 1024/1024 bytes at offset 14336 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 15360 ++wrote 1024/1024 bytes at offset 15360 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 16384 ++wrote 1024/1024 bytes at offset 16384 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 17408 ++wrote 1024/1024 bytes at offset 17408 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 18432 ++wrote 1024/1024 bytes at offset 18432 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 19456 ++wrote 1024/1024 bytes at offset 19456 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 20480 ++wrote 1024/1024 bytes at offset 20480 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 21504 ++wrote 1024/1024 bytes at offset 21504 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 22528 ++wrote 1024/1024 bytes at offset 22528 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 23552 ++wrote 1024/1024 bytes at offset 23552 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 24576 ++wrote 1024/1024 bytes at offset 24576 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 25600 ++wrote 1024/1024 bytes at offset 25600 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 26624 ++wrote 1024/1024 bytes at offset 26624 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 27648 ++wrote 1024/1024 bytes at offset 27648 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 28672 ++wrote 1024/1024 bytes at offset 28672 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 29696 ++wrote 1024/1024 bytes at offset 29696 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 30720 ++wrote 1024/1024 bytes at offset 30720 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 31744 ++wrote 1024/1024 bytes at offset 31744 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 32768 ++wrote 1024/1024 bytes at offset 32768 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 33792 ++wrote 1024/1024 bytes at offset 33792 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 34816 ++wrote 1024/1024 bytes at offset 34816 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 35840 ++wrote 1024/1024 bytes at offset 35840 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 73 +-qemu-io> wrote 512/512 bytes at offset 37376 ++=== IO: pattern 73 ++wrote 512/512 bytes at offset 37376 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 38400 ++wrote 512/512 bytes at offset 38400 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 39424 ++wrote 512/512 bytes at offset 39424 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 40448 ++wrote 512/512 bytes at offset 40448 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 41472 ++wrote 512/512 bytes at offset 41472 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 42496 ++wrote 512/512 bytes at offset 42496 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 43520 ++wrote 512/512 bytes at offset 43520 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 44544 ++wrote 512/512 bytes at offset 44544 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 45568 ++wrote 512/512 bytes at offset 45568 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 46592 ++wrote 512/512 bytes at offset 46592 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 47616 ++wrote 512/512 bytes at offset 47616 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 48640 ++wrote 512/512 bytes at offset 48640 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 49664 ++wrote 512/512 bytes at offset 49664 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 50688 ++wrote 512/512 bytes at offset 50688 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 51712 ++wrote 512/512 bytes at offset 51712 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 52736 ++wrote 512/512 bytes at offset 52736 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 53760 ++wrote 512/512 bytes at offset 53760 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 54784 ++wrote 512/512 bytes at offset 54784 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 55808 ++wrote 512/512 bytes at offset 55808 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 56832 ++wrote 512/512 bytes at offset 56832 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 57856 ++wrote 512/512 bytes at offset 57856 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 58880 ++wrote 512/512 bytes at offset 58880 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 59904 ++wrote 512/512 bytes at offset 59904 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 60928 ++wrote 512/512 bytes at offset 60928 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 61952 ++wrote 512/512 bytes at offset 61952 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 62976 ++wrote 512/512 bytes at offset 62976 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 64000 ++wrote 512/512 bytes at offset 64000 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 65024 ++wrote 512/512 bytes at offset 65024 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 66048 ++wrote 512/512 bytes at offset 66048 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 67072 ++wrote 512/512 bytes at offset 67072 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 68096 ++wrote 512/512 bytes at offset 68096 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 69120 ++wrote 512/512 bytes at offset 69120 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 70144 ++wrote 512/512 bytes at offset 70144 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 71168 ++wrote 512/512 bytes at offset 71168 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 72192 ++wrote 512/512 bytes at offset 72192 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 73216 ++wrote 512/512 bytes at offset 73216 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 144 +-qemu-io> wrote 512/512 bytes at offset 73728 ++=== IO: pattern 144 ++wrote 512/512 bytes at offset 73728 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 74752 ++wrote 512/512 bytes at offset 74752 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 75776 ++wrote 512/512 bytes at offset 75776 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 76800 ++wrote 512/512 bytes at offset 76800 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 77824 ++wrote 512/512 bytes at offset 77824 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 78848 ++wrote 512/512 bytes at offset 78848 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 79872 ++wrote 512/512 bytes at offset 79872 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 80896 ++wrote 512/512 bytes at offset 80896 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 81920 ++wrote 512/512 bytes at offset 81920 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 82944 ++wrote 512/512 bytes at offset 82944 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 83968 ++wrote 512/512 bytes at offset 83968 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 84992 ++wrote 512/512 bytes at offset 84992 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 86016 ++wrote 512/512 bytes at offset 86016 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 87040 ++wrote 512/512 bytes at offset 87040 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 88064 ++wrote 512/512 bytes at offset 88064 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 89088 ++wrote 512/512 bytes at offset 89088 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 90112 ++wrote 512/512 bytes at offset 90112 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 91136 ++wrote 512/512 bytes at offset 91136 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 92160 ++wrote 512/512 bytes at offset 92160 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 93184 ++wrote 512/512 bytes at offset 93184 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 94208 ++wrote 512/512 bytes at offset 94208 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 95232 ++wrote 512/512 bytes at offset 95232 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 96256 ++wrote 512/512 bytes at offset 96256 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 97280 ++wrote 512/512 bytes at offset 97280 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 98304 ++wrote 512/512 bytes at offset 98304 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 99328 ++wrote 512/512 bytes at offset 99328 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 100352 ++wrote 512/512 bytes at offset 100352 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 101376 ++wrote 512/512 bytes at offset 101376 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 102400 ++wrote 512/512 bytes at offset 102400 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 103424 ++wrote 512/512 bytes at offset 103424 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 104448 ++wrote 512/512 bytes at offset 104448 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 105472 ++wrote 512/512 bytes at offset 105472 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 106496 ++wrote 512/512 bytes at offset 106496 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 107520 ++wrote 512/512 bytes at offset 107520 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 108544 ++wrote 512/512 bytes at offset 108544 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 109568 ++wrote 512/512 bytes at offset 109568 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 216 +-qemu-io> offset 110848 is not sector aligned +-qemu-io> offset 111872 is not sector aligned +-qemu-io> offset 112896 is not sector aligned +-qemu-io> offset 113920 is not sector aligned +-qemu-io> offset 114944 is not sector aligned +-qemu-io> offset 115968 is not sector aligned +-qemu-io> offset 116992 is not sector aligned +-qemu-io> offset 118016 is not sector aligned +-qemu-io> offset 119040 is not sector aligned +-qemu-io> offset 120064 is not sector aligned +-qemu-io> offset 121088 is not sector aligned +-qemu-io> offset 122112 is not sector aligned +-qemu-io> offset 123136 is not sector aligned +-qemu-io> offset 124160 is not sector aligned +-qemu-io> offset 125184 is not sector aligned +-qemu-io> offset 126208 is not sector aligned +-qemu-io> offset 127232 is not sector aligned +-qemu-io> offset 128256 is not sector aligned +-qemu-io> offset 129280 is not sector aligned +-qemu-io> offset 130304 is not sector aligned +-qemu-io> offset 131328 is not sector aligned +-qemu-io> offset 132352 is not sector aligned +-qemu-io> offset 133376 is not sector aligned +-qemu-io> offset 134400 is not sector aligned +-qemu-io> offset 135424 is not sector aligned +-qemu-io> offset 136448 is not sector aligned +-qemu-io> offset 137472 is not sector aligned +-qemu-io> offset 138496 is not sector aligned +-qemu-io> offset 139520 is not sector aligned +-qemu-io> offset 140544 is not sector aligned +-qemu-io> offset 141568 is not sector aligned +-qemu-io> offset 142592 is not sector aligned +-qemu-io> offset 143616 is not sector aligned +-qemu-io> offset 144640 is not sector aligned +-qemu-io> offset 145664 is not sector aligned +-qemu-io> offset 146688 is not sector aligned +-qemu-io> === IO: pattern 33 +-qemu-io> wrote 2048/2048 bytes at offset 147968 ++=== IO: pattern 216 ++offset 110848 is not sector aligned ++offset 111872 is not sector aligned ++offset 112896 is not sector aligned ++offset 113920 is not sector aligned ++offset 114944 is not sector aligned ++offset 115968 is not sector aligned ++offset 116992 is not sector aligned ++offset 118016 is not sector aligned ++offset 119040 is not sector aligned ++offset 120064 is not sector aligned ++offset 121088 is not sector aligned ++offset 122112 is not sector aligned ++offset 123136 is not sector aligned ++offset 124160 is not sector aligned ++offset 125184 is not sector aligned ++offset 126208 is not sector aligned ++offset 127232 is not sector aligned ++offset 128256 is not sector aligned ++offset 129280 is not sector aligned ++offset 130304 is not sector aligned ++offset 131328 is not sector aligned ++offset 132352 is not sector aligned ++offset 133376 is not sector aligned ++offset 134400 is not sector aligned ++offset 135424 is not sector aligned ++offset 136448 is not sector aligned ++offset 137472 is not sector aligned ++offset 138496 is not sector aligned ++offset 139520 is not sector aligned ++offset 140544 is not sector aligned ++offset 141568 is not sector aligned ++offset 142592 is not sector aligned ++offset 143616 is not sector aligned ++offset 144640 is not sector aligned ++offset 145664 is not sector aligned ++offset 146688 is not sector aligned ++=== IO: pattern 33 ++wrote 2048/2048 bytes at offset 147968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 151040 ++wrote 2048/2048 bytes at offset 151040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 154112 ++wrote 2048/2048 bytes at offset 154112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 157184 ++wrote 2048/2048 bytes at offset 157184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 160256 ++wrote 2048/2048 bytes at offset 160256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 163328 ++wrote 2048/2048 bytes at offset 163328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 166400 ++wrote 2048/2048 bytes at offset 166400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 169472 ++wrote 2048/2048 bytes at offset 169472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 172544 ++wrote 2048/2048 bytes at offset 172544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 253 +-qemu-io> wrote 3072/3072 bytes at offset 260608 ++=== IO: pattern 253 ++wrote 3072/3072 bytes at offset 260608 + 3 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 3072/3072 bytes at offset 392192 ++wrote 3072/3072 bytes at offset 392192 + 3 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 3072/3072 bytes at offset 523776 ++wrote 3072/3072 bytes at offset 523776 + 3 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> read 1024/1024 bytes at offset 0 ++=== IO: pattern 0 ++read 1024/1024 bytes at offset 0 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 1024 ++read 1024/1024 bytes at offset 1024 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 2048 ++read 1024/1024 bytes at offset 2048 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 3072 ++read 1024/1024 bytes at offset 3072 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4096 ++read 1024/1024 bytes at offset 4096 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 5120 ++read 1024/1024 bytes at offset 5120 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 6144 ++read 1024/1024 bytes at offset 6144 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 7168 ++read 1024/1024 bytes at offset 7168 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 8192 ++read 1024/1024 bytes at offset 8192 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 9216 ++read 1024/1024 bytes at offset 9216 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 10240 ++read 1024/1024 bytes at offset 10240 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 11264 ++read 1024/1024 bytes at offset 11264 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 12288 ++read 1024/1024 bytes at offset 12288 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 13312 ++read 1024/1024 bytes at offset 13312 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 14336 ++read 1024/1024 bytes at offset 14336 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 15360 ++read 1024/1024 bytes at offset 15360 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 16384 ++read 1024/1024 bytes at offset 16384 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 17408 ++read 1024/1024 bytes at offset 17408 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 18432 ++read 1024/1024 bytes at offset 18432 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 19456 ++read 1024/1024 bytes at offset 19456 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 20480 ++read 1024/1024 bytes at offset 20480 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 21504 ++read 1024/1024 bytes at offset 21504 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 22528 ++read 1024/1024 bytes at offset 22528 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 23552 ++read 1024/1024 bytes at offset 23552 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 24576 ++read 1024/1024 bytes at offset 24576 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 25600 ++read 1024/1024 bytes at offset 25600 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 26624 ++read 1024/1024 bytes at offset 26624 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 27648 ++read 1024/1024 bytes at offset 27648 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 28672 ++read 1024/1024 bytes at offset 28672 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 29696 ++read 1024/1024 bytes at offset 29696 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 30720 ++read 1024/1024 bytes at offset 30720 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 31744 ++read 1024/1024 bytes at offset 31744 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 32768 ++read 1024/1024 bytes at offset 32768 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 33792 ++read 1024/1024 bytes at offset 33792 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 34816 ++read 1024/1024 bytes at offset 34816 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 35840 ++read 1024/1024 bytes at offset 35840 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 73 +-qemu-io> read 512/512 bytes at offset 37376 ++=== IO: pattern 73 ++read 512/512 bytes at offset 37376 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 38400 ++read 512/512 bytes at offset 38400 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 39424 ++read 512/512 bytes at offset 39424 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 40448 ++read 512/512 bytes at offset 40448 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 41472 ++read 512/512 bytes at offset 41472 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 42496 ++read 512/512 bytes at offset 42496 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 43520 ++read 512/512 bytes at offset 43520 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 44544 ++read 512/512 bytes at offset 44544 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 45568 ++read 512/512 bytes at offset 45568 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 46592 ++read 512/512 bytes at offset 46592 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 47616 ++read 512/512 bytes at offset 47616 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 48640 ++read 512/512 bytes at offset 48640 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 49664 ++read 512/512 bytes at offset 49664 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 50688 ++read 512/512 bytes at offset 50688 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 51712 ++read 512/512 bytes at offset 51712 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 52736 ++read 512/512 bytes at offset 52736 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 53760 ++read 512/512 bytes at offset 53760 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 54784 ++read 512/512 bytes at offset 54784 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 55808 ++read 512/512 bytes at offset 55808 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 56832 ++read 512/512 bytes at offset 56832 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 57856 ++read 512/512 bytes at offset 57856 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 58880 ++read 512/512 bytes at offset 58880 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 59904 ++read 512/512 bytes at offset 59904 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 60928 ++read 512/512 bytes at offset 60928 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 61952 ++read 512/512 bytes at offset 61952 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 62976 ++read 512/512 bytes at offset 62976 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 64000 ++read 512/512 bytes at offset 64000 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 65024 ++read 512/512 bytes at offset 65024 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 66048 ++read 512/512 bytes at offset 66048 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 67072 ++read 512/512 bytes at offset 67072 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 68096 ++read 512/512 bytes at offset 68096 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 69120 ++read 512/512 bytes at offset 69120 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 70144 ++read 512/512 bytes at offset 70144 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 71168 ++read 512/512 bytes at offset 71168 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 72192 ++read 512/512 bytes at offset 72192 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 73216 ++read 512/512 bytes at offset 73216 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 144 +-qemu-io> read 512/512 bytes at offset 73728 ++=== IO: pattern 144 ++read 512/512 bytes at offset 73728 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 74752 ++read 512/512 bytes at offset 74752 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 75776 ++read 512/512 bytes at offset 75776 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 76800 ++read 512/512 bytes at offset 76800 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 77824 ++read 512/512 bytes at offset 77824 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 78848 ++read 512/512 bytes at offset 78848 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 79872 ++read 512/512 bytes at offset 79872 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 80896 ++read 512/512 bytes at offset 80896 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 81920 ++read 512/512 bytes at offset 81920 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 82944 ++read 512/512 bytes at offset 82944 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 83968 ++read 512/512 bytes at offset 83968 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 84992 ++read 512/512 bytes at offset 84992 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 86016 ++read 512/512 bytes at offset 86016 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 87040 ++read 512/512 bytes at offset 87040 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 88064 ++read 512/512 bytes at offset 88064 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 89088 ++read 512/512 bytes at offset 89088 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 90112 ++read 512/512 bytes at offset 90112 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 91136 ++read 512/512 bytes at offset 91136 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 92160 ++read 512/512 bytes at offset 92160 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 93184 ++read 512/512 bytes at offset 93184 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 94208 ++read 512/512 bytes at offset 94208 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 95232 ++read 512/512 bytes at offset 95232 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 96256 ++read 512/512 bytes at offset 96256 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 97280 ++read 512/512 bytes at offset 97280 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 98304 ++read 512/512 bytes at offset 98304 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 99328 ++read 512/512 bytes at offset 99328 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 100352 ++read 512/512 bytes at offset 100352 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 101376 ++read 512/512 bytes at offset 101376 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 102400 ++read 512/512 bytes at offset 102400 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 103424 ++read 512/512 bytes at offset 103424 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 104448 ++read 512/512 bytes at offset 104448 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 105472 ++read 512/512 bytes at offset 105472 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 106496 ++read 512/512 bytes at offset 106496 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 107520 ++read 512/512 bytes at offset 107520 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 108544 ++read 512/512 bytes at offset 108544 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 109568 ++read 512/512 bytes at offset 109568 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 216 +-qemu-io> offset 110848 is not sector aligned +-qemu-io> offset 111872 is not sector aligned +-qemu-io> offset 112896 is not sector aligned +-qemu-io> offset 113920 is not sector aligned +-qemu-io> offset 114944 is not sector aligned +-qemu-io> offset 115968 is not sector aligned +-qemu-io> offset 116992 is not sector aligned +-qemu-io> offset 118016 is not sector aligned +-qemu-io> offset 119040 is not sector aligned +-qemu-io> offset 120064 is not sector aligned +-qemu-io> offset 121088 is not sector aligned +-qemu-io> offset 122112 is not sector aligned +-qemu-io> offset 123136 is not sector aligned +-qemu-io> offset 124160 is not sector aligned +-qemu-io> offset 125184 is not sector aligned +-qemu-io> offset 126208 is not sector aligned +-qemu-io> offset 127232 is not sector aligned +-qemu-io> offset 128256 is not sector aligned +-qemu-io> offset 129280 is not sector aligned +-qemu-io> offset 130304 is not sector aligned +-qemu-io> offset 131328 is not sector aligned +-qemu-io> offset 132352 is not sector aligned +-qemu-io> offset 133376 is not sector aligned +-qemu-io> offset 134400 is not sector aligned +-qemu-io> offset 135424 is not sector aligned +-qemu-io> offset 136448 is not sector aligned +-qemu-io> offset 137472 is not sector aligned +-qemu-io> offset 138496 is not sector aligned +-qemu-io> offset 139520 is not sector aligned +-qemu-io> offset 140544 is not sector aligned +-qemu-io> offset 141568 is not sector aligned +-qemu-io> offset 142592 is not sector aligned +-qemu-io> offset 143616 is not sector aligned +-qemu-io> offset 144640 is not sector aligned +-qemu-io> offset 145664 is not sector aligned +-qemu-io> offset 146688 is not sector aligned +-qemu-io> === IO: pattern 33 +-qemu-io> read 2048/2048 bytes at offset 147968 ++=== IO: pattern 216 ++offset 110848 is not sector aligned ++offset 111872 is not sector aligned ++offset 112896 is not sector aligned ++offset 113920 is not sector aligned ++offset 114944 is not sector aligned ++offset 115968 is not sector aligned ++offset 116992 is not sector aligned ++offset 118016 is not sector aligned ++offset 119040 is not sector aligned ++offset 120064 is not sector aligned ++offset 121088 is not sector aligned ++offset 122112 is not sector aligned ++offset 123136 is not sector aligned ++offset 124160 is not sector aligned ++offset 125184 is not sector aligned ++offset 126208 is not sector aligned ++offset 127232 is not sector aligned ++offset 128256 is not sector aligned ++offset 129280 is not sector aligned ++offset 130304 is not sector aligned ++offset 131328 is not sector aligned ++offset 132352 is not sector aligned ++offset 133376 is not sector aligned ++offset 134400 is not sector aligned ++offset 135424 is not sector aligned ++offset 136448 is not sector aligned ++offset 137472 is not sector aligned ++offset 138496 is not sector aligned ++offset 139520 is not sector aligned ++offset 140544 is not sector aligned ++offset 141568 is not sector aligned ++offset 142592 is not sector aligned ++offset 143616 is not sector aligned ++offset 144640 is not sector aligned ++offset 145664 is not sector aligned ++offset 146688 is not sector aligned ++=== IO: pattern 33 ++read 2048/2048 bytes at offset 147968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 151040 ++read 2048/2048 bytes at offset 151040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 154112 ++read 2048/2048 bytes at offset 154112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 157184 ++read 2048/2048 bytes at offset 157184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 160256 ++read 2048/2048 bytes at offset 160256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 163328 ++read 2048/2048 bytes at offset 163328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 166400 ++read 2048/2048 bytes at offset 166400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 169472 ++read 2048/2048 bytes at offset 169472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 172544 ++read 2048/2048 bytes at offset 172544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 253 +-qemu-io> read 3072/3072 bytes at offset 260608 ++=== IO: pattern 253 ++read 3072/3072 bytes at offset 260608 + 3 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 3072/3072 bytes at offset 392192 ++read 3072/3072 bytes at offset 392192 + 3 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 3072/3072 bytes at offset 523776 ++read 3072/3072 bytes at offset 523776 + 3 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> No errors were found on the image. ++No errors were found on the image. + At offset 4294967296: + === IO: pattern 0 +-qemu-io> wrote 1024/1024 bytes at offset 4294967296 ++wrote 1024/1024 bytes at offset 4294967296 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294968320 ++wrote 1024/1024 bytes at offset 4294968320 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294969344 ++wrote 1024/1024 bytes at offset 4294969344 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294970368 ++wrote 1024/1024 bytes at offset 4294970368 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294971392 ++wrote 1024/1024 bytes at offset 4294971392 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294972416 ++wrote 1024/1024 bytes at offset 4294972416 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294973440 ++wrote 1024/1024 bytes at offset 4294973440 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294974464 ++wrote 1024/1024 bytes at offset 4294974464 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294975488 ++wrote 1024/1024 bytes at offset 4294975488 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294976512 ++wrote 1024/1024 bytes at offset 4294976512 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294977536 ++wrote 1024/1024 bytes at offset 4294977536 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294978560 ++wrote 1024/1024 bytes at offset 4294978560 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294979584 ++wrote 1024/1024 bytes at offset 4294979584 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294980608 ++wrote 1024/1024 bytes at offset 4294980608 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294981632 ++wrote 1024/1024 bytes at offset 4294981632 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294982656 ++wrote 1024/1024 bytes at offset 4294982656 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294983680 ++wrote 1024/1024 bytes at offset 4294983680 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294984704 ++wrote 1024/1024 bytes at offset 4294984704 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294985728 ++wrote 1024/1024 bytes at offset 4294985728 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294986752 ++wrote 1024/1024 bytes at offset 4294986752 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294987776 ++wrote 1024/1024 bytes at offset 4294987776 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294988800 ++wrote 1024/1024 bytes at offset 4294988800 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294989824 ++wrote 1024/1024 bytes at offset 4294989824 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294990848 ++wrote 1024/1024 bytes at offset 4294990848 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294991872 ++wrote 1024/1024 bytes at offset 4294991872 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294992896 ++wrote 1024/1024 bytes at offset 4294992896 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294993920 ++wrote 1024/1024 bytes at offset 4294993920 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294994944 ++wrote 1024/1024 bytes at offset 4294994944 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294995968 ++wrote 1024/1024 bytes at offset 4294995968 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294996992 ++wrote 1024/1024 bytes at offset 4294996992 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294998016 ++wrote 1024/1024 bytes at offset 4294998016 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294999040 ++wrote 1024/1024 bytes at offset 4294999040 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4295000064 ++wrote 1024/1024 bytes at offset 4295000064 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4295001088 ++wrote 1024/1024 bytes at offset 4295001088 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4295002112 ++wrote 1024/1024 bytes at offset 4295002112 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4295003136 ++wrote 1024/1024 bytes at offset 4295003136 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 73 +-qemu-io> wrote 512/512 bytes at offset 4295004672 ++=== IO: pattern 73 ++wrote 512/512 bytes at offset 4295004672 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295005696 ++wrote 512/512 bytes at offset 4295005696 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295006720 ++wrote 512/512 bytes at offset 4295006720 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295007744 ++wrote 512/512 bytes at offset 4295007744 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295008768 ++wrote 512/512 bytes at offset 4295008768 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295009792 ++wrote 512/512 bytes at offset 4295009792 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295010816 ++wrote 512/512 bytes at offset 4295010816 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295011840 ++wrote 512/512 bytes at offset 4295011840 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295012864 ++wrote 512/512 bytes at offset 4295012864 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295013888 ++wrote 512/512 bytes at offset 4295013888 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295014912 ++wrote 512/512 bytes at offset 4295014912 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295015936 ++wrote 512/512 bytes at offset 4295015936 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295016960 ++wrote 512/512 bytes at offset 4295016960 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295017984 ++wrote 512/512 bytes at offset 4295017984 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295019008 ++wrote 512/512 bytes at offset 4295019008 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295020032 ++wrote 512/512 bytes at offset 4295020032 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295021056 ++wrote 512/512 bytes at offset 4295021056 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295022080 ++wrote 512/512 bytes at offset 4295022080 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295023104 ++wrote 512/512 bytes at offset 4295023104 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295024128 ++wrote 512/512 bytes at offset 4295024128 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295025152 ++wrote 512/512 bytes at offset 4295025152 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295026176 ++wrote 512/512 bytes at offset 4295026176 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295027200 ++wrote 512/512 bytes at offset 4295027200 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295028224 ++wrote 512/512 bytes at offset 4295028224 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295029248 ++wrote 512/512 bytes at offset 4295029248 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295030272 ++wrote 512/512 bytes at offset 4295030272 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295031296 ++wrote 512/512 bytes at offset 4295031296 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295032320 ++wrote 512/512 bytes at offset 4295032320 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295033344 ++wrote 512/512 bytes at offset 4295033344 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295034368 ++wrote 512/512 bytes at offset 4295034368 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295035392 ++wrote 512/512 bytes at offset 4295035392 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295036416 ++wrote 512/512 bytes at offset 4295036416 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295037440 ++wrote 512/512 bytes at offset 4295037440 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295038464 ++wrote 512/512 bytes at offset 4295038464 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295039488 ++wrote 512/512 bytes at offset 4295039488 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295040512 ++wrote 512/512 bytes at offset 4295040512 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 144 +-qemu-io> wrote 512/512 bytes at offset 4295041024 ++=== IO: pattern 144 ++wrote 512/512 bytes at offset 4295041024 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295042048 ++wrote 512/512 bytes at offset 4295042048 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295043072 ++wrote 512/512 bytes at offset 4295043072 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295044096 ++wrote 512/512 bytes at offset 4295044096 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295045120 ++wrote 512/512 bytes at offset 4295045120 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295046144 ++wrote 512/512 bytes at offset 4295046144 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295047168 ++wrote 512/512 bytes at offset 4295047168 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295048192 ++wrote 512/512 bytes at offset 4295048192 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295049216 ++wrote 512/512 bytes at offset 4295049216 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295050240 ++wrote 512/512 bytes at offset 4295050240 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295051264 ++wrote 512/512 bytes at offset 4295051264 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295052288 ++wrote 512/512 bytes at offset 4295052288 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295053312 ++wrote 512/512 bytes at offset 4295053312 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295054336 ++wrote 512/512 bytes at offset 4295054336 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295055360 ++wrote 512/512 bytes at offset 4295055360 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295056384 ++wrote 512/512 bytes at offset 4295056384 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295057408 ++wrote 512/512 bytes at offset 4295057408 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295058432 ++wrote 512/512 bytes at offset 4295058432 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295059456 ++wrote 512/512 bytes at offset 4295059456 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295060480 ++wrote 512/512 bytes at offset 4295060480 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295061504 ++wrote 512/512 bytes at offset 4295061504 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295062528 ++wrote 512/512 bytes at offset 4295062528 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295063552 ++wrote 512/512 bytes at offset 4295063552 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295064576 ++wrote 512/512 bytes at offset 4295064576 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295065600 ++wrote 512/512 bytes at offset 4295065600 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295066624 ++wrote 512/512 bytes at offset 4295066624 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295067648 ++wrote 512/512 bytes at offset 4295067648 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295068672 ++wrote 512/512 bytes at offset 4295068672 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295069696 ++wrote 512/512 bytes at offset 4295069696 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295070720 ++wrote 512/512 bytes at offset 4295070720 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295071744 ++wrote 512/512 bytes at offset 4295071744 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295072768 ++wrote 512/512 bytes at offset 4295072768 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295073792 ++wrote 512/512 bytes at offset 4295073792 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295074816 ++wrote 512/512 bytes at offset 4295074816 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295075840 ++wrote 512/512 bytes at offset 4295075840 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295076864 ++wrote 512/512 bytes at offset 4295076864 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 216 +-qemu-io> offset 4295078144 is not sector aligned +-qemu-io> offset 4295079168 is not sector aligned +-qemu-io> offset 4295080192 is not sector aligned +-qemu-io> offset 4295081216 is not sector aligned +-qemu-io> offset 4295082240 is not sector aligned +-qemu-io> offset 4295083264 is not sector aligned +-qemu-io> offset 4295084288 is not sector aligned +-qemu-io> offset 4295085312 is not sector aligned +-qemu-io> offset 4295086336 is not sector aligned +-qemu-io> offset 4295087360 is not sector aligned +-qemu-io> offset 4295088384 is not sector aligned +-qemu-io> offset 4295089408 is not sector aligned +-qemu-io> offset 4295090432 is not sector aligned +-qemu-io> offset 4295091456 is not sector aligned +-qemu-io> offset 4295092480 is not sector aligned +-qemu-io> offset 4295093504 is not sector aligned +-qemu-io> offset 4295094528 is not sector aligned +-qemu-io> offset 4295095552 is not sector aligned +-qemu-io> offset 4295096576 is not sector aligned +-qemu-io> offset 4295097600 is not sector aligned +-qemu-io> offset 4295098624 is not sector aligned +-qemu-io> offset 4295099648 is not sector aligned +-qemu-io> offset 4295100672 is not sector aligned +-qemu-io> offset 4295101696 is not sector aligned +-qemu-io> offset 4295102720 is not sector aligned +-qemu-io> offset 4295103744 is not sector aligned +-qemu-io> offset 4295104768 is not sector aligned +-qemu-io> offset 4295105792 is not sector aligned +-qemu-io> offset 4295106816 is not sector aligned +-qemu-io> offset 4295107840 is not sector aligned +-qemu-io> offset 4295108864 is not sector aligned +-qemu-io> offset 4295109888 is not sector aligned +-qemu-io> offset 4295110912 is not sector aligned +-qemu-io> offset 4295111936 is not sector aligned +-qemu-io> offset 4295112960 is not sector aligned +-qemu-io> offset 4295113984 is not sector aligned +-qemu-io> === IO: pattern 33 +-qemu-io> wrote 2048/2048 bytes at offset 4295115264 ++=== IO: pattern 216 ++offset 4295078144 is not sector aligned ++offset 4295079168 is not sector aligned ++offset 4295080192 is not sector aligned ++offset 4295081216 is not sector aligned ++offset 4295082240 is not sector aligned ++offset 4295083264 is not sector aligned ++offset 4295084288 is not sector aligned ++offset 4295085312 is not sector aligned ++offset 4295086336 is not sector aligned ++offset 4295087360 is not sector aligned ++offset 4295088384 is not sector aligned ++offset 4295089408 is not sector aligned ++offset 4295090432 is not sector aligned ++offset 4295091456 is not sector aligned ++offset 4295092480 is not sector aligned ++offset 4295093504 is not sector aligned ++offset 4295094528 is not sector aligned ++offset 4295095552 is not sector aligned ++offset 4295096576 is not sector aligned ++offset 4295097600 is not sector aligned ++offset 4295098624 is not sector aligned ++offset 4295099648 is not sector aligned ++offset 4295100672 is not sector aligned ++offset 4295101696 is not sector aligned ++offset 4295102720 is not sector aligned ++offset 4295103744 is not sector aligned ++offset 4295104768 is not sector aligned ++offset 4295105792 is not sector aligned ++offset 4295106816 is not sector aligned ++offset 4295107840 is not sector aligned ++offset 4295108864 is not sector aligned ++offset 4295109888 is not sector aligned ++offset 4295110912 is not sector aligned ++offset 4295111936 is not sector aligned ++offset 4295112960 is not sector aligned ++offset 4295113984 is not sector aligned ++=== IO: pattern 33 ++wrote 2048/2048 bytes at offset 4295115264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295118336 ++wrote 2048/2048 bytes at offset 4295118336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295121408 ++wrote 2048/2048 bytes at offset 4295121408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295124480 ++wrote 2048/2048 bytes at offset 4295124480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295127552 ++wrote 2048/2048 bytes at offset 4295127552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295130624 ++wrote 2048/2048 bytes at offset 4295130624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295133696 ++wrote 2048/2048 bytes at offset 4295133696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295136768 ++wrote 2048/2048 bytes at offset 4295136768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295139840 ++wrote 2048/2048 bytes at offset 4295139840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 253 +-qemu-io> wrote 3072/3072 bytes at offset 4295227904 ++=== IO: pattern 253 ++wrote 3072/3072 bytes at offset 4295227904 + 3 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 3072/3072 bytes at offset 4295359488 ++wrote 3072/3072 bytes at offset 4295359488 + 3 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 3072/3072 bytes at offset 4295491072 ++wrote 3072/3072 bytes at offset 4295491072 + 3 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> read 1024/1024 bytes at offset 4294967296 ++=== IO: pattern 0 ++read 1024/1024 bytes at offset 4294967296 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294968320 ++read 1024/1024 bytes at offset 4294968320 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294969344 ++read 1024/1024 bytes at offset 4294969344 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294970368 ++read 1024/1024 bytes at offset 4294970368 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294971392 ++read 1024/1024 bytes at offset 4294971392 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294972416 ++read 1024/1024 bytes at offset 4294972416 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294973440 ++read 1024/1024 bytes at offset 4294973440 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294974464 ++read 1024/1024 bytes at offset 4294974464 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294975488 ++read 1024/1024 bytes at offset 4294975488 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294976512 ++read 1024/1024 bytes at offset 4294976512 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294977536 ++read 1024/1024 bytes at offset 4294977536 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294978560 ++read 1024/1024 bytes at offset 4294978560 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294979584 ++read 1024/1024 bytes at offset 4294979584 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294980608 ++read 1024/1024 bytes at offset 4294980608 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294981632 ++read 1024/1024 bytes at offset 4294981632 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294982656 ++read 1024/1024 bytes at offset 4294982656 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294983680 ++read 1024/1024 bytes at offset 4294983680 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294984704 ++read 1024/1024 bytes at offset 4294984704 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294985728 ++read 1024/1024 bytes at offset 4294985728 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294986752 ++read 1024/1024 bytes at offset 4294986752 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294987776 ++read 1024/1024 bytes at offset 4294987776 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294988800 ++read 1024/1024 bytes at offset 4294988800 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294989824 ++read 1024/1024 bytes at offset 4294989824 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294990848 ++read 1024/1024 bytes at offset 4294990848 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294991872 ++read 1024/1024 bytes at offset 4294991872 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294992896 ++read 1024/1024 bytes at offset 4294992896 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294993920 ++read 1024/1024 bytes at offset 4294993920 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294994944 ++read 1024/1024 bytes at offset 4294994944 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294995968 ++read 1024/1024 bytes at offset 4294995968 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294996992 ++read 1024/1024 bytes at offset 4294996992 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294998016 ++read 1024/1024 bytes at offset 4294998016 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294999040 ++read 1024/1024 bytes at offset 4294999040 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4295000064 ++read 1024/1024 bytes at offset 4295000064 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4295001088 ++read 1024/1024 bytes at offset 4295001088 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4295002112 ++read 1024/1024 bytes at offset 4295002112 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4295003136 ++read 1024/1024 bytes at offset 4295003136 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 73 +-qemu-io> read 512/512 bytes at offset 4295004672 ++=== IO: pattern 73 ++read 512/512 bytes at offset 4295004672 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295005696 ++read 512/512 bytes at offset 4295005696 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295006720 ++read 512/512 bytes at offset 4295006720 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295007744 ++read 512/512 bytes at offset 4295007744 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295008768 ++read 512/512 bytes at offset 4295008768 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295009792 ++read 512/512 bytes at offset 4295009792 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295010816 ++read 512/512 bytes at offset 4295010816 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295011840 ++read 512/512 bytes at offset 4295011840 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295012864 ++read 512/512 bytes at offset 4295012864 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295013888 ++read 512/512 bytes at offset 4295013888 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295014912 ++read 512/512 bytes at offset 4295014912 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295015936 ++read 512/512 bytes at offset 4295015936 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295016960 ++read 512/512 bytes at offset 4295016960 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295017984 ++read 512/512 bytes at offset 4295017984 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295019008 ++read 512/512 bytes at offset 4295019008 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295020032 ++read 512/512 bytes at offset 4295020032 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295021056 ++read 512/512 bytes at offset 4295021056 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295022080 ++read 512/512 bytes at offset 4295022080 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295023104 ++read 512/512 bytes at offset 4295023104 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295024128 ++read 512/512 bytes at offset 4295024128 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295025152 ++read 512/512 bytes at offset 4295025152 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295026176 ++read 512/512 bytes at offset 4295026176 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295027200 ++read 512/512 bytes at offset 4295027200 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295028224 ++read 512/512 bytes at offset 4295028224 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295029248 ++read 512/512 bytes at offset 4295029248 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295030272 ++read 512/512 bytes at offset 4295030272 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295031296 ++read 512/512 bytes at offset 4295031296 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295032320 ++read 512/512 bytes at offset 4295032320 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295033344 ++read 512/512 bytes at offset 4295033344 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295034368 ++read 512/512 bytes at offset 4295034368 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295035392 ++read 512/512 bytes at offset 4295035392 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295036416 ++read 512/512 bytes at offset 4295036416 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295037440 ++read 512/512 bytes at offset 4295037440 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295038464 ++read 512/512 bytes at offset 4295038464 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295039488 ++read 512/512 bytes at offset 4295039488 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295040512 ++read 512/512 bytes at offset 4295040512 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 144 +-qemu-io> read 512/512 bytes at offset 4295041024 ++=== IO: pattern 144 ++read 512/512 bytes at offset 4295041024 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295042048 ++read 512/512 bytes at offset 4295042048 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295043072 ++read 512/512 bytes at offset 4295043072 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295044096 ++read 512/512 bytes at offset 4295044096 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295045120 ++read 512/512 bytes at offset 4295045120 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295046144 ++read 512/512 bytes at offset 4295046144 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295047168 ++read 512/512 bytes at offset 4295047168 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295048192 ++read 512/512 bytes at offset 4295048192 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295049216 ++read 512/512 bytes at offset 4295049216 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295050240 ++read 512/512 bytes at offset 4295050240 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295051264 ++read 512/512 bytes at offset 4295051264 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295052288 ++read 512/512 bytes at offset 4295052288 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295053312 ++read 512/512 bytes at offset 4295053312 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295054336 ++read 512/512 bytes at offset 4295054336 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295055360 ++read 512/512 bytes at offset 4295055360 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295056384 ++read 512/512 bytes at offset 4295056384 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295057408 ++read 512/512 bytes at offset 4295057408 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295058432 ++read 512/512 bytes at offset 4295058432 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295059456 ++read 512/512 bytes at offset 4295059456 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295060480 ++read 512/512 bytes at offset 4295060480 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295061504 ++read 512/512 bytes at offset 4295061504 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295062528 ++read 512/512 bytes at offset 4295062528 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295063552 ++read 512/512 bytes at offset 4295063552 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295064576 ++read 512/512 bytes at offset 4295064576 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295065600 ++read 512/512 bytes at offset 4295065600 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295066624 ++read 512/512 bytes at offset 4295066624 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295067648 ++read 512/512 bytes at offset 4295067648 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295068672 ++read 512/512 bytes at offset 4295068672 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295069696 ++read 512/512 bytes at offset 4295069696 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295070720 ++read 512/512 bytes at offset 4295070720 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295071744 ++read 512/512 bytes at offset 4295071744 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295072768 ++read 512/512 bytes at offset 4295072768 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295073792 ++read 512/512 bytes at offset 4295073792 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295074816 ++read 512/512 bytes at offset 4295074816 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295075840 ++read 512/512 bytes at offset 4295075840 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295076864 ++read 512/512 bytes at offset 4295076864 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 216 +-qemu-io> offset 4295078144 is not sector aligned +-qemu-io> offset 4295079168 is not sector aligned +-qemu-io> offset 4295080192 is not sector aligned +-qemu-io> offset 4295081216 is not sector aligned +-qemu-io> offset 4295082240 is not sector aligned +-qemu-io> offset 4295083264 is not sector aligned +-qemu-io> offset 4295084288 is not sector aligned +-qemu-io> offset 4295085312 is not sector aligned +-qemu-io> offset 4295086336 is not sector aligned +-qemu-io> offset 4295087360 is not sector aligned +-qemu-io> offset 4295088384 is not sector aligned +-qemu-io> offset 4295089408 is not sector aligned +-qemu-io> offset 4295090432 is not sector aligned +-qemu-io> offset 4295091456 is not sector aligned +-qemu-io> offset 4295092480 is not sector aligned +-qemu-io> offset 4295093504 is not sector aligned +-qemu-io> offset 4295094528 is not sector aligned +-qemu-io> offset 4295095552 is not sector aligned +-qemu-io> offset 4295096576 is not sector aligned +-qemu-io> offset 4295097600 is not sector aligned +-qemu-io> offset 4295098624 is not sector aligned +-qemu-io> offset 4295099648 is not sector aligned +-qemu-io> offset 4295100672 is not sector aligned +-qemu-io> offset 4295101696 is not sector aligned +-qemu-io> offset 4295102720 is not sector aligned +-qemu-io> offset 4295103744 is not sector aligned +-qemu-io> offset 4295104768 is not sector aligned +-qemu-io> offset 4295105792 is not sector aligned +-qemu-io> offset 4295106816 is not sector aligned +-qemu-io> offset 4295107840 is not sector aligned +-qemu-io> offset 4295108864 is not sector aligned +-qemu-io> offset 4295109888 is not sector aligned +-qemu-io> offset 4295110912 is not sector aligned +-qemu-io> offset 4295111936 is not sector aligned +-qemu-io> offset 4295112960 is not sector aligned +-qemu-io> offset 4295113984 is not sector aligned +-qemu-io> === IO: pattern 33 +-qemu-io> read 2048/2048 bytes at offset 4295115264 ++=== IO: pattern 216 ++offset 4295078144 is not sector aligned ++offset 4295079168 is not sector aligned ++offset 4295080192 is not sector aligned ++offset 4295081216 is not sector aligned ++offset 4295082240 is not sector aligned ++offset 4295083264 is not sector aligned ++offset 4295084288 is not sector aligned ++offset 4295085312 is not sector aligned ++offset 4295086336 is not sector aligned ++offset 4295087360 is not sector aligned ++offset 4295088384 is not sector aligned ++offset 4295089408 is not sector aligned ++offset 4295090432 is not sector aligned ++offset 4295091456 is not sector aligned ++offset 4295092480 is not sector aligned ++offset 4295093504 is not sector aligned ++offset 4295094528 is not sector aligned ++offset 4295095552 is not sector aligned ++offset 4295096576 is not sector aligned ++offset 4295097600 is not sector aligned ++offset 4295098624 is not sector aligned ++offset 4295099648 is not sector aligned ++offset 4295100672 is not sector aligned ++offset 4295101696 is not sector aligned ++offset 4295102720 is not sector aligned ++offset 4295103744 is not sector aligned ++offset 4295104768 is not sector aligned ++offset 4295105792 is not sector aligned ++offset 4295106816 is not sector aligned ++offset 4295107840 is not sector aligned ++offset 4295108864 is not sector aligned ++offset 4295109888 is not sector aligned ++offset 4295110912 is not sector aligned ++offset 4295111936 is not sector aligned ++offset 4295112960 is not sector aligned ++offset 4295113984 is not sector aligned ++=== IO: pattern 33 ++read 2048/2048 bytes at offset 4295115264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295118336 ++read 2048/2048 bytes at offset 4295118336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295121408 ++read 2048/2048 bytes at offset 4295121408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295124480 ++read 2048/2048 bytes at offset 4295124480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295127552 ++read 2048/2048 bytes at offset 4295127552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295130624 ++read 2048/2048 bytes at offset 4295130624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295133696 ++read 2048/2048 bytes at offset 4295133696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295136768 ++read 2048/2048 bytes at offset 4295136768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295139840 ++read 2048/2048 bytes at offset 4295139840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 253 +-qemu-io> read 3072/3072 bytes at offset 4295227904 ++=== IO: pattern 253 ++read 3072/3072 bytes at offset 4295227904 + 3 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 3072/3072 bytes at offset 4295359488 ++read 3072/3072 bytes at offset 4295359488 + 3 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 3072/3072 bytes at offset 4295491072 ++read 3072/3072 bytes at offset 4295491072 + 3 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> wrote 1024/1024 bytes at offset 4294967296 ++=== IO: pattern 0 ++wrote 1024/1024 bytes at offset 4294967296 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294968320 ++wrote 1024/1024 bytes at offset 4294968320 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294969344 ++wrote 1024/1024 bytes at offset 4294969344 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294970368 ++wrote 1024/1024 bytes at offset 4294970368 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294971392 ++wrote 1024/1024 bytes at offset 4294971392 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294972416 ++wrote 1024/1024 bytes at offset 4294972416 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294973440 ++wrote 1024/1024 bytes at offset 4294973440 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294974464 ++wrote 1024/1024 bytes at offset 4294974464 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294975488 ++wrote 1024/1024 bytes at offset 4294975488 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294976512 ++wrote 1024/1024 bytes at offset 4294976512 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294977536 ++wrote 1024/1024 bytes at offset 4294977536 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294978560 ++wrote 1024/1024 bytes at offset 4294978560 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294979584 ++wrote 1024/1024 bytes at offset 4294979584 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294980608 ++wrote 1024/1024 bytes at offset 4294980608 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294981632 ++wrote 1024/1024 bytes at offset 4294981632 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294982656 ++wrote 1024/1024 bytes at offset 4294982656 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294983680 ++wrote 1024/1024 bytes at offset 4294983680 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294984704 ++wrote 1024/1024 bytes at offset 4294984704 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294985728 ++wrote 1024/1024 bytes at offset 4294985728 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294986752 ++wrote 1024/1024 bytes at offset 4294986752 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294987776 ++wrote 1024/1024 bytes at offset 4294987776 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294988800 ++wrote 1024/1024 bytes at offset 4294988800 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294989824 ++wrote 1024/1024 bytes at offset 4294989824 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294990848 ++wrote 1024/1024 bytes at offset 4294990848 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294991872 ++wrote 1024/1024 bytes at offset 4294991872 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294992896 ++wrote 1024/1024 bytes at offset 4294992896 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294993920 ++wrote 1024/1024 bytes at offset 4294993920 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294994944 ++wrote 1024/1024 bytes at offset 4294994944 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294995968 ++wrote 1024/1024 bytes at offset 4294995968 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294996992 ++wrote 1024/1024 bytes at offset 4294996992 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294998016 ++wrote 1024/1024 bytes at offset 4294998016 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294999040 ++wrote 1024/1024 bytes at offset 4294999040 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4295000064 ++wrote 1024/1024 bytes at offset 4295000064 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4295001088 ++wrote 1024/1024 bytes at offset 4295001088 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4295002112 ++wrote 1024/1024 bytes at offset 4295002112 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4295003136 ++wrote 1024/1024 bytes at offset 4295003136 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 73 +-qemu-io> wrote 512/512 bytes at offset 4295004672 ++=== IO: pattern 73 ++wrote 512/512 bytes at offset 4295004672 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295005696 ++wrote 512/512 bytes at offset 4295005696 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295006720 ++wrote 512/512 bytes at offset 4295006720 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295007744 ++wrote 512/512 bytes at offset 4295007744 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295008768 ++wrote 512/512 bytes at offset 4295008768 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295009792 ++wrote 512/512 bytes at offset 4295009792 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295010816 ++wrote 512/512 bytes at offset 4295010816 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295011840 ++wrote 512/512 bytes at offset 4295011840 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295012864 ++wrote 512/512 bytes at offset 4295012864 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295013888 ++wrote 512/512 bytes at offset 4295013888 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295014912 ++wrote 512/512 bytes at offset 4295014912 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295015936 ++wrote 512/512 bytes at offset 4295015936 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295016960 ++wrote 512/512 bytes at offset 4295016960 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295017984 ++wrote 512/512 bytes at offset 4295017984 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295019008 ++wrote 512/512 bytes at offset 4295019008 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295020032 ++wrote 512/512 bytes at offset 4295020032 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295021056 ++wrote 512/512 bytes at offset 4295021056 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295022080 ++wrote 512/512 bytes at offset 4295022080 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295023104 ++wrote 512/512 bytes at offset 4295023104 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295024128 ++wrote 512/512 bytes at offset 4295024128 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295025152 ++wrote 512/512 bytes at offset 4295025152 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295026176 ++wrote 512/512 bytes at offset 4295026176 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295027200 ++wrote 512/512 bytes at offset 4295027200 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295028224 ++wrote 512/512 bytes at offset 4295028224 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295029248 ++wrote 512/512 bytes at offset 4295029248 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295030272 ++wrote 512/512 bytes at offset 4295030272 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295031296 ++wrote 512/512 bytes at offset 4295031296 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295032320 ++wrote 512/512 bytes at offset 4295032320 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295033344 ++wrote 512/512 bytes at offset 4295033344 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295034368 ++wrote 512/512 bytes at offset 4295034368 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295035392 ++wrote 512/512 bytes at offset 4295035392 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295036416 ++wrote 512/512 bytes at offset 4295036416 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295037440 ++wrote 512/512 bytes at offset 4295037440 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295038464 ++wrote 512/512 bytes at offset 4295038464 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295039488 ++wrote 512/512 bytes at offset 4295039488 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295040512 ++wrote 512/512 bytes at offset 4295040512 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 144 +-qemu-io> wrote 512/512 bytes at offset 4295041024 ++=== IO: pattern 144 ++wrote 512/512 bytes at offset 4295041024 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295042048 ++wrote 512/512 bytes at offset 4295042048 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295043072 ++wrote 512/512 bytes at offset 4295043072 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295044096 ++wrote 512/512 bytes at offset 4295044096 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295045120 ++wrote 512/512 bytes at offset 4295045120 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295046144 ++wrote 512/512 bytes at offset 4295046144 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295047168 ++wrote 512/512 bytes at offset 4295047168 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295048192 ++wrote 512/512 bytes at offset 4295048192 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295049216 ++wrote 512/512 bytes at offset 4295049216 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295050240 ++wrote 512/512 bytes at offset 4295050240 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295051264 ++wrote 512/512 bytes at offset 4295051264 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295052288 ++wrote 512/512 bytes at offset 4295052288 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295053312 ++wrote 512/512 bytes at offset 4295053312 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295054336 ++wrote 512/512 bytes at offset 4295054336 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295055360 ++wrote 512/512 bytes at offset 4295055360 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295056384 ++wrote 512/512 bytes at offset 4295056384 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295057408 ++wrote 512/512 bytes at offset 4295057408 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295058432 ++wrote 512/512 bytes at offset 4295058432 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295059456 ++wrote 512/512 bytes at offset 4295059456 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295060480 ++wrote 512/512 bytes at offset 4295060480 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295061504 ++wrote 512/512 bytes at offset 4295061504 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295062528 ++wrote 512/512 bytes at offset 4295062528 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295063552 ++wrote 512/512 bytes at offset 4295063552 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295064576 ++wrote 512/512 bytes at offset 4295064576 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295065600 ++wrote 512/512 bytes at offset 4295065600 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295066624 ++wrote 512/512 bytes at offset 4295066624 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295067648 ++wrote 512/512 bytes at offset 4295067648 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295068672 ++wrote 512/512 bytes at offset 4295068672 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295069696 ++wrote 512/512 bytes at offset 4295069696 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295070720 ++wrote 512/512 bytes at offset 4295070720 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295071744 ++wrote 512/512 bytes at offset 4295071744 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295072768 ++wrote 512/512 bytes at offset 4295072768 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295073792 ++wrote 512/512 bytes at offset 4295073792 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295074816 ++wrote 512/512 bytes at offset 4295074816 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295075840 ++wrote 512/512 bytes at offset 4295075840 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295076864 ++wrote 512/512 bytes at offset 4295076864 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 216 +-qemu-io> offset 4295078144 is not sector aligned +-qemu-io> offset 4295079168 is not sector aligned +-qemu-io> offset 4295080192 is not sector aligned +-qemu-io> offset 4295081216 is not sector aligned +-qemu-io> offset 4295082240 is not sector aligned +-qemu-io> offset 4295083264 is not sector aligned +-qemu-io> offset 4295084288 is not sector aligned +-qemu-io> offset 4295085312 is not sector aligned +-qemu-io> offset 4295086336 is not sector aligned +-qemu-io> offset 4295087360 is not sector aligned +-qemu-io> offset 4295088384 is not sector aligned +-qemu-io> offset 4295089408 is not sector aligned +-qemu-io> offset 4295090432 is not sector aligned +-qemu-io> offset 4295091456 is not sector aligned +-qemu-io> offset 4295092480 is not sector aligned +-qemu-io> offset 4295093504 is not sector aligned +-qemu-io> offset 4295094528 is not sector aligned +-qemu-io> offset 4295095552 is not sector aligned +-qemu-io> offset 4295096576 is not sector aligned +-qemu-io> offset 4295097600 is not sector aligned +-qemu-io> offset 4295098624 is not sector aligned +-qemu-io> offset 4295099648 is not sector aligned +-qemu-io> offset 4295100672 is not sector aligned +-qemu-io> offset 4295101696 is not sector aligned +-qemu-io> offset 4295102720 is not sector aligned +-qemu-io> offset 4295103744 is not sector aligned +-qemu-io> offset 4295104768 is not sector aligned +-qemu-io> offset 4295105792 is not sector aligned +-qemu-io> offset 4295106816 is not sector aligned +-qemu-io> offset 4295107840 is not sector aligned +-qemu-io> offset 4295108864 is not sector aligned +-qemu-io> offset 4295109888 is not sector aligned +-qemu-io> offset 4295110912 is not sector aligned +-qemu-io> offset 4295111936 is not sector aligned +-qemu-io> offset 4295112960 is not sector aligned +-qemu-io> offset 4295113984 is not sector aligned +-qemu-io> === IO: pattern 33 +-qemu-io> wrote 2048/2048 bytes at offset 4295115264 ++=== IO: pattern 216 ++offset 4295078144 is not sector aligned ++offset 4295079168 is not sector aligned ++offset 4295080192 is not sector aligned ++offset 4295081216 is not sector aligned ++offset 4295082240 is not sector aligned ++offset 4295083264 is not sector aligned ++offset 4295084288 is not sector aligned ++offset 4295085312 is not sector aligned ++offset 4295086336 is not sector aligned ++offset 4295087360 is not sector aligned ++offset 4295088384 is not sector aligned ++offset 4295089408 is not sector aligned ++offset 4295090432 is not sector aligned ++offset 4295091456 is not sector aligned ++offset 4295092480 is not sector aligned ++offset 4295093504 is not sector aligned ++offset 4295094528 is not sector aligned ++offset 4295095552 is not sector aligned ++offset 4295096576 is not sector aligned ++offset 4295097600 is not sector aligned ++offset 4295098624 is not sector aligned ++offset 4295099648 is not sector aligned ++offset 4295100672 is not sector aligned ++offset 4295101696 is not sector aligned ++offset 4295102720 is not sector aligned ++offset 4295103744 is not sector aligned ++offset 4295104768 is not sector aligned ++offset 4295105792 is not sector aligned ++offset 4295106816 is not sector aligned ++offset 4295107840 is not sector aligned ++offset 4295108864 is not sector aligned ++offset 4295109888 is not sector aligned ++offset 4295110912 is not sector aligned ++offset 4295111936 is not sector aligned ++offset 4295112960 is not sector aligned ++offset 4295113984 is not sector aligned ++=== IO: pattern 33 ++wrote 2048/2048 bytes at offset 4295115264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295118336 ++wrote 2048/2048 bytes at offset 4295118336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295121408 ++wrote 2048/2048 bytes at offset 4295121408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295124480 ++wrote 2048/2048 bytes at offset 4295124480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295127552 ++wrote 2048/2048 bytes at offset 4295127552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295130624 ++wrote 2048/2048 bytes at offset 4295130624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295133696 ++wrote 2048/2048 bytes at offset 4295133696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295136768 ++wrote 2048/2048 bytes at offset 4295136768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295139840 ++wrote 2048/2048 bytes at offset 4295139840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 253 +-qemu-io> wrote 3072/3072 bytes at offset 4295227904 ++=== IO: pattern 253 ++wrote 3072/3072 bytes at offset 4295227904 + 3 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 3072/3072 bytes at offset 4295359488 ++wrote 3072/3072 bytes at offset 4295359488 + 3 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 3072/3072 bytes at offset 4295491072 ++wrote 3072/3072 bytes at offset 4295491072 + 3 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> read 1024/1024 bytes at offset 4294967296 ++=== IO: pattern 0 ++read 1024/1024 bytes at offset 4294967296 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294968320 ++read 1024/1024 bytes at offset 4294968320 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294969344 ++read 1024/1024 bytes at offset 4294969344 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294970368 ++read 1024/1024 bytes at offset 4294970368 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294971392 ++read 1024/1024 bytes at offset 4294971392 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294972416 ++read 1024/1024 bytes at offset 4294972416 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294973440 ++read 1024/1024 bytes at offset 4294973440 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294974464 ++read 1024/1024 bytes at offset 4294974464 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294975488 ++read 1024/1024 bytes at offset 4294975488 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294976512 ++read 1024/1024 bytes at offset 4294976512 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294977536 ++read 1024/1024 bytes at offset 4294977536 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294978560 ++read 1024/1024 bytes at offset 4294978560 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294979584 ++read 1024/1024 bytes at offset 4294979584 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294980608 ++read 1024/1024 bytes at offset 4294980608 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294981632 ++read 1024/1024 bytes at offset 4294981632 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294982656 ++read 1024/1024 bytes at offset 4294982656 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294983680 ++read 1024/1024 bytes at offset 4294983680 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294984704 ++read 1024/1024 bytes at offset 4294984704 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294985728 ++read 1024/1024 bytes at offset 4294985728 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294986752 ++read 1024/1024 bytes at offset 4294986752 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294987776 ++read 1024/1024 bytes at offset 4294987776 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294988800 ++read 1024/1024 bytes at offset 4294988800 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294989824 ++read 1024/1024 bytes at offset 4294989824 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294990848 ++read 1024/1024 bytes at offset 4294990848 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294991872 ++read 1024/1024 bytes at offset 4294991872 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294992896 ++read 1024/1024 bytes at offset 4294992896 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294993920 ++read 1024/1024 bytes at offset 4294993920 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294994944 ++read 1024/1024 bytes at offset 4294994944 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294995968 ++read 1024/1024 bytes at offset 4294995968 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294996992 ++read 1024/1024 bytes at offset 4294996992 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294998016 ++read 1024/1024 bytes at offset 4294998016 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294999040 ++read 1024/1024 bytes at offset 4294999040 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4295000064 ++read 1024/1024 bytes at offset 4295000064 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4295001088 ++read 1024/1024 bytes at offset 4295001088 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4295002112 ++read 1024/1024 bytes at offset 4295002112 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4295003136 ++read 1024/1024 bytes at offset 4295003136 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 73 +-qemu-io> read 512/512 bytes at offset 4295004672 ++=== IO: pattern 73 ++read 512/512 bytes at offset 4295004672 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295005696 ++read 512/512 bytes at offset 4295005696 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295006720 ++read 512/512 bytes at offset 4295006720 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295007744 ++read 512/512 bytes at offset 4295007744 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295008768 ++read 512/512 bytes at offset 4295008768 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295009792 ++read 512/512 bytes at offset 4295009792 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295010816 ++read 512/512 bytes at offset 4295010816 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295011840 ++read 512/512 bytes at offset 4295011840 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295012864 ++read 512/512 bytes at offset 4295012864 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295013888 ++read 512/512 bytes at offset 4295013888 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295014912 ++read 512/512 bytes at offset 4295014912 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295015936 ++read 512/512 bytes at offset 4295015936 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295016960 ++read 512/512 bytes at offset 4295016960 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295017984 ++read 512/512 bytes at offset 4295017984 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295019008 ++read 512/512 bytes at offset 4295019008 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295020032 ++read 512/512 bytes at offset 4295020032 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295021056 ++read 512/512 bytes at offset 4295021056 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295022080 ++read 512/512 bytes at offset 4295022080 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295023104 ++read 512/512 bytes at offset 4295023104 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295024128 ++read 512/512 bytes at offset 4295024128 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295025152 ++read 512/512 bytes at offset 4295025152 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295026176 ++read 512/512 bytes at offset 4295026176 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295027200 ++read 512/512 bytes at offset 4295027200 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295028224 ++read 512/512 bytes at offset 4295028224 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295029248 ++read 512/512 bytes at offset 4295029248 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295030272 ++read 512/512 bytes at offset 4295030272 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295031296 ++read 512/512 bytes at offset 4295031296 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295032320 ++read 512/512 bytes at offset 4295032320 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295033344 ++read 512/512 bytes at offset 4295033344 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295034368 ++read 512/512 bytes at offset 4295034368 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295035392 ++read 512/512 bytes at offset 4295035392 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295036416 ++read 512/512 bytes at offset 4295036416 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295037440 ++read 512/512 bytes at offset 4295037440 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295038464 ++read 512/512 bytes at offset 4295038464 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295039488 ++read 512/512 bytes at offset 4295039488 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295040512 ++read 512/512 bytes at offset 4295040512 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 144 +-qemu-io> read 512/512 bytes at offset 4295041024 ++=== IO: pattern 144 ++read 512/512 bytes at offset 4295041024 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295042048 ++read 512/512 bytes at offset 4295042048 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295043072 ++read 512/512 bytes at offset 4295043072 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295044096 ++read 512/512 bytes at offset 4295044096 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295045120 ++read 512/512 bytes at offset 4295045120 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295046144 ++read 512/512 bytes at offset 4295046144 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295047168 ++read 512/512 bytes at offset 4295047168 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295048192 ++read 512/512 bytes at offset 4295048192 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295049216 ++read 512/512 bytes at offset 4295049216 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295050240 ++read 512/512 bytes at offset 4295050240 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295051264 ++read 512/512 bytes at offset 4295051264 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295052288 ++read 512/512 bytes at offset 4295052288 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295053312 ++read 512/512 bytes at offset 4295053312 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295054336 ++read 512/512 bytes at offset 4295054336 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295055360 ++read 512/512 bytes at offset 4295055360 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295056384 ++read 512/512 bytes at offset 4295056384 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295057408 ++read 512/512 bytes at offset 4295057408 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295058432 ++read 512/512 bytes at offset 4295058432 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295059456 ++read 512/512 bytes at offset 4295059456 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295060480 ++read 512/512 bytes at offset 4295060480 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295061504 ++read 512/512 bytes at offset 4295061504 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295062528 ++read 512/512 bytes at offset 4295062528 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295063552 ++read 512/512 bytes at offset 4295063552 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295064576 ++read 512/512 bytes at offset 4295064576 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295065600 ++read 512/512 bytes at offset 4295065600 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295066624 ++read 512/512 bytes at offset 4295066624 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295067648 ++read 512/512 bytes at offset 4295067648 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295068672 ++read 512/512 bytes at offset 4295068672 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295069696 ++read 512/512 bytes at offset 4295069696 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295070720 ++read 512/512 bytes at offset 4295070720 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295071744 ++read 512/512 bytes at offset 4295071744 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295072768 ++read 512/512 bytes at offset 4295072768 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295073792 ++read 512/512 bytes at offset 4295073792 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295074816 ++read 512/512 bytes at offset 4295074816 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295075840 ++read 512/512 bytes at offset 4295075840 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295076864 ++read 512/512 bytes at offset 4295076864 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 216 +-qemu-io> offset 4295078144 is not sector aligned +-qemu-io> offset 4295079168 is not sector aligned +-qemu-io> offset 4295080192 is not sector aligned +-qemu-io> offset 4295081216 is not sector aligned +-qemu-io> offset 4295082240 is not sector aligned +-qemu-io> offset 4295083264 is not sector aligned +-qemu-io> offset 4295084288 is not sector aligned +-qemu-io> offset 4295085312 is not sector aligned +-qemu-io> offset 4295086336 is not sector aligned +-qemu-io> offset 4295087360 is not sector aligned +-qemu-io> offset 4295088384 is not sector aligned +-qemu-io> offset 4295089408 is not sector aligned +-qemu-io> offset 4295090432 is not sector aligned +-qemu-io> offset 4295091456 is not sector aligned +-qemu-io> offset 4295092480 is not sector aligned +-qemu-io> offset 4295093504 is not sector aligned +-qemu-io> offset 4295094528 is not sector aligned +-qemu-io> offset 4295095552 is not sector aligned +-qemu-io> offset 4295096576 is not sector aligned +-qemu-io> offset 4295097600 is not sector aligned +-qemu-io> offset 4295098624 is not sector aligned +-qemu-io> offset 4295099648 is not sector aligned +-qemu-io> offset 4295100672 is not sector aligned +-qemu-io> offset 4295101696 is not sector aligned +-qemu-io> offset 4295102720 is not sector aligned +-qemu-io> offset 4295103744 is not sector aligned +-qemu-io> offset 4295104768 is not sector aligned +-qemu-io> offset 4295105792 is not sector aligned +-qemu-io> offset 4295106816 is not sector aligned +-qemu-io> offset 4295107840 is not sector aligned +-qemu-io> offset 4295108864 is not sector aligned +-qemu-io> offset 4295109888 is not sector aligned +-qemu-io> offset 4295110912 is not sector aligned +-qemu-io> offset 4295111936 is not sector aligned +-qemu-io> offset 4295112960 is not sector aligned +-qemu-io> offset 4295113984 is not sector aligned +-qemu-io> === IO: pattern 33 +-qemu-io> read 2048/2048 bytes at offset 4295115264 ++=== IO: pattern 216 ++offset 4295078144 is not sector aligned ++offset 4295079168 is not sector aligned ++offset 4295080192 is not sector aligned ++offset 4295081216 is not sector aligned ++offset 4295082240 is not sector aligned ++offset 4295083264 is not sector aligned ++offset 4295084288 is not sector aligned ++offset 4295085312 is not sector aligned ++offset 4295086336 is not sector aligned ++offset 4295087360 is not sector aligned ++offset 4295088384 is not sector aligned ++offset 4295089408 is not sector aligned ++offset 4295090432 is not sector aligned ++offset 4295091456 is not sector aligned ++offset 4295092480 is not sector aligned ++offset 4295093504 is not sector aligned ++offset 4295094528 is not sector aligned ++offset 4295095552 is not sector aligned ++offset 4295096576 is not sector aligned ++offset 4295097600 is not sector aligned ++offset 4295098624 is not sector aligned ++offset 4295099648 is not sector aligned ++offset 4295100672 is not sector aligned ++offset 4295101696 is not sector aligned ++offset 4295102720 is not sector aligned ++offset 4295103744 is not sector aligned ++offset 4295104768 is not sector aligned ++offset 4295105792 is not sector aligned ++offset 4295106816 is not sector aligned ++offset 4295107840 is not sector aligned ++offset 4295108864 is not sector aligned ++offset 4295109888 is not sector aligned ++offset 4295110912 is not sector aligned ++offset 4295111936 is not sector aligned ++offset 4295112960 is not sector aligned ++offset 4295113984 is not sector aligned ++=== IO: pattern 33 ++read 2048/2048 bytes at offset 4295115264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295118336 ++read 2048/2048 bytes at offset 4295118336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295121408 ++read 2048/2048 bytes at offset 4295121408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295124480 ++read 2048/2048 bytes at offset 4295124480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295127552 ++read 2048/2048 bytes at offset 4295127552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295130624 ++read 2048/2048 bytes at offset 4295130624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295133696 ++read 2048/2048 bytes at offset 4295133696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295136768 ++read 2048/2048 bytes at offset 4295136768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295139840 ++read 2048/2048 bytes at offset 4295139840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 253 +-qemu-io> read 3072/3072 bytes at offset 4295227904 ++=== IO: pattern 253 ++read 3072/3072 bytes at offset 4295227904 + 3 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 3072/3072 bytes at offset 4295359488 ++read 3072/3072 bytes at offset 4295359488 + 3 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 3072/3072 bytes at offset 4295491072 ++read 3072/3072 bytes at offset 4295491072 + 3 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> No errors were found on the image. ++No errors were found on the image. + Compressing image + + Testing compressed image + + With offset 0: + === IO: pattern 0 +-qemu-io> read 1024/1024 bytes at offset 0 ++read 1024/1024 bytes at offset 0 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 1024 ++read 1024/1024 bytes at offset 1024 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 2048 ++read 1024/1024 bytes at offset 2048 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 3072 ++read 1024/1024 bytes at offset 3072 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4096 ++read 1024/1024 bytes at offset 4096 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 5120 ++read 1024/1024 bytes at offset 5120 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 6144 ++read 1024/1024 bytes at offset 6144 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 7168 ++read 1024/1024 bytes at offset 7168 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 8192 ++read 1024/1024 bytes at offset 8192 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 9216 ++read 1024/1024 bytes at offset 9216 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 10240 ++read 1024/1024 bytes at offset 10240 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 11264 ++read 1024/1024 bytes at offset 11264 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 12288 ++read 1024/1024 bytes at offset 12288 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 13312 ++read 1024/1024 bytes at offset 13312 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 14336 ++read 1024/1024 bytes at offset 14336 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 15360 ++read 1024/1024 bytes at offset 15360 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 16384 ++read 1024/1024 bytes at offset 16384 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 17408 ++read 1024/1024 bytes at offset 17408 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 18432 ++read 1024/1024 bytes at offset 18432 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 19456 ++read 1024/1024 bytes at offset 19456 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 20480 ++read 1024/1024 bytes at offset 20480 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 21504 ++read 1024/1024 bytes at offset 21504 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 22528 ++read 1024/1024 bytes at offset 22528 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 23552 ++read 1024/1024 bytes at offset 23552 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 24576 ++read 1024/1024 bytes at offset 24576 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 25600 ++read 1024/1024 bytes at offset 25600 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 26624 ++read 1024/1024 bytes at offset 26624 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 27648 ++read 1024/1024 bytes at offset 27648 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 28672 ++read 1024/1024 bytes at offset 28672 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 29696 ++read 1024/1024 bytes at offset 29696 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 30720 ++read 1024/1024 bytes at offset 30720 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 31744 ++read 1024/1024 bytes at offset 31744 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 32768 ++read 1024/1024 bytes at offset 32768 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 33792 ++read 1024/1024 bytes at offset 33792 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 34816 ++read 1024/1024 bytes at offset 34816 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 35840 ++read 1024/1024 bytes at offset 35840 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 73 +-qemu-io> read 512/512 bytes at offset 37376 ++=== IO: pattern 73 ++read 512/512 bytes at offset 37376 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 38400 ++read 512/512 bytes at offset 38400 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 39424 ++read 512/512 bytes at offset 39424 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 40448 ++read 512/512 bytes at offset 40448 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 41472 ++read 512/512 bytes at offset 41472 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 42496 ++read 512/512 bytes at offset 42496 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 43520 ++read 512/512 bytes at offset 43520 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 44544 ++read 512/512 bytes at offset 44544 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 45568 ++read 512/512 bytes at offset 45568 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 46592 ++read 512/512 bytes at offset 46592 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 47616 ++read 512/512 bytes at offset 47616 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 48640 ++read 512/512 bytes at offset 48640 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 49664 ++read 512/512 bytes at offset 49664 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 50688 ++read 512/512 bytes at offset 50688 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 51712 ++read 512/512 bytes at offset 51712 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 52736 ++read 512/512 bytes at offset 52736 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 53760 ++read 512/512 bytes at offset 53760 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 54784 ++read 512/512 bytes at offset 54784 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 55808 ++read 512/512 bytes at offset 55808 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 56832 ++read 512/512 bytes at offset 56832 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 57856 ++read 512/512 bytes at offset 57856 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 58880 ++read 512/512 bytes at offset 58880 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 59904 ++read 512/512 bytes at offset 59904 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 60928 ++read 512/512 bytes at offset 60928 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 61952 ++read 512/512 bytes at offset 61952 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 62976 ++read 512/512 bytes at offset 62976 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 64000 ++read 512/512 bytes at offset 64000 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 65024 ++read 512/512 bytes at offset 65024 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 66048 ++read 512/512 bytes at offset 66048 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 67072 ++read 512/512 bytes at offset 67072 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 68096 ++read 512/512 bytes at offset 68096 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 69120 ++read 512/512 bytes at offset 69120 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 70144 ++read 512/512 bytes at offset 70144 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 71168 ++read 512/512 bytes at offset 71168 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 72192 ++read 512/512 bytes at offset 72192 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 73216 ++read 512/512 bytes at offset 73216 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 144 +-qemu-io> read 512/512 bytes at offset 73728 ++=== IO: pattern 144 ++read 512/512 bytes at offset 73728 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 74752 ++read 512/512 bytes at offset 74752 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 75776 ++read 512/512 bytes at offset 75776 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 76800 ++read 512/512 bytes at offset 76800 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 77824 ++read 512/512 bytes at offset 77824 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 78848 ++read 512/512 bytes at offset 78848 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 79872 ++read 512/512 bytes at offset 79872 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 80896 ++read 512/512 bytes at offset 80896 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 81920 ++read 512/512 bytes at offset 81920 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 82944 ++read 512/512 bytes at offset 82944 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 83968 ++read 512/512 bytes at offset 83968 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 84992 ++read 512/512 bytes at offset 84992 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 86016 ++read 512/512 bytes at offset 86016 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 87040 ++read 512/512 bytes at offset 87040 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 88064 ++read 512/512 bytes at offset 88064 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 89088 ++read 512/512 bytes at offset 89088 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 90112 ++read 512/512 bytes at offset 90112 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 91136 ++read 512/512 bytes at offset 91136 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 92160 ++read 512/512 bytes at offset 92160 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 93184 ++read 512/512 bytes at offset 93184 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 94208 ++read 512/512 bytes at offset 94208 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 95232 ++read 512/512 bytes at offset 95232 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 96256 ++read 512/512 bytes at offset 96256 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 97280 ++read 512/512 bytes at offset 97280 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 98304 ++read 512/512 bytes at offset 98304 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 99328 ++read 512/512 bytes at offset 99328 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 100352 ++read 512/512 bytes at offset 100352 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 101376 ++read 512/512 bytes at offset 101376 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 102400 ++read 512/512 bytes at offset 102400 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 103424 ++read 512/512 bytes at offset 103424 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 104448 ++read 512/512 bytes at offset 104448 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 105472 ++read 512/512 bytes at offset 105472 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 106496 ++read 512/512 bytes at offset 106496 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 107520 ++read 512/512 bytes at offset 107520 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 108544 ++read 512/512 bytes at offset 108544 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 109568 ++read 512/512 bytes at offset 109568 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 216 +-qemu-io> offset 110848 is not sector aligned +-qemu-io> offset 111872 is not sector aligned +-qemu-io> offset 112896 is not sector aligned +-qemu-io> offset 113920 is not sector aligned +-qemu-io> offset 114944 is not sector aligned +-qemu-io> offset 115968 is not sector aligned +-qemu-io> offset 116992 is not sector aligned +-qemu-io> offset 118016 is not sector aligned +-qemu-io> offset 119040 is not sector aligned +-qemu-io> offset 120064 is not sector aligned +-qemu-io> offset 121088 is not sector aligned +-qemu-io> offset 122112 is not sector aligned +-qemu-io> offset 123136 is not sector aligned +-qemu-io> offset 124160 is not sector aligned +-qemu-io> offset 125184 is not sector aligned +-qemu-io> offset 126208 is not sector aligned +-qemu-io> offset 127232 is not sector aligned +-qemu-io> offset 128256 is not sector aligned +-qemu-io> offset 129280 is not sector aligned +-qemu-io> offset 130304 is not sector aligned +-qemu-io> offset 131328 is not sector aligned +-qemu-io> offset 132352 is not sector aligned +-qemu-io> offset 133376 is not sector aligned +-qemu-io> offset 134400 is not sector aligned +-qemu-io> offset 135424 is not sector aligned +-qemu-io> offset 136448 is not sector aligned +-qemu-io> offset 137472 is not sector aligned +-qemu-io> offset 138496 is not sector aligned +-qemu-io> offset 139520 is not sector aligned +-qemu-io> offset 140544 is not sector aligned +-qemu-io> offset 141568 is not sector aligned +-qemu-io> offset 142592 is not sector aligned +-qemu-io> offset 143616 is not sector aligned +-qemu-io> offset 144640 is not sector aligned +-qemu-io> offset 145664 is not sector aligned +-qemu-io> offset 146688 is not sector aligned +-qemu-io> === IO: pattern 33 +-qemu-io> read 2048/2048 bytes at offset 147968 ++=== IO: pattern 216 ++offset 110848 is not sector aligned ++offset 111872 is not sector aligned ++offset 112896 is not sector aligned ++offset 113920 is not sector aligned ++offset 114944 is not sector aligned ++offset 115968 is not sector aligned ++offset 116992 is not sector aligned ++offset 118016 is not sector aligned ++offset 119040 is not sector aligned ++offset 120064 is not sector aligned ++offset 121088 is not sector aligned ++offset 122112 is not sector aligned ++offset 123136 is not sector aligned ++offset 124160 is not sector aligned ++offset 125184 is not sector aligned ++offset 126208 is not sector aligned ++offset 127232 is not sector aligned ++offset 128256 is not sector aligned ++offset 129280 is not sector aligned ++offset 130304 is not sector aligned ++offset 131328 is not sector aligned ++offset 132352 is not sector aligned ++offset 133376 is not sector aligned ++offset 134400 is not sector aligned ++offset 135424 is not sector aligned ++offset 136448 is not sector aligned ++offset 137472 is not sector aligned ++offset 138496 is not sector aligned ++offset 139520 is not sector aligned ++offset 140544 is not sector aligned ++offset 141568 is not sector aligned ++offset 142592 is not sector aligned ++offset 143616 is not sector aligned ++offset 144640 is not sector aligned ++offset 145664 is not sector aligned ++offset 146688 is not sector aligned ++=== IO: pattern 33 ++read 2048/2048 bytes at offset 147968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 151040 ++read 2048/2048 bytes at offset 151040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 154112 ++read 2048/2048 bytes at offset 154112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 157184 ++read 2048/2048 bytes at offset 157184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 160256 ++read 2048/2048 bytes at offset 160256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 163328 ++read 2048/2048 bytes at offset 163328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 166400 ++read 2048/2048 bytes at offset 166400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 169472 ++read 2048/2048 bytes at offset 169472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 172544 ++read 2048/2048 bytes at offset 172544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 253 +-qemu-io> read 3072/3072 bytes at offset 260608 ++=== IO: pattern 253 ++read 3072/3072 bytes at offset 260608 + 3 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 3072/3072 bytes at offset 392192 ++read 3072/3072 bytes at offset 392192 + 3 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 3072/3072 bytes at offset 523776 ++read 3072/3072 bytes at offset 523776 + 3 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> read 1024/1024 bytes at offset 0 ++=== IO: pattern 0 ++read 1024/1024 bytes at offset 0 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 1024 ++read 1024/1024 bytes at offset 1024 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 2048 ++read 1024/1024 bytes at offset 2048 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 3072 ++read 1024/1024 bytes at offset 3072 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4096 ++read 1024/1024 bytes at offset 4096 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 5120 ++read 1024/1024 bytes at offset 5120 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 6144 ++read 1024/1024 bytes at offset 6144 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 7168 ++read 1024/1024 bytes at offset 7168 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 8192 ++read 1024/1024 bytes at offset 8192 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 9216 ++read 1024/1024 bytes at offset 9216 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 10240 ++read 1024/1024 bytes at offset 10240 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 11264 ++read 1024/1024 bytes at offset 11264 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 12288 ++read 1024/1024 bytes at offset 12288 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 13312 ++read 1024/1024 bytes at offset 13312 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 14336 ++read 1024/1024 bytes at offset 14336 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 15360 ++read 1024/1024 bytes at offset 15360 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 16384 ++read 1024/1024 bytes at offset 16384 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 17408 ++read 1024/1024 bytes at offset 17408 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 18432 ++read 1024/1024 bytes at offset 18432 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 19456 ++read 1024/1024 bytes at offset 19456 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 20480 ++read 1024/1024 bytes at offset 20480 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 21504 ++read 1024/1024 bytes at offset 21504 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 22528 ++read 1024/1024 bytes at offset 22528 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 23552 ++read 1024/1024 bytes at offset 23552 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 24576 ++read 1024/1024 bytes at offset 24576 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 25600 ++read 1024/1024 bytes at offset 25600 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 26624 ++read 1024/1024 bytes at offset 26624 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 27648 ++read 1024/1024 bytes at offset 27648 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 28672 ++read 1024/1024 bytes at offset 28672 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 29696 ++read 1024/1024 bytes at offset 29696 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 30720 ++read 1024/1024 bytes at offset 30720 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 31744 ++read 1024/1024 bytes at offset 31744 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 32768 ++read 1024/1024 bytes at offset 32768 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 33792 ++read 1024/1024 bytes at offset 33792 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 34816 ++read 1024/1024 bytes at offset 34816 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 35840 ++read 1024/1024 bytes at offset 35840 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 73 +-qemu-io> read 512/512 bytes at offset 37376 ++=== IO: pattern 73 ++read 512/512 bytes at offset 37376 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 38400 ++read 512/512 bytes at offset 38400 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 39424 ++read 512/512 bytes at offset 39424 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 40448 ++read 512/512 bytes at offset 40448 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 41472 ++read 512/512 bytes at offset 41472 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 42496 ++read 512/512 bytes at offset 42496 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 43520 ++read 512/512 bytes at offset 43520 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 44544 ++read 512/512 bytes at offset 44544 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 45568 ++read 512/512 bytes at offset 45568 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 46592 ++read 512/512 bytes at offset 46592 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 47616 ++read 512/512 bytes at offset 47616 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 48640 ++read 512/512 bytes at offset 48640 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 49664 ++read 512/512 bytes at offset 49664 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 50688 ++read 512/512 bytes at offset 50688 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 51712 ++read 512/512 bytes at offset 51712 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 52736 ++read 512/512 bytes at offset 52736 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 53760 ++read 512/512 bytes at offset 53760 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 54784 ++read 512/512 bytes at offset 54784 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 55808 ++read 512/512 bytes at offset 55808 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 56832 ++read 512/512 bytes at offset 56832 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 57856 ++read 512/512 bytes at offset 57856 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 58880 ++read 512/512 bytes at offset 58880 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 59904 ++read 512/512 bytes at offset 59904 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 60928 ++read 512/512 bytes at offset 60928 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 61952 ++read 512/512 bytes at offset 61952 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 62976 ++read 512/512 bytes at offset 62976 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 64000 ++read 512/512 bytes at offset 64000 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 65024 ++read 512/512 bytes at offset 65024 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 66048 ++read 512/512 bytes at offset 66048 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 67072 ++read 512/512 bytes at offset 67072 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 68096 ++read 512/512 bytes at offset 68096 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 69120 ++read 512/512 bytes at offset 69120 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 70144 ++read 512/512 bytes at offset 70144 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 71168 ++read 512/512 bytes at offset 71168 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 72192 ++read 512/512 bytes at offset 72192 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 73216 ++read 512/512 bytes at offset 73216 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 144 +-qemu-io> read 512/512 bytes at offset 73728 ++=== IO: pattern 144 ++read 512/512 bytes at offset 73728 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 74752 ++read 512/512 bytes at offset 74752 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 75776 ++read 512/512 bytes at offset 75776 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 76800 ++read 512/512 bytes at offset 76800 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 77824 ++read 512/512 bytes at offset 77824 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 78848 ++read 512/512 bytes at offset 78848 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 79872 ++read 512/512 bytes at offset 79872 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 80896 ++read 512/512 bytes at offset 80896 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 81920 ++read 512/512 bytes at offset 81920 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 82944 ++read 512/512 bytes at offset 82944 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 83968 ++read 512/512 bytes at offset 83968 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 84992 ++read 512/512 bytes at offset 84992 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 86016 ++read 512/512 bytes at offset 86016 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 87040 ++read 512/512 bytes at offset 87040 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 88064 ++read 512/512 bytes at offset 88064 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 89088 ++read 512/512 bytes at offset 89088 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 90112 ++read 512/512 bytes at offset 90112 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 91136 ++read 512/512 bytes at offset 91136 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 92160 ++read 512/512 bytes at offset 92160 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 93184 ++read 512/512 bytes at offset 93184 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 94208 ++read 512/512 bytes at offset 94208 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 95232 ++read 512/512 bytes at offset 95232 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 96256 ++read 512/512 bytes at offset 96256 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 97280 ++read 512/512 bytes at offset 97280 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 98304 ++read 512/512 bytes at offset 98304 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 99328 ++read 512/512 bytes at offset 99328 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 100352 ++read 512/512 bytes at offset 100352 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 101376 ++read 512/512 bytes at offset 101376 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 102400 ++read 512/512 bytes at offset 102400 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 103424 ++read 512/512 bytes at offset 103424 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 104448 ++read 512/512 bytes at offset 104448 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 105472 ++read 512/512 bytes at offset 105472 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 106496 ++read 512/512 bytes at offset 106496 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 107520 ++read 512/512 bytes at offset 107520 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 108544 ++read 512/512 bytes at offset 108544 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 109568 ++read 512/512 bytes at offset 109568 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 216 +-qemu-io> offset 110848 is not sector aligned +-qemu-io> offset 111872 is not sector aligned +-qemu-io> offset 112896 is not sector aligned +-qemu-io> offset 113920 is not sector aligned +-qemu-io> offset 114944 is not sector aligned +-qemu-io> offset 115968 is not sector aligned +-qemu-io> offset 116992 is not sector aligned +-qemu-io> offset 118016 is not sector aligned +-qemu-io> offset 119040 is not sector aligned +-qemu-io> offset 120064 is not sector aligned +-qemu-io> offset 121088 is not sector aligned +-qemu-io> offset 122112 is not sector aligned +-qemu-io> offset 123136 is not sector aligned +-qemu-io> offset 124160 is not sector aligned +-qemu-io> offset 125184 is not sector aligned +-qemu-io> offset 126208 is not sector aligned +-qemu-io> offset 127232 is not sector aligned +-qemu-io> offset 128256 is not sector aligned +-qemu-io> offset 129280 is not sector aligned +-qemu-io> offset 130304 is not sector aligned +-qemu-io> offset 131328 is not sector aligned +-qemu-io> offset 132352 is not sector aligned +-qemu-io> offset 133376 is not sector aligned +-qemu-io> offset 134400 is not sector aligned +-qemu-io> offset 135424 is not sector aligned +-qemu-io> offset 136448 is not sector aligned +-qemu-io> offset 137472 is not sector aligned +-qemu-io> offset 138496 is not sector aligned +-qemu-io> offset 139520 is not sector aligned +-qemu-io> offset 140544 is not sector aligned +-qemu-io> offset 141568 is not sector aligned +-qemu-io> offset 142592 is not sector aligned +-qemu-io> offset 143616 is not sector aligned +-qemu-io> offset 144640 is not sector aligned +-qemu-io> offset 145664 is not sector aligned +-qemu-io> offset 146688 is not sector aligned +-qemu-io> === IO: pattern 33 +-qemu-io> read 2048/2048 bytes at offset 147968 ++=== IO: pattern 216 ++offset 110848 is not sector aligned ++offset 111872 is not sector aligned ++offset 112896 is not sector aligned ++offset 113920 is not sector aligned ++offset 114944 is not sector aligned ++offset 115968 is not sector aligned ++offset 116992 is not sector aligned ++offset 118016 is not sector aligned ++offset 119040 is not sector aligned ++offset 120064 is not sector aligned ++offset 121088 is not sector aligned ++offset 122112 is not sector aligned ++offset 123136 is not sector aligned ++offset 124160 is not sector aligned ++offset 125184 is not sector aligned ++offset 126208 is not sector aligned ++offset 127232 is not sector aligned ++offset 128256 is not sector aligned ++offset 129280 is not sector aligned ++offset 130304 is not sector aligned ++offset 131328 is not sector aligned ++offset 132352 is not sector aligned ++offset 133376 is not sector aligned ++offset 134400 is not sector aligned ++offset 135424 is not sector aligned ++offset 136448 is not sector aligned ++offset 137472 is not sector aligned ++offset 138496 is not sector aligned ++offset 139520 is not sector aligned ++offset 140544 is not sector aligned ++offset 141568 is not sector aligned ++offset 142592 is not sector aligned ++offset 143616 is not sector aligned ++offset 144640 is not sector aligned ++offset 145664 is not sector aligned ++offset 146688 is not sector aligned ++=== IO: pattern 33 ++read 2048/2048 bytes at offset 147968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 151040 ++read 2048/2048 bytes at offset 151040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 154112 ++read 2048/2048 bytes at offset 154112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 157184 ++read 2048/2048 bytes at offset 157184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 160256 ++read 2048/2048 bytes at offset 160256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 163328 ++read 2048/2048 bytes at offset 163328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 166400 ++read 2048/2048 bytes at offset 166400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 169472 ++read 2048/2048 bytes at offset 169472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 172544 ++read 2048/2048 bytes at offset 172544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 253 +-qemu-io> read 3072/3072 bytes at offset 260608 ++=== IO: pattern 253 ++read 3072/3072 bytes at offset 260608 + 3 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 3072/3072 bytes at offset 392192 ++read 3072/3072 bytes at offset 392192 + 3 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 3072/3072 bytes at offset 523776 ++read 3072/3072 bytes at offset 523776 + 3 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> No errors were found on the image. ++No errors were found on the image. + With offset 4294967296: + === IO: pattern 0 +-qemu-io> read 1024/1024 bytes at offset 4294967296 ++read 1024/1024 bytes at offset 4294967296 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294968320 ++read 1024/1024 bytes at offset 4294968320 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294969344 ++read 1024/1024 bytes at offset 4294969344 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294970368 ++read 1024/1024 bytes at offset 4294970368 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294971392 ++read 1024/1024 bytes at offset 4294971392 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294972416 ++read 1024/1024 bytes at offset 4294972416 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294973440 ++read 1024/1024 bytes at offset 4294973440 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294974464 ++read 1024/1024 bytes at offset 4294974464 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294975488 ++read 1024/1024 bytes at offset 4294975488 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294976512 ++read 1024/1024 bytes at offset 4294976512 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294977536 ++read 1024/1024 bytes at offset 4294977536 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294978560 ++read 1024/1024 bytes at offset 4294978560 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294979584 ++read 1024/1024 bytes at offset 4294979584 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294980608 ++read 1024/1024 bytes at offset 4294980608 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294981632 ++read 1024/1024 bytes at offset 4294981632 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294982656 ++read 1024/1024 bytes at offset 4294982656 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294983680 ++read 1024/1024 bytes at offset 4294983680 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294984704 ++read 1024/1024 bytes at offset 4294984704 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294985728 ++read 1024/1024 bytes at offset 4294985728 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294986752 ++read 1024/1024 bytes at offset 4294986752 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294987776 ++read 1024/1024 bytes at offset 4294987776 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294988800 ++read 1024/1024 bytes at offset 4294988800 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294989824 ++read 1024/1024 bytes at offset 4294989824 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294990848 ++read 1024/1024 bytes at offset 4294990848 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294991872 ++read 1024/1024 bytes at offset 4294991872 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294992896 ++read 1024/1024 bytes at offset 4294992896 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294993920 ++read 1024/1024 bytes at offset 4294993920 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294994944 ++read 1024/1024 bytes at offset 4294994944 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294995968 ++read 1024/1024 bytes at offset 4294995968 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294996992 ++read 1024/1024 bytes at offset 4294996992 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294998016 ++read 1024/1024 bytes at offset 4294998016 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294999040 ++read 1024/1024 bytes at offset 4294999040 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4295000064 ++read 1024/1024 bytes at offset 4295000064 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4295001088 ++read 1024/1024 bytes at offset 4295001088 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4295002112 ++read 1024/1024 bytes at offset 4295002112 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4295003136 ++read 1024/1024 bytes at offset 4295003136 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 73 +-qemu-io> read 512/512 bytes at offset 4295004672 ++=== IO: pattern 73 ++read 512/512 bytes at offset 4295004672 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295005696 ++read 512/512 bytes at offset 4295005696 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295006720 ++read 512/512 bytes at offset 4295006720 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295007744 ++read 512/512 bytes at offset 4295007744 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295008768 ++read 512/512 bytes at offset 4295008768 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295009792 ++read 512/512 bytes at offset 4295009792 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295010816 ++read 512/512 bytes at offset 4295010816 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295011840 ++read 512/512 bytes at offset 4295011840 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295012864 ++read 512/512 bytes at offset 4295012864 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295013888 ++read 512/512 bytes at offset 4295013888 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295014912 ++read 512/512 bytes at offset 4295014912 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295015936 ++read 512/512 bytes at offset 4295015936 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295016960 ++read 512/512 bytes at offset 4295016960 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295017984 ++read 512/512 bytes at offset 4295017984 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295019008 ++read 512/512 bytes at offset 4295019008 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295020032 ++read 512/512 bytes at offset 4295020032 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295021056 ++read 512/512 bytes at offset 4295021056 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295022080 ++read 512/512 bytes at offset 4295022080 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295023104 ++read 512/512 bytes at offset 4295023104 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295024128 ++read 512/512 bytes at offset 4295024128 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295025152 ++read 512/512 bytes at offset 4295025152 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295026176 ++read 512/512 bytes at offset 4295026176 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295027200 ++read 512/512 bytes at offset 4295027200 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295028224 ++read 512/512 bytes at offset 4295028224 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295029248 ++read 512/512 bytes at offset 4295029248 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295030272 ++read 512/512 bytes at offset 4295030272 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295031296 ++read 512/512 bytes at offset 4295031296 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295032320 ++read 512/512 bytes at offset 4295032320 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295033344 ++read 512/512 bytes at offset 4295033344 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295034368 ++read 512/512 bytes at offset 4295034368 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295035392 ++read 512/512 bytes at offset 4295035392 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295036416 ++read 512/512 bytes at offset 4295036416 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295037440 ++read 512/512 bytes at offset 4295037440 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295038464 ++read 512/512 bytes at offset 4295038464 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295039488 ++read 512/512 bytes at offset 4295039488 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295040512 ++read 512/512 bytes at offset 4295040512 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 144 +-qemu-io> read 512/512 bytes at offset 4295041024 ++=== IO: pattern 144 ++read 512/512 bytes at offset 4295041024 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295042048 ++read 512/512 bytes at offset 4295042048 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295043072 ++read 512/512 bytes at offset 4295043072 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295044096 ++read 512/512 bytes at offset 4295044096 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295045120 ++read 512/512 bytes at offset 4295045120 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295046144 ++read 512/512 bytes at offset 4295046144 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295047168 ++read 512/512 bytes at offset 4295047168 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295048192 ++read 512/512 bytes at offset 4295048192 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295049216 ++read 512/512 bytes at offset 4295049216 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295050240 ++read 512/512 bytes at offset 4295050240 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295051264 ++read 512/512 bytes at offset 4295051264 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295052288 ++read 512/512 bytes at offset 4295052288 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295053312 ++read 512/512 bytes at offset 4295053312 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295054336 ++read 512/512 bytes at offset 4295054336 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295055360 ++read 512/512 bytes at offset 4295055360 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295056384 ++read 512/512 bytes at offset 4295056384 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295057408 ++read 512/512 bytes at offset 4295057408 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295058432 ++read 512/512 bytes at offset 4295058432 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295059456 ++read 512/512 bytes at offset 4295059456 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295060480 ++read 512/512 bytes at offset 4295060480 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295061504 ++read 512/512 bytes at offset 4295061504 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295062528 ++read 512/512 bytes at offset 4295062528 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295063552 ++read 512/512 bytes at offset 4295063552 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295064576 ++read 512/512 bytes at offset 4295064576 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295065600 ++read 512/512 bytes at offset 4295065600 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295066624 ++read 512/512 bytes at offset 4295066624 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295067648 ++read 512/512 bytes at offset 4295067648 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295068672 ++read 512/512 bytes at offset 4295068672 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295069696 ++read 512/512 bytes at offset 4295069696 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295070720 ++read 512/512 bytes at offset 4295070720 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295071744 ++read 512/512 bytes at offset 4295071744 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295072768 ++read 512/512 bytes at offset 4295072768 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295073792 ++read 512/512 bytes at offset 4295073792 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295074816 ++read 512/512 bytes at offset 4295074816 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295075840 ++read 512/512 bytes at offset 4295075840 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295076864 ++read 512/512 bytes at offset 4295076864 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 216 +-qemu-io> offset 4295078144 is not sector aligned +-qemu-io> offset 4295079168 is not sector aligned +-qemu-io> offset 4295080192 is not sector aligned +-qemu-io> offset 4295081216 is not sector aligned +-qemu-io> offset 4295082240 is not sector aligned +-qemu-io> offset 4295083264 is not sector aligned +-qemu-io> offset 4295084288 is not sector aligned +-qemu-io> offset 4295085312 is not sector aligned +-qemu-io> offset 4295086336 is not sector aligned +-qemu-io> offset 4295087360 is not sector aligned +-qemu-io> offset 4295088384 is not sector aligned +-qemu-io> offset 4295089408 is not sector aligned +-qemu-io> offset 4295090432 is not sector aligned +-qemu-io> offset 4295091456 is not sector aligned +-qemu-io> offset 4295092480 is not sector aligned +-qemu-io> offset 4295093504 is not sector aligned +-qemu-io> offset 4295094528 is not sector aligned +-qemu-io> offset 4295095552 is not sector aligned +-qemu-io> offset 4295096576 is not sector aligned +-qemu-io> offset 4295097600 is not sector aligned +-qemu-io> offset 4295098624 is not sector aligned +-qemu-io> offset 4295099648 is not sector aligned +-qemu-io> offset 4295100672 is not sector aligned +-qemu-io> offset 4295101696 is not sector aligned +-qemu-io> offset 4295102720 is not sector aligned +-qemu-io> offset 4295103744 is not sector aligned +-qemu-io> offset 4295104768 is not sector aligned +-qemu-io> offset 4295105792 is not sector aligned +-qemu-io> offset 4295106816 is not sector aligned +-qemu-io> offset 4295107840 is not sector aligned +-qemu-io> offset 4295108864 is not sector aligned +-qemu-io> offset 4295109888 is not sector aligned +-qemu-io> offset 4295110912 is not sector aligned +-qemu-io> offset 4295111936 is not sector aligned +-qemu-io> offset 4295112960 is not sector aligned +-qemu-io> offset 4295113984 is not sector aligned +-qemu-io> === IO: pattern 33 +-qemu-io> read 2048/2048 bytes at offset 4295115264 ++=== IO: pattern 216 ++offset 4295078144 is not sector aligned ++offset 4295079168 is not sector aligned ++offset 4295080192 is not sector aligned ++offset 4295081216 is not sector aligned ++offset 4295082240 is not sector aligned ++offset 4295083264 is not sector aligned ++offset 4295084288 is not sector aligned ++offset 4295085312 is not sector aligned ++offset 4295086336 is not sector aligned ++offset 4295087360 is not sector aligned ++offset 4295088384 is not sector aligned ++offset 4295089408 is not sector aligned ++offset 4295090432 is not sector aligned ++offset 4295091456 is not sector aligned ++offset 4295092480 is not sector aligned ++offset 4295093504 is not sector aligned ++offset 4295094528 is not sector aligned ++offset 4295095552 is not sector aligned ++offset 4295096576 is not sector aligned ++offset 4295097600 is not sector aligned ++offset 4295098624 is not sector aligned ++offset 4295099648 is not sector aligned ++offset 4295100672 is not sector aligned ++offset 4295101696 is not sector aligned ++offset 4295102720 is not sector aligned ++offset 4295103744 is not sector aligned ++offset 4295104768 is not sector aligned ++offset 4295105792 is not sector aligned ++offset 4295106816 is not sector aligned ++offset 4295107840 is not sector aligned ++offset 4295108864 is not sector aligned ++offset 4295109888 is not sector aligned ++offset 4295110912 is not sector aligned ++offset 4295111936 is not sector aligned ++offset 4295112960 is not sector aligned ++offset 4295113984 is not sector aligned ++=== IO: pattern 33 ++read 2048/2048 bytes at offset 4295115264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295118336 ++read 2048/2048 bytes at offset 4295118336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295121408 ++read 2048/2048 bytes at offset 4295121408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295124480 ++read 2048/2048 bytes at offset 4295124480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295127552 ++read 2048/2048 bytes at offset 4295127552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295130624 ++read 2048/2048 bytes at offset 4295130624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295133696 ++read 2048/2048 bytes at offset 4295133696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295136768 ++read 2048/2048 bytes at offset 4295136768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295139840 ++read 2048/2048 bytes at offset 4295139840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 253 +-qemu-io> read 3072/3072 bytes at offset 4295227904 ++=== IO: pattern 253 ++read 3072/3072 bytes at offset 4295227904 + 3 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 3072/3072 bytes at offset 4295359488 ++read 3072/3072 bytes at offset 4295359488 + 3 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 3072/3072 bytes at offset 4295491072 ++read 3072/3072 bytes at offset 4295491072 + 3 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> read 1024/1024 bytes at offset 4294967296 ++=== IO: pattern 0 ++read 1024/1024 bytes at offset 4294967296 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294968320 ++read 1024/1024 bytes at offset 4294968320 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294969344 ++read 1024/1024 bytes at offset 4294969344 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294970368 ++read 1024/1024 bytes at offset 4294970368 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294971392 ++read 1024/1024 bytes at offset 4294971392 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294972416 ++read 1024/1024 bytes at offset 4294972416 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294973440 ++read 1024/1024 bytes at offset 4294973440 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294974464 ++read 1024/1024 bytes at offset 4294974464 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294975488 ++read 1024/1024 bytes at offset 4294975488 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294976512 ++read 1024/1024 bytes at offset 4294976512 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294977536 ++read 1024/1024 bytes at offset 4294977536 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294978560 ++read 1024/1024 bytes at offset 4294978560 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294979584 ++read 1024/1024 bytes at offset 4294979584 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294980608 ++read 1024/1024 bytes at offset 4294980608 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294981632 ++read 1024/1024 bytes at offset 4294981632 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294982656 ++read 1024/1024 bytes at offset 4294982656 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294983680 ++read 1024/1024 bytes at offset 4294983680 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294984704 ++read 1024/1024 bytes at offset 4294984704 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294985728 ++read 1024/1024 bytes at offset 4294985728 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294986752 ++read 1024/1024 bytes at offset 4294986752 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294987776 ++read 1024/1024 bytes at offset 4294987776 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294988800 ++read 1024/1024 bytes at offset 4294988800 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294989824 ++read 1024/1024 bytes at offset 4294989824 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294990848 ++read 1024/1024 bytes at offset 4294990848 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294991872 ++read 1024/1024 bytes at offset 4294991872 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294992896 ++read 1024/1024 bytes at offset 4294992896 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294993920 ++read 1024/1024 bytes at offset 4294993920 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294994944 ++read 1024/1024 bytes at offset 4294994944 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294995968 ++read 1024/1024 bytes at offset 4294995968 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294996992 ++read 1024/1024 bytes at offset 4294996992 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294998016 ++read 1024/1024 bytes at offset 4294998016 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294999040 ++read 1024/1024 bytes at offset 4294999040 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4295000064 ++read 1024/1024 bytes at offset 4295000064 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4295001088 ++read 1024/1024 bytes at offset 4295001088 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4295002112 ++read 1024/1024 bytes at offset 4295002112 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4295003136 ++read 1024/1024 bytes at offset 4295003136 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 73 +-qemu-io> read 512/512 bytes at offset 4295004672 ++=== IO: pattern 73 ++read 512/512 bytes at offset 4295004672 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295005696 ++read 512/512 bytes at offset 4295005696 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295006720 ++read 512/512 bytes at offset 4295006720 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295007744 ++read 512/512 bytes at offset 4295007744 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295008768 ++read 512/512 bytes at offset 4295008768 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295009792 ++read 512/512 bytes at offset 4295009792 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295010816 ++read 512/512 bytes at offset 4295010816 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295011840 ++read 512/512 bytes at offset 4295011840 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295012864 ++read 512/512 bytes at offset 4295012864 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295013888 ++read 512/512 bytes at offset 4295013888 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295014912 ++read 512/512 bytes at offset 4295014912 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295015936 ++read 512/512 bytes at offset 4295015936 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295016960 ++read 512/512 bytes at offset 4295016960 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295017984 ++read 512/512 bytes at offset 4295017984 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295019008 ++read 512/512 bytes at offset 4295019008 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295020032 ++read 512/512 bytes at offset 4295020032 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295021056 ++read 512/512 bytes at offset 4295021056 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295022080 ++read 512/512 bytes at offset 4295022080 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295023104 ++read 512/512 bytes at offset 4295023104 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295024128 ++read 512/512 bytes at offset 4295024128 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295025152 ++read 512/512 bytes at offset 4295025152 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295026176 ++read 512/512 bytes at offset 4295026176 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295027200 ++read 512/512 bytes at offset 4295027200 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295028224 ++read 512/512 bytes at offset 4295028224 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295029248 ++read 512/512 bytes at offset 4295029248 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295030272 ++read 512/512 bytes at offset 4295030272 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295031296 ++read 512/512 bytes at offset 4295031296 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295032320 ++read 512/512 bytes at offset 4295032320 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295033344 ++read 512/512 bytes at offset 4295033344 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295034368 ++read 512/512 bytes at offset 4295034368 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295035392 ++read 512/512 bytes at offset 4295035392 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295036416 ++read 512/512 bytes at offset 4295036416 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295037440 ++read 512/512 bytes at offset 4295037440 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295038464 ++read 512/512 bytes at offset 4295038464 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295039488 ++read 512/512 bytes at offset 4295039488 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295040512 ++read 512/512 bytes at offset 4295040512 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 144 +-qemu-io> read 512/512 bytes at offset 4295041024 ++=== IO: pattern 144 ++read 512/512 bytes at offset 4295041024 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295042048 ++read 512/512 bytes at offset 4295042048 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295043072 ++read 512/512 bytes at offset 4295043072 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295044096 ++read 512/512 bytes at offset 4295044096 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295045120 ++read 512/512 bytes at offset 4295045120 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295046144 ++read 512/512 bytes at offset 4295046144 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295047168 ++read 512/512 bytes at offset 4295047168 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295048192 ++read 512/512 bytes at offset 4295048192 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295049216 ++read 512/512 bytes at offset 4295049216 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295050240 ++read 512/512 bytes at offset 4295050240 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295051264 ++read 512/512 bytes at offset 4295051264 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295052288 ++read 512/512 bytes at offset 4295052288 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295053312 ++read 512/512 bytes at offset 4295053312 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295054336 ++read 512/512 bytes at offset 4295054336 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295055360 ++read 512/512 bytes at offset 4295055360 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295056384 ++read 512/512 bytes at offset 4295056384 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295057408 ++read 512/512 bytes at offset 4295057408 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295058432 ++read 512/512 bytes at offset 4295058432 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295059456 ++read 512/512 bytes at offset 4295059456 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295060480 ++read 512/512 bytes at offset 4295060480 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295061504 ++read 512/512 bytes at offset 4295061504 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295062528 ++read 512/512 bytes at offset 4295062528 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295063552 ++read 512/512 bytes at offset 4295063552 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295064576 ++read 512/512 bytes at offset 4295064576 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295065600 ++read 512/512 bytes at offset 4295065600 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295066624 ++read 512/512 bytes at offset 4295066624 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295067648 ++read 512/512 bytes at offset 4295067648 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295068672 ++read 512/512 bytes at offset 4295068672 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295069696 ++read 512/512 bytes at offset 4295069696 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295070720 ++read 512/512 bytes at offset 4295070720 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295071744 ++read 512/512 bytes at offset 4295071744 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295072768 ++read 512/512 bytes at offset 4295072768 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295073792 ++read 512/512 bytes at offset 4295073792 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295074816 ++read 512/512 bytes at offset 4295074816 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295075840 ++read 512/512 bytes at offset 4295075840 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295076864 ++read 512/512 bytes at offset 4295076864 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 216 +-qemu-io> offset 4295078144 is not sector aligned +-qemu-io> offset 4295079168 is not sector aligned +-qemu-io> offset 4295080192 is not sector aligned +-qemu-io> offset 4295081216 is not sector aligned +-qemu-io> offset 4295082240 is not sector aligned +-qemu-io> offset 4295083264 is not sector aligned +-qemu-io> offset 4295084288 is not sector aligned +-qemu-io> offset 4295085312 is not sector aligned +-qemu-io> offset 4295086336 is not sector aligned +-qemu-io> offset 4295087360 is not sector aligned +-qemu-io> offset 4295088384 is not sector aligned +-qemu-io> offset 4295089408 is not sector aligned +-qemu-io> offset 4295090432 is not sector aligned +-qemu-io> offset 4295091456 is not sector aligned +-qemu-io> offset 4295092480 is not sector aligned +-qemu-io> offset 4295093504 is not sector aligned +-qemu-io> offset 4295094528 is not sector aligned +-qemu-io> offset 4295095552 is not sector aligned +-qemu-io> offset 4295096576 is not sector aligned +-qemu-io> offset 4295097600 is not sector aligned +-qemu-io> offset 4295098624 is not sector aligned +-qemu-io> offset 4295099648 is not sector aligned +-qemu-io> offset 4295100672 is not sector aligned +-qemu-io> offset 4295101696 is not sector aligned +-qemu-io> offset 4295102720 is not sector aligned +-qemu-io> offset 4295103744 is not sector aligned +-qemu-io> offset 4295104768 is not sector aligned +-qemu-io> offset 4295105792 is not sector aligned +-qemu-io> offset 4295106816 is not sector aligned +-qemu-io> offset 4295107840 is not sector aligned +-qemu-io> offset 4295108864 is not sector aligned +-qemu-io> offset 4295109888 is not sector aligned +-qemu-io> offset 4295110912 is not sector aligned +-qemu-io> offset 4295111936 is not sector aligned +-qemu-io> offset 4295112960 is not sector aligned +-qemu-io> offset 4295113984 is not sector aligned +-qemu-io> === IO: pattern 33 +-qemu-io> read 2048/2048 bytes at offset 4295115264 ++=== IO: pattern 216 ++offset 4295078144 is not sector aligned ++offset 4295079168 is not sector aligned ++offset 4295080192 is not sector aligned ++offset 4295081216 is not sector aligned ++offset 4295082240 is not sector aligned ++offset 4295083264 is not sector aligned ++offset 4295084288 is not sector aligned ++offset 4295085312 is not sector aligned ++offset 4295086336 is not sector aligned ++offset 4295087360 is not sector aligned ++offset 4295088384 is not sector aligned ++offset 4295089408 is not sector aligned ++offset 4295090432 is not sector aligned ++offset 4295091456 is not sector aligned ++offset 4295092480 is not sector aligned ++offset 4295093504 is not sector aligned ++offset 4295094528 is not sector aligned ++offset 4295095552 is not sector aligned ++offset 4295096576 is not sector aligned ++offset 4295097600 is not sector aligned ++offset 4295098624 is not sector aligned ++offset 4295099648 is not sector aligned ++offset 4295100672 is not sector aligned ++offset 4295101696 is not sector aligned ++offset 4295102720 is not sector aligned ++offset 4295103744 is not sector aligned ++offset 4295104768 is not sector aligned ++offset 4295105792 is not sector aligned ++offset 4295106816 is not sector aligned ++offset 4295107840 is not sector aligned ++offset 4295108864 is not sector aligned ++offset 4295109888 is not sector aligned ++offset 4295110912 is not sector aligned ++offset 4295111936 is not sector aligned ++offset 4295112960 is not sector aligned ++offset 4295113984 is not sector aligned ++=== IO: pattern 33 ++read 2048/2048 bytes at offset 4295115264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295118336 ++read 2048/2048 bytes at offset 4295118336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295121408 ++read 2048/2048 bytes at offset 4295121408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295124480 ++read 2048/2048 bytes at offset 4295124480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295127552 ++read 2048/2048 bytes at offset 4295127552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295130624 ++read 2048/2048 bytes at offset 4295130624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295133696 ++read 2048/2048 bytes at offset 4295133696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295136768 ++read 2048/2048 bytes at offset 4295136768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295139840 ++read 2048/2048 bytes at offset 4295139840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 253 +-qemu-io> read 3072/3072 bytes at offset 4295227904 ++=== IO: pattern 253 ++read 3072/3072 bytes at offset 4295227904 + 3 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 3072/3072 bytes at offset 4295359488 ++read 3072/3072 bytes at offset 4295359488 + 3 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 3072/3072 bytes at offset 4295491072 ++read 3072/3072 bytes at offset 4295491072 + 3 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> No errors were found on the image. ++No errors were found on the image. + Testing compressed image with odd offsets + + With offset 512: + === IO: pattern 1 +-qemu-io> wrote 1024/1024 bytes at offset 512 ++wrote 1024/1024 bytes at offset 512 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 1536 ++wrote 1024/1024 bytes at offset 1536 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 2560 ++wrote 1024/1024 bytes at offset 2560 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 3584 ++wrote 1024/1024 bytes at offset 3584 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4608 ++wrote 1024/1024 bytes at offset 4608 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 5632 ++wrote 1024/1024 bytes at offset 5632 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 6656 ++wrote 1024/1024 bytes at offset 6656 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 7680 ++wrote 1024/1024 bytes at offset 7680 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 8704 ++wrote 1024/1024 bytes at offset 8704 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 9728 ++wrote 1024/1024 bytes at offset 9728 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 10752 ++wrote 1024/1024 bytes at offset 10752 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 11776 ++wrote 1024/1024 bytes at offset 11776 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 12800 ++wrote 1024/1024 bytes at offset 12800 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 13824 ++wrote 1024/1024 bytes at offset 13824 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 14848 ++wrote 1024/1024 bytes at offset 14848 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 15872 ++wrote 1024/1024 bytes at offset 15872 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 16896 ++wrote 1024/1024 bytes at offset 16896 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 17920 ++wrote 1024/1024 bytes at offset 17920 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 18944 ++wrote 1024/1024 bytes at offset 18944 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 19968 ++wrote 1024/1024 bytes at offset 19968 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 20992 ++wrote 1024/1024 bytes at offset 20992 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 22016 ++wrote 1024/1024 bytes at offset 22016 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 23040 ++wrote 1024/1024 bytes at offset 23040 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 24064 ++wrote 1024/1024 bytes at offset 24064 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 25088 ++wrote 1024/1024 bytes at offset 25088 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 26112 ++wrote 1024/1024 bytes at offset 26112 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 27136 ++wrote 1024/1024 bytes at offset 27136 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 28160 ++wrote 1024/1024 bytes at offset 28160 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 29184 ++wrote 1024/1024 bytes at offset 29184 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 30208 ++wrote 1024/1024 bytes at offset 30208 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 31232 ++wrote 1024/1024 bytes at offset 31232 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 32256 ++wrote 1024/1024 bytes at offset 32256 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 33280 ++wrote 1024/1024 bytes at offset 33280 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 34304 ++wrote 1024/1024 bytes at offset 34304 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 35328 ++wrote 1024/1024 bytes at offset 35328 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 36352 ++wrote 1024/1024 bytes at offset 36352 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 74 +-qemu-io> wrote 512/512 bytes at offset 37888 ++=== IO: pattern 74 ++wrote 512/512 bytes at offset 37888 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 38912 ++wrote 512/512 bytes at offset 38912 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 39936 ++wrote 512/512 bytes at offset 39936 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 40960 ++wrote 512/512 bytes at offset 40960 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 41984 ++wrote 512/512 bytes at offset 41984 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 43008 ++wrote 512/512 bytes at offset 43008 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 44032 ++wrote 512/512 bytes at offset 44032 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 45056 ++wrote 512/512 bytes at offset 45056 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 46080 ++wrote 512/512 bytes at offset 46080 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 47104 ++wrote 512/512 bytes at offset 47104 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 48128 ++wrote 512/512 bytes at offset 48128 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 49152 ++wrote 512/512 bytes at offset 49152 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 50176 ++wrote 512/512 bytes at offset 50176 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 51200 ++wrote 512/512 bytes at offset 51200 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 52224 ++wrote 512/512 bytes at offset 52224 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 53248 ++wrote 512/512 bytes at offset 53248 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 54272 ++wrote 512/512 bytes at offset 54272 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 55296 ++wrote 512/512 bytes at offset 55296 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 56320 ++wrote 512/512 bytes at offset 56320 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 57344 ++wrote 512/512 bytes at offset 57344 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 58368 ++wrote 512/512 bytes at offset 58368 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 59392 ++wrote 512/512 bytes at offset 59392 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 60416 ++wrote 512/512 bytes at offset 60416 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 61440 ++wrote 512/512 bytes at offset 61440 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 62464 ++wrote 512/512 bytes at offset 62464 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 63488 ++wrote 512/512 bytes at offset 63488 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 64512 ++wrote 512/512 bytes at offset 64512 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 65536 ++wrote 512/512 bytes at offset 65536 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 66560 ++wrote 512/512 bytes at offset 66560 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 67584 ++wrote 512/512 bytes at offset 67584 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 68608 ++wrote 512/512 bytes at offset 68608 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 69632 ++wrote 512/512 bytes at offset 69632 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 70656 ++wrote 512/512 bytes at offset 70656 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 71680 ++wrote 512/512 bytes at offset 71680 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 72704 ++wrote 512/512 bytes at offset 72704 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 73728 ++wrote 512/512 bytes at offset 73728 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 145 +-qemu-io> wrote 512/512 bytes at offset 74240 ++=== IO: pattern 145 ++wrote 512/512 bytes at offset 74240 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 75264 ++wrote 512/512 bytes at offset 75264 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 76288 ++wrote 512/512 bytes at offset 76288 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 77312 ++wrote 512/512 bytes at offset 77312 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 78336 ++wrote 512/512 bytes at offset 78336 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 79360 ++wrote 512/512 bytes at offset 79360 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 80384 ++wrote 512/512 bytes at offset 80384 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 81408 ++wrote 512/512 bytes at offset 81408 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 82432 ++wrote 512/512 bytes at offset 82432 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 83456 ++wrote 512/512 bytes at offset 83456 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 84480 ++wrote 512/512 bytes at offset 84480 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 85504 ++wrote 512/512 bytes at offset 85504 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 86528 ++wrote 512/512 bytes at offset 86528 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 87552 ++wrote 512/512 bytes at offset 87552 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 88576 ++wrote 512/512 bytes at offset 88576 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 89600 ++wrote 512/512 bytes at offset 89600 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 90624 ++wrote 512/512 bytes at offset 90624 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 91648 ++wrote 512/512 bytes at offset 91648 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 92672 ++wrote 512/512 bytes at offset 92672 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 93696 ++wrote 512/512 bytes at offset 93696 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 94720 ++wrote 512/512 bytes at offset 94720 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 95744 ++wrote 512/512 bytes at offset 95744 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 96768 ++wrote 512/512 bytes at offset 96768 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 97792 ++wrote 512/512 bytes at offset 97792 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 98816 ++wrote 512/512 bytes at offset 98816 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 99840 ++wrote 512/512 bytes at offset 99840 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 100864 ++wrote 512/512 bytes at offset 100864 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 101888 ++wrote 512/512 bytes at offset 101888 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 102912 ++wrote 512/512 bytes at offset 102912 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 103936 ++wrote 512/512 bytes at offset 103936 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 104960 ++wrote 512/512 bytes at offset 104960 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 105984 ++wrote 512/512 bytes at offset 105984 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 107008 ++wrote 512/512 bytes at offset 107008 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 108032 ++wrote 512/512 bytes at offset 108032 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 109056 ++wrote 512/512 bytes at offset 109056 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 110080 ++wrote 512/512 bytes at offset 110080 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 217 +-qemu-io> offset 111360 is not sector aligned +-qemu-io> offset 112384 is not sector aligned +-qemu-io> offset 113408 is not sector aligned +-qemu-io> offset 114432 is not sector aligned +-qemu-io> offset 115456 is not sector aligned +-qemu-io> offset 116480 is not sector aligned +-qemu-io> offset 117504 is not sector aligned +-qemu-io> offset 118528 is not sector aligned +-qemu-io> offset 119552 is not sector aligned +-qemu-io> offset 120576 is not sector aligned +-qemu-io> offset 121600 is not sector aligned +-qemu-io> offset 122624 is not sector aligned +-qemu-io> offset 123648 is not sector aligned +-qemu-io> offset 124672 is not sector aligned +-qemu-io> offset 125696 is not sector aligned +-qemu-io> offset 126720 is not sector aligned +-qemu-io> offset 127744 is not sector aligned +-qemu-io> offset 128768 is not sector aligned +-qemu-io> offset 129792 is not sector aligned +-qemu-io> offset 130816 is not sector aligned +-qemu-io> offset 131840 is not sector aligned +-qemu-io> offset 132864 is not sector aligned +-qemu-io> offset 133888 is not sector aligned +-qemu-io> offset 134912 is not sector aligned +-qemu-io> offset 135936 is not sector aligned +-qemu-io> offset 136960 is not sector aligned +-qemu-io> offset 137984 is not sector aligned +-qemu-io> offset 139008 is not sector aligned +-qemu-io> offset 140032 is not sector aligned +-qemu-io> offset 141056 is not sector aligned +-qemu-io> offset 142080 is not sector aligned +-qemu-io> offset 143104 is not sector aligned +-qemu-io> offset 144128 is not sector aligned +-qemu-io> offset 145152 is not sector aligned +-qemu-io> offset 146176 is not sector aligned +-qemu-io> offset 147200 is not sector aligned +-qemu-io> === IO: pattern 34 +-qemu-io> wrote 2048/2048 bytes at offset 148480 ++=== IO: pattern 217 ++offset 111360 is not sector aligned ++offset 112384 is not sector aligned ++offset 113408 is not sector aligned ++offset 114432 is not sector aligned ++offset 115456 is not sector aligned ++offset 116480 is not sector aligned ++offset 117504 is not sector aligned ++offset 118528 is not sector aligned ++offset 119552 is not sector aligned ++offset 120576 is not sector aligned ++offset 121600 is not sector aligned ++offset 122624 is not sector aligned ++offset 123648 is not sector aligned ++offset 124672 is not sector aligned ++offset 125696 is not sector aligned ++offset 126720 is not sector aligned ++offset 127744 is not sector aligned ++offset 128768 is not sector aligned ++offset 129792 is not sector aligned ++offset 130816 is not sector aligned ++offset 131840 is not sector aligned ++offset 132864 is not sector aligned ++offset 133888 is not sector aligned ++offset 134912 is not sector aligned ++offset 135936 is not sector aligned ++offset 136960 is not sector aligned ++offset 137984 is not sector aligned ++offset 139008 is not sector aligned ++offset 140032 is not sector aligned ++offset 141056 is not sector aligned ++offset 142080 is not sector aligned ++offset 143104 is not sector aligned ++offset 144128 is not sector aligned ++offset 145152 is not sector aligned ++offset 146176 is not sector aligned ++offset 147200 is not sector aligned ++=== IO: pattern 34 ++wrote 2048/2048 bytes at offset 148480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 151552 ++wrote 2048/2048 bytes at offset 151552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 154624 ++wrote 2048/2048 bytes at offset 154624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 157696 ++wrote 2048/2048 bytes at offset 157696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 160768 ++wrote 2048/2048 bytes at offset 160768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 163840 ++wrote 2048/2048 bytes at offset 163840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 166912 ++wrote 2048/2048 bytes at offset 166912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 169984 ++wrote 2048/2048 bytes at offset 169984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 173056 ++wrote 2048/2048 bytes at offset 173056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 253 +-qemu-io> wrote 3072/3072 bytes at offset 260608 ++=== IO: pattern 253 ++wrote 3072/3072 bytes at offset 260608 + 3 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 3072/3072 bytes at offset 392192 ++wrote 3072/3072 bytes at offset 392192 + 3 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 3072/3072 bytes at offset 523776 ++wrote 3072/3072 bytes at offset 523776 + 3 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 1 +-qemu-io> read 1024/1024 bytes at offset 512 ++=== IO: pattern 1 ++read 1024/1024 bytes at offset 512 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 1536 ++read 1024/1024 bytes at offset 1536 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 2560 ++read 1024/1024 bytes at offset 2560 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 3584 ++read 1024/1024 bytes at offset 3584 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4608 ++read 1024/1024 bytes at offset 4608 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 5632 ++read 1024/1024 bytes at offset 5632 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 6656 ++read 1024/1024 bytes at offset 6656 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 7680 ++read 1024/1024 bytes at offset 7680 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 8704 ++read 1024/1024 bytes at offset 8704 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 9728 ++read 1024/1024 bytes at offset 9728 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 10752 ++read 1024/1024 bytes at offset 10752 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 11776 ++read 1024/1024 bytes at offset 11776 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 12800 ++read 1024/1024 bytes at offset 12800 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 13824 ++read 1024/1024 bytes at offset 13824 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 14848 ++read 1024/1024 bytes at offset 14848 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 15872 ++read 1024/1024 bytes at offset 15872 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 16896 ++read 1024/1024 bytes at offset 16896 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 17920 ++read 1024/1024 bytes at offset 17920 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 18944 ++read 1024/1024 bytes at offset 18944 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 19968 ++read 1024/1024 bytes at offset 19968 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 20992 ++read 1024/1024 bytes at offset 20992 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 22016 ++read 1024/1024 bytes at offset 22016 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 23040 ++read 1024/1024 bytes at offset 23040 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 24064 ++read 1024/1024 bytes at offset 24064 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 25088 ++read 1024/1024 bytes at offset 25088 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 26112 ++read 1024/1024 bytes at offset 26112 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 27136 ++read 1024/1024 bytes at offset 27136 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 28160 ++read 1024/1024 bytes at offset 28160 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 29184 ++read 1024/1024 bytes at offset 29184 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 30208 ++read 1024/1024 bytes at offset 30208 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 31232 ++read 1024/1024 bytes at offset 31232 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 32256 ++read 1024/1024 bytes at offset 32256 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 33280 ++read 1024/1024 bytes at offset 33280 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 34304 ++read 1024/1024 bytes at offset 34304 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 35328 ++read 1024/1024 bytes at offset 35328 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 36352 ++read 1024/1024 bytes at offset 36352 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 74 +-qemu-io> read 512/512 bytes at offset 37888 ++=== IO: pattern 74 ++read 512/512 bytes at offset 37888 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 38912 ++read 512/512 bytes at offset 38912 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 39936 ++read 512/512 bytes at offset 39936 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 40960 ++read 512/512 bytes at offset 40960 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 41984 ++read 512/512 bytes at offset 41984 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 43008 ++read 512/512 bytes at offset 43008 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 44032 ++read 512/512 bytes at offset 44032 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 45056 ++read 512/512 bytes at offset 45056 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 46080 ++read 512/512 bytes at offset 46080 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 47104 ++read 512/512 bytes at offset 47104 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 48128 ++read 512/512 bytes at offset 48128 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 49152 ++read 512/512 bytes at offset 49152 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 50176 ++read 512/512 bytes at offset 50176 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 51200 ++read 512/512 bytes at offset 51200 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 52224 ++read 512/512 bytes at offset 52224 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 53248 ++read 512/512 bytes at offset 53248 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 54272 ++read 512/512 bytes at offset 54272 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 55296 ++read 512/512 bytes at offset 55296 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 56320 ++read 512/512 bytes at offset 56320 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 57344 ++read 512/512 bytes at offset 57344 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 58368 ++read 512/512 bytes at offset 58368 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 59392 ++read 512/512 bytes at offset 59392 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 60416 ++read 512/512 bytes at offset 60416 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 61440 ++read 512/512 bytes at offset 61440 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 62464 ++read 512/512 bytes at offset 62464 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 63488 ++read 512/512 bytes at offset 63488 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 64512 ++read 512/512 bytes at offset 64512 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 65536 ++read 512/512 bytes at offset 65536 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 66560 ++read 512/512 bytes at offset 66560 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 67584 ++read 512/512 bytes at offset 67584 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 68608 ++read 512/512 bytes at offset 68608 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 69632 ++read 512/512 bytes at offset 69632 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 70656 ++read 512/512 bytes at offset 70656 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 71680 ++read 512/512 bytes at offset 71680 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 72704 ++read 512/512 bytes at offset 72704 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 73728 ++read 512/512 bytes at offset 73728 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 145 +-qemu-io> read 512/512 bytes at offset 74240 ++=== IO: pattern 145 ++read 512/512 bytes at offset 74240 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 75264 ++read 512/512 bytes at offset 75264 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 76288 ++read 512/512 bytes at offset 76288 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 77312 ++read 512/512 bytes at offset 77312 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 78336 ++read 512/512 bytes at offset 78336 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 79360 ++read 512/512 bytes at offset 79360 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 80384 ++read 512/512 bytes at offset 80384 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 81408 ++read 512/512 bytes at offset 81408 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 82432 ++read 512/512 bytes at offset 82432 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 83456 ++read 512/512 bytes at offset 83456 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 84480 ++read 512/512 bytes at offset 84480 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 85504 ++read 512/512 bytes at offset 85504 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 86528 ++read 512/512 bytes at offset 86528 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 87552 ++read 512/512 bytes at offset 87552 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 88576 ++read 512/512 bytes at offset 88576 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 89600 ++read 512/512 bytes at offset 89600 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 90624 ++read 512/512 bytes at offset 90624 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 91648 ++read 512/512 bytes at offset 91648 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 92672 ++read 512/512 bytes at offset 92672 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 93696 ++read 512/512 bytes at offset 93696 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 94720 ++read 512/512 bytes at offset 94720 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 95744 ++read 512/512 bytes at offset 95744 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 96768 ++read 512/512 bytes at offset 96768 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 97792 ++read 512/512 bytes at offset 97792 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 98816 ++read 512/512 bytes at offset 98816 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 99840 ++read 512/512 bytes at offset 99840 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 100864 ++read 512/512 bytes at offset 100864 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 101888 ++read 512/512 bytes at offset 101888 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 102912 ++read 512/512 bytes at offset 102912 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 103936 ++read 512/512 bytes at offset 103936 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 104960 ++read 512/512 bytes at offset 104960 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 105984 ++read 512/512 bytes at offset 105984 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 107008 ++read 512/512 bytes at offset 107008 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 108032 ++read 512/512 bytes at offset 108032 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 109056 ++read 512/512 bytes at offset 109056 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 110080 ++read 512/512 bytes at offset 110080 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 217 +-qemu-io> offset 111360 is not sector aligned +-qemu-io> offset 112384 is not sector aligned +-qemu-io> offset 113408 is not sector aligned +-qemu-io> offset 114432 is not sector aligned +-qemu-io> offset 115456 is not sector aligned +-qemu-io> offset 116480 is not sector aligned +-qemu-io> offset 117504 is not sector aligned +-qemu-io> offset 118528 is not sector aligned +-qemu-io> offset 119552 is not sector aligned +-qemu-io> offset 120576 is not sector aligned +-qemu-io> offset 121600 is not sector aligned +-qemu-io> offset 122624 is not sector aligned +-qemu-io> offset 123648 is not sector aligned +-qemu-io> offset 124672 is not sector aligned +-qemu-io> offset 125696 is not sector aligned +-qemu-io> offset 126720 is not sector aligned +-qemu-io> offset 127744 is not sector aligned +-qemu-io> offset 128768 is not sector aligned +-qemu-io> offset 129792 is not sector aligned +-qemu-io> offset 130816 is not sector aligned +-qemu-io> offset 131840 is not sector aligned +-qemu-io> offset 132864 is not sector aligned +-qemu-io> offset 133888 is not sector aligned +-qemu-io> offset 134912 is not sector aligned +-qemu-io> offset 135936 is not sector aligned +-qemu-io> offset 136960 is not sector aligned +-qemu-io> offset 137984 is not sector aligned +-qemu-io> offset 139008 is not sector aligned +-qemu-io> offset 140032 is not sector aligned +-qemu-io> offset 141056 is not sector aligned +-qemu-io> offset 142080 is not sector aligned +-qemu-io> offset 143104 is not sector aligned +-qemu-io> offset 144128 is not sector aligned +-qemu-io> offset 145152 is not sector aligned +-qemu-io> offset 146176 is not sector aligned +-qemu-io> offset 147200 is not sector aligned +-qemu-io> === IO: pattern 34 +-qemu-io> read 2048/2048 bytes at offset 148480 ++=== IO: pattern 217 ++offset 111360 is not sector aligned ++offset 112384 is not sector aligned ++offset 113408 is not sector aligned ++offset 114432 is not sector aligned ++offset 115456 is not sector aligned ++offset 116480 is not sector aligned ++offset 117504 is not sector aligned ++offset 118528 is not sector aligned ++offset 119552 is not sector aligned ++offset 120576 is not sector aligned ++offset 121600 is not sector aligned ++offset 122624 is not sector aligned ++offset 123648 is not sector aligned ++offset 124672 is not sector aligned ++offset 125696 is not sector aligned ++offset 126720 is not sector aligned ++offset 127744 is not sector aligned ++offset 128768 is not sector aligned ++offset 129792 is not sector aligned ++offset 130816 is not sector aligned ++offset 131840 is not sector aligned ++offset 132864 is not sector aligned ++offset 133888 is not sector aligned ++offset 134912 is not sector aligned ++offset 135936 is not sector aligned ++offset 136960 is not sector aligned ++offset 137984 is not sector aligned ++offset 139008 is not sector aligned ++offset 140032 is not sector aligned ++offset 141056 is not sector aligned ++offset 142080 is not sector aligned ++offset 143104 is not sector aligned ++offset 144128 is not sector aligned ++offset 145152 is not sector aligned ++offset 146176 is not sector aligned ++offset 147200 is not sector aligned ++=== IO: pattern 34 ++read 2048/2048 bytes at offset 148480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 151552 ++read 2048/2048 bytes at offset 151552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 154624 ++read 2048/2048 bytes at offset 154624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 157696 ++read 2048/2048 bytes at offset 157696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 160768 ++read 2048/2048 bytes at offset 160768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 163840 ++read 2048/2048 bytes at offset 163840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 166912 ++read 2048/2048 bytes at offset 166912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 169984 ++read 2048/2048 bytes at offset 169984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 173056 ++read 2048/2048 bytes at offset 173056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 253 +-qemu-io> read 3072/3072 bytes at offset 260608 ++=== IO: pattern 253 ++read 3072/3072 bytes at offset 260608 + 3 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 3072/3072 bytes at offset 392192 ++read 3072/3072 bytes at offset 392192 + 3 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 3072/3072 bytes at offset 523776 ++read 3072/3072 bytes at offset 523776 + 3 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 1 +-qemu-io> wrote 1024/1024 bytes at offset 512 ++=== IO: pattern 1 ++wrote 1024/1024 bytes at offset 512 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 1536 ++wrote 1024/1024 bytes at offset 1536 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 2560 ++wrote 1024/1024 bytes at offset 2560 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 3584 ++wrote 1024/1024 bytes at offset 3584 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4608 ++wrote 1024/1024 bytes at offset 4608 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 5632 ++wrote 1024/1024 bytes at offset 5632 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 6656 ++wrote 1024/1024 bytes at offset 6656 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 7680 ++wrote 1024/1024 bytes at offset 7680 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 8704 ++wrote 1024/1024 bytes at offset 8704 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 9728 ++wrote 1024/1024 bytes at offset 9728 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 10752 ++wrote 1024/1024 bytes at offset 10752 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 11776 ++wrote 1024/1024 bytes at offset 11776 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 12800 ++wrote 1024/1024 bytes at offset 12800 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 13824 ++wrote 1024/1024 bytes at offset 13824 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 14848 ++wrote 1024/1024 bytes at offset 14848 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 15872 ++wrote 1024/1024 bytes at offset 15872 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 16896 ++wrote 1024/1024 bytes at offset 16896 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 17920 ++wrote 1024/1024 bytes at offset 17920 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 18944 ++wrote 1024/1024 bytes at offset 18944 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 19968 ++wrote 1024/1024 bytes at offset 19968 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 20992 ++wrote 1024/1024 bytes at offset 20992 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 22016 ++wrote 1024/1024 bytes at offset 22016 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 23040 ++wrote 1024/1024 bytes at offset 23040 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 24064 ++wrote 1024/1024 bytes at offset 24064 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 25088 ++wrote 1024/1024 bytes at offset 25088 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 26112 ++wrote 1024/1024 bytes at offset 26112 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 27136 ++wrote 1024/1024 bytes at offset 27136 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 28160 ++wrote 1024/1024 bytes at offset 28160 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 29184 ++wrote 1024/1024 bytes at offset 29184 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 30208 ++wrote 1024/1024 bytes at offset 30208 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 31232 ++wrote 1024/1024 bytes at offset 31232 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 32256 ++wrote 1024/1024 bytes at offset 32256 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 33280 ++wrote 1024/1024 bytes at offset 33280 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 34304 ++wrote 1024/1024 bytes at offset 34304 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 35328 ++wrote 1024/1024 bytes at offset 35328 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 36352 ++wrote 1024/1024 bytes at offset 36352 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 74 +-qemu-io> wrote 512/512 bytes at offset 37888 ++=== IO: pattern 74 ++wrote 512/512 bytes at offset 37888 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 38912 ++wrote 512/512 bytes at offset 38912 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 39936 ++wrote 512/512 bytes at offset 39936 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 40960 ++wrote 512/512 bytes at offset 40960 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 41984 ++wrote 512/512 bytes at offset 41984 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 43008 ++wrote 512/512 bytes at offset 43008 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 44032 ++wrote 512/512 bytes at offset 44032 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 45056 ++wrote 512/512 bytes at offset 45056 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 46080 ++wrote 512/512 bytes at offset 46080 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 47104 ++wrote 512/512 bytes at offset 47104 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 48128 ++wrote 512/512 bytes at offset 48128 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 49152 ++wrote 512/512 bytes at offset 49152 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 50176 ++wrote 512/512 bytes at offset 50176 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 51200 ++wrote 512/512 bytes at offset 51200 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 52224 ++wrote 512/512 bytes at offset 52224 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 53248 ++wrote 512/512 bytes at offset 53248 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 54272 ++wrote 512/512 bytes at offset 54272 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 55296 ++wrote 512/512 bytes at offset 55296 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 56320 ++wrote 512/512 bytes at offset 56320 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 57344 ++wrote 512/512 bytes at offset 57344 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 58368 ++wrote 512/512 bytes at offset 58368 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 59392 ++wrote 512/512 bytes at offset 59392 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 60416 ++wrote 512/512 bytes at offset 60416 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 61440 ++wrote 512/512 bytes at offset 61440 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 62464 ++wrote 512/512 bytes at offset 62464 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 63488 ++wrote 512/512 bytes at offset 63488 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 64512 ++wrote 512/512 bytes at offset 64512 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 65536 ++wrote 512/512 bytes at offset 65536 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 66560 ++wrote 512/512 bytes at offset 66560 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 67584 ++wrote 512/512 bytes at offset 67584 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 68608 ++wrote 512/512 bytes at offset 68608 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 69632 ++wrote 512/512 bytes at offset 69632 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 70656 ++wrote 512/512 bytes at offset 70656 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 71680 ++wrote 512/512 bytes at offset 71680 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 72704 ++wrote 512/512 bytes at offset 72704 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 73728 ++wrote 512/512 bytes at offset 73728 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 145 +-qemu-io> wrote 512/512 bytes at offset 74240 ++=== IO: pattern 145 ++wrote 512/512 bytes at offset 74240 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 75264 ++wrote 512/512 bytes at offset 75264 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 76288 ++wrote 512/512 bytes at offset 76288 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 77312 ++wrote 512/512 bytes at offset 77312 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 78336 ++wrote 512/512 bytes at offset 78336 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 79360 ++wrote 512/512 bytes at offset 79360 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 80384 ++wrote 512/512 bytes at offset 80384 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 81408 ++wrote 512/512 bytes at offset 81408 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 82432 ++wrote 512/512 bytes at offset 82432 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 83456 ++wrote 512/512 bytes at offset 83456 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 84480 ++wrote 512/512 bytes at offset 84480 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 85504 ++wrote 512/512 bytes at offset 85504 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 86528 ++wrote 512/512 bytes at offset 86528 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 87552 ++wrote 512/512 bytes at offset 87552 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 88576 ++wrote 512/512 bytes at offset 88576 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 89600 ++wrote 512/512 bytes at offset 89600 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 90624 ++wrote 512/512 bytes at offset 90624 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 91648 ++wrote 512/512 bytes at offset 91648 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 92672 ++wrote 512/512 bytes at offset 92672 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 93696 ++wrote 512/512 bytes at offset 93696 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 94720 ++wrote 512/512 bytes at offset 94720 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 95744 ++wrote 512/512 bytes at offset 95744 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 96768 ++wrote 512/512 bytes at offset 96768 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 97792 ++wrote 512/512 bytes at offset 97792 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 98816 ++wrote 512/512 bytes at offset 98816 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 99840 ++wrote 512/512 bytes at offset 99840 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 100864 ++wrote 512/512 bytes at offset 100864 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 101888 ++wrote 512/512 bytes at offset 101888 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 102912 ++wrote 512/512 bytes at offset 102912 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 103936 ++wrote 512/512 bytes at offset 103936 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 104960 ++wrote 512/512 bytes at offset 104960 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 105984 ++wrote 512/512 bytes at offset 105984 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 107008 ++wrote 512/512 bytes at offset 107008 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 108032 ++wrote 512/512 bytes at offset 108032 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 109056 ++wrote 512/512 bytes at offset 109056 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 110080 ++wrote 512/512 bytes at offset 110080 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 217 +-qemu-io> offset 111360 is not sector aligned +-qemu-io> offset 112384 is not sector aligned +-qemu-io> offset 113408 is not sector aligned +-qemu-io> offset 114432 is not sector aligned +-qemu-io> offset 115456 is not sector aligned +-qemu-io> offset 116480 is not sector aligned +-qemu-io> offset 117504 is not sector aligned +-qemu-io> offset 118528 is not sector aligned +-qemu-io> offset 119552 is not sector aligned +-qemu-io> offset 120576 is not sector aligned +-qemu-io> offset 121600 is not sector aligned +-qemu-io> offset 122624 is not sector aligned +-qemu-io> offset 123648 is not sector aligned +-qemu-io> offset 124672 is not sector aligned +-qemu-io> offset 125696 is not sector aligned +-qemu-io> offset 126720 is not sector aligned +-qemu-io> offset 127744 is not sector aligned +-qemu-io> offset 128768 is not sector aligned +-qemu-io> offset 129792 is not sector aligned +-qemu-io> offset 130816 is not sector aligned +-qemu-io> offset 131840 is not sector aligned +-qemu-io> offset 132864 is not sector aligned +-qemu-io> offset 133888 is not sector aligned +-qemu-io> offset 134912 is not sector aligned +-qemu-io> offset 135936 is not sector aligned +-qemu-io> offset 136960 is not sector aligned +-qemu-io> offset 137984 is not sector aligned +-qemu-io> offset 139008 is not sector aligned +-qemu-io> offset 140032 is not sector aligned +-qemu-io> offset 141056 is not sector aligned +-qemu-io> offset 142080 is not sector aligned +-qemu-io> offset 143104 is not sector aligned +-qemu-io> offset 144128 is not sector aligned +-qemu-io> offset 145152 is not sector aligned +-qemu-io> offset 146176 is not sector aligned +-qemu-io> offset 147200 is not sector aligned +-qemu-io> === IO: pattern 34 +-qemu-io> wrote 2048/2048 bytes at offset 148480 ++=== IO: pattern 217 ++offset 111360 is not sector aligned ++offset 112384 is not sector aligned ++offset 113408 is not sector aligned ++offset 114432 is not sector aligned ++offset 115456 is not sector aligned ++offset 116480 is not sector aligned ++offset 117504 is not sector aligned ++offset 118528 is not sector aligned ++offset 119552 is not sector aligned ++offset 120576 is not sector aligned ++offset 121600 is not sector aligned ++offset 122624 is not sector aligned ++offset 123648 is not sector aligned ++offset 124672 is not sector aligned ++offset 125696 is not sector aligned ++offset 126720 is not sector aligned ++offset 127744 is not sector aligned ++offset 128768 is not sector aligned ++offset 129792 is not sector aligned ++offset 130816 is not sector aligned ++offset 131840 is not sector aligned ++offset 132864 is not sector aligned ++offset 133888 is not sector aligned ++offset 134912 is not sector aligned ++offset 135936 is not sector aligned ++offset 136960 is not sector aligned ++offset 137984 is not sector aligned ++offset 139008 is not sector aligned ++offset 140032 is not sector aligned ++offset 141056 is not sector aligned ++offset 142080 is not sector aligned ++offset 143104 is not sector aligned ++offset 144128 is not sector aligned ++offset 145152 is not sector aligned ++offset 146176 is not sector aligned ++offset 147200 is not sector aligned ++=== IO: pattern 34 ++wrote 2048/2048 bytes at offset 148480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 151552 ++wrote 2048/2048 bytes at offset 151552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 154624 ++wrote 2048/2048 bytes at offset 154624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 157696 ++wrote 2048/2048 bytes at offset 157696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 160768 ++wrote 2048/2048 bytes at offset 160768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 163840 ++wrote 2048/2048 bytes at offset 163840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 166912 ++wrote 2048/2048 bytes at offset 166912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 169984 ++wrote 2048/2048 bytes at offset 169984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 173056 ++wrote 2048/2048 bytes at offset 173056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 253 +-qemu-io> wrote 3072/3072 bytes at offset 260608 ++=== IO: pattern 253 ++wrote 3072/3072 bytes at offset 260608 + 3 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 3072/3072 bytes at offset 392192 ++wrote 3072/3072 bytes at offset 392192 + 3 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 3072/3072 bytes at offset 523776 ++wrote 3072/3072 bytes at offset 523776 + 3 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 1 +-qemu-io> read 1024/1024 bytes at offset 512 ++=== IO: pattern 1 ++read 1024/1024 bytes at offset 512 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 1536 ++read 1024/1024 bytes at offset 1536 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 2560 ++read 1024/1024 bytes at offset 2560 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 3584 ++read 1024/1024 bytes at offset 3584 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4608 ++read 1024/1024 bytes at offset 4608 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 5632 ++read 1024/1024 bytes at offset 5632 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 6656 ++read 1024/1024 bytes at offset 6656 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 7680 ++read 1024/1024 bytes at offset 7680 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 8704 ++read 1024/1024 bytes at offset 8704 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 9728 ++read 1024/1024 bytes at offset 9728 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 10752 ++read 1024/1024 bytes at offset 10752 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 11776 ++read 1024/1024 bytes at offset 11776 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 12800 ++read 1024/1024 bytes at offset 12800 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 13824 ++read 1024/1024 bytes at offset 13824 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 14848 ++read 1024/1024 bytes at offset 14848 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 15872 ++read 1024/1024 bytes at offset 15872 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 16896 ++read 1024/1024 bytes at offset 16896 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 17920 ++read 1024/1024 bytes at offset 17920 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 18944 ++read 1024/1024 bytes at offset 18944 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 19968 ++read 1024/1024 bytes at offset 19968 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 20992 ++read 1024/1024 bytes at offset 20992 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 22016 ++read 1024/1024 bytes at offset 22016 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 23040 ++read 1024/1024 bytes at offset 23040 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 24064 ++read 1024/1024 bytes at offset 24064 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 25088 ++read 1024/1024 bytes at offset 25088 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 26112 ++read 1024/1024 bytes at offset 26112 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 27136 ++read 1024/1024 bytes at offset 27136 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 28160 ++read 1024/1024 bytes at offset 28160 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 29184 ++read 1024/1024 bytes at offset 29184 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 30208 ++read 1024/1024 bytes at offset 30208 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 31232 ++read 1024/1024 bytes at offset 31232 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 32256 ++read 1024/1024 bytes at offset 32256 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 33280 ++read 1024/1024 bytes at offset 33280 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 34304 ++read 1024/1024 bytes at offset 34304 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 35328 ++read 1024/1024 bytes at offset 35328 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 36352 ++read 1024/1024 bytes at offset 36352 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 74 +-qemu-io> read 512/512 bytes at offset 37888 ++=== IO: pattern 74 ++read 512/512 bytes at offset 37888 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 38912 ++read 512/512 bytes at offset 38912 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 39936 ++read 512/512 bytes at offset 39936 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 40960 ++read 512/512 bytes at offset 40960 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 41984 ++read 512/512 bytes at offset 41984 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 43008 ++read 512/512 bytes at offset 43008 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 44032 ++read 512/512 bytes at offset 44032 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 45056 ++read 512/512 bytes at offset 45056 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 46080 ++read 512/512 bytes at offset 46080 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 47104 ++read 512/512 bytes at offset 47104 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 48128 ++read 512/512 bytes at offset 48128 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 49152 ++read 512/512 bytes at offset 49152 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 50176 ++read 512/512 bytes at offset 50176 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 51200 ++read 512/512 bytes at offset 51200 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 52224 ++read 512/512 bytes at offset 52224 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 53248 ++read 512/512 bytes at offset 53248 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 54272 ++read 512/512 bytes at offset 54272 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 55296 ++read 512/512 bytes at offset 55296 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 56320 ++read 512/512 bytes at offset 56320 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 57344 ++read 512/512 bytes at offset 57344 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 58368 ++read 512/512 bytes at offset 58368 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 59392 ++read 512/512 bytes at offset 59392 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 60416 ++read 512/512 bytes at offset 60416 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 61440 ++read 512/512 bytes at offset 61440 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 62464 ++read 512/512 bytes at offset 62464 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 63488 ++read 512/512 bytes at offset 63488 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 64512 ++read 512/512 bytes at offset 64512 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 65536 ++read 512/512 bytes at offset 65536 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 66560 ++read 512/512 bytes at offset 66560 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 67584 ++read 512/512 bytes at offset 67584 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 68608 ++read 512/512 bytes at offset 68608 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 69632 ++read 512/512 bytes at offset 69632 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 70656 ++read 512/512 bytes at offset 70656 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 71680 ++read 512/512 bytes at offset 71680 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 72704 ++read 512/512 bytes at offset 72704 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 73728 ++read 512/512 bytes at offset 73728 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 145 +-qemu-io> read 512/512 bytes at offset 74240 ++=== IO: pattern 145 ++read 512/512 bytes at offset 74240 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 75264 ++read 512/512 bytes at offset 75264 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 76288 ++read 512/512 bytes at offset 76288 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 77312 ++read 512/512 bytes at offset 77312 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 78336 ++read 512/512 bytes at offset 78336 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 79360 ++read 512/512 bytes at offset 79360 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 80384 ++read 512/512 bytes at offset 80384 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 81408 ++read 512/512 bytes at offset 81408 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 82432 ++read 512/512 bytes at offset 82432 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 83456 ++read 512/512 bytes at offset 83456 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 84480 ++read 512/512 bytes at offset 84480 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 85504 ++read 512/512 bytes at offset 85504 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 86528 ++read 512/512 bytes at offset 86528 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 87552 ++read 512/512 bytes at offset 87552 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 88576 ++read 512/512 bytes at offset 88576 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 89600 ++read 512/512 bytes at offset 89600 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 90624 ++read 512/512 bytes at offset 90624 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 91648 ++read 512/512 bytes at offset 91648 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 92672 ++read 512/512 bytes at offset 92672 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 93696 ++read 512/512 bytes at offset 93696 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 94720 ++read 512/512 bytes at offset 94720 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 95744 ++read 512/512 bytes at offset 95744 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 96768 ++read 512/512 bytes at offset 96768 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 97792 ++read 512/512 bytes at offset 97792 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 98816 ++read 512/512 bytes at offset 98816 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 99840 ++read 512/512 bytes at offset 99840 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 100864 ++read 512/512 bytes at offset 100864 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 101888 ++read 512/512 bytes at offset 101888 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 102912 ++read 512/512 bytes at offset 102912 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 103936 ++read 512/512 bytes at offset 103936 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 104960 ++read 512/512 bytes at offset 104960 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 105984 ++read 512/512 bytes at offset 105984 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 107008 ++read 512/512 bytes at offset 107008 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 108032 ++read 512/512 bytes at offset 108032 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 109056 ++read 512/512 bytes at offset 109056 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 110080 ++read 512/512 bytes at offset 110080 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 217 +-qemu-io> offset 111360 is not sector aligned +-qemu-io> offset 112384 is not sector aligned +-qemu-io> offset 113408 is not sector aligned +-qemu-io> offset 114432 is not sector aligned +-qemu-io> offset 115456 is not sector aligned +-qemu-io> offset 116480 is not sector aligned +-qemu-io> offset 117504 is not sector aligned +-qemu-io> offset 118528 is not sector aligned +-qemu-io> offset 119552 is not sector aligned +-qemu-io> offset 120576 is not sector aligned +-qemu-io> offset 121600 is not sector aligned +-qemu-io> offset 122624 is not sector aligned +-qemu-io> offset 123648 is not sector aligned +-qemu-io> offset 124672 is not sector aligned +-qemu-io> offset 125696 is not sector aligned +-qemu-io> offset 126720 is not sector aligned +-qemu-io> offset 127744 is not sector aligned +-qemu-io> offset 128768 is not sector aligned +-qemu-io> offset 129792 is not sector aligned +-qemu-io> offset 130816 is not sector aligned +-qemu-io> offset 131840 is not sector aligned +-qemu-io> offset 132864 is not sector aligned +-qemu-io> offset 133888 is not sector aligned +-qemu-io> offset 134912 is not sector aligned +-qemu-io> offset 135936 is not sector aligned +-qemu-io> offset 136960 is not sector aligned +-qemu-io> offset 137984 is not sector aligned +-qemu-io> offset 139008 is not sector aligned +-qemu-io> offset 140032 is not sector aligned +-qemu-io> offset 141056 is not sector aligned +-qemu-io> offset 142080 is not sector aligned +-qemu-io> offset 143104 is not sector aligned +-qemu-io> offset 144128 is not sector aligned +-qemu-io> offset 145152 is not sector aligned +-qemu-io> offset 146176 is not sector aligned +-qemu-io> offset 147200 is not sector aligned +-qemu-io> === IO: pattern 34 +-qemu-io> read 2048/2048 bytes at offset 148480 ++=== IO: pattern 217 ++offset 111360 is not sector aligned ++offset 112384 is not sector aligned ++offset 113408 is not sector aligned ++offset 114432 is not sector aligned ++offset 115456 is not sector aligned ++offset 116480 is not sector aligned ++offset 117504 is not sector aligned ++offset 118528 is not sector aligned ++offset 119552 is not sector aligned ++offset 120576 is not sector aligned ++offset 121600 is not sector aligned ++offset 122624 is not sector aligned ++offset 123648 is not sector aligned ++offset 124672 is not sector aligned ++offset 125696 is not sector aligned ++offset 126720 is not sector aligned ++offset 127744 is not sector aligned ++offset 128768 is not sector aligned ++offset 129792 is not sector aligned ++offset 130816 is not sector aligned ++offset 131840 is not sector aligned ++offset 132864 is not sector aligned ++offset 133888 is not sector aligned ++offset 134912 is not sector aligned ++offset 135936 is not sector aligned ++offset 136960 is not sector aligned ++offset 137984 is not sector aligned ++offset 139008 is not sector aligned ++offset 140032 is not sector aligned ++offset 141056 is not sector aligned ++offset 142080 is not sector aligned ++offset 143104 is not sector aligned ++offset 144128 is not sector aligned ++offset 145152 is not sector aligned ++offset 146176 is not sector aligned ++offset 147200 is not sector aligned ++=== IO: pattern 34 ++read 2048/2048 bytes at offset 148480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 151552 ++read 2048/2048 bytes at offset 151552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 154624 ++read 2048/2048 bytes at offset 154624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 157696 ++read 2048/2048 bytes at offset 157696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 160768 ++read 2048/2048 bytes at offset 160768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 163840 ++read 2048/2048 bytes at offset 163840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 166912 ++read 2048/2048 bytes at offset 166912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 169984 ++read 2048/2048 bytes at offset 169984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 173056 ++read 2048/2048 bytes at offset 173056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 253 +-qemu-io> read 3072/3072 bytes at offset 260608 ++=== IO: pattern 253 ++read 3072/3072 bytes at offset 260608 + 3 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 3072/3072 bytes at offset 392192 ++read 3072/3072 bytes at offset 392192 + 3 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 3072/3072 bytes at offset 523776 ++read 3072/3072 bytes at offset 523776 + 3 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> No errors were found on the image. ++No errors were found on the image. + With offset 4294967808: + === IO: pattern 1 +-qemu-io> wrote 1024/1024 bytes at offset 4294967808 ++wrote 1024/1024 bytes at offset 4294967808 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294968832 ++wrote 1024/1024 bytes at offset 4294968832 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294969856 ++wrote 1024/1024 bytes at offset 4294969856 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294970880 ++wrote 1024/1024 bytes at offset 4294970880 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294971904 ++wrote 1024/1024 bytes at offset 4294971904 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294972928 ++wrote 1024/1024 bytes at offset 4294972928 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294973952 ++wrote 1024/1024 bytes at offset 4294973952 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294974976 ++wrote 1024/1024 bytes at offset 4294974976 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294976000 ++wrote 1024/1024 bytes at offset 4294976000 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294977024 ++wrote 1024/1024 bytes at offset 4294977024 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294978048 ++wrote 1024/1024 bytes at offset 4294978048 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294979072 ++wrote 1024/1024 bytes at offset 4294979072 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294980096 ++wrote 1024/1024 bytes at offset 4294980096 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294981120 ++wrote 1024/1024 bytes at offset 4294981120 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294982144 ++wrote 1024/1024 bytes at offset 4294982144 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294983168 ++wrote 1024/1024 bytes at offset 4294983168 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294984192 ++wrote 1024/1024 bytes at offset 4294984192 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294985216 ++wrote 1024/1024 bytes at offset 4294985216 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294986240 ++wrote 1024/1024 bytes at offset 4294986240 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294987264 ++wrote 1024/1024 bytes at offset 4294987264 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294988288 ++wrote 1024/1024 bytes at offset 4294988288 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294989312 ++wrote 1024/1024 bytes at offset 4294989312 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294990336 ++wrote 1024/1024 bytes at offset 4294990336 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294991360 ++wrote 1024/1024 bytes at offset 4294991360 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294992384 ++wrote 1024/1024 bytes at offset 4294992384 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294993408 ++wrote 1024/1024 bytes at offset 4294993408 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294994432 ++wrote 1024/1024 bytes at offset 4294994432 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294995456 ++wrote 1024/1024 bytes at offset 4294995456 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294996480 ++wrote 1024/1024 bytes at offset 4294996480 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294997504 ++wrote 1024/1024 bytes at offset 4294997504 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294998528 ++wrote 1024/1024 bytes at offset 4294998528 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294999552 ++wrote 1024/1024 bytes at offset 4294999552 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4295000576 ++wrote 1024/1024 bytes at offset 4295000576 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4295001600 ++wrote 1024/1024 bytes at offset 4295001600 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4295002624 ++wrote 1024/1024 bytes at offset 4295002624 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4295003648 ++wrote 1024/1024 bytes at offset 4295003648 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 74 +-qemu-io> wrote 512/512 bytes at offset 4295005184 ++=== IO: pattern 74 ++wrote 512/512 bytes at offset 4295005184 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295006208 ++wrote 512/512 bytes at offset 4295006208 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295007232 ++wrote 512/512 bytes at offset 4295007232 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295008256 ++wrote 512/512 bytes at offset 4295008256 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295009280 ++wrote 512/512 bytes at offset 4295009280 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295010304 ++wrote 512/512 bytes at offset 4295010304 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295011328 ++wrote 512/512 bytes at offset 4295011328 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295012352 ++wrote 512/512 bytes at offset 4295012352 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295013376 ++wrote 512/512 bytes at offset 4295013376 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295014400 ++wrote 512/512 bytes at offset 4295014400 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295015424 ++wrote 512/512 bytes at offset 4295015424 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295016448 ++wrote 512/512 bytes at offset 4295016448 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295017472 ++wrote 512/512 bytes at offset 4295017472 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295018496 ++wrote 512/512 bytes at offset 4295018496 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295019520 ++wrote 512/512 bytes at offset 4295019520 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295020544 ++wrote 512/512 bytes at offset 4295020544 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295021568 ++wrote 512/512 bytes at offset 4295021568 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295022592 ++wrote 512/512 bytes at offset 4295022592 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295023616 ++wrote 512/512 bytes at offset 4295023616 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295024640 ++wrote 512/512 bytes at offset 4295024640 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295025664 ++wrote 512/512 bytes at offset 4295025664 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295026688 ++wrote 512/512 bytes at offset 4295026688 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295027712 ++wrote 512/512 bytes at offset 4295027712 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295028736 ++wrote 512/512 bytes at offset 4295028736 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295029760 ++wrote 512/512 bytes at offset 4295029760 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295030784 ++wrote 512/512 bytes at offset 4295030784 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295031808 ++wrote 512/512 bytes at offset 4295031808 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295032832 ++wrote 512/512 bytes at offset 4295032832 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295033856 ++wrote 512/512 bytes at offset 4295033856 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295034880 ++wrote 512/512 bytes at offset 4295034880 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295035904 ++wrote 512/512 bytes at offset 4295035904 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295036928 ++wrote 512/512 bytes at offset 4295036928 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295037952 ++wrote 512/512 bytes at offset 4295037952 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295038976 ++wrote 512/512 bytes at offset 4295038976 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295040000 ++wrote 512/512 bytes at offset 4295040000 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295041024 ++wrote 512/512 bytes at offset 4295041024 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 145 +-qemu-io> wrote 512/512 bytes at offset 4295041536 ++=== IO: pattern 145 ++wrote 512/512 bytes at offset 4295041536 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295042560 ++wrote 512/512 bytes at offset 4295042560 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295043584 ++wrote 512/512 bytes at offset 4295043584 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295044608 ++wrote 512/512 bytes at offset 4295044608 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295045632 ++wrote 512/512 bytes at offset 4295045632 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295046656 ++wrote 512/512 bytes at offset 4295046656 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295047680 ++wrote 512/512 bytes at offset 4295047680 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295048704 ++wrote 512/512 bytes at offset 4295048704 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295049728 ++wrote 512/512 bytes at offset 4295049728 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295050752 ++wrote 512/512 bytes at offset 4295050752 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295051776 ++wrote 512/512 bytes at offset 4295051776 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295052800 ++wrote 512/512 bytes at offset 4295052800 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295053824 ++wrote 512/512 bytes at offset 4295053824 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295054848 ++wrote 512/512 bytes at offset 4295054848 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295055872 ++wrote 512/512 bytes at offset 4295055872 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295056896 ++wrote 512/512 bytes at offset 4295056896 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295057920 ++wrote 512/512 bytes at offset 4295057920 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295058944 ++wrote 512/512 bytes at offset 4295058944 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295059968 ++wrote 512/512 bytes at offset 4295059968 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295060992 ++wrote 512/512 bytes at offset 4295060992 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295062016 ++wrote 512/512 bytes at offset 4295062016 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295063040 ++wrote 512/512 bytes at offset 4295063040 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295064064 ++wrote 512/512 bytes at offset 4295064064 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295065088 ++wrote 512/512 bytes at offset 4295065088 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295066112 ++wrote 512/512 bytes at offset 4295066112 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295067136 ++wrote 512/512 bytes at offset 4295067136 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295068160 ++wrote 512/512 bytes at offset 4295068160 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295069184 ++wrote 512/512 bytes at offset 4295069184 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295070208 ++wrote 512/512 bytes at offset 4295070208 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295071232 ++wrote 512/512 bytes at offset 4295071232 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295072256 ++wrote 512/512 bytes at offset 4295072256 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295073280 ++wrote 512/512 bytes at offset 4295073280 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295074304 ++wrote 512/512 bytes at offset 4295074304 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295075328 ++wrote 512/512 bytes at offset 4295075328 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295076352 ++wrote 512/512 bytes at offset 4295076352 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295077376 ++wrote 512/512 bytes at offset 4295077376 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 217 +-qemu-io> offset 4295078656 is not sector aligned +-qemu-io> offset 4295079680 is not sector aligned +-qemu-io> offset 4295080704 is not sector aligned +-qemu-io> offset 4295081728 is not sector aligned +-qemu-io> offset 4295082752 is not sector aligned +-qemu-io> offset 4295083776 is not sector aligned +-qemu-io> offset 4295084800 is not sector aligned +-qemu-io> offset 4295085824 is not sector aligned +-qemu-io> offset 4295086848 is not sector aligned +-qemu-io> offset 4295087872 is not sector aligned +-qemu-io> offset 4295088896 is not sector aligned +-qemu-io> offset 4295089920 is not sector aligned +-qemu-io> offset 4295090944 is not sector aligned +-qemu-io> offset 4295091968 is not sector aligned +-qemu-io> offset 4295092992 is not sector aligned +-qemu-io> offset 4295094016 is not sector aligned +-qemu-io> offset 4295095040 is not sector aligned +-qemu-io> offset 4295096064 is not sector aligned +-qemu-io> offset 4295097088 is not sector aligned +-qemu-io> offset 4295098112 is not sector aligned +-qemu-io> offset 4295099136 is not sector aligned +-qemu-io> offset 4295100160 is not sector aligned +-qemu-io> offset 4295101184 is not sector aligned +-qemu-io> offset 4295102208 is not sector aligned +-qemu-io> offset 4295103232 is not sector aligned +-qemu-io> offset 4295104256 is not sector aligned +-qemu-io> offset 4295105280 is not sector aligned +-qemu-io> offset 4295106304 is not sector aligned +-qemu-io> offset 4295107328 is not sector aligned +-qemu-io> offset 4295108352 is not sector aligned +-qemu-io> offset 4295109376 is not sector aligned +-qemu-io> offset 4295110400 is not sector aligned +-qemu-io> offset 4295111424 is not sector aligned +-qemu-io> offset 4295112448 is not sector aligned +-qemu-io> offset 4295113472 is not sector aligned +-qemu-io> offset 4295114496 is not sector aligned +-qemu-io> === IO: pattern 34 +-qemu-io> wrote 2048/2048 bytes at offset 4295115776 ++=== IO: pattern 217 ++offset 4295078656 is not sector aligned ++offset 4295079680 is not sector aligned ++offset 4295080704 is not sector aligned ++offset 4295081728 is not sector aligned ++offset 4295082752 is not sector aligned ++offset 4295083776 is not sector aligned ++offset 4295084800 is not sector aligned ++offset 4295085824 is not sector aligned ++offset 4295086848 is not sector aligned ++offset 4295087872 is not sector aligned ++offset 4295088896 is not sector aligned ++offset 4295089920 is not sector aligned ++offset 4295090944 is not sector aligned ++offset 4295091968 is not sector aligned ++offset 4295092992 is not sector aligned ++offset 4295094016 is not sector aligned ++offset 4295095040 is not sector aligned ++offset 4295096064 is not sector aligned ++offset 4295097088 is not sector aligned ++offset 4295098112 is not sector aligned ++offset 4295099136 is not sector aligned ++offset 4295100160 is not sector aligned ++offset 4295101184 is not sector aligned ++offset 4295102208 is not sector aligned ++offset 4295103232 is not sector aligned ++offset 4295104256 is not sector aligned ++offset 4295105280 is not sector aligned ++offset 4295106304 is not sector aligned ++offset 4295107328 is not sector aligned ++offset 4295108352 is not sector aligned ++offset 4295109376 is not sector aligned ++offset 4295110400 is not sector aligned ++offset 4295111424 is not sector aligned ++offset 4295112448 is not sector aligned ++offset 4295113472 is not sector aligned ++offset 4295114496 is not sector aligned ++=== IO: pattern 34 ++wrote 2048/2048 bytes at offset 4295115776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295118848 ++wrote 2048/2048 bytes at offset 4295118848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295121920 ++wrote 2048/2048 bytes at offset 4295121920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295124992 ++wrote 2048/2048 bytes at offset 4295124992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295128064 ++wrote 2048/2048 bytes at offset 4295128064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295131136 ++wrote 2048/2048 bytes at offset 4295131136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295134208 ++wrote 2048/2048 bytes at offset 4295134208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295137280 ++wrote 2048/2048 bytes at offset 4295137280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295140352 ++wrote 2048/2048 bytes at offset 4295140352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 253 +-qemu-io> wrote 3072/3072 bytes at offset 4295227904 ++=== IO: pattern 253 ++wrote 3072/3072 bytes at offset 4295227904 + 3 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 3072/3072 bytes at offset 4295359488 ++wrote 3072/3072 bytes at offset 4295359488 + 3 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 3072/3072 bytes at offset 4295491072 ++wrote 3072/3072 bytes at offset 4295491072 + 3 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 1 +-qemu-io> read 1024/1024 bytes at offset 4294967808 ++=== IO: pattern 1 ++read 1024/1024 bytes at offset 4294967808 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294968832 ++read 1024/1024 bytes at offset 4294968832 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294969856 ++read 1024/1024 bytes at offset 4294969856 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294970880 ++read 1024/1024 bytes at offset 4294970880 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294971904 ++read 1024/1024 bytes at offset 4294971904 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294972928 ++read 1024/1024 bytes at offset 4294972928 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294973952 ++read 1024/1024 bytes at offset 4294973952 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294974976 ++read 1024/1024 bytes at offset 4294974976 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294976000 ++read 1024/1024 bytes at offset 4294976000 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294977024 ++read 1024/1024 bytes at offset 4294977024 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294978048 ++read 1024/1024 bytes at offset 4294978048 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294979072 ++read 1024/1024 bytes at offset 4294979072 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294980096 ++read 1024/1024 bytes at offset 4294980096 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294981120 ++read 1024/1024 bytes at offset 4294981120 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294982144 ++read 1024/1024 bytes at offset 4294982144 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294983168 ++read 1024/1024 bytes at offset 4294983168 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294984192 ++read 1024/1024 bytes at offset 4294984192 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294985216 ++read 1024/1024 bytes at offset 4294985216 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294986240 ++read 1024/1024 bytes at offset 4294986240 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294987264 ++read 1024/1024 bytes at offset 4294987264 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294988288 ++read 1024/1024 bytes at offset 4294988288 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294989312 ++read 1024/1024 bytes at offset 4294989312 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294990336 ++read 1024/1024 bytes at offset 4294990336 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294991360 ++read 1024/1024 bytes at offset 4294991360 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294992384 ++read 1024/1024 bytes at offset 4294992384 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294993408 ++read 1024/1024 bytes at offset 4294993408 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294994432 ++read 1024/1024 bytes at offset 4294994432 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294995456 ++read 1024/1024 bytes at offset 4294995456 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294996480 ++read 1024/1024 bytes at offset 4294996480 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294997504 ++read 1024/1024 bytes at offset 4294997504 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294998528 ++read 1024/1024 bytes at offset 4294998528 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294999552 ++read 1024/1024 bytes at offset 4294999552 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4295000576 ++read 1024/1024 bytes at offset 4295000576 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4295001600 ++read 1024/1024 bytes at offset 4295001600 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4295002624 ++read 1024/1024 bytes at offset 4295002624 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4295003648 ++read 1024/1024 bytes at offset 4295003648 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 74 +-qemu-io> read 512/512 bytes at offset 4295005184 ++=== IO: pattern 74 ++read 512/512 bytes at offset 4295005184 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295006208 ++read 512/512 bytes at offset 4295006208 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295007232 ++read 512/512 bytes at offset 4295007232 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295008256 ++read 512/512 bytes at offset 4295008256 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295009280 ++read 512/512 bytes at offset 4295009280 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295010304 ++read 512/512 bytes at offset 4295010304 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295011328 ++read 512/512 bytes at offset 4295011328 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295012352 ++read 512/512 bytes at offset 4295012352 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295013376 ++read 512/512 bytes at offset 4295013376 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295014400 ++read 512/512 bytes at offset 4295014400 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295015424 ++read 512/512 bytes at offset 4295015424 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295016448 ++read 512/512 bytes at offset 4295016448 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295017472 ++read 512/512 bytes at offset 4295017472 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295018496 ++read 512/512 bytes at offset 4295018496 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295019520 ++read 512/512 bytes at offset 4295019520 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295020544 ++read 512/512 bytes at offset 4295020544 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295021568 ++read 512/512 bytes at offset 4295021568 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295022592 ++read 512/512 bytes at offset 4295022592 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295023616 ++read 512/512 bytes at offset 4295023616 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295024640 ++read 512/512 bytes at offset 4295024640 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295025664 ++read 512/512 bytes at offset 4295025664 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295026688 ++read 512/512 bytes at offset 4295026688 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295027712 ++read 512/512 bytes at offset 4295027712 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295028736 ++read 512/512 bytes at offset 4295028736 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295029760 ++read 512/512 bytes at offset 4295029760 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295030784 ++read 512/512 bytes at offset 4295030784 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295031808 ++read 512/512 bytes at offset 4295031808 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295032832 ++read 512/512 bytes at offset 4295032832 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295033856 ++read 512/512 bytes at offset 4295033856 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295034880 ++read 512/512 bytes at offset 4295034880 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295035904 ++read 512/512 bytes at offset 4295035904 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295036928 ++read 512/512 bytes at offset 4295036928 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295037952 ++read 512/512 bytes at offset 4295037952 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295038976 ++read 512/512 bytes at offset 4295038976 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295040000 ++read 512/512 bytes at offset 4295040000 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295041024 ++read 512/512 bytes at offset 4295041024 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 145 +-qemu-io> read 512/512 bytes at offset 4295041536 ++=== IO: pattern 145 ++read 512/512 bytes at offset 4295041536 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295042560 ++read 512/512 bytes at offset 4295042560 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295043584 ++read 512/512 bytes at offset 4295043584 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295044608 ++read 512/512 bytes at offset 4295044608 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295045632 ++read 512/512 bytes at offset 4295045632 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295046656 ++read 512/512 bytes at offset 4295046656 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295047680 ++read 512/512 bytes at offset 4295047680 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295048704 ++read 512/512 bytes at offset 4295048704 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295049728 ++read 512/512 bytes at offset 4295049728 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295050752 ++read 512/512 bytes at offset 4295050752 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295051776 ++read 512/512 bytes at offset 4295051776 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295052800 ++read 512/512 bytes at offset 4295052800 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295053824 ++read 512/512 bytes at offset 4295053824 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295054848 ++read 512/512 bytes at offset 4295054848 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295055872 ++read 512/512 bytes at offset 4295055872 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295056896 ++read 512/512 bytes at offset 4295056896 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295057920 ++read 512/512 bytes at offset 4295057920 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295058944 ++read 512/512 bytes at offset 4295058944 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295059968 ++read 512/512 bytes at offset 4295059968 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295060992 ++read 512/512 bytes at offset 4295060992 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295062016 ++read 512/512 bytes at offset 4295062016 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295063040 ++read 512/512 bytes at offset 4295063040 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295064064 ++read 512/512 bytes at offset 4295064064 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295065088 ++read 512/512 bytes at offset 4295065088 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295066112 ++read 512/512 bytes at offset 4295066112 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295067136 ++read 512/512 bytes at offset 4295067136 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295068160 ++read 512/512 bytes at offset 4295068160 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295069184 ++read 512/512 bytes at offset 4295069184 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295070208 ++read 512/512 bytes at offset 4295070208 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295071232 ++read 512/512 bytes at offset 4295071232 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295072256 ++read 512/512 bytes at offset 4295072256 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295073280 ++read 512/512 bytes at offset 4295073280 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295074304 ++read 512/512 bytes at offset 4295074304 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295075328 ++read 512/512 bytes at offset 4295075328 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295076352 ++read 512/512 bytes at offset 4295076352 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295077376 ++read 512/512 bytes at offset 4295077376 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 217 +-qemu-io> offset 4295078656 is not sector aligned +-qemu-io> offset 4295079680 is not sector aligned +-qemu-io> offset 4295080704 is not sector aligned +-qemu-io> offset 4295081728 is not sector aligned +-qemu-io> offset 4295082752 is not sector aligned +-qemu-io> offset 4295083776 is not sector aligned +-qemu-io> offset 4295084800 is not sector aligned +-qemu-io> offset 4295085824 is not sector aligned +-qemu-io> offset 4295086848 is not sector aligned +-qemu-io> offset 4295087872 is not sector aligned +-qemu-io> offset 4295088896 is not sector aligned +-qemu-io> offset 4295089920 is not sector aligned +-qemu-io> offset 4295090944 is not sector aligned +-qemu-io> offset 4295091968 is not sector aligned +-qemu-io> offset 4295092992 is not sector aligned +-qemu-io> offset 4295094016 is not sector aligned +-qemu-io> offset 4295095040 is not sector aligned +-qemu-io> offset 4295096064 is not sector aligned +-qemu-io> offset 4295097088 is not sector aligned +-qemu-io> offset 4295098112 is not sector aligned +-qemu-io> offset 4295099136 is not sector aligned +-qemu-io> offset 4295100160 is not sector aligned +-qemu-io> offset 4295101184 is not sector aligned +-qemu-io> offset 4295102208 is not sector aligned +-qemu-io> offset 4295103232 is not sector aligned +-qemu-io> offset 4295104256 is not sector aligned +-qemu-io> offset 4295105280 is not sector aligned +-qemu-io> offset 4295106304 is not sector aligned +-qemu-io> offset 4295107328 is not sector aligned +-qemu-io> offset 4295108352 is not sector aligned +-qemu-io> offset 4295109376 is not sector aligned +-qemu-io> offset 4295110400 is not sector aligned +-qemu-io> offset 4295111424 is not sector aligned +-qemu-io> offset 4295112448 is not sector aligned +-qemu-io> offset 4295113472 is not sector aligned +-qemu-io> offset 4295114496 is not sector aligned +-qemu-io> === IO: pattern 34 +-qemu-io> read 2048/2048 bytes at offset 4295115776 ++=== IO: pattern 217 ++offset 4295078656 is not sector aligned ++offset 4295079680 is not sector aligned ++offset 4295080704 is not sector aligned ++offset 4295081728 is not sector aligned ++offset 4295082752 is not sector aligned ++offset 4295083776 is not sector aligned ++offset 4295084800 is not sector aligned ++offset 4295085824 is not sector aligned ++offset 4295086848 is not sector aligned ++offset 4295087872 is not sector aligned ++offset 4295088896 is not sector aligned ++offset 4295089920 is not sector aligned ++offset 4295090944 is not sector aligned ++offset 4295091968 is not sector aligned ++offset 4295092992 is not sector aligned ++offset 4295094016 is not sector aligned ++offset 4295095040 is not sector aligned ++offset 4295096064 is not sector aligned ++offset 4295097088 is not sector aligned ++offset 4295098112 is not sector aligned ++offset 4295099136 is not sector aligned ++offset 4295100160 is not sector aligned ++offset 4295101184 is not sector aligned ++offset 4295102208 is not sector aligned ++offset 4295103232 is not sector aligned ++offset 4295104256 is not sector aligned ++offset 4295105280 is not sector aligned ++offset 4295106304 is not sector aligned ++offset 4295107328 is not sector aligned ++offset 4295108352 is not sector aligned ++offset 4295109376 is not sector aligned ++offset 4295110400 is not sector aligned ++offset 4295111424 is not sector aligned ++offset 4295112448 is not sector aligned ++offset 4295113472 is not sector aligned ++offset 4295114496 is not sector aligned ++=== IO: pattern 34 ++read 2048/2048 bytes at offset 4295115776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295118848 ++read 2048/2048 bytes at offset 4295118848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295121920 ++read 2048/2048 bytes at offset 4295121920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295124992 ++read 2048/2048 bytes at offset 4295124992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295128064 ++read 2048/2048 bytes at offset 4295128064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295131136 ++read 2048/2048 bytes at offset 4295131136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295134208 ++read 2048/2048 bytes at offset 4295134208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295137280 ++read 2048/2048 bytes at offset 4295137280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295140352 ++read 2048/2048 bytes at offset 4295140352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 253 +-qemu-io> read 3072/3072 bytes at offset 4295227904 ++=== IO: pattern 253 ++read 3072/3072 bytes at offset 4295227904 + 3 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 3072/3072 bytes at offset 4295359488 ++read 3072/3072 bytes at offset 4295359488 + 3 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 3072/3072 bytes at offset 4295491072 ++read 3072/3072 bytes at offset 4295491072 + 3 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 1 +-qemu-io> wrote 1024/1024 bytes at offset 4294967808 ++=== IO: pattern 1 ++wrote 1024/1024 bytes at offset 4294967808 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294968832 ++wrote 1024/1024 bytes at offset 4294968832 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294969856 ++wrote 1024/1024 bytes at offset 4294969856 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294970880 ++wrote 1024/1024 bytes at offset 4294970880 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294971904 ++wrote 1024/1024 bytes at offset 4294971904 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294972928 ++wrote 1024/1024 bytes at offset 4294972928 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294973952 ++wrote 1024/1024 bytes at offset 4294973952 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294974976 ++wrote 1024/1024 bytes at offset 4294974976 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294976000 ++wrote 1024/1024 bytes at offset 4294976000 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294977024 ++wrote 1024/1024 bytes at offset 4294977024 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294978048 ++wrote 1024/1024 bytes at offset 4294978048 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294979072 ++wrote 1024/1024 bytes at offset 4294979072 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294980096 ++wrote 1024/1024 bytes at offset 4294980096 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294981120 ++wrote 1024/1024 bytes at offset 4294981120 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294982144 ++wrote 1024/1024 bytes at offset 4294982144 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294983168 ++wrote 1024/1024 bytes at offset 4294983168 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294984192 ++wrote 1024/1024 bytes at offset 4294984192 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294985216 ++wrote 1024/1024 bytes at offset 4294985216 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294986240 ++wrote 1024/1024 bytes at offset 4294986240 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294987264 ++wrote 1024/1024 bytes at offset 4294987264 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294988288 ++wrote 1024/1024 bytes at offset 4294988288 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294989312 ++wrote 1024/1024 bytes at offset 4294989312 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294990336 ++wrote 1024/1024 bytes at offset 4294990336 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294991360 ++wrote 1024/1024 bytes at offset 4294991360 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294992384 ++wrote 1024/1024 bytes at offset 4294992384 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294993408 ++wrote 1024/1024 bytes at offset 4294993408 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294994432 ++wrote 1024/1024 bytes at offset 4294994432 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294995456 ++wrote 1024/1024 bytes at offset 4294995456 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294996480 ++wrote 1024/1024 bytes at offset 4294996480 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294997504 ++wrote 1024/1024 bytes at offset 4294997504 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294998528 ++wrote 1024/1024 bytes at offset 4294998528 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294999552 ++wrote 1024/1024 bytes at offset 4294999552 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4295000576 ++wrote 1024/1024 bytes at offset 4295000576 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4295001600 ++wrote 1024/1024 bytes at offset 4295001600 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4295002624 ++wrote 1024/1024 bytes at offset 4295002624 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4295003648 ++wrote 1024/1024 bytes at offset 4295003648 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 74 +-qemu-io> wrote 512/512 bytes at offset 4295005184 ++=== IO: pattern 74 ++wrote 512/512 bytes at offset 4295005184 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295006208 ++wrote 512/512 bytes at offset 4295006208 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295007232 ++wrote 512/512 bytes at offset 4295007232 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295008256 ++wrote 512/512 bytes at offset 4295008256 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295009280 ++wrote 512/512 bytes at offset 4295009280 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295010304 ++wrote 512/512 bytes at offset 4295010304 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295011328 ++wrote 512/512 bytes at offset 4295011328 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295012352 ++wrote 512/512 bytes at offset 4295012352 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295013376 ++wrote 512/512 bytes at offset 4295013376 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295014400 ++wrote 512/512 bytes at offset 4295014400 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295015424 ++wrote 512/512 bytes at offset 4295015424 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295016448 ++wrote 512/512 bytes at offset 4295016448 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295017472 ++wrote 512/512 bytes at offset 4295017472 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295018496 ++wrote 512/512 bytes at offset 4295018496 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295019520 ++wrote 512/512 bytes at offset 4295019520 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295020544 ++wrote 512/512 bytes at offset 4295020544 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295021568 ++wrote 512/512 bytes at offset 4295021568 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295022592 ++wrote 512/512 bytes at offset 4295022592 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295023616 ++wrote 512/512 bytes at offset 4295023616 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295024640 ++wrote 512/512 bytes at offset 4295024640 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295025664 ++wrote 512/512 bytes at offset 4295025664 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295026688 ++wrote 512/512 bytes at offset 4295026688 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295027712 ++wrote 512/512 bytes at offset 4295027712 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295028736 ++wrote 512/512 bytes at offset 4295028736 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295029760 ++wrote 512/512 bytes at offset 4295029760 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295030784 ++wrote 512/512 bytes at offset 4295030784 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295031808 ++wrote 512/512 bytes at offset 4295031808 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295032832 ++wrote 512/512 bytes at offset 4295032832 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295033856 ++wrote 512/512 bytes at offset 4295033856 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295034880 ++wrote 512/512 bytes at offset 4295034880 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295035904 ++wrote 512/512 bytes at offset 4295035904 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295036928 ++wrote 512/512 bytes at offset 4295036928 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295037952 ++wrote 512/512 bytes at offset 4295037952 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295038976 ++wrote 512/512 bytes at offset 4295038976 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295040000 ++wrote 512/512 bytes at offset 4295040000 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295041024 ++wrote 512/512 bytes at offset 4295041024 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 145 +-qemu-io> wrote 512/512 bytes at offset 4295041536 ++=== IO: pattern 145 ++wrote 512/512 bytes at offset 4295041536 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295042560 ++wrote 512/512 bytes at offset 4295042560 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295043584 ++wrote 512/512 bytes at offset 4295043584 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295044608 ++wrote 512/512 bytes at offset 4295044608 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295045632 ++wrote 512/512 bytes at offset 4295045632 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295046656 ++wrote 512/512 bytes at offset 4295046656 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295047680 ++wrote 512/512 bytes at offset 4295047680 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295048704 ++wrote 512/512 bytes at offset 4295048704 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295049728 ++wrote 512/512 bytes at offset 4295049728 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295050752 ++wrote 512/512 bytes at offset 4295050752 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295051776 ++wrote 512/512 bytes at offset 4295051776 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295052800 ++wrote 512/512 bytes at offset 4295052800 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295053824 ++wrote 512/512 bytes at offset 4295053824 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295054848 ++wrote 512/512 bytes at offset 4295054848 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295055872 ++wrote 512/512 bytes at offset 4295055872 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295056896 ++wrote 512/512 bytes at offset 4295056896 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295057920 ++wrote 512/512 bytes at offset 4295057920 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295058944 ++wrote 512/512 bytes at offset 4295058944 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295059968 ++wrote 512/512 bytes at offset 4295059968 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295060992 ++wrote 512/512 bytes at offset 4295060992 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295062016 ++wrote 512/512 bytes at offset 4295062016 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295063040 ++wrote 512/512 bytes at offset 4295063040 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295064064 ++wrote 512/512 bytes at offset 4295064064 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295065088 ++wrote 512/512 bytes at offset 4295065088 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295066112 ++wrote 512/512 bytes at offset 4295066112 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295067136 ++wrote 512/512 bytes at offset 4295067136 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295068160 ++wrote 512/512 bytes at offset 4295068160 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295069184 ++wrote 512/512 bytes at offset 4295069184 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295070208 ++wrote 512/512 bytes at offset 4295070208 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295071232 ++wrote 512/512 bytes at offset 4295071232 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295072256 ++wrote 512/512 bytes at offset 4295072256 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295073280 ++wrote 512/512 bytes at offset 4295073280 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295074304 ++wrote 512/512 bytes at offset 4295074304 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295075328 ++wrote 512/512 bytes at offset 4295075328 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295076352 ++wrote 512/512 bytes at offset 4295076352 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4295077376 ++wrote 512/512 bytes at offset 4295077376 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 217 +-qemu-io> offset 4295078656 is not sector aligned +-qemu-io> offset 4295079680 is not sector aligned +-qemu-io> offset 4295080704 is not sector aligned +-qemu-io> offset 4295081728 is not sector aligned +-qemu-io> offset 4295082752 is not sector aligned +-qemu-io> offset 4295083776 is not sector aligned +-qemu-io> offset 4295084800 is not sector aligned +-qemu-io> offset 4295085824 is not sector aligned +-qemu-io> offset 4295086848 is not sector aligned +-qemu-io> offset 4295087872 is not sector aligned +-qemu-io> offset 4295088896 is not sector aligned +-qemu-io> offset 4295089920 is not sector aligned +-qemu-io> offset 4295090944 is not sector aligned +-qemu-io> offset 4295091968 is not sector aligned +-qemu-io> offset 4295092992 is not sector aligned +-qemu-io> offset 4295094016 is not sector aligned +-qemu-io> offset 4295095040 is not sector aligned +-qemu-io> offset 4295096064 is not sector aligned +-qemu-io> offset 4295097088 is not sector aligned +-qemu-io> offset 4295098112 is not sector aligned +-qemu-io> offset 4295099136 is not sector aligned +-qemu-io> offset 4295100160 is not sector aligned +-qemu-io> offset 4295101184 is not sector aligned +-qemu-io> offset 4295102208 is not sector aligned +-qemu-io> offset 4295103232 is not sector aligned +-qemu-io> offset 4295104256 is not sector aligned +-qemu-io> offset 4295105280 is not sector aligned +-qemu-io> offset 4295106304 is not sector aligned +-qemu-io> offset 4295107328 is not sector aligned +-qemu-io> offset 4295108352 is not sector aligned +-qemu-io> offset 4295109376 is not sector aligned +-qemu-io> offset 4295110400 is not sector aligned +-qemu-io> offset 4295111424 is not sector aligned +-qemu-io> offset 4295112448 is not sector aligned +-qemu-io> offset 4295113472 is not sector aligned +-qemu-io> offset 4295114496 is not sector aligned +-qemu-io> === IO: pattern 34 +-qemu-io> wrote 2048/2048 bytes at offset 4295115776 ++=== IO: pattern 217 ++offset 4295078656 is not sector aligned ++offset 4295079680 is not sector aligned ++offset 4295080704 is not sector aligned ++offset 4295081728 is not sector aligned ++offset 4295082752 is not sector aligned ++offset 4295083776 is not sector aligned ++offset 4295084800 is not sector aligned ++offset 4295085824 is not sector aligned ++offset 4295086848 is not sector aligned ++offset 4295087872 is not sector aligned ++offset 4295088896 is not sector aligned ++offset 4295089920 is not sector aligned ++offset 4295090944 is not sector aligned ++offset 4295091968 is not sector aligned ++offset 4295092992 is not sector aligned ++offset 4295094016 is not sector aligned ++offset 4295095040 is not sector aligned ++offset 4295096064 is not sector aligned ++offset 4295097088 is not sector aligned ++offset 4295098112 is not sector aligned ++offset 4295099136 is not sector aligned ++offset 4295100160 is not sector aligned ++offset 4295101184 is not sector aligned ++offset 4295102208 is not sector aligned ++offset 4295103232 is not sector aligned ++offset 4295104256 is not sector aligned ++offset 4295105280 is not sector aligned ++offset 4295106304 is not sector aligned ++offset 4295107328 is not sector aligned ++offset 4295108352 is not sector aligned ++offset 4295109376 is not sector aligned ++offset 4295110400 is not sector aligned ++offset 4295111424 is not sector aligned ++offset 4295112448 is not sector aligned ++offset 4295113472 is not sector aligned ++offset 4295114496 is not sector aligned ++=== IO: pattern 34 ++wrote 2048/2048 bytes at offset 4295115776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295118848 ++wrote 2048/2048 bytes at offset 4295118848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295121920 ++wrote 2048/2048 bytes at offset 4295121920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295124992 ++wrote 2048/2048 bytes at offset 4295124992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295128064 ++wrote 2048/2048 bytes at offset 4295128064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295131136 ++wrote 2048/2048 bytes at offset 4295131136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295134208 ++wrote 2048/2048 bytes at offset 4295134208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295137280 ++wrote 2048/2048 bytes at offset 4295137280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295140352 ++wrote 2048/2048 bytes at offset 4295140352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 253 +-qemu-io> wrote 3072/3072 bytes at offset 4295227904 ++=== IO: pattern 253 ++wrote 3072/3072 bytes at offset 4295227904 + 3 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 3072/3072 bytes at offset 4295359488 ++wrote 3072/3072 bytes at offset 4295359488 + 3 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 3072/3072 bytes at offset 4295491072 ++wrote 3072/3072 bytes at offset 4295491072 + 3 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 1 +-qemu-io> read 1024/1024 bytes at offset 4294967808 ++=== IO: pattern 1 ++read 1024/1024 bytes at offset 4294967808 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294968832 ++read 1024/1024 bytes at offset 4294968832 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294969856 ++read 1024/1024 bytes at offset 4294969856 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294970880 ++read 1024/1024 bytes at offset 4294970880 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294971904 ++read 1024/1024 bytes at offset 4294971904 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294972928 ++read 1024/1024 bytes at offset 4294972928 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294973952 ++read 1024/1024 bytes at offset 4294973952 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294974976 ++read 1024/1024 bytes at offset 4294974976 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294976000 ++read 1024/1024 bytes at offset 4294976000 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294977024 ++read 1024/1024 bytes at offset 4294977024 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294978048 ++read 1024/1024 bytes at offset 4294978048 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294979072 ++read 1024/1024 bytes at offset 4294979072 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294980096 ++read 1024/1024 bytes at offset 4294980096 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294981120 ++read 1024/1024 bytes at offset 4294981120 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294982144 ++read 1024/1024 bytes at offset 4294982144 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294983168 ++read 1024/1024 bytes at offset 4294983168 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294984192 ++read 1024/1024 bytes at offset 4294984192 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294985216 ++read 1024/1024 bytes at offset 4294985216 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294986240 ++read 1024/1024 bytes at offset 4294986240 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294987264 ++read 1024/1024 bytes at offset 4294987264 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294988288 ++read 1024/1024 bytes at offset 4294988288 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294989312 ++read 1024/1024 bytes at offset 4294989312 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294990336 ++read 1024/1024 bytes at offset 4294990336 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294991360 ++read 1024/1024 bytes at offset 4294991360 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294992384 ++read 1024/1024 bytes at offset 4294992384 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294993408 ++read 1024/1024 bytes at offset 4294993408 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294994432 ++read 1024/1024 bytes at offset 4294994432 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294995456 ++read 1024/1024 bytes at offset 4294995456 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294996480 ++read 1024/1024 bytes at offset 4294996480 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294997504 ++read 1024/1024 bytes at offset 4294997504 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294998528 ++read 1024/1024 bytes at offset 4294998528 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294999552 ++read 1024/1024 bytes at offset 4294999552 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4295000576 ++read 1024/1024 bytes at offset 4295000576 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4295001600 ++read 1024/1024 bytes at offset 4295001600 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4295002624 ++read 1024/1024 bytes at offset 4295002624 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4295003648 ++read 1024/1024 bytes at offset 4295003648 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 74 +-qemu-io> read 512/512 bytes at offset 4295005184 ++=== IO: pattern 74 ++read 512/512 bytes at offset 4295005184 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295006208 ++read 512/512 bytes at offset 4295006208 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295007232 ++read 512/512 bytes at offset 4295007232 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295008256 ++read 512/512 bytes at offset 4295008256 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295009280 ++read 512/512 bytes at offset 4295009280 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295010304 ++read 512/512 bytes at offset 4295010304 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295011328 ++read 512/512 bytes at offset 4295011328 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295012352 ++read 512/512 bytes at offset 4295012352 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295013376 ++read 512/512 bytes at offset 4295013376 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295014400 ++read 512/512 bytes at offset 4295014400 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295015424 ++read 512/512 bytes at offset 4295015424 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295016448 ++read 512/512 bytes at offset 4295016448 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295017472 ++read 512/512 bytes at offset 4295017472 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295018496 ++read 512/512 bytes at offset 4295018496 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295019520 ++read 512/512 bytes at offset 4295019520 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295020544 ++read 512/512 bytes at offset 4295020544 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295021568 ++read 512/512 bytes at offset 4295021568 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295022592 ++read 512/512 bytes at offset 4295022592 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295023616 ++read 512/512 bytes at offset 4295023616 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295024640 ++read 512/512 bytes at offset 4295024640 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295025664 ++read 512/512 bytes at offset 4295025664 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295026688 ++read 512/512 bytes at offset 4295026688 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295027712 ++read 512/512 bytes at offset 4295027712 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295028736 ++read 512/512 bytes at offset 4295028736 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295029760 ++read 512/512 bytes at offset 4295029760 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295030784 ++read 512/512 bytes at offset 4295030784 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295031808 ++read 512/512 bytes at offset 4295031808 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295032832 ++read 512/512 bytes at offset 4295032832 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295033856 ++read 512/512 bytes at offset 4295033856 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295034880 ++read 512/512 bytes at offset 4295034880 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295035904 ++read 512/512 bytes at offset 4295035904 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295036928 ++read 512/512 bytes at offset 4295036928 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295037952 ++read 512/512 bytes at offset 4295037952 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295038976 ++read 512/512 bytes at offset 4295038976 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295040000 ++read 512/512 bytes at offset 4295040000 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295041024 ++read 512/512 bytes at offset 4295041024 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 145 +-qemu-io> read 512/512 bytes at offset 4295041536 ++=== IO: pattern 145 ++read 512/512 bytes at offset 4295041536 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295042560 ++read 512/512 bytes at offset 4295042560 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295043584 ++read 512/512 bytes at offset 4295043584 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295044608 ++read 512/512 bytes at offset 4295044608 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295045632 ++read 512/512 bytes at offset 4295045632 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295046656 ++read 512/512 bytes at offset 4295046656 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295047680 ++read 512/512 bytes at offset 4295047680 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295048704 ++read 512/512 bytes at offset 4295048704 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295049728 ++read 512/512 bytes at offset 4295049728 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295050752 ++read 512/512 bytes at offset 4295050752 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295051776 ++read 512/512 bytes at offset 4295051776 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295052800 ++read 512/512 bytes at offset 4295052800 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295053824 ++read 512/512 bytes at offset 4295053824 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295054848 ++read 512/512 bytes at offset 4295054848 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295055872 ++read 512/512 bytes at offset 4295055872 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295056896 ++read 512/512 bytes at offset 4295056896 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295057920 ++read 512/512 bytes at offset 4295057920 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295058944 ++read 512/512 bytes at offset 4295058944 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295059968 ++read 512/512 bytes at offset 4295059968 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295060992 ++read 512/512 bytes at offset 4295060992 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295062016 ++read 512/512 bytes at offset 4295062016 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295063040 ++read 512/512 bytes at offset 4295063040 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295064064 ++read 512/512 bytes at offset 4295064064 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295065088 ++read 512/512 bytes at offset 4295065088 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295066112 ++read 512/512 bytes at offset 4295066112 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295067136 ++read 512/512 bytes at offset 4295067136 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295068160 ++read 512/512 bytes at offset 4295068160 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295069184 ++read 512/512 bytes at offset 4295069184 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295070208 ++read 512/512 bytes at offset 4295070208 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295071232 ++read 512/512 bytes at offset 4295071232 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295072256 ++read 512/512 bytes at offset 4295072256 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295073280 ++read 512/512 bytes at offset 4295073280 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295074304 ++read 512/512 bytes at offset 4295074304 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295075328 ++read 512/512 bytes at offset 4295075328 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295076352 ++read 512/512 bytes at offset 4295076352 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4295077376 ++read 512/512 bytes at offset 4295077376 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 217 +-qemu-io> offset 4295078656 is not sector aligned +-qemu-io> offset 4295079680 is not sector aligned +-qemu-io> offset 4295080704 is not sector aligned +-qemu-io> offset 4295081728 is not sector aligned +-qemu-io> offset 4295082752 is not sector aligned +-qemu-io> offset 4295083776 is not sector aligned +-qemu-io> offset 4295084800 is not sector aligned +-qemu-io> offset 4295085824 is not sector aligned +-qemu-io> offset 4295086848 is not sector aligned +-qemu-io> offset 4295087872 is not sector aligned +-qemu-io> offset 4295088896 is not sector aligned +-qemu-io> offset 4295089920 is not sector aligned +-qemu-io> offset 4295090944 is not sector aligned +-qemu-io> offset 4295091968 is not sector aligned +-qemu-io> offset 4295092992 is not sector aligned +-qemu-io> offset 4295094016 is not sector aligned +-qemu-io> offset 4295095040 is not sector aligned +-qemu-io> offset 4295096064 is not sector aligned +-qemu-io> offset 4295097088 is not sector aligned +-qemu-io> offset 4295098112 is not sector aligned +-qemu-io> offset 4295099136 is not sector aligned +-qemu-io> offset 4295100160 is not sector aligned +-qemu-io> offset 4295101184 is not sector aligned +-qemu-io> offset 4295102208 is not sector aligned +-qemu-io> offset 4295103232 is not sector aligned +-qemu-io> offset 4295104256 is not sector aligned +-qemu-io> offset 4295105280 is not sector aligned +-qemu-io> offset 4295106304 is not sector aligned +-qemu-io> offset 4295107328 is not sector aligned +-qemu-io> offset 4295108352 is not sector aligned +-qemu-io> offset 4295109376 is not sector aligned +-qemu-io> offset 4295110400 is not sector aligned +-qemu-io> offset 4295111424 is not sector aligned +-qemu-io> offset 4295112448 is not sector aligned +-qemu-io> offset 4295113472 is not sector aligned +-qemu-io> offset 4295114496 is not sector aligned +-qemu-io> === IO: pattern 34 +-qemu-io> read 2048/2048 bytes at offset 4295115776 ++=== IO: pattern 217 ++offset 4295078656 is not sector aligned ++offset 4295079680 is not sector aligned ++offset 4295080704 is not sector aligned ++offset 4295081728 is not sector aligned ++offset 4295082752 is not sector aligned ++offset 4295083776 is not sector aligned ++offset 4295084800 is not sector aligned ++offset 4295085824 is not sector aligned ++offset 4295086848 is not sector aligned ++offset 4295087872 is not sector aligned ++offset 4295088896 is not sector aligned ++offset 4295089920 is not sector aligned ++offset 4295090944 is not sector aligned ++offset 4295091968 is not sector aligned ++offset 4295092992 is not sector aligned ++offset 4295094016 is not sector aligned ++offset 4295095040 is not sector aligned ++offset 4295096064 is not sector aligned ++offset 4295097088 is not sector aligned ++offset 4295098112 is not sector aligned ++offset 4295099136 is not sector aligned ++offset 4295100160 is not sector aligned ++offset 4295101184 is not sector aligned ++offset 4295102208 is not sector aligned ++offset 4295103232 is not sector aligned ++offset 4295104256 is not sector aligned ++offset 4295105280 is not sector aligned ++offset 4295106304 is not sector aligned ++offset 4295107328 is not sector aligned ++offset 4295108352 is not sector aligned ++offset 4295109376 is not sector aligned ++offset 4295110400 is not sector aligned ++offset 4295111424 is not sector aligned ++offset 4295112448 is not sector aligned ++offset 4295113472 is not sector aligned ++offset 4295114496 is not sector aligned ++=== IO: pattern 34 ++read 2048/2048 bytes at offset 4295115776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295118848 ++read 2048/2048 bytes at offset 4295118848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295121920 ++read 2048/2048 bytes at offset 4295121920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295124992 ++read 2048/2048 bytes at offset 4295124992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295128064 ++read 2048/2048 bytes at offset 4295128064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295131136 ++read 2048/2048 bytes at offset 4295131136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295134208 ++read 2048/2048 bytes at offset 4295134208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295137280 ++read 2048/2048 bytes at offset 4295137280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295140352 ++read 2048/2048 bytes at offset 4295140352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 253 +-qemu-io> read 3072/3072 bytes at offset 4295227904 ++=== IO: pattern 253 ++read 3072/3072 bytes at offset 4295227904 + 3 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 3072/3072 bytes at offset 4295359488 ++read 3072/3072 bytes at offset 4295359488 + 3 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 3072/3072 bytes at offset 4295491072 ++read 3072/3072 bytes at offset 4295491072 + 3 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> No errors were found on the image. ++No errors were found on the image. + Creating another new image + + Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=8589934592 +@@ -5670,221 +5670,221 @@ More complex patterns + test2: With offset 0 + === Clusters to be compressed [1] + === IO: pattern 165 +-qemu-io> wrote 1024/1024 bytes at offset 4096 ++wrote 1024/1024 bytes at offset 4096 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 13312 ++wrote 1024/1024 bytes at offset 13312 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 22528 ++wrote 1024/1024 bytes at offset 22528 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 31744 ++wrote 1024/1024 bytes at offset 31744 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === Clusters to be compressed [2] ++=== Clusters to be compressed [2] + === IO: pattern 165 +-qemu-io> wrote 1024/1024 bytes at offset 5120 ++wrote 1024/1024 bytes at offset 5120 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 14336 ++wrote 1024/1024 bytes at offset 14336 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 23552 ++wrote 1024/1024 bytes at offset 23552 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 32768 ++wrote 1024/1024 bytes at offset 32768 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === Clusters to be compressed [3] ++=== Clusters to be compressed [3] + === IO: pattern 165 +-qemu-io> wrote 1024/1024 bytes at offset 8192 ++wrote 1024/1024 bytes at offset 8192 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 17408 ++wrote 1024/1024 bytes at offset 17408 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 26624 ++wrote 1024/1024 bytes at offset 26624 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 35840 ++wrote 1024/1024 bytes at offset 35840 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === Used clusters [1] ++=== Used clusters [1] + === IO: pattern 165 +-qemu-io> wrote 1024/1024 bytes at offset 0 ++wrote 1024/1024 bytes at offset 0 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 9216 ++wrote 1024/1024 bytes at offset 9216 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 18432 ++wrote 1024/1024 bytes at offset 18432 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 27648 ++wrote 1024/1024 bytes at offset 27648 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === Used clusters [2] ++=== Used clusters [2] + === IO: pattern 165 +-qemu-io> wrote 1024/1024 bytes at offset 1024 ++wrote 1024/1024 bytes at offset 1024 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 10240 ++wrote 1024/1024 bytes at offset 10240 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 19456 ++wrote 1024/1024 bytes at offset 19456 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 28672 ++wrote 1024/1024 bytes at offset 28672 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === Used clusters [3] ++=== Used clusters [3] + === IO: pattern 165 +-qemu-io> wrote 1024/1024 bytes at offset 3072 ++wrote 1024/1024 bytes at offset 3072 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 12288 ++wrote 1024/1024 bytes at offset 12288 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 21504 ++wrote 1024/1024 bytes at offset 21504 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 30720 ++wrote 1024/1024 bytes at offset 30720 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === Read used/compressed clusters ++=== Read used/compressed clusters + === IO: pattern 165 +-qemu-io> read 2048/2048 bytes at offset 0 ++read 2048/2048 bytes at offset 0 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 9216 ++read 2048/2048 bytes at offset 9216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 18432 ++read 2048/2048 bytes at offset 18432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 27648 ++read 2048/2048 bytes at offset 27648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 165 +-qemu-io> read 3072/3072 bytes at offset 3072 ++=== IO: pattern 165 ++read 3072/3072 bytes at offset 3072 + 3 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 3072/3072 bytes at offset 12288 ++read 3072/3072 bytes at offset 12288 + 3 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 3072/3072 bytes at offset 21504 ++read 3072/3072 bytes at offset 21504 + 3 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 3072/3072 bytes at offset 30720 ++read 3072/3072 bytes at offset 30720 + 3 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 165 +-qemu-io> read 1024/1024 bytes at offset 8192 ++=== IO: pattern 165 ++read 1024/1024 bytes at offset 8192 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 17408 ++read 1024/1024 bytes at offset 17408 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 26624 ++read 1024/1024 bytes at offset 26624 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 35840 ++read 1024/1024 bytes at offset 35840 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === Read zeros ++=== Read zeros + === IO: pattern 0 +-qemu-io> read 1024/1024 bytes at offset 2048 ++read 1024/1024 bytes at offset 2048 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 11264 ++read 1024/1024 bytes at offset 11264 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 20480 ++read 1024/1024 bytes at offset 20480 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 29696 ++read 1024/1024 bytes at offset 29696 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> read 2048/2048 bytes at offset 6144 ++=== IO: pattern 0 ++read 2048/2048 bytes at offset 6144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 15360 ++read 2048/2048 bytes at offset 15360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 24576 ++read 2048/2048 bytes at offset 24576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 33792 ++read 2048/2048 bytes at offset 33792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> No errors were found on the image. ++No errors were found on the image. + test2: With offset 4294967296 + === Clusters to be compressed [1] + === IO: pattern 165 +-qemu-io> wrote 1024/1024 bytes at offset 4294971392 ++wrote 1024/1024 bytes at offset 4294971392 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294980608 ++wrote 1024/1024 bytes at offset 4294980608 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294989824 ++wrote 1024/1024 bytes at offset 4294989824 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294999040 ++wrote 1024/1024 bytes at offset 4294999040 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === Clusters to be compressed [2] ++=== Clusters to be compressed [2] + === IO: pattern 165 +-qemu-io> wrote 1024/1024 bytes at offset 4294972416 ++wrote 1024/1024 bytes at offset 4294972416 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294981632 ++wrote 1024/1024 bytes at offset 4294981632 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294990848 ++wrote 1024/1024 bytes at offset 4294990848 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4295000064 ++wrote 1024/1024 bytes at offset 4295000064 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === Clusters to be compressed [3] ++=== Clusters to be compressed [3] + === IO: pattern 165 +-qemu-io> wrote 1024/1024 bytes at offset 4294975488 ++wrote 1024/1024 bytes at offset 4294975488 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294984704 ++wrote 1024/1024 bytes at offset 4294984704 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294993920 ++wrote 1024/1024 bytes at offset 4294993920 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4295003136 ++wrote 1024/1024 bytes at offset 4295003136 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === Used clusters [1] ++=== Used clusters [1] + === IO: pattern 165 +-qemu-io> wrote 1024/1024 bytes at offset 4294967296 ++wrote 1024/1024 bytes at offset 4294967296 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294976512 ++wrote 1024/1024 bytes at offset 4294976512 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294985728 ++wrote 1024/1024 bytes at offset 4294985728 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294994944 ++wrote 1024/1024 bytes at offset 4294994944 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === Used clusters [2] ++=== Used clusters [2] + === IO: pattern 165 +-qemu-io> wrote 1024/1024 bytes at offset 4294968320 ++wrote 1024/1024 bytes at offset 4294968320 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294977536 ++wrote 1024/1024 bytes at offset 4294977536 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294986752 ++wrote 1024/1024 bytes at offset 4294986752 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294995968 ++wrote 1024/1024 bytes at offset 4294995968 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === Used clusters [3] ++=== Used clusters [3] + === IO: pattern 165 +-qemu-io> wrote 1024/1024 bytes at offset 4294970368 ++wrote 1024/1024 bytes at offset 4294970368 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294979584 ++wrote 1024/1024 bytes at offset 4294979584 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294988800 ++wrote 1024/1024 bytes at offset 4294988800 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 1024/1024 bytes at offset 4294998016 ++wrote 1024/1024 bytes at offset 4294998016 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === Read used/compressed clusters ++=== Read used/compressed clusters + === IO: pattern 165 +-qemu-io> read 2048/2048 bytes at offset 4294967296 ++read 2048/2048 bytes at offset 4294967296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4294976512 ++read 2048/2048 bytes at offset 4294976512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4294985728 ++read 2048/2048 bytes at offset 4294985728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4294994944 ++read 2048/2048 bytes at offset 4294994944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 165 +-qemu-io> read 3072/3072 bytes at offset 4294970368 ++=== IO: pattern 165 ++read 3072/3072 bytes at offset 4294970368 + 3 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 3072/3072 bytes at offset 4294979584 ++read 3072/3072 bytes at offset 4294979584 + 3 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 3072/3072 bytes at offset 4294988800 ++read 3072/3072 bytes at offset 4294988800 + 3 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 3072/3072 bytes at offset 4294998016 ++read 3072/3072 bytes at offset 4294998016 + 3 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 165 +-qemu-io> read 1024/1024 bytes at offset 4294975488 ++=== IO: pattern 165 ++read 1024/1024 bytes at offset 4294975488 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294984704 ++read 1024/1024 bytes at offset 4294984704 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294993920 ++read 1024/1024 bytes at offset 4294993920 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4295003136 ++read 1024/1024 bytes at offset 4295003136 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === Read zeros ++=== Read zeros + === IO: pattern 0 +-qemu-io> read 1024/1024 bytes at offset 4294969344 ++read 1024/1024 bytes at offset 4294969344 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294978560 ++read 1024/1024 bytes at offset 4294978560 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294987776 ++read 1024/1024 bytes at offset 4294987776 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 1024/1024 bytes at offset 4294996992 ++read 1024/1024 bytes at offset 4294996992 + 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> read 2048/2048 bytes at offset 4294973440 ++=== IO: pattern 0 ++read 2048/2048 bytes at offset 4294973440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4294982656 ++read 2048/2048 bytes at offset 4294982656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4294991872 ++read 2048/2048 bytes at offset 4294991872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295001088 ++read 2048/2048 bytes at offset 4295001088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> No errors were found on the image. ++No errors were found on the image. + Creating new image; cluster size: 4096 + + Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=8589934592 +@@ -5892,6382 +5892,6382 @@ Testing empty image + + At offset 0: + === IO: pattern 0 +-qemu-io> wrote 4096/4096 bytes at offset 0 ++wrote 4096/4096 bytes at offset 0 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4096 ++wrote 4096/4096 bytes at offset 4096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8192 ++wrote 4096/4096 bytes at offset 8192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 12288 ++wrote 4096/4096 bytes at offset 12288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 16384 ++wrote 4096/4096 bytes at offset 16384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 20480 ++wrote 4096/4096 bytes at offset 20480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 24576 ++wrote 4096/4096 bytes at offset 24576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 28672 ++wrote 4096/4096 bytes at offset 28672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 32768 ++wrote 4096/4096 bytes at offset 32768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 36864 ++wrote 4096/4096 bytes at offset 36864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 40960 ++wrote 4096/4096 bytes at offset 40960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 45056 ++wrote 4096/4096 bytes at offset 45056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 49152 ++wrote 4096/4096 bytes at offset 49152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 53248 ++wrote 4096/4096 bytes at offset 53248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 57344 ++wrote 4096/4096 bytes at offset 57344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 61440 ++wrote 4096/4096 bytes at offset 61440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 65536 ++wrote 4096/4096 bytes at offset 65536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 69632 ++wrote 4096/4096 bytes at offset 69632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 73728 ++wrote 4096/4096 bytes at offset 73728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 77824 ++wrote 4096/4096 bytes at offset 77824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 81920 ++wrote 4096/4096 bytes at offset 81920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 86016 ++wrote 4096/4096 bytes at offset 86016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 90112 ++wrote 4096/4096 bytes at offset 90112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 94208 ++wrote 4096/4096 bytes at offset 94208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 98304 ++wrote 4096/4096 bytes at offset 98304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 102400 ++wrote 4096/4096 bytes at offset 102400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 106496 ++wrote 4096/4096 bytes at offset 106496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 110592 ++wrote 4096/4096 bytes at offset 110592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 114688 ++wrote 4096/4096 bytes at offset 114688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 118784 ++wrote 4096/4096 bytes at offset 118784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 122880 ++wrote 4096/4096 bytes at offset 122880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 126976 ++wrote 4096/4096 bytes at offset 126976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 131072 ++wrote 4096/4096 bytes at offset 131072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 135168 ++wrote 4096/4096 bytes at offset 135168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 139264 ++wrote 4096/4096 bytes at offset 139264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 143360 ++wrote 4096/4096 bytes at offset 143360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 36 +-qemu-io> wrote 2048/2048 bytes at offset 149504 ++=== IO: pattern 36 ++wrote 2048/2048 bytes at offset 149504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 153600 ++wrote 2048/2048 bytes at offset 153600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 157696 ++wrote 2048/2048 bytes at offset 157696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 161792 ++wrote 2048/2048 bytes at offset 161792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 165888 ++wrote 2048/2048 bytes at offset 165888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 169984 ++wrote 2048/2048 bytes at offset 169984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 174080 ++wrote 2048/2048 bytes at offset 174080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 178176 ++wrote 2048/2048 bytes at offset 178176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 182272 ++wrote 2048/2048 bytes at offset 182272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 186368 ++wrote 2048/2048 bytes at offset 186368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 190464 ++wrote 2048/2048 bytes at offset 190464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 194560 ++wrote 2048/2048 bytes at offset 194560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 198656 ++wrote 2048/2048 bytes at offset 198656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 202752 ++wrote 2048/2048 bytes at offset 202752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 206848 ++wrote 2048/2048 bytes at offset 206848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 210944 ++wrote 2048/2048 bytes at offset 210944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 215040 ++wrote 2048/2048 bytes at offset 215040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 219136 ++wrote 2048/2048 bytes at offset 219136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 223232 ++wrote 2048/2048 bytes at offset 223232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 227328 ++wrote 2048/2048 bytes at offset 227328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 231424 ++wrote 2048/2048 bytes at offset 231424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 235520 ++wrote 2048/2048 bytes at offset 235520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 239616 ++wrote 2048/2048 bytes at offset 239616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 243712 ++wrote 2048/2048 bytes at offset 243712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 247808 ++wrote 2048/2048 bytes at offset 247808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 251904 ++wrote 2048/2048 bytes at offset 251904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 256000 ++wrote 2048/2048 bytes at offset 256000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 260096 ++wrote 2048/2048 bytes at offset 260096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 264192 ++wrote 2048/2048 bytes at offset 264192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 268288 ++wrote 2048/2048 bytes at offset 268288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 272384 ++wrote 2048/2048 bytes at offset 272384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 276480 ++wrote 2048/2048 bytes at offset 276480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 280576 ++wrote 2048/2048 bytes at offset 280576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 284672 ++wrote 2048/2048 bytes at offset 284672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 288768 ++wrote 2048/2048 bytes at offset 288768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 292864 ++wrote 2048/2048 bytes at offset 292864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 64 +-qemu-io> wrote 2048/2048 bytes at offset 294912 ++=== IO: pattern 64 ++wrote 2048/2048 bytes at offset 294912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 299008 ++wrote 2048/2048 bytes at offset 299008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 303104 ++wrote 2048/2048 bytes at offset 303104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 307200 ++wrote 2048/2048 bytes at offset 307200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 311296 ++wrote 2048/2048 bytes at offset 311296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 315392 ++wrote 2048/2048 bytes at offset 315392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 319488 ++wrote 2048/2048 bytes at offset 319488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 323584 ++wrote 2048/2048 bytes at offset 323584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 327680 ++wrote 2048/2048 bytes at offset 327680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 331776 ++wrote 2048/2048 bytes at offset 331776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 335872 ++wrote 2048/2048 bytes at offset 335872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 339968 ++wrote 2048/2048 bytes at offset 339968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 344064 ++wrote 2048/2048 bytes at offset 344064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 348160 ++wrote 2048/2048 bytes at offset 348160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 352256 ++wrote 2048/2048 bytes at offset 352256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 356352 ++wrote 2048/2048 bytes at offset 356352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 360448 ++wrote 2048/2048 bytes at offset 360448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 364544 ++wrote 2048/2048 bytes at offset 364544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 368640 ++wrote 2048/2048 bytes at offset 368640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 372736 ++wrote 2048/2048 bytes at offset 372736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 376832 ++wrote 2048/2048 bytes at offset 376832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 380928 ++wrote 2048/2048 bytes at offset 380928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 385024 ++wrote 2048/2048 bytes at offset 385024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 389120 ++wrote 2048/2048 bytes at offset 389120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 393216 ++wrote 2048/2048 bytes at offset 393216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 397312 ++wrote 2048/2048 bytes at offset 397312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 401408 ++wrote 2048/2048 bytes at offset 401408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 405504 ++wrote 2048/2048 bytes at offset 405504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 409600 ++wrote 2048/2048 bytes at offset 409600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 413696 ++wrote 2048/2048 bytes at offset 413696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 417792 ++wrote 2048/2048 bytes at offset 417792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 421888 ++wrote 2048/2048 bytes at offset 421888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 425984 ++wrote 2048/2048 bytes at offset 425984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 430080 ++wrote 2048/2048 bytes at offset 430080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 434176 ++wrote 2048/2048 bytes at offset 434176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 438272 ++wrote 2048/2048 bytes at offset 438272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 98 +-qemu-io> wrote 2048/2048 bytes at offset 443392 ++=== IO: pattern 98 ++wrote 2048/2048 bytes at offset 443392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 447488 ++wrote 2048/2048 bytes at offset 447488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 451584 ++wrote 2048/2048 bytes at offset 451584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 455680 ++wrote 2048/2048 bytes at offset 455680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 459776 ++wrote 2048/2048 bytes at offset 459776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 463872 ++wrote 2048/2048 bytes at offset 463872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 467968 ++wrote 2048/2048 bytes at offset 467968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 472064 ++wrote 2048/2048 bytes at offset 472064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 476160 ++wrote 2048/2048 bytes at offset 476160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 480256 ++wrote 2048/2048 bytes at offset 480256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 484352 ++wrote 2048/2048 bytes at offset 484352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 488448 ++wrote 2048/2048 bytes at offset 488448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 492544 ++wrote 2048/2048 bytes at offset 492544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 496640 ++wrote 2048/2048 bytes at offset 496640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 500736 ++wrote 2048/2048 bytes at offset 500736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 504832 ++wrote 2048/2048 bytes at offset 504832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 508928 ++wrote 2048/2048 bytes at offset 508928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 513024 ++wrote 2048/2048 bytes at offset 513024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 517120 ++wrote 2048/2048 bytes at offset 517120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 521216 ++wrote 2048/2048 bytes at offset 521216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 525312 ++wrote 2048/2048 bytes at offset 525312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 529408 ++wrote 2048/2048 bytes at offset 529408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 533504 ++wrote 2048/2048 bytes at offset 533504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 537600 ++wrote 2048/2048 bytes at offset 537600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 541696 ++wrote 2048/2048 bytes at offset 541696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 545792 ++wrote 2048/2048 bytes at offset 545792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 549888 ++wrote 2048/2048 bytes at offset 549888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 553984 ++wrote 2048/2048 bytes at offset 553984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 558080 ++wrote 2048/2048 bytes at offset 558080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 562176 ++wrote 2048/2048 bytes at offset 562176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 566272 ++wrote 2048/2048 bytes at offset 566272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 570368 ++wrote 2048/2048 bytes at offset 570368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 574464 ++wrote 2048/2048 bytes at offset 574464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 578560 ++wrote 2048/2048 bytes at offset 578560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 582656 ++wrote 2048/2048 bytes at offset 582656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 586752 ++wrote 2048/2048 bytes at offset 586752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 132 +-qemu-io> wrote 8192/8192 bytes at offset 591872 ++=== IO: pattern 132 ++wrote 8192/8192 bytes at offset 591872 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 604160 ++wrote 8192/8192 bytes at offset 604160 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 616448 ++wrote 8192/8192 bytes at offset 616448 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 628736 ++wrote 8192/8192 bytes at offset 628736 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 641024 ++wrote 8192/8192 bytes at offset 641024 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 653312 ++wrote 8192/8192 bytes at offset 653312 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 665600 ++wrote 8192/8192 bytes at offset 665600 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 677888 ++wrote 8192/8192 bytes at offset 677888 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 690176 ++wrote 8192/8192 bytes at offset 690176 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 244 +-qemu-io> wrote 12288/12288 bytes at offset 2091008 ++=== IO: pattern 244 ++wrote 12288/12288 bytes at offset 2091008 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 4190208 ++wrote 12288/12288 bytes at offset 4190208 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 6289408 ++wrote 12288/12288 bytes at offset 6289408 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> read 4096/4096 bytes at offset 0 ++=== IO: pattern 0 ++read 4096/4096 bytes at offset 0 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4096 ++read 4096/4096 bytes at offset 4096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 8192 ++read 4096/4096 bytes at offset 8192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 12288 ++read 4096/4096 bytes at offset 12288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 16384 ++read 4096/4096 bytes at offset 16384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 20480 ++read 4096/4096 bytes at offset 20480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 24576 ++read 4096/4096 bytes at offset 24576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 28672 ++read 4096/4096 bytes at offset 28672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 32768 ++read 4096/4096 bytes at offset 32768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 36864 ++read 4096/4096 bytes at offset 36864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 40960 ++read 4096/4096 bytes at offset 40960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 45056 ++read 4096/4096 bytes at offset 45056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 49152 ++read 4096/4096 bytes at offset 49152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 53248 ++read 4096/4096 bytes at offset 53248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 57344 ++read 4096/4096 bytes at offset 57344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 61440 ++read 4096/4096 bytes at offset 61440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 65536 ++read 4096/4096 bytes at offset 65536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 69632 ++read 4096/4096 bytes at offset 69632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 73728 ++read 4096/4096 bytes at offset 73728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 77824 ++read 4096/4096 bytes at offset 77824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 81920 ++read 4096/4096 bytes at offset 81920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 86016 ++read 4096/4096 bytes at offset 86016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 90112 ++read 4096/4096 bytes at offset 90112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 94208 ++read 4096/4096 bytes at offset 94208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 98304 ++read 4096/4096 bytes at offset 98304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 102400 ++read 4096/4096 bytes at offset 102400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 106496 ++read 4096/4096 bytes at offset 106496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 110592 ++read 4096/4096 bytes at offset 110592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 114688 ++read 4096/4096 bytes at offset 114688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 118784 ++read 4096/4096 bytes at offset 118784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 122880 ++read 4096/4096 bytes at offset 122880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 126976 ++read 4096/4096 bytes at offset 126976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 131072 ++read 4096/4096 bytes at offset 131072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 135168 ++read 4096/4096 bytes at offset 135168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 139264 ++read 4096/4096 bytes at offset 139264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 143360 ++read 4096/4096 bytes at offset 143360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 36 +-qemu-io> read 2048/2048 bytes at offset 149504 ++=== IO: pattern 36 ++read 2048/2048 bytes at offset 149504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 153600 ++read 2048/2048 bytes at offset 153600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 157696 ++read 2048/2048 bytes at offset 157696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 161792 ++read 2048/2048 bytes at offset 161792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 165888 ++read 2048/2048 bytes at offset 165888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 169984 ++read 2048/2048 bytes at offset 169984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 174080 ++read 2048/2048 bytes at offset 174080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 178176 ++read 2048/2048 bytes at offset 178176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 182272 ++read 2048/2048 bytes at offset 182272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 186368 ++read 2048/2048 bytes at offset 186368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 190464 ++read 2048/2048 bytes at offset 190464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 194560 ++read 2048/2048 bytes at offset 194560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 198656 ++read 2048/2048 bytes at offset 198656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 202752 ++read 2048/2048 bytes at offset 202752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 206848 ++read 2048/2048 bytes at offset 206848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 210944 ++read 2048/2048 bytes at offset 210944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 215040 ++read 2048/2048 bytes at offset 215040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 219136 ++read 2048/2048 bytes at offset 219136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 223232 ++read 2048/2048 bytes at offset 223232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 227328 ++read 2048/2048 bytes at offset 227328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 231424 ++read 2048/2048 bytes at offset 231424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 235520 ++read 2048/2048 bytes at offset 235520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 239616 ++read 2048/2048 bytes at offset 239616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 243712 ++read 2048/2048 bytes at offset 243712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 247808 ++read 2048/2048 bytes at offset 247808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 251904 ++read 2048/2048 bytes at offset 251904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 256000 ++read 2048/2048 bytes at offset 256000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 260096 ++read 2048/2048 bytes at offset 260096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 264192 ++read 2048/2048 bytes at offset 264192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 268288 ++read 2048/2048 bytes at offset 268288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 272384 ++read 2048/2048 bytes at offset 272384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 276480 ++read 2048/2048 bytes at offset 276480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 280576 ++read 2048/2048 bytes at offset 280576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 284672 ++read 2048/2048 bytes at offset 284672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 288768 ++read 2048/2048 bytes at offset 288768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 292864 ++read 2048/2048 bytes at offset 292864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 64 +-qemu-io> read 2048/2048 bytes at offset 294912 ++=== IO: pattern 64 ++read 2048/2048 bytes at offset 294912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 299008 ++read 2048/2048 bytes at offset 299008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 303104 ++read 2048/2048 bytes at offset 303104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 307200 ++read 2048/2048 bytes at offset 307200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 311296 ++read 2048/2048 bytes at offset 311296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 315392 ++read 2048/2048 bytes at offset 315392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 319488 ++read 2048/2048 bytes at offset 319488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 323584 ++read 2048/2048 bytes at offset 323584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 327680 ++read 2048/2048 bytes at offset 327680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 331776 ++read 2048/2048 bytes at offset 331776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 335872 ++read 2048/2048 bytes at offset 335872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 339968 ++read 2048/2048 bytes at offset 339968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 344064 ++read 2048/2048 bytes at offset 344064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 348160 ++read 2048/2048 bytes at offset 348160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 352256 ++read 2048/2048 bytes at offset 352256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 356352 ++read 2048/2048 bytes at offset 356352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 360448 ++read 2048/2048 bytes at offset 360448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 364544 ++read 2048/2048 bytes at offset 364544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 368640 ++read 2048/2048 bytes at offset 368640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 372736 ++read 2048/2048 bytes at offset 372736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 376832 ++read 2048/2048 bytes at offset 376832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 380928 ++read 2048/2048 bytes at offset 380928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 385024 ++read 2048/2048 bytes at offset 385024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 389120 ++read 2048/2048 bytes at offset 389120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 393216 ++read 2048/2048 bytes at offset 393216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 397312 ++read 2048/2048 bytes at offset 397312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 401408 ++read 2048/2048 bytes at offset 401408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 405504 ++read 2048/2048 bytes at offset 405504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 409600 ++read 2048/2048 bytes at offset 409600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 413696 ++read 2048/2048 bytes at offset 413696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 417792 ++read 2048/2048 bytes at offset 417792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 421888 ++read 2048/2048 bytes at offset 421888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 425984 ++read 2048/2048 bytes at offset 425984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 430080 ++read 2048/2048 bytes at offset 430080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 434176 ++read 2048/2048 bytes at offset 434176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 438272 ++read 2048/2048 bytes at offset 438272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 98 +-qemu-io> read 2048/2048 bytes at offset 443392 ++=== IO: pattern 98 ++read 2048/2048 bytes at offset 443392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 447488 ++read 2048/2048 bytes at offset 447488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 451584 ++read 2048/2048 bytes at offset 451584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 455680 ++read 2048/2048 bytes at offset 455680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 459776 ++read 2048/2048 bytes at offset 459776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 463872 ++read 2048/2048 bytes at offset 463872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 467968 ++read 2048/2048 bytes at offset 467968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 472064 ++read 2048/2048 bytes at offset 472064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 476160 ++read 2048/2048 bytes at offset 476160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 480256 ++read 2048/2048 bytes at offset 480256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 484352 ++read 2048/2048 bytes at offset 484352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 488448 ++read 2048/2048 bytes at offset 488448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 492544 ++read 2048/2048 bytes at offset 492544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 496640 ++read 2048/2048 bytes at offset 496640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 500736 ++read 2048/2048 bytes at offset 500736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 504832 ++read 2048/2048 bytes at offset 504832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 508928 ++read 2048/2048 bytes at offset 508928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 513024 ++read 2048/2048 bytes at offset 513024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 517120 ++read 2048/2048 bytes at offset 517120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 521216 ++read 2048/2048 bytes at offset 521216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 525312 ++read 2048/2048 bytes at offset 525312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 529408 ++read 2048/2048 bytes at offset 529408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 533504 ++read 2048/2048 bytes at offset 533504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 537600 ++read 2048/2048 bytes at offset 537600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 541696 ++read 2048/2048 bytes at offset 541696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 545792 ++read 2048/2048 bytes at offset 545792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 549888 ++read 2048/2048 bytes at offset 549888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 553984 ++read 2048/2048 bytes at offset 553984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 558080 ++read 2048/2048 bytes at offset 558080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 562176 ++read 2048/2048 bytes at offset 562176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 566272 ++read 2048/2048 bytes at offset 566272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 570368 ++read 2048/2048 bytes at offset 570368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 574464 ++read 2048/2048 bytes at offset 574464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 578560 ++read 2048/2048 bytes at offset 578560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 582656 ++read 2048/2048 bytes at offset 582656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 586752 ++read 2048/2048 bytes at offset 586752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 132 +-qemu-io> read 8192/8192 bytes at offset 591872 ++=== IO: pattern 132 ++read 8192/8192 bytes at offset 591872 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 604160 ++read 8192/8192 bytes at offset 604160 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 616448 ++read 8192/8192 bytes at offset 616448 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 628736 ++read 8192/8192 bytes at offset 628736 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 641024 ++read 8192/8192 bytes at offset 641024 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 653312 ++read 8192/8192 bytes at offset 653312 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 665600 ++read 8192/8192 bytes at offset 665600 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 677888 ++read 8192/8192 bytes at offset 677888 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 690176 ++read 8192/8192 bytes at offset 690176 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 244 +-qemu-io> read 12288/12288 bytes at offset 2091008 ++=== IO: pattern 244 ++read 12288/12288 bytes at offset 2091008 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4190208 ++read 12288/12288 bytes at offset 4190208 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 6289408 ++read 12288/12288 bytes at offset 6289408 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> wrote 4096/4096 bytes at offset 0 ++=== IO: pattern 0 ++wrote 4096/4096 bytes at offset 0 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4096 ++wrote 4096/4096 bytes at offset 4096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8192 ++wrote 4096/4096 bytes at offset 8192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 12288 ++wrote 4096/4096 bytes at offset 12288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 16384 ++wrote 4096/4096 bytes at offset 16384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 20480 ++wrote 4096/4096 bytes at offset 20480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 24576 ++wrote 4096/4096 bytes at offset 24576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 28672 ++wrote 4096/4096 bytes at offset 28672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 32768 ++wrote 4096/4096 bytes at offset 32768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 36864 ++wrote 4096/4096 bytes at offset 36864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 40960 ++wrote 4096/4096 bytes at offset 40960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 45056 ++wrote 4096/4096 bytes at offset 45056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 49152 ++wrote 4096/4096 bytes at offset 49152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 53248 ++wrote 4096/4096 bytes at offset 53248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 57344 ++wrote 4096/4096 bytes at offset 57344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 61440 ++wrote 4096/4096 bytes at offset 61440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 65536 ++wrote 4096/4096 bytes at offset 65536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 69632 ++wrote 4096/4096 bytes at offset 69632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 73728 ++wrote 4096/4096 bytes at offset 73728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 77824 ++wrote 4096/4096 bytes at offset 77824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 81920 ++wrote 4096/4096 bytes at offset 81920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 86016 ++wrote 4096/4096 bytes at offset 86016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 90112 ++wrote 4096/4096 bytes at offset 90112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 94208 ++wrote 4096/4096 bytes at offset 94208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 98304 ++wrote 4096/4096 bytes at offset 98304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 102400 ++wrote 4096/4096 bytes at offset 102400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 106496 ++wrote 4096/4096 bytes at offset 106496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 110592 ++wrote 4096/4096 bytes at offset 110592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 114688 ++wrote 4096/4096 bytes at offset 114688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 118784 ++wrote 4096/4096 bytes at offset 118784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 122880 ++wrote 4096/4096 bytes at offset 122880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 126976 ++wrote 4096/4096 bytes at offset 126976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 131072 ++wrote 4096/4096 bytes at offset 131072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 135168 ++wrote 4096/4096 bytes at offset 135168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 139264 ++wrote 4096/4096 bytes at offset 139264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 143360 ++wrote 4096/4096 bytes at offset 143360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 36 +-qemu-io> wrote 2048/2048 bytes at offset 149504 ++=== IO: pattern 36 ++wrote 2048/2048 bytes at offset 149504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 153600 ++wrote 2048/2048 bytes at offset 153600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 157696 ++wrote 2048/2048 bytes at offset 157696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 161792 ++wrote 2048/2048 bytes at offset 161792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 165888 ++wrote 2048/2048 bytes at offset 165888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 169984 ++wrote 2048/2048 bytes at offset 169984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 174080 ++wrote 2048/2048 bytes at offset 174080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 178176 ++wrote 2048/2048 bytes at offset 178176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 182272 ++wrote 2048/2048 bytes at offset 182272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 186368 ++wrote 2048/2048 bytes at offset 186368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 190464 ++wrote 2048/2048 bytes at offset 190464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 194560 ++wrote 2048/2048 bytes at offset 194560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 198656 ++wrote 2048/2048 bytes at offset 198656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 202752 ++wrote 2048/2048 bytes at offset 202752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 206848 ++wrote 2048/2048 bytes at offset 206848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 210944 ++wrote 2048/2048 bytes at offset 210944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 215040 ++wrote 2048/2048 bytes at offset 215040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 219136 ++wrote 2048/2048 bytes at offset 219136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 223232 ++wrote 2048/2048 bytes at offset 223232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 227328 ++wrote 2048/2048 bytes at offset 227328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 231424 ++wrote 2048/2048 bytes at offset 231424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 235520 ++wrote 2048/2048 bytes at offset 235520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 239616 ++wrote 2048/2048 bytes at offset 239616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 243712 ++wrote 2048/2048 bytes at offset 243712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 247808 ++wrote 2048/2048 bytes at offset 247808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 251904 ++wrote 2048/2048 bytes at offset 251904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 256000 ++wrote 2048/2048 bytes at offset 256000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 260096 ++wrote 2048/2048 bytes at offset 260096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 264192 ++wrote 2048/2048 bytes at offset 264192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 268288 ++wrote 2048/2048 bytes at offset 268288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 272384 ++wrote 2048/2048 bytes at offset 272384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 276480 ++wrote 2048/2048 bytes at offset 276480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 280576 ++wrote 2048/2048 bytes at offset 280576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 284672 ++wrote 2048/2048 bytes at offset 284672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 288768 ++wrote 2048/2048 bytes at offset 288768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 292864 ++wrote 2048/2048 bytes at offset 292864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 64 +-qemu-io> wrote 2048/2048 bytes at offset 294912 ++=== IO: pattern 64 ++wrote 2048/2048 bytes at offset 294912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 299008 ++wrote 2048/2048 bytes at offset 299008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 303104 ++wrote 2048/2048 bytes at offset 303104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 307200 ++wrote 2048/2048 bytes at offset 307200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 311296 ++wrote 2048/2048 bytes at offset 311296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 315392 ++wrote 2048/2048 bytes at offset 315392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 319488 ++wrote 2048/2048 bytes at offset 319488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 323584 ++wrote 2048/2048 bytes at offset 323584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 327680 ++wrote 2048/2048 bytes at offset 327680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 331776 ++wrote 2048/2048 bytes at offset 331776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 335872 ++wrote 2048/2048 bytes at offset 335872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 339968 ++wrote 2048/2048 bytes at offset 339968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 344064 ++wrote 2048/2048 bytes at offset 344064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 348160 ++wrote 2048/2048 bytes at offset 348160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 352256 ++wrote 2048/2048 bytes at offset 352256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 356352 ++wrote 2048/2048 bytes at offset 356352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 360448 ++wrote 2048/2048 bytes at offset 360448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 364544 ++wrote 2048/2048 bytes at offset 364544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 368640 ++wrote 2048/2048 bytes at offset 368640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 372736 ++wrote 2048/2048 bytes at offset 372736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 376832 ++wrote 2048/2048 bytes at offset 376832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 380928 ++wrote 2048/2048 bytes at offset 380928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 385024 ++wrote 2048/2048 bytes at offset 385024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 389120 ++wrote 2048/2048 bytes at offset 389120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 393216 ++wrote 2048/2048 bytes at offset 393216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 397312 ++wrote 2048/2048 bytes at offset 397312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 401408 ++wrote 2048/2048 bytes at offset 401408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 405504 ++wrote 2048/2048 bytes at offset 405504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 409600 ++wrote 2048/2048 bytes at offset 409600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 413696 ++wrote 2048/2048 bytes at offset 413696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 417792 ++wrote 2048/2048 bytes at offset 417792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 421888 ++wrote 2048/2048 bytes at offset 421888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 425984 ++wrote 2048/2048 bytes at offset 425984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 430080 ++wrote 2048/2048 bytes at offset 430080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 434176 ++wrote 2048/2048 bytes at offset 434176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 438272 ++wrote 2048/2048 bytes at offset 438272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 98 +-qemu-io> wrote 2048/2048 bytes at offset 443392 ++=== IO: pattern 98 ++wrote 2048/2048 bytes at offset 443392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 447488 ++wrote 2048/2048 bytes at offset 447488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 451584 ++wrote 2048/2048 bytes at offset 451584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 455680 ++wrote 2048/2048 bytes at offset 455680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 459776 ++wrote 2048/2048 bytes at offset 459776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 463872 ++wrote 2048/2048 bytes at offset 463872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 467968 ++wrote 2048/2048 bytes at offset 467968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 472064 ++wrote 2048/2048 bytes at offset 472064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 476160 ++wrote 2048/2048 bytes at offset 476160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 480256 ++wrote 2048/2048 bytes at offset 480256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 484352 ++wrote 2048/2048 bytes at offset 484352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 488448 ++wrote 2048/2048 bytes at offset 488448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 492544 ++wrote 2048/2048 bytes at offset 492544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 496640 ++wrote 2048/2048 bytes at offset 496640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 500736 ++wrote 2048/2048 bytes at offset 500736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 504832 ++wrote 2048/2048 bytes at offset 504832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 508928 ++wrote 2048/2048 bytes at offset 508928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 513024 ++wrote 2048/2048 bytes at offset 513024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 517120 ++wrote 2048/2048 bytes at offset 517120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 521216 ++wrote 2048/2048 bytes at offset 521216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 525312 ++wrote 2048/2048 bytes at offset 525312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 529408 ++wrote 2048/2048 bytes at offset 529408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 533504 ++wrote 2048/2048 bytes at offset 533504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 537600 ++wrote 2048/2048 bytes at offset 537600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 541696 ++wrote 2048/2048 bytes at offset 541696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 545792 ++wrote 2048/2048 bytes at offset 545792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 549888 ++wrote 2048/2048 bytes at offset 549888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 553984 ++wrote 2048/2048 bytes at offset 553984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 558080 ++wrote 2048/2048 bytes at offset 558080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 562176 ++wrote 2048/2048 bytes at offset 562176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 566272 ++wrote 2048/2048 bytes at offset 566272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 570368 ++wrote 2048/2048 bytes at offset 570368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 574464 ++wrote 2048/2048 bytes at offset 574464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 578560 ++wrote 2048/2048 bytes at offset 578560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 582656 ++wrote 2048/2048 bytes at offset 582656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 586752 ++wrote 2048/2048 bytes at offset 586752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 132 +-qemu-io> wrote 8192/8192 bytes at offset 591872 ++=== IO: pattern 132 ++wrote 8192/8192 bytes at offset 591872 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 604160 ++wrote 8192/8192 bytes at offset 604160 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 616448 ++wrote 8192/8192 bytes at offset 616448 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 628736 ++wrote 8192/8192 bytes at offset 628736 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 641024 ++wrote 8192/8192 bytes at offset 641024 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 653312 ++wrote 8192/8192 bytes at offset 653312 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 665600 ++wrote 8192/8192 bytes at offset 665600 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 677888 ++wrote 8192/8192 bytes at offset 677888 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 690176 ++wrote 8192/8192 bytes at offset 690176 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 244 +-qemu-io> wrote 12288/12288 bytes at offset 2091008 ++=== IO: pattern 244 ++wrote 12288/12288 bytes at offset 2091008 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 4190208 ++wrote 12288/12288 bytes at offset 4190208 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 6289408 ++wrote 12288/12288 bytes at offset 6289408 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> read 4096/4096 bytes at offset 0 ++=== IO: pattern 0 ++read 4096/4096 bytes at offset 0 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4096 ++read 4096/4096 bytes at offset 4096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 8192 ++read 4096/4096 bytes at offset 8192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 12288 ++read 4096/4096 bytes at offset 12288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 16384 ++read 4096/4096 bytes at offset 16384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 20480 ++read 4096/4096 bytes at offset 20480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 24576 ++read 4096/4096 bytes at offset 24576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 28672 ++read 4096/4096 bytes at offset 28672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 32768 ++read 4096/4096 bytes at offset 32768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 36864 ++read 4096/4096 bytes at offset 36864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 40960 ++read 4096/4096 bytes at offset 40960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 45056 ++read 4096/4096 bytes at offset 45056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 49152 ++read 4096/4096 bytes at offset 49152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 53248 ++read 4096/4096 bytes at offset 53248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 57344 ++read 4096/4096 bytes at offset 57344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 61440 ++read 4096/4096 bytes at offset 61440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 65536 ++read 4096/4096 bytes at offset 65536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 69632 ++read 4096/4096 bytes at offset 69632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 73728 ++read 4096/4096 bytes at offset 73728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 77824 ++read 4096/4096 bytes at offset 77824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 81920 ++read 4096/4096 bytes at offset 81920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 86016 ++read 4096/4096 bytes at offset 86016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 90112 ++read 4096/4096 bytes at offset 90112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 94208 ++read 4096/4096 bytes at offset 94208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 98304 ++read 4096/4096 bytes at offset 98304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 102400 ++read 4096/4096 bytes at offset 102400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 106496 ++read 4096/4096 bytes at offset 106496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 110592 ++read 4096/4096 bytes at offset 110592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 114688 ++read 4096/4096 bytes at offset 114688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 118784 ++read 4096/4096 bytes at offset 118784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 122880 ++read 4096/4096 bytes at offset 122880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 126976 ++read 4096/4096 bytes at offset 126976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 131072 ++read 4096/4096 bytes at offset 131072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 135168 ++read 4096/4096 bytes at offset 135168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 139264 ++read 4096/4096 bytes at offset 139264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 143360 ++read 4096/4096 bytes at offset 143360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 36 +-qemu-io> read 2048/2048 bytes at offset 149504 ++=== IO: pattern 36 ++read 2048/2048 bytes at offset 149504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 153600 ++read 2048/2048 bytes at offset 153600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 157696 ++read 2048/2048 bytes at offset 157696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 161792 ++read 2048/2048 bytes at offset 161792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 165888 ++read 2048/2048 bytes at offset 165888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 169984 ++read 2048/2048 bytes at offset 169984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 174080 ++read 2048/2048 bytes at offset 174080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 178176 ++read 2048/2048 bytes at offset 178176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 182272 ++read 2048/2048 bytes at offset 182272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 186368 ++read 2048/2048 bytes at offset 186368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 190464 ++read 2048/2048 bytes at offset 190464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 194560 ++read 2048/2048 bytes at offset 194560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 198656 ++read 2048/2048 bytes at offset 198656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 202752 ++read 2048/2048 bytes at offset 202752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 206848 ++read 2048/2048 bytes at offset 206848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 210944 ++read 2048/2048 bytes at offset 210944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 215040 ++read 2048/2048 bytes at offset 215040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 219136 ++read 2048/2048 bytes at offset 219136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 223232 ++read 2048/2048 bytes at offset 223232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 227328 ++read 2048/2048 bytes at offset 227328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 231424 ++read 2048/2048 bytes at offset 231424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 235520 ++read 2048/2048 bytes at offset 235520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 239616 ++read 2048/2048 bytes at offset 239616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 243712 ++read 2048/2048 bytes at offset 243712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 247808 ++read 2048/2048 bytes at offset 247808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 251904 ++read 2048/2048 bytes at offset 251904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 256000 ++read 2048/2048 bytes at offset 256000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 260096 ++read 2048/2048 bytes at offset 260096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 264192 ++read 2048/2048 bytes at offset 264192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 268288 ++read 2048/2048 bytes at offset 268288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 272384 ++read 2048/2048 bytes at offset 272384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 276480 ++read 2048/2048 bytes at offset 276480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 280576 ++read 2048/2048 bytes at offset 280576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 284672 ++read 2048/2048 bytes at offset 284672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 288768 ++read 2048/2048 bytes at offset 288768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 292864 ++read 2048/2048 bytes at offset 292864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 64 +-qemu-io> read 2048/2048 bytes at offset 294912 ++=== IO: pattern 64 ++read 2048/2048 bytes at offset 294912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 299008 ++read 2048/2048 bytes at offset 299008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 303104 ++read 2048/2048 bytes at offset 303104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 307200 ++read 2048/2048 bytes at offset 307200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 311296 ++read 2048/2048 bytes at offset 311296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 315392 ++read 2048/2048 bytes at offset 315392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 319488 ++read 2048/2048 bytes at offset 319488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 323584 ++read 2048/2048 bytes at offset 323584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 327680 ++read 2048/2048 bytes at offset 327680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 331776 ++read 2048/2048 bytes at offset 331776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 335872 ++read 2048/2048 bytes at offset 335872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 339968 ++read 2048/2048 bytes at offset 339968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 344064 ++read 2048/2048 bytes at offset 344064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 348160 ++read 2048/2048 bytes at offset 348160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 352256 ++read 2048/2048 bytes at offset 352256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 356352 ++read 2048/2048 bytes at offset 356352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 360448 ++read 2048/2048 bytes at offset 360448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 364544 ++read 2048/2048 bytes at offset 364544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 368640 ++read 2048/2048 bytes at offset 368640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 372736 ++read 2048/2048 bytes at offset 372736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 376832 ++read 2048/2048 bytes at offset 376832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 380928 ++read 2048/2048 bytes at offset 380928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 385024 ++read 2048/2048 bytes at offset 385024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 389120 ++read 2048/2048 bytes at offset 389120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 393216 ++read 2048/2048 bytes at offset 393216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 397312 ++read 2048/2048 bytes at offset 397312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 401408 ++read 2048/2048 bytes at offset 401408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 405504 ++read 2048/2048 bytes at offset 405504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 409600 ++read 2048/2048 bytes at offset 409600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 413696 ++read 2048/2048 bytes at offset 413696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 417792 ++read 2048/2048 bytes at offset 417792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 421888 ++read 2048/2048 bytes at offset 421888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 425984 ++read 2048/2048 bytes at offset 425984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 430080 ++read 2048/2048 bytes at offset 430080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 434176 ++read 2048/2048 bytes at offset 434176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 438272 ++read 2048/2048 bytes at offset 438272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 98 +-qemu-io> read 2048/2048 bytes at offset 443392 ++=== IO: pattern 98 ++read 2048/2048 bytes at offset 443392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 447488 ++read 2048/2048 bytes at offset 447488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 451584 ++read 2048/2048 bytes at offset 451584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 455680 ++read 2048/2048 bytes at offset 455680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 459776 ++read 2048/2048 bytes at offset 459776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 463872 ++read 2048/2048 bytes at offset 463872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 467968 ++read 2048/2048 bytes at offset 467968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 472064 ++read 2048/2048 bytes at offset 472064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 476160 ++read 2048/2048 bytes at offset 476160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 480256 ++read 2048/2048 bytes at offset 480256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 484352 ++read 2048/2048 bytes at offset 484352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 488448 ++read 2048/2048 bytes at offset 488448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 492544 ++read 2048/2048 bytes at offset 492544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 496640 ++read 2048/2048 bytes at offset 496640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 500736 ++read 2048/2048 bytes at offset 500736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 504832 ++read 2048/2048 bytes at offset 504832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 508928 ++read 2048/2048 bytes at offset 508928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 513024 ++read 2048/2048 bytes at offset 513024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 517120 ++read 2048/2048 bytes at offset 517120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 521216 ++read 2048/2048 bytes at offset 521216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 525312 ++read 2048/2048 bytes at offset 525312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 529408 ++read 2048/2048 bytes at offset 529408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 533504 ++read 2048/2048 bytes at offset 533504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 537600 ++read 2048/2048 bytes at offset 537600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 541696 ++read 2048/2048 bytes at offset 541696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 545792 ++read 2048/2048 bytes at offset 545792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 549888 ++read 2048/2048 bytes at offset 549888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 553984 ++read 2048/2048 bytes at offset 553984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 558080 ++read 2048/2048 bytes at offset 558080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 562176 ++read 2048/2048 bytes at offset 562176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 566272 ++read 2048/2048 bytes at offset 566272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 570368 ++read 2048/2048 bytes at offset 570368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 574464 ++read 2048/2048 bytes at offset 574464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 578560 ++read 2048/2048 bytes at offset 578560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 582656 ++read 2048/2048 bytes at offset 582656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 586752 ++read 2048/2048 bytes at offset 586752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 132 +-qemu-io> read 8192/8192 bytes at offset 591872 ++=== IO: pattern 132 ++read 8192/8192 bytes at offset 591872 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 604160 ++read 8192/8192 bytes at offset 604160 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 616448 ++read 8192/8192 bytes at offset 616448 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 628736 ++read 8192/8192 bytes at offset 628736 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 641024 ++read 8192/8192 bytes at offset 641024 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 653312 ++read 8192/8192 bytes at offset 653312 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 665600 ++read 8192/8192 bytes at offset 665600 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 677888 ++read 8192/8192 bytes at offset 677888 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 690176 ++read 8192/8192 bytes at offset 690176 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 244 +-qemu-io> read 12288/12288 bytes at offset 2091008 ++=== IO: pattern 244 ++read 12288/12288 bytes at offset 2091008 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4190208 ++read 12288/12288 bytes at offset 4190208 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 6289408 ++read 12288/12288 bytes at offset 6289408 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> No errors were found on the image. ++No errors were found on the image. + At offset 4294967296: + === IO: pattern 0 +-qemu-io> wrote 4096/4096 bytes at offset 4294967296 ++wrote 4096/4096 bytes at offset 4294967296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4294971392 ++wrote 4096/4096 bytes at offset 4294971392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4294975488 ++wrote 4096/4096 bytes at offset 4294975488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4294979584 ++wrote 4096/4096 bytes at offset 4294979584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4294983680 ++wrote 4096/4096 bytes at offset 4294983680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4294987776 ++wrote 4096/4096 bytes at offset 4294987776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4294991872 ++wrote 4096/4096 bytes at offset 4294991872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4294995968 ++wrote 4096/4096 bytes at offset 4294995968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295000064 ++wrote 4096/4096 bytes at offset 4295000064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295004160 ++wrote 4096/4096 bytes at offset 4295004160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295008256 ++wrote 4096/4096 bytes at offset 4295008256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295012352 ++wrote 4096/4096 bytes at offset 4295012352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295016448 ++wrote 4096/4096 bytes at offset 4295016448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295020544 ++wrote 4096/4096 bytes at offset 4295020544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295024640 ++wrote 4096/4096 bytes at offset 4295024640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295028736 ++wrote 4096/4096 bytes at offset 4295028736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295032832 ++wrote 4096/4096 bytes at offset 4295032832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295036928 ++wrote 4096/4096 bytes at offset 4295036928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295041024 ++wrote 4096/4096 bytes at offset 4295041024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295045120 ++wrote 4096/4096 bytes at offset 4295045120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295049216 ++wrote 4096/4096 bytes at offset 4295049216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295053312 ++wrote 4096/4096 bytes at offset 4295053312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295057408 ++wrote 4096/4096 bytes at offset 4295057408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295061504 ++wrote 4096/4096 bytes at offset 4295061504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295065600 ++wrote 4096/4096 bytes at offset 4295065600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295069696 ++wrote 4096/4096 bytes at offset 4295069696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295073792 ++wrote 4096/4096 bytes at offset 4295073792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295077888 ++wrote 4096/4096 bytes at offset 4295077888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295081984 ++wrote 4096/4096 bytes at offset 4295081984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295086080 ++wrote 4096/4096 bytes at offset 4295086080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295090176 ++wrote 4096/4096 bytes at offset 4295090176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295094272 ++wrote 4096/4096 bytes at offset 4295094272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295098368 ++wrote 4096/4096 bytes at offset 4295098368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295102464 ++wrote 4096/4096 bytes at offset 4295102464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295106560 ++wrote 4096/4096 bytes at offset 4295106560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295110656 ++wrote 4096/4096 bytes at offset 4295110656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 36 +-qemu-io> wrote 2048/2048 bytes at offset 4295116800 ++=== IO: pattern 36 ++wrote 2048/2048 bytes at offset 4295116800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295120896 ++wrote 2048/2048 bytes at offset 4295120896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295124992 ++wrote 2048/2048 bytes at offset 4295124992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295129088 ++wrote 2048/2048 bytes at offset 4295129088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295133184 ++wrote 2048/2048 bytes at offset 4295133184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295137280 ++wrote 2048/2048 bytes at offset 4295137280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295141376 ++wrote 2048/2048 bytes at offset 4295141376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295145472 ++wrote 2048/2048 bytes at offset 4295145472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295149568 ++wrote 2048/2048 bytes at offset 4295149568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295153664 ++wrote 2048/2048 bytes at offset 4295153664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295157760 ++wrote 2048/2048 bytes at offset 4295157760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295161856 ++wrote 2048/2048 bytes at offset 4295161856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295165952 ++wrote 2048/2048 bytes at offset 4295165952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295170048 ++wrote 2048/2048 bytes at offset 4295170048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295174144 ++wrote 2048/2048 bytes at offset 4295174144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295178240 ++wrote 2048/2048 bytes at offset 4295178240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295182336 ++wrote 2048/2048 bytes at offset 4295182336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295186432 ++wrote 2048/2048 bytes at offset 4295186432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295190528 ++wrote 2048/2048 bytes at offset 4295190528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295194624 ++wrote 2048/2048 bytes at offset 4295194624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295198720 ++wrote 2048/2048 bytes at offset 4295198720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295202816 ++wrote 2048/2048 bytes at offset 4295202816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295206912 ++wrote 2048/2048 bytes at offset 4295206912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295211008 ++wrote 2048/2048 bytes at offset 4295211008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295215104 ++wrote 2048/2048 bytes at offset 4295215104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295219200 ++wrote 2048/2048 bytes at offset 4295219200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295223296 ++wrote 2048/2048 bytes at offset 4295223296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295227392 ++wrote 2048/2048 bytes at offset 4295227392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295231488 ++wrote 2048/2048 bytes at offset 4295231488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295235584 ++wrote 2048/2048 bytes at offset 4295235584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295239680 ++wrote 2048/2048 bytes at offset 4295239680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295243776 ++wrote 2048/2048 bytes at offset 4295243776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295247872 ++wrote 2048/2048 bytes at offset 4295247872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295251968 ++wrote 2048/2048 bytes at offset 4295251968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295256064 ++wrote 2048/2048 bytes at offset 4295256064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295260160 ++wrote 2048/2048 bytes at offset 4295260160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 64 +-qemu-io> wrote 2048/2048 bytes at offset 4295262208 ++=== IO: pattern 64 ++wrote 2048/2048 bytes at offset 4295262208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295266304 ++wrote 2048/2048 bytes at offset 4295266304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295270400 ++wrote 2048/2048 bytes at offset 4295270400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295274496 ++wrote 2048/2048 bytes at offset 4295274496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295278592 ++wrote 2048/2048 bytes at offset 4295278592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295282688 ++wrote 2048/2048 bytes at offset 4295282688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295286784 ++wrote 2048/2048 bytes at offset 4295286784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295290880 ++wrote 2048/2048 bytes at offset 4295290880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295294976 ++wrote 2048/2048 bytes at offset 4295294976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295299072 ++wrote 2048/2048 bytes at offset 4295299072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295303168 ++wrote 2048/2048 bytes at offset 4295303168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295307264 ++wrote 2048/2048 bytes at offset 4295307264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295311360 ++wrote 2048/2048 bytes at offset 4295311360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295315456 ++wrote 2048/2048 bytes at offset 4295315456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295319552 ++wrote 2048/2048 bytes at offset 4295319552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295323648 ++wrote 2048/2048 bytes at offset 4295323648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295327744 ++wrote 2048/2048 bytes at offset 4295327744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295331840 ++wrote 2048/2048 bytes at offset 4295331840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295335936 ++wrote 2048/2048 bytes at offset 4295335936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295340032 ++wrote 2048/2048 bytes at offset 4295340032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295344128 ++wrote 2048/2048 bytes at offset 4295344128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295348224 ++wrote 2048/2048 bytes at offset 4295348224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295352320 ++wrote 2048/2048 bytes at offset 4295352320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295356416 ++wrote 2048/2048 bytes at offset 4295356416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295360512 ++wrote 2048/2048 bytes at offset 4295360512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295364608 ++wrote 2048/2048 bytes at offset 4295364608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295368704 ++wrote 2048/2048 bytes at offset 4295368704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295372800 ++wrote 2048/2048 bytes at offset 4295372800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295376896 ++wrote 2048/2048 bytes at offset 4295376896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295380992 ++wrote 2048/2048 bytes at offset 4295380992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295385088 ++wrote 2048/2048 bytes at offset 4295385088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295389184 ++wrote 2048/2048 bytes at offset 4295389184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295393280 ++wrote 2048/2048 bytes at offset 4295393280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295397376 ++wrote 2048/2048 bytes at offset 4295397376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295401472 ++wrote 2048/2048 bytes at offset 4295401472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295405568 ++wrote 2048/2048 bytes at offset 4295405568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 98 +-qemu-io> wrote 2048/2048 bytes at offset 4295410688 ++=== IO: pattern 98 ++wrote 2048/2048 bytes at offset 4295410688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295414784 ++wrote 2048/2048 bytes at offset 4295414784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295418880 ++wrote 2048/2048 bytes at offset 4295418880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295422976 ++wrote 2048/2048 bytes at offset 4295422976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295427072 ++wrote 2048/2048 bytes at offset 4295427072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295431168 ++wrote 2048/2048 bytes at offset 4295431168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295435264 ++wrote 2048/2048 bytes at offset 4295435264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295439360 ++wrote 2048/2048 bytes at offset 4295439360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295443456 ++wrote 2048/2048 bytes at offset 4295443456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295447552 ++wrote 2048/2048 bytes at offset 4295447552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295451648 ++wrote 2048/2048 bytes at offset 4295451648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295455744 ++wrote 2048/2048 bytes at offset 4295455744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295459840 ++wrote 2048/2048 bytes at offset 4295459840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295463936 ++wrote 2048/2048 bytes at offset 4295463936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295468032 ++wrote 2048/2048 bytes at offset 4295468032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295472128 ++wrote 2048/2048 bytes at offset 4295472128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295476224 ++wrote 2048/2048 bytes at offset 4295476224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295480320 ++wrote 2048/2048 bytes at offset 4295480320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295484416 ++wrote 2048/2048 bytes at offset 4295484416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295488512 ++wrote 2048/2048 bytes at offset 4295488512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295492608 ++wrote 2048/2048 bytes at offset 4295492608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295496704 ++wrote 2048/2048 bytes at offset 4295496704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295500800 ++wrote 2048/2048 bytes at offset 4295500800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295504896 ++wrote 2048/2048 bytes at offset 4295504896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295508992 ++wrote 2048/2048 bytes at offset 4295508992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295513088 ++wrote 2048/2048 bytes at offset 4295513088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295517184 ++wrote 2048/2048 bytes at offset 4295517184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295521280 ++wrote 2048/2048 bytes at offset 4295521280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295525376 ++wrote 2048/2048 bytes at offset 4295525376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295529472 ++wrote 2048/2048 bytes at offset 4295529472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295533568 ++wrote 2048/2048 bytes at offset 4295533568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295537664 ++wrote 2048/2048 bytes at offset 4295537664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295541760 ++wrote 2048/2048 bytes at offset 4295541760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295545856 ++wrote 2048/2048 bytes at offset 4295545856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295549952 ++wrote 2048/2048 bytes at offset 4295549952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295554048 ++wrote 2048/2048 bytes at offset 4295554048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 132 +-qemu-io> wrote 8192/8192 bytes at offset 4295559168 ++=== IO: pattern 132 ++wrote 8192/8192 bytes at offset 4295559168 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295571456 ++wrote 8192/8192 bytes at offset 4295571456 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295583744 ++wrote 8192/8192 bytes at offset 4295583744 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295596032 ++wrote 8192/8192 bytes at offset 4295596032 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295608320 ++wrote 8192/8192 bytes at offset 4295608320 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295620608 ++wrote 8192/8192 bytes at offset 4295620608 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295632896 ++wrote 8192/8192 bytes at offset 4295632896 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295645184 ++wrote 8192/8192 bytes at offset 4295645184 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295657472 ++wrote 8192/8192 bytes at offset 4295657472 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 244 +-qemu-io> wrote 12288/12288 bytes at offset 4297058304 ++=== IO: pattern 244 ++wrote 12288/12288 bytes at offset 4297058304 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 4299157504 ++wrote 12288/12288 bytes at offset 4299157504 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 4301256704 ++wrote 12288/12288 bytes at offset 4301256704 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> read 4096/4096 bytes at offset 4294967296 ++=== IO: pattern 0 ++read 4096/4096 bytes at offset 4294967296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294971392 ++read 4096/4096 bytes at offset 4294971392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294975488 ++read 4096/4096 bytes at offset 4294975488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294979584 ++read 4096/4096 bytes at offset 4294979584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294983680 ++read 4096/4096 bytes at offset 4294983680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294987776 ++read 4096/4096 bytes at offset 4294987776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294991872 ++read 4096/4096 bytes at offset 4294991872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294995968 ++read 4096/4096 bytes at offset 4294995968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295000064 ++read 4096/4096 bytes at offset 4295000064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295004160 ++read 4096/4096 bytes at offset 4295004160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295008256 ++read 4096/4096 bytes at offset 4295008256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295012352 ++read 4096/4096 bytes at offset 4295012352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295016448 ++read 4096/4096 bytes at offset 4295016448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295020544 ++read 4096/4096 bytes at offset 4295020544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295024640 ++read 4096/4096 bytes at offset 4295024640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295028736 ++read 4096/4096 bytes at offset 4295028736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295032832 ++read 4096/4096 bytes at offset 4295032832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295036928 ++read 4096/4096 bytes at offset 4295036928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295041024 ++read 4096/4096 bytes at offset 4295041024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295045120 ++read 4096/4096 bytes at offset 4295045120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295049216 ++read 4096/4096 bytes at offset 4295049216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295053312 ++read 4096/4096 bytes at offset 4295053312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295057408 ++read 4096/4096 bytes at offset 4295057408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295061504 ++read 4096/4096 bytes at offset 4295061504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295065600 ++read 4096/4096 bytes at offset 4295065600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295069696 ++read 4096/4096 bytes at offset 4295069696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295073792 ++read 4096/4096 bytes at offset 4295073792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295077888 ++read 4096/4096 bytes at offset 4295077888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295081984 ++read 4096/4096 bytes at offset 4295081984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295086080 ++read 4096/4096 bytes at offset 4295086080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295090176 ++read 4096/4096 bytes at offset 4295090176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295094272 ++read 4096/4096 bytes at offset 4295094272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295098368 ++read 4096/4096 bytes at offset 4295098368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295102464 ++read 4096/4096 bytes at offset 4295102464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295106560 ++read 4096/4096 bytes at offset 4295106560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295110656 ++read 4096/4096 bytes at offset 4295110656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 36 +-qemu-io> read 2048/2048 bytes at offset 4295116800 ++=== IO: pattern 36 ++read 2048/2048 bytes at offset 4295116800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295120896 ++read 2048/2048 bytes at offset 4295120896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295124992 ++read 2048/2048 bytes at offset 4295124992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295129088 ++read 2048/2048 bytes at offset 4295129088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295133184 ++read 2048/2048 bytes at offset 4295133184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295137280 ++read 2048/2048 bytes at offset 4295137280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295141376 ++read 2048/2048 bytes at offset 4295141376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295145472 ++read 2048/2048 bytes at offset 4295145472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295149568 ++read 2048/2048 bytes at offset 4295149568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295153664 ++read 2048/2048 bytes at offset 4295153664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295157760 ++read 2048/2048 bytes at offset 4295157760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295161856 ++read 2048/2048 bytes at offset 4295161856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295165952 ++read 2048/2048 bytes at offset 4295165952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295170048 ++read 2048/2048 bytes at offset 4295170048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295174144 ++read 2048/2048 bytes at offset 4295174144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295178240 ++read 2048/2048 bytes at offset 4295178240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295182336 ++read 2048/2048 bytes at offset 4295182336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295186432 ++read 2048/2048 bytes at offset 4295186432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295190528 ++read 2048/2048 bytes at offset 4295190528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295194624 ++read 2048/2048 bytes at offset 4295194624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295198720 ++read 2048/2048 bytes at offset 4295198720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295202816 ++read 2048/2048 bytes at offset 4295202816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295206912 ++read 2048/2048 bytes at offset 4295206912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295211008 ++read 2048/2048 bytes at offset 4295211008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295215104 ++read 2048/2048 bytes at offset 4295215104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295219200 ++read 2048/2048 bytes at offset 4295219200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295223296 ++read 2048/2048 bytes at offset 4295223296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295227392 ++read 2048/2048 bytes at offset 4295227392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295231488 ++read 2048/2048 bytes at offset 4295231488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295235584 ++read 2048/2048 bytes at offset 4295235584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295239680 ++read 2048/2048 bytes at offset 4295239680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295243776 ++read 2048/2048 bytes at offset 4295243776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295247872 ++read 2048/2048 bytes at offset 4295247872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295251968 ++read 2048/2048 bytes at offset 4295251968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295256064 ++read 2048/2048 bytes at offset 4295256064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295260160 ++read 2048/2048 bytes at offset 4295260160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 64 +-qemu-io> read 2048/2048 bytes at offset 4295262208 ++=== IO: pattern 64 ++read 2048/2048 bytes at offset 4295262208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295266304 ++read 2048/2048 bytes at offset 4295266304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295270400 ++read 2048/2048 bytes at offset 4295270400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295274496 ++read 2048/2048 bytes at offset 4295274496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295278592 ++read 2048/2048 bytes at offset 4295278592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295282688 ++read 2048/2048 bytes at offset 4295282688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295286784 ++read 2048/2048 bytes at offset 4295286784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295290880 ++read 2048/2048 bytes at offset 4295290880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295294976 ++read 2048/2048 bytes at offset 4295294976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295299072 ++read 2048/2048 bytes at offset 4295299072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295303168 ++read 2048/2048 bytes at offset 4295303168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295307264 ++read 2048/2048 bytes at offset 4295307264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295311360 ++read 2048/2048 bytes at offset 4295311360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295315456 ++read 2048/2048 bytes at offset 4295315456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295319552 ++read 2048/2048 bytes at offset 4295319552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295323648 ++read 2048/2048 bytes at offset 4295323648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295327744 ++read 2048/2048 bytes at offset 4295327744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295331840 ++read 2048/2048 bytes at offset 4295331840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295335936 ++read 2048/2048 bytes at offset 4295335936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295340032 ++read 2048/2048 bytes at offset 4295340032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295344128 ++read 2048/2048 bytes at offset 4295344128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295348224 ++read 2048/2048 bytes at offset 4295348224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295352320 ++read 2048/2048 bytes at offset 4295352320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295356416 ++read 2048/2048 bytes at offset 4295356416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295360512 ++read 2048/2048 bytes at offset 4295360512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295364608 ++read 2048/2048 bytes at offset 4295364608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295368704 ++read 2048/2048 bytes at offset 4295368704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295372800 ++read 2048/2048 bytes at offset 4295372800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295376896 ++read 2048/2048 bytes at offset 4295376896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295380992 ++read 2048/2048 bytes at offset 4295380992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295385088 ++read 2048/2048 bytes at offset 4295385088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295389184 ++read 2048/2048 bytes at offset 4295389184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295393280 ++read 2048/2048 bytes at offset 4295393280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295397376 ++read 2048/2048 bytes at offset 4295397376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295401472 ++read 2048/2048 bytes at offset 4295401472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295405568 ++read 2048/2048 bytes at offset 4295405568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 98 +-qemu-io> read 2048/2048 bytes at offset 4295410688 ++=== IO: pattern 98 ++read 2048/2048 bytes at offset 4295410688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295414784 ++read 2048/2048 bytes at offset 4295414784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295418880 ++read 2048/2048 bytes at offset 4295418880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295422976 ++read 2048/2048 bytes at offset 4295422976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295427072 ++read 2048/2048 bytes at offset 4295427072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295431168 ++read 2048/2048 bytes at offset 4295431168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295435264 ++read 2048/2048 bytes at offset 4295435264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295439360 ++read 2048/2048 bytes at offset 4295439360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295443456 ++read 2048/2048 bytes at offset 4295443456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295447552 ++read 2048/2048 bytes at offset 4295447552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295451648 ++read 2048/2048 bytes at offset 4295451648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295455744 ++read 2048/2048 bytes at offset 4295455744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295459840 ++read 2048/2048 bytes at offset 4295459840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295463936 ++read 2048/2048 bytes at offset 4295463936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295468032 ++read 2048/2048 bytes at offset 4295468032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295472128 ++read 2048/2048 bytes at offset 4295472128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295476224 ++read 2048/2048 bytes at offset 4295476224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295480320 ++read 2048/2048 bytes at offset 4295480320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295484416 ++read 2048/2048 bytes at offset 4295484416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295488512 ++read 2048/2048 bytes at offset 4295488512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295492608 ++read 2048/2048 bytes at offset 4295492608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295496704 ++read 2048/2048 bytes at offset 4295496704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295500800 ++read 2048/2048 bytes at offset 4295500800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295504896 ++read 2048/2048 bytes at offset 4295504896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295508992 ++read 2048/2048 bytes at offset 4295508992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295513088 ++read 2048/2048 bytes at offset 4295513088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295517184 ++read 2048/2048 bytes at offset 4295517184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295521280 ++read 2048/2048 bytes at offset 4295521280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295525376 ++read 2048/2048 bytes at offset 4295525376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295529472 ++read 2048/2048 bytes at offset 4295529472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295533568 ++read 2048/2048 bytes at offset 4295533568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295537664 ++read 2048/2048 bytes at offset 4295537664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295541760 ++read 2048/2048 bytes at offset 4295541760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295545856 ++read 2048/2048 bytes at offset 4295545856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295549952 ++read 2048/2048 bytes at offset 4295549952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295554048 ++read 2048/2048 bytes at offset 4295554048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 132 +-qemu-io> read 8192/8192 bytes at offset 4295559168 ++=== IO: pattern 132 ++read 8192/8192 bytes at offset 4295559168 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295571456 ++read 8192/8192 bytes at offset 4295571456 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295583744 ++read 8192/8192 bytes at offset 4295583744 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295596032 ++read 8192/8192 bytes at offset 4295596032 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295608320 ++read 8192/8192 bytes at offset 4295608320 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295620608 ++read 8192/8192 bytes at offset 4295620608 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295632896 ++read 8192/8192 bytes at offset 4295632896 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295645184 ++read 8192/8192 bytes at offset 4295645184 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295657472 ++read 8192/8192 bytes at offset 4295657472 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 244 +-qemu-io> read 12288/12288 bytes at offset 4297058304 ++=== IO: pattern 244 ++read 12288/12288 bytes at offset 4297058304 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4299157504 ++read 12288/12288 bytes at offset 4299157504 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4301256704 ++read 12288/12288 bytes at offset 4301256704 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> wrote 4096/4096 bytes at offset 4294967296 ++=== IO: pattern 0 ++wrote 4096/4096 bytes at offset 4294967296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4294971392 ++wrote 4096/4096 bytes at offset 4294971392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4294975488 ++wrote 4096/4096 bytes at offset 4294975488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4294979584 ++wrote 4096/4096 bytes at offset 4294979584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4294983680 ++wrote 4096/4096 bytes at offset 4294983680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4294987776 ++wrote 4096/4096 bytes at offset 4294987776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4294991872 ++wrote 4096/4096 bytes at offset 4294991872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4294995968 ++wrote 4096/4096 bytes at offset 4294995968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295000064 ++wrote 4096/4096 bytes at offset 4295000064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295004160 ++wrote 4096/4096 bytes at offset 4295004160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295008256 ++wrote 4096/4096 bytes at offset 4295008256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295012352 ++wrote 4096/4096 bytes at offset 4295012352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295016448 ++wrote 4096/4096 bytes at offset 4295016448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295020544 ++wrote 4096/4096 bytes at offset 4295020544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295024640 ++wrote 4096/4096 bytes at offset 4295024640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295028736 ++wrote 4096/4096 bytes at offset 4295028736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295032832 ++wrote 4096/4096 bytes at offset 4295032832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295036928 ++wrote 4096/4096 bytes at offset 4295036928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295041024 ++wrote 4096/4096 bytes at offset 4295041024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295045120 ++wrote 4096/4096 bytes at offset 4295045120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295049216 ++wrote 4096/4096 bytes at offset 4295049216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295053312 ++wrote 4096/4096 bytes at offset 4295053312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295057408 ++wrote 4096/4096 bytes at offset 4295057408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295061504 ++wrote 4096/4096 bytes at offset 4295061504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295065600 ++wrote 4096/4096 bytes at offset 4295065600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295069696 ++wrote 4096/4096 bytes at offset 4295069696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295073792 ++wrote 4096/4096 bytes at offset 4295073792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295077888 ++wrote 4096/4096 bytes at offset 4295077888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295081984 ++wrote 4096/4096 bytes at offset 4295081984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295086080 ++wrote 4096/4096 bytes at offset 4295086080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295090176 ++wrote 4096/4096 bytes at offset 4295090176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295094272 ++wrote 4096/4096 bytes at offset 4295094272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295098368 ++wrote 4096/4096 bytes at offset 4295098368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295102464 ++wrote 4096/4096 bytes at offset 4295102464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295106560 ++wrote 4096/4096 bytes at offset 4295106560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295110656 ++wrote 4096/4096 bytes at offset 4295110656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 36 +-qemu-io> wrote 2048/2048 bytes at offset 4295116800 ++=== IO: pattern 36 ++wrote 2048/2048 bytes at offset 4295116800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295120896 ++wrote 2048/2048 bytes at offset 4295120896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295124992 ++wrote 2048/2048 bytes at offset 4295124992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295129088 ++wrote 2048/2048 bytes at offset 4295129088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295133184 ++wrote 2048/2048 bytes at offset 4295133184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295137280 ++wrote 2048/2048 bytes at offset 4295137280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295141376 ++wrote 2048/2048 bytes at offset 4295141376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295145472 ++wrote 2048/2048 bytes at offset 4295145472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295149568 ++wrote 2048/2048 bytes at offset 4295149568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295153664 ++wrote 2048/2048 bytes at offset 4295153664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295157760 ++wrote 2048/2048 bytes at offset 4295157760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295161856 ++wrote 2048/2048 bytes at offset 4295161856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295165952 ++wrote 2048/2048 bytes at offset 4295165952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295170048 ++wrote 2048/2048 bytes at offset 4295170048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295174144 ++wrote 2048/2048 bytes at offset 4295174144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295178240 ++wrote 2048/2048 bytes at offset 4295178240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295182336 ++wrote 2048/2048 bytes at offset 4295182336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295186432 ++wrote 2048/2048 bytes at offset 4295186432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295190528 ++wrote 2048/2048 bytes at offset 4295190528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295194624 ++wrote 2048/2048 bytes at offset 4295194624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295198720 ++wrote 2048/2048 bytes at offset 4295198720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295202816 ++wrote 2048/2048 bytes at offset 4295202816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295206912 ++wrote 2048/2048 bytes at offset 4295206912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295211008 ++wrote 2048/2048 bytes at offset 4295211008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295215104 ++wrote 2048/2048 bytes at offset 4295215104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295219200 ++wrote 2048/2048 bytes at offset 4295219200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295223296 ++wrote 2048/2048 bytes at offset 4295223296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295227392 ++wrote 2048/2048 bytes at offset 4295227392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295231488 ++wrote 2048/2048 bytes at offset 4295231488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295235584 ++wrote 2048/2048 bytes at offset 4295235584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295239680 ++wrote 2048/2048 bytes at offset 4295239680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295243776 ++wrote 2048/2048 bytes at offset 4295243776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295247872 ++wrote 2048/2048 bytes at offset 4295247872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295251968 ++wrote 2048/2048 bytes at offset 4295251968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295256064 ++wrote 2048/2048 bytes at offset 4295256064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295260160 ++wrote 2048/2048 bytes at offset 4295260160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 64 +-qemu-io> wrote 2048/2048 bytes at offset 4295262208 ++=== IO: pattern 64 ++wrote 2048/2048 bytes at offset 4295262208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295266304 ++wrote 2048/2048 bytes at offset 4295266304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295270400 ++wrote 2048/2048 bytes at offset 4295270400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295274496 ++wrote 2048/2048 bytes at offset 4295274496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295278592 ++wrote 2048/2048 bytes at offset 4295278592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295282688 ++wrote 2048/2048 bytes at offset 4295282688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295286784 ++wrote 2048/2048 bytes at offset 4295286784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295290880 ++wrote 2048/2048 bytes at offset 4295290880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295294976 ++wrote 2048/2048 bytes at offset 4295294976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295299072 ++wrote 2048/2048 bytes at offset 4295299072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295303168 ++wrote 2048/2048 bytes at offset 4295303168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295307264 ++wrote 2048/2048 bytes at offset 4295307264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295311360 ++wrote 2048/2048 bytes at offset 4295311360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295315456 ++wrote 2048/2048 bytes at offset 4295315456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295319552 ++wrote 2048/2048 bytes at offset 4295319552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295323648 ++wrote 2048/2048 bytes at offset 4295323648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295327744 ++wrote 2048/2048 bytes at offset 4295327744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295331840 ++wrote 2048/2048 bytes at offset 4295331840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295335936 ++wrote 2048/2048 bytes at offset 4295335936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295340032 ++wrote 2048/2048 bytes at offset 4295340032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295344128 ++wrote 2048/2048 bytes at offset 4295344128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295348224 ++wrote 2048/2048 bytes at offset 4295348224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295352320 ++wrote 2048/2048 bytes at offset 4295352320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295356416 ++wrote 2048/2048 bytes at offset 4295356416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295360512 ++wrote 2048/2048 bytes at offset 4295360512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295364608 ++wrote 2048/2048 bytes at offset 4295364608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295368704 ++wrote 2048/2048 bytes at offset 4295368704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295372800 ++wrote 2048/2048 bytes at offset 4295372800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295376896 ++wrote 2048/2048 bytes at offset 4295376896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295380992 ++wrote 2048/2048 bytes at offset 4295380992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295385088 ++wrote 2048/2048 bytes at offset 4295385088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295389184 ++wrote 2048/2048 bytes at offset 4295389184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295393280 ++wrote 2048/2048 bytes at offset 4295393280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295397376 ++wrote 2048/2048 bytes at offset 4295397376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295401472 ++wrote 2048/2048 bytes at offset 4295401472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295405568 ++wrote 2048/2048 bytes at offset 4295405568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 98 +-qemu-io> wrote 2048/2048 bytes at offset 4295410688 ++=== IO: pattern 98 ++wrote 2048/2048 bytes at offset 4295410688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295414784 ++wrote 2048/2048 bytes at offset 4295414784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295418880 ++wrote 2048/2048 bytes at offset 4295418880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295422976 ++wrote 2048/2048 bytes at offset 4295422976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295427072 ++wrote 2048/2048 bytes at offset 4295427072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295431168 ++wrote 2048/2048 bytes at offset 4295431168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295435264 ++wrote 2048/2048 bytes at offset 4295435264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295439360 ++wrote 2048/2048 bytes at offset 4295439360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295443456 ++wrote 2048/2048 bytes at offset 4295443456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295447552 ++wrote 2048/2048 bytes at offset 4295447552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295451648 ++wrote 2048/2048 bytes at offset 4295451648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295455744 ++wrote 2048/2048 bytes at offset 4295455744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295459840 ++wrote 2048/2048 bytes at offset 4295459840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295463936 ++wrote 2048/2048 bytes at offset 4295463936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295468032 ++wrote 2048/2048 bytes at offset 4295468032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295472128 ++wrote 2048/2048 bytes at offset 4295472128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295476224 ++wrote 2048/2048 bytes at offset 4295476224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295480320 ++wrote 2048/2048 bytes at offset 4295480320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295484416 ++wrote 2048/2048 bytes at offset 4295484416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295488512 ++wrote 2048/2048 bytes at offset 4295488512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295492608 ++wrote 2048/2048 bytes at offset 4295492608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295496704 ++wrote 2048/2048 bytes at offset 4295496704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295500800 ++wrote 2048/2048 bytes at offset 4295500800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295504896 ++wrote 2048/2048 bytes at offset 4295504896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295508992 ++wrote 2048/2048 bytes at offset 4295508992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295513088 ++wrote 2048/2048 bytes at offset 4295513088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295517184 ++wrote 2048/2048 bytes at offset 4295517184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295521280 ++wrote 2048/2048 bytes at offset 4295521280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295525376 ++wrote 2048/2048 bytes at offset 4295525376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295529472 ++wrote 2048/2048 bytes at offset 4295529472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295533568 ++wrote 2048/2048 bytes at offset 4295533568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295537664 ++wrote 2048/2048 bytes at offset 4295537664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295541760 ++wrote 2048/2048 bytes at offset 4295541760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295545856 ++wrote 2048/2048 bytes at offset 4295545856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295549952 ++wrote 2048/2048 bytes at offset 4295549952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295554048 ++wrote 2048/2048 bytes at offset 4295554048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 132 +-qemu-io> wrote 8192/8192 bytes at offset 4295559168 ++=== IO: pattern 132 ++wrote 8192/8192 bytes at offset 4295559168 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295571456 ++wrote 8192/8192 bytes at offset 4295571456 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295583744 ++wrote 8192/8192 bytes at offset 4295583744 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295596032 ++wrote 8192/8192 bytes at offset 4295596032 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295608320 ++wrote 8192/8192 bytes at offset 4295608320 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295620608 ++wrote 8192/8192 bytes at offset 4295620608 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295632896 ++wrote 8192/8192 bytes at offset 4295632896 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295645184 ++wrote 8192/8192 bytes at offset 4295645184 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295657472 ++wrote 8192/8192 bytes at offset 4295657472 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 244 +-qemu-io> wrote 12288/12288 bytes at offset 4297058304 ++=== IO: pattern 244 ++wrote 12288/12288 bytes at offset 4297058304 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 4299157504 ++wrote 12288/12288 bytes at offset 4299157504 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 4301256704 ++wrote 12288/12288 bytes at offset 4301256704 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> read 4096/4096 bytes at offset 4294967296 ++=== IO: pattern 0 ++read 4096/4096 bytes at offset 4294967296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294971392 ++read 4096/4096 bytes at offset 4294971392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294975488 ++read 4096/4096 bytes at offset 4294975488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294979584 ++read 4096/4096 bytes at offset 4294979584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294983680 ++read 4096/4096 bytes at offset 4294983680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294987776 ++read 4096/4096 bytes at offset 4294987776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294991872 ++read 4096/4096 bytes at offset 4294991872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294995968 ++read 4096/4096 bytes at offset 4294995968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295000064 ++read 4096/4096 bytes at offset 4295000064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295004160 ++read 4096/4096 bytes at offset 4295004160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295008256 ++read 4096/4096 bytes at offset 4295008256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295012352 ++read 4096/4096 bytes at offset 4295012352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295016448 ++read 4096/4096 bytes at offset 4295016448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295020544 ++read 4096/4096 bytes at offset 4295020544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295024640 ++read 4096/4096 bytes at offset 4295024640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295028736 ++read 4096/4096 bytes at offset 4295028736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295032832 ++read 4096/4096 bytes at offset 4295032832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295036928 ++read 4096/4096 bytes at offset 4295036928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295041024 ++read 4096/4096 bytes at offset 4295041024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295045120 ++read 4096/4096 bytes at offset 4295045120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295049216 ++read 4096/4096 bytes at offset 4295049216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295053312 ++read 4096/4096 bytes at offset 4295053312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295057408 ++read 4096/4096 bytes at offset 4295057408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295061504 ++read 4096/4096 bytes at offset 4295061504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295065600 ++read 4096/4096 bytes at offset 4295065600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295069696 ++read 4096/4096 bytes at offset 4295069696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295073792 ++read 4096/4096 bytes at offset 4295073792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295077888 ++read 4096/4096 bytes at offset 4295077888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295081984 ++read 4096/4096 bytes at offset 4295081984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295086080 ++read 4096/4096 bytes at offset 4295086080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295090176 ++read 4096/4096 bytes at offset 4295090176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295094272 ++read 4096/4096 bytes at offset 4295094272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295098368 ++read 4096/4096 bytes at offset 4295098368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295102464 ++read 4096/4096 bytes at offset 4295102464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295106560 ++read 4096/4096 bytes at offset 4295106560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295110656 ++read 4096/4096 bytes at offset 4295110656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 36 +-qemu-io> read 2048/2048 bytes at offset 4295116800 ++=== IO: pattern 36 ++read 2048/2048 bytes at offset 4295116800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295120896 ++read 2048/2048 bytes at offset 4295120896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295124992 ++read 2048/2048 bytes at offset 4295124992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295129088 ++read 2048/2048 bytes at offset 4295129088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295133184 ++read 2048/2048 bytes at offset 4295133184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295137280 ++read 2048/2048 bytes at offset 4295137280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295141376 ++read 2048/2048 bytes at offset 4295141376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295145472 ++read 2048/2048 bytes at offset 4295145472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295149568 ++read 2048/2048 bytes at offset 4295149568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295153664 ++read 2048/2048 bytes at offset 4295153664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295157760 ++read 2048/2048 bytes at offset 4295157760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295161856 ++read 2048/2048 bytes at offset 4295161856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295165952 ++read 2048/2048 bytes at offset 4295165952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295170048 ++read 2048/2048 bytes at offset 4295170048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295174144 ++read 2048/2048 bytes at offset 4295174144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295178240 ++read 2048/2048 bytes at offset 4295178240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295182336 ++read 2048/2048 bytes at offset 4295182336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295186432 ++read 2048/2048 bytes at offset 4295186432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295190528 ++read 2048/2048 bytes at offset 4295190528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295194624 ++read 2048/2048 bytes at offset 4295194624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295198720 ++read 2048/2048 bytes at offset 4295198720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295202816 ++read 2048/2048 bytes at offset 4295202816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295206912 ++read 2048/2048 bytes at offset 4295206912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295211008 ++read 2048/2048 bytes at offset 4295211008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295215104 ++read 2048/2048 bytes at offset 4295215104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295219200 ++read 2048/2048 bytes at offset 4295219200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295223296 ++read 2048/2048 bytes at offset 4295223296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295227392 ++read 2048/2048 bytes at offset 4295227392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295231488 ++read 2048/2048 bytes at offset 4295231488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295235584 ++read 2048/2048 bytes at offset 4295235584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295239680 ++read 2048/2048 bytes at offset 4295239680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295243776 ++read 2048/2048 bytes at offset 4295243776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295247872 ++read 2048/2048 bytes at offset 4295247872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295251968 ++read 2048/2048 bytes at offset 4295251968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295256064 ++read 2048/2048 bytes at offset 4295256064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295260160 ++read 2048/2048 bytes at offset 4295260160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 64 +-qemu-io> read 2048/2048 bytes at offset 4295262208 ++=== IO: pattern 64 ++read 2048/2048 bytes at offset 4295262208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295266304 ++read 2048/2048 bytes at offset 4295266304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295270400 ++read 2048/2048 bytes at offset 4295270400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295274496 ++read 2048/2048 bytes at offset 4295274496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295278592 ++read 2048/2048 bytes at offset 4295278592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295282688 ++read 2048/2048 bytes at offset 4295282688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295286784 ++read 2048/2048 bytes at offset 4295286784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295290880 ++read 2048/2048 bytes at offset 4295290880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295294976 ++read 2048/2048 bytes at offset 4295294976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295299072 ++read 2048/2048 bytes at offset 4295299072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295303168 ++read 2048/2048 bytes at offset 4295303168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295307264 ++read 2048/2048 bytes at offset 4295307264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295311360 ++read 2048/2048 bytes at offset 4295311360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295315456 ++read 2048/2048 bytes at offset 4295315456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295319552 ++read 2048/2048 bytes at offset 4295319552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295323648 ++read 2048/2048 bytes at offset 4295323648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295327744 ++read 2048/2048 bytes at offset 4295327744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295331840 ++read 2048/2048 bytes at offset 4295331840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295335936 ++read 2048/2048 bytes at offset 4295335936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295340032 ++read 2048/2048 bytes at offset 4295340032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295344128 ++read 2048/2048 bytes at offset 4295344128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295348224 ++read 2048/2048 bytes at offset 4295348224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295352320 ++read 2048/2048 bytes at offset 4295352320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295356416 ++read 2048/2048 bytes at offset 4295356416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295360512 ++read 2048/2048 bytes at offset 4295360512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295364608 ++read 2048/2048 bytes at offset 4295364608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295368704 ++read 2048/2048 bytes at offset 4295368704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295372800 ++read 2048/2048 bytes at offset 4295372800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295376896 ++read 2048/2048 bytes at offset 4295376896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295380992 ++read 2048/2048 bytes at offset 4295380992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295385088 ++read 2048/2048 bytes at offset 4295385088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295389184 ++read 2048/2048 bytes at offset 4295389184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295393280 ++read 2048/2048 bytes at offset 4295393280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295397376 ++read 2048/2048 bytes at offset 4295397376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295401472 ++read 2048/2048 bytes at offset 4295401472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295405568 ++read 2048/2048 bytes at offset 4295405568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 98 +-qemu-io> read 2048/2048 bytes at offset 4295410688 ++=== IO: pattern 98 ++read 2048/2048 bytes at offset 4295410688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295414784 ++read 2048/2048 bytes at offset 4295414784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295418880 ++read 2048/2048 bytes at offset 4295418880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295422976 ++read 2048/2048 bytes at offset 4295422976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295427072 ++read 2048/2048 bytes at offset 4295427072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295431168 ++read 2048/2048 bytes at offset 4295431168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295435264 ++read 2048/2048 bytes at offset 4295435264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295439360 ++read 2048/2048 bytes at offset 4295439360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295443456 ++read 2048/2048 bytes at offset 4295443456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295447552 ++read 2048/2048 bytes at offset 4295447552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295451648 ++read 2048/2048 bytes at offset 4295451648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295455744 ++read 2048/2048 bytes at offset 4295455744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295459840 ++read 2048/2048 bytes at offset 4295459840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295463936 ++read 2048/2048 bytes at offset 4295463936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295468032 ++read 2048/2048 bytes at offset 4295468032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295472128 ++read 2048/2048 bytes at offset 4295472128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295476224 ++read 2048/2048 bytes at offset 4295476224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295480320 ++read 2048/2048 bytes at offset 4295480320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295484416 ++read 2048/2048 bytes at offset 4295484416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295488512 ++read 2048/2048 bytes at offset 4295488512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295492608 ++read 2048/2048 bytes at offset 4295492608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295496704 ++read 2048/2048 bytes at offset 4295496704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295500800 ++read 2048/2048 bytes at offset 4295500800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295504896 ++read 2048/2048 bytes at offset 4295504896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295508992 ++read 2048/2048 bytes at offset 4295508992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295513088 ++read 2048/2048 bytes at offset 4295513088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295517184 ++read 2048/2048 bytes at offset 4295517184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295521280 ++read 2048/2048 bytes at offset 4295521280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295525376 ++read 2048/2048 bytes at offset 4295525376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295529472 ++read 2048/2048 bytes at offset 4295529472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295533568 ++read 2048/2048 bytes at offset 4295533568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295537664 ++read 2048/2048 bytes at offset 4295537664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295541760 ++read 2048/2048 bytes at offset 4295541760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295545856 ++read 2048/2048 bytes at offset 4295545856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295549952 ++read 2048/2048 bytes at offset 4295549952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295554048 ++read 2048/2048 bytes at offset 4295554048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 132 +-qemu-io> read 8192/8192 bytes at offset 4295559168 ++=== IO: pattern 132 ++read 8192/8192 bytes at offset 4295559168 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295571456 ++read 8192/8192 bytes at offset 4295571456 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295583744 ++read 8192/8192 bytes at offset 4295583744 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295596032 ++read 8192/8192 bytes at offset 4295596032 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295608320 ++read 8192/8192 bytes at offset 4295608320 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295620608 ++read 8192/8192 bytes at offset 4295620608 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295632896 ++read 8192/8192 bytes at offset 4295632896 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295645184 ++read 8192/8192 bytes at offset 4295645184 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295657472 ++read 8192/8192 bytes at offset 4295657472 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 244 +-qemu-io> read 12288/12288 bytes at offset 4297058304 ++=== IO: pattern 244 ++read 12288/12288 bytes at offset 4297058304 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4299157504 ++read 12288/12288 bytes at offset 4299157504 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4301256704 ++read 12288/12288 bytes at offset 4301256704 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> No errors were found on the image. ++No errors were found on the image. + Compressing image + + Testing compressed image + + With offset 0: + === IO: pattern 0 +-qemu-io> read 4096/4096 bytes at offset 0 ++read 4096/4096 bytes at offset 0 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4096 ++read 4096/4096 bytes at offset 4096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 8192 ++read 4096/4096 bytes at offset 8192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 12288 ++read 4096/4096 bytes at offset 12288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 16384 ++read 4096/4096 bytes at offset 16384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 20480 ++read 4096/4096 bytes at offset 20480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 24576 ++read 4096/4096 bytes at offset 24576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 28672 ++read 4096/4096 bytes at offset 28672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 32768 ++read 4096/4096 bytes at offset 32768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 36864 ++read 4096/4096 bytes at offset 36864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 40960 ++read 4096/4096 bytes at offset 40960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 45056 ++read 4096/4096 bytes at offset 45056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 49152 ++read 4096/4096 bytes at offset 49152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 53248 ++read 4096/4096 bytes at offset 53248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 57344 ++read 4096/4096 bytes at offset 57344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 61440 ++read 4096/4096 bytes at offset 61440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 65536 ++read 4096/4096 bytes at offset 65536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 69632 ++read 4096/4096 bytes at offset 69632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 73728 ++read 4096/4096 bytes at offset 73728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 77824 ++read 4096/4096 bytes at offset 77824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 81920 ++read 4096/4096 bytes at offset 81920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 86016 ++read 4096/4096 bytes at offset 86016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 90112 ++read 4096/4096 bytes at offset 90112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 94208 ++read 4096/4096 bytes at offset 94208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 98304 ++read 4096/4096 bytes at offset 98304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 102400 ++read 4096/4096 bytes at offset 102400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 106496 ++read 4096/4096 bytes at offset 106496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 110592 ++read 4096/4096 bytes at offset 110592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 114688 ++read 4096/4096 bytes at offset 114688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 118784 ++read 4096/4096 bytes at offset 118784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 122880 ++read 4096/4096 bytes at offset 122880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 126976 ++read 4096/4096 bytes at offset 126976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 131072 ++read 4096/4096 bytes at offset 131072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 135168 ++read 4096/4096 bytes at offset 135168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 139264 ++read 4096/4096 bytes at offset 139264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 143360 ++read 4096/4096 bytes at offset 143360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 36 +-qemu-io> read 2048/2048 bytes at offset 149504 ++=== IO: pattern 36 ++read 2048/2048 bytes at offset 149504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 153600 ++read 2048/2048 bytes at offset 153600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 157696 ++read 2048/2048 bytes at offset 157696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 161792 ++read 2048/2048 bytes at offset 161792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 165888 ++read 2048/2048 bytes at offset 165888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 169984 ++read 2048/2048 bytes at offset 169984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 174080 ++read 2048/2048 bytes at offset 174080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 178176 ++read 2048/2048 bytes at offset 178176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 182272 ++read 2048/2048 bytes at offset 182272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 186368 ++read 2048/2048 bytes at offset 186368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 190464 ++read 2048/2048 bytes at offset 190464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 194560 ++read 2048/2048 bytes at offset 194560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 198656 ++read 2048/2048 bytes at offset 198656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 202752 ++read 2048/2048 bytes at offset 202752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 206848 ++read 2048/2048 bytes at offset 206848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 210944 ++read 2048/2048 bytes at offset 210944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 215040 ++read 2048/2048 bytes at offset 215040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 219136 ++read 2048/2048 bytes at offset 219136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 223232 ++read 2048/2048 bytes at offset 223232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 227328 ++read 2048/2048 bytes at offset 227328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 231424 ++read 2048/2048 bytes at offset 231424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 235520 ++read 2048/2048 bytes at offset 235520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 239616 ++read 2048/2048 bytes at offset 239616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 243712 ++read 2048/2048 bytes at offset 243712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 247808 ++read 2048/2048 bytes at offset 247808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 251904 ++read 2048/2048 bytes at offset 251904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 256000 ++read 2048/2048 bytes at offset 256000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 260096 ++read 2048/2048 bytes at offset 260096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 264192 ++read 2048/2048 bytes at offset 264192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 268288 ++read 2048/2048 bytes at offset 268288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 272384 ++read 2048/2048 bytes at offset 272384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 276480 ++read 2048/2048 bytes at offset 276480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 280576 ++read 2048/2048 bytes at offset 280576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 284672 ++read 2048/2048 bytes at offset 284672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 288768 ++read 2048/2048 bytes at offset 288768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 292864 ++read 2048/2048 bytes at offset 292864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 64 +-qemu-io> read 2048/2048 bytes at offset 294912 ++=== IO: pattern 64 ++read 2048/2048 bytes at offset 294912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 299008 ++read 2048/2048 bytes at offset 299008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 303104 ++read 2048/2048 bytes at offset 303104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 307200 ++read 2048/2048 bytes at offset 307200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 311296 ++read 2048/2048 bytes at offset 311296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 315392 ++read 2048/2048 bytes at offset 315392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 319488 ++read 2048/2048 bytes at offset 319488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 323584 ++read 2048/2048 bytes at offset 323584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 327680 ++read 2048/2048 bytes at offset 327680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 331776 ++read 2048/2048 bytes at offset 331776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 335872 ++read 2048/2048 bytes at offset 335872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 339968 ++read 2048/2048 bytes at offset 339968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 344064 ++read 2048/2048 bytes at offset 344064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 348160 ++read 2048/2048 bytes at offset 348160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 352256 ++read 2048/2048 bytes at offset 352256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 356352 ++read 2048/2048 bytes at offset 356352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 360448 ++read 2048/2048 bytes at offset 360448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 364544 ++read 2048/2048 bytes at offset 364544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 368640 ++read 2048/2048 bytes at offset 368640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 372736 ++read 2048/2048 bytes at offset 372736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 376832 ++read 2048/2048 bytes at offset 376832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 380928 ++read 2048/2048 bytes at offset 380928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 385024 ++read 2048/2048 bytes at offset 385024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 389120 ++read 2048/2048 bytes at offset 389120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 393216 ++read 2048/2048 bytes at offset 393216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 397312 ++read 2048/2048 bytes at offset 397312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 401408 ++read 2048/2048 bytes at offset 401408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 405504 ++read 2048/2048 bytes at offset 405504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 409600 ++read 2048/2048 bytes at offset 409600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 413696 ++read 2048/2048 bytes at offset 413696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 417792 ++read 2048/2048 bytes at offset 417792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 421888 ++read 2048/2048 bytes at offset 421888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 425984 ++read 2048/2048 bytes at offset 425984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 430080 ++read 2048/2048 bytes at offset 430080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 434176 ++read 2048/2048 bytes at offset 434176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 438272 ++read 2048/2048 bytes at offset 438272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 98 +-qemu-io> read 2048/2048 bytes at offset 443392 ++=== IO: pattern 98 ++read 2048/2048 bytes at offset 443392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 447488 ++read 2048/2048 bytes at offset 447488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 451584 ++read 2048/2048 bytes at offset 451584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 455680 ++read 2048/2048 bytes at offset 455680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 459776 ++read 2048/2048 bytes at offset 459776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 463872 ++read 2048/2048 bytes at offset 463872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 467968 ++read 2048/2048 bytes at offset 467968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 472064 ++read 2048/2048 bytes at offset 472064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 476160 ++read 2048/2048 bytes at offset 476160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 480256 ++read 2048/2048 bytes at offset 480256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 484352 ++read 2048/2048 bytes at offset 484352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 488448 ++read 2048/2048 bytes at offset 488448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 492544 ++read 2048/2048 bytes at offset 492544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 496640 ++read 2048/2048 bytes at offset 496640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 500736 ++read 2048/2048 bytes at offset 500736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 504832 ++read 2048/2048 bytes at offset 504832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 508928 ++read 2048/2048 bytes at offset 508928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 513024 ++read 2048/2048 bytes at offset 513024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 517120 ++read 2048/2048 bytes at offset 517120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 521216 ++read 2048/2048 bytes at offset 521216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 525312 ++read 2048/2048 bytes at offset 525312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 529408 ++read 2048/2048 bytes at offset 529408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 533504 ++read 2048/2048 bytes at offset 533504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 537600 ++read 2048/2048 bytes at offset 537600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 541696 ++read 2048/2048 bytes at offset 541696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 545792 ++read 2048/2048 bytes at offset 545792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 549888 ++read 2048/2048 bytes at offset 549888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 553984 ++read 2048/2048 bytes at offset 553984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 558080 ++read 2048/2048 bytes at offset 558080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 562176 ++read 2048/2048 bytes at offset 562176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 566272 ++read 2048/2048 bytes at offset 566272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 570368 ++read 2048/2048 bytes at offset 570368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 574464 ++read 2048/2048 bytes at offset 574464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 578560 ++read 2048/2048 bytes at offset 578560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 582656 ++read 2048/2048 bytes at offset 582656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 586752 ++read 2048/2048 bytes at offset 586752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 132 +-qemu-io> read 8192/8192 bytes at offset 591872 ++=== IO: pattern 132 ++read 8192/8192 bytes at offset 591872 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 604160 ++read 8192/8192 bytes at offset 604160 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 616448 ++read 8192/8192 bytes at offset 616448 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 628736 ++read 8192/8192 bytes at offset 628736 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 641024 ++read 8192/8192 bytes at offset 641024 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 653312 ++read 8192/8192 bytes at offset 653312 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 665600 ++read 8192/8192 bytes at offset 665600 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 677888 ++read 8192/8192 bytes at offset 677888 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 690176 ++read 8192/8192 bytes at offset 690176 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 244 +-qemu-io> read 12288/12288 bytes at offset 2091008 ++=== IO: pattern 244 ++read 12288/12288 bytes at offset 2091008 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4190208 ++read 12288/12288 bytes at offset 4190208 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 6289408 ++read 12288/12288 bytes at offset 6289408 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> read 4096/4096 bytes at offset 0 ++=== IO: pattern 0 ++read 4096/4096 bytes at offset 0 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4096 ++read 4096/4096 bytes at offset 4096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 8192 ++read 4096/4096 bytes at offset 8192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 12288 ++read 4096/4096 bytes at offset 12288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 16384 ++read 4096/4096 bytes at offset 16384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 20480 ++read 4096/4096 bytes at offset 20480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 24576 ++read 4096/4096 bytes at offset 24576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 28672 ++read 4096/4096 bytes at offset 28672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 32768 ++read 4096/4096 bytes at offset 32768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 36864 ++read 4096/4096 bytes at offset 36864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 40960 ++read 4096/4096 bytes at offset 40960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 45056 ++read 4096/4096 bytes at offset 45056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 49152 ++read 4096/4096 bytes at offset 49152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 53248 ++read 4096/4096 bytes at offset 53248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 57344 ++read 4096/4096 bytes at offset 57344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 61440 ++read 4096/4096 bytes at offset 61440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 65536 ++read 4096/4096 bytes at offset 65536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 69632 ++read 4096/4096 bytes at offset 69632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 73728 ++read 4096/4096 bytes at offset 73728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 77824 ++read 4096/4096 bytes at offset 77824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 81920 ++read 4096/4096 bytes at offset 81920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 86016 ++read 4096/4096 bytes at offset 86016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 90112 ++read 4096/4096 bytes at offset 90112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 94208 ++read 4096/4096 bytes at offset 94208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 98304 ++read 4096/4096 bytes at offset 98304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 102400 ++read 4096/4096 bytes at offset 102400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 106496 ++read 4096/4096 bytes at offset 106496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 110592 ++read 4096/4096 bytes at offset 110592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 114688 ++read 4096/4096 bytes at offset 114688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 118784 ++read 4096/4096 bytes at offset 118784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 122880 ++read 4096/4096 bytes at offset 122880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 126976 ++read 4096/4096 bytes at offset 126976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 131072 ++read 4096/4096 bytes at offset 131072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 135168 ++read 4096/4096 bytes at offset 135168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 139264 ++read 4096/4096 bytes at offset 139264 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 143360 ++read 4096/4096 bytes at offset 143360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 36 +-qemu-io> read 2048/2048 bytes at offset 149504 ++=== IO: pattern 36 ++read 2048/2048 bytes at offset 149504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 153600 ++read 2048/2048 bytes at offset 153600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 157696 ++read 2048/2048 bytes at offset 157696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 161792 ++read 2048/2048 bytes at offset 161792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 165888 ++read 2048/2048 bytes at offset 165888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 169984 ++read 2048/2048 bytes at offset 169984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 174080 ++read 2048/2048 bytes at offset 174080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 178176 ++read 2048/2048 bytes at offset 178176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 182272 ++read 2048/2048 bytes at offset 182272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 186368 ++read 2048/2048 bytes at offset 186368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 190464 ++read 2048/2048 bytes at offset 190464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 194560 ++read 2048/2048 bytes at offset 194560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 198656 ++read 2048/2048 bytes at offset 198656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 202752 ++read 2048/2048 bytes at offset 202752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 206848 ++read 2048/2048 bytes at offset 206848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 210944 ++read 2048/2048 bytes at offset 210944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 215040 ++read 2048/2048 bytes at offset 215040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 219136 ++read 2048/2048 bytes at offset 219136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 223232 ++read 2048/2048 bytes at offset 223232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 227328 ++read 2048/2048 bytes at offset 227328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 231424 ++read 2048/2048 bytes at offset 231424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 235520 ++read 2048/2048 bytes at offset 235520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 239616 ++read 2048/2048 bytes at offset 239616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 243712 ++read 2048/2048 bytes at offset 243712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 247808 ++read 2048/2048 bytes at offset 247808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 251904 ++read 2048/2048 bytes at offset 251904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 256000 ++read 2048/2048 bytes at offset 256000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 260096 ++read 2048/2048 bytes at offset 260096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 264192 ++read 2048/2048 bytes at offset 264192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 268288 ++read 2048/2048 bytes at offset 268288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 272384 ++read 2048/2048 bytes at offset 272384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 276480 ++read 2048/2048 bytes at offset 276480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 280576 ++read 2048/2048 bytes at offset 280576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 284672 ++read 2048/2048 bytes at offset 284672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 288768 ++read 2048/2048 bytes at offset 288768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 292864 ++read 2048/2048 bytes at offset 292864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 64 +-qemu-io> read 2048/2048 bytes at offset 294912 ++=== IO: pattern 64 ++read 2048/2048 bytes at offset 294912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 299008 ++read 2048/2048 bytes at offset 299008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 303104 ++read 2048/2048 bytes at offset 303104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 307200 ++read 2048/2048 bytes at offset 307200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 311296 ++read 2048/2048 bytes at offset 311296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 315392 ++read 2048/2048 bytes at offset 315392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 319488 ++read 2048/2048 bytes at offset 319488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 323584 ++read 2048/2048 bytes at offset 323584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 327680 ++read 2048/2048 bytes at offset 327680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 331776 ++read 2048/2048 bytes at offset 331776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 335872 ++read 2048/2048 bytes at offset 335872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 339968 ++read 2048/2048 bytes at offset 339968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 344064 ++read 2048/2048 bytes at offset 344064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 348160 ++read 2048/2048 bytes at offset 348160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 352256 ++read 2048/2048 bytes at offset 352256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 356352 ++read 2048/2048 bytes at offset 356352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 360448 ++read 2048/2048 bytes at offset 360448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 364544 ++read 2048/2048 bytes at offset 364544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 368640 ++read 2048/2048 bytes at offset 368640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 372736 ++read 2048/2048 bytes at offset 372736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 376832 ++read 2048/2048 bytes at offset 376832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 380928 ++read 2048/2048 bytes at offset 380928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 385024 ++read 2048/2048 bytes at offset 385024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 389120 ++read 2048/2048 bytes at offset 389120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 393216 ++read 2048/2048 bytes at offset 393216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 397312 ++read 2048/2048 bytes at offset 397312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 401408 ++read 2048/2048 bytes at offset 401408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 405504 ++read 2048/2048 bytes at offset 405504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 409600 ++read 2048/2048 bytes at offset 409600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 413696 ++read 2048/2048 bytes at offset 413696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 417792 ++read 2048/2048 bytes at offset 417792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 421888 ++read 2048/2048 bytes at offset 421888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 425984 ++read 2048/2048 bytes at offset 425984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 430080 ++read 2048/2048 bytes at offset 430080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 434176 ++read 2048/2048 bytes at offset 434176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 438272 ++read 2048/2048 bytes at offset 438272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 98 +-qemu-io> read 2048/2048 bytes at offset 443392 ++=== IO: pattern 98 ++read 2048/2048 bytes at offset 443392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 447488 ++read 2048/2048 bytes at offset 447488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 451584 ++read 2048/2048 bytes at offset 451584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 455680 ++read 2048/2048 bytes at offset 455680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 459776 ++read 2048/2048 bytes at offset 459776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 463872 ++read 2048/2048 bytes at offset 463872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 467968 ++read 2048/2048 bytes at offset 467968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 472064 ++read 2048/2048 bytes at offset 472064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 476160 ++read 2048/2048 bytes at offset 476160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 480256 ++read 2048/2048 bytes at offset 480256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 484352 ++read 2048/2048 bytes at offset 484352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 488448 ++read 2048/2048 bytes at offset 488448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 492544 ++read 2048/2048 bytes at offset 492544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 496640 ++read 2048/2048 bytes at offset 496640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 500736 ++read 2048/2048 bytes at offset 500736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 504832 ++read 2048/2048 bytes at offset 504832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 508928 ++read 2048/2048 bytes at offset 508928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 513024 ++read 2048/2048 bytes at offset 513024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 517120 ++read 2048/2048 bytes at offset 517120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 521216 ++read 2048/2048 bytes at offset 521216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 525312 ++read 2048/2048 bytes at offset 525312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 529408 ++read 2048/2048 bytes at offset 529408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 533504 ++read 2048/2048 bytes at offset 533504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 537600 ++read 2048/2048 bytes at offset 537600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 541696 ++read 2048/2048 bytes at offset 541696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 545792 ++read 2048/2048 bytes at offset 545792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 549888 ++read 2048/2048 bytes at offset 549888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 553984 ++read 2048/2048 bytes at offset 553984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 558080 ++read 2048/2048 bytes at offset 558080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 562176 ++read 2048/2048 bytes at offset 562176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 566272 ++read 2048/2048 bytes at offset 566272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 570368 ++read 2048/2048 bytes at offset 570368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 574464 ++read 2048/2048 bytes at offset 574464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 578560 ++read 2048/2048 bytes at offset 578560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 582656 ++read 2048/2048 bytes at offset 582656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 586752 ++read 2048/2048 bytes at offset 586752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 132 +-qemu-io> read 8192/8192 bytes at offset 591872 ++=== IO: pattern 132 ++read 8192/8192 bytes at offset 591872 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 604160 ++read 8192/8192 bytes at offset 604160 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 616448 ++read 8192/8192 bytes at offset 616448 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 628736 ++read 8192/8192 bytes at offset 628736 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 641024 ++read 8192/8192 bytes at offset 641024 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 653312 ++read 8192/8192 bytes at offset 653312 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 665600 ++read 8192/8192 bytes at offset 665600 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 677888 ++read 8192/8192 bytes at offset 677888 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 690176 ++read 8192/8192 bytes at offset 690176 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 244 +-qemu-io> read 12288/12288 bytes at offset 2091008 ++=== IO: pattern 244 ++read 12288/12288 bytes at offset 2091008 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4190208 ++read 12288/12288 bytes at offset 4190208 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 6289408 ++read 12288/12288 bytes at offset 6289408 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> No errors were found on the image. ++No errors were found on the image. + With offset 4294967296: + === IO: pattern 0 +-qemu-io> read 4096/4096 bytes at offset 4294967296 ++read 4096/4096 bytes at offset 4294967296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294971392 ++read 4096/4096 bytes at offset 4294971392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294975488 ++read 4096/4096 bytes at offset 4294975488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294979584 ++read 4096/4096 bytes at offset 4294979584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294983680 ++read 4096/4096 bytes at offset 4294983680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294987776 ++read 4096/4096 bytes at offset 4294987776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294991872 ++read 4096/4096 bytes at offset 4294991872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294995968 ++read 4096/4096 bytes at offset 4294995968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295000064 ++read 4096/4096 bytes at offset 4295000064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295004160 ++read 4096/4096 bytes at offset 4295004160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295008256 ++read 4096/4096 bytes at offset 4295008256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295012352 ++read 4096/4096 bytes at offset 4295012352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295016448 ++read 4096/4096 bytes at offset 4295016448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295020544 ++read 4096/4096 bytes at offset 4295020544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295024640 ++read 4096/4096 bytes at offset 4295024640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295028736 ++read 4096/4096 bytes at offset 4295028736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295032832 ++read 4096/4096 bytes at offset 4295032832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295036928 ++read 4096/4096 bytes at offset 4295036928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295041024 ++read 4096/4096 bytes at offset 4295041024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295045120 ++read 4096/4096 bytes at offset 4295045120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295049216 ++read 4096/4096 bytes at offset 4295049216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295053312 ++read 4096/4096 bytes at offset 4295053312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295057408 ++read 4096/4096 bytes at offset 4295057408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295061504 ++read 4096/4096 bytes at offset 4295061504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295065600 ++read 4096/4096 bytes at offset 4295065600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295069696 ++read 4096/4096 bytes at offset 4295069696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295073792 ++read 4096/4096 bytes at offset 4295073792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295077888 ++read 4096/4096 bytes at offset 4295077888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295081984 ++read 4096/4096 bytes at offset 4295081984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295086080 ++read 4096/4096 bytes at offset 4295086080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295090176 ++read 4096/4096 bytes at offset 4295090176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295094272 ++read 4096/4096 bytes at offset 4295094272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295098368 ++read 4096/4096 bytes at offset 4295098368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295102464 ++read 4096/4096 bytes at offset 4295102464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295106560 ++read 4096/4096 bytes at offset 4295106560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295110656 ++read 4096/4096 bytes at offset 4295110656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 36 +-qemu-io> read 2048/2048 bytes at offset 4295116800 ++=== IO: pattern 36 ++read 2048/2048 bytes at offset 4295116800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295120896 ++read 2048/2048 bytes at offset 4295120896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295124992 ++read 2048/2048 bytes at offset 4295124992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295129088 ++read 2048/2048 bytes at offset 4295129088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295133184 ++read 2048/2048 bytes at offset 4295133184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295137280 ++read 2048/2048 bytes at offset 4295137280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295141376 ++read 2048/2048 bytes at offset 4295141376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295145472 ++read 2048/2048 bytes at offset 4295145472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295149568 ++read 2048/2048 bytes at offset 4295149568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295153664 ++read 2048/2048 bytes at offset 4295153664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295157760 ++read 2048/2048 bytes at offset 4295157760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295161856 ++read 2048/2048 bytes at offset 4295161856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295165952 ++read 2048/2048 bytes at offset 4295165952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295170048 ++read 2048/2048 bytes at offset 4295170048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295174144 ++read 2048/2048 bytes at offset 4295174144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295178240 ++read 2048/2048 bytes at offset 4295178240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295182336 ++read 2048/2048 bytes at offset 4295182336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295186432 ++read 2048/2048 bytes at offset 4295186432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295190528 ++read 2048/2048 bytes at offset 4295190528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295194624 ++read 2048/2048 bytes at offset 4295194624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295198720 ++read 2048/2048 bytes at offset 4295198720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295202816 ++read 2048/2048 bytes at offset 4295202816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295206912 ++read 2048/2048 bytes at offset 4295206912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295211008 ++read 2048/2048 bytes at offset 4295211008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295215104 ++read 2048/2048 bytes at offset 4295215104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295219200 ++read 2048/2048 bytes at offset 4295219200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295223296 ++read 2048/2048 bytes at offset 4295223296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295227392 ++read 2048/2048 bytes at offset 4295227392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295231488 ++read 2048/2048 bytes at offset 4295231488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295235584 ++read 2048/2048 bytes at offset 4295235584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295239680 ++read 2048/2048 bytes at offset 4295239680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295243776 ++read 2048/2048 bytes at offset 4295243776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295247872 ++read 2048/2048 bytes at offset 4295247872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295251968 ++read 2048/2048 bytes at offset 4295251968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295256064 ++read 2048/2048 bytes at offset 4295256064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295260160 ++read 2048/2048 bytes at offset 4295260160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 64 +-qemu-io> read 2048/2048 bytes at offset 4295262208 ++=== IO: pattern 64 ++read 2048/2048 bytes at offset 4295262208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295266304 ++read 2048/2048 bytes at offset 4295266304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295270400 ++read 2048/2048 bytes at offset 4295270400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295274496 ++read 2048/2048 bytes at offset 4295274496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295278592 ++read 2048/2048 bytes at offset 4295278592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295282688 ++read 2048/2048 bytes at offset 4295282688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295286784 ++read 2048/2048 bytes at offset 4295286784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295290880 ++read 2048/2048 bytes at offset 4295290880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295294976 ++read 2048/2048 bytes at offset 4295294976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295299072 ++read 2048/2048 bytes at offset 4295299072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295303168 ++read 2048/2048 bytes at offset 4295303168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295307264 ++read 2048/2048 bytes at offset 4295307264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295311360 ++read 2048/2048 bytes at offset 4295311360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295315456 ++read 2048/2048 bytes at offset 4295315456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295319552 ++read 2048/2048 bytes at offset 4295319552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295323648 ++read 2048/2048 bytes at offset 4295323648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295327744 ++read 2048/2048 bytes at offset 4295327744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295331840 ++read 2048/2048 bytes at offset 4295331840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295335936 ++read 2048/2048 bytes at offset 4295335936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295340032 ++read 2048/2048 bytes at offset 4295340032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295344128 ++read 2048/2048 bytes at offset 4295344128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295348224 ++read 2048/2048 bytes at offset 4295348224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295352320 ++read 2048/2048 bytes at offset 4295352320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295356416 ++read 2048/2048 bytes at offset 4295356416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295360512 ++read 2048/2048 bytes at offset 4295360512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295364608 ++read 2048/2048 bytes at offset 4295364608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295368704 ++read 2048/2048 bytes at offset 4295368704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295372800 ++read 2048/2048 bytes at offset 4295372800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295376896 ++read 2048/2048 bytes at offset 4295376896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295380992 ++read 2048/2048 bytes at offset 4295380992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295385088 ++read 2048/2048 bytes at offset 4295385088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295389184 ++read 2048/2048 bytes at offset 4295389184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295393280 ++read 2048/2048 bytes at offset 4295393280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295397376 ++read 2048/2048 bytes at offset 4295397376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295401472 ++read 2048/2048 bytes at offset 4295401472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295405568 ++read 2048/2048 bytes at offset 4295405568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 98 +-qemu-io> read 2048/2048 bytes at offset 4295410688 ++=== IO: pattern 98 ++read 2048/2048 bytes at offset 4295410688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295414784 ++read 2048/2048 bytes at offset 4295414784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295418880 ++read 2048/2048 bytes at offset 4295418880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295422976 ++read 2048/2048 bytes at offset 4295422976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295427072 ++read 2048/2048 bytes at offset 4295427072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295431168 ++read 2048/2048 bytes at offset 4295431168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295435264 ++read 2048/2048 bytes at offset 4295435264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295439360 ++read 2048/2048 bytes at offset 4295439360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295443456 ++read 2048/2048 bytes at offset 4295443456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295447552 ++read 2048/2048 bytes at offset 4295447552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295451648 ++read 2048/2048 bytes at offset 4295451648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295455744 ++read 2048/2048 bytes at offset 4295455744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295459840 ++read 2048/2048 bytes at offset 4295459840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295463936 ++read 2048/2048 bytes at offset 4295463936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295468032 ++read 2048/2048 bytes at offset 4295468032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295472128 ++read 2048/2048 bytes at offset 4295472128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295476224 ++read 2048/2048 bytes at offset 4295476224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295480320 ++read 2048/2048 bytes at offset 4295480320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295484416 ++read 2048/2048 bytes at offset 4295484416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295488512 ++read 2048/2048 bytes at offset 4295488512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295492608 ++read 2048/2048 bytes at offset 4295492608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295496704 ++read 2048/2048 bytes at offset 4295496704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295500800 ++read 2048/2048 bytes at offset 4295500800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295504896 ++read 2048/2048 bytes at offset 4295504896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295508992 ++read 2048/2048 bytes at offset 4295508992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295513088 ++read 2048/2048 bytes at offset 4295513088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295517184 ++read 2048/2048 bytes at offset 4295517184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295521280 ++read 2048/2048 bytes at offset 4295521280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295525376 ++read 2048/2048 bytes at offset 4295525376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295529472 ++read 2048/2048 bytes at offset 4295529472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295533568 ++read 2048/2048 bytes at offset 4295533568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295537664 ++read 2048/2048 bytes at offset 4295537664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295541760 ++read 2048/2048 bytes at offset 4295541760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295545856 ++read 2048/2048 bytes at offset 4295545856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295549952 ++read 2048/2048 bytes at offset 4295549952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295554048 ++read 2048/2048 bytes at offset 4295554048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 132 +-qemu-io> read 8192/8192 bytes at offset 4295559168 ++=== IO: pattern 132 ++read 8192/8192 bytes at offset 4295559168 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295571456 ++read 8192/8192 bytes at offset 4295571456 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295583744 ++read 8192/8192 bytes at offset 4295583744 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295596032 ++read 8192/8192 bytes at offset 4295596032 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295608320 ++read 8192/8192 bytes at offset 4295608320 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295620608 ++read 8192/8192 bytes at offset 4295620608 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295632896 ++read 8192/8192 bytes at offset 4295632896 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295645184 ++read 8192/8192 bytes at offset 4295645184 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295657472 ++read 8192/8192 bytes at offset 4295657472 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 244 +-qemu-io> read 12288/12288 bytes at offset 4297058304 ++=== IO: pattern 244 ++read 12288/12288 bytes at offset 4297058304 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4299157504 ++read 12288/12288 bytes at offset 4299157504 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4301256704 ++read 12288/12288 bytes at offset 4301256704 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> read 4096/4096 bytes at offset 4294967296 ++=== IO: pattern 0 ++read 4096/4096 bytes at offset 4294967296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294971392 ++read 4096/4096 bytes at offset 4294971392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294975488 ++read 4096/4096 bytes at offset 4294975488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294979584 ++read 4096/4096 bytes at offset 4294979584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294983680 ++read 4096/4096 bytes at offset 4294983680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294987776 ++read 4096/4096 bytes at offset 4294987776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294991872 ++read 4096/4096 bytes at offset 4294991872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294995968 ++read 4096/4096 bytes at offset 4294995968 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295000064 ++read 4096/4096 bytes at offset 4295000064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295004160 ++read 4096/4096 bytes at offset 4295004160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295008256 ++read 4096/4096 bytes at offset 4295008256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295012352 ++read 4096/4096 bytes at offset 4295012352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295016448 ++read 4096/4096 bytes at offset 4295016448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295020544 ++read 4096/4096 bytes at offset 4295020544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295024640 ++read 4096/4096 bytes at offset 4295024640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295028736 ++read 4096/4096 bytes at offset 4295028736 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295032832 ++read 4096/4096 bytes at offset 4295032832 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295036928 ++read 4096/4096 bytes at offset 4295036928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295041024 ++read 4096/4096 bytes at offset 4295041024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295045120 ++read 4096/4096 bytes at offset 4295045120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295049216 ++read 4096/4096 bytes at offset 4295049216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295053312 ++read 4096/4096 bytes at offset 4295053312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295057408 ++read 4096/4096 bytes at offset 4295057408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295061504 ++read 4096/4096 bytes at offset 4295061504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295065600 ++read 4096/4096 bytes at offset 4295065600 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295069696 ++read 4096/4096 bytes at offset 4295069696 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295073792 ++read 4096/4096 bytes at offset 4295073792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295077888 ++read 4096/4096 bytes at offset 4295077888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295081984 ++read 4096/4096 bytes at offset 4295081984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295086080 ++read 4096/4096 bytes at offset 4295086080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295090176 ++read 4096/4096 bytes at offset 4295090176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295094272 ++read 4096/4096 bytes at offset 4295094272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295098368 ++read 4096/4096 bytes at offset 4295098368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295102464 ++read 4096/4096 bytes at offset 4295102464 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295106560 ++read 4096/4096 bytes at offset 4295106560 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295110656 ++read 4096/4096 bytes at offset 4295110656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 36 +-qemu-io> read 2048/2048 bytes at offset 4295116800 ++=== IO: pattern 36 ++read 2048/2048 bytes at offset 4295116800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295120896 ++read 2048/2048 bytes at offset 4295120896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295124992 ++read 2048/2048 bytes at offset 4295124992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295129088 ++read 2048/2048 bytes at offset 4295129088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295133184 ++read 2048/2048 bytes at offset 4295133184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295137280 ++read 2048/2048 bytes at offset 4295137280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295141376 ++read 2048/2048 bytes at offset 4295141376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295145472 ++read 2048/2048 bytes at offset 4295145472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295149568 ++read 2048/2048 bytes at offset 4295149568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295153664 ++read 2048/2048 bytes at offset 4295153664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295157760 ++read 2048/2048 bytes at offset 4295157760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295161856 ++read 2048/2048 bytes at offset 4295161856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295165952 ++read 2048/2048 bytes at offset 4295165952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295170048 ++read 2048/2048 bytes at offset 4295170048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295174144 ++read 2048/2048 bytes at offset 4295174144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295178240 ++read 2048/2048 bytes at offset 4295178240 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295182336 ++read 2048/2048 bytes at offset 4295182336 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295186432 ++read 2048/2048 bytes at offset 4295186432 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295190528 ++read 2048/2048 bytes at offset 4295190528 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295194624 ++read 2048/2048 bytes at offset 4295194624 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295198720 ++read 2048/2048 bytes at offset 4295198720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295202816 ++read 2048/2048 bytes at offset 4295202816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295206912 ++read 2048/2048 bytes at offset 4295206912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295211008 ++read 2048/2048 bytes at offset 4295211008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295215104 ++read 2048/2048 bytes at offset 4295215104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295219200 ++read 2048/2048 bytes at offset 4295219200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295223296 ++read 2048/2048 bytes at offset 4295223296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295227392 ++read 2048/2048 bytes at offset 4295227392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295231488 ++read 2048/2048 bytes at offset 4295231488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295235584 ++read 2048/2048 bytes at offset 4295235584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295239680 ++read 2048/2048 bytes at offset 4295239680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295243776 ++read 2048/2048 bytes at offset 4295243776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295247872 ++read 2048/2048 bytes at offset 4295247872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295251968 ++read 2048/2048 bytes at offset 4295251968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295256064 ++read 2048/2048 bytes at offset 4295256064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295260160 ++read 2048/2048 bytes at offset 4295260160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 64 +-qemu-io> read 2048/2048 bytes at offset 4295262208 ++=== IO: pattern 64 ++read 2048/2048 bytes at offset 4295262208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295266304 ++read 2048/2048 bytes at offset 4295266304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295270400 ++read 2048/2048 bytes at offset 4295270400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295274496 ++read 2048/2048 bytes at offset 4295274496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295278592 ++read 2048/2048 bytes at offset 4295278592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295282688 ++read 2048/2048 bytes at offset 4295282688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295286784 ++read 2048/2048 bytes at offset 4295286784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295290880 ++read 2048/2048 bytes at offset 4295290880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295294976 ++read 2048/2048 bytes at offset 4295294976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295299072 ++read 2048/2048 bytes at offset 4295299072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295303168 ++read 2048/2048 bytes at offset 4295303168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295307264 ++read 2048/2048 bytes at offset 4295307264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295311360 ++read 2048/2048 bytes at offset 4295311360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295315456 ++read 2048/2048 bytes at offset 4295315456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295319552 ++read 2048/2048 bytes at offset 4295319552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295323648 ++read 2048/2048 bytes at offset 4295323648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295327744 ++read 2048/2048 bytes at offset 4295327744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295331840 ++read 2048/2048 bytes at offset 4295331840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295335936 ++read 2048/2048 bytes at offset 4295335936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295340032 ++read 2048/2048 bytes at offset 4295340032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295344128 ++read 2048/2048 bytes at offset 4295344128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295348224 ++read 2048/2048 bytes at offset 4295348224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295352320 ++read 2048/2048 bytes at offset 4295352320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295356416 ++read 2048/2048 bytes at offset 4295356416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295360512 ++read 2048/2048 bytes at offset 4295360512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295364608 ++read 2048/2048 bytes at offset 4295364608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295368704 ++read 2048/2048 bytes at offset 4295368704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295372800 ++read 2048/2048 bytes at offset 4295372800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295376896 ++read 2048/2048 bytes at offset 4295376896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295380992 ++read 2048/2048 bytes at offset 4295380992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295385088 ++read 2048/2048 bytes at offset 4295385088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295389184 ++read 2048/2048 bytes at offset 4295389184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295393280 ++read 2048/2048 bytes at offset 4295393280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295397376 ++read 2048/2048 bytes at offset 4295397376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295401472 ++read 2048/2048 bytes at offset 4295401472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295405568 ++read 2048/2048 bytes at offset 4295405568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 98 +-qemu-io> read 2048/2048 bytes at offset 4295410688 ++=== IO: pattern 98 ++read 2048/2048 bytes at offset 4295410688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295414784 ++read 2048/2048 bytes at offset 4295414784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295418880 ++read 2048/2048 bytes at offset 4295418880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295422976 ++read 2048/2048 bytes at offset 4295422976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295427072 ++read 2048/2048 bytes at offset 4295427072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295431168 ++read 2048/2048 bytes at offset 4295431168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295435264 ++read 2048/2048 bytes at offset 4295435264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295439360 ++read 2048/2048 bytes at offset 4295439360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295443456 ++read 2048/2048 bytes at offset 4295443456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295447552 ++read 2048/2048 bytes at offset 4295447552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295451648 ++read 2048/2048 bytes at offset 4295451648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295455744 ++read 2048/2048 bytes at offset 4295455744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295459840 ++read 2048/2048 bytes at offset 4295459840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295463936 ++read 2048/2048 bytes at offset 4295463936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295468032 ++read 2048/2048 bytes at offset 4295468032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295472128 ++read 2048/2048 bytes at offset 4295472128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295476224 ++read 2048/2048 bytes at offset 4295476224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295480320 ++read 2048/2048 bytes at offset 4295480320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295484416 ++read 2048/2048 bytes at offset 4295484416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295488512 ++read 2048/2048 bytes at offset 4295488512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295492608 ++read 2048/2048 bytes at offset 4295492608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295496704 ++read 2048/2048 bytes at offset 4295496704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295500800 ++read 2048/2048 bytes at offset 4295500800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295504896 ++read 2048/2048 bytes at offset 4295504896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295508992 ++read 2048/2048 bytes at offset 4295508992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295513088 ++read 2048/2048 bytes at offset 4295513088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295517184 ++read 2048/2048 bytes at offset 4295517184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295521280 ++read 2048/2048 bytes at offset 4295521280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295525376 ++read 2048/2048 bytes at offset 4295525376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295529472 ++read 2048/2048 bytes at offset 4295529472 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295533568 ++read 2048/2048 bytes at offset 4295533568 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295537664 ++read 2048/2048 bytes at offset 4295537664 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295541760 ++read 2048/2048 bytes at offset 4295541760 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295545856 ++read 2048/2048 bytes at offset 4295545856 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295549952 ++read 2048/2048 bytes at offset 4295549952 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295554048 ++read 2048/2048 bytes at offset 4295554048 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 132 +-qemu-io> read 8192/8192 bytes at offset 4295559168 ++=== IO: pattern 132 ++read 8192/8192 bytes at offset 4295559168 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295571456 ++read 8192/8192 bytes at offset 4295571456 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295583744 ++read 8192/8192 bytes at offset 4295583744 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295596032 ++read 8192/8192 bytes at offset 4295596032 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295608320 ++read 8192/8192 bytes at offset 4295608320 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295620608 ++read 8192/8192 bytes at offset 4295620608 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295632896 ++read 8192/8192 bytes at offset 4295632896 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295645184 ++read 8192/8192 bytes at offset 4295645184 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295657472 ++read 8192/8192 bytes at offset 4295657472 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 244 +-qemu-io> read 12288/12288 bytes at offset 4297058304 ++=== IO: pattern 244 ++read 12288/12288 bytes at offset 4297058304 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4299157504 ++read 12288/12288 bytes at offset 4299157504 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4301256704 ++read 12288/12288 bytes at offset 4301256704 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> No errors were found on the image. ++No errors were found on the image. + Testing compressed image with odd offsets + + With offset 512: + === IO: pattern 1 +-qemu-io> wrote 4096/4096 bytes at offset 512 ++wrote 4096/4096 bytes at offset 512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4608 ++wrote 4096/4096 bytes at offset 4608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8704 ++wrote 4096/4096 bytes at offset 8704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 12800 ++wrote 4096/4096 bytes at offset 12800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 16896 ++wrote 4096/4096 bytes at offset 16896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 20992 ++wrote 4096/4096 bytes at offset 20992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 25088 ++wrote 4096/4096 bytes at offset 25088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 29184 ++wrote 4096/4096 bytes at offset 29184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 33280 ++wrote 4096/4096 bytes at offset 33280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 37376 ++wrote 4096/4096 bytes at offset 37376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 41472 ++wrote 4096/4096 bytes at offset 41472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 45568 ++wrote 4096/4096 bytes at offset 45568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 49664 ++wrote 4096/4096 bytes at offset 49664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 53760 ++wrote 4096/4096 bytes at offset 53760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 57856 ++wrote 4096/4096 bytes at offset 57856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 61952 ++wrote 4096/4096 bytes at offset 61952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 66048 ++wrote 4096/4096 bytes at offset 66048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 70144 ++wrote 4096/4096 bytes at offset 70144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 74240 ++wrote 4096/4096 bytes at offset 74240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 78336 ++wrote 4096/4096 bytes at offset 78336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 82432 ++wrote 4096/4096 bytes at offset 82432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 86528 ++wrote 4096/4096 bytes at offset 86528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 90624 ++wrote 4096/4096 bytes at offset 90624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 94720 ++wrote 4096/4096 bytes at offset 94720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 98816 ++wrote 4096/4096 bytes at offset 98816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 102912 ++wrote 4096/4096 bytes at offset 102912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 107008 ++wrote 4096/4096 bytes at offset 107008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 111104 ++wrote 4096/4096 bytes at offset 111104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 115200 ++wrote 4096/4096 bytes at offset 115200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 119296 ++wrote 4096/4096 bytes at offset 119296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 123392 ++wrote 4096/4096 bytes at offset 123392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 127488 ++wrote 4096/4096 bytes at offset 127488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 131584 ++wrote 4096/4096 bytes at offset 131584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 135680 ++wrote 4096/4096 bytes at offset 135680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 139776 ++wrote 4096/4096 bytes at offset 139776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 143872 ++wrote 4096/4096 bytes at offset 143872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 37 +-qemu-io> wrote 2048/2048 bytes at offset 150016 ++=== IO: pattern 37 ++wrote 2048/2048 bytes at offset 150016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 154112 ++wrote 2048/2048 bytes at offset 154112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 158208 ++wrote 2048/2048 bytes at offset 158208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 162304 ++wrote 2048/2048 bytes at offset 162304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 166400 ++wrote 2048/2048 bytes at offset 166400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 170496 ++wrote 2048/2048 bytes at offset 170496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 174592 ++wrote 2048/2048 bytes at offset 174592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 178688 ++wrote 2048/2048 bytes at offset 178688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 182784 ++wrote 2048/2048 bytes at offset 182784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 186880 ++wrote 2048/2048 bytes at offset 186880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 190976 ++wrote 2048/2048 bytes at offset 190976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 195072 ++wrote 2048/2048 bytes at offset 195072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 199168 ++wrote 2048/2048 bytes at offset 199168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 203264 ++wrote 2048/2048 bytes at offset 203264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 207360 ++wrote 2048/2048 bytes at offset 207360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 211456 ++wrote 2048/2048 bytes at offset 211456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 215552 ++wrote 2048/2048 bytes at offset 215552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 219648 ++wrote 2048/2048 bytes at offset 219648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 223744 ++wrote 2048/2048 bytes at offset 223744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 227840 ++wrote 2048/2048 bytes at offset 227840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 231936 ++wrote 2048/2048 bytes at offset 231936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 236032 ++wrote 2048/2048 bytes at offset 236032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 240128 ++wrote 2048/2048 bytes at offset 240128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 244224 ++wrote 2048/2048 bytes at offset 244224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 248320 ++wrote 2048/2048 bytes at offset 248320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 252416 ++wrote 2048/2048 bytes at offset 252416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 256512 ++wrote 2048/2048 bytes at offset 256512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 260608 ++wrote 2048/2048 bytes at offset 260608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 264704 ++wrote 2048/2048 bytes at offset 264704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 268800 ++wrote 2048/2048 bytes at offset 268800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 272896 ++wrote 2048/2048 bytes at offset 272896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 276992 ++wrote 2048/2048 bytes at offset 276992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 281088 ++wrote 2048/2048 bytes at offset 281088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 285184 ++wrote 2048/2048 bytes at offset 285184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 289280 ++wrote 2048/2048 bytes at offset 289280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 293376 ++wrote 2048/2048 bytes at offset 293376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 65 +-qemu-io> wrote 2048/2048 bytes at offset 295424 ++=== IO: pattern 65 ++wrote 2048/2048 bytes at offset 295424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 299520 ++wrote 2048/2048 bytes at offset 299520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 303616 ++wrote 2048/2048 bytes at offset 303616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 307712 ++wrote 2048/2048 bytes at offset 307712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 311808 ++wrote 2048/2048 bytes at offset 311808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 315904 ++wrote 2048/2048 bytes at offset 315904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 320000 ++wrote 2048/2048 bytes at offset 320000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 324096 ++wrote 2048/2048 bytes at offset 324096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 328192 ++wrote 2048/2048 bytes at offset 328192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 332288 ++wrote 2048/2048 bytes at offset 332288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 336384 ++wrote 2048/2048 bytes at offset 336384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 340480 ++wrote 2048/2048 bytes at offset 340480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 344576 ++wrote 2048/2048 bytes at offset 344576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 348672 ++wrote 2048/2048 bytes at offset 348672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 352768 ++wrote 2048/2048 bytes at offset 352768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 356864 ++wrote 2048/2048 bytes at offset 356864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 360960 ++wrote 2048/2048 bytes at offset 360960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 365056 ++wrote 2048/2048 bytes at offset 365056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 369152 ++wrote 2048/2048 bytes at offset 369152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 373248 ++wrote 2048/2048 bytes at offset 373248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 377344 ++wrote 2048/2048 bytes at offset 377344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 381440 ++wrote 2048/2048 bytes at offset 381440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 385536 ++wrote 2048/2048 bytes at offset 385536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 389632 ++wrote 2048/2048 bytes at offset 389632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 393728 ++wrote 2048/2048 bytes at offset 393728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 397824 ++wrote 2048/2048 bytes at offset 397824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 401920 ++wrote 2048/2048 bytes at offset 401920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 406016 ++wrote 2048/2048 bytes at offset 406016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 410112 ++wrote 2048/2048 bytes at offset 410112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 414208 ++wrote 2048/2048 bytes at offset 414208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 418304 ++wrote 2048/2048 bytes at offset 418304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 422400 ++wrote 2048/2048 bytes at offset 422400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 426496 ++wrote 2048/2048 bytes at offset 426496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 430592 ++wrote 2048/2048 bytes at offset 430592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 434688 ++wrote 2048/2048 bytes at offset 434688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 438784 ++wrote 2048/2048 bytes at offset 438784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 99 +-qemu-io> wrote 2048/2048 bytes at offset 443904 ++=== IO: pattern 99 ++wrote 2048/2048 bytes at offset 443904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 448000 ++wrote 2048/2048 bytes at offset 448000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 452096 ++wrote 2048/2048 bytes at offset 452096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 456192 ++wrote 2048/2048 bytes at offset 456192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 460288 ++wrote 2048/2048 bytes at offset 460288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 464384 ++wrote 2048/2048 bytes at offset 464384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 468480 ++wrote 2048/2048 bytes at offset 468480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 472576 ++wrote 2048/2048 bytes at offset 472576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 476672 ++wrote 2048/2048 bytes at offset 476672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 480768 ++wrote 2048/2048 bytes at offset 480768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 484864 ++wrote 2048/2048 bytes at offset 484864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 488960 ++wrote 2048/2048 bytes at offset 488960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 493056 ++wrote 2048/2048 bytes at offset 493056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 497152 ++wrote 2048/2048 bytes at offset 497152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 501248 ++wrote 2048/2048 bytes at offset 501248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 505344 ++wrote 2048/2048 bytes at offset 505344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 509440 ++wrote 2048/2048 bytes at offset 509440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 513536 ++wrote 2048/2048 bytes at offset 513536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 517632 ++wrote 2048/2048 bytes at offset 517632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 521728 ++wrote 2048/2048 bytes at offset 521728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 525824 ++wrote 2048/2048 bytes at offset 525824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 529920 ++wrote 2048/2048 bytes at offset 529920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 534016 ++wrote 2048/2048 bytes at offset 534016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 538112 ++wrote 2048/2048 bytes at offset 538112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 542208 ++wrote 2048/2048 bytes at offset 542208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 546304 ++wrote 2048/2048 bytes at offset 546304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 550400 ++wrote 2048/2048 bytes at offset 550400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 554496 ++wrote 2048/2048 bytes at offset 554496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 558592 ++wrote 2048/2048 bytes at offset 558592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 562688 ++wrote 2048/2048 bytes at offset 562688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 566784 ++wrote 2048/2048 bytes at offset 566784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 570880 ++wrote 2048/2048 bytes at offset 570880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 574976 ++wrote 2048/2048 bytes at offset 574976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 579072 ++wrote 2048/2048 bytes at offset 579072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 583168 ++wrote 2048/2048 bytes at offset 583168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 587264 ++wrote 2048/2048 bytes at offset 587264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 133 +-qemu-io> wrote 8192/8192 bytes at offset 592384 ++=== IO: pattern 133 ++wrote 8192/8192 bytes at offset 592384 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 604672 ++wrote 8192/8192 bytes at offset 604672 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 616960 ++wrote 8192/8192 bytes at offset 616960 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 629248 ++wrote 8192/8192 bytes at offset 629248 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 641536 ++wrote 8192/8192 bytes at offset 641536 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 653824 ++wrote 8192/8192 bytes at offset 653824 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 666112 ++wrote 8192/8192 bytes at offset 666112 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 678400 ++wrote 8192/8192 bytes at offset 678400 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 690688 ++wrote 8192/8192 bytes at offset 690688 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 244 +-qemu-io> wrote 12288/12288 bytes at offset 2091008 ++=== IO: pattern 244 ++wrote 12288/12288 bytes at offset 2091008 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 4190208 ++wrote 12288/12288 bytes at offset 4190208 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 6289408 ++wrote 12288/12288 bytes at offset 6289408 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 1 +-qemu-io> read 4096/4096 bytes at offset 512 ++=== IO: pattern 1 ++read 4096/4096 bytes at offset 512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4608 ++read 4096/4096 bytes at offset 4608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 8704 ++read 4096/4096 bytes at offset 8704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 12800 ++read 4096/4096 bytes at offset 12800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 16896 ++read 4096/4096 bytes at offset 16896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 20992 ++read 4096/4096 bytes at offset 20992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 25088 ++read 4096/4096 bytes at offset 25088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 29184 ++read 4096/4096 bytes at offset 29184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 33280 ++read 4096/4096 bytes at offset 33280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 37376 ++read 4096/4096 bytes at offset 37376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 41472 ++read 4096/4096 bytes at offset 41472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 45568 ++read 4096/4096 bytes at offset 45568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 49664 ++read 4096/4096 bytes at offset 49664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 53760 ++read 4096/4096 bytes at offset 53760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 57856 ++read 4096/4096 bytes at offset 57856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 61952 ++read 4096/4096 bytes at offset 61952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 66048 ++read 4096/4096 bytes at offset 66048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 70144 ++read 4096/4096 bytes at offset 70144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 74240 ++read 4096/4096 bytes at offset 74240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 78336 ++read 4096/4096 bytes at offset 78336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 82432 ++read 4096/4096 bytes at offset 82432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 86528 ++read 4096/4096 bytes at offset 86528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 90624 ++read 4096/4096 bytes at offset 90624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 94720 ++read 4096/4096 bytes at offset 94720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 98816 ++read 4096/4096 bytes at offset 98816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 102912 ++read 4096/4096 bytes at offset 102912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 107008 ++read 4096/4096 bytes at offset 107008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 111104 ++read 4096/4096 bytes at offset 111104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 115200 ++read 4096/4096 bytes at offset 115200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 119296 ++read 4096/4096 bytes at offset 119296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 123392 ++read 4096/4096 bytes at offset 123392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 127488 ++read 4096/4096 bytes at offset 127488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 131584 ++read 4096/4096 bytes at offset 131584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 135680 ++read 4096/4096 bytes at offset 135680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 139776 ++read 4096/4096 bytes at offset 139776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 143872 ++read 4096/4096 bytes at offset 143872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 37 +-qemu-io> read 2048/2048 bytes at offset 150016 ++=== IO: pattern 37 ++read 2048/2048 bytes at offset 150016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 154112 ++read 2048/2048 bytes at offset 154112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 158208 ++read 2048/2048 bytes at offset 158208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 162304 ++read 2048/2048 bytes at offset 162304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 166400 ++read 2048/2048 bytes at offset 166400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 170496 ++read 2048/2048 bytes at offset 170496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 174592 ++read 2048/2048 bytes at offset 174592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 178688 ++read 2048/2048 bytes at offset 178688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 182784 ++read 2048/2048 bytes at offset 182784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 186880 ++read 2048/2048 bytes at offset 186880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 190976 ++read 2048/2048 bytes at offset 190976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 195072 ++read 2048/2048 bytes at offset 195072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 199168 ++read 2048/2048 bytes at offset 199168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 203264 ++read 2048/2048 bytes at offset 203264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 207360 ++read 2048/2048 bytes at offset 207360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 211456 ++read 2048/2048 bytes at offset 211456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 215552 ++read 2048/2048 bytes at offset 215552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 219648 ++read 2048/2048 bytes at offset 219648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 223744 ++read 2048/2048 bytes at offset 223744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 227840 ++read 2048/2048 bytes at offset 227840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 231936 ++read 2048/2048 bytes at offset 231936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 236032 ++read 2048/2048 bytes at offset 236032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 240128 ++read 2048/2048 bytes at offset 240128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 244224 ++read 2048/2048 bytes at offset 244224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 248320 ++read 2048/2048 bytes at offset 248320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 252416 ++read 2048/2048 bytes at offset 252416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 256512 ++read 2048/2048 bytes at offset 256512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 260608 ++read 2048/2048 bytes at offset 260608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 264704 ++read 2048/2048 bytes at offset 264704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 268800 ++read 2048/2048 bytes at offset 268800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 272896 ++read 2048/2048 bytes at offset 272896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 276992 ++read 2048/2048 bytes at offset 276992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 281088 ++read 2048/2048 bytes at offset 281088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 285184 ++read 2048/2048 bytes at offset 285184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 289280 ++read 2048/2048 bytes at offset 289280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 293376 ++read 2048/2048 bytes at offset 293376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 65 +-qemu-io> read 2048/2048 bytes at offset 295424 ++=== IO: pattern 65 ++read 2048/2048 bytes at offset 295424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 299520 ++read 2048/2048 bytes at offset 299520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 303616 ++read 2048/2048 bytes at offset 303616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 307712 ++read 2048/2048 bytes at offset 307712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 311808 ++read 2048/2048 bytes at offset 311808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 315904 ++read 2048/2048 bytes at offset 315904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 320000 ++read 2048/2048 bytes at offset 320000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 324096 ++read 2048/2048 bytes at offset 324096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 328192 ++read 2048/2048 bytes at offset 328192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 332288 ++read 2048/2048 bytes at offset 332288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 336384 ++read 2048/2048 bytes at offset 336384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 340480 ++read 2048/2048 bytes at offset 340480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 344576 ++read 2048/2048 bytes at offset 344576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 348672 ++read 2048/2048 bytes at offset 348672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 352768 ++read 2048/2048 bytes at offset 352768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 356864 ++read 2048/2048 bytes at offset 356864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 360960 ++read 2048/2048 bytes at offset 360960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 365056 ++read 2048/2048 bytes at offset 365056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 369152 ++read 2048/2048 bytes at offset 369152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 373248 ++read 2048/2048 bytes at offset 373248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 377344 ++read 2048/2048 bytes at offset 377344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 381440 ++read 2048/2048 bytes at offset 381440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 385536 ++read 2048/2048 bytes at offset 385536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 389632 ++read 2048/2048 bytes at offset 389632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 393728 ++read 2048/2048 bytes at offset 393728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 397824 ++read 2048/2048 bytes at offset 397824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 401920 ++read 2048/2048 bytes at offset 401920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 406016 ++read 2048/2048 bytes at offset 406016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 410112 ++read 2048/2048 bytes at offset 410112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 414208 ++read 2048/2048 bytes at offset 414208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 418304 ++read 2048/2048 bytes at offset 418304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 422400 ++read 2048/2048 bytes at offset 422400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 426496 ++read 2048/2048 bytes at offset 426496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 430592 ++read 2048/2048 bytes at offset 430592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 434688 ++read 2048/2048 bytes at offset 434688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 438784 ++read 2048/2048 bytes at offset 438784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 99 +-qemu-io> read 2048/2048 bytes at offset 443904 ++=== IO: pattern 99 ++read 2048/2048 bytes at offset 443904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 448000 ++read 2048/2048 bytes at offset 448000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 452096 ++read 2048/2048 bytes at offset 452096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 456192 ++read 2048/2048 bytes at offset 456192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 460288 ++read 2048/2048 bytes at offset 460288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 464384 ++read 2048/2048 bytes at offset 464384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 468480 ++read 2048/2048 bytes at offset 468480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 472576 ++read 2048/2048 bytes at offset 472576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 476672 ++read 2048/2048 bytes at offset 476672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 480768 ++read 2048/2048 bytes at offset 480768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 484864 ++read 2048/2048 bytes at offset 484864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 488960 ++read 2048/2048 bytes at offset 488960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 493056 ++read 2048/2048 bytes at offset 493056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 497152 ++read 2048/2048 bytes at offset 497152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 501248 ++read 2048/2048 bytes at offset 501248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 505344 ++read 2048/2048 bytes at offset 505344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 509440 ++read 2048/2048 bytes at offset 509440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 513536 ++read 2048/2048 bytes at offset 513536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 517632 ++read 2048/2048 bytes at offset 517632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 521728 ++read 2048/2048 bytes at offset 521728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 525824 ++read 2048/2048 bytes at offset 525824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 529920 ++read 2048/2048 bytes at offset 529920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 534016 ++read 2048/2048 bytes at offset 534016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 538112 ++read 2048/2048 bytes at offset 538112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 542208 ++read 2048/2048 bytes at offset 542208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 546304 ++read 2048/2048 bytes at offset 546304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 550400 ++read 2048/2048 bytes at offset 550400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 554496 ++read 2048/2048 bytes at offset 554496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 558592 ++read 2048/2048 bytes at offset 558592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 562688 ++read 2048/2048 bytes at offset 562688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 566784 ++read 2048/2048 bytes at offset 566784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 570880 ++read 2048/2048 bytes at offset 570880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 574976 ++read 2048/2048 bytes at offset 574976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 579072 ++read 2048/2048 bytes at offset 579072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 583168 ++read 2048/2048 bytes at offset 583168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 587264 ++read 2048/2048 bytes at offset 587264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 133 +-qemu-io> read 8192/8192 bytes at offset 592384 ++=== IO: pattern 133 ++read 8192/8192 bytes at offset 592384 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 604672 ++read 8192/8192 bytes at offset 604672 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 616960 ++read 8192/8192 bytes at offset 616960 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 629248 ++read 8192/8192 bytes at offset 629248 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 641536 ++read 8192/8192 bytes at offset 641536 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 653824 ++read 8192/8192 bytes at offset 653824 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 666112 ++read 8192/8192 bytes at offset 666112 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 678400 ++read 8192/8192 bytes at offset 678400 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 690688 ++read 8192/8192 bytes at offset 690688 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 244 +-qemu-io> read 12288/12288 bytes at offset 2091008 ++=== IO: pattern 244 ++read 12288/12288 bytes at offset 2091008 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4190208 ++read 12288/12288 bytes at offset 4190208 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 6289408 ++read 12288/12288 bytes at offset 6289408 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 1 +-qemu-io> wrote 4096/4096 bytes at offset 512 ++=== IO: pattern 1 ++wrote 4096/4096 bytes at offset 512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4608 ++wrote 4096/4096 bytes at offset 4608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 8704 ++wrote 4096/4096 bytes at offset 8704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 12800 ++wrote 4096/4096 bytes at offset 12800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 16896 ++wrote 4096/4096 bytes at offset 16896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 20992 ++wrote 4096/4096 bytes at offset 20992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 25088 ++wrote 4096/4096 bytes at offset 25088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 29184 ++wrote 4096/4096 bytes at offset 29184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 33280 ++wrote 4096/4096 bytes at offset 33280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 37376 ++wrote 4096/4096 bytes at offset 37376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 41472 ++wrote 4096/4096 bytes at offset 41472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 45568 ++wrote 4096/4096 bytes at offset 45568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 49664 ++wrote 4096/4096 bytes at offset 49664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 53760 ++wrote 4096/4096 bytes at offset 53760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 57856 ++wrote 4096/4096 bytes at offset 57856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 61952 ++wrote 4096/4096 bytes at offset 61952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 66048 ++wrote 4096/4096 bytes at offset 66048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 70144 ++wrote 4096/4096 bytes at offset 70144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 74240 ++wrote 4096/4096 bytes at offset 74240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 78336 ++wrote 4096/4096 bytes at offset 78336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 82432 ++wrote 4096/4096 bytes at offset 82432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 86528 ++wrote 4096/4096 bytes at offset 86528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 90624 ++wrote 4096/4096 bytes at offset 90624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 94720 ++wrote 4096/4096 bytes at offset 94720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 98816 ++wrote 4096/4096 bytes at offset 98816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 102912 ++wrote 4096/4096 bytes at offset 102912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 107008 ++wrote 4096/4096 bytes at offset 107008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 111104 ++wrote 4096/4096 bytes at offset 111104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 115200 ++wrote 4096/4096 bytes at offset 115200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 119296 ++wrote 4096/4096 bytes at offset 119296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 123392 ++wrote 4096/4096 bytes at offset 123392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 127488 ++wrote 4096/4096 bytes at offset 127488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 131584 ++wrote 4096/4096 bytes at offset 131584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 135680 ++wrote 4096/4096 bytes at offset 135680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 139776 ++wrote 4096/4096 bytes at offset 139776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 143872 ++wrote 4096/4096 bytes at offset 143872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 37 +-qemu-io> wrote 2048/2048 bytes at offset 150016 ++=== IO: pattern 37 ++wrote 2048/2048 bytes at offset 150016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 154112 ++wrote 2048/2048 bytes at offset 154112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 158208 ++wrote 2048/2048 bytes at offset 158208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 162304 ++wrote 2048/2048 bytes at offset 162304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 166400 ++wrote 2048/2048 bytes at offset 166400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 170496 ++wrote 2048/2048 bytes at offset 170496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 174592 ++wrote 2048/2048 bytes at offset 174592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 178688 ++wrote 2048/2048 bytes at offset 178688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 182784 ++wrote 2048/2048 bytes at offset 182784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 186880 ++wrote 2048/2048 bytes at offset 186880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 190976 ++wrote 2048/2048 bytes at offset 190976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 195072 ++wrote 2048/2048 bytes at offset 195072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 199168 ++wrote 2048/2048 bytes at offset 199168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 203264 ++wrote 2048/2048 bytes at offset 203264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 207360 ++wrote 2048/2048 bytes at offset 207360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 211456 ++wrote 2048/2048 bytes at offset 211456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 215552 ++wrote 2048/2048 bytes at offset 215552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 219648 ++wrote 2048/2048 bytes at offset 219648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 223744 ++wrote 2048/2048 bytes at offset 223744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 227840 ++wrote 2048/2048 bytes at offset 227840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 231936 ++wrote 2048/2048 bytes at offset 231936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 236032 ++wrote 2048/2048 bytes at offset 236032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 240128 ++wrote 2048/2048 bytes at offset 240128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 244224 ++wrote 2048/2048 bytes at offset 244224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 248320 ++wrote 2048/2048 bytes at offset 248320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 252416 ++wrote 2048/2048 bytes at offset 252416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 256512 ++wrote 2048/2048 bytes at offset 256512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 260608 ++wrote 2048/2048 bytes at offset 260608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 264704 ++wrote 2048/2048 bytes at offset 264704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 268800 ++wrote 2048/2048 bytes at offset 268800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 272896 ++wrote 2048/2048 bytes at offset 272896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 276992 ++wrote 2048/2048 bytes at offset 276992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 281088 ++wrote 2048/2048 bytes at offset 281088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 285184 ++wrote 2048/2048 bytes at offset 285184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 289280 ++wrote 2048/2048 bytes at offset 289280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 293376 ++wrote 2048/2048 bytes at offset 293376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 65 +-qemu-io> wrote 2048/2048 bytes at offset 295424 ++=== IO: pattern 65 ++wrote 2048/2048 bytes at offset 295424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 299520 ++wrote 2048/2048 bytes at offset 299520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 303616 ++wrote 2048/2048 bytes at offset 303616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 307712 ++wrote 2048/2048 bytes at offset 307712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 311808 ++wrote 2048/2048 bytes at offset 311808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 315904 ++wrote 2048/2048 bytes at offset 315904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 320000 ++wrote 2048/2048 bytes at offset 320000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 324096 ++wrote 2048/2048 bytes at offset 324096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 328192 ++wrote 2048/2048 bytes at offset 328192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 332288 ++wrote 2048/2048 bytes at offset 332288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 336384 ++wrote 2048/2048 bytes at offset 336384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 340480 ++wrote 2048/2048 bytes at offset 340480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 344576 ++wrote 2048/2048 bytes at offset 344576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 348672 ++wrote 2048/2048 bytes at offset 348672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 352768 ++wrote 2048/2048 bytes at offset 352768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 356864 ++wrote 2048/2048 bytes at offset 356864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 360960 ++wrote 2048/2048 bytes at offset 360960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 365056 ++wrote 2048/2048 bytes at offset 365056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 369152 ++wrote 2048/2048 bytes at offset 369152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 373248 ++wrote 2048/2048 bytes at offset 373248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 377344 ++wrote 2048/2048 bytes at offset 377344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 381440 ++wrote 2048/2048 bytes at offset 381440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 385536 ++wrote 2048/2048 bytes at offset 385536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 389632 ++wrote 2048/2048 bytes at offset 389632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 393728 ++wrote 2048/2048 bytes at offset 393728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 397824 ++wrote 2048/2048 bytes at offset 397824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 401920 ++wrote 2048/2048 bytes at offset 401920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 406016 ++wrote 2048/2048 bytes at offset 406016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 410112 ++wrote 2048/2048 bytes at offset 410112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 414208 ++wrote 2048/2048 bytes at offset 414208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 418304 ++wrote 2048/2048 bytes at offset 418304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 422400 ++wrote 2048/2048 bytes at offset 422400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 426496 ++wrote 2048/2048 bytes at offset 426496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 430592 ++wrote 2048/2048 bytes at offset 430592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 434688 ++wrote 2048/2048 bytes at offset 434688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 438784 ++wrote 2048/2048 bytes at offset 438784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 99 +-qemu-io> wrote 2048/2048 bytes at offset 443904 ++=== IO: pattern 99 ++wrote 2048/2048 bytes at offset 443904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 448000 ++wrote 2048/2048 bytes at offset 448000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 452096 ++wrote 2048/2048 bytes at offset 452096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 456192 ++wrote 2048/2048 bytes at offset 456192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 460288 ++wrote 2048/2048 bytes at offset 460288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 464384 ++wrote 2048/2048 bytes at offset 464384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 468480 ++wrote 2048/2048 bytes at offset 468480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 472576 ++wrote 2048/2048 bytes at offset 472576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 476672 ++wrote 2048/2048 bytes at offset 476672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 480768 ++wrote 2048/2048 bytes at offset 480768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 484864 ++wrote 2048/2048 bytes at offset 484864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 488960 ++wrote 2048/2048 bytes at offset 488960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 493056 ++wrote 2048/2048 bytes at offset 493056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 497152 ++wrote 2048/2048 bytes at offset 497152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 501248 ++wrote 2048/2048 bytes at offset 501248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 505344 ++wrote 2048/2048 bytes at offset 505344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 509440 ++wrote 2048/2048 bytes at offset 509440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 513536 ++wrote 2048/2048 bytes at offset 513536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 517632 ++wrote 2048/2048 bytes at offset 517632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 521728 ++wrote 2048/2048 bytes at offset 521728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 525824 ++wrote 2048/2048 bytes at offset 525824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 529920 ++wrote 2048/2048 bytes at offset 529920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 534016 ++wrote 2048/2048 bytes at offset 534016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 538112 ++wrote 2048/2048 bytes at offset 538112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 542208 ++wrote 2048/2048 bytes at offset 542208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 546304 ++wrote 2048/2048 bytes at offset 546304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 550400 ++wrote 2048/2048 bytes at offset 550400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 554496 ++wrote 2048/2048 bytes at offset 554496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 558592 ++wrote 2048/2048 bytes at offset 558592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 562688 ++wrote 2048/2048 bytes at offset 562688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 566784 ++wrote 2048/2048 bytes at offset 566784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 570880 ++wrote 2048/2048 bytes at offset 570880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 574976 ++wrote 2048/2048 bytes at offset 574976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 579072 ++wrote 2048/2048 bytes at offset 579072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 583168 ++wrote 2048/2048 bytes at offset 583168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 587264 ++wrote 2048/2048 bytes at offset 587264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 133 +-qemu-io> wrote 8192/8192 bytes at offset 592384 ++=== IO: pattern 133 ++wrote 8192/8192 bytes at offset 592384 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 604672 ++wrote 8192/8192 bytes at offset 604672 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 616960 ++wrote 8192/8192 bytes at offset 616960 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 629248 ++wrote 8192/8192 bytes at offset 629248 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 641536 ++wrote 8192/8192 bytes at offset 641536 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 653824 ++wrote 8192/8192 bytes at offset 653824 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 666112 ++wrote 8192/8192 bytes at offset 666112 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 678400 ++wrote 8192/8192 bytes at offset 678400 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 690688 ++wrote 8192/8192 bytes at offset 690688 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 244 +-qemu-io> wrote 12288/12288 bytes at offset 2091008 ++=== IO: pattern 244 ++wrote 12288/12288 bytes at offset 2091008 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 4190208 ++wrote 12288/12288 bytes at offset 4190208 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 6289408 ++wrote 12288/12288 bytes at offset 6289408 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 1 +-qemu-io> read 4096/4096 bytes at offset 512 ++=== IO: pattern 1 ++read 4096/4096 bytes at offset 512 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4608 ++read 4096/4096 bytes at offset 4608 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 8704 ++read 4096/4096 bytes at offset 8704 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 12800 ++read 4096/4096 bytes at offset 12800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 16896 ++read 4096/4096 bytes at offset 16896 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 20992 ++read 4096/4096 bytes at offset 20992 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 25088 ++read 4096/4096 bytes at offset 25088 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 29184 ++read 4096/4096 bytes at offset 29184 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 33280 ++read 4096/4096 bytes at offset 33280 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 37376 ++read 4096/4096 bytes at offset 37376 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 41472 ++read 4096/4096 bytes at offset 41472 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 45568 ++read 4096/4096 bytes at offset 45568 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 49664 ++read 4096/4096 bytes at offset 49664 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 53760 ++read 4096/4096 bytes at offset 53760 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 57856 ++read 4096/4096 bytes at offset 57856 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 61952 ++read 4096/4096 bytes at offset 61952 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 66048 ++read 4096/4096 bytes at offset 66048 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 70144 ++read 4096/4096 bytes at offset 70144 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 74240 ++read 4096/4096 bytes at offset 74240 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 78336 ++read 4096/4096 bytes at offset 78336 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 82432 ++read 4096/4096 bytes at offset 82432 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 86528 ++read 4096/4096 bytes at offset 86528 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 90624 ++read 4096/4096 bytes at offset 90624 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 94720 ++read 4096/4096 bytes at offset 94720 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 98816 ++read 4096/4096 bytes at offset 98816 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 102912 ++read 4096/4096 bytes at offset 102912 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 107008 ++read 4096/4096 bytes at offset 107008 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 111104 ++read 4096/4096 bytes at offset 111104 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 115200 ++read 4096/4096 bytes at offset 115200 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 119296 ++read 4096/4096 bytes at offset 119296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 123392 ++read 4096/4096 bytes at offset 123392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 127488 ++read 4096/4096 bytes at offset 127488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 131584 ++read 4096/4096 bytes at offset 131584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 135680 ++read 4096/4096 bytes at offset 135680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 139776 ++read 4096/4096 bytes at offset 139776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 143872 ++read 4096/4096 bytes at offset 143872 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 37 +-qemu-io> read 2048/2048 bytes at offset 150016 ++=== IO: pattern 37 ++read 2048/2048 bytes at offset 150016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 154112 ++read 2048/2048 bytes at offset 154112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 158208 ++read 2048/2048 bytes at offset 158208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 162304 ++read 2048/2048 bytes at offset 162304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 166400 ++read 2048/2048 bytes at offset 166400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 170496 ++read 2048/2048 bytes at offset 170496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 174592 ++read 2048/2048 bytes at offset 174592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 178688 ++read 2048/2048 bytes at offset 178688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 182784 ++read 2048/2048 bytes at offset 182784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 186880 ++read 2048/2048 bytes at offset 186880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 190976 ++read 2048/2048 bytes at offset 190976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 195072 ++read 2048/2048 bytes at offset 195072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 199168 ++read 2048/2048 bytes at offset 199168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 203264 ++read 2048/2048 bytes at offset 203264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 207360 ++read 2048/2048 bytes at offset 207360 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 211456 ++read 2048/2048 bytes at offset 211456 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 215552 ++read 2048/2048 bytes at offset 215552 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 219648 ++read 2048/2048 bytes at offset 219648 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 223744 ++read 2048/2048 bytes at offset 223744 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 227840 ++read 2048/2048 bytes at offset 227840 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 231936 ++read 2048/2048 bytes at offset 231936 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 236032 ++read 2048/2048 bytes at offset 236032 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 240128 ++read 2048/2048 bytes at offset 240128 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 244224 ++read 2048/2048 bytes at offset 244224 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 248320 ++read 2048/2048 bytes at offset 248320 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 252416 ++read 2048/2048 bytes at offset 252416 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 256512 ++read 2048/2048 bytes at offset 256512 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 260608 ++read 2048/2048 bytes at offset 260608 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 264704 ++read 2048/2048 bytes at offset 264704 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 268800 ++read 2048/2048 bytes at offset 268800 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 272896 ++read 2048/2048 bytes at offset 272896 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 276992 ++read 2048/2048 bytes at offset 276992 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 281088 ++read 2048/2048 bytes at offset 281088 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 285184 ++read 2048/2048 bytes at offset 285184 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 289280 ++read 2048/2048 bytes at offset 289280 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 293376 ++read 2048/2048 bytes at offset 293376 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 65 +-qemu-io> read 2048/2048 bytes at offset 295424 ++=== IO: pattern 65 ++read 2048/2048 bytes at offset 295424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 299520 ++read 2048/2048 bytes at offset 299520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 303616 ++read 2048/2048 bytes at offset 303616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 307712 ++read 2048/2048 bytes at offset 307712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 311808 ++read 2048/2048 bytes at offset 311808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 315904 ++read 2048/2048 bytes at offset 315904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 320000 ++read 2048/2048 bytes at offset 320000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 324096 ++read 2048/2048 bytes at offset 324096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 328192 ++read 2048/2048 bytes at offset 328192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 332288 ++read 2048/2048 bytes at offset 332288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 336384 ++read 2048/2048 bytes at offset 336384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 340480 ++read 2048/2048 bytes at offset 340480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 344576 ++read 2048/2048 bytes at offset 344576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 348672 ++read 2048/2048 bytes at offset 348672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 352768 ++read 2048/2048 bytes at offset 352768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 356864 ++read 2048/2048 bytes at offset 356864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 360960 ++read 2048/2048 bytes at offset 360960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 365056 ++read 2048/2048 bytes at offset 365056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 369152 ++read 2048/2048 bytes at offset 369152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 373248 ++read 2048/2048 bytes at offset 373248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 377344 ++read 2048/2048 bytes at offset 377344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 381440 ++read 2048/2048 bytes at offset 381440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 385536 ++read 2048/2048 bytes at offset 385536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 389632 ++read 2048/2048 bytes at offset 389632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 393728 ++read 2048/2048 bytes at offset 393728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 397824 ++read 2048/2048 bytes at offset 397824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 401920 ++read 2048/2048 bytes at offset 401920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 406016 ++read 2048/2048 bytes at offset 406016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 410112 ++read 2048/2048 bytes at offset 410112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 414208 ++read 2048/2048 bytes at offset 414208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 418304 ++read 2048/2048 bytes at offset 418304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 422400 ++read 2048/2048 bytes at offset 422400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 426496 ++read 2048/2048 bytes at offset 426496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 430592 ++read 2048/2048 bytes at offset 430592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 434688 ++read 2048/2048 bytes at offset 434688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 438784 ++read 2048/2048 bytes at offset 438784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 99 +-qemu-io> read 2048/2048 bytes at offset 443904 ++=== IO: pattern 99 ++read 2048/2048 bytes at offset 443904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 448000 ++read 2048/2048 bytes at offset 448000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 452096 ++read 2048/2048 bytes at offset 452096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 456192 ++read 2048/2048 bytes at offset 456192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 460288 ++read 2048/2048 bytes at offset 460288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 464384 ++read 2048/2048 bytes at offset 464384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 468480 ++read 2048/2048 bytes at offset 468480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 472576 ++read 2048/2048 bytes at offset 472576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 476672 ++read 2048/2048 bytes at offset 476672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 480768 ++read 2048/2048 bytes at offset 480768 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 484864 ++read 2048/2048 bytes at offset 484864 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 488960 ++read 2048/2048 bytes at offset 488960 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 493056 ++read 2048/2048 bytes at offset 493056 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 497152 ++read 2048/2048 bytes at offset 497152 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 501248 ++read 2048/2048 bytes at offset 501248 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 505344 ++read 2048/2048 bytes at offset 505344 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 509440 ++read 2048/2048 bytes at offset 509440 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 513536 ++read 2048/2048 bytes at offset 513536 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 517632 ++read 2048/2048 bytes at offset 517632 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 521728 ++read 2048/2048 bytes at offset 521728 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 525824 ++read 2048/2048 bytes at offset 525824 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 529920 ++read 2048/2048 bytes at offset 529920 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 534016 ++read 2048/2048 bytes at offset 534016 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 538112 ++read 2048/2048 bytes at offset 538112 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 542208 ++read 2048/2048 bytes at offset 542208 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 546304 ++read 2048/2048 bytes at offset 546304 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 550400 ++read 2048/2048 bytes at offset 550400 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 554496 ++read 2048/2048 bytes at offset 554496 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 558592 ++read 2048/2048 bytes at offset 558592 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 562688 ++read 2048/2048 bytes at offset 562688 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 566784 ++read 2048/2048 bytes at offset 566784 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 570880 ++read 2048/2048 bytes at offset 570880 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 574976 ++read 2048/2048 bytes at offset 574976 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 579072 ++read 2048/2048 bytes at offset 579072 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 583168 ++read 2048/2048 bytes at offset 583168 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 587264 ++read 2048/2048 bytes at offset 587264 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 133 +-qemu-io> read 8192/8192 bytes at offset 592384 ++=== IO: pattern 133 ++read 8192/8192 bytes at offset 592384 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 604672 ++read 8192/8192 bytes at offset 604672 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 616960 ++read 8192/8192 bytes at offset 616960 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 629248 ++read 8192/8192 bytes at offset 629248 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 641536 ++read 8192/8192 bytes at offset 641536 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 653824 ++read 8192/8192 bytes at offset 653824 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 666112 ++read 8192/8192 bytes at offset 666112 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 678400 ++read 8192/8192 bytes at offset 678400 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 690688 ++read 8192/8192 bytes at offset 690688 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 244 +-qemu-io> read 12288/12288 bytes at offset 2091008 ++=== IO: pattern 244 ++read 12288/12288 bytes at offset 2091008 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4190208 ++read 12288/12288 bytes at offset 4190208 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 6289408 ++read 12288/12288 bytes at offset 6289408 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> No errors were found on the image. ++No errors were found on the image. + With offset 4294967808: + === IO: pattern 1 +-qemu-io> wrote 4096/4096 bytes at offset 4294967808 ++wrote 4096/4096 bytes at offset 4294967808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4294971904 ++wrote 4096/4096 bytes at offset 4294971904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4294976000 ++wrote 4096/4096 bytes at offset 4294976000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4294980096 ++wrote 4096/4096 bytes at offset 4294980096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4294984192 ++wrote 4096/4096 bytes at offset 4294984192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4294988288 ++wrote 4096/4096 bytes at offset 4294988288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4294992384 ++wrote 4096/4096 bytes at offset 4294992384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4294996480 ++wrote 4096/4096 bytes at offset 4294996480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295000576 ++wrote 4096/4096 bytes at offset 4295000576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295004672 ++wrote 4096/4096 bytes at offset 4295004672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295008768 ++wrote 4096/4096 bytes at offset 4295008768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295012864 ++wrote 4096/4096 bytes at offset 4295012864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295016960 ++wrote 4096/4096 bytes at offset 4295016960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295021056 ++wrote 4096/4096 bytes at offset 4295021056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295025152 ++wrote 4096/4096 bytes at offset 4295025152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295029248 ++wrote 4096/4096 bytes at offset 4295029248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295033344 ++wrote 4096/4096 bytes at offset 4295033344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295037440 ++wrote 4096/4096 bytes at offset 4295037440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295041536 ++wrote 4096/4096 bytes at offset 4295041536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295045632 ++wrote 4096/4096 bytes at offset 4295045632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295049728 ++wrote 4096/4096 bytes at offset 4295049728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295053824 ++wrote 4096/4096 bytes at offset 4295053824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295057920 ++wrote 4096/4096 bytes at offset 4295057920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295062016 ++wrote 4096/4096 bytes at offset 4295062016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295066112 ++wrote 4096/4096 bytes at offset 4295066112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295070208 ++wrote 4096/4096 bytes at offset 4295070208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295074304 ++wrote 4096/4096 bytes at offset 4295074304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295078400 ++wrote 4096/4096 bytes at offset 4295078400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295082496 ++wrote 4096/4096 bytes at offset 4295082496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295086592 ++wrote 4096/4096 bytes at offset 4295086592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295090688 ++wrote 4096/4096 bytes at offset 4295090688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295094784 ++wrote 4096/4096 bytes at offset 4295094784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295098880 ++wrote 4096/4096 bytes at offset 4295098880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295102976 ++wrote 4096/4096 bytes at offset 4295102976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295107072 ++wrote 4096/4096 bytes at offset 4295107072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295111168 ++wrote 4096/4096 bytes at offset 4295111168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 37 +-qemu-io> wrote 2048/2048 bytes at offset 4295117312 ++=== IO: pattern 37 ++wrote 2048/2048 bytes at offset 4295117312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295121408 ++wrote 2048/2048 bytes at offset 4295121408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295125504 ++wrote 2048/2048 bytes at offset 4295125504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295129600 ++wrote 2048/2048 bytes at offset 4295129600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295133696 ++wrote 2048/2048 bytes at offset 4295133696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295137792 ++wrote 2048/2048 bytes at offset 4295137792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295141888 ++wrote 2048/2048 bytes at offset 4295141888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295145984 ++wrote 2048/2048 bytes at offset 4295145984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295150080 ++wrote 2048/2048 bytes at offset 4295150080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295154176 ++wrote 2048/2048 bytes at offset 4295154176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295158272 ++wrote 2048/2048 bytes at offset 4295158272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295162368 ++wrote 2048/2048 bytes at offset 4295162368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295166464 ++wrote 2048/2048 bytes at offset 4295166464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295170560 ++wrote 2048/2048 bytes at offset 4295170560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295174656 ++wrote 2048/2048 bytes at offset 4295174656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295178752 ++wrote 2048/2048 bytes at offset 4295178752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295182848 ++wrote 2048/2048 bytes at offset 4295182848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295186944 ++wrote 2048/2048 bytes at offset 4295186944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295191040 ++wrote 2048/2048 bytes at offset 4295191040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295195136 ++wrote 2048/2048 bytes at offset 4295195136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295199232 ++wrote 2048/2048 bytes at offset 4295199232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295203328 ++wrote 2048/2048 bytes at offset 4295203328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295207424 ++wrote 2048/2048 bytes at offset 4295207424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295211520 ++wrote 2048/2048 bytes at offset 4295211520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295215616 ++wrote 2048/2048 bytes at offset 4295215616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295219712 ++wrote 2048/2048 bytes at offset 4295219712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295223808 ++wrote 2048/2048 bytes at offset 4295223808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295227904 ++wrote 2048/2048 bytes at offset 4295227904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295232000 ++wrote 2048/2048 bytes at offset 4295232000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295236096 ++wrote 2048/2048 bytes at offset 4295236096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295240192 ++wrote 2048/2048 bytes at offset 4295240192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295244288 ++wrote 2048/2048 bytes at offset 4295244288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295248384 ++wrote 2048/2048 bytes at offset 4295248384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295252480 ++wrote 2048/2048 bytes at offset 4295252480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295256576 ++wrote 2048/2048 bytes at offset 4295256576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295260672 ++wrote 2048/2048 bytes at offset 4295260672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 65 +-qemu-io> wrote 2048/2048 bytes at offset 4295262720 ++=== IO: pattern 65 ++wrote 2048/2048 bytes at offset 4295262720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295266816 ++wrote 2048/2048 bytes at offset 4295266816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295270912 ++wrote 2048/2048 bytes at offset 4295270912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295275008 ++wrote 2048/2048 bytes at offset 4295275008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295279104 ++wrote 2048/2048 bytes at offset 4295279104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295283200 ++wrote 2048/2048 bytes at offset 4295283200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295287296 ++wrote 2048/2048 bytes at offset 4295287296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295291392 ++wrote 2048/2048 bytes at offset 4295291392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295295488 ++wrote 2048/2048 bytes at offset 4295295488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295299584 ++wrote 2048/2048 bytes at offset 4295299584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295303680 ++wrote 2048/2048 bytes at offset 4295303680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295307776 ++wrote 2048/2048 bytes at offset 4295307776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295311872 ++wrote 2048/2048 bytes at offset 4295311872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295315968 ++wrote 2048/2048 bytes at offset 4295315968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295320064 ++wrote 2048/2048 bytes at offset 4295320064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295324160 ++wrote 2048/2048 bytes at offset 4295324160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295328256 ++wrote 2048/2048 bytes at offset 4295328256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295332352 ++wrote 2048/2048 bytes at offset 4295332352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295336448 ++wrote 2048/2048 bytes at offset 4295336448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295340544 ++wrote 2048/2048 bytes at offset 4295340544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295344640 ++wrote 2048/2048 bytes at offset 4295344640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295348736 ++wrote 2048/2048 bytes at offset 4295348736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295352832 ++wrote 2048/2048 bytes at offset 4295352832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295356928 ++wrote 2048/2048 bytes at offset 4295356928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295361024 ++wrote 2048/2048 bytes at offset 4295361024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295365120 ++wrote 2048/2048 bytes at offset 4295365120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295369216 ++wrote 2048/2048 bytes at offset 4295369216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295373312 ++wrote 2048/2048 bytes at offset 4295373312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295377408 ++wrote 2048/2048 bytes at offset 4295377408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295381504 ++wrote 2048/2048 bytes at offset 4295381504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295385600 ++wrote 2048/2048 bytes at offset 4295385600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295389696 ++wrote 2048/2048 bytes at offset 4295389696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295393792 ++wrote 2048/2048 bytes at offset 4295393792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295397888 ++wrote 2048/2048 bytes at offset 4295397888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295401984 ++wrote 2048/2048 bytes at offset 4295401984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295406080 ++wrote 2048/2048 bytes at offset 4295406080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 99 +-qemu-io> wrote 2048/2048 bytes at offset 4295411200 ++=== IO: pattern 99 ++wrote 2048/2048 bytes at offset 4295411200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295415296 ++wrote 2048/2048 bytes at offset 4295415296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295419392 ++wrote 2048/2048 bytes at offset 4295419392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295423488 ++wrote 2048/2048 bytes at offset 4295423488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295427584 ++wrote 2048/2048 bytes at offset 4295427584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295431680 ++wrote 2048/2048 bytes at offset 4295431680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295435776 ++wrote 2048/2048 bytes at offset 4295435776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295439872 ++wrote 2048/2048 bytes at offset 4295439872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295443968 ++wrote 2048/2048 bytes at offset 4295443968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295448064 ++wrote 2048/2048 bytes at offset 4295448064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295452160 ++wrote 2048/2048 bytes at offset 4295452160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295456256 ++wrote 2048/2048 bytes at offset 4295456256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295460352 ++wrote 2048/2048 bytes at offset 4295460352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295464448 ++wrote 2048/2048 bytes at offset 4295464448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295468544 ++wrote 2048/2048 bytes at offset 4295468544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295472640 ++wrote 2048/2048 bytes at offset 4295472640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295476736 ++wrote 2048/2048 bytes at offset 4295476736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295480832 ++wrote 2048/2048 bytes at offset 4295480832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295484928 ++wrote 2048/2048 bytes at offset 4295484928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295489024 ++wrote 2048/2048 bytes at offset 4295489024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295493120 ++wrote 2048/2048 bytes at offset 4295493120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295497216 ++wrote 2048/2048 bytes at offset 4295497216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295501312 ++wrote 2048/2048 bytes at offset 4295501312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295505408 ++wrote 2048/2048 bytes at offset 4295505408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295509504 ++wrote 2048/2048 bytes at offset 4295509504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295513600 ++wrote 2048/2048 bytes at offset 4295513600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295517696 ++wrote 2048/2048 bytes at offset 4295517696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295521792 ++wrote 2048/2048 bytes at offset 4295521792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295525888 ++wrote 2048/2048 bytes at offset 4295525888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295529984 ++wrote 2048/2048 bytes at offset 4295529984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295534080 ++wrote 2048/2048 bytes at offset 4295534080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295538176 ++wrote 2048/2048 bytes at offset 4295538176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295542272 ++wrote 2048/2048 bytes at offset 4295542272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295546368 ++wrote 2048/2048 bytes at offset 4295546368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295550464 ++wrote 2048/2048 bytes at offset 4295550464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295554560 ++wrote 2048/2048 bytes at offset 4295554560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 133 +-qemu-io> wrote 8192/8192 bytes at offset 4295559680 ++=== IO: pattern 133 ++wrote 8192/8192 bytes at offset 4295559680 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295571968 ++wrote 8192/8192 bytes at offset 4295571968 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295584256 ++wrote 8192/8192 bytes at offset 4295584256 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295596544 ++wrote 8192/8192 bytes at offset 4295596544 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295608832 ++wrote 8192/8192 bytes at offset 4295608832 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295621120 ++wrote 8192/8192 bytes at offset 4295621120 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295633408 ++wrote 8192/8192 bytes at offset 4295633408 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295645696 ++wrote 8192/8192 bytes at offset 4295645696 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295657984 ++wrote 8192/8192 bytes at offset 4295657984 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 244 +-qemu-io> wrote 12288/12288 bytes at offset 4297058304 ++=== IO: pattern 244 ++wrote 12288/12288 bytes at offset 4297058304 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 4299157504 ++wrote 12288/12288 bytes at offset 4299157504 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 4301256704 ++wrote 12288/12288 bytes at offset 4301256704 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 1 +-qemu-io> read 4096/4096 bytes at offset 4294967808 ++=== IO: pattern 1 ++read 4096/4096 bytes at offset 4294967808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294971904 ++read 4096/4096 bytes at offset 4294971904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294976000 ++read 4096/4096 bytes at offset 4294976000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294980096 ++read 4096/4096 bytes at offset 4294980096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294984192 ++read 4096/4096 bytes at offset 4294984192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294988288 ++read 4096/4096 bytes at offset 4294988288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294992384 ++read 4096/4096 bytes at offset 4294992384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294996480 ++read 4096/4096 bytes at offset 4294996480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295000576 ++read 4096/4096 bytes at offset 4295000576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295004672 ++read 4096/4096 bytes at offset 4295004672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295008768 ++read 4096/4096 bytes at offset 4295008768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295012864 ++read 4096/4096 bytes at offset 4295012864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295016960 ++read 4096/4096 bytes at offset 4295016960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295021056 ++read 4096/4096 bytes at offset 4295021056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295025152 ++read 4096/4096 bytes at offset 4295025152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295029248 ++read 4096/4096 bytes at offset 4295029248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295033344 ++read 4096/4096 bytes at offset 4295033344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295037440 ++read 4096/4096 bytes at offset 4295037440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295041536 ++read 4096/4096 bytes at offset 4295041536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295045632 ++read 4096/4096 bytes at offset 4295045632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295049728 ++read 4096/4096 bytes at offset 4295049728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295053824 ++read 4096/4096 bytes at offset 4295053824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295057920 ++read 4096/4096 bytes at offset 4295057920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295062016 ++read 4096/4096 bytes at offset 4295062016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295066112 ++read 4096/4096 bytes at offset 4295066112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295070208 ++read 4096/4096 bytes at offset 4295070208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295074304 ++read 4096/4096 bytes at offset 4295074304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295078400 ++read 4096/4096 bytes at offset 4295078400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295082496 ++read 4096/4096 bytes at offset 4295082496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295086592 ++read 4096/4096 bytes at offset 4295086592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295090688 ++read 4096/4096 bytes at offset 4295090688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295094784 ++read 4096/4096 bytes at offset 4295094784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295098880 ++read 4096/4096 bytes at offset 4295098880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295102976 ++read 4096/4096 bytes at offset 4295102976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295107072 ++read 4096/4096 bytes at offset 4295107072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295111168 ++read 4096/4096 bytes at offset 4295111168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 37 +-qemu-io> read 2048/2048 bytes at offset 4295117312 ++=== IO: pattern 37 ++read 2048/2048 bytes at offset 4295117312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295121408 ++read 2048/2048 bytes at offset 4295121408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295125504 ++read 2048/2048 bytes at offset 4295125504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295129600 ++read 2048/2048 bytes at offset 4295129600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295133696 ++read 2048/2048 bytes at offset 4295133696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295137792 ++read 2048/2048 bytes at offset 4295137792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295141888 ++read 2048/2048 bytes at offset 4295141888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295145984 ++read 2048/2048 bytes at offset 4295145984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295150080 ++read 2048/2048 bytes at offset 4295150080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295154176 ++read 2048/2048 bytes at offset 4295154176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295158272 ++read 2048/2048 bytes at offset 4295158272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295162368 ++read 2048/2048 bytes at offset 4295162368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295166464 ++read 2048/2048 bytes at offset 4295166464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295170560 ++read 2048/2048 bytes at offset 4295170560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295174656 ++read 2048/2048 bytes at offset 4295174656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295178752 ++read 2048/2048 bytes at offset 4295178752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295182848 ++read 2048/2048 bytes at offset 4295182848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295186944 ++read 2048/2048 bytes at offset 4295186944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295191040 ++read 2048/2048 bytes at offset 4295191040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295195136 ++read 2048/2048 bytes at offset 4295195136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295199232 ++read 2048/2048 bytes at offset 4295199232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295203328 ++read 2048/2048 bytes at offset 4295203328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295207424 ++read 2048/2048 bytes at offset 4295207424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295211520 ++read 2048/2048 bytes at offset 4295211520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295215616 ++read 2048/2048 bytes at offset 4295215616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295219712 ++read 2048/2048 bytes at offset 4295219712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295223808 ++read 2048/2048 bytes at offset 4295223808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295227904 ++read 2048/2048 bytes at offset 4295227904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295232000 ++read 2048/2048 bytes at offset 4295232000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295236096 ++read 2048/2048 bytes at offset 4295236096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295240192 ++read 2048/2048 bytes at offset 4295240192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295244288 ++read 2048/2048 bytes at offset 4295244288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295248384 ++read 2048/2048 bytes at offset 4295248384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295252480 ++read 2048/2048 bytes at offset 4295252480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295256576 ++read 2048/2048 bytes at offset 4295256576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295260672 ++read 2048/2048 bytes at offset 4295260672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 65 +-qemu-io> read 2048/2048 bytes at offset 4295262720 ++=== IO: pattern 65 ++read 2048/2048 bytes at offset 4295262720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295266816 ++read 2048/2048 bytes at offset 4295266816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295270912 ++read 2048/2048 bytes at offset 4295270912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295275008 ++read 2048/2048 bytes at offset 4295275008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295279104 ++read 2048/2048 bytes at offset 4295279104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295283200 ++read 2048/2048 bytes at offset 4295283200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295287296 ++read 2048/2048 bytes at offset 4295287296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295291392 ++read 2048/2048 bytes at offset 4295291392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295295488 ++read 2048/2048 bytes at offset 4295295488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295299584 ++read 2048/2048 bytes at offset 4295299584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295303680 ++read 2048/2048 bytes at offset 4295303680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295307776 ++read 2048/2048 bytes at offset 4295307776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295311872 ++read 2048/2048 bytes at offset 4295311872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295315968 ++read 2048/2048 bytes at offset 4295315968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295320064 ++read 2048/2048 bytes at offset 4295320064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295324160 ++read 2048/2048 bytes at offset 4295324160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295328256 ++read 2048/2048 bytes at offset 4295328256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295332352 ++read 2048/2048 bytes at offset 4295332352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295336448 ++read 2048/2048 bytes at offset 4295336448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295340544 ++read 2048/2048 bytes at offset 4295340544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295344640 ++read 2048/2048 bytes at offset 4295344640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295348736 ++read 2048/2048 bytes at offset 4295348736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295352832 ++read 2048/2048 bytes at offset 4295352832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295356928 ++read 2048/2048 bytes at offset 4295356928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295361024 ++read 2048/2048 bytes at offset 4295361024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295365120 ++read 2048/2048 bytes at offset 4295365120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295369216 ++read 2048/2048 bytes at offset 4295369216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295373312 ++read 2048/2048 bytes at offset 4295373312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295377408 ++read 2048/2048 bytes at offset 4295377408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295381504 ++read 2048/2048 bytes at offset 4295381504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295385600 ++read 2048/2048 bytes at offset 4295385600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295389696 ++read 2048/2048 bytes at offset 4295389696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295393792 ++read 2048/2048 bytes at offset 4295393792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295397888 ++read 2048/2048 bytes at offset 4295397888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295401984 ++read 2048/2048 bytes at offset 4295401984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295406080 ++read 2048/2048 bytes at offset 4295406080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 99 +-qemu-io> read 2048/2048 bytes at offset 4295411200 ++=== IO: pattern 99 ++read 2048/2048 bytes at offset 4295411200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295415296 ++read 2048/2048 bytes at offset 4295415296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295419392 ++read 2048/2048 bytes at offset 4295419392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295423488 ++read 2048/2048 bytes at offset 4295423488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295427584 ++read 2048/2048 bytes at offset 4295427584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295431680 ++read 2048/2048 bytes at offset 4295431680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295435776 ++read 2048/2048 bytes at offset 4295435776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295439872 ++read 2048/2048 bytes at offset 4295439872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295443968 ++read 2048/2048 bytes at offset 4295443968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295448064 ++read 2048/2048 bytes at offset 4295448064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295452160 ++read 2048/2048 bytes at offset 4295452160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295456256 ++read 2048/2048 bytes at offset 4295456256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295460352 ++read 2048/2048 bytes at offset 4295460352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295464448 ++read 2048/2048 bytes at offset 4295464448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295468544 ++read 2048/2048 bytes at offset 4295468544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295472640 ++read 2048/2048 bytes at offset 4295472640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295476736 ++read 2048/2048 bytes at offset 4295476736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295480832 ++read 2048/2048 bytes at offset 4295480832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295484928 ++read 2048/2048 bytes at offset 4295484928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295489024 ++read 2048/2048 bytes at offset 4295489024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295493120 ++read 2048/2048 bytes at offset 4295493120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295497216 ++read 2048/2048 bytes at offset 4295497216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295501312 ++read 2048/2048 bytes at offset 4295501312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295505408 ++read 2048/2048 bytes at offset 4295505408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295509504 ++read 2048/2048 bytes at offset 4295509504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295513600 ++read 2048/2048 bytes at offset 4295513600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295517696 ++read 2048/2048 bytes at offset 4295517696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295521792 ++read 2048/2048 bytes at offset 4295521792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295525888 ++read 2048/2048 bytes at offset 4295525888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295529984 ++read 2048/2048 bytes at offset 4295529984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295534080 ++read 2048/2048 bytes at offset 4295534080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295538176 ++read 2048/2048 bytes at offset 4295538176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295542272 ++read 2048/2048 bytes at offset 4295542272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295546368 ++read 2048/2048 bytes at offset 4295546368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295550464 ++read 2048/2048 bytes at offset 4295550464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295554560 ++read 2048/2048 bytes at offset 4295554560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 133 +-qemu-io> read 8192/8192 bytes at offset 4295559680 ++=== IO: pattern 133 ++read 8192/8192 bytes at offset 4295559680 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295571968 ++read 8192/8192 bytes at offset 4295571968 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295584256 ++read 8192/8192 bytes at offset 4295584256 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295596544 ++read 8192/8192 bytes at offset 4295596544 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295608832 ++read 8192/8192 bytes at offset 4295608832 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295621120 ++read 8192/8192 bytes at offset 4295621120 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295633408 ++read 8192/8192 bytes at offset 4295633408 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295645696 ++read 8192/8192 bytes at offset 4295645696 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295657984 ++read 8192/8192 bytes at offset 4295657984 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 244 +-qemu-io> read 12288/12288 bytes at offset 4297058304 ++=== IO: pattern 244 ++read 12288/12288 bytes at offset 4297058304 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4299157504 ++read 12288/12288 bytes at offset 4299157504 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4301256704 ++read 12288/12288 bytes at offset 4301256704 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 1 +-qemu-io> wrote 4096/4096 bytes at offset 4294967808 ++=== IO: pattern 1 ++wrote 4096/4096 bytes at offset 4294967808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4294971904 ++wrote 4096/4096 bytes at offset 4294971904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4294976000 ++wrote 4096/4096 bytes at offset 4294976000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4294980096 ++wrote 4096/4096 bytes at offset 4294980096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4294984192 ++wrote 4096/4096 bytes at offset 4294984192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4294988288 ++wrote 4096/4096 bytes at offset 4294988288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4294992384 ++wrote 4096/4096 bytes at offset 4294992384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4294996480 ++wrote 4096/4096 bytes at offset 4294996480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295000576 ++wrote 4096/4096 bytes at offset 4295000576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295004672 ++wrote 4096/4096 bytes at offset 4295004672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295008768 ++wrote 4096/4096 bytes at offset 4295008768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295012864 ++wrote 4096/4096 bytes at offset 4295012864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295016960 ++wrote 4096/4096 bytes at offset 4295016960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295021056 ++wrote 4096/4096 bytes at offset 4295021056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295025152 ++wrote 4096/4096 bytes at offset 4295025152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295029248 ++wrote 4096/4096 bytes at offset 4295029248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295033344 ++wrote 4096/4096 bytes at offset 4295033344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295037440 ++wrote 4096/4096 bytes at offset 4295037440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295041536 ++wrote 4096/4096 bytes at offset 4295041536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295045632 ++wrote 4096/4096 bytes at offset 4295045632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295049728 ++wrote 4096/4096 bytes at offset 4295049728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295053824 ++wrote 4096/4096 bytes at offset 4295053824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295057920 ++wrote 4096/4096 bytes at offset 4295057920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295062016 ++wrote 4096/4096 bytes at offset 4295062016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295066112 ++wrote 4096/4096 bytes at offset 4295066112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295070208 ++wrote 4096/4096 bytes at offset 4295070208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295074304 ++wrote 4096/4096 bytes at offset 4295074304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295078400 ++wrote 4096/4096 bytes at offset 4295078400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295082496 ++wrote 4096/4096 bytes at offset 4295082496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295086592 ++wrote 4096/4096 bytes at offset 4295086592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295090688 ++wrote 4096/4096 bytes at offset 4295090688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295094784 ++wrote 4096/4096 bytes at offset 4295094784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295098880 ++wrote 4096/4096 bytes at offset 4295098880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295102976 ++wrote 4096/4096 bytes at offset 4295102976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295107072 ++wrote 4096/4096 bytes at offset 4295107072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295111168 ++wrote 4096/4096 bytes at offset 4295111168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 37 +-qemu-io> wrote 2048/2048 bytes at offset 4295117312 ++=== IO: pattern 37 ++wrote 2048/2048 bytes at offset 4295117312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295121408 ++wrote 2048/2048 bytes at offset 4295121408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295125504 ++wrote 2048/2048 bytes at offset 4295125504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295129600 ++wrote 2048/2048 bytes at offset 4295129600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295133696 ++wrote 2048/2048 bytes at offset 4295133696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295137792 ++wrote 2048/2048 bytes at offset 4295137792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295141888 ++wrote 2048/2048 bytes at offset 4295141888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295145984 ++wrote 2048/2048 bytes at offset 4295145984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295150080 ++wrote 2048/2048 bytes at offset 4295150080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295154176 ++wrote 2048/2048 bytes at offset 4295154176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295158272 ++wrote 2048/2048 bytes at offset 4295158272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295162368 ++wrote 2048/2048 bytes at offset 4295162368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295166464 ++wrote 2048/2048 bytes at offset 4295166464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295170560 ++wrote 2048/2048 bytes at offset 4295170560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295174656 ++wrote 2048/2048 bytes at offset 4295174656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295178752 ++wrote 2048/2048 bytes at offset 4295178752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295182848 ++wrote 2048/2048 bytes at offset 4295182848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295186944 ++wrote 2048/2048 bytes at offset 4295186944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295191040 ++wrote 2048/2048 bytes at offset 4295191040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295195136 ++wrote 2048/2048 bytes at offset 4295195136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295199232 ++wrote 2048/2048 bytes at offset 4295199232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295203328 ++wrote 2048/2048 bytes at offset 4295203328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295207424 ++wrote 2048/2048 bytes at offset 4295207424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295211520 ++wrote 2048/2048 bytes at offset 4295211520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295215616 ++wrote 2048/2048 bytes at offset 4295215616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295219712 ++wrote 2048/2048 bytes at offset 4295219712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295223808 ++wrote 2048/2048 bytes at offset 4295223808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295227904 ++wrote 2048/2048 bytes at offset 4295227904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295232000 ++wrote 2048/2048 bytes at offset 4295232000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295236096 ++wrote 2048/2048 bytes at offset 4295236096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295240192 ++wrote 2048/2048 bytes at offset 4295240192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295244288 ++wrote 2048/2048 bytes at offset 4295244288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295248384 ++wrote 2048/2048 bytes at offset 4295248384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295252480 ++wrote 2048/2048 bytes at offset 4295252480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295256576 ++wrote 2048/2048 bytes at offset 4295256576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295260672 ++wrote 2048/2048 bytes at offset 4295260672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 65 +-qemu-io> wrote 2048/2048 bytes at offset 4295262720 ++=== IO: pattern 65 ++wrote 2048/2048 bytes at offset 4295262720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295266816 ++wrote 2048/2048 bytes at offset 4295266816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295270912 ++wrote 2048/2048 bytes at offset 4295270912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295275008 ++wrote 2048/2048 bytes at offset 4295275008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295279104 ++wrote 2048/2048 bytes at offset 4295279104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295283200 ++wrote 2048/2048 bytes at offset 4295283200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295287296 ++wrote 2048/2048 bytes at offset 4295287296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295291392 ++wrote 2048/2048 bytes at offset 4295291392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295295488 ++wrote 2048/2048 bytes at offset 4295295488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295299584 ++wrote 2048/2048 bytes at offset 4295299584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295303680 ++wrote 2048/2048 bytes at offset 4295303680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295307776 ++wrote 2048/2048 bytes at offset 4295307776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295311872 ++wrote 2048/2048 bytes at offset 4295311872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295315968 ++wrote 2048/2048 bytes at offset 4295315968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295320064 ++wrote 2048/2048 bytes at offset 4295320064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295324160 ++wrote 2048/2048 bytes at offset 4295324160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295328256 ++wrote 2048/2048 bytes at offset 4295328256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295332352 ++wrote 2048/2048 bytes at offset 4295332352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295336448 ++wrote 2048/2048 bytes at offset 4295336448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295340544 ++wrote 2048/2048 bytes at offset 4295340544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295344640 ++wrote 2048/2048 bytes at offset 4295344640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295348736 ++wrote 2048/2048 bytes at offset 4295348736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295352832 ++wrote 2048/2048 bytes at offset 4295352832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295356928 ++wrote 2048/2048 bytes at offset 4295356928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295361024 ++wrote 2048/2048 bytes at offset 4295361024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295365120 ++wrote 2048/2048 bytes at offset 4295365120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295369216 ++wrote 2048/2048 bytes at offset 4295369216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295373312 ++wrote 2048/2048 bytes at offset 4295373312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295377408 ++wrote 2048/2048 bytes at offset 4295377408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295381504 ++wrote 2048/2048 bytes at offset 4295381504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295385600 ++wrote 2048/2048 bytes at offset 4295385600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295389696 ++wrote 2048/2048 bytes at offset 4295389696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295393792 ++wrote 2048/2048 bytes at offset 4295393792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295397888 ++wrote 2048/2048 bytes at offset 4295397888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295401984 ++wrote 2048/2048 bytes at offset 4295401984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295406080 ++wrote 2048/2048 bytes at offset 4295406080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 99 +-qemu-io> wrote 2048/2048 bytes at offset 4295411200 ++=== IO: pattern 99 ++wrote 2048/2048 bytes at offset 4295411200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295415296 ++wrote 2048/2048 bytes at offset 4295415296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295419392 ++wrote 2048/2048 bytes at offset 4295419392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295423488 ++wrote 2048/2048 bytes at offset 4295423488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295427584 ++wrote 2048/2048 bytes at offset 4295427584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295431680 ++wrote 2048/2048 bytes at offset 4295431680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295435776 ++wrote 2048/2048 bytes at offset 4295435776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295439872 ++wrote 2048/2048 bytes at offset 4295439872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295443968 ++wrote 2048/2048 bytes at offset 4295443968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295448064 ++wrote 2048/2048 bytes at offset 4295448064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295452160 ++wrote 2048/2048 bytes at offset 4295452160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295456256 ++wrote 2048/2048 bytes at offset 4295456256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295460352 ++wrote 2048/2048 bytes at offset 4295460352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295464448 ++wrote 2048/2048 bytes at offset 4295464448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295468544 ++wrote 2048/2048 bytes at offset 4295468544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295472640 ++wrote 2048/2048 bytes at offset 4295472640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295476736 ++wrote 2048/2048 bytes at offset 4295476736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295480832 ++wrote 2048/2048 bytes at offset 4295480832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295484928 ++wrote 2048/2048 bytes at offset 4295484928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295489024 ++wrote 2048/2048 bytes at offset 4295489024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295493120 ++wrote 2048/2048 bytes at offset 4295493120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295497216 ++wrote 2048/2048 bytes at offset 4295497216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295501312 ++wrote 2048/2048 bytes at offset 4295501312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295505408 ++wrote 2048/2048 bytes at offset 4295505408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295509504 ++wrote 2048/2048 bytes at offset 4295509504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295513600 ++wrote 2048/2048 bytes at offset 4295513600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295517696 ++wrote 2048/2048 bytes at offset 4295517696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295521792 ++wrote 2048/2048 bytes at offset 4295521792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295525888 ++wrote 2048/2048 bytes at offset 4295525888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295529984 ++wrote 2048/2048 bytes at offset 4295529984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295534080 ++wrote 2048/2048 bytes at offset 4295534080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295538176 ++wrote 2048/2048 bytes at offset 4295538176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295542272 ++wrote 2048/2048 bytes at offset 4295542272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295546368 ++wrote 2048/2048 bytes at offset 4295546368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295550464 ++wrote 2048/2048 bytes at offset 4295550464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 2048/2048 bytes at offset 4295554560 ++wrote 2048/2048 bytes at offset 4295554560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 133 +-qemu-io> wrote 8192/8192 bytes at offset 4295559680 ++=== IO: pattern 133 ++wrote 8192/8192 bytes at offset 4295559680 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295571968 ++wrote 8192/8192 bytes at offset 4295571968 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295584256 ++wrote 8192/8192 bytes at offset 4295584256 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295596544 ++wrote 8192/8192 bytes at offset 4295596544 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295608832 ++wrote 8192/8192 bytes at offset 4295608832 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295621120 ++wrote 8192/8192 bytes at offset 4295621120 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295633408 ++wrote 8192/8192 bytes at offset 4295633408 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295645696 ++wrote 8192/8192 bytes at offset 4295645696 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295657984 ++wrote 8192/8192 bytes at offset 4295657984 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 244 +-qemu-io> wrote 12288/12288 bytes at offset 4297058304 ++=== IO: pattern 244 ++wrote 12288/12288 bytes at offset 4297058304 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 4299157504 ++wrote 12288/12288 bytes at offset 4299157504 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 12288/12288 bytes at offset 4301256704 ++wrote 12288/12288 bytes at offset 4301256704 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 1 +-qemu-io> read 4096/4096 bytes at offset 4294967808 ++=== IO: pattern 1 ++read 4096/4096 bytes at offset 4294967808 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294971904 ++read 4096/4096 bytes at offset 4294971904 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294976000 ++read 4096/4096 bytes at offset 4294976000 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294980096 ++read 4096/4096 bytes at offset 4294980096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294984192 ++read 4096/4096 bytes at offset 4294984192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294988288 ++read 4096/4096 bytes at offset 4294988288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294992384 ++read 4096/4096 bytes at offset 4294992384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4294996480 ++read 4096/4096 bytes at offset 4294996480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295000576 ++read 4096/4096 bytes at offset 4295000576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295004672 ++read 4096/4096 bytes at offset 4295004672 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295008768 ++read 4096/4096 bytes at offset 4295008768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295012864 ++read 4096/4096 bytes at offset 4295012864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295016960 ++read 4096/4096 bytes at offset 4295016960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295021056 ++read 4096/4096 bytes at offset 4295021056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295025152 ++read 4096/4096 bytes at offset 4295025152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295029248 ++read 4096/4096 bytes at offset 4295029248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295033344 ++read 4096/4096 bytes at offset 4295033344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295037440 ++read 4096/4096 bytes at offset 4295037440 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295041536 ++read 4096/4096 bytes at offset 4295041536 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295045632 ++read 4096/4096 bytes at offset 4295045632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295049728 ++read 4096/4096 bytes at offset 4295049728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295053824 ++read 4096/4096 bytes at offset 4295053824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295057920 ++read 4096/4096 bytes at offset 4295057920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295062016 ++read 4096/4096 bytes at offset 4295062016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295066112 ++read 4096/4096 bytes at offset 4295066112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295070208 ++read 4096/4096 bytes at offset 4295070208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295074304 ++read 4096/4096 bytes at offset 4295074304 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295078400 ++read 4096/4096 bytes at offset 4295078400 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295082496 ++read 4096/4096 bytes at offset 4295082496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295086592 ++read 4096/4096 bytes at offset 4295086592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295090688 ++read 4096/4096 bytes at offset 4295090688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295094784 ++read 4096/4096 bytes at offset 4295094784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295098880 ++read 4096/4096 bytes at offset 4295098880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295102976 ++read 4096/4096 bytes at offset 4295102976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295107072 ++read 4096/4096 bytes at offset 4295107072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295111168 ++read 4096/4096 bytes at offset 4295111168 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 37 +-qemu-io> read 2048/2048 bytes at offset 4295117312 ++=== IO: pattern 37 ++read 2048/2048 bytes at offset 4295117312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295121408 ++read 2048/2048 bytes at offset 4295121408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295125504 ++read 2048/2048 bytes at offset 4295125504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295129600 ++read 2048/2048 bytes at offset 4295129600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295133696 ++read 2048/2048 bytes at offset 4295133696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295137792 ++read 2048/2048 bytes at offset 4295137792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295141888 ++read 2048/2048 bytes at offset 4295141888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295145984 ++read 2048/2048 bytes at offset 4295145984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295150080 ++read 2048/2048 bytes at offset 4295150080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295154176 ++read 2048/2048 bytes at offset 4295154176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295158272 ++read 2048/2048 bytes at offset 4295158272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295162368 ++read 2048/2048 bytes at offset 4295162368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295166464 ++read 2048/2048 bytes at offset 4295166464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295170560 ++read 2048/2048 bytes at offset 4295170560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295174656 ++read 2048/2048 bytes at offset 4295174656 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295178752 ++read 2048/2048 bytes at offset 4295178752 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295182848 ++read 2048/2048 bytes at offset 4295182848 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295186944 ++read 2048/2048 bytes at offset 4295186944 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295191040 ++read 2048/2048 bytes at offset 4295191040 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295195136 ++read 2048/2048 bytes at offset 4295195136 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295199232 ++read 2048/2048 bytes at offset 4295199232 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295203328 ++read 2048/2048 bytes at offset 4295203328 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295207424 ++read 2048/2048 bytes at offset 4295207424 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295211520 ++read 2048/2048 bytes at offset 4295211520 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295215616 ++read 2048/2048 bytes at offset 4295215616 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295219712 ++read 2048/2048 bytes at offset 4295219712 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295223808 ++read 2048/2048 bytes at offset 4295223808 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295227904 ++read 2048/2048 bytes at offset 4295227904 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295232000 ++read 2048/2048 bytes at offset 4295232000 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295236096 ++read 2048/2048 bytes at offset 4295236096 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295240192 ++read 2048/2048 bytes at offset 4295240192 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295244288 ++read 2048/2048 bytes at offset 4295244288 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295248384 ++read 2048/2048 bytes at offset 4295248384 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295252480 ++read 2048/2048 bytes at offset 4295252480 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295256576 ++read 2048/2048 bytes at offset 4295256576 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295260672 ++read 2048/2048 bytes at offset 4295260672 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 65 +-qemu-io> read 2048/2048 bytes at offset 4295262720 ++=== IO: pattern 65 ++read 2048/2048 bytes at offset 4295262720 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295266816 ++read 2048/2048 bytes at offset 4295266816 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295270912 ++read 2048/2048 bytes at offset 4295270912 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295275008 ++read 2048/2048 bytes at offset 4295275008 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295279104 ++read 2048/2048 bytes at offset 4295279104 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295283200 ++read 2048/2048 bytes at offset 4295283200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295287296 ++read 2048/2048 bytes at offset 4295287296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295291392 ++read 2048/2048 bytes at offset 4295291392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295295488 ++read 2048/2048 bytes at offset 4295295488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295299584 ++read 2048/2048 bytes at offset 4295299584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295303680 ++read 2048/2048 bytes at offset 4295303680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295307776 ++read 2048/2048 bytes at offset 4295307776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295311872 ++read 2048/2048 bytes at offset 4295311872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295315968 ++read 2048/2048 bytes at offset 4295315968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295320064 ++read 2048/2048 bytes at offset 4295320064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295324160 ++read 2048/2048 bytes at offset 4295324160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295328256 ++read 2048/2048 bytes at offset 4295328256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295332352 ++read 2048/2048 bytes at offset 4295332352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295336448 ++read 2048/2048 bytes at offset 4295336448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295340544 ++read 2048/2048 bytes at offset 4295340544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295344640 ++read 2048/2048 bytes at offset 4295344640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295348736 ++read 2048/2048 bytes at offset 4295348736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295352832 ++read 2048/2048 bytes at offset 4295352832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295356928 ++read 2048/2048 bytes at offset 4295356928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295361024 ++read 2048/2048 bytes at offset 4295361024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295365120 ++read 2048/2048 bytes at offset 4295365120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295369216 ++read 2048/2048 bytes at offset 4295369216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295373312 ++read 2048/2048 bytes at offset 4295373312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295377408 ++read 2048/2048 bytes at offset 4295377408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295381504 ++read 2048/2048 bytes at offset 4295381504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295385600 ++read 2048/2048 bytes at offset 4295385600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295389696 ++read 2048/2048 bytes at offset 4295389696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295393792 ++read 2048/2048 bytes at offset 4295393792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295397888 ++read 2048/2048 bytes at offset 4295397888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295401984 ++read 2048/2048 bytes at offset 4295401984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295406080 ++read 2048/2048 bytes at offset 4295406080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 99 +-qemu-io> read 2048/2048 bytes at offset 4295411200 ++=== IO: pattern 99 ++read 2048/2048 bytes at offset 4295411200 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295415296 ++read 2048/2048 bytes at offset 4295415296 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295419392 ++read 2048/2048 bytes at offset 4295419392 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295423488 ++read 2048/2048 bytes at offset 4295423488 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295427584 ++read 2048/2048 bytes at offset 4295427584 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295431680 ++read 2048/2048 bytes at offset 4295431680 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295435776 ++read 2048/2048 bytes at offset 4295435776 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295439872 ++read 2048/2048 bytes at offset 4295439872 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295443968 ++read 2048/2048 bytes at offset 4295443968 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295448064 ++read 2048/2048 bytes at offset 4295448064 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295452160 ++read 2048/2048 bytes at offset 4295452160 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295456256 ++read 2048/2048 bytes at offset 4295456256 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295460352 ++read 2048/2048 bytes at offset 4295460352 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295464448 ++read 2048/2048 bytes at offset 4295464448 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295468544 ++read 2048/2048 bytes at offset 4295468544 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295472640 ++read 2048/2048 bytes at offset 4295472640 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295476736 ++read 2048/2048 bytes at offset 4295476736 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295480832 ++read 2048/2048 bytes at offset 4295480832 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295484928 ++read 2048/2048 bytes at offset 4295484928 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295489024 ++read 2048/2048 bytes at offset 4295489024 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295493120 ++read 2048/2048 bytes at offset 4295493120 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295497216 ++read 2048/2048 bytes at offset 4295497216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295501312 ++read 2048/2048 bytes at offset 4295501312 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295505408 ++read 2048/2048 bytes at offset 4295505408 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295509504 ++read 2048/2048 bytes at offset 4295509504 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295513600 ++read 2048/2048 bytes at offset 4295513600 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295517696 ++read 2048/2048 bytes at offset 4295517696 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295521792 ++read 2048/2048 bytes at offset 4295521792 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295525888 ++read 2048/2048 bytes at offset 4295525888 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295529984 ++read 2048/2048 bytes at offset 4295529984 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295534080 ++read 2048/2048 bytes at offset 4295534080 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295538176 ++read 2048/2048 bytes at offset 4295538176 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295542272 ++read 2048/2048 bytes at offset 4295542272 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295546368 ++read 2048/2048 bytes at offset 4295546368 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295550464 ++read 2048/2048 bytes at offset 4295550464 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 4295554560 ++read 2048/2048 bytes at offset 4295554560 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 133 +-qemu-io> read 8192/8192 bytes at offset 4295559680 ++=== IO: pattern 133 ++read 8192/8192 bytes at offset 4295559680 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295571968 ++read 8192/8192 bytes at offset 4295571968 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295584256 ++read 8192/8192 bytes at offset 4295584256 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295596544 ++read 8192/8192 bytes at offset 4295596544 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295608832 ++read 8192/8192 bytes at offset 4295608832 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295621120 ++read 8192/8192 bytes at offset 4295621120 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295633408 ++read 8192/8192 bytes at offset 4295633408 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295645696 ++read 8192/8192 bytes at offset 4295645696 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295657984 ++read 8192/8192 bytes at offset 4295657984 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 244 +-qemu-io> read 12288/12288 bytes at offset 4297058304 ++=== IO: pattern 244 ++read 12288/12288 bytes at offset 4297058304 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4299157504 ++read 12288/12288 bytes at offset 4299157504 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4301256704 ++read 12288/12288 bytes at offset 4301256704 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> No errors were found on the image. ++No errors were found on the image. + Creating another new image + + Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=8589934592 +@@ -12276,221 +12276,221 @@ More complex patterns + test2: With offset 0 + === Clusters to be compressed [1] + === IO: pattern 165 +-qemu-io> wrote 4096/4096 bytes at offset 16384 ++wrote 4096/4096 bytes at offset 16384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 53248 ++wrote 4096/4096 bytes at offset 53248 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 90112 ++wrote 4096/4096 bytes at offset 90112 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 126976 ++wrote 4096/4096 bytes at offset 126976 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === Clusters to be compressed [2] ++=== Clusters to be compressed [2] + === IO: pattern 165 +-qemu-io> wrote 4096/4096 bytes at offset 20480 ++wrote 4096/4096 bytes at offset 20480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 57344 ++wrote 4096/4096 bytes at offset 57344 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 94208 ++wrote 4096/4096 bytes at offset 94208 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 131072 ++wrote 4096/4096 bytes at offset 131072 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === Clusters to be compressed [3] ++=== Clusters to be compressed [3] + === IO: pattern 165 +-qemu-io> wrote 4096/4096 bytes at offset 32768 ++wrote 4096/4096 bytes at offset 32768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 69632 ++wrote 4096/4096 bytes at offset 69632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 106496 ++wrote 4096/4096 bytes at offset 106496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 143360 ++wrote 4096/4096 bytes at offset 143360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === Used clusters [1] ++=== Used clusters [1] + === IO: pattern 165 +-qemu-io> wrote 4096/4096 bytes at offset 0 ++wrote 4096/4096 bytes at offset 0 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 36864 ++wrote 4096/4096 bytes at offset 36864 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 73728 ++wrote 4096/4096 bytes at offset 73728 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 110592 ++wrote 4096/4096 bytes at offset 110592 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === Used clusters [2] ++=== Used clusters [2] + === IO: pattern 165 +-qemu-io> wrote 4096/4096 bytes at offset 4096 ++wrote 4096/4096 bytes at offset 4096 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 40960 ++wrote 4096/4096 bytes at offset 40960 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 77824 ++wrote 4096/4096 bytes at offset 77824 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 114688 ++wrote 4096/4096 bytes at offset 114688 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === Used clusters [3] ++=== Used clusters [3] + === IO: pattern 165 +-qemu-io> wrote 4096/4096 bytes at offset 12288 ++wrote 4096/4096 bytes at offset 12288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 49152 ++wrote 4096/4096 bytes at offset 49152 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 86016 ++wrote 4096/4096 bytes at offset 86016 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 122880 ++wrote 4096/4096 bytes at offset 122880 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === Read used/compressed clusters ++=== Read used/compressed clusters + === IO: pattern 165 +-qemu-io> read 8192/8192 bytes at offset 0 ++read 8192/8192 bytes at offset 0 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 36864 ++read 8192/8192 bytes at offset 36864 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 73728 ++read 8192/8192 bytes at offset 73728 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 110592 ++read 8192/8192 bytes at offset 110592 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 165 +-qemu-io> read 12288/12288 bytes at offset 12288 ++=== IO: pattern 165 ++read 12288/12288 bytes at offset 12288 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 49152 ++read 12288/12288 bytes at offset 49152 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 86016 ++read 12288/12288 bytes at offset 86016 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 122880 ++read 12288/12288 bytes at offset 122880 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 165 +-qemu-io> read 4096/4096 bytes at offset 32768 ++=== IO: pattern 165 ++read 4096/4096 bytes at offset 32768 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 69632 ++read 4096/4096 bytes at offset 69632 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 106496 ++read 4096/4096 bytes at offset 106496 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 143360 ++read 4096/4096 bytes at offset 143360 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === Read zeros ++=== Read zeros + === IO: pattern 0 +-qemu-io> read 4096/4096 bytes at offset 8192 ++read 4096/4096 bytes at offset 8192 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 45056 ++read 4096/4096 bytes at offset 45056 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 81920 ++read 4096/4096 bytes at offset 81920 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 118784 ++read 4096/4096 bytes at offset 118784 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> read 8192/8192 bytes at offset 24576 ++=== IO: pattern 0 ++read 8192/8192 bytes at offset 24576 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 61440 ++read 8192/8192 bytes at offset 61440 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 98304 ++read 8192/8192 bytes at offset 98304 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 135168 ++read 8192/8192 bytes at offset 135168 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> No errors were found on the image. ++No errors were found on the image. + test2: With offset 4294967296 + === Clusters to be compressed [1] + === IO: pattern 165 +-qemu-io> wrote 4096/4096 bytes at offset 4294983680 ++wrote 4096/4096 bytes at offset 4294983680 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295020544 ++wrote 4096/4096 bytes at offset 4295020544 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295057408 ++wrote 4096/4096 bytes at offset 4295057408 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295094272 ++wrote 4096/4096 bytes at offset 4295094272 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === Clusters to be compressed [2] ++=== Clusters to be compressed [2] + === IO: pattern 165 +-qemu-io> wrote 4096/4096 bytes at offset 4294987776 ++wrote 4096/4096 bytes at offset 4294987776 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295024640 ++wrote 4096/4096 bytes at offset 4295024640 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295061504 ++wrote 4096/4096 bytes at offset 4295061504 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295098368 ++wrote 4096/4096 bytes at offset 4295098368 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === Clusters to be compressed [3] ++=== Clusters to be compressed [3] + === IO: pattern 165 +-qemu-io> wrote 4096/4096 bytes at offset 4295000064 ++wrote 4096/4096 bytes at offset 4295000064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295036928 ++wrote 4096/4096 bytes at offset 4295036928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295073792 ++wrote 4096/4096 bytes at offset 4295073792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295110656 ++wrote 4096/4096 bytes at offset 4295110656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === Used clusters [1] ++=== Used clusters [1] + === IO: pattern 165 +-qemu-io> wrote 4096/4096 bytes at offset 4294967296 ++wrote 4096/4096 bytes at offset 4294967296 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295004160 ++wrote 4096/4096 bytes at offset 4295004160 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295041024 ++wrote 4096/4096 bytes at offset 4295041024 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295077888 ++wrote 4096/4096 bytes at offset 4295077888 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === Used clusters [2] ++=== Used clusters [2] + === IO: pattern 165 +-qemu-io> wrote 4096/4096 bytes at offset 4294971392 ++wrote 4096/4096 bytes at offset 4294971392 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295008256 ++wrote 4096/4096 bytes at offset 4295008256 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295045120 ++wrote 4096/4096 bytes at offset 4295045120 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295081984 ++wrote 4096/4096 bytes at offset 4295081984 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === Used clusters [3] ++=== Used clusters [3] + === IO: pattern 165 +-qemu-io> wrote 4096/4096 bytes at offset 4294979584 ++wrote 4096/4096 bytes at offset 4294979584 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295016448 ++wrote 4096/4096 bytes at offset 4295016448 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295053312 ++wrote 4096/4096 bytes at offset 4295053312 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 4295090176 ++wrote 4096/4096 bytes at offset 4295090176 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === Read used/compressed clusters ++=== Read used/compressed clusters + === IO: pattern 165 +-qemu-io> read 8192/8192 bytes at offset 4294967296 ++read 8192/8192 bytes at offset 4294967296 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295004160 ++read 8192/8192 bytes at offset 4295004160 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295041024 ++read 8192/8192 bytes at offset 4295041024 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295077888 ++read 8192/8192 bytes at offset 4295077888 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 165 +-qemu-io> read 12288/12288 bytes at offset 4294979584 ++=== IO: pattern 165 ++read 12288/12288 bytes at offset 4294979584 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4295016448 ++read 12288/12288 bytes at offset 4295016448 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4295053312 ++read 12288/12288 bytes at offset 4295053312 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 4295090176 ++read 12288/12288 bytes at offset 4295090176 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 165 +-qemu-io> read 4096/4096 bytes at offset 4295000064 ++=== IO: pattern 165 ++read 4096/4096 bytes at offset 4295000064 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295036928 ++read 4096/4096 bytes at offset 4295036928 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295073792 ++read 4096/4096 bytes at offset 4295073792 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295110656 ++read 4096/4096 bytes at offset 4295110656 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === Read zeros ++=== Read zeros + === IO: pattern 0 +-qemu-io> read 4096/4096 bytes at offset 4294975488 ++read 4096/4096 bytes at offset 4294975488 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295012352 ++read 4096/4096 bytes at offset 4295012352 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295049216 ++read 4096/4096 bytes at offset 4295049216 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 4096/4096 bytes at offset 4295086080 ++read 4096/4096 bytes at offset 4295086080 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> read 8192/8192 bytes at offset 4294991872 ++=== IO: pattern 0 ++read 8192/8192 bytes at offset 4294991872 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295028736 ++read 8192/8192 bytes at offset 4295028736 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295065600 ++read 8192/8192 bytes at offset 4295065600 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295102464 ++read 8192/8192 bytes at offset 4295102464 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> No errors were found on the image. ++No errors were found on the image. + Creating new image; cluster size: 16384 + + Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=8589934592 +@@ -12498,6382 +12498,6382 @@ Testing empty image + + At offset 0: + === IO: pattern 0 +-qemu-io> wrote 16384/16384 bytes at offset 0 ++wrote 16384/16384 bytes at offset 0 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 16384 ++wrote 16384/16384 bytes at offset 16384 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 32768 ++wrote 16384/16384 bytes at offset 32768 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 49152 ++wrote 16384/16384 bytes at offset 49152 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 65536 ++wrote 16384/16384 bytes at offset 65536 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 81920 ++wrote 16384/16384 bytes at offset 81920 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 98304 ++wrote 16384/16384 bytes at offset 98304 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 114688 ++wrote 16384/16384 bytes at offset 114688 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 131072 ++wrote 16384/16384 bytes at offset 131072 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 147456 ++wrote 16384/16384 bytes at offset 147456 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 163840 ++wrote 16384/16384 bytes at offset 163840 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 180224 ++wrote 16384/16384 bytes at offset 180224 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 196608 ++wrote 16384/16384 bytes at offset 196608 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 212992 ++wrote 16384/16384 bytes at offset 212992 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 229376 ++wrote 16384/16384 bytes at offset 229376 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 245760 ++wrote 16384/16384 bytes at offset 245760 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 262144 ++wrote 16384/16384 bytes at offset 262144 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 278528 ++wrote 16384/16384 bytes at offset 278528 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 294912 ++wrote 16384/16384 bytes at offset 294912 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 311296 ++wrote 16384/16384 bytes at offset 311296 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 327680 ++wrote 16384/16384 bytes at offset 327680 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 344064 ++wrote 16384/16384 bytes at offset 344064 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 360448 ++wrote 16384/16384 bytes at offset 360448 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 376832 ++wrote 16384/16384 bytes at offset 376832 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 393216 ++wrote 16384/16384 bytes at offset 393216 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 409600 ++wrote 16384/16384 bytes at offset 409600 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 425984 ++wrote 16384/16384 bytes at offset 425984 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 442368 ++wrote 16384/16384 bytes at offset 442368 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 458752 ++wrote 16384/16384 bytes at offset 458752 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 475136 ++wrote 16384/16384 bytes at offset 475136 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 491520 ++wrote 16384/16384 bytes at offset 491520 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 507904 ++wrote 16384/16384 bytes at offset 507904 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 524288 ++wrote 16384/16384 bytes at offset 524288 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 540672 ++wrote 16384/16384 bytes at offset 540672 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 557056 ++wrote 16384/16384 bytes at offset 557056 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 573440 ++wrote 16384/16384 bytes at offset 573440 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 144 +-qemu-io> wrote 8192/8192 bytes at offset 598016 ++=== IO: pattern 144 ++wrote 8192/8192 bytes at offset 598016 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 614400 ++wrote 8192/8192 bytes at offset 614400 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 630784 ++wrote 8192/8192 bytes at offset 630784 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 647168 ++wrote 8192/8192 bytes at offset 647168 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 663552 ++wrote 8192/8192 bytes at offset 663552 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 679936 ++wrote 8192/8192 bytes at offset 679936 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 696320 ++wrote 8192/8192 bytes at offset 696320 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 712704 ++wrote 8192/8192 bytes at offset 712704 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 729088 ++wrote 8192/8192 bytes at offset 729088 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 745472 ++wrote 8192/8192 bytes at offset 745472 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 761856 ++wrote 8192/8192 bytes at offset 761856 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 778240 ++wrote 8192/8192 bytes at offset 778240 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 794624 ++wrote 8192/8192 bytes at offset 794624 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 811008 ++wrote 8192/8192 bytes at offset 811008 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 827392 ++wrote 8192/8192 bytes at offset 827392 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 843776 ++wrote 8192/8192 bytes at offset 843776 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 860160 ++wrote 8192/8192 bytes at offset 860160 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 876544 ++wrote 8192/8192 bytes at offset 876544 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 892928 ++wrote 8192/8192 bytes at offset 892928 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 909312 ++wrote 8192/8192 bytes at offset 909312 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 925696 ++wrote 8192/8192 bytes at offset 925696 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 942080 ++wrote 8192/8192 bytes at offset 942080 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 958464 ++wrote 8192/8192 bytes at offset 958464 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 974848 ++wrote 8192/8192 bytes at offset 974848 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 991232 ++wrote 8192/8192 bytes at offset 991232 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1007616 ++wrote 8192/8192 bytes at offset 1007616 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1024000 ++wrote 8192/8192 bytes at offset 1024000 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1040384 ++wrote 8192/8192 bytes at offset 1040384 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1056768 ++wrote 8192/8192 bytes at offset 1056768 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1073152 ++wrote 8192/8192 bytes at offset 1073152 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1089536 ++wrote 8192/8192 bytes at offset 1089536 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1105920 ++wrote 8192/8192 bytes at offset 1105920 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1122304 ++wrote 8192/8192 bytes at offset 1122304 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1138688 ++wrote 8192/8192 bytes at offset 1138688 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1155072 ++wrote 8192/8192 bytes at offset 1155072 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1171456 ++wrote 8192/8192 bytes at offset 1171456 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> wrote 8192/8192 bytes at offset 1179648 ++=== IO: pattern 0 ++wrote 8192/8192 bytes at offset 1179648 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1196032 ++wrote 8192/8192 bytes at offset 1196032 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1212416 ++wrote 8192/8192 bytes at offset 1212416 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1228800 ++wrote 8192/8192 bytes at offset 1228800 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1245184 ++wrote 8192/8192 bytes at offset 1245184 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1261568 ++wrote 8192/8192 bytes at offset 1261568 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1277952 ++wrote 8192/8192 bytes at offset 1277952 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1294336 ++wrote 8192/8192 bytes at offset 1294336 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1310720 ++wrote 8192/8192 bytes at offset 1310720 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1327104 ++wrote 8192/8192 bytes at offset 1327104 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1343488 ++wrote 8192/8192 bytes at offset 1343488 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1359872 ++wrote 8192/8192 bytes at offset 1359872 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1376256 ++wrote 8192/8192 bytes at offset 1376256 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1392640 ++wrote 8192/8192 bytes at offset 1392640 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1409024 ++wrote 8192/8192 bytes at offset 1409024 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1425408 ++wrote 8192/8192 bytes at offset 1425408 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1441792 ++wrote 8192/8192 bytes at offset 1441792 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1458176 ++wrote 8192/8192 bytes at offset 1458176 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1474560 ++wrote 8192/8192 bytes at offset 1474560 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1490944 ++wrote 8192/8192 bytes at offset 1490944 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1507328 ++wrote 8192/8192 bytes at offset 1507328 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1523712 ++wrote 8192/8192 bytes at offset 1523712 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1540096 ++wrote 8192/8192 bytes at offset 1540096 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1556480 ++wrote 8192/8192 bytes at offset 1556480 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1572864 ++wrote 8192/8192 bytes at offset 1572864 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1589248 ++wrote 8192/8192 bytes at offset 1589248 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1605632 ++wrote 8192/8192 bytes at offset 1605632 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1622016 ++wrote 8192/8192 bytes at offset 1622016 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1638400 ++wrote 8192/8192 bytes at offset 1638400 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1654784 ++wrote 8192/8192 bytes at offset 1654784 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1671168 ++wrote 8192/8192 bytes at offset 1671168 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1687552 ++wrote 8192/8192 bytes at offset 1687552 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1703936 ++wrote 8192/8192 bytes at offset 1703936 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1720320 ++wrote 8192/8192 bytes at offset 1720320 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1736704 ++wrote 8192/8192 bytes at offset 1736704 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1753088 ++wrote 8192/8192 bytes at offset 1753088 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 136 +-qemu-io> wrote 8192/8192 bytes at offset 1773568 ++=== IO: pattern 136 ++wrote 8192/8192 bytes at offset 1773568 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1789952 ++wrote 8192/8192 bytes at offset 1789952 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1806336 ++wrote 8192/8192 bytes at offset 1806336 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1822720 ++wrote 8192/8192 bytes at offset 1822720 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1839104 ++wrote 8192/8192 bytes at offset 1839104 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1855488 ++wrote 8192/8192 bytes at offset 1855488 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1871872 ++wrote 8192/8192 bytes at offset 1871872 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1888256 ++wrote 8192/8192 bytes at offset 1888256 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1904640 ++wrote 8192/8192 bytes at offset 1904640 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1921024 ++wrote 8192/8192 bytes at offset 1921024 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1937408 ++wrote 8192/8192 bytes at offset 1937408 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1953792 ++wrote 8192/8192 bytes at offset 1953792 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1970176 ++wrote 8192/8192 bytes at offset 1970176 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1986560 ++wrote 8192/8192 bytes at offset 1986560 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 2002944 ++wrote 8192/8192 bytes at offset 2002944 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 2019328 ++wrote 8192/8192 bytes at offset 2019328 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 2035712 ++wrote 8192/8192 bytes at offset 2035712 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 2052096 ++wrote 8192/8192 bytes at offset 2052096 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 2068480 ++wrote 8192/8192 bytes at offset 2068480 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 2084864 ++wrote 8192/8192 bytes at offset 2084864 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 2101248 ++wrote 8192/8192 bytes at offset 2101248 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 2117632 ++wrote 8192/8192 bytes at offset 2117632 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 2134016 ++wrote 8192/8192 bytes at offset 2134016 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 2150400 ++wrote 8192/8192 bytes at offset 2150400 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 2166784 ++wrote 8192/8192 bytes at offset 2166784 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 2183168 ++wrote 8192/8192 bytes at offset 2183168 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 2199552 ++wrote 8192/8192 bytes at offset 2199552 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 2215936 ++wrote 8192/8192 bytes at offset 2215936 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 2232320 ++wrote 8192/8192 bytes at offset 2232320 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 2248704 ++wrote 8192/8192 bytes at offset 2248704 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 2265088 ++wrote 8192/8192 bytes at offset 2265088 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 2281472 ++wrote 8192/8192 bytes at offset 2281472 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 2297856 ++wrote 8192/8192 bytes at offset 2297856 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 2314240 ++wrote 8192/8192 bytes at offset 2314240 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 2330624 ++wrote 8192/8192 bytes at offset 2330624 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 2347008 ++wrote 8192/8192 bytes at offset 2347008 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 16 +-qemu-io> wrote 32768/32768 bytes at offset 2367488 ++=== IO: pattern 16 ++wrote 32768/32768 bytes at offset 2367488 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 2416640 ++wrote 32768/32768 bytes at offset 2416640 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 2465792 ++wrote 32768/32768 bytes at offset 2465792 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 2514944 ++wrote 32768/32768 bytes at offset 2514944 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 2564096 ++wrote 32768/32768 bytes at offset 2564096 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 2613248 ++wrote 32768/32768 bytes at offset 2613248 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 2662400 ++wrote 32768/32768 bytes at offset 2662400 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 2711552 ++wrote 32768/32768 bytes at offset 2711552 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 2760704 ++wrote 32768/32768 bytes at offset 2760704 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 208 +-qemu-io> wrote 49152/49152 bytes at offset 33529856 ++=== IO: pattern 208 ++wrote 49152/49152 bytes at offset 33529856 + 48 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 49152/49152 bytes at offset 67092480 ++wrote 49152/49152 bytes at offset 67092480 + 48 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 49152/49152 bytes at offset 100655104 ++wrote 49152/49152 bytes at offset 100655104 + 48 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> read 16384/16384 bytes at offset 0 ++=== IO: pattern 0 ++read 16384/16384 bytes at offset 0 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 16384 ++read 16384/16384 bytes at offset 16384 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 32768 ++read 16384/16384 bytes at offset 32768 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 49152 ++read 16384/16384 bytes at offset 49152 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 65536 ++read 16384/16384 bytes at offset 65536 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 81920 ++read 16384/16384 bytes at offset 81920 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 98304 ++read 16384/16384 bytes at offset 98304 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 114688 ++read 16384/16384 bytes at offset 114688 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 131072 ++read 16384/16384 bytes at offset 131072 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 147456 ++read 16384/16384 bytes at offset 147456 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 163840 ++read 16384/16384 bytes at offset 163840 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 180224 ++read 16384/16384 bytes at offset 180224 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 196608 ++read 16384/16384 bytes at offset 196608 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 212992 ++read 16384/16384 bytes at offset 212992 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 229376 ++read 16384/16384 bytes at offset 229376 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 245760 ++read 16384/16384 bytes at offset 245760 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 262144 ++read 16384/16384 bytes at offset 262144 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 278528 ++read 16384/16384 bytes at offset 278528 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 294912 ++read 16384/16384 bytes at offset 294912 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 311296 ++read 16384/16384 bytes at offset 311296 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 327680 ++read 16384/16384 bytes at offset 327680 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 344064 ++read 16384/16384 bytes at offset 344064 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 360448 ++read 16384/16384 bytes at offset 360448 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 376832 ++read 16384/16384 bytes at offset 376832 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 393216 ++read 16384/16384 bytes at offset 393216 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 409600 ++read 16384/16384 bytes at offset 409600 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 425984 ++read 16384/16384 bytes at offset 425984 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 442368 ++read 16384/16384 bytes at offset 442368 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 458752 ++read 16384/16384 bytes at offset 458752 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 475136 ++read 16384/16384 bytes at offset 475136 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 491520 ++read 16384/16384 bytes at offset 491520 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 507904 ++read 16384/16384 bytes at offset 507904 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 524288 ++read 16384/16384 bytes at offset 524288 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 540672 ++read 16384/16384 bytes at offset 540672 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 557056 ++read 16384/16384 bytes at offset 557056 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 573440 ++read 16384/16384 bytes at offset 573440 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 144 +-qemu-io> read 8192/8192 bytes at offset 598016 ++=== IO: pattern 144 ++read 8192/8192 bytes at offset 598016 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 614400 ++read 8192/8192 bytes at offset 614400 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 630784 ++read 8192/8192 bytes at offset 630784 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 647168 ++read 8192/8192 bytes at offset 647168 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 663552 ++read 8192/8192 bytes at offset 663552 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 679936 ++read 8192/8192 bytes at offset 679936 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 696320 ++read 8192/8192 bytes at offset 696320 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 712704 ++read 8192/8192 bytes at offset 712704 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 729088 ++read 8192/8192 bytes at offset 729088 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 745472 ++read 8192/8192 bytes at offset 745472 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 761856 ++read 8192/8192 bytes at offset 761856 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 778240 ++read 8192/8192 bytes at offset 778240 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 794624 ++read 8192/8192 bytes at offset 794624 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 811008 ++read 8192/8192 bytes at offset 811008 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 827392 ++read 8192/8192 bytes at offset 827392 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 843776 ++read 8192/8192 bytes at offset 843776 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 860160 ++read 8192/8192 bytes at offset 860160 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 876544 ++read 8192/8192 bytes at offset 876544 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 892928 ++read 8192/8192 bytes at offset 892928 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 909312 ++read 8192/8192 bytes at offset 909312 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 925696 ++read 8192/8192 bytes at offset 925696 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 942080 ++read 8192/8192 bytes at offset 942080 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 958464 ++read 8192/8192 bytes at offset 958464 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 974848 ++read 8192/8192 bytes at offset 974848 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 991232 ++read 8192/8192 bytes at offset 991232 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1007616 ++read 8192/8192 bytes at offset 1007616 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1024000 ++read 8192/8192 bytes at offset 1024000 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1040384 ++read 8192/8192 bytes at offset 1040384 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1056768 ++read 8192/8192 bytes at offset 1056768 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1073152 ++read 8192/8192 bytes at offset 1073152 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1089536 ++read 8192/8192 bytes at offset 1089536 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1105920 ++read 8192/8192 bytes at offset 1105920 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1122304 ++read 8192/8192 bytes at offset 1122304 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1138688 ++read 8192/8192 bytes at offset 1138688 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1155072 ++read 8192/8192 bytes at offset 1155072 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1171456 ++read 8192/8192 bytes at offset 1171456 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> read 8192/8192 bytes at offset 1179648 ++=== IO: pattern 0 ++read 8192/8192 bytes at offset 1179648 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1196032 ++read 8192/8192 bytes at offset 1196032 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1212416 ++read 8192/8192 bytes at offset 1212416 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1228800 ++read 8192/8192 bytes at offset 1228800 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1245184 ++read 8192/8192 bytes at offset 1245184 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1261568 ++read 8192/8192 bytes at offset 1261568 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1277952 ++read 8192/8192 bytes at offset 1277952 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1294336 ++read 8192/8192 bytes at offset 1294336 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1310720 ++read 8192/8192 bytes at offset 1310720 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1327104 ++read 8192/8192 bytes at offset 1327104 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1343488 ++read 8192/8192 bytes at offset 1343488 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1359872 ++read 8192/8192 bytes at offset 1359872 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1376256 ++read 8192/8192 bytes at offset 1376256 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1392640 ++read 8192/8192 bytes at offset 1392640 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1409024 ++read 8192/8192 bytes at offset 1409024 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1425408 ++read 8192/8192 bytes at offset 1425408 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1441792 ++read 8192/8192 bytes at offset 1441792 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1458176 ++read 8192/8192 bytes at offset 1458176 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1474560 ++read 8192/8192 bytes at offset 1474560 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1490944 ++read 8192/8192 bytes at offset 1490944 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1507328 ++read 8192/8192 bytes at offset 1507328 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1523712 ++read 8192/8192 bytes at offset 1523712 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1540096 ++read 8192/8192 bytes at offset 1540096 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1556480 ++read 8192/8192 bytes at offset 1556480 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1572864 ++read 8192/8192 bytes at offset 1572864 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1589248 ++read 8192/8192 bytes at offset 1589248 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1605632 ++read 8192/8192 bytes at offset 1605632 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1622016 ++read 8192/8192 bytes at offset 1622016 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1638400 ++read 8192/8192 bytes at offset 1638400 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1654784 ++read 8192/8192 bytes at offset 1654784 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1671168 ++read 8192/8192 bytes at offset 1671168 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1687552 ++read 8192/8192 bytes at offset 1687552 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1703936 ++read 8192/8192 bytes at offset 1703936 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1720320 ++read 8192/8192 bytes at offset 1720320 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1736704 ++read 8192/8192 bytes at offset 1736704 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1753088 ++read 8192/8192 bytes at offset 1753088 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 136 +-qemu-io> read 8192/8192 bytes at offset 1773568 ++=== IO: pattern 136 ++read 8192/8192 bytes at offset 1773568 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1789952 ++read 8192/8192 bytes at offset 1789952 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1806336 ++read 8192/8192 bytes at offset 1806336 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1822720 ++read 8192/8192 bytes at offset 1822720 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1839104 ++read 8192/8192 bytes at offset 1839104 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1855488 ++read 8192/8192 bytes at offset 1855488 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1871872 ++read 8192/8192 bytes at offset 1871872 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1888256 ++read 8192/8192 bytes at offset 1888256 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1904640 ++read 8192/8192 bytes at offset 1904640 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1921024 ++read 8192/8192 bytes at offset 1921024 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1937408 ++read 8192/8192 bytes at offset 1937408 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1953792 ++read 8192/8192 bytes at offset 1953792 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1970176 ++read 8192/8192 bytes at offset 1970176 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1986560 ++read 8192/8192 bytes at offset 1986560 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2002944 ++read 8192/8192 bytes at offset 2002944 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2019328 ++read 8192/8192 bytes at offset 2019328 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2035712 ++read 8192/8192 bytes at offset 2035712 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2052096 ++read 8192/8192 bytes at offset 2052096 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2068480 ++read 8192/8192 bytes at offset 2068480 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2084864 ++read 8192/8192 bytes at offset 2084864 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2101248 ++read 8192/8192 bytes at offset 2101248 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2117632 ++read 8192/8192 bytes at offset 2117632 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2134016 ++read 8192/8192 bytes at offset 2134016 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2150400 ++read 8192/8192 bytes at offset 2150400 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2166784 ++read 8192/8192 bytes at offset 2166784 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2183168 ++read 8192/8192 bytes at offset 2183168 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2199552 ++read 8192/8192 bytes at offset 2199552 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2215936 ++read 8192/8192 bytes at offset 2215936 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2232320 ++read 8192/8192 bytes at offset 2232320 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2248704 ++read 8192/8192 bytes at offset 2248704 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2265088 ++read 8192/8192 bytes at offset 2265088 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2281472 ++read 8192/8192 bytes at offset 2281472 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2297856 ++read 8192/8192 bytes at offset 2297856 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2314240 ++read 8192/8192 bytes at offset 2314240 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2330624 ++read 8192/8192 bytes at offset 2330624 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2347008 ++read 8192/8192 bytes at offset 2347008 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 16 +-qemu-io> read 32768/32768 bytes at offset 2367488 ++=== IO: pattern 16 ++read 32768/32768 bytes at offset 2367488 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 2416640 ++read 32768/32768 bytes at offset 2416640 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 2465792 ++read 32768/32768 bytes at offset 2465792 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 2514944 ++read 32768/32768 bytes at offset 2514944 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 2564096 ++read 32768/32768 bytes at offset 2564096 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 2613248 ++read 32768/32768 bytes at offset 2613248 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 2662400 ++read 32768/32768 bytes at offset 2662400 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 2711552 ++read 32768/32768 bytes at offset 2711552 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 2760704 ++read 32768/32768 bytes at offset 2760704 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 208 +-qemu-io> read 49152/49152 bytes at offset 33529856 ++=== IO: pattern 208 ++read 49152/49152 bytes at offset 33529856 + 48 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 49152/49152 bytes at offset 67092480 ++read 49152/49152 bytes at offset 67092480 + 48 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 49152/49152 bytes at offset 100655104 ++read 49152/49152 bytes at offset 100655104 + 48 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> wrote 16384/16384 bytes at offset 0 ++=== IO: pattern 0 ++wrote 16384/16384 bytes at offset 0 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 16384 ++wrote 16384/16384 bytes at offset 16384 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 32768 ++wrote 16384/16384 bytes at offset 32768 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 49152 ++wrote 16384/16384 bytes at offset 49152 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 65536 ++wrote 16384/16384 bytes at offset 65536 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 81920 ++wrote 16384/16384 bytes at offset 81920 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 98304 ++wrote 16384/16384 bytes at offset 98304 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 114688 ++wrote 16384/16384 bytes at offset 114688 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 131072 ++wrote 16384/16384 bytes at offset 131072 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 147456 ++wrote 16384/16384 bytes at offset 147456 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 163840 ++wrote 16384/16384 bytes at offset 163840 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 180224 ++wrote 16384/16384 bytes at offset 180224 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 196608 ++wrote 16384/16384 bytes at offset 196608 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 212992 ++wrote 16384/16384 bytes at offset 212992 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 229376 ++wrote 16384/16384 bytes at offset 229376 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 245760 ++wrote 16384/16384 bytes at offset 245760 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 262144 ++wrote 16384/16384 bytes at offset 262144 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 278528 ++wrote 16384/16384 bytes at offset 278528 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 294912 ++wrote 16384/16384 bytes at offset 294912 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 311296 ++wrote 16384/16384 bytes at offset 311296 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 327680 ++wrote 16384/16384 bytes at offset 327680 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 344064 ++wrote 16384/16384 bytes at offset 344064 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 360448 ++wrote 16384/16384 bytes at offset 360448 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 376832 ++wrote 16384/16384 bytes at offset 376832 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 393216 ++wrote 16384/16384 bytes at offset 393216 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 409600 ++wrote 16384/16384 bytes at offset 409600 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 425984 ++wrote 16384/16384 bytes at offset 425984 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 442368 ++wrote 16384/16384 bytes at offset 442368 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 458752 ++wrote 16384/16384 bytes at offset 458752 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 475136 ++wrote 16384/16384 bytes at offset 475136 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 491520 ++wrote 16384/16384 bytes at offset 491520 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 507904 ++wrote 16384/16384 bytes at offset 507904 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 524288 ++wrote 16384/16384 bytes at offset 524288 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 540672 ++wrote 16384/16384 bytes at offset 540672 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 557056 ++wrote 16384/16384 bytes at offset 557056 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 573440 ++wrote 16384/16384 bytes at offset 573440 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 144 +-qemu-io> wrote 8192/8192 bytes at offset 598016 ++=== IO: pattern 144 ++wrote 8192/8192 bytes at offset 598016 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 614400 ++wrote 8192/8192 bytes at offset 614400 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 630784 ++wrote 8192/8192 bytes at offset 630784 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 647168 ++wrote 8192/8192 bytes at offset 647168 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 663552 ++wrote 8192/8192 bytes at offset 663552 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 679936 ++wrote 8192/8192 bytes at offset 679936 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 696320 ++wrote 8192/8192 bytes at offset 696320 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 712704 ++wrote 8192/8192 bytes at offset 712704 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 729088 ++wrote 8192/8192 bytes at offset 729088 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 745472 ++wrote 8192/8192 bytes at offset 745472 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 761856 ++wrote 8192/8192 bytes at offset 761856 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 778240 ++wrote 8192/8192 bytes at offset 778240 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 794624 ++wrote 8192/8192 bytes at offset 794624 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 811008 ++wrote 8192/8192 bytes at offset 811008 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 827392 ++wrote 8192/8192 bytes at offset 827392 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 843776 ++wrote 8192/8192 bytes at offset 843776 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 860160 ++wrote 8192/8192 bytes at offset 860160 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 876544 ++wrote 8192/8192 bytes at offset 876544 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 892928 ++wrote 8192/8192 bytes at offset 892928 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 909312 ++wrote 8192/8192 bytes at offset 909312 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 925696 ++wrote 8192/8192 bytes at offset 925696 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 942080 ++wrote 8192/8192 bytes at offset 942080 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 958464 ++wrote 8192/8192 bytes at offset 958464 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 974848 ++wrote 8192/8192 bytes at offset 974848 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 991232 ++wrote 8192/8192 bytes at offset 991232 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1007616 ++wrote 8192/8192 bytes at offset 1007616 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1024000 ++wrote 8192/8192 bytes at offset 1024000 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1040384 ++wrote 8192/8192 bytes at offset 1040384 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1056768 ++wrote 8192/8192 bytes at offset 1056768 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1073152 ++wrote 8192/8192 bytes at offset 1073152 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1089536 ++wrote 8192/8192 bytes at offset 1089536 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1105920 ++wrote 8192/8192 bytes at offset 1105920 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1122304 ++wrote 8192/8192 bytes at offset 1122304 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1138688 ++wrote 8192/8192 bytes at offset 1138688 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1155072 ++wrote 8192/8192 bytes at offset 1155072 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1171456 ++wrote 8192/8192 bytes at offset 1171456 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> wrote 8192/8192 bytes at offset 1179648 ++=== IO: pattern 0 ++wrote 8192/8192 bytes at offset 1179648 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1196032 ++wrote 8192/8192 bytes at offset 1196032 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1212416 ++wrote 8192/8192 bytes at offset 1212416 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1228800 ++wrote 8192/8192 bytes at offset 1228800 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1245184 ++wrote 8192/8192 bytes at offset 1245184 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1261568 ++wrote 8192/8192 bytes at offset 1261568 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1277952 ++wrote 8192/8192 bytes at offset 1277952 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1294336 ++wrote 8192/8192 bytes at offset 1294336 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1310720 ++wrote 8192/8192 bytes at offset 1310720 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1327104 ++wrote 8192/8192 bytes at offset 1327104 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1343488 ++wrote 8192/8192 bytes at offset 1343488 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1359872 ++wrote 8192/8192 bytes at offset 1359872 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1376256 ++wrote 8192/8192 bytes at offset 1376256 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1392640 ++wrote 8192/8192 bytes at offset 1392640 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1409024 ++wrote 8192/8192 bytes at offset 1409024 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1425408 ++wrote 8192/8192 bytes at offset 1425408 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1441792 ++wrote 8192/8192 bytes at offset 1441792 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1458176 ++wrote 8192/8192 bytes at offset 1458176 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1474560 ++wrote 8192/8192 bytes at offset 1474560 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1490944 ++wrote 8192/8192 bytes at offset 1490944 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1507328 ++wrote 8192/8192 bytes at offset 1507328 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1523712 ++wrote 8192/8192 bytes at offset 1523712 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1540096 ++wrote 8192/8192 bytes at offset 1540096 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1556480 ++wrote 8192/8192 bytes at offset 1556480 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1572864 ++wrote 8192/8192 bytes at offset 1572864 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1589248 ++wrote 8192/8192 bytes at offset 1589248 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1605632 ++wrote 8192/8192 bytes at offset 1605632 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1622016 ++wrote 8192/8192 bytes at offset 1622016 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1638400 ++wrote 8192/8192 bytes at offset 1638400 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1654784 ++wrote 8192/8192 bytes at offset 1654784 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1671168 ++wrote 8192/8192 bytes at offset 1671168 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1687552 ++wrote 8192/8192 bytes at offset 1687552 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1703936 ++wrote 8192/8192 bytes at offset 1703936 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1720320 ++wrote 8192/8192 bytes at offset 1720320 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1736704 ++wrote 8192/8192 bytes at offset 1736704 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1753088 ++wrote 8192/8192 bytes at offset 1753088 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 136 +-qemu-io> wrote 8192/8192 bytes at offset 1773568 ++=== IO: pattern 136 ++wrote 8192/8192 bytes at offset 1773568 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1789952 ++wrote 8192/8192 bytes at offset 1789952 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1806336 ++wrote 8192/8192 bytes at offset 1806336 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1822720 ++wrote 8192/8192 bytes at offset 1822720 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1839104 ++wrote 8192/8192 bytes at offset 1839104 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1855488 ++wrote 8192/8192 bytes at offset 1855488 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1871872 ++wrote 8192/8192 bytes at offset 1871872 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1888256 ++wrote 8192/8192 bytes at offset 1888256 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1904640 ++wrote 8192/8192 bytes at offset 1904640 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1921024 ++wrote 8192/8192 bytes at offset 1921024 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1937408 ++wrote 8192/8192 bytes at offset 1937408 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1953792 ++wrote 8192/8192 bytes at offset 1953792 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1970176 ++wrote 8192/8192 bytes at offset 1970176 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1986560 ++wrote 8192/8192 bytes at offset 1986560 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 2002944 ++wrote 8192/8192 bytes at offset 2002944 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 2019328 ++wrote 8192/8192 bytes at offset 2019328 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 2035712 ++wrote 8192/8192 bytes at offset 2035712 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 2052096 ++wrote 8192/8192 bytes at offset 2052096 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 2068480 ++wrote 8192/8192 bytes at offset 2068480 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 2084864 ++wrote 8192/8192 bytes at offset 2084864 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 2101248 ++wrote 8192/8192 bytes at offset 2101248 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 2117632 ++wrote 8192/8192 bytes at offset 2117632 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 2134016 ++wrote 8192/8192 bytes at offset 2134016 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 2150400 ++wrote 8192/8192 bytes at offset 2150400 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 2166784 ++wrote 8192/8192 bytes at offset 2166784 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 2183168 ++wrote 8192/8192 bytes at offset 2183168 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 2199552 ++wrote 8192/8192 bytes at offset 2199552 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 2215936 ++wrote 8192/8192 bytes at offset 2215936 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 2232320 ++wrote 8192/8192 bytes at offset 2232320 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 2248704 ++wrote 8192/8192 bytes at offset 2248704 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 2265088 ++wrote 8192/8192 bytes at offset 2265088 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 2281472 ++wrote 8192/8192 bytes at offset 2281472 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 2297856 ++wrote 8192/8192 bytes at offset 2297856 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 2314240 ++wrote 8192/8192 bytes at offset 2314240 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 2330624 ++wrote 8192/8192 bytes at offset 2330624 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 2347008 ++wrote 8192/8192 bytes at offset 2347008 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 16 +-qemu-io> wrote 32768/32768 bytes at offset 2367488 ++=== IO: pattern 16 ++wrote 32768/32768 bytes at offset 2367488 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 2416640 ++wrote 32768/32768 bytes at offset 2416640 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 2465792 ++wrote 32768/32768 bytes at offset 2465792 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 2514944 ++wrote 32768/32768 bytes at offset 2514944 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 2564096 ++wrote 32768/32768 bytes at offset 2564096 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 2613248 ++wrote 32768/32768 bytes at offset 2613248 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 2662400 ++wrote 32768/32768 bytes at offset 2662400 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 2711552 ++wrote 32768/32768 bytes at offset 2711552 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 2760704 ++wrote 32768/32768 bytes at offset 2760704 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 208 +-qemu-io> wrote 49152/49152 bytes at offset 33529856 ++=== IO: pattern 208 ++wrote 49152/49152 bytes at offset 33529856 + 48 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 49152/49152 bytes at offset 67092480 ++wrote 49152/49152 bytes at offset 67092480 + 48 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 49152/49152 bytes at offset 100655104 ++wrote 49152/49152 bytes at offset 100655104 + 48 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> read 16384/16384 bytes at offset 0 ++=== IO: pattern 0 ++read 16384/16384 bytes at offset 0 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 16384 ++read 16384/16384 bytes at offset 16384 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 32768 ++read 16384/16384 bytes at offset 32768 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 49152 ++read 16384/16384 bytes at offset 49152 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 65536 ++read 16384/16384 bytes at offset 65536 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 81920 ++read 16384/16384 bytes at offset 81920 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 98304 ++read 16384/16384 bytes at offset 98304 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 114688 ++read 16384/16384 bytes at offset 114688 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 131072 ++read 16384/16384 bytes at offset 131072 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 147456 ++read 16384/16384 bytes at offset 147456 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 163840 ++read 16384/16384 bytes at offset 163840 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 180224 ++read 16384/16384 bytes at offset 180224 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 196608 ++read 16384/16384 bytes at offset 196608 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 212992 ++read 16384/16384 bytes at offset 212992 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 229376 ++read 16384/16384 bytes at offset 229376 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 245760 ++read 16384/16384 bytes at offset 245760 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 262144 ++read 16384/16384 bytes at offset 262144 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 278528 ++read 16384/16384 bytes at offset 278528 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 294912 ++read 16384/16384 bytes at offset 294912 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 311296 ++read 16384/16384 bytes at offset 311296 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 327680 ++read 16384/16384 bytes at offset 327680 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 344064 ++read 16384/16384 bytes at offset 344064 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 360448 ++read 16384/16384 bytes at offset 360448 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 376832 ++read 16384/16384 bytes at offset 376832 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 393216 ++read 16384/16384 bytes at offset 393216 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 409600 ++read 16384/16384 bytes at offset 409600 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 425984 ++read 16384/16384 bytes at offset 425984 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 442368 ++read 16384/16384 bytes at offset 442368 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 458752 ++read 16384/16384 bytes at offset 458752 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 475136 ++read 16384/16384 bytes at offset 475136 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 491520 ++read 16384/16384 bytes at offset 491520 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 507904 ++read 16384/16384 bytes at offset 507904 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 524288 ++read 16384/16384 bytes at offset 524288 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 540672 ++read 16384/16384 bytes at offset 540672 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 557056 ++read 16384/16384 bytes at offset 557056 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 573440 ++read 16384/16384 bytes at offset 573440 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 144 +-qemu-io> read 8192/8192 bytes at offset 598016 ++=== IO: pattern 144 ++read 8192/8192 bytes at offset 598016 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 614400 ++read 8192/8192 bytes at offset 614400 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 630784 ++read 8192/8192 bytes at offset 630784 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 647168 ++read 8192/8192 bytes at offset 647168 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 663552 ++read 8192/8192 bytes at offset 663552 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 679936 ++read 8192/8192 bytes at offset 679936 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 696320 ++read 8192/8192 bytes at offset 696320 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 712704 ++read 8192/8192 bytes at offset 712704 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 729088 ++read 8192/8192 bytes at offset 729088 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 745472 ++read 8192/8192 bytes at offset 745472 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 761856 ++read 8192/8192 bytes at offset 761856 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 778240 ++read 8192/8192 bytes at offset 778240 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 794624 ++read 8192/8192 bytes at offset 794624 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 811008 ++read 8192/8192 bytes at offset 811008 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 827392 ++read 8192/8192 bytes at offset 827392 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 843776 ++read 8192/8192 bytes at offset 843776 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 860160 ++read 8192/8192 bytes at offset 860160 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 876544 ++read 8192/8192 bytes at offset 876544 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 892928 ++read 8192/8192 bytes at offset 892928 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 909312 ++read 8192/8192 bytes at offset 909312 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 925696 ++read 8192/8192 bytes at offset 925696 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 942080 ++read 8192/8192 bytes at offset 942080 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 958464 ++read 8192/8192 bytes at offset 958464 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 974848 ++read 8192/8192 bytes at offset 974848 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 991232 ++read 8192/8192 bytes at offset 991232 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1007616 ++read 8192/8192 bytes at offset 1007616 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1024000 ++read 8192/8192 bytes at offset 1024000 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1040384 ++read 8192/8192 bytes at offset 1040384 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1056768 ++read 8192/8192 bytes at offset 1056768 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1073152 ++read 8192/8192 bytes at offset 1073152 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1089536 ++read 8192/8192 bytes at offset 1089536 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1105920 ++read 8192/8192 bytes at offset 1105920 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1122304 ++read 8192/8192 bytes at offset 1122304 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1138688 ++read 8192/8192 bytes at offset 1138688 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1155072 ++read 8192/8192 bytes at offset 1155072 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1171456 ++read 8192/8192 bytes at offset 1171456 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> read 8192/8192 bytes at offset 1179648 ++=== IO: pattern 0 ++read 8192/8192 bytes at offset 1179648 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1196032 ++read 8192/8192 bytes at offset 1196032 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1212416 ++read 8192/8192 bytes at offset 1212416 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1228800 ++read 8192/8192 bytes at offset 1228800 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1245184 ++read 8192/8192 bytes at offset 1245184 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1261568 ++read 8192/8192 bytes at offset 1261568 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1277952 ++read 8192/8192 bytes at offset 1277952 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1294336 ++read 8192/8192 bytes at offset 1294336 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1310720 ++read 8192/8192 bytes at offset 1310720 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1327104 ++read 8192/8192 bytes at offset 1327104 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1343488 ++read 8192/8192 bytes at offset 1343488 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1359872 ++read 8192/8192 bytes at offset 1359872 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1376256 ++read 8192/8192 bytes at offset 1376256 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1392640 ++read 8192/8192 bytes at offset 1392640 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1409024 ++read 8192/8192 bytes at offset 1409024 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1425408 ++read 8192/8192 bytes at offset 1425408 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1441792 ++read 8192/8192 bytes at offset 1441792 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1458176 ++read 8192/8192 bytes at offset 1458176 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1474560 ++read 8192/8192 bytes at offset 1474560 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1490944 ++read 8192/8192 bytes at offset 1490944 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1507328 ++read 8192/8192 bytes at offset 1507328 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1523712 ++read 8192/8192 bytes at offset 1523712 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1540096 ++read 8192/8192 bytes at offset 1540096 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1556480 ++read 8192/8192 bytes at offset 1556480 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1572864 ++read 8192/8192 bytes at offset 1572864 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1589248 ++read 8192/8192 bytes at offset 1589248 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1605632 ++read 8192/8192 bytes at offset 1605632 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1622016 ++read 8192/8192 bytes at offset 1622016 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1638400 ++read 8192/8192 bytes at offset 1638400 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1654784 ++read 8192/8192 bytes at offset 1654784 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1671168 ++read 8192/8192 bytes at offset 1671168 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1687552 ++read 8192/8192 bytes at offset 1687552 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1703936 ++read 8192/8192 bytes at offset 1703936 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1720320 ++read 8192/8192 bytes at offset 1720320 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1736704 ++read 8192/8192 bytes at offset 1736704 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1753088 ++read 8192/8192 bytes at offset 1753088 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 136 +-qemu-io> read 8192/8192 bytes at offset 1773568 ++=== IO: pattern 136 ++read 8192/8192 bytes at offset 1773568 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1789952 ++read 8192/8192 bytes at offset 1789952 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1806336 ++read 8192/8192 bytes at offset 1806336 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1822720 ++read 8192/8192 bytes at offset 1822720 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1839104 ++read 8192/8192 bytes at offset 1839104 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1855488 ++read 8192/8192 bytes at offset 1855488 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1871872 ++read 8192/8192 bytes at offset 1871872 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1888256 ++read 8192/8192 bytes at offset 1888256 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1904640 ++read 8192/8192 bytes at offset 1904640 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1921024 ++read 8192/8192 bytes at offset 1921024 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1937408 ++read 8192/8192 bytes at offset 1937408 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1953792 ++read 8192/8192 bytes at offset 1953792 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1970176 ++read 8192/8192 bytes at offset 1970176 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1986560 ++read 8192/8192 bytes at offset 1986560 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2002944 ++read 8192/8192 bytes at offset 2002944 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2019328 ++read 8192/8192 bytes at offset 2019328 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2035712 ++read 8192/8192 bytes at offset 2035712 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2052096 ++read 8192/8192 bytes at offset 2052096 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2068480 ++read 8192/8192 bytes at offset 2068480 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2084864 ++read 8192/8192 bytes at offset 2084864 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2101248 ++read 8192/8192 bytes at offset 2101248 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2117632 ++read 8192/8192 bytes at offset 2117632 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2134016 ++read 8192/8192 bytes at offset 2134016 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2150400 ++read 8192/8192 bytes at offset 2150400 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2166784 ++read 8192/8192 bytes at offset 2166784 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2183168 ++read 8192/8192 bytes at offset 2183168 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2199552 ++read 8192/8192 bytes at offset 2199552 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2215936 ++read 8192/8192 bytes at offset 2215936 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2232320 ++read 8192/8192 bytes at offset 2232320 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2248704 ++read 8192/8192 bytes at offset 2248704 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2265088 ++read 8192/8192 bytes at offset 2265088 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2281472 ++read 8192/8192 bytes at offset 2281472 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2297856 ++read 8192/8192 bytes at offset 2297856 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2314240 ++read 8192/8192 bytes at offset 2314240 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2330624 ++read 8192/8192 bytes at offset 2330624 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2347008 ++read 8192/8192 bytes at offset 2347008 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 16 +-qemu-io> read 32768/32768 bytes at offset 2367488 ++=== IO: pattern 16 ++read 32768/32768 bytes at offset 2367488 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 2416640 ++read 32768/32768 bytes at offset 2416640 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 2465792 ++read 32768/32768 bytes at offset 2465792 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 2514944 ++read 32768/32768 bytes at offset 2514944 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 2564096 ++read 32768/32768 bytes at offset 2564096 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 2613248 ++read 32768/32768 bytes at offset 2613248 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 2662400 ++read 32768/32768 bytes at offset 2662400 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 2711552 ++read 32768/32768 bytes at offset 2711552 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 2760704 ++read 32768/32768 bytes at offset 2760704 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 208 +-qemu-io> read 49152/49152 bytes at offset 33529856 ++=== IO: pattern 208 ++read 49152/49152 bytes at offset 33529856 + 48 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 49152/49152 bytes at offset 67092480 ++read 49152/49152 bytes at offset 67092480 + 48 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 49152/49152 bytes at offset 100655104 ++read 49152/49152 bytes at offset 100655104 + 48 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> No errors were found on the image. ++No errors were found on the image. + At offset 4294967296: + === IO: pattern 0 +-qemu-io> wrote 16384/16384 bytes at offset 4294967296 ++wrote 16384/16384 bytes at offset 4294967296 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4294983680 ++wrote 16384/16384 bytes at offset 4294983680 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295000064 ++wrote 16384/16384 bytes at offset 4295000064 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295016448 ++wrote 16384/16384 bytes at offset 4295016448 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295032832 ++wrote 16384/16384 bytes at offset 4295032832 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295049216 ++wrote 16384/16384 bytes at offset 4295049216 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295065600 ++wrote 16384/16384 bytes at offset 4295065600 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295081984 ++wrote 16384/16384 bytes at offset 4295081984 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295098368 ++wrote 16384/16384 bytes at offset 4295098368 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295114752 ++wrote 16384/16384 bytes at offset 4295114752 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295131136 ++wrote 16384/16384 bytes at offset 4295131136 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295147520 ++wrote 16384/16384 bytes at offset 4295147520 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295163904 ++wrote 16384/16384 bytes at offset 4295163904 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295180288 ++wrote 16384/16384 bytes at offset 4295180288 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295196672 ++wrote 16384/16384 bytes at offset 4295196672 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295213056 ++wrote 16384/16384 bytes at offset 4295213056 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295229440 ++wrote 16384/16384 bytes at offset 4295229440 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295245824 ++wrote 16384/16384 bytes at offset 4295245824 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295262208 ++wrote 16384/16384 bytes at offset 4295262208 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295278592 ++wrote 16384/16384 bytes at offset 4295278592 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295294976 ++wrote 16384/16384 bytes at offset 4295294976 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295311360 ++wrote 16384/16384 bytes at offset 4295311360 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295327744 ++wrote 16384/16384 bytes at offset 4295327744 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295344128 ++wrote 16384/16384 bytes at offset 4295344128 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295360512 ++wrote 16384/16384 bytes at offset 4295360512 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295376896 ++wrote 16384/16384 bytes at offset 4295376896 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295393280 ++wrote 16384/16384 bytes at offset 4295393280 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295409664 ++wrote 16384/16384 bytes at offset 4295409664 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295426048 ++wrote 16384/16384 bytes at offset 4295426048 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295442432 ++wrote 16384/16384 bytes at offset 4295442432 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295458816 ++wrote 16384/16384 bytes at offset 4295458816 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295475200 ++wrote 16384/16384 bytes at offset 4295475200 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295491584 ++wrote 16384/16384 bytes at offset 4295491584 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295507968 ++wrote 16384/16384 bytes at offset 4295507968 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295524352 ++wrote 16384/16384 bytes at offset 4295524352 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295540736 ++wrote 16384/16384 bytes at offset 4295540736 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 144 +-qemu-io> wrote 8192/8192 bytes at offset 4295565312 ++=== IO: pattern 144 ++wrote 8192/8192 bytes at offset 4295565312 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295581696 ++wrote 8192/8192 bytes at offset 4295581696 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295598080 ++wrote 8192/8192 bytes at offset 4295598080 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295614464 ++wrote 8192/8192 bytes at offset 4295614464 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295630848 ++wrote 8192/8192 bytes at offset 4295630848 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295647232 ++wrote 8192/8192 bytes at offset 4295647232 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295663616 ++wrote 8192/8192 bytes at offset 4295663616 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295680000 ++wrote 8192/8192 bytes at offset 4295680000 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295696384 ++wrote 8192/8192 bytes at offset 4295696384 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295712768 ++wrote 8192/8192 bytes at offset 4295712768 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295729152 ++wrote 8192/8192 bytes at offset 4295729152 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295745536 ++wrote 8192/8192 bytes at offset 4295745536 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295761920 ++wrote 8192/8192 bytes at offset 4295761920 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295778304 ++wrote 8192/8192 bytes at offset 4295778304 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295794688 ++wrote 8192/8192 bytes at offset 4295794688 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295811072 ++wrote 8192/8192 bytes at offset 4295811072 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295827456 ++wrote 8192/8192 bytes at offset 4295827456 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295843840 ++wrote 8192/8192 bytes at offset 4295843840 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295860224 ++wrote 8192/8192 bytes at offset 4295860224 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295876608 ++wrote 8192/8192 bytes at offset 4295876608 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295892992 ++wrote 8192/8192 bytes at offset 4295892992 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295909376 ++wrote 8192/8192 bytes at offset 4295909376 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295925760 ++wrote 8192/8192 bytes at offset 4295925760 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295942144 ++wrote 8192/8192 bytes at offset 4295942144 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295958528 ++wrote 8192/8192 bytes at offset 4295958528 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295974912 ++wrote 8192/8192 bytes at offset 4295974912 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295991296 ++wrote 8192/8192 bytes at offset 4295991296 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296007680 ++wrote 8192/8192 bytes at offset 4296007680 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296024064 ++wrote 8192/8192 bytes at offset 4296024064 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296040448 ++wrote 8192/8192 bytes at offset 4296040448 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296056832 ++wrote 8192/8192 bytes at offset 4296056832 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296073216 ++wrote 8192/8192 bytes at offset 4296073216 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296089600 ++wrote 8192/8192 bytes at offset 4296089600 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296105984 ++wrote 8192/8192 bytes at offset 4296105984 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296122368 ++wrote 8192/8192 bytes at offset 4296122368 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296138752 ++wrote 8192/8192 bytes at offset 4296138752 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> wrote 8192/8192 bytes at offset 4296146944 ++=== IO: pattern 0 ++wrote 8192/8192 bytes at offset 4296146944 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296163328 ++wrote 8192/8192 bytes at offset 4296163328 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296179712 ++wrote 8192/8192 bytes at offset 4296179712 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296196096 ++wrote 8192/8192 bytes at offset 4296196096 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296212480 ++wrote 8192/8192 bytes at offset 4296212480 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296228864 ++wrote 8192/8192 bytes at offset 4296228864 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296245248 ++wrote 8192/8192 bytes at offset 4296245248 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296261632 ++wrote 8192/8192 bytes at offset 4296261632 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296278016 ++wrote 8192/8192 bytes at offset 4296278016 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296294400 ++wrote 8192/8192 bytes at offset 4296294400 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296310784 ++wrote 8192/8192 bytes at offset 4296310784 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296327168 ++wrote 8192/8192 bytes at offset 4296327168 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296343552 ++wrote 8192/8192 bytes at offset 4296343552 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296359936 ++wrote 8192/8192 bytes at offset 4296359936 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296376320 ++wrote 8192/8192 bytes at offset 4296376320 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296392704 ++wrote 8192/8192 bytes at offset 4296392704 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296409088 ++wrote 8192/8192 bytes at offset 4296409088 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296425472 ++wrote 8192/8192 bytes at offset 4296425472 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296441856 ++wrote 8192/8192 bytes at offset 4296441856 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296458240 ++wrote 8192/8192 bytes at offset 4296458240 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296474624 ++wrote 8192/8192 bytes at offset 4296474624 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296491008 ++wrote 8192/8192 bytes at offset 4296491008 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296507392 ++wrote 8192/8192 bytes at offset 4296507392 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296523776 ++wrote 8192/8192 bytes at offset 4296523776 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296540160 ++wrote 8192/8192 bytes at offset 4296540160 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296556544 ++wrote 8192/8192 bytes at offset 4296556544 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296572928 ++wrote 8192/8192 bytes at offset 4296572928 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296589312 ++wrote 8192/8192 bytes at offset 4296589312 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296605696 ++wrote 8192/8192 bytes at offset 4296605696 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296622080 ++wrote 8192/8192 bytes at offset 4296622080 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296638464 ++wrote 8192/8192 bytes at offset 4296638464 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296654848 ++wrote 8192/8192 bytes at offset 4296654848 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296671232 ++wrote 8192/8192 bytes at offset 4296671232 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296687616 ++wrote 8192/8192 bytes at offset 4296687616 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296704000 ++wrote 8192/8192 bytes at offset 4296704000 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296720384 ++wrote 8192/8192 bytes at offset 4296720384 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 136 +-qemu-io> wrote 8192/8192 bytes at offset 4296740864 ++=== IO: pattern 136 ++wrote 8192/8192 bytes at offset 4296740864 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296757248 ++wrote 8192/8192 bytes at offset 4296757248 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296773632 ++wrote 8192/8192 bytes at offset 4296773632 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296790016 ++wrote 8192/8192 bytes at offset 4296790016 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296806400 ++wrote 8192/8192 bytes at offset 4296806400 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296822784 ++wrote 8192/8192 bytes at offset 4296822784 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296839168 ++wrote 8192/8192 bytes at offset 4296839168 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296855552 ++wrote 8192/8192 bytes at offset 4296855552 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296871936 ++wrote 8192/8192 bytes at offset 4296871936 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296888320 ++wrote 8192/8192 bytes at offset 4296888320 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296904704 ++wrote 8192/8192 bytes at offset 4296904704 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296921088 ++wrote 8192/8192 bytes at offset 4296921088 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296937472 ++wrote 8192/8192 bytes at offset 4296937472 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296953856 ++wrote 8192/8192 bytes at offset 4296953856 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296970240 ++wrote 8192/8192 bytes at offset 4296970240 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296986624 ++wrote 8192/8192 bytes at offset 4296986624 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4297003008 ++wrote 8192/8192 bytes at offset 4297003008 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4297019392 ++wrote 8192/8192 bytes at offset 4297019392 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4297035776 ++wrote 8192/8192 bytes at offset 4297035776 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4297052160 ++wrote 8192/8192 bytes at offset 4297052160 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4297068544 ++wrote 8192/8192 bytes at offset 4297068544 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4297084928 ++wrote 8192/8192 bytes at offset 4297084928 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4297101312 ++wrote 8192/8192 bytes at offset 4297101312 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4297117696 ++wrote 8192/8192 bytes at offset 4297117696 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4297134080 ++wrote 8192/8192 bytes at offset 4297134080 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4297150464 ++wrote 8192/8192 bytes at offset 4297150464 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4297166848 ++wrote 8192/8192 bytes at offset 4297166848 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4297183232 ++wrote 8192/8192 bytes at offset 4297183232 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4297199616 ++wrote 8192/8192 bytes at offset 4297199616 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4297216000 ++wrote 8192/8192 bytes at offset 4297216000 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4297232384 ++wrote 8192/8192 bytes at offset 4297232384 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4297248768 ++wrote 8192/8192 bytes at offset 4297248768 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4297265152 ++wrote 8192/8192 bytes at offset 4297265152 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4297281536 ++wrote 8192/8192 bytes at offset 4297281536 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4297297920 ++wrote 8192/8192 bytes at offset 4297297920 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4297314304 ++wrote 8192/8192 bytes at offset 4297314304 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 16 +-qemu-io> wrote 32768/32768 bytes at offset 4297334784 ++=== IO: pattern 16 ++wrote 32768/32768 bytes at offset 4297334784 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4297383936 ++wrote 32768/32768 bytes at offset 4297383936 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4297433088 ++wrote 32768/32768 bytes at offset 4297433088 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4297482240 ++wrote 32768/32768 bytes at offset 4297482240 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4297531392 ++wrote 32768/32768 bytes at offset 4297531392 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4297580544 ++wrote 32768/32768 bytes at offset 4297580544 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4297629696 ++wrote 32768/32768 bytes at offset 4297629696 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4297678848 ++wrote 32768/32768 bytes at offset 4297678848 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4297728000 ++wrote 32768/32768 bytes at offset 4297728000 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 208 +-qemu-io> wrote 49152/49152 bytes at offset 4328497152 ++=== IO: pattern 208 ++wrote 49152/49152 bytes at offset 4328497152 + 48 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 49152/49152 bytes at offset 4362059776 ++wrote 49152/49152 bytes at offset 4362059776 + 48 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 49152/49152 bytes at offset 4395622400 ++wrote 49152/49152 bytes at offset 4395622400 + 48 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> read 16384/16384 bytes at offset 4294967296 ++=== IO: pattern 0 ++read 16384/16384 bytes at offset 4294967296 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4294983680 ++read 16384/16384 bytes at offset 4294983680 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295000064 ++read 16384/16384 bytes at offset 4295000064 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295016448 ++read 16384/16384 bytes at offset 4295016448 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295032832 ++read 16384/16384 bytes at offset 4295032832 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295049216 ++read 16384/16384 bytes at offset 4295049216 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295065600 ++read 16384/16384 bytes at offset 4295065600 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295081984 ++read 16384/16384 bytes at offset 4295081984 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295098368 ++read 16384/16384 bytes at offset 4295098368 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295114752 ++read 16384/16384 bytes at offset 4295114752 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295131136 ++read 16384/16384 bytes at offset 4295131136 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295147520 ++read 16384/16384 bytes at offset 4295147520 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295163904 ++read 16384/16384 bytes at offset 4295163904 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295180288 ++read 16384/16384 bytes at offset 4295180288 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295196672 ++read 16384/16384 bytes at offset 4295196672 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295213056 ++read 16384/16384 bytes at offset 4295213056 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295229440 ++read 16384/16384 bytes at offset 4295229440 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295245824 ++read 16384/16384 bytes at offset 4295245824 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295262208 ++read 16384/16384 bytes at offset 4295262208 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295278592 ++read 16384/16384 bytes at offset 4295278592 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295294976 ++read 16384/16384 bytes at offset 4295294976 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295311360 ++read 16384/16384 bytes at offset 4295311360 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295327744 ++read 16384/16384 bytes at offset 4295327744 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295344128 ++read 16384/16384 bytes at offset 4295344128 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295360512 ++read 16384/16384 bytes at offset 4295360512 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295376896 ++read 16384/16384 bytes at offset 4295376896 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295393280 ++read 16384/16384 bytes at offset 4295393280 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295409664 ++read 16384/16384 bytes at offset 4295409664 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295426048 ++read 16384/16384 bytes at offset 4295426048 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295442432 ++read 16384/16384 bytes at offset 4295442432 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295458816 ++read 16384/16384 bytes at offset 4295458816 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295475200 ++read 16384/16384 bytes at offset 4295475200 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295491584 ++read 16384/16384 bytes at offset 4295491584 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295507968 ++read 16384/16384 bytes at offset 4295507968 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295524352 ++read 16384/16384 bytes at offset 4295524352 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295540736 ++read 16384/16384 bytes at offset 4295540736 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 144 +-qemu-io> read 8192/8192 bytes at offset 4295565312 ++=== IO: pattern 144 ++read 8192/8192 bytes at offset 4295565312 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295581696 ++read 8192/8192 bytes at offset 4295581696 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295598080 ++read 8192/8192 bytes at offset 4295598080 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295614464 ++read 8192/8192 bytes at offset 4295614464 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295630848 ++read 8192/8192 bytes at offset 4295630848 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295647232 ++read 8192/8192 bytes at offset 4295647232 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295663616 ++read 8192/8192 bytes at offset 4295663616 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295680000 ++read 8192/8192 bytes at offset 4295680000 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295696384 ++read 8192/8192 bytes at offset 4295696384 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295712768 ++read 8192/8192 bytes at offset 4295712768 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295729152 ++read 8192/8192 bytes at offset 4295729152 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295745536 ++read 8192/8192 bytes at offset 4295745536 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295761920 ++read 8192/8192 bytes at offset 4295761920 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295778304 ++read 8192/8192 bytes at offset 4295778304 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295794688 ++read 8192/8192 bytes at offset 4295794688 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295811072 ++read 8192/8192 bytes at offset 4295811072 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295827456 ++read 8192/8192 bytes at offset 4295827456 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295843840 ++read 8192/8192 bytes at offset 4295843840 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295860224 ++read 8192/8192 bytes at offset 4295860224 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295876608 ++read 8192/8192 bytes at offset 4295876608 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295892992 ++read 8192/8192 bytes at offset 4295892992 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295909376 ++read 8192/8192 bytes at offset 4295909376 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295925760 ++read 8192/8192 bytes at offset 4295925760 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295942144 ++read 8192/8192 bytes at offset 4295942144 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295958528 ++read 8192/8192 bytes at offset 4295958528 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295974912 ++read 8192/8192 bytes at offset 4295974912 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295991296 ++read 8192/8192 bytes at offset 4295991296 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296007680 ++read 8192/8192 bytes at offset 4296007680 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296024064 ++read 8192/8192 bytes at offset 4296024064 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296040448 ++read 8192/8192 bytes at offset 4296040448 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296056832 ++read 8192/8192 bytes at offset 4296056832 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296073216 ++read 8192/8192 bytes at offset 4296073216 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296089600 ++read 8192/8192 bytes at offset 4296089600 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296105984 ++read 8192/8192 bytes at offset 4296105984 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296122368 ++read 8192/8192 bytes at offset 4296122368 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296138752 ++read 8192/8192 bytes at offset 4296138752 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> read 8192/8192 bytes at offset 4296146944 ++=== IO: pattern 0 ++read 8192/8192 bytes at offset 4296146944 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296163328 ++read 8192/8192 bytes at offset 4296163328 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296179712 ++read 8192/8192 bytes at offset 4296179712 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296196096 ++read 8192/8192 bytes at offset 4296196096 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296212480 ++read 8192/8192 bytes at offset 4296212480 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296228864 ++read 8192/8192 bytes at offset 4296228864 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296245248 ++read 8192/8192 bytes at offset 4296245248 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296261632 ++read 8192/8192 bytes at offset 4296261632 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296278016 ++read 8192/8192 bytes at offset 4296278016 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296294400 ++read 8192/8192 bytes at offset 4296294400 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296310784 ++read 8192/8192 bytes at offset 4296310784 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296327168 ++read 8192/8192 bytes at offset 4296327168 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296343552 ++read 8192/8192 bytes at offset 4296343552 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296359936 ++read 8192/8192 bytes at offset 4296359936 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296376320 ++read 8192/8192 bytes at offset 4296376320 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296392704 ++read 8192/8192 bytes at offset 4296392704 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296409088 ++read 8192/8192 bytes at offset 4296409088 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296425472 ++read 8192/8192 bytes at offset 4296425472 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296441856 ++read 8192/8192 bytes at offset 4296441856 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296458240 ++read 8192/8192 bytes at offset 4296458240 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296474624 ++read 8192/8192 bytes at offset 4296474624 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296491008 ++read 8192/8192 bytes at offset 4296491008 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296507392 ++read 8192/8192 bytes at offset 4296507392 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296523776 ++read 8192/8192 bytes at offset 4296523776 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296540160 ++read 8192/8192 bytes at offset 4296540160 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296556544 ++read 8192/8192 bytes at offset 4296556544 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296572928 ++read 8192/8192 bytes at offset 4296572928 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296589312 ++read 8192/8192 bytes at offset 4296589312 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296605696 ++read 8192/8192 bytes at offset 4296605696 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296622080 ++read 8192/8192 bytes at offset 4296622080 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296638464 ++read 8192/8192 bytes at offset 4296638464 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296654848 ++read 8192/8192 bytes at offset 4296654848 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296671232 ++read 8192/8192 bytes at offset 4296671232 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296687616 ++read 8192/8192 bytes at offset 4296687616 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296704000 ++read 8192/8192 bytes at offset 4296704000 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296720384 ++read 8192/8192 bytes at offset 4296720384 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 136 +-qemu-io> read 8192/8192 bytes at offset 4296740864 ++=== IO: pattern 136 ++read 8192/8192 bytes at offset 4296740864 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296757248 ++read 8192/8192 bytes at offset 4296757248 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296773632 ++read 8192/8192 bytes at offset 4296773632 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296790016 ++read 8192/8192 bytes at offset 4296790016 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296806400 ++read 8192/8192 bytes at offset 4296806400 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296822784 ++read 8192/8192 bytes at offset 4296822784 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296839168 ++read 8192/8192 bytes at offset 4296839168 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296855552 ++read 8192/8192 bytes at offset 4296855552 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296871936 ++read 8192/8192 bytes at offset 4296871936 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296888320 ++read 8192/8192 bytes at offset 4296888320 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296904704 ++read 8192/8192 bytes at offset 4296904704 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296921088 ++read 8192/8192 bytes at offset 4296921088 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296937472 ++read 8192/8192 bytes at offset 4296937472 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296953856 ++read 8192/8192 bytes at offset 4296953856 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296970240 ++read 8192/8192 bytes at offset 4296970240 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296986624 ++read 8192/8192 bytes at offset 4296986624 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297003008 ++read 8192/8192 bytes at offset 4297003008 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297019392 ++read 8192/8192 bytes at offset 4297019392 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297035776 ++read 8192/8192 bytes at offset 4297035776 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297052160 ++read 8192/8192 bytes at offset 4297052160 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297068544 ++read 8192/8192 bytes at offset 4297068544 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297084928 ++read 8192/8192 bytes at offset 4297084928 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297101312 ++read 8192/8192 bytes at offset 4297101312 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297117696 ++read 8192/8192 bytes at offset 4297117696 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297134080 ++read 8192/8192 bytes at offset 4297134080 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297150464 ++read 8192/8192 bytes at offset 4297150464 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297166848 ++read 8192/8192 bytes at offset 4297166848 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297183232 ++read 8192/8192 bytes at offset 4297183232 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297199616 ++read 8192/8192 bytes at offset 4297199616 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297216000 ++read 8192/8192 bytes at offset 4297216000 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297232384 ++read 8192/8192 bytes at offset 4297232384 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297248768 ++read 8192/8192 bytes at offset 4297248768 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297265152 ++read 8192/8192 bytes at offset 4297265152 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297281536 ++read 8192/8192 bytes at offset 4297281536 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297297920 ++read 8192/8192 bytes at offset 4297297920 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297314304 ++read 8192/8192 bytes at offset 4297314304 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 16 +-qemu-io> read 32768/32768 bytes at offset 4297334784 ++=== IO: pattern 16 ++read 32768/32768 bytes at offset 4297334784 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4297383936 ++read 32768/32768 bytes at offset 4297383936 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4297433088 ++read 32768/32768 bytes at offset 4297433088 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4297482240 ++read 32768/32768 bytes at offset 4297482240 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4297531392 ++read 32768/32768 bytes at offset 4297531392 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4297580544 ++read 32768/32768 bytes at offset 4297580544 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4297629696 ++read 32768/32768 bytes at offset 4297629696 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4297678848 ++read 32768/32768 bytes at offset 4297678848 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4297728000 ++read 32768/32768 bytes at offset 4297728000 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 208 +-qemu-io> read 49152/49152 bytes at offset 4328497152 ++=== IO: pattern 208 ++read 49152/49152 bytes at offset 4328497152 + 48 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 49152/49152 bytes at offset 4362059776 ++read 49152/49152 bytes at offset 4362059776 + 48 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 49152/49152 bytes at offset 4395622400 ++read 49152/49152 bytes at offset 4395622400 + 48 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> wrote 16384/16384 bytes at offset 4294967296 ++=== IO: pattern 0 ++wrote 16384/16384 bytes at offset 4294967296 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4294983680 ++wrote 16384/16384 bytes at offset 4294983680 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295000064 ++wrote 16384/16384 bytes at offset 4295000064 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295016448 ++wrote 16384/16384 bytes at offset 4295016448 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295032832 ++wrote 16384/16384 bytes at offset 4295032832 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295049216 ++wrote 16384/16384 bytes at offset 4295049216 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295065600 ++wrote 16384/16384 bytes at offset 4295065600 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295081984 ++wrote 16384/16384 bytes at offset 4295081984 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295098368 ++wrote 16384/16384 bytes at offset 4295098368 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295114752 ++wrote 16384/16384 bytes at offset 4295114752 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295131136 ++wrote 16384/16384 bytes at offset 4295131136 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295147520 ++wrote 16384/16384 bytes at offset 4295147520 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295163904 ++wrote 16384/16384 bytes at offset 4295163904 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295180288 ++wrote 16384/16384 bytes at offset 4295180288 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295196672 ++wrote 16384/16384 bytes at offset 4295196672 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295213056 ++wrote 16384/16384 bytes at offset 4295213056 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295229440 ++wrote 16384/16384 bytes at offset 4295229440 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295245824 ++wrote 16384/16384 bytes at offset 4295245824 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295262208 ++wrote 16384/16384 bytes at offset 4295262208 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295278592 ++wrote 16384/16384 bytes at offset 4295278592 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295294976 ++wrote 16384/16384 bytes at offset 4295294976 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295311360 ++wrote 16384/16384 bytes at offset 4295311360 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295327744 ++wrote 16384/16384 bytes at offset 4295327744 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295344128 ++wrote 16384/16384 bytes at offset 4295344128 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295360512 ++wrote 16384/16384 bytes at offset 4295360512 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295376896 ++wrote 16384/16384 bytes at offset 4295376896 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295393280 ++wrote 16384/16384 bytes at offset 4295393280 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295409664 ++wrote 16384/16384 bytes at offset 4295409664 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295426048 ++wrote 16384/16384 bytes at offset 4295426048 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295442432 ++wrote 16384/16384 bytes at offset 4295442432 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295458816 ++wrote 16384/16384 bytes at offset 4295458816 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295475200 ++wrote 16384/16384 bytes at offset 4295475200 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295491584 ++wrote 16384/16384 bytes at offset 4295491584 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295507968 ++wrote 16384/16384 bytes at offset 4295507968 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295524352 ++wrote 16384/16384 bytes at offset 4295524352 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295540736 ++wrote 16384/16384 bytes at offset 4295540736 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 144 +-qemu-io> wrote 8192/8192 bytes at offset 4295565312 ++=== IO: pattern 144 ++wrote 8192/8192 bytes at offset 4295565312 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295581696 ++wrote 8192/8192 bytes at offset 4295581696 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295598080 ++wrote 8192/8192 bytes at offset 4295598080 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295614464 ++wrote 8192/8192 bytes at offset 4295614464 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295630848 ++wrote 8192/8192 bytes at offset 4295630848 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295647232 ++wrote 8192/8192 bytes at offset 4295647232 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295663616 ++wrote 8192/8192 bytes at offset 4295663616 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295680000 ++wrote 8192/8192 bytes at offset 4295680000 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295696384 ++wrote 8192/8192 bytes at offset 4295696384 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295712768 ++wrote 8192/8192 bytes at offset 4295712768 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295729152 ++wrote 8192/8192 bytes at offset 4295729152 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295745536 ++wrote 8192/8192 bytes at offset 4295745536 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295761920 ++wrote 8192/8192 bytes at offset 4295761920 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295778304 ++wrote 8192/8192 bytes at offset 4295778304 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295794688 ++wrote 8192/8192 bytes at offset 4295794688 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295811072 ++wrote 8192/8192 bytes at offset 4295811072 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295827456 ++wrote 8192/8192 bytes at offset 4295827456 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295843840 ++wrote 8192/8192 bytes at offset 4295843840 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295860224 ++wrote 8192/8192 bytes at offset 4295860224 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295876608 ++wrote 8192/8192 bytes at offset 4295876608 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295892992 ++wrote 8192/8192 bytes at offset 4295892992 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295909376 ++wrote 8192/8192 bytes at offset 4295909376 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295925760 ++wrote 8192/8192 bytes at offset 4295925760 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295942144 ++wrote 8192/8192 bytes at offset 4295942144 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295958528 ++wrote 8192/8192 bytes at offset 4295958528 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295974912 ++wrote 8192/8192 bytes at offset 4295974912 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295991296 ++wrote 8192/8192 bytes at offset 4295991296 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296007680 ++wrote 8192/8192 bytes at offset 4296007680 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296024064 ++wrote 8192/8192 bytes at offset 4296024064 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296040448 ++wrote 8192/8192 bytes at offset 4296040448 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296056832 ++wrote 8192/8192 bytes at offset 4296056832 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296073216 ++wrote 8192/8192 bytes at offset 4296073216 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296089600 ++wrote 8192/8192 bytes at offset 4296089600 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296105984 ++wrote 8192/8192 bytes at offset 4296105984 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296122368 ++wrote 8192/8192 bytes at offset 4296122368 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296138752 ++wrote 8192/8192 bytes at offset 4296138752 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> wrote 8192/8192 bytes at offset 4296146944 ++=== IO: pattern 0 ++wrote 8192/8192 bytes at offset 4296146944 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296163328 ++wrote 8192/8192 bytes at offset 4296163328 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296179712 ++wrote 8192/8192 bytes at offset 4296179712 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296196096 ++wrote 8192/8192 bytes at offset 4296196096 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296212480 ++wrote 8192/8192 bytes at offset 4296212480 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296228864 ++wrote 8192/8192 bytes at offset 4296228864 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296245248 ++wrote 8192/8192 bytes at offset 4296245248 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296261632 ++wrote 8192/8192 bytes at offset 4296261632 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296278016 ++wrote 8192/8192 bytes at offset 4296278016 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296294400 ++wrote 8192/8192 bytes at offset 4296294400 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296310784 ++wrote 8192/8192 bytes at offset 4296310784 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296327168 ++wrote 8192/8192 bytes at offset 4296327168 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296343552 ++wrote 8192/8192 bytes at offset 4296343552 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296359936 ++wrote 8192/8192 bytes at offset 4296359936 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296376320 ++wrote 8192/8192 bytes at offset 4296376320 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296392704 ++wrote 8192/8192 bytes at offset 4296392704 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296409088 ++wrote 8192/8192 bytes at offset 4296409088 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296425472 ++wrote 8192/8192 bytes at offset 4296425472 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296441856 ++wrote 8192/8192 bytes at offset 4296441856 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296458240 ++wrote 8192/8192 bytes at offset 4296458240 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296474624 ++wrote 8192/8192 bytes at offset 4296474624 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296491008 ++wrote 8192/8192 bytes at offset 4296491008 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296507392 ++wrote 8192/8192 bytes at offset 4296507392 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296523776 ++wrote 8192/8192 bytes at offset 4296523776 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296540160 ++wrote 8192/8192 bytes at offset 4296540160 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296556544 ++wrote 8192/8192 bytes at offset 4296556544 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296572928 ++wrote 8192/8192 bytes at offset 4296572928 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296589312 ++wrote 8192/8192 bytes at offset 4296589312 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296605696 ++wrote 8192/8192 bytes at offset 4296605696 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296622080 ++wrote 8192/8192 bytes at offset 4296622080 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296638464 ++wrote 8192/8192 bytes at offset 4296638464 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296654848 ++wrote 8192/8192 bytes at offset 4296654848 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296671232 ++wrote 8192/8192 bytes at offset 4296671232 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296687616 ++wrote 8192/8192 bytes at offset 4296687616 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296704000 ++wrote 8192/8192 bytes at offset 4296704000 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296720384 ++wrote 8192/8192 bytes at offset 4296720384 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 136 +-qemu-io> wrote 8192/8192 bytes at offset 4296740864 ++=== IO: pattern 136 ++wrote 8192/8192 bytes at offset 4296740864 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296757248 ++wrote 8192/8192 bytes at offset 4296757248 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296773632 ++wrote 8192/8192 bytes at offset 4296773632 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296790016 ++wrote 8192/8192 bytes at offset 4296790016 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296806400 ++wrote 8192/8192 bytes at offset 4296806400 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296822784 ++wrote 8192/8192 bytes at offset 4296822784 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296839168 ++wrote 8192/8192 bytes at offset 4296839168 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296855552 ++wrote 8192/8192 bytes at offset 4296855552 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296871936 ++wrote 8192/8192 bytes at offset 4296871936 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296888320 ++wrote 8192/8192 bytes at offset 4296888320 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296904704 ++wrote 8192/8192 bytes at offset 4296904704 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296921088 ++wrote 8192/8192 bytes at offset 4296921088 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296937472 ++wrote 8192/8192 bytes at offset 4296937472 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296953856 ++wrote 8192/8192 bytes at offset 4296953856 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296970240 ++wrote 8192/8192 bytes at offset 4296970240 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296986624 ++wrote 8192/8192 bytes at offset 4296986624 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4297003008 ++wrote 8192/8192 bytes at offset 4297003008 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4297019392 ++wrote 8192/8192 bytes at offset 4297019392 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4297035776 ++wrote 8192/8192 bytes at offset 4297035776 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4297052160 ++wrote 8192/8192 bytes at offset 4297052160 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4297068544 ++wrote 8192/8192 bytes at offset 4297068544 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4297084928 ++wrote 8192/8192 bytes at offset 4297084928 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4297101312 ++wrote 8192/8192 bytes at offset 4297101312 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4297117696 ++wrote 8192/8192 bytes at offset 4297117696 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4297134080 ++wrote 8192/8192 bytes at offset 4297134080 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4297150464 ++wrote 8192/8192 bytes at offset 4297150464 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4297166848 ++wrote 8192/8192 bytes at offset 4297166848 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4297183232 ++wrote 8192/8192 bytes at offset 4297183232 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4297199616 ++wrote 8192/8192 bytes at offset 4297199616 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4297216000 ++wrote 8192/8192 bytes at offset 4297216000 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4297232384 ++wrote 8192/8192 bytes at offset 4297232384 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4297248768 ++wrote 8192/8192 bytes at offset 4297248768 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4297265152 ++wrote 8192/8192 bytes at offset 4297265152 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4297281536 ++wrote 8192/8192 bytes at offset 4297281536 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4297297920 ++wrote 8192/8192 bytes at offset 4297297920 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4297314304 ++wrote 8192/8192 bytes at offset 4297314304 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 16 +-qemu-io> wrote 32768/32768 bytes at offset 4297334784 ++=== IO: pattern 16 ++wrote 32768/32768 bytes at offset 4297334784 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4297383936 ++wrote 32768/32768 bytes at offset 4297383936 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4297433088 ++wrote 32768/32768 bytes at offset 4297433088 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4297482240 ++wrote 32768/32768 bytes at offset 4297482240 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4297531392 ++wrote 32768/32768 bytes at offset 4297531392 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4297580544 ++wrote 32768/32768 bytes at offset 4297580544 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4297629696 ++wrote 32768/32768 bytes at offset 4297629696 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4297678848 ++wrote 32768/32768 bytes at offset 4297678848 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4297728000 ++wrote 32768/32768 bytes at offset 4297728000 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 208 +-qemu-io> wrote 49152/49152 bytes at offset 4328497152 ++=== IO: pattern 208 ++wrote 49152/49152 bytes at offset 4328497152 + 48 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 49152/49152 bytes at offset 4362059776 ++wrote 49152/49152 bytes at offset 4362059776 + 48 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 49152/49152 bytes at offset 4395622400 ++wrote 49152/49152 bytes at offset 4395622400 + 48 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> read 16384/16384 bytes at offset 4294967296 ++=== IO: pattern 0 ++read 16384/16384 bytes at offset 4294967296 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4294983680 ++read 16384/16384 bytes at offset 4294983680 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295000064 ++read 16384/16384 bytes at offset 4295000064 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295016448 ++read 16384/16384 bytes at offset 4295016448 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295032832 ++read 16384/16384 bytes at offset 4295032832 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295049216 ++read 16384/16384 bytes at offset 4295049216 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295065600 ++read 16384/16384 bytes at offset 4295065600 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295081984 ++read 16384/16384 bytes at offset 4295081984 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295098368 ++read 16384/16384 bytes at offset 4295098368 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295114752 ++read 16384/16384 bytes at offset 4295114752 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295131136 ++read 16384/16384 bytes at offset 4295131136 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295147520 ++read 16384/16384 bytes at offset 4295147520 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295163904 ++read 16384/16384 bytes at offset 4295163904 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295180288 ++read 16384/16384 bytes at offset 4295180288 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295196672 ++read 16384/16384 bytes at offset 4295196672 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295213056 ++read 16384/16384 bytes at offset 4295213056 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295229440 ++read 16384/16384 bytes at offset 4295229440 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295245824 ++read 16384/16384 bytes at offset 4295245824 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295262208 ++read 16384/16384 bytes at offset 4295262208 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295278592 ++read 16384/16384 bytes at offset 4295278592 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295294976 ++read 16384/16384 bytes at offset 4295294976 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295311360 ++read 16384/16384 bytes at offset 4295311360 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295327744 ++read 16384/16384 bytes at offset 4295327744 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295344128 ++read 16384/16384 bytes at offset 4295344128 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295360512 ++read 16384/16384 bytes at offset 4295360512 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295376896 ++read 16384/16384 bytes at offset 4295376896 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295393280 ++read 16384/16384 bytes at offset 4295393280 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295409664 ++read 16384/16384 bytes at offset 4295409664 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295426048 ++read 16384/16384 bytes at offset 4295426048 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295442432 ++read 16384/16384 bytes at offset 4295442432 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295458816 ++read 16384/16384 bytes at offset 4295458816 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295475200 ++read 16384/16384 bytes at offset 4295475200 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295491584 ++read 16384/16384 bytes at offset 4295491584 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295507968 ++read 16384/16384 bytes at offset 4295507968 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295524352 ++read 16384/16384 bytes at offset 4295524352 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295540736 ++read 16384/16384 bytes at offset 4295540736 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 144 +-qemu-io> read 8192/8192 bytes at offset 4295565312 ++=== IO: pattern 144 ++read 8192/8192 bytes at offset 4295565312 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295581696 ++read 8192/8192 bytes at offset 4295581696 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295598080 ++read 8192/8192 bytes at offset 4295598080 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295614464 ++read 8192/8192 bytes at offset 4295614464 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295630848 ++read 8192/8192 bytes at offset 4295630848 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295647232 ++read 8192/8192 bytes at offset 4295647232 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295663616 ++read 8192/8192 bytes at offset 4295663616 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295680000 ++read 8192/8192 bytes at offset 4295680000 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295696384 ++read 8192/8192 bytes at offset 4295696384 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295712768 ++read 8192/8192 bytes at offset 4295712768 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295729152 ++read 8192/8192 bytes at offset 4295729152 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295745536 ++read 8192/8192 bytes at offset 4295745536 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295761920 ++read 8192/8192 bytes at offset 4295761920 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295778304 ++read 8192/8192 bytes at offset 4295778304 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295794688 ++read 8192/8192 bytes at offset 4295794688 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295811072 ++read 8192/8192 bytes at offset 4295811072 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295827456 ++read 8192/8192 bytes at offset 4295827456 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295843840 ++read 8192/8192 bytes at offset 4295843840 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295860224 ++read 8192/8192 bytes at offset 4295860224 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295876608 ++read 8192/8192 bytes at offset 4295876608 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295892992 ++read 8192/8192 bytes at offset 4295892992 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295909376 ++read 8192/8192 bytes at offset 4295909376 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295925760 ++read 8192/8192 bytes at offset 4295925760 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295942144 ++read 8192/8192 bytes at offset 4295942144 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295958528 ++read 8192/8192 bytes at offset 4295958528 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295974912 ++read 8192/8192 bytes at offset 4295974912 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295991296 ++read 8192/8192 bytes at offset 4295991296 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296007680 ++read 8192/8192 bytes at offset 4296007680 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296024064 ++read 8192/8192 bytes at offset 4296024064 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296040448 ++read 8192/8192 bytes at offset 4296040448 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296056832 ++read 8192/8192 bytes at offset 4296056832 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296073216 ++read 8192/8192 bytes at offset 4296073216 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296089600 ++read 8192/8192 bytes at offset 4296089600 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296105984 ++read 8192/8192 bytes at offset 4296105984 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296122368 ++read 8192/8192 bytes at offset 4296122368 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296138752 ++read 8192/8192 bytes at offset 4296138752 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> read 8192/8192 bytes at offset 4296146944 ++=== IO: pattern 0 ++read 8192/8192 bytes at offset 4296146944 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296163328 ++read 8192/8192 bytes at offset 4296163328 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296179712 ++read 8192/8192 bytes at offset 4296179712 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296196096 ++read 8192/8192 bytes at offset 4296196096 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296212480 ++read 8192/8192 bytes at offset 4296212480 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296228864 ++read 8192/8192 bytes at offset 4296228864 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296245248 ++read 8192/8192 bytes at offset 4296245248 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296261632 ++read 8192/8192 bytes at offset 4296261632 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296278016 ++read 8192/8192 bytes at offset 4296278016 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296294400 ++read 8192/8192 bytes at offset 4296294400 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296310784 ++read 8192/8192 bytes at offset 4296310784 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296327168 ++read 8192/8192 bytes at offset 4296327168 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296343552 ++read 8192/8192 bytes at offset 4296343552 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296359936 ++read 8192/8192 bytes at offset 4296359936 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296376320 ++read 8192/8192 bytes at offset 4296376320 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296392704 ++read 8192/8192 bytes at offset 4296392704 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296409088 ++read 8192/8192 bytes at offset 4296409088 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296425472 ++read 8192/8192 bytes at offset 4296425472 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296441856 ++read 8192/8192 bytes at offset 4296441856 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296458240 ++read 8192/8192 bytes at offset 4296458240 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296474624 ++read 8192/8192 bytes at offset 4296474624 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296491008 ++read 8192/8192 bytes at offset 4296491008 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296507392 ++read 8192/8192 bytes at offset 4296507392 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296523776 ++read 8192/8192 bytes at offset 4296523776 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296540160 ++read 8192/8192 bytes at offset 4296540160 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296556544 ++read 8192/8192 bytes at offset 4296556544 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296572928 ++read 8192/8192 bytes at offset 4296572928 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296589312 ++read 8192/8192 bytes at offset 4296589312 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296605696 ++read 8192/8192 bytes at offset 4296605696 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296622080 ++read 8192/8192 bytes at offset 4296622080 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296638464 ++read 8192/8192 bytes at offset 4296638464 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296654848 ++read 8192/8192 bytes at offset 4296654848 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296671232 ++read 8192/8192 bytes at offset 4296671232 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296687616 ++read 8192/8192 bytes at offset 4296687616 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296704000 ++read 8192/8192 bytes at offset 4296704000 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296720384 ++read 8192/8192 bytes at offset 4296720384 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 136 +-qemu-io> read 8192/8192 bytes at offset 4296740864 ++=== IO: pattern 136 ++read 8192/8192 bytes at offset 4296740864 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296757248 ++read 8192/8192 bytes at offset 4296757248 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296773632 ++read 8192/8192 bytes at offset 4296773632 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296790016 ++read 8192/8192 bytes at offset 4296790016 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296806400 ++read 8192/8192 bytes at offset 4296806400 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296822784 ++read 8192/8192 bytes at offset 4296822784 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296839168 ++read 8192/8192 bytes at offset 4296839168 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296855552 ++read 8192/8192 bytes at offset 4296855552 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296871936 ++read 8192/8192 bytes at offset 4296871936 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296888320 ++read 8192/8192 bytes at offset 4296888320 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296904704 ++read 8192/8192 bytes at offset 4296904704 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296921088 ++read 8192/8192 bytes at offset 4296921088 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296937472 ++read 8192/8192 bytes at offset 4296937472 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296953856 ++read 8192/8192 bytes at offset 4296953856 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296970240 ++read 8192/8192 bytes at offset 4296970240 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296986624 ++read 8192/8192 bytes at offset 4296986624 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297003008 ++read 8192/8192 bytes at offset 4297003008 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297019392 ++read 8192/8192 bytes at offset 4297019392 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297035776 ++read 8192/8192 bytes at offset 4297035776 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297052160 ++read 8192/8192 bytes at offset 4297052160 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297068544 ++read 8192/8192 bytes at offset 4297068544 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297084928 ++read 8192/8192 bytes at offset 4297084928 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297101312 ++read 8192/8192 bytes at offset 4297101312 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297117696 ++read 8192/8192 bytes at offset 4297117696 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297134080 ++read 8192/8192 bytes at offset 4297134080 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297150464 ++read 8192/8192 bytes at offset 4297150464 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297166848 ++read 8192/8192 bytes at offset 4297166848 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297183232 ++read 8192/8192 bytes at offset 4297183232 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297199616 ++read 8192/8192 bytes at offset 4297199616 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297216000 ++read 8192/8192 bytes at offset 4297216000 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297232384 ++read 8192/8192 bytes at offset 4297232384 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297248768 ++read 8192/8192 bytes at offset 4297248768 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297265152 ++read 8192/8192 bytes at offset 4297265152 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297281536 ++read 8192/8192 bytes at offset 4297281536 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297297920 ++read 8192/8192 bytes at offset 4297297920 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297314304 ++read 8192/8192 bytes at offset 4297314304 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 16 +-qemu-io> read 32768/32768 bytes at offset 4297334784 ++=== IO: pattern 16 ++read 32768/32768 bytes at offset 4297334784 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4297383936 ++read 32768/32768 bytes at offset 4297383936 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4297433088 ++read 32768/32768 bytes at offset 4297433088 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4297482240 ++read 32768/32768 bytes at offset 4297482240 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4297531392 ++read 32768/32768 bytes at offset 4297531392 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4297580544 ++read 32768/32768 bytes at offset 4297580544 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4297629696 ++read 32768/32768 bytes at offset 4297629696 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4297678848 ++read 32768/32768 bytes at offset 4297678848 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4297728000 ++read 32768/32768 bytes at offset 4297728000 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 208 +-qemu-io> read 49152/49152 bytes at offset 4328497152 ++=== IO: pattern 208 ++read 49152/49152 bytes at offset 4328497152 + 48 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 49152/49152 bytes at offset 4362059776 ++read 49152/49152 bytes at offset 4362059776 + 48 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 49152/49152 bytes at offset 4395622400 ++read 49152/49152 bytes at offset 4395622400 + 48 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> No errors were found on the image. ++No errors were found on the image. + Compressing image + + Testing compressed image + + With offset 0: + === IO: pattern 0 +-qemu-io> read 16384/16384 bytes at offset 0 ++read 16384/16384 bytes at offset 0 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 16384 ++read 16384/16384 bytes at offset 16384 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 32768 ++read 16384/16384 bytes at offset 32768 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 49152 ++read 16384/16384 bytes at offset 49152 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 65536 ++read 16384/16384 bytes at offset 65536 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 81920 ++read 16384/16384 bytes at offset 81920 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 98304 ++read 16384/16384 bytes at offset 98304 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 114688 ++read 16384/16384 bytes at offset 114688 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 131072 ++read 16384/16384 bytes at offset 131072 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 147456 ++read 16384/16384 bytes at offset 147456 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 163840 ++read 16384/16384 bytes at offset 163840 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 180224 ++read 16384/16384 bytes at offset 180224 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 196608 ++read 16384/16384 bytes at offset 196608 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 212992 ++read 16384/16384 bytes at offset 212992 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 229376 ++read 16384/16384 bytes at offset 229376 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 245760 ++read 16384/16384 bytes at offset 245760 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 262144 ++read 16384/16384 bytes at offset 262144 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 278528 ++read 16384/16384 bytes at offset 278528 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 294912 ++read 16384/16384 bytes at offset 294912 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 311296 ++read 16384/16384 bytes at offset 311296 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 327680 ++read 16384/16384 bytes at offset 327680 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 344064 ++read 16384/16384 bytes at offset 344064 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 360448 ++read 16384/16384 bytes at offset 360448 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 376832 ++read 16384/16384 bytes at offset 376832 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 393216 ++read 16384/16384 bytes at offset 393216 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 409600 ++read 16384/16384 bytes at offset 409600 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 425984 ++read 16384/16384 bytes at offset 425984 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 442368 ++read 16384/16384 bytes at offset 442368 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 458752 ++read 16384/16384 bytes at offset 458752 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 475136 ++read 16384/16384 bytes at offset 475136 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 491520 ++read 16384/16384 bytes at offset 491520 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 507904 ++read 16384/16384 bytes at offset 507904 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 524288 ++read 16384/16384 bytes at offset 524288 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 540672 ++read 16384/16384 bytes at offset 540672 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 557056 ++read 16384/16384 bytes at offset 557056 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 573440 ++read 16384/16384 bytes at offset 573440 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 144 +-qemu-io> read 8192/8192 bytes at offset 598016 ++=== IO: pattern 144 ++read 8192/8192 bytes at offset 598016 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 614400 ++read 8192/8192 bytes at offset 614400 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 630784 ++read 8192/8192 bytes at offset 630784 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 647168 ++read 8192/8192 bytes at offset 647168 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 663552 ++read 8192/8192 bytes at offset 663552 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 679936 ++read 8192/8192 bytes at offset 679936 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 696320 ++read 8192/8192 bytes at offset 696320 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 712704 ++read 8192/8192 bytes at offset 712704 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 729088 ++read 8192/8192 bytes at offset 729088 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 745472 ++read 8192/8192 bytes at offset 745472 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 761856 ++read 8192/8192 bytes at offset 761856 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 778240 ++read 8192/8192 bytes at offset 778240 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 794624 ++read 8192/8192 bytes at offset 794624 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 811008 ++read 8192/8192 bytes at offset 811008 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 827392 ++read 8192/8192 bytes at offset 827392 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 843776 ++read 8192/8192 bytes at offset 843776 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 860160 ++read 8192/8192 bytes at offset 860160 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 876544 ++read 8192/8192 bytes at offset 876544 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 892928 ++read 8192/8192 bytes at offset 892928 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 909312 ++read 8192/8192 bytes at offset 909312 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 925696 ++read 8192/8192 bytes at offset 925696 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 942080 ++read 8192/8192 bytes at offset 942080 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 958464 ++read 8192/8192 bytes at offset 958464 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 974848 ++read 8192/8192 bytes at offset 974848 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 991232 ++read 8192/8192 bytes at offset 991232 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1007616 ++read 8192/8192 bytes at offset 1007616 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1024000 ++read 8192/8192 bytes at offset 1024000 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1040384 ++read 8192/8192 bytes at offset 1040384 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1056768 ++read 8192/8192 bytes at offset 1056768 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1073152 ++read 8192/8192 bytes at offset 1073152 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1089536 ++read 8192/8192 bytes at offset 1089536 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1105920 ++read 8192/8192 bytes at offset 1105920 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1122304 ++read 8192/8192 bytes at offset 1122304 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1138688 ++read 8192/8192 bytes at offset 1138688 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1155072 ++read 8192/8192 bytes at offset 1155072 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1171456 ++read 8192/8192 bytes at offset 1171456 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> read 8192/8192 bytes at offset 1179648 ++=== IO: pattern 0 ++read 8192/8192 bytes at offset 1179648 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1196032 ++read 8192/8192 bytes at offset 1196032 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1212416 ++read 8192/8192 bytes at offset 1212416 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1228800 ++read 8192/8192 bytes at offset 1228800 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1245184 ++read 8192/8192 bytes at offset 1245184 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1261568 ++read 8192/8192 bytes at offset 1261568 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1277952 ++read 8192/8192 bytes at offset 1277952 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1294336 ++read 8192/8192 bytes at offset 1294336 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1310720 ++read 8192/8192 bytes at offset 1310720 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1327104 ++read 8192/8192 bytes at offset 1327104 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1343488 ++read 8192/8192 bytes at offset 1343488 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1359872 ++read 8192/8192 bytes at offset 1359872 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1376256 ++read 8192/8192 bytes at offset 1376256 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1392640 ++read 8192/8192 bytes at offset 1392640 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1409024 ++read 8192/8192 bytes at offset 1409024 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1425408 ++read 8192/8192 bytes at offset 1425408 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1441792 ++read 8192/8192 bytes at offset 1441792 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1458176 ++read 8192/8192 bytes at offset 1458176 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1474560 ++read 8192/8192 bytes at offset 1474560 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1490944 ++read 8192/8192 bytes at offset 1490944 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1507328 ++read 8192/8192 bytes at offset 1507328 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1523712 ++read 8192/8192 bytes at offset 1523712 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1540096 ++read 8192/8192 bytes at offset 1540096 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1556480 ++read 8192/8192 bytes at offset 1556480 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1572864 ++read 8192/8192 bytes at offset 1572864 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1589248 ++read 8192/8192 bytes at offset 1589248 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1605632 ++read 8192/8192 bytes at offset 1605632 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1622016 ++read 8192/8192 bytes at offset 1622016 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1638400 ++read 8192/8192 bytes at offset 1638400 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1654784 ++read 8192/8192 bytes at offset 1654784 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1671168 ++read 8192/8192 bytes at offset 1671168 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1687552 ++read 8192/8192 bytes at offset 1687552 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1703936 ++read 8192/8192 bytes at offset 1703936 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1720320 ++read 8192/8192 bytes at offset 1720320 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1736704 ++read 8192/8192 bytes at offset 1736704 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1753088 ++read 8192/8192 bytes at offset 1753088 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 136 +-qemu-io> read 8192/8192 bytes at offset 1773568 ++=== IO: pattern 136 ++read 8192/8192 bytes at offset 1773568 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1789952 ++read 8192/8192 bytes at offset 1789952 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1806336 ++read 8192/8192 bytes at offset 1806336 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1822720 ++read 8192/8192 bytes at offset 1822720 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1839104 ++read 8192/8192 bytes at offset 1839104 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1855488 ++read 8192/8192 bytes at offset 1855488 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1871872 ++read 8192/8192 bytes at offset 1871872 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1888256 ++read 8192/8192 bytes at offset 1888256 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1904640 ++read 8192/8192 bytes at offset 1904640 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1921024 ++read 8192/8192 bytes at offset 1921024 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1937408 ++read 8192/8192 bytes at offset 1937408 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1953792 ++read 8192/8192 bytes at offset 1953792 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1970176 ++read 8192/8192 bytes at offset 1970176 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1986560 ++read 8192/8192 bytes at offset 1986560 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2002944 ++read 8192/8192 bytes at offset 2002944 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2019328 ++read 8192/8192 bytes at offset 2019328 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2035712 ++read 8192/8192 bytes at offset 2035712 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2052096 ++read 8192/8192 bytes at offset 2052096 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2068480 ++read 8192/8192 bytes at offset 2068480 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2084864 ++read 8192/8192 bytes at offset 2084864 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2101248 ++read 8192/8192 bytes at offset 2101248 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2117632 ++read 8192/8192 bytes at offset 2117632 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2134016 ++read 8192/8192 bytes at offset 2134016 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2150400 ++read 8192/8192 bytes at offset 2150400 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2166784 ++read 8192/8192 bytes at offset 2166784 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2183168 ++read 8192/8192 bytes at offset 2183168 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2199552 ++read 8192/8192 bytes at offset 2199552 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2215936 ++read 8192/8192 bytes at offset 2215936 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2232320 ++read 8192/8192 bytes at offset 2232320 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2248704 ++read 8192/8192 bytes at offset 2248704 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2265088 ++read 8192/8192 bytes at offset 2265088 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2281472 ++read 8192/8192 bytes at offset 2281472 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2297856 ++read 8192/8192 bytes at offset 2297856 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2314240 ++read 8192/8192 bytes at offset 2314240 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2330624 ++read 8192/8192 bytes at offset 2330624 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2347008 ++read 8192/8192 bytes at offset 2347008 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 16 +-qemu-io> read 32768/32768 bytes at offset 2367488 ++=== IO: pattern 16 ++read 32768/32768 bytes at offset 2367488 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 2416640 ++read 32768/32768 bytes at offset 2416640 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 2465792 ++read 32768/32768 bytes at offset 2465792 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 2514944 ++read 32768/32768 bytes at offset 2514944 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 2564096 ++read 32768/32768 bytes at offset 2564096 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 2613248 ++read 32768/32768 bytes at offset 2613248 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 2662400 ++read 32768/32768 bytes at offset 2662400 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 2711552 ++read 32768/32768 bytes at offset 2711552 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 2760704 ++read 32768/32768 bytes at offset 2760704 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 208 +-qemu-io> read 49152/49152 bytes at offset 33529856 ++=== IO: pattern 208 ++read 49152/49152 bytes at offset 33529856 + 48 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 49152/49152 bytes at offset 67092480 ++read 49152/49152 bytes at offset 67092480 + 48 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 49152/49152 bytes at offset 100655104 ++read 49152/49152 bytes at offset 100655104 + 48 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> read 16384/16384 bytes at offset 0 ++=== IO: pattern 0 ++read 16384/16384 bytes at offset 0 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 16384 ++read 16384/16384 bytes at offset 16384 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 32768 ++read 16384/16384 bytes at offset 32768 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 49152 ++read 16384/16384 bytes at offset 49152 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 65536 ++read 16384/16384 bytes at offset 65536 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 81920 ++read 16384/16384 bytes at offset 81920 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 98304 ++read 16384/16384 bytes at offset 98304 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 114688 ++read 16384/16384 bytes at offset 114688 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 131072 ++read 16384/16384 bytes at offset 131072 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 147456 ++read 16384/16384 bytes at offset 147456 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 163840 ++read 16384/16384 bytes at offset 163840 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 180224 ++read 16384/16384 bytes at offset 180224 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 196608 ++read 16384/16384 bytes at offset 196608 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 212992 ++read 16384/16384 bytes at offset 212992 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 229376 ++read 16384/16384 bytes at offset 229376 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 245760 ++read 16384/16384 bytes at offset 245760 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 262144 ++read 16384/16384 bytes at offset 262144 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 278528 ++read 16384/16384 bytes at offset 278528 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 294912 ++read 16384/16384 bytes at offset 294912 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 311296 ++read 16384/16384 bytes at offset 311296 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 327680 ++read 16384/16384 bytes at offset 327680 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 344064 ++read 16384/16384 bytes at offset 344064 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 360448 ++read 16384/16384 bytes at offset 360448 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 376832 ++read 16384/16384 bytes at offset 376832 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 393216 ++read 16384/16384 bytes at offset 393216 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 409600 ++read 16384/16384 bytes at offset 409600 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 425984 ++read 16384/16384 bytes at offset 425984 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 442368 ++read 16384/16384 bytes at offset 442368 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 458752 ++read 16384/16384 bytes at offset 458752 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 475136 ++read 16384/16384 bytes at offset 475136 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 491520 ++read 16384/16384 bytes at offset 491520 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 507904 ++read 16384/16384 bytes at offset 507904 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 524288 ++read 16384/16384 bytes at offset 524288 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 540672 ++read 16384/16384 bytes at offset 540672 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 557056 ++read 16384/16384 bytes at offset 557056 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 573440 ++read 16384/16384 bytes at offset 573440 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 144 +-qemu-io> read 8192/8192 bytes at offset 598016 ++=== IO: pattern 144 ++read 8192/8192 bytes at offset 598016 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 614400 ++read 8192/8192 bytes at offset 614400 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 630784 ++read 8192/8192 bytes at offset 630784 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 647168 ++read 8192/8192 bytes at offset 647168 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 663552 ++read 8192/8192 bytes at offset 663552 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 679936 ++read 8192/8192 bytes at offset 679936 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 696320 ++read 8192/8192 bytes at offset 696320 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 712704 ++read 8192/8192 bytes at offset 712704 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 729088 ++read 8192/8192 bytes at offset 729088 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 745472 ++read 8192/8192 bytes at offset 745472 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 761856 ++read 8192/8192 bytes at offset 761856 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 778240 ++read 8192/8192 bytes at offset 778240 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 794624 ++read 8192/8192 bytes at offset 794624 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 811008 ++read 8192/8192 bytes at offset 811008 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 827392 ++read 8192/8192 bytes at offset 827392 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 843776 ++read 8192/8192 bytes at offset 843776 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 860160 ++read 8192/8192 bytes at offset 860160 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 876544 ++read 8192/8192 bytes at offset 876544 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 892928 ++read 8192/8192 bytes at offset 892928 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 909312 ++read 8192/8192 bytes at offset 909312 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 925696 ++read 8192/8192 bytes at offset 925696 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 942080 ++read 8192/8192 bytes at offset 942080 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 958464 ++read 8192/8192 bytes at offset 958464 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 974848 ++read 8192/8192 bytes at offset 974848 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 991232 ++read 8192/8192 bytes at offset 991232 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1007616 ++read 8192/8192 bytes at offset 1007616 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1024000 ++read 8192/8192 bytes at offset 1024000 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1040384 ++read 8192/8192 bytes at offset 1040384 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1056768 ++read 8192/8192 bytes at offset 1056768 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1073152 ++read 8192/8192 bytes at offset 1073152 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1089536 ++read 8192/8192 bytes at offset 1089536 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1105920 ++read 8192/8192 bytes at offset 1105920 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1122304 ++read 8192/8192 bytes at offset 1122304 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1138688 ++read 8192/8192 bytes at offset 1138688 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1155072 ++read 8192/8192 bytes at offset 1155072 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1171456 ++read 8192/8192 bytes at offset 1171456 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> read 8192/8192 bytes at offset 1179648 ++=== IO: pattern 0 ++read 8192/8192 bytes at offset 1179648 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1196032 ++read 8192/8192 bytes at offset 1196032 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1212416 ++read 8192/8192 bytes at offset 1212416 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1228800 ++read 8192/8192 bytes at offset 1228800 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1245184 ++read 8192/8192 bytes at offset 1245184 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1261568 ++read 8192/8192 bytes at offset 1261568 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1277952 ++read 8192/8192 bytes at offset 1277952 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1294336 ++read 8192/8192 bytes at offset 1294336 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1310720 ++read 8192/8192 bytes at offset 1310720 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1327104 ++read 8192/8192 bytes at offset 1327104 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1343488 ++read 8192/8192 bytes at offset 1343488 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1359872 ++read 8192/8192 bytes at offset 1359872 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1376256 ++read 8192/8192 bytes at offset 1376256 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1392640 ++read 8192/8192 bytes at offset 1392640 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1409024 ++read 8192/8192 bytes at offset 1409024 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1425408 ++read 8192/8192 bytes at offset 1425408 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1441792 ++read 8192/8192 bytes at offset 1441792 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1458176 ++read 8192/8192 bytes at offset 1458176 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1474560 ++read 8192/8192 bytes at offset 1474560 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1490944 ++read 8192/8192 bytes at offset 1490944 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1507328 ++read 8192/8192 bytes at offset 1507328 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1523712 ++read 8192/8192 bytes at offset 1523712 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1540096 ++read 8192/8192 bytes at offset 1540096 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1556480 ++read 8192/8192 bytes at offset 1556480 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1572864 ++read 8192/8192 bytes at offset 1572864 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1589248 ++read 8192/8192 bytes at offset 1589248 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1605632 ++read 8192/8192 bytes at offset 1605632 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1622016 ++read 8192/8192 bytes at offset 1622016 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1638400 ++read 8192/8192 bytes at offset 1638400 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1654784 ++read 8192/8192 bytes at offset 1654784 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1671168 ++read 8192/8192 bytes at offset 1671168 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1687552 ++read 8192/8192 bytes at offset 1687552 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1703936 ++read 8192/8192 bytes at offset 1703936 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1720320 ++read 8192/8192 bytes at offset 1720320 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1736704 ++read 8192/8192 bytes at offset 1736704 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1753088 ++read 8192/8192 bytes at offset 1753088 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 136 +-qemu-io> read 8192/8192 bytes at offset 1773568 ++=== IO: pattern 136 ++read 8192/8192 bytes at offset 1773568 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1789952 ++read 8192/8192 bytes at offset 1789952 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1806336 ++read 8192/8192 bytes at offset 1806336 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1822720 ++read 8192/8192 bytes at offset 1822720 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1839104 ++read 8192/8192 bytes at offset 1839104 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1855488 ++read 8192/8192 bytes at offset 1855488 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1871872 ++read 8192/8192 bytes at offset 1871872 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1888256 ++read 8192/8192 bytes at offset 1888256 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1904640 ++read 8192/8192 bytes at offset 1904640 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1921024 ++read 8192/8192 bytes at offset 1921024 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1937408 ++read 8192/8192 bytes at offset 1937408 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1953792 ++read 8192/8192 bytes at offset 1953792 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1970176 ++read 8192/8192 bytes at offset 1970176 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1986560 ++read 8192/8192 bytes at offset 1986560 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2002944 ++read 8192/8192 bytes at offset 2002944 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2019328 ++read 8192/8192 bytes at offset 2019328 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2035712 ++read 8192/8192 bytes at offset 2035712 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2052096 ++read 8192/8192 bytes at offset 2052096 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2068480 ++read 8192/8192 bytes at offset 2068480 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2084864 ++read 8192/8192 bytes at offset 2084864 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2101248 ++read 8192/8192 bytes at offset 2101248 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2117632 ++read 8192/8192 bytes at offset 2117632 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2134016 ++read 8192/8192 bytes at offset 2134016 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2150400 ++read 8192/8192 bytes at offset 2150400 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2166784 ++read 8192/8192 bytes at offset 2166784 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2183168 ++read 8192/8192 bytes at offset 2183168 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2199552 ++read 8192/8192 bytes at offset 2199552 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2215936 ++read 8192/8192 bytes at offset 2215936 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2232320 ++read 8192/8192 bytes at offset 2232320 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2248704 ++read 8192/8192 bytes at offset 2248704 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2265088 ++read 8192/8192 bytes at offset 2265088 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2281472 ++read 8192/8192 bytes at offset 2281472 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2297856 ++read 8192/8192 bytes at offset 2297856 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2314240 ++read 8192/8192 bytes at offset 2314240 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2330624 ++read 8192/8192 bytes at offset 2330624 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2347008 ++read 8192/8192 bytes at offset 2347008 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 16 +-qemu-io> read 32768/32768 bytes at offset 2367488 ++=== IO: pattern 16 ++read 32768/32768 bytes at offset 2367488 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 2416640 ++read 32768/32768 bytes at offset 2416640 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 2465792 ++read 32768/32768 bytes at offset 2465792 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 2514944 ++read 32768/32768 bytes at offset 2514944 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 2564096 ++read 32768/32768 bytes at offset 2564096 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 2613248 ++read 32768/32768 bytes at offset 2613248 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 2662400 ++read 32768/32768 bytes at offset 2662400 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 2711552 ++read 32768/32768 bytes at offset 2711552 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 2760704 ++read 32768/32768 bytes at offset 2760704 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 208 +-qemu-io> read 49152/49152 bytes at offset 33529856 ++=== IO: pattern 208 ++read 49152/49152 bytes at offset 33529856 + 48 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 49152/49152 bytes at offset 67092480 ++read 49152/49152 bytes at offset 67092480 + 48 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 49152/49152 bytes at offset 100655104 ++read 49152/49152 bytes at offset 100655104 + 48 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> No errors were found on the image. ++No errors were found on the image. + With offset 4294967296: + === IO: pattern 0 +-qemu-io> read 16384/16384 bytes at offset 4294967296 ++read 16384/16384 bytes at offset 4294967296 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4294983680 ++read 16384/16384 bytes at offset 4294983680 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295000064 ++read 16384/16384 bytes at offset 4295000064 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295016448 ++read 16384/16384 bytes at offset 4295016448 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295032832 ++read 16384/16384 bytes at offset 4295032832 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295049216 ++read 16384/16384 bytes at offset 4295049216 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295065600 ++read 16384/16384 bytes at offset 4295065600 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295081984 ++read 16384/16384 bytes at offset 4295081984 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295098368 ++read 16384/16384 bytes at offset 4295098368 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295114752 ++read 16384/16384 bytes at offset 4295114752 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295131136 ++read 16384/16384 bytes at offset 4295131136 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295147520 ++read 16384/16384 bytes at offset 4295147520 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295163904 ++read 16384/16384 bytes at offset 4295163904 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295180288 ++read 16384/16384 bytes at offset 4295180288 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295196672 ++read 16384/16384 bytes at offset 4295196672 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295213056 ++read 16384/16384 bytes at offset 4295213056 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295229440 ++read 16384/16384 bytes at offset 4295229440 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295245824 ++read 16384/16384 bytes at offset 4295245824 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295262208 ++read 16384/16384 bytes at offset 4295262208 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295278592 ++read 16384/16384 bytes at offset 4295278592 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295294976 ++read 16384/16384 bytes at offset 4295294976 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295311360 ++read 16384/16384 bytes at offset 4295311360 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295327744 ++read 16384/16384 bytes at offset 4295327744 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295344128 ++read 16384/16384 bytes at offset 4295344128 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295360512 ++read 16384/16384 bytes at offset 4295360512 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295376896 ++read 16384/16384 bytes at offset 4295376896 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295393280 ++read 16384/16384 bytes at offset 4295393280 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295409664 ++read 16384/16384 bytes at offset 4295409664 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295426048 ++read 16384/16384 bytes at offset 4295426048 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295442432 ++read 16384/16384 bytes at offset 4295442432 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295458816 ++read 16384/16384 bytes at offset 4295458816 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295475200 ++read 16384/16384 bytes at offset 4295475200 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295491584 ++read 16384/16384 bytes at offset 4295491584 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295507968 ++read 16384/16384 bytes at offset 4295507968 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295524352 ++read 16384/16384 bytes at offset 4295524352 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295540736 ++read 16384/16384 bytes at offset 4295540736 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 144 +-qemu-io> read 8192/8192 bytes at offset 4295565312 ++=== IO: pattern 144 ++read 8192/8192 bytes at offset 4295565312 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295581696 ++read 8192/8192 bytes at offset 4295581696 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295598080 ++read 8192/8192 bytes at offset 4295598080 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295614464 ++read 8192/8192 bytes at offset 4295614464 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295630848 ++read 8192/8192 bytes at offset 4295630848 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295647232 ++read 8192/8192 bytes at offset 4295647232 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295663616 ++read 8192/8192 bytes at offset 4295663616 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295680000 ++read 8192/8192 bytes at offset 4295680000 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295696384 ++read 8192/8192 bytes at offset 4295696384 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295712768 ++read 8192/8192 bytes at offset 4295712768 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295729152 ++read 8192/8192 bytes at offset 4295729152 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295745536 ++read 8192/8192 bytes at offset 4295745536 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295761920 ++read 8192/8192 bytes at offset 4295761920 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295778304 ++read 8192/8192 bytes at offset 4295778304 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295794688 ++read 8192/8192 bytes at offset 4295794688 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295811072 ++read 8192/8192 bytes at offset 4295811072 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295827456 ++read 8192/8192 bytes at offset 4295827456 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295843840 ++read 8192/8192 bytes at offset 4295843840 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295860224 ++read 8192/8192 bytes at offset 4295860224 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295876608 ++read 8192/8192 bytes at offset 4295876608 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295892992 ++read 8192/8192 bytes at offset 4295892992 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295909376 ++read 8192/8192 bytes at offset 4295909376 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295925760 ++read 8192/8192 bytes at offset 4295925760 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295942144 ++read 8192/8192 bytes at offset 4295942144 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295958528 ++read 8192/8192 bytes at offset 4295958528 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295974912 ++read 8192/8192 bytes at offset 4295974912 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295991296 ++read 8192/8192 bytes at offset 4295991296 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296007680 ++read 8192/8192 bytes at offset 4296007680 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296024064 ++read 8192/8192 bytes at offset 4296024064 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296040448 ++read 8192/8192 bytes at offset 4296040448 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296056832 ++read 8192/8192 bytes at offset 4296056832 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296073216 ++read 8192/8192 bytes at offset 4296073216 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296089600 ++read 8192/8192 bytes at offset 4296089600 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296105984 ++read 8192/8192 bytes at offset 4296105984 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296122368 ++read 8192/8192 bytes at offset 4296122368 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296138752 ++read 8192/8192 bytes at offset 4296138752 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> read 8192/8192 bytes at offset 4296146944 ++=== IO: pattern 0 ++read 8192/8192 bytes at offset 4296146944 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296163328 ++read 8192/8192 bytes at offset 4296163328 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296179712 ++read 8192/8192 bytes at offset 4296179712 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296196096 ++read 8192/8192 bytes at offset 4296196096 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296212480 ++read 8192/8192 bytes at offset 4296212480 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296228864 ++read 8192/8192 bytes at offset 4296228864 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296245248 ++read 8192/8192 bytes at offset 4296245248 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296261632 ++read 8192/8192 bytes at offset 4296261632 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296278016 ++read 8192/8192 bytes at offset 4296278016 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296294400 ++read 8192/8192 bytes at offset 4296294400 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296310784 ++read 8192/8192 bytes at offset 4296310784 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296327168 ++read 8192/8192 bytes at offset 4296327168 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296343552 ++read 8192/8192 bytes at offset 4296343552 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296359936 ++read 8192/8192 bytes at offset 4296359936 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296376320 ++read 8192/8192 bytes at offset 4296376320 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296392704 ++read 8192/8192 bytes at offset 4296392704 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296409088 ++read 8192/8192 bytes at offset 4296409088 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296425472 ++read 8192/8192 bytes at offset 4296425472 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296441856 ++read 8192/8192 bytes at offset 4296441856 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296458240 ++read 8192/8192 bytes at offset 4296458240 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296474624 ++read 8192/8192 bytes at offset 4296474624 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296491008 ++read 8192/8192 bytes at offset 4296491008 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296507392 ++read 8192/8192 bytes at offset 4296507392 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296523776 ++read 8192/8192 bytes at offset 4296523776 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296540160 ++read 8192/8192 bytes at offset 4296540160 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296556544 ++read 8192/8192 bytes at offset 4296556544 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296572928 ++read 8192/8192 bytes at offset 4296572928 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296589312 ++read 8192/8192 bytes at offset 4296589312 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296605696 ++read 8192/8192 bytes at offset 4296605696 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296622080 ++read 8192/8192 bytes at offset 4296622080 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296638464 ++read 8192/8192 bytes at offset 4296638464 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296654848 ++read 8192/8192 bytes at offset 4296654848 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296671232 ++read 8192/8192 bytes at offset 4296671232 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296687616 ++read 8192/8192 bytes at offset 4296687616 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296704000 ++read 8192/8192 bytes at offset 4296704000 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296720384 ++read 8192/8192 bytes at offset 4296720384 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 136 +-qemu-io> read 8192/8192 bytes at offset 4296740864 ++=== IO: pattern 136 ++read 8192/8192 bytes at offset 4296740864 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296757248 ++read 8192/8192 bytes at offset 4296757248 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296773632 ++read 8192/8192 bytes at offset 4296773632 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296790016 ++read 8192/8192 bytes at offset 4296790016 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296806400 ++read 8192/8192 bytes at offset 4296806400 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296822784 ++read 8192/8192 bytes at offset 4296822784 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296839168 ++read 8192/8192 bytes at offset 4296839168 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296855552 ++read 8192/8192 bytes at offset 4296855552 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296871936 ++read 8192/8192 bytes at offset 4296871936 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296888320 ++read 8192/8192 bytes at offset 4296888320 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296904704 ++read 8192/8192 bytes at offset 4296904704 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296921088 ++read 8192/8192 bytes at offset 4296921088 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296937472 ++read 8192/8192 bytes at offset 4296937472 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296953856 ++read 8192/8192 bytes at offset 4296953856 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296970240 ++read 8192/8192 bytes at offset 4296970240 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296986624 ++read 8192/8192 bytes at offset 4296986624 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297003008 ++read 8192/8192 bytes at offset 4297003008 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297019392 ++read 8192/8192 bytes at offset 4297019392 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297035776 ++read 8192/8192 bytes at offset 4297035776 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297052160 ++read 8192/8192 bytes at offset 4297052160 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297068544 ++read 8192/8192 bytes at offset 4297068544 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297084928 ++read 8192/8192 bytes at offset 4297084928 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297101312 ++read 8192/8192 bytes at offset 4297101312 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297117696 ++read 8192/8192 bytes at offset 4297117696 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297134080 ++read 8192/8192 bytes at offset 4297134080 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297150464 ++read 8192/8192 bytes at offset 4297150464 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297166848 ++read 8192/8192 bytes at offset 4297166848 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297183232 ++read 8192/8192 bytes at offset 4297183232 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297199616 ++read 8192/8192 bytes at offset 4297199616 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297216000 ++read 8192/8192 bytes at offset 4297216000 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297232384 ++read 8192/8192 bytes at offset 4297232384 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297248768 ++read 8192/8192 bytes at offset 4297248768 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297265152 ++read 8192/8192 bytes at offset 4297265152 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297281536 ++read 8192/8192 bytes at offset 4297281536 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297297920 ++read 8192/8192 bytes at offset 4297297920 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297314304 ++read 8192/8192 bytes at offset 4297314304 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 16 +-qemu-io> read 32768/32768 bytes at offset 4297334784 ++=== IO: pattern 16 ++read 32768/32768 bytes at offset 4297334784 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4297383936 ++read 32768/32768 bytes at offset 4297383936 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4297433088 ++read 32768/32768 bytes at offset 4297433088 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4297482240 ++read 32768/32768 bytes at offset 4297482240 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4297531392 ++read 32768/32768 bytes at offset 4297531392 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4297580544 ++read 32768/32768 bytes at offset 4297580544 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4297629696 ++read 32768/32768 bytes at offset 4297629696 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4297678848 ++read 32768/32768 bytes at offset 4297678848 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4297728000 ++read 32768/32768 bytes at offset 4297728000 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 208 +-qemu-io> read 49152/49152 bytes at offset 4328497152 ++=== IO: pattern 208 ++read 49152/49152 bytes at offset 4328497152 + 48 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 49152/49152 bytes at offset 4362059776 ++read 49152/49152 bytes at offset 4362059776 + 48 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 49152/49152 bytes at offset 4395622400 ++read 49152/49152 bytes at offset 4395622400 + 48 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> read 16384/16384 bytes at offset 4294967296 ++=== IO: pattern 0 ++read 16384/16384 bytes at offset 4294967296 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4294983680 ++read 16384/16384 bytes at offset 4294983680 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295000064 ++read 16384/16384 bytes at offset 4295000064 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295016448 ++read 16384/16384 bytes at offset 4295016448 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295032832 ++read 16384/16384 bytes at offset 4295032832 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295049216 ++read 16384/16384 bytes at offset 4295049216 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295065600 ++read 16384/16384 bytes at offset 4295065600 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295081984 ++read 16384/16384 bytes at offset 4295081984 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295098368 ++read 16384/16384 bytes at offset 4295098368 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295114752 ++read 16384/16384 bytes at offset 4295114752 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295131136 ++read 16384/16384 bytes at offset 4295131136 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295147520 ++read 16384/16384 bytes at offset 4295147520 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295163904 ++read 16384/16384 bytes at offset 4295163904 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295180288 ++read 16384/16384 bytes at offset 4295180288 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295196672 ++read 16384/16384 bytes at offset 4295196672 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295213056 ++read 16384/16384 bytes at offset 4295213056 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295229440 ++read 16384/16384 bytes at offset 4295229440 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295245824 ++read 16384/16384 bytes at offset 4295245824 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295262208 ++read 16384/16384 bytes at offset 4295262208 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295278592 ++read 16384/16384 bytes at offset 4295278592 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295294976 ++read 16384/16384 bytes at offset 4295294976 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295311360 ++read 16384/16384 bytes at offset 4295311360 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295327744 ++read 16384/16384 bytes at offset 4295327744 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295344128 ++read 16384/16384 bytes at offset 4295344128 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295360512 ++read 16384/16384 bytes at offset 4295360512 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295376896 ++read 16384/16384 bytes at offset 4295376896 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295393280 ++read 16384/16384 bytes at offset 4295393280 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295409664 ++read 16384/16384 bytes at offset 4295409664 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295426048 ++read 16384/16384 bytes at offset 4295426048 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295442432 ++read 16384/16384 bytes at offset 4295442432 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295458816 ++read 16384/16384 bytes at offset 4295458816 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295475200 ++read 16384/16384 bytes at offset 4295475200 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295491584 ++read 16384/16384 bytes at offset 4295491584 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295507968 ++read 16384/16384 bytes at offset 4295507968 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295524352 ++read 16384/16384 bytes at offset 4295524352 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295540736 ++read 16384/16384 bytes at offset 4295540736 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 144 +-qemu-io> read 8192/8192 bytes at offset 4295565312 ++=== IO: pattern 144 ++read 8192/8192 bytes at offset 4295565312 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295581696 ++read 8192/8192 bytes at offset 4295581696 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295598080 ++read 8192/8192 bytes at offset 4295598080 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295614464 ++read 8192/8192 bytes at offset 4295614464 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295630848 ++read 8192/8192 bytes at offset 4295630848 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295647232 ++read 8192/8192 bytes at offset 4295647232 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295663616 ++read 8192/8192 bytes at offset 4295663616 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295680000 ++read 8192/8192 bytes at offset 4295680000 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295696384 ++read 8192/8192 bytes at offset 4295696384 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295712768 ++read 8192/8192 bytes at offset 4295712768 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295729152 ++read 8192/8192 bytes at offset 4295729152 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295745536 ++read 8192/8192 bytes at offset 4295745536 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295761920 ++read 8192/8192 bytes at offset 4295761920 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295778304 ++read 8192/8192 bytes at offset 4295778304 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295794688 ++read 8192/8192 bytes at offset 4295794688 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295811072 ++read 8192/8192 bytes at offset 4295811072 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295827456 ++read 8192/8192 bytes at offset 4295827456 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295843840 ++read 8192/8192 bytes at offset 4295843840 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295860224 ++read 8192/8192 bytes at offset 4295860224 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295876608 ++read 8192/8192 bytes at offset 4295876608 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295892992 ++read 8192/8192 bytes at offset 4295892992 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295909376 ++read 8192/8192 bytes at offset 4295909376 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295925760 ++read 8192/8192 bytes at offset 4295925760 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295942144 ++read 8192/8192 bytes at offset 4295942144 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295958528 ++read 8192/8192 bytes at offset 4295958528 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295974912 ++read 8192/8192 bytes at offset 4295974912 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295991296 ++read 8192/8192 bytes at offset 4295991296 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296007680 ++read 8192/8192 bytes at offset 4296007680 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296024064 ++read 8192/8192 bytes at offset 4296024064 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296040448 ++read 8192/8192 bytes at offset 4296040448 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296056832 ++read 8192/8192 bytes at offset 4296056832 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296073216 ++read 8192/8192 bytes at offset 4296073216 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296089600 ++read 8192/8192 bytes at offset 4296089600 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296105984 ++read 8192/8192 bytes at offset 4296105984 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296122368 ++read 8192/8192 bytes at offset 4296122368 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296138752 ++read 8192/8192 bytes at offset 4296138752 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> read 8192/8192 bytes at offset 4296146944 ++=== IO: pattern 0 ++read 8192/8192 bytes at offset 4296146944 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296163328 ++read 8192/8192 bytes at offset 4296163328 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296179712 ++read 8192/8192 bytes at offset 4296179712 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296196096 ++read 8192/8192 bytes at offset 4296196096 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296212480 ++read 8192/8192 bytes at offset 4296212480 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296228864 ++read 8192/8192 bytes at offset 4296228864 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296245248 ++read 8192/8192 bytes at offset 4296245248 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296261632 ++read 8192/8192 bytes at offset 4296261632 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296278016 ++read 8192/8192 bytes at offset 4296278016 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296294400 ++read 8192/8192 bytes at offset 4296294400 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296310784 ++read 8192/8192 bytes at offset 4296310784 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296327168 ++read 8192/8192 bytes at offset 4296327168 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296343552 ++read 8192/8192 bytes at offset 4296343552 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296359936 ++read 8192/8192 bytes at offset 4296359936 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296376320 ++read 8192/8192 bytes at offset 4296376320 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296392704 ++read 8192/8192 bytes at offset 4296392704 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296409088 ++read 8192/8192 bytes at offset 4296409088 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296425472 ++read 8192/8192 bytes at offset 4296425472 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296441856 ++read 8192/8192 bytes at offset 4296441856 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296458240 ++read 8192/8192 bytes at offset 4296458240 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296474624 ++read 8192/8192 bytes at offset 4296474624 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296491008 ++read 8192/8192 bytes at offset 4296491008 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296507392 ++read 8192/8192 bytes at offset 4296507392 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296523776 ++read 8192/8192 bytes at offset 4296523776 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296540160 ++read 8192/8192 bytes at offset 4296540160 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296556544 ++read 8192/8192 bytes at offset 4296556544 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296572928 ++read 8192/8192 bytes at offset 4296572928 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296589312 ++read 8192/8192 bytes at offset 4296589312 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296605696 ++read 8192/8192 bytes at offset 4296605696 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296622080 ++read 8192/8192 bytes at offset 4296622080 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296638464 ++read 8192/8192 bytes at offset 4296638464 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296654848 ++read 8192/8192 bytes at offset 4296654848 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296671232 ++read 8192/8192 bytes at offset 4296671232 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296687616 ++read 8192/8192 bytes at offset 4296687616 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296704000 ++read 8192/8192 bytes at offset 4296704000 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296720384 ++read 8192/8192 bytes at offset 4296720384 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 136 +-qemu-io> read 8192/8192 bytes at offset 4296740864 ++=== IO: pattern 136 ++read 8192/8192 bytes at offset 4296740864 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296757248 ++read 8192/8192 bytes at offset 4296757248 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296773632 ++read 8192/8192 bytes at offset 4296773632 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296790016 ++read 8192/8192 bytes at offset 4296790016 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296806400 ++read 8192/8192 bytes at offset 4296806400 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296822784 ++read 8192/8192 bytes at offset 4296822784 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296839168 ++read 8192/8192 bytes at offset 4296839168 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296855552 ++read 8192/8192 bytes at offset 4296855552 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296871936 ++read 8192/8192 bytes at offset 4296871936 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296888320 ++read 8192/8192 bytes at offset 4296888320 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296904704 ++read 8192/8192 bytes at offset 4296904704 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296921088 ++read 8192/8192 bytes at offset 4296921088 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296937472 ++read 8192/8192 bytes at offset 4296937472 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296953856 ++read 8192/8192 bytes at offset 4296953856 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296970240 ++read 8192/8192 bytes at offset 4296970240 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296986624 ++read 8192/8192 bytes at offset 4296986624 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297003008 ++read 8192/8192 bytes at offset 4297003008 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297019392 ++read 8192/8192 bytes at offset 4297019392 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297035776 ++read 8192/8192 bytes at offset 4297035776 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297052160 ++read 8192/8192 bytes at offset 4297052160 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297068544 ++read 8192/8192 bytes at offset 4297068544 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297084928 ++read 8192/8192 bytes at offset 4297084928 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297101312 ++read 8192/8192 bytes at offset 4297101312 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297117696 ++read 8192/8192 bytes at offset 4297117696 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297134080 ++read 8192/8192 bytes at offset 4297134080 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297150464 ++read 8192/8192 bytes at offset 4297150464 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297166848 ++read 8192/8192 bytes at offset 4297166848 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297183232 ++read 8192/8192 bytes at offset 4297183232 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297199616 ++read 8192/8192 bytes at offset 4297199616 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297216000 ++read 8192/8192 bytes at offset 4297216000 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297232384 ++read 8192/8192 bytes at offset 4297232384 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297248768 ++read 8192/8192 bytes at offset 4297248768 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297265152 ++read 8192/8192 bytes at offset 4297265152 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297281536 ++read 8192/8192 bytes at offset 4297281536 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297297920 ++read 8192/8192 bytes at offset 4297297920 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297314304 ++read 8192/8192 bytes at offset 4297314304 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 16 +-qemu-io> read 32768/32768 bytes at offset 4297334784 ++=== IO: pattern 16 ++read 32768/32768 bytes at offset 4297334784 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4297383936 ++read 32768/32768 bytes at offset 4297383936 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4297433088 ++read 32768/32768 bytes at offset 4297433088 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4297482240 ++read 32768/32768 bytes at offset 4297482240 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4297531392 ++read 32768/32768 bytes at offset 4297531392 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4297580544 ++read 32768/32768 bytes at offset 4297580544 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4297629696 ++read 32768/32768 bytes at offset 4297629696 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4297678848 ++read 32768/32768 bytes at offset 4297678848 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4297728000 ++read 32768/32768 bytes at offset 4297728000 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 208 +-qemu-io> read 49152/49152 bytes at offset 4328497152 ++=== IO: pattern 208 ++read 49152/49152 bytes at offset 4328497152 + 48 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 49152/49152 bytes at offset 4362059776 ++read 49152/49152 bytes at offset 4362059776 + 48 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 49152/49152 bytes at offset 4395622400 ++read 49152/49152 bytes at offset 4395622400 + 48 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> No errors were found on the image. ++No errors were found on the image. + Testing compressed image with odd offsets + + With offset 512: + === IO: pattern 1 +-qemu-io> wrote 16384/16384 bytes at offset 512 ++wrote 16384/16384 bytes at offset 512 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 16896 ++wrote 16384/16384 bytes at offset 16896 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 33280 ++wrote 16384/16384 bytes at offset 33280 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 49664 ++wrote 16384/16384 bytes at offset 49664 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 66048 ++wrote 16384/16384 bytes at offset 66048 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 82432 ++wrote 16384/16384 bytes at offset 82432 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 98816 ++wrote 16384/16384 bytes at offset 98816 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 115200 ++wrote 16384/16384 bytes at offset 115200 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 131584 ++wrote 16384/16384 bytes at offset 131584 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 147968 ++wrote 16384/16384 bytes at offset 147968 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 164352 ++wrote 16384/16384 bytes at offset 164352 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 180736 ++wrote 16384/16384 bytes at offset 180736 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 197120 ++wrote 16384/16384 bytes at offset 197120 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 213504 ++wrote 16384/16384 bytes at offset 213504 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 229888 ++wrote 16384/16384 bytes at offset 229888 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 246272 ++wrote 16384/16384 bytes at offset 246272 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 262656 ++wrote 16384/16384 bytes at offset 262656 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 279040 ++wrote 16384/16384 bytes at offset 279040 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 295424 ++wrote 16384/16384 bytes at offset 295424 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 311808 ++wrote 16384/16384 bytes at offset 311808 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 328192 ++wrote 16384/16384 bytes at offset 328192 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 344576 ++wrote 16384/16384 bytes at offset 344576 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 360960 ++wrote 16384/16384 bytes at offset 360960 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 377344 ++wrote 16384/16384 bytes at offset 377344 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 393728 ++wrote 16384/16384 bytes at offset 393728 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 410112 ++wrote 16384/16384 bytes at offset 410112 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 426496 ++wrote 16384/16384 bytes at offset 426496 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 442880 ++wrote 16384/16384 bytes at offset 442880 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 459264 ++wrote 16384/16384 bytes at offset 459264 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 475648 ++wrote 16384/16384 bytes at offset 475648 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 492032 ++wrote 16384/16384 bytes at offset 492032 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 508416 ++wrote 16384/16384 bytes at offset 508416 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 524800 ++wrote 16384/16384 bytes at offset 524800 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 541184 ++wrote 16384/16384 bytes at offset 541184 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 557568 ++wrote 16384/16384 bytes at offset 557568 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 573952 ++wrote 16384/16384 bytes at offset 573952 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 145 +-qemu-io> wrote 8192/8192 bytes at offset 598528 ++=== IO: pattern 145 ++wrote 8192/8192 bytes at offset 598528 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 614912 ++wrote 8192/8192 bytes at offset 614912 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 631296 ++wrote 8192/8192 bytes at offset 631296 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 647680 ++wrote 8192/8192 bytes at offset 647680 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 664064 ++wrote 8192/8192 bytes at offset 664064 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 680448 ++wrote 8192/8192 bytes at offset 680448 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 696832 ++wrote 8192/8192 bytes at offset 696832 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 713216 ++wrote 8192/8192 bytes at offset 713216 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 729600 ++wrote 8192/8192 bytes at offset 729600 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 745984 ++wrote 8192/8192 bytes at offset 745984 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 762368 ++wrote 8192/8192 bytes at offset 762368 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 778752 ++wrote 8192/8192 bytes at offset 778752 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 795136 ++wrote 8192/8192 bytes at offset 795136 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 811520 ++wrote 8192/8192 bytes at offset 811520 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 827904 ++wrote 8192/8192 bytes at offset 827904 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 844288 ++wrote 8192/8192 bytes at offset 844288 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 860672 ++wrote 8192/8192 bytes at offset 860672 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 877056 ++wrote 8192/8192 bytes at offset 877056 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 893440 ++wrote 8192/8192 bytes at offset 893440 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 909824 ++wrote 8192/8192 bytes at offset 909824 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 926208 ++wrote 8192/8192 bytes at offset 926208 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 942592 ++wrote 8192/8192 bytes at offset 942592 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 958976 ++wrote 8192/8192 bytes at offset 958976 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 975360 ++wrote 8192/8192 bytes at offset 975360 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 991744 ++wrote 8192/8192 bytes at offset 991744 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1008128 ++wrote 8192/8192 bytes at offset 1008128 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1024512 ++wrote 8192/8192 bytes at offset 1024512 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1040896 ++wrote 8192/8192 bytes at offset 1040896 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1057280 ++wrote 8192/8192 bytes at offset 1057280 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1073664 ++wrote 8192/8192 bytes at offset 1073664 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1090048 ++wrote 8192/8192 bytes at offset 1090048 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1106432 ++wrote 8192/8192 bytes at offset 1106432 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1122816 ++wrote 8192/8192 bytes at offset 1122816 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1139200 ++wrote 8192/8192 bytes at offset 1139200 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1155584 ++wrote 8192/8192 bytes at offset 1155584 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1171968 ++wrote 8192/8192 bytes at offset 1171968 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 1 +-qemu-io> wrote 8192/8192 bytes at offset 1180160 ++=== IO: pattern 1 ++wrote 8192/8192 bytes at offset 1180160 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1196544 ++wrote 8192/8192 bytes at offset 1196544 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1212928 ++wrote 8192/8192 bytes at offset 1212928 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1229312 ++wrote 8192/8192 bytes at offset 1229312 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1245696 ++wrote 8192/8192 bytes at offset 1245696 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1262080 ++wrote 8192/8192 bytes at offset 1262080 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1278464 ++wrote 8192/8192 bytes at offset 1278464 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1294848 ++wrote 8192/8192 bytes at offset 1294848 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1311232 ++wrote 8192/8192 bytes at offset 1311232 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1327616 ++wrote 8192/8192 bytes at offset 1327616 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1344000 ++wrote 8192/8192 bytes at offset 1344000 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1360384 ++wrote 8192/8192 bytes at offset 1360384 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1376768 ++wrote 8192/8192 bytes at offset 1376768 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1393152 ++wrote 8192/8192 bytes at offset 1393152 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1409536 ++wrote 8192/8192 bytes at offset 1409536 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1425920 ++wrote 8192/8192 bytes at offset 1425920 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1442304 ++wrote 8192/8192 bytes at offset 1442304 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1458688 ++wrote 8192/8192 bytes at offset 1458688 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1475072 ++wrote 8192/8192 bytes at offset 1475072 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1491456 ++wrote 8192/8192 bytes at offset 1491456 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1507840 ++wrote 8192/8192 bytes at offset 1507840 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1524224 ++wrote 8192/8192 bytes at offset 1524224 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1540608 ++wrote 8192/8192 bytes at offset 1540608 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1556992 ++wrote 8192/8192 bytes at offset 1556992 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1573376 ++wrote 8192/8192 bytes at offset 1573376 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1589760 ++wrote 8192/8192 bytes at offset 1589760 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1606144 ++wrote 8192/8192 bytes at offset 1606144 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1622528 ++wrote 8192/8192 bytes at offset 1622528 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1638912 ++wrote 8192/8192 bytes at offset 1638912 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1655296 ++wrote 8192/8192 bytes at offset 1655296 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1671680 ++wrote 8192/8192 bytes at offset 1671680 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1688064 ++wrote 8192/8192 bytes at offset 1688064 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1704448 ++wrote 8192/8192 bytes at offset 1704448 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1720832 ++wrote 8192/8192 bytes at offset 1720832 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1737216 ++wrote 8192/8192 bytes at offset 1737216 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1753600 ++wrote 8192/8192 bytes at offset 1753600 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 137 +-qemu-io> wrote 8192/8192 bytes at offset 1774080 ++=== IO: pattern 137 ++wrote 8192/8192 bytes at offset 1774080 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1790464 ++wrote 8192/8192 bytes at offset 1790464 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1806848 ++wrote 8192/8192 bytes at offset 1806848 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1823232 ++wrote 8192/8192 bytes at offset 1823232 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1839616 ++wrote 8192/8192 bytes at offset 1839616 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1856000 ++wrote 8192/8192 bytes at offset 1856000 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1872384 ++wrote 8192/8192 bytes at offset 1872384 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1888768 ++wrote 8192/8192 bytes at offset 1888768 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1905152 ++wrote 8192/8192 bytes at offset 1905152 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1921536 ++wrote 8192/8192 bytes at offset 1921536 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1937920 ++wrote 8192/8192 bytes at offset 1937920 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1954304 ++wrote 8192/8192 bytes at offset 1954304 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1970688 ++wrote 8192/8192 bytes at offset 1970688 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1987072 ++wrote 8192/8192 bytes at offset 1987072 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 2003456 ++wrote 8192/8192 bytes at offset 2003456 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 2019840 ++wrote 8192/8192 bytes at offset 2019840 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 2036224 ++wrote 8192/8192 bytes at offset 2036224 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 2052608 ++wrote 8192/8192 bytes at offset 2052608 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 2068992 ++wrote 8192/8192 bytes at offset 2068992 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 2085376 ++wrote 8192/8192 bytes at offset 2085376 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 2101760 ++wrote 8192/8192 bytes at offset 2101760 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 2118144 ++wrote 8192/8192 bytes at offset 2118144 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 2134528 ++wrote 8192/8192 bytes at offset 2134528 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 2150912 ++wrote 8192/8192 bytes at offset 2150912 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 2167296 ++wrote 8192/8192 bytes at offset 2167296 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 2183680 ++wrote 8192/8192 bytes at offset 2183680 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 2200064 ++wrote 8192/8192 bytes at offset 2200064 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 2216448 ++wrote 8192/8192 bytes at offset 2216448 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 2232832 ++wrote 8192/8192 bytes at offset 2232832 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 2249216 ++wrote 8192/8192 bytes at offset 2249216 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 2265600 ++wrote 8192/8192 bytes at offset 2265600 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 2281984 ++wrote 8192/8192 bytes at offset 2281984 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 2298368 ++wrote 8192/8192 bytes at offset 2298368 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 2314752 ++wrote 8192/8192 bytes at offset 2314752 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 2331136 ++wrote 8192/8192 bytes at offset 2331136 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 2347520 ++wrote 8192/8192 bytes at offset 2347520 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 17 +-qemu-io> wrote 32768/32768 bytes at offset 2368000 ++=== IO: pattern 17 ++wrote 32768/32768 bytes at offset 2368000 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 2417152 ++wrote 32768/32768 bytes at offset 2417152 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 2466304 ++wrote 32768/32768 bytes at offset 2466304 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 2515456 ++wrote 32768/32768 bytes at offset 2515456 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 2564608 ++wrote 32768/32768 bytes at offset 2564608 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 2613760 ++wrote 32768/32768 bytes at offset 2613760 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 2662912 ++wrote 32768/32768 bytes at offset 2662912 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 2712064 ++wrote 32768/32768 bytes at offset 2712064 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 2761216 ++wrote 32768/32768 bytes at offset 2761216 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 208 +-qemu-io> wrote 49152/49152 bytes at offset 33529856 ++=== IO: pattern 208 ++wrote 49152/49152 bytes at offset 33529856 + 48 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 49152/49152 bytes at offset 67092480 ++wrote 49152/49152 bytes at offset 67092480 + 48 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 49152/49152 bytes at offset 100655104 ++wrote 49152/49152 bytes at offset 100655104 + 48 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 1 +-qemu-io> read 16384/16384 bytes at offset 512 ++=== IO: pattern 1 ++read 16384/16384 bytes at offset 512 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 16896 ++read 16384/16384 bytes at offset 16896 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 33280 ++read 16384/16384 bytes at offset 33280 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 49664 ++read 16384/16384 bytes at offset 49664 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 66048 ++read 16384/16384 bytes at offset 66048 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 82432 ++read 16384/16384 bytes at offset 82432 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 98816 ++read 16384/16384 bytes at offset 98816 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 115200 ++read 16384/16384 bytes at offset 115200 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 131584 ++read 16384/16384 bytes at offset 131584 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 147968 ++read 16384/16384 bytes at offset 147968 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 164352 ++read 16384/16384 bytes at offset 164352 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 180736 ++read 16384/16384 bytes at offset 180736 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 197120 ++read 16384/16384 bytes at offset 197120 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 213504 ++read 16384/16384 bytes at offset 213504 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 229888 ++read 16384/16384 bytes at offset 229888 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 246272 ++read 16384/16384 bytes at offset 246272 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 262656 ++read 16384/16384 bytes at offset 262656 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 279040 ++read 16384/16384 bytes at offset 279040 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 295424 ++read 16384/16384 bytes at offset 295424 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 311808 ++read 16384/16384 bytes at offset 311808 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 328192 ++read 16384/16384 bytes at offset 328192 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 344576 ++read 16384/16384 bytes at offset 344576 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 360960 ++read 16384/16384 bytes at offset 360960 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 377344 ++read 16384/16384 bytes at offset 377344 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 393728 ++read 16384/16384 bytes at offset 393728 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 410112 ++read 16384/16384 bytes at offset 410112 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 426496 ++read 16384/16384 bytes at offset 426496 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 442880 ++read 16384/16384 bytes at offset 442880 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 459264 ++read 16384/16384 bytes at offset 459264 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 475648 ++read 16384/16384 bytes at offset 475648 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 492032 ++read 16384/16384 bytes at offset 492032 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 508416 ++read 16384/16384 bytes at offset 508416 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 524800 ++read 16384/16384 bytes at offset 524800 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 541184 ++read 16384/16384 bytes at offset 541184 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 557568 ++read 16384/16384 bytes at offset 557568 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 573952 ++read 16384/16384 bytes at offset 573952 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 145 +-qemu-io> read 8192/8192 bytes at offset 598528 ++=== IO: pattern 145 ++read 8192/8192 bytes at offset 598528 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 614912 ++read 8192/8192 bytes at offset 614912 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 631296 ++read 8192/8192 bytes at offset 631296 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 647680 ++read 8192/8192 bytes at offset 647680 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 664064 ++read 8192/8192 bytes at offset 664064 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 680448 ++read 8192/8192 bytes at offset 680448 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 696832 ++read 8192/8192 bytes at offset 696832 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 713216 ++read 8192/8192 bytes at offset 713216 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 729600 ++read 8192/8192 bytes at offset 729600 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 745984 ++read 8192/8192 bytes at offset 745984 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 762368 ++read 8192/8192 bytes at offset 762368 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 778752 ++read 8192/8192 bytes at offset 778752 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 795136 ++read 8192/8192 bytes at offset 795136 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 811520 ++read 8192/8192 bytes at offset 811520 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 827904 ++read 8192/8192 bytes at offset 827904 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 844288 ++read 8192/8192 bytes at offset 844288 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 860672 ++read 8192/8192 bytes at offset 860672 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 877056 ++read 8192/8192 bytes at offset 877056 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 893440 ++read 8192/8192 bytes at offset 893440 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 909824 ++read 8192/8192 bytes at offset 909824 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 926208 ++read 8192/8192 bytes at offset 926208 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 942592 ++read 8192/8192 bytes at offset 942592 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 958976 ++read 8192/8192 bytes at offset 958976 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 975360 ++read 8192/8192 bytes at offset 975360 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 991744 ++read 8192/8192 bytes at offset 991744 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1008128 ++read 8192/8192 bytes at offset 1008128 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1024512 ++read 8192/8192 bytes at offset 1024512 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1040896 ++read 8192/8192 bytes at offset 1040896 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1057280 ++read 8192/8192 bytes at offset 1057280 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1073664 ++read 8192/8192 bytes at offset 1073664 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1090048 ++read 8192/8192 bytes at offset 1090048 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1106432 ++read 8192/8192 bytes at offset 1106432 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1122816 ++read 8192/8192 bytes at offset 1122816 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1139200 ++read 8192/8192 bytes at offset 1139200 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1155584 ++read 8192/8192 bytes at offset 1155584 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1171968 ++read 8192/8192 bytes at offset 1171968 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 1 +-qemu-io> read 8192/8192 bytes at offset 1180160 ++=== IO: pattern 1 ++read 8192/8192 bytes at offset 1180160 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1196544 ++read 8192/8192 bytes at offset 1196544 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1212928 ++read 8192/8192 bytes at offset 1212928 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1229312 ++read 8192/8192 bytes at offset 1229312 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1245696 ++read 8192/8192 bytes at offset 1245696 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1262080 ++read 8192/8192 bytes at offset 1262080 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1278464 ++read 8192/8192 bytes at offset 1278464 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1294848 ++read 8192/8192 bytes at offset 1294848 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1311232 ++read 8192/8192 bytes at offset 1311232 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1327616 ++read 8192/8192 bytes at offset 1327616 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1344000 ++read 8192/8192 bytes at offset 1344000 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1360384 ++read 8192/8192 bytes at offset 1360384 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1376768 ++read 8192/8192 bytes at offset 1376768 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1393152 ++read 8192/8192 bytes at offset 1393152 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1409536 ++read 8192/8192 bytes at offset 1409536 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1425920 ++read 8192/8192 bytes at offset 1425920 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1442304 ++read 8192/8192 bytes at offset 1442304 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1458688 ++read 8192/8192 bytes at offset 1458688 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1475072 ++read 8192/8192 bytes at offset 1475072 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1491456 ++read 8192/8192 bytes at offset 1491456 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1507840 ++read 8192/8192 bytes at offset 1507840 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1524224 ++read 8192/8192 bytes at offset 1524224 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1540608 ++read 8192/8192 bytes at offset 1540608 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1556992 ++read 8192/8192 bytes at offset 1556992 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1573376 ++read 8192/8192 bytes at offset 1573376 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1589760 ++read 8192/8192 bytes at offset 1589760 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1606144 ++read 8192/8192 bytes at offset 1606144 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1622528 ++read 8192/8192 bytes at offset 1622528 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1638912 ++read 8192/8192 bytes at offset 1638912 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1655296 ++read 8192/8192 bytes at offset 1655296 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1671680 ++read 8192/8192 bytes at offset 1671680 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1688064 ++read 8192/8192 bytes at offset 1688064 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1704448 ++read 8192/8192 bytes at offset 1704448 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1720832 ++read 8192/8192 bytes at offset 1720832 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1737216 ++read 8192/8192 bytes at offset 1737216 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1753600 ++read 8192/8192 bytes at offset 1753600 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 137 +-qemu-io> read 8192/8192 bytes at offset 1774080 ++=== IO: pattern 137 ++read 8192/8192 bytes at offset 1774080 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1790464 ++read 8192/8192 bytes at offset 1790464 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1806848 ++read 8192/8192 bytes at offset 1806848 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1823232 ++read 8192/8192 bytes at offset 1823232 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1839616 ++read 8192/8192 bytes at offset 1839616 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1856000 ++read 8192/8192 bytes at offset 1856000 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1872384 ++read 8192/8192 bytes at offset 1872384 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1888768 ++read 8192/8192 bytes at offset 1888768 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1905152 ++read 8192/8192 bytes at offset 1905152 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1921536 ++read 8192/8192 bytes at offset 1921536 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1937920 ++read 8192/8192 bytes at offset 1937920 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1954304 ++read 8192/8192 bytes at offset 1954304 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1970688 ++read 8192/8192 bytes at offset 1970688 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1987072 ++read 8192/8192 bytes at offset 1987072 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2003456 ++read 8192/8192 bytes at offset 2003456 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2019840 ++read 8192/8192 bytes at offset 2019840 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2036224 ++read 8192/8192 bytes at offset 2036224 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2052608 ++read 8192/8192 bytes at offset 2052608 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2068992 ++read 8192/8192 bytes at offset 2068992 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2085376 ++read 8192/8192 bytes at offset 2085376 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2101760 ++read 8192/8192 bytes at offset 2101760 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2118144 ++read 8192/8192 bytes at offset 2118144 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2134528 ++read 8192/8192 bytes at offset 2134528 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2150912 ++read 8192/8192 bytes at offset 2150912 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2167296 ++read 8192/8192 bytes at offset 2167296 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2183680 ++read 8192/8192 bytes at offset 2183680 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2200064 ++read 8192/8192 bytes at offset 2200064 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2216448 ++read 8192/8192 bytes at offset 2216448 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2232832 ++read 8192/8192 bytes at offset 2232832 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2249216 ++read 8192/8192 bytes at offset 2249216 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2265600 ++read 8192/8192 bytes at offset 2265600 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2281984 ++read 8192/8192 bytes at offset 2281984 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2298368 ++read 8192/8192 bytes at offset 2298368 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2314752 ++read 8192/8192 bytes at offset 2314752 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2331136 ++read 8192/8192 bytes at offset 2331136 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2347520 ++read 8192/8192 bytes at offset 2347520 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 17 +-qemu-io> read 32768/32768 bytes at offset 2368000 ++=== IO: pattern 17 ++read 32768/32768 bytes at offset 2368000 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 2417152 ++read 32768/32768 bytes at offset 2417152 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 2466304 ++read 32768/32768 bytes at offset 2466304 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 2515456 ++read 32768/32768 bytes at offset 2515456 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 2564608 ++read 32768/32768 bytes at offset 2564608 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 2613760 ++read 32768/32768 bytes at offset 2613760 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 2662912 ++read 32768/32768 bytes at offset 2662912 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 2712064 ++read 32768/32768 bytes at offset 2712064 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 2761216 ++read 32768/32768 bytes at offset 2761216 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 208 +-qemu-io> read 49152/49152 bytes at offset 33529856 ++=== IO: pattern 208 ++read 49152/49152 bytes at offset 33529856 + 48 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 49152/49152 bytes at offset 67092480 ++read 49152/49152 bytes at offset 67092480 + 48 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 49152/49152 bytes at offset 100655104 ++read 49152/49152 bytes at offset 100655104 + 48 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 1 +-qemu-io> wrote 16384/16384 bytes at offset 512 ++=== IO: pattern 1 ++wrote 16384/16384 bytes at offset 512 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 16896 ++wrote 16384/16384 bytes at offset 16896 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 33280 ++wrote 16384/16384 bytes at offset 33280 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 49664 ++wrote 16384/16384 bytes at offset 49664 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 66048 ++wrote 16384/16384 bytes at offset 66048 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 82432 ++wrote 16384/16384 bytes at offset 82432 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 98816 ++wrote 16384/16384 bytes at offset 98816 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 115200 ++wrote 16384/16384 bytes at offset 115200 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 131584 ++wrote 16384/16384 bytes at offset 131584 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 147968 ++wrote 16384/16384 bytes at offset 147968 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 164352 ++wrote 16384/16384 bytes at offset 164352 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 180736 ++wrote 16384/16384 bytes at offset 180736 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 197120 ++wrote 16384/16384 bytes at offset 197120 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 213504 ++wrote 16384/16384 bytes at offset 213504 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 229888 ++wrote 16384/16384 bytes at offset 229888 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 246272 ++wrote 16384/16384 bytes at offset 246272 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 262656 ++wrote 16384/16384 bytes at offset 262656 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 279040 ++wrote 16384/16384 bytes at offset 279040 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 295424 ++wrote 16384/16384 bytes at offset 295424 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 311808 ++wrote 16384/16384 bytes at offset 311808 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 328192 ++wrote 16384/16384 bytes at offset 328192 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 344576 ++wrote 16384/16384 bytes at offset 344576 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 360960 ++wrote 16384/16384 bytes at offset 360960 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 377344 ++wrote 16384/16384 bytes at offset 377344 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 393728 ++wrote 16384/16384 bytes at offset 393728 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 410112 ++wrote 16384/16384 bytes at offset 410112 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 426496 ++wrote 16384/16384 bytes at offset 426496 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 442880 ++wrote 16384/16384 bytes at offset 442880 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 459264 ++wrote 16384/16384 bytes at offset 459264 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 475648 ++wrote 16384/16384 bytes at offset 475648 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 492032 ++wrote 16384/16384 bytes at offset 492032 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 508416 ++wrote 16384/16384 bytes at offset 508416 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 524800 ++wrote 16384/16384 bytes at offset 524800 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 541184 ++wrote 16384/16384 bytes at offset 541184 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 557568 ++wrote 16384/16384 bytes at offset 557568 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 573952 ++wrote 16384/16384 bytes at offset 573952 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 145 +-qemu-io> wrote 8192/8192 bytes at offset 598528 ++=== IO: pattern 145 ++wrote 8192/8192 bytes at offset 598528 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 614912 ++wrote 8192/8192 bytes at offset 614912 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 631296 ++wrote 8192/8192 bytes at offset 631296 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 647680 ++wrote 8192/8192 bytes at offset 647680 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 664064 ++wrote 8192/8192 bytes at offset 664064 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 680448 ++wrote 8192/8192 bytes at offset 680448 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 696832 ++wrote 8192/8192 bytes at offset 696832 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 713216 ++wrote 8192/8192 bytes at offset 713216 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 729600 ++wrote 8192/8192 bytes at offset 729600 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 745984 ++wrote 8192/8192 bytes at offset 745984 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 762368 ++wrote 8192/8192 bytes at offset 762368 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 778752 ++wrote 8192/8192 bytes at offset 778752 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 795136 ++wrote 8192/8192 bytes at offset 795136 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 811520 ++wrote 8192/8192 bytes at offset 811520 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 827904 ++wrote 8192/8192 bytes at offset 827904 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 844288 ++wrote 8192/8192 bytes at offset 844288 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 860672 ++wrote 8192/8192 bytes at offset 860672 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 877056 ++wrote 8192/8192 bytes at offset 877056 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 893440 ++wrote 8192/8192 bytes at offset 893440 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 909824 ++wrote 8192/8192 bytes at offset 909824 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 926208 ++wrote 8192/8192 bytes at offset 926208 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 942592 ++wrote 8192/8192 bytes at offset 942592 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 958976 ++wrote 8192/8192 bytes at offset 958976 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 975360 ++wrote 8192/8192 bytes at offset 975360 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 991744 ++wrote 8192/8192 bytes at offset 991744 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1008128 ++wrote 8192/8192 bytes at offset 1008128 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1024512 ++wrote 8192/8192 bytes at offset 1024512 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1040896 ++wrote 8192/8192 bytes at offset 1040896 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1057280 ++wrote 8192/8192 bytes at offset 1057280 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1073664 ++wrote 8192/8192 bytes at offset 1073664 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1090048 ++wrote 8192/8192 bytes at offset 1090048 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1106432 ++wrote 8192/8192 bytes at offset 1106432 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1122816 ++wrote 8192/8192 bytes at offset 1122816 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1139200 ++wrote 8192/8192 bytes at offset 1139200 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1155584 ++wrote 8192/8192 bytes at offset 1155584 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1171968 ++wrote 8192/8192 bytes at offset 1171968 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 1 +-qemu-io> wrote 8192/8192 bytes at offset 1180160 ++=== IO: pattern 1 ++wrote 8192/8192 bytes at offset 1180160 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1196544 ++wrote 8192/8192 bytes at offset 1196544 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1212928 ++wrote 8192/8192 bytes at offset 1212928 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1229312 ++wrote 8192/8192 bytes at offset 1229312 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1245696 ++wrote 8192/8192 bytes at offset 1245696 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1262080 ++wrote 8192/8192 bytes at offset 1262080 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1278464 ++wrote 8192/8192 bytes at offset 1278464 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1294848 ++wrote 8192/8192 bytes at offset 1294848 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1311232 ++wrote 8192/8192 bytes at offset 1311232 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1327616 ++wrote 8192/8192 bytes at offset 1327616 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1344000 ++wrote 8192/8192 bytes at offset 1344000 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1360384 ++wrote 8192/8192 bytes at offset 1360384 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1376768 ++wrote 8192/8192 bytes at offset 1376768 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1393152 ++wrote 8192/8192 bytes at offset 1393152 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1409536 ++wrote 8192/8192 bytes at offset 1409536 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1425920 ++wrote 8192/8192 bytes at offset 1425920 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1442304 ++wrote 8192/8192 bytes at offset 1442304 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1458688 ++wrote 8192/8192 bytes at offset 1458688 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1475072 ++wrote 8192/8192 bytes at offset 1475072 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1491456 ++wrote 8192/8192 bytes at offset 1491456 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1507840 ++wrote 8192/8192 bytes at offset 1507840 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1524224 ++wrote 8192/8192 bytes at offset 1524224 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1540608 ++wrote 8192/8192 bytes at offset 1540608 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1556992 ++wrote 8192/8192 bytes at offset 1556992 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1573376 ++wrote 8192/8192 bytes at offset 1573376 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1589760 ++wrote 8192/8192 bytes at offset 1589760 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1606144 ++wrote 8192/8192 bytes at offset 1606144 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1622528 ++wrote 8192/8192 bytes at offset 1622528 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1638912 ++wrote 8192/8192 bytes at offset 1638912 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1655296 ++wrote 8192/8192 bytes at offset 1655296 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1671680 ++wrote 8192/8192 bytes at offset 1671680 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1688064 ++wrote 8192/8192 bytes at offset 1688064 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1704448 ++wrote 8192/8192 bytes at offset 1704448 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1720832 ++wrote 8192/8192 bytes at offset 1720832 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1737216 ++wrote 8192/8192 bytes at offset 1737216 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1753600 ++wrote 8192/8192 bytes at offset 1753600 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 137 +-qemu-io> wrote 8192/8192 bytes at offset 1774080 ++=== IO: pattern 137 ++wrote 8192/8192 bytes at offset 1774080 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1790464 ++wrote 8192/8192 bytes at offset 1790464 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1806848 ++wrote 8192/8192 bytes at offset 1806848 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1823232 ++wrote 8192/8192 bytes at offset 1823232 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1839616 ++wrote 8192/8192 bytes at offset 1839616 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1856000 ++wrote 8192/8192 bytes at offset 1856000 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1872384 ++wrote 8192/8192 bytes at offset 1872384 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1888768 ++wrote 8192/8192 bytes at offset 1888768 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1905152 ++wrote 8192/8192 bytes at offset 1905152 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1921536 ++wrote 8192/8192 bytes at offset 1921536 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1937920 ++wrote 8192/8192 bytes at offset 1937920 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1954304 ++wrote 8192/8192 bytes at offset 1954304 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1970688 ++wrote 8192/8192 bytes at offset 1970688 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 1987072 ++wrote 8192/8192 bytes at offset 1987072 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 2003456 ++wrote 8192/8192 bytes at offset 2003456 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 2019840 ++wrote 8192/8192 bytes at offset 2019840 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 2036224 ++wrote 8192/8192 bytes at offset 2036224 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 2052608 ++wrote 8192/8192 bytes at offset 2052608 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 2068992 ++wrote 8192/8192 bytes at offset 2068992 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 2085376 ++wrote 8192/8192 bytes at offset 2085376 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 2101760 ++wrote 8192/8192 bytes at offset 2101760 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 2118144 ++wrote 8192/8192 bytes at offset 2118144 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 2134528 ++wrote 8192/8192 bytes at offset 2134528 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 2150912 ++wrote 8192/8192 bytes at offset 2150912 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 2167296 ++wrote 8192/8192 bytes at offset 2167296 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 2183680 ++wrote 8192/8192 bytes at offset 2183680 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 2200064 ++wrote 8192/8192 bytes at offset 2200064 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 2216448 ++wrote 8192/8192 bytes at offset 2216448 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 2232832 ++wrote 8192/8192 bytes at offset 2232832 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 2249216 ++wrote 8192/8192 bytes at offset 2249216 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 2265600 ++wrote 8192/8192 bytes at offset 2265600 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 2281984 ++wrote 8192/8192 bytes at offset 2281984 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 2298368 ++wrote 8192/8192 bytes at offset 2298368 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 2314752 ++wrote 8192/8192 bytes at offset 2314752 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 2331136 ++wrote 8192/8192 bytes at offset 2331136 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 2347520 ++wrote 8192/8192 bytes at offset 2347520 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 17 +-qemu-io> wrote 32768/32768 bytes at offset 2368000 ++=== IO: pattern 17 ++wrote 32768/32768 bytes at offset 2368000 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 2417152 ++wrote 32768/32768 bytes at offset 2417152 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 2466304 ++wrote 32768/32768 bytes at offset 2466304 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 2515456 ++wrote 32768/32768 bytes at offset 2515456 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 2564608 ++wrote 32768/32768 bytes at offset 2564608 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 2613760 ++wrote 32768/32768 bytes at offset 2613760 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 2662912 ++wrote 32768/32768 bytes at offset 2662912 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 2712064 ++wrote 32768/32768 bytes at offset 2712064 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 2761216 ++wrote 32768/32768 bytes at offset 2761216 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 208 +-qemu-io> wrote 49152/49152 bytes at offset 33529856 ++=== IO: pattern 208 ++wrote 49152/49152 bytes at offset 33529856 + 48 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 49152/49152 bytes at offset 67092480 ++wrote 49152/49152 bytes at offset 67092480 + 48 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 49152/49152 bytes at offset 100655104 ++wrote 49152/49152 bytes at offset 100655104 + 48 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 1 +-qemu-io> read 16384/16384 bytes at offset 512 ++=== IO: pattern 1 ++read 16384/16384 bytes at offset 512 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 16896 ++read 16384/16384 bytes at offset 16896 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 33280 ++read 16384/16384 bytes at offset 33280 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 49664 ++read 16384/16384 bytes at offset 49664 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 66048 ++read 16384/16384 bytes at offset 66048 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 82432 ++read 16384/16384 bytes at offset 82432 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 98816 ++read 16384/16384 bytes at offset 98816 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 115200 ++read 16384/16384 bytes at offset 115200 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 131584 ++read 16384/16384 bytes at offset 131584 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 147968 ++read 16384/16384 bytes at offset 147968 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 164352 ++read 16384/16384 bytes at offset 164352 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 180736 ++read 16384/16384 bytes at offset 180736 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 197120 ++read 16384/16384 bytes at offset 197120 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 213504 ++read 16384/16384 bytes at offset 213504 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 229888 ++read 16384/16384 bytes at offset 229888 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 246272 ++read 16384/16384 bytes at offset 246272 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 262656 ++read 16384/16384 bytes at offset 262656 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 279040 ++read 16384/16384 bytes at offset 279040 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 295424 ++read 16384/16384 bytes at offset 295424 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 311808 ++read 16384/16384 bytes at offset 311808 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 328192 ++read 16384/16384 bytes at offset 328192 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 344576 ++read 16384/16384 bytes at offset 344576 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 360960 ++read 16384/16384 bytes at offset 360960 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 377344 ++read 16384/16384 bytes at offset 377344 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 393728 ++read 16384/16384 bytes at offset 393728 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 410112 ++read 16384/16384 bytes at offset 410112 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 426496 ++read 16384/16384 bytes at offset 426496 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 442880 ++read 16384/16384 bytes at offset 442880 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 459264 ++read 16384/16384 bytes at offset 459264 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 475648 ++read 16384/16384 bytes at offset 475648 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 492032 ++read 16384/16384 bytes at offset 492032 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 508416 ++read 16384/16384 bytes at offset 508416 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 524800 ++read 16384/16384 bytes at offset 524800 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 541184 ++read 16384/16384 bytes at offset 541184 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 557568 ++read 16384/16384 bytes at offset 557568 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 573952 ++read 16384/16384 bytes at offset 573952 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 145 +-qemu-io> read 8192/8192 bytes at offset 598528 ++=== IO: pattern 145 ++read 8192/8192 bytes at offset 598528 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 614912 ++read 8192/8192 bytes at offset 614912 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 631296 ++read 8192/8192 bytes at offset 631296 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 647680 ++read 8192/8192 bytes at offset 647680 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 664064 ++read 8192/8192 bytes at offset 664064 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 680448 ++read 8192/8192 bytes at offset 680448 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 696832 ++read 8192/8192 bytes at offset 696832 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 713216 ++read 8192/8192 bytes at offset 713216 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 729600 ++read 8192/8192 bytes at offset 729600 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 745984 ++read 8192/8192 bytes at offset 745984 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 762368 ++read 8192/8192 bytes at offset 762368 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 778752 ++read 8192/8192 bytes at offset 778752 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 795136 ++read 8192/8192 bytes at offset 795136 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 811520 ++read 8192/8192 bytes at offset 811520 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 827904 ++read 8192/8192 bytes at offset 827904 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 844288 ++read 8192/8192 bytes at offset 844288 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 860672 ++read 8192/8192 bytes at offset 860672 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 877056 ++read 8192/8192 bytes at offset 877056 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 893440 ++read 8192/8192 bytes at offset 893440 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 909824 ++read 8192/8192 bytes at offset 909824 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 926208 ++read 8192/8192 bytes at offset 926208 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 942592 ++read 8192/8192 bytes at offset 942592 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 958976 ++read 8192/8192 bytes at offset 958976 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 975360 ++read 8192/8192 bytes at offset 975360 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 991744 ++read 8192/8192 bytes at offset 991744 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1008128 ++read 8192/8192 bytes at offset 1008128 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1024512 ++read 8192/8192 bytes at offset 1024512 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1040896 ++read 8192/8192 bytes at offset 1040896 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1057280 ++read 8192/8192 bytes at offset 1057280 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1073664 ++read 8192/8192 bytes at offset 1073664 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1090048 ++read 8192/8192 bytes at offset 1090048 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1106432 ++read 8192/8192 bytes at offset 1106432 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1122816 ++read 8192/8192 bytes at offset 1122816 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1139200 ++read 8192/8192 bytes at offset 1139200 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1155584 ++read 8192/8192 bytes at offset 1155584 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1171968 ++read 8192/8192 bytes at offset 1171968 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 1 +-qemu-io> read 8192/8192 bytes at offset 1180160 ++=== IO: pattern 1 ++read 8192/8192 bytes at offset 1180160 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1196544 ++read 8192/8192 bytes at offset 1196544 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1212928 ++read 8192/8192 bytes at offset 1212928 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1229312 ++read 8192/8192 bytes at offset 1229312 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1245696 ++read 8192/8192 bytes at offset 1245696 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1262080 ++read 8192/8192 bytes at offset 1262080 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1278464 ++read 8192/8192 bytes at offset 1278464 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1294848 ++read 8192/8192 bytes at offset 1294848 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1311232 ++read 8192/8192 bytes at offset 1311232 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1327616 ++read 8192/8192 bytes at offset 1327616 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1344000 ++read 8192/8192 bytes at offset 1344000 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1360384 ++read 8192/8192 bytes at offset 1360384 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1376768 ++read 8192/8192 bytes at offset 1376768 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1393152 ++read 8192/8192 bytes at offset 1393152 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1409536 ++read 8192/8192 bytes at offset 1409536 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1425920 ++read 8192/8192 bytes at offset 1425920 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1442304 ++read 8192/8192 bytes at offset 1442304 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1458688 ++read 8192/8192 bytes at offset 1458688 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1475072 ++read 8192/8192 bytes at offset 1475072 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1491456 ++read 8192/8192 bytes at offset 1491456 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1507840 ++read 8192/8192 bytes at offset 1507840 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1524224 ++read 8192/8192 bytes at offset 1524224 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1540608 ++read 8192/8192 bytes at offset 1540608 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1556992 ++read 8192/8192 bytes at offset 1556992 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1573376 ++read 8192/8192 bytes at offset 1573376 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1589760 ++read 8192/8192 bytes at offset 1589760 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1606144 ++read 8192/8192 bytes at offset 1606144 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1622528 ++read 8192/8192 bytes at offset 1622528 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1638912 ++read 8192/8192 bytes at offset 1638912 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1655296 ++read 8192/8192 bytes at offset 1655296 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1671680 ++read 8192/8192 bytes at offset 1671680 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1688064 ++read 8192/8192 bytes at offset 1688064 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1704448 ++read 8192/8192 bytes at offset 1704448 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1720832 ++read 8192/8192 bytes at offset 1720832 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1737216 ++read 8192/8192 bytes at offset 1737216 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1753600 ++read 8192/8192 bytes at offset 1753600 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 137 +-qemu-io> read 8192/8192 bytes at offset 1774080 ++=== IO: pattern 137 ++read 8192/8192 bytes at offset 1774080 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1790464 ++read 8192/8192 bytes at offset 1790464 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1806848 ++read 8192/8192 bytes at offset 1806848 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1823232 ++read 8192/8192 bytes at offset 1823232 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1839616 ++read 8192/8192 bytes at offset 1839616 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1856000 ++read 8192/8192 bytes at offset 1856000 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1872384 ++read 8192/8192 bytes at offset 1872384 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1888768 ++read 8192/8192 bytes at offset 1888768 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1905152 ++read 8192/8192 bytes at offset 1905152 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1921536 ++read 8192/8192 bytes at offset 1921536 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1937920 ++read 8192/8192 bytes at offset 1937920 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1954304 ++read 8192/8192 bytes at offset 1954304 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1970688 ++read 8192/8192 bytes at offset 1970688 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1987072 ++read 8192/8192 bytes at offset 1987072 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2003456 ++read 8192/8192 bytes at offset 2003456 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2019840 ++read 8192/8192 bytes at offset 2019840 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2036224 ++read 8192/8192 bytes at offset 2036224 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2052608 ++read 8192/8192 bytes at offset 2052608 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2068992 ++read 8192/8192 bytes at offset 2068992 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2085376 ++read 8192/8192 bytes at offset 2085376 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2101760 ++read 8192/8192 bytes at offset 2101760 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2118144 ++read 8192/8192 bytes at offset 2118144 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2134528 ++read 8192/8192 bytes at offset 2134528 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2150912 ++read 8192/8192 bytes at offset 2150912 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2167296 ++read 8192/8192 bytes at offset 2167296 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2183680 ++read 8192/8192 bytes at offset 2183680 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2200064 ++read 8192/8192 bytes at offset 2200064 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2216448 ++read 8192/8192 bytes at offset 2216448 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2232832 ++read 8192/8192 bytes at offset 2232832 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2249216 ++read 8192/8192 bytes at offset 2249216 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2265600 ++read 8192/8192 bytes at offset 2265600 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2281984 ++read 8192/8192 bytes at offset 2281984 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2298368 ++read 8192/8192 bytes at offset 2298368 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2314752 ++read 8192/8192 bytes at offset 2314752 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2331136 ++read 8192/8192 bytes at offset 2331136 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 2347520 ++read 8192/8192 bytes at offset 2347520 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 17 +-qemu-io> read 32768/32768 bytes at offset 2368000 ++=== IO: pattern 17 ++read 32768/32768 bytes at offset 2368000 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 2417152 ++read 32768/32768 bytes at offset 2417152 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 2466304 ++read 32768/32768 bytes at offset 2466304 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 2515456 ++read 32768/32768 bytes at offset 2515456 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 2564608 ++read 32768/32768 bytes at offset 2564608 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 2613760 ++read 32768/32768 bytes at offset 2613760 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 2662912 ++read 32768/32768 bytes at offset 2662912 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 2712064 ++read 32768/32768 bytes at offset 2712064 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 2761216 ++read 32768/32768 bytes at offset 2761216 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 208 +-qemu-io> read 49152/49152 bytes at offset 33529856 ++=== IO: pattern 208 ++read 49152/49152 bytes at offset 33529856 + 48 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 49152/49152 bytes at offset 67092480 ++read 49152/49152 bytes at offset 67092480 + 48 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 49152/49152 bytes at offset 100655104 ++read 49152/49152 bytes at offset 100655104 + 48 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> No errors were found on the image. ++No errors were found on the image. + With offset 4294967808: + === IO: pattern 1 +-qemu-io> wrote 16384/16384 bytes at offset 4294967808 ++wrote 16384/16384 bytes at offset 4294967808 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4294984192 ++wrote 16384/16384 bytes at offset 4294984192 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295000576 ++wrote 16384/16384 bytes at offset 4295000576 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295016960 ++wrote 16384/16384 bytes at offset 4295016960 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295033344 ++wrote 16384/16384 bytes at offset 4295033344 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295049728 ++wrote 16384/16384 bytes at offset 4295049728 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295066112 ++wrote 16384/16384 bytes at offset 4295066112 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295082496 ++wrote 16384/16384 bytes at offset 4295082496 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295098880 ++wrote 16384/16384 bytes at offset 4295098880 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295115264 ++wrote 16384/16384 bytes at offset 4295115264 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295131648 ++wrote 16384/16384 bytes at offset 4295131648 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295148032 ++wrote 16384/16384 bytes at offset 4295148032 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295164416 ++wrote 16384/16384 bytes at offset 4295164416 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295180800 ++wrote 16384/16384 bytes at offset 4295180800 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295197184 ++wrote 16384/16384 bytes at offset 4295197184 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295213568 ++wrote 16384/16384 bytes at offset 4295213568 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295229952 ++wrote 16384/16384 bytes at offset 4295229952 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295246336 ++wrote 16384/16384 bytes at offset 4295246336 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295262720 ++wrote 16384/16384 bytes at offset 4295262720 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295279104 ++wrote 16384/16384 bytes at offset 4295279104 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295295488 ++wrote 16384/16384 bytes at offset 4295295488 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295311872 ++wrote 16384/16384 bytes at offset 4295311872 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295328256 ++wrote 16384/16384 bytes at offset 4295328256 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295344640 ++wrote 16384/16384 bytes at offset 4295344640 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295361024 ++wrote 16384/16384 bytes at offset 4295361024 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295377408 ++wrote 16384/16384 bytes at offset 4295377408 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295393792 ++wrote 16384/16384 bytes at offset 4295393792 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295410176 ++wrote 16384/16384 bytes at offset 4295410176 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295426560 ++wrote 16384/16384 bytes at offset 4295426560 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295442944 ++wrote 16384/16384 bytes at offset 4295442944 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295459328 ++wrote 16384/16384 bytes at offset 4295459328 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295475712 ++wrote 16384/16384 bytes at offset 4295475712 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295492096 ++wrote 16384/16384 bytes at offset 4295492096 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295508480 ++wrote 16384/16384 bytes at offset 4295508480 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295524864 ++wrote 16384/16384 bytes at offset 4295524864 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295541248 ++wrote 16384/16384 bytes at offset 4295541248 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 145 +-qemu-io> wrote 8192/8192 bytes at offset 4295565824 ++=== IO: pattern 145 ++wrote 8192/8192 bytes at offset 4295565824 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295582208 ++wrote 8192/8192 bytes at offset 4295582208 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295598592 ++wrote 8192/8192 bytes at offset 4295598592 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295614976 ++wrote 8192/8192 bytes at offset 4295614976 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295631360 ++wrote 8192/8192 bytes at offset 4295631360 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295647744 ++wrote 8192/8192 bytes at offset 4295647744 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295664128 ++wrote 8192/8192 bytes at offset 4295664128 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295680512 ++wrote 8192/8192 bytes at offset 4295680512 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295696896 ++wrote 8192/8192 bytes at offset 4295696896 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295713280 ++wrote 8192/8192 bytes at offset 4295713280 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295729664 ++wrote 8192/8192 bytes at offset 4295729664 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295746048 ++wrote 8192/8192 bytes at offset 4295746048 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295762432 ++wrote 8192/8192 bytes at offset 4295762432 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295778816 ++wrote 8192/8192 bytes at offset 4295778816 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295795200 ++wrote 8192/8192 bytes at offset 4295795200 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295811584 ++wrote 8192/8192 bytes at offset 4295811584 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295827968 ++wrote 8192/8192 bytes at offset 4295827968 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295844352 ++wrote 8192/8192 bytes at offset 4295844352 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295860736 ++wrote 8192/8192 bytes at offset 4295860736 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295877120 ++wrote 8192/8192 bytes at offset 4295877120 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295893504 ++wrote 8192/8192 bytes at offset 4295893504 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295909888 ++wrote 8192/8192 bytes at offset 4295909888 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295926272 ++wrote 8192/8192 bytes at offset 4295926272 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295942656 ++wrote 8192/8192 bytes at offset 4295942656 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295959040 ++wrote 8192/8192 bytes at offset 4295959040 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295975424 ++wrote 8192/8192 bytes at offset 4295975424 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295991808 ++wrote 8192/8192 bytes at offset 4295991808 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296008192 ++wrote 8192/8192 bytes at offset 4296008192 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296024576 ++wrote 8192/8192 bytes at offset 4296024576 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296040960 ++wrote 8192/8192 bytes at offset 4296040960 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296057344 ++wrote 8192/8192 bytes at offset 4296057344 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296073728 ++wrote 8192/8192 bytes at offset 4296073728 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296090112 ++wrote 8192/8192 bytes at offset 4296090112 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296106496 ++wrote 8192/8192 bytes at offset 4296106496 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296122880 ++wrote 8192/8192 bytes at offset 4296122880 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296139264 ++wrote 8192/8192 bytes at offset 4296139264 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 1 +-qemu-io> wrote 8192/8192 bytes at offset 4296147456 ++=== IO: pattern 1 ++wrote 8192/8192 bytes at offset 4296147456 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296163840 ++wrote 8192/8192 bytes at offset 4296163840 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296180224 ++wrote 8192/8192 bytes at offset 4296180224 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296196608 ++wrote 8192/8192 bytes at offset 4296196608 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296212992 ++wrote 8192/8192 bytes at offset 4296212992 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296229376 ++wrote 8192/8192 bytes at offset 4296229376 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296245760 ++wrote 8192/8192 bytes at offset 4296245760 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296262144 ++wrote 8192/8192 bytes at offset 4296262144 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296278528 ++wrote 8192/8192 bytes at offset 4296278528 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296294912 ++wrote 8192/8192 bytes at offset 4296294912 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296311296 ++wrote 8192/8192 bytes at offset 4296311296 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296327680 ++wrote 8192/8192 bytes at offset 4296327680 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296344064 ++wrote 8192/8192 bytes at offset 4296344064 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296360448 ++wrote 8192/8192 bytes at offset 4296360448 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296376832 ++wrote 8192/8192 bytes at offset 4296376832 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296393216 ++wrote 8192/8192 bytes at offset 4296393216 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296409600 ++wrote 8192/8192 bytes at offset 4296409600 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296425984 ++wrote 8192/8192 bytes at offset 4296425984 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296442368 ++wrote 8192/8192 bytes at offset 4296442368 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296458752 ++wrote 8192/8192 bytes at offset 4296458752 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296475136 ++wrote 8192/8192 bytes at offset 4296475136 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296491520 ++wrote 8192/8192 bytes at offset 4296491520 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296507904 ++wrote 8192/8192 bytes at offset 4296507904 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296524288 ++wrote 8192/8192 bytes at offset 4296524288 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296540672 ++wrote 8192/8192 bytes at offset 4296540672 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296557056 ++wrote 8192/8192 bytes at offset 4296557056 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296573440 ++wrote 8192/8192 bytes at offset 4296573440 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296589824 ++wrote 8192/8192 bytes at offset 4296589824 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296606208 ++wrote 8192/8192 bytes at offset 4296606208 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296622592 ++wrote 8192/8192 bytes at offset 4296622592 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296638976 ++wrote 8192/8192 bytes at offset 4296638976 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296655360 ++wrote 8192/8192 bytes at offset 4296655360 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296671744 ++wrote 8192/8192 bytes at offset 4296671744 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296688128 ++wrote 8192/8192 bytes at offset 4296688128 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296704512 ++wrote 8192/8192 bytes at offset 4296704512 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296720896 ++wrote 8192/8192 bytes at offset 4296720896 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 137 +-qemu-io> wrote 8192/8192 bytes at offset 4296741376 ++=== IO: pattern 137 ++wrote 8192/8192 bytes at offset 4296741376 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296757760 ++wrote 8192/8192 bytes at offset 4296757760 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296774144 ++wrote 8192/8192 bytes at offset 4296774144 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296790528 ++wrote 8192/8192 bytes at offset 4296790528 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296806912 ++wrote 8192/8192 bytes at offset 4296806912 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296823296 ++wrote 8192/8192 bytes at offset 4296823296 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296839680 ++wrote 8192/8192 bytes at offset 4296839680 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296856064 ++wrote 8192/8192 bytes at offset 4296856064 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296872448 ++wrote 8192/8192 bytes at offset 4296872448 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296888832 ++wrote 8192/8192 bytes at offset 4296888832 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296905216 ++wrote 8192/8192 bytes at offset 4296905216 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296921600 ++wrote 8192/8192 bytes at offset 4296921600 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296937984 ++wrote 8192/8192 bytes at offset 4296937984 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296954368 ++wrote 8192/8192 bytes at offset 4296954368 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296970752 ++wrote 8192/8192 bytes at offset 4296970752 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296987136 ++wrote 8192/8192 bytes at offset 4296987136 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4297003520 ++wrote 8192/8192 bytes at offset 4297003520 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4297019904 ++wrote 8192/8192 bytes at offset 4297019904 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4297036288 ++wrote 8192/8192 bytes at offset 4297036288 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4297052672 ++wrote 8192/8192 bytes at offset 4297052672 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4297069056 ++wrote 8192/8192 bytes at offset 4297069056 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4297085440 ++wrote 8192/8192 bytes at offset 4297085440 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4297101824 ++wrote 8192/8192 bytes at offset 4297101824 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4297118208 ++wrote 8192/8192 bytes at offset 4297118208 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4297134592 ++wrote 8192/8192 bytes at offset 4297134592 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4297150976 ++wrote 8192/8192 bytes at offset 4297150976 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4297167360 ++wrote 8192/8192 bytes at offset 4297167360 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4297183744 ++wrote 8192/8192 bytes at offset 4297183744 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4297200128 ++wrote 8192/8192 bytes at offset 4297200128 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4297216512 ++wrote 8192/8192 bytes at offset 4297216512 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4297232896 ++wrote 8192/8192 bytes at offset 4297232896 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4297249280 ++wrote 8192/8192 bytes at offset 4297249280 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4297265664 ++wrote 8192/8192 bytes at offset 4297265664 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4297282048 ++wrote 8192/8192 bytes at offset 4297282048 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4297298432 ++wrote 8192/8192 bytes at offset 4297298432 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4297314816 ++wrote 8192/8192 bytes at offset 4297314816 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 17 +-qemu-io> wrote 32768/32768 bytes at offset 4297335296 ++=== IO: pattern 17 ++wrote 32768/32768 bytes at offset 4297335296 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4297384448 ++wrote 32768/32768 bytes at offset 4297384448 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4297433600 ++wrote 32768/32768 bytes at offset 4297433600 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4297482752 ++wrote 32768/32768 bytes at offset 4297482752 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4297531904 ++wrote 32768/32768 bytes at offset 4297531904 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4297581056 ++wrote 32768/32768 bytes at offset 4297581056 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4297630208 ++wrote 32768/32768 bytes at offset 4297630208 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4297679360 ++wrote 32768/32768 bytes at offset 4297679360 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4297728512 ++wrote 32768/32768 bytes at offset 4297728512 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 208 +-qemu-io> wrote 49152/49152 bytes at offset 4328497152 ++=== IO: pattern 208 ++wrote 49152/49152 bytes at offset 4328497152 + 48 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 49152/49152 bytes at offset 4362059776 ++wrote 49152/49152 bytes at offset 4362059776 + 48 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 49152/49152 bytes at offset 4395622400 ++wrote 49152/49152 bytes at offset 4395622400 + 48 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 1 +-qemu-io> read 16384/16384 bytes at offset 4294967808 ++=== IO: pattern 1 ++read 16384/16384 bytes at offset 4294967808 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4294984192 ++read 16384/16384 bytes at offset 4294984192 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295000576 ++read 16384/16384 bytes at offset 4295000576 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295016960 ++read 16384/16384 bytes at offset 4295016960 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295033344 ++read 16384/16384 bytes at offset 4295033344 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295049728 ++read 16384/16384 bytes at offset 4295049728 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295066112 ++read 16384/16384 bytes at offset 4295066112 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295082496 ++read 16384/16384 bytes at offset 4295082496 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295098880 ++read 16384/16384 bytes at offset 4295098880 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295115264 ++read 16384/16384 bytes at offset 4295115264 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295131648 ++read 16384/16384 bytes at offset 4295131648 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295148032 ++read 16384/16384 bytes at offset 4295148032 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295164416 ++read 16384/16384 bytes at offset 4295164416 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295180800 ++read 16384/16384 bytes at offset 4295180800 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295197184 ++read 16384/16384 bytes at offset 4295197184 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295213568 ++read 16384/16384 bytes at offset 4295213568 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295229952 ++read 16384/16384 bytes at offset 4295229952 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295246336 ++read 16384/16384 bytes at offset 4295246336 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295262720 ++read 16384/16384 bytes at offset 4295262720 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295279104 ++read 16384/16384 bytes at offset 4295279104 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295295488 ++read 16384/16384 bytes at offset 4295295488 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295311872 ++read 16384/16384 bytes at offset 4295311872 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295328256 ++read 16384/16384 bytes at offset 4295328256 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295344640 ++read 16384/16384 bytes at offset 4295344640 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295361024 ++read 16384/16384 bytes at offset 4295361024 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295377408 ++read 16384/16384 bytes at offset 4295377408 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295393792 ++read 16384/16384 bytes at offset 4295393792 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295410176 ++read 16384/16384 bytes at offset 4295410176 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295426560 ++read 16384/16384 bytes at offset 4295426560 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295442944 ++read 16384/16384 bytes at offset 4295442944 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295459328 ++read 16384/16384 bytes at offset 4295459328 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295475712 ++read 16384/16384 bytes at offset 4295475712 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295492096 ++read 16384/16384 bytes at offset 4295492096 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295508480 ++read 16384/16384 bytes at offset 4295508480 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295524864 ++read 16384/16384 bytes at offset 4295524864 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295541248 ++read 16384/16384 bytes at offset 4295541248 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 145 +-qemu-io> read 8192/8192 bytes at offset 4295565824 ++=== IO: pattern 145 ++read 8192/8192 bytes at offset 4295565824 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295582208 ++read 8192/8192 bytes at offset 4295582208 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295598592 ++read 8192/8192 bytes at offset 4295598592 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295614976 ++read 8192/8192 bytes at offset 4295614976 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295631360 ++read 8192/8192 bytes at offset 4295631360 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295647744 ++read 8192/8192 bytes at offset 4295647744 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295664128 ++read 8192/8192 bytes at offset 4295664128 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295680512 ++read 8192/8192 bytes at offset 4295680512 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295696896 ++read 8192/8192 bytes at offset 4295696896 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295713280 ++read 8192/8192 bytes at offset 4295713280 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295729664 ++read 8192/8192 bytes at offset 4295729664 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295746048 ++read 8192/8192 bytes at offset 4295746048 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295762432 ++read 8192/8192 bytes at offset 4295762432 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295778816 ++read 8192/8192 bytes at offset 4295778816 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295795200 ++read 8192/8192 bytes at offset 4295795200 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295811584 ++read 8192/8192 bytes at offset 4295811584 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295827968 ++read 8192/8192 bytes at offset 4295827968 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295844352 ++read 8192/8192 bytes at offset 4295844352 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295860736 ++read 8192/8192 bytes at offset 4295860736 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295877120 ++read 8192/8192 bytes at offset 4295877120 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295893504 ++read 8192/8192 bytes at offset 4295893504 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295909888 ++read 8192/8192 bytes at offset 4295909888 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295926272 ++read 8192/8192 bytes at offset 4295926272 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295942656 ++read 8192/8192 bytes at offset 4295942656 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295959040 ++read 8192/8192 bytes at offset 4295959040 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295975424 ++read 8192/8192 bytes at offset 4295975424 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295991808 ++read 8192/8192 bytes at offset 4295991808 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296008192 ++read 8192/8192 bytes at offset 4296008192 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296024576 ++read 8192/8192 bytes at offset 4296024576 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296040960 ++read 8192/8192 bytes at offset 4296040960 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296057344 ++read 8192/8192 bytes at offset 4296057344 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296073728 ++read 8192/8192 bytes at offset 4296073728 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296090112 ++read 8192/8192 bytes at offset 4296090112 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296106496 ++read 8192/8192 bytes at offset 4296106496 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296122880 ++read 8192/8192 bytes at offset 4296122880 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296139264 ++read 8192/8192 bytes at offset 4296139264 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 1 +-qemu-io> read 8192/8192 bytes at offset 4296147456 ++=== IO: pattern 1 ++read 8192/8192 bytes at offset 4296147456 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296163840 ++read 8192/8192 bytes at offset 4296163840 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296180224 ++read 8192/8192 bytes at offset 4296180224 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296196608 ++read 8192/8192 bytes at offset 4296196608 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296212992 ++read 8192/8192 bytes at offset 4296212992 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296229376 ++read 8192/8192 bytes at offset 4296229376 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296245760 ++read 8192/8192 bytes at offset 4296245760 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296262144 ++read 8192/8192 bytes at offset 4296262144 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296278528 ++read 8192/8192 bytes at offset 4296278528 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296294912 ++read 8192/8192 bytes at offset 4296294912 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296311296 ++read 8192/8192 bytes at offset 4296311296 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296327680 ++read 8192/8192 bytes at offset 4296327680 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296344064 ++read 8192/8192 bytes at offset 4296344064 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296360448 ++read 8192/8192 bytes at offset 4296360448 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296376832 ++read 8192/8192 bytes at offset 4296376832 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296393216 ++read 8192/8192 bytes at offset 4296393216 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296409600 ++read 8192/8192 bytes at offset 4296409600 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296425984 ++read 8192/8192 bytes at offset 4296425984 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296442368 ++read 8192/8192 bytes at offset 4296442368 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296458752 ++read 8192/8192 bytes at offset 4296458752 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296475136 ++read 8192/8192 bytes at offset 4296475136 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296491520 ++read 8192/8192 bytes at offset 4296491520 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296507904 ++read 8192/8192 bytes at offset 4296507904 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296524288 ++read 8192/8192 bytes at offset 4296524288 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296540672 ++read 8192/8192 bytes at offset 4296540672 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296557056 ++read 8192/8192 bytes at offset 4296557056 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296573440 ++read 8192/8192 bytes at offset 4296573440 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296589824 ++read 8192/8192 bytes at offset 4296589824 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296606208 ++read 8192/8192 bytes at offset 4296606208 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296622592 ++read 8192/8192 bytes at offset 4296622592 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296638976 ++read 8192/8192 bytes at offset 4296638976 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296655360 ++read 8192/8192 bytes at offset 4296655360 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296671744 ++read 8192/8192 bytes at offset 4296671744 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296688128 ++read 8192/8192 bytes at offset 4296688128 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296704512 ++read 8192/8192 bytes at offset 4296704512 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296720896 ++read 8192/8192 bytes at offset 4296720896 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 137 +-qemu-io> read 8192/8192 bytes at offset 4296741376 ++=== IO: pattern 137 ++read 8192/8192 bytes at offset 4296741376 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296757760 ++read 8192/8192 bytes at offset 4296757760 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296774144 ++read 8192/8192 bytes at offset 4296774144 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296790528 ++read 8192/8192 bytes at offset 4296790528 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296806912 ++read 8192/8192 bytes at offset 4296806912 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296823296 ++read 8192/8192 bytes at offset 4296823296 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296839680 ++read 8192/8192 bytes at offset 4296839680 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296856064 ++read 8192/8192 bytes at offset 4296856064 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296872448 ++read 8192/8192 bytes at offset 4296872448 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296888832 ++read 8192/8192 bytes at offset 4296888832 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296905216 ++read 8192/8192 bytes at offset 4296905216 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296921600 ++read 8192/8192 bytes at offset 4296921600 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296937984 ++read 8192/8192 bytes at offset 4296937984 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296954368 ++read 8192/8192 bytes at offset 4296954368 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296970752 ++read 8192/8192 bytes at offset 4296970752 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296987136 ++read 8192/8192 bytes at offset 4296987136 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297003520 ++read 8192/8192 bytes at offset 4297003520 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297019904 ++read 8192/8192 bytes at offset 4297019904 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297036288 ++read 8192/8192 bytes at offset 4297036288 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297052672 ++read 8192/8192 bytes at offset 4297052672 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297069056 ++read 8192/8192 bytes at offset 4297069056 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297085440 ++read 8192/8192 bytes at offset 4297085440 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297101824 ++read 8192/8192 bytes at offset 4297101824 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297118208 ++read 8192/8192 bytes at offset 4297118208 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297134592 ++read 8192/8192 bytes at offset 4297134592 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297150976 ++read 8192/8192 bytes at offset 4297150976 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297167360 ++read 8192/8192 bytes at offset 4297167360 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297183744 ++read 8192/8192 bytes at offset 4297183744 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297200128 ++read 8192/8192 bytes at offset 4297200128 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297216512 ++read 8192/8192 bytes at offset 4297216512 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297232896 ++read 8192/8192 bytes at offset 4297232896 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297249280 ++read 8192/8192 bytes at offset 4297249280 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297265664 ++read 8192/8192 bytes at offset 4297265664 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297282048 ++read 8192/8192 bytes at offset 4297282048 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297298432 ++read 8192/8192 bytes at offset 4297298432 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297314816 ++read 8192/8192 bytes at offset 4297314816 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 17 +-qemu-io> read 32768/32768 bytes at offset 4297335296 ++=== IO: pattern 17 ++read 32768/32768 bytes at offset 4297335296 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4297384448 ++read 32768/32768 bytes at offset 4297384448 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4297433600 ++read 32768/32768 bytes at offset 4297433600 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4297482752 ++read 32768/32768 bytes at offset 4297482752 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4297531904 ++read 32768/32768 bytes at offset 4297531904 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4297581056 ++read 32768/32768 bytes at offset 4297581056 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4297630208 ++read 32768/32768 bytes at offset 4297630208 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4297679360 ++read 32768/32768 bytes at offset 4297679360 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4297728512 ++read 32768/32768 bytes at offset 4297728512 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 208 +-qemu-io> read 49152/49152 bytes at offset 4328497152 ++=== IO: pattern 208 ++read 49152/49152 bytes at offset 4328497152 + 48 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 49152/49152 bytes at offset 4362059776 ++read 49152/49152 bytes at offset 4362059776 + 48 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 49152/49152 bytes at offset 4395622400 ++read 49152/49152 bytes at offset 4395622400 + 48 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 1 +-qemu-io> wrote 16384/16384 bytes at offset 4294967808 ++=== IO: pattern 1 ++wrote 16384/16384 bytes at offset 4294967808 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4294984192 ++wrote 16384/16384 bytes at offset 4294984192 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295000576 ++wrote 16384/16384 bytes at offset 4295000576 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295016960 ++wrote 16384/16384 bytes at offset 4295016960 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295033344 ++wrote 16384/16384 bytes at offset 4295033344 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295049728 ++wrote 16384/16384 bytes at offset 4295049728 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295066112 ++wrote 16384/16384 bytes at offset 4295066112 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295082496 ++wrote 16384/16384 bytes at offset 4295082496 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295098880 ++wrote 16384/16384 bytes at offset 4295098880 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295115264 ++wrote 16384/16384 bytes at offset 4295115264 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295131648 ++wrote 16384/16384 bytes at offset 4295131648 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295148032 ++wrote 16384/16384 bytes at offset 4295148032 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295164416 ++wrote 16384/16384 bytes at offset 4295164416 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295180800 ++wrote 16384/16384 bytes at offset 4295180800 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295197184 ++wrote 16384/16384 bytes at offset 4295197184 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295213568 ++wrote 16384/16384 bytes at offset 4295213568 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295229952 ++wrote 16384/16384 bytes at offset 4295229952 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295246336 ++wrote 16384/16384 bytes at offset 4295246336 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295262720 ++wrote 16384/16384 bytes at offset 4295262720 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295279104 ++wrote 16384/16384 bytes at offset 4295279104 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295295488 ++wrote 16384/16384 bytes at offset 4295295488 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295311872 ++wrote 16384/16384 bytes at offset 4295311872 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295328256 ++wrote 16384/16384 bytes at offset 4295328256 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295344640 ++wrote 16384/16384 bytes at offset 4295344640 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295361024 ++wrote 16384/16384 bytes at offset 4295361024 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295377408 ++wrote 16384/16384 bytes at offset 4295377408 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295393792 ++wrote 16384/16384 bytes at offset 4295393792 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295410176 ++wrote 16384/16384 bytes at offset 4295410176 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295426560 ++wrote 16384/16384 bytes at offset 4295426560 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295442944 ++wrote 16384/16384 bytes at offset 4295442944 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295459328 ++wrote 16384/16384 bytes at offset 4295459328 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295475712 ++wrote 16384/16384 bytes at offset 4295475712 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295492096 ++wrote 16384/16384 bytes at offset 4295492096 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295508480 ++wrote 16384/16384 bytes at offset 4295508480 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295524864 ++wrote 16384/16384 bytes at offset 4295524864 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295541248 ++wrote 16384/16384 bytes at offset 4295541248 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 145 +-qemu-io> wrote 8192/8192 bytes at offset 4295565824 ++=== IO: pattern 145 ++wrote 8192/8192 bytes at offset 4295565824 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295582208 ++wrote 8192/8192 bytes at offset 4295582208 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295598592 ++wrote 8192/8192 bytes at offset 4295598592 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295614976 ++wrote 8192/8192 bytes at offset 4295614976 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295631360 ++wrote 8192/8192 bytes at offset 4295631360 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295647744 ++wrote 8192/8192 bytes at offset 4295647744 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295664128 ++wrote 8192/8192 bytes at offset 4295664128 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295680512 ++wrote 8192/8192 bytes at offset 4295680512 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295696896 ++wrote 8192/8192 bytes at offset 4295696896 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295713280 ++wrote 8192/8192 bytes at offset 4295713280 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295729664 ++wrote 8192/8192 bytes at offset 4295729664 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295746048 ++wrote 8192/8192 bytes at offset 4295746048 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295762432 ++wrote 8192/8192 bytes at offset 4295762432 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295778816 ++wrote 8192/8192 bytes at offset 4295778816 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295795200 ++wrote 8192/8192 bytes at offset 4295795200 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295811584 ++wrote 8192/8192 bytes at offset 4295811584 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295827968 ++wrote 8192/8192 bytes at offset 4295827968 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295844352 ++wrote 8192/8192 bytes at offset 4295844352 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295860736 ++wrote 8192/8192 bytes at offset 4295860736 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295877120 ++wrote 8192/8192 bytes at offset 4295877120 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295893504 ++wrote 8192/8192 bytes at offset 4295893504 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295909888 ++wrote 8192/8192 bytes at offset 4295909888 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295926272 ++wrote 8192/8192 bytes at offset 4295926272 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295942656 ++wrote 8192/8192 bytes at offset 4295942656 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295959040 ++wrote 8192/8192 bytes at offset 4295959040 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295975424 ++wrote 8192/8192 bytes at offset 4295975424 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4295991808 ++wrote 8192/8192 bytes at offset 4295991808 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296008192 ++wrote 8192/8192 bytes at offset 4296008192 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296024576 ++wrote 8192/8192 bytes at offset 4296024576 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296040960 ++wrote 8192/8192 bytes at offset 4296040960 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296057344 ++wrote 8192/8192 bytes at offset 4296057344 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296073728 ++wrote 8192/8192 bytes at offset 4296073728 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296090112 ++wrote 8192/8192 bytes at offset 4296090112 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296106496 ++wrote 8192/8192 bytes at offset 4296106496 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296122880 ++wrote 8192/8192 bytes at offset 4296122880 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296139264 ++wrote 8192/8192 bytes at offset 4296139264 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 1 +-qemu-io> wrote 8192/8192 bytes at offset 4296147456 ++=== IO: pattern 1 ++wrote 8192/8192 bytes at offset 4296147456 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296163840 ++wrote 8192/8192 bytes at offset 4296163840 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296180224 ++wrote 8192/8192 bytes at offset 4296180224 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296196608 ++wrote 8192/8192 bytes at offset 4296196608 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296212992 ++wrote 8192/8192 bytes at offset 4296212992 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296229376 ++wrote 8192/8192 bytes at offset 4296229376 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296245760 ++wrote 8192/8192 bytes at offset 4296245760 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296262144 ++wrote 8192/8192 bytes at offset 4296262144 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296278528 ++wrote 8192/8192 bytes at offset 4296278528 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296294912 ++wrote 8192/8192 bytes at offset 4296294912 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296311296 ++wrote 8192/8192 bytes at offset 4296311296 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296327680 ++wrote 8192/8192 bytes at offset 4296327680 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296344064 ++wrote 8192/8192 bytes at offset 4296344064 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296360448 ++wrote 8192/8192 bytes at offset 4296360448 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296376832 ++wrote 8192/8192 bytes at offset 4296376832 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296393216 ++wrote 8192/8192 bytes at offset 4296393216 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296409600 ++wrote 8192/8192 bytes at offset 4296409600 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296425984 ++wrote 8192/8192 bytes at offset 4296425984 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296442368 ++wrote 8192/8192 bytes at offset 4296442368 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296458752 ++wrote 8192/8192 bytes at offset 4296458752 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296475136 ++wrote 8192/8192 bytes at offset 4296475136 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296491520 ++wrote 8192/8192 bytes at offset 4296491520 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296507904 ++wrote 8192/8192 bytes at offset 4296507904 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296524288 ++wrote 8192/8192 bytes at offset 4296524288 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296540672 ++wrote 8192/8192 bytes at offset 4296540672 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296557056 ++wrote 8192/8192 bytes at offset 4296557056 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296573440 ++wrote 8192/8192 bytes at offset 4296573440 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296589824 ++wrote 8192/8192 bytes at offset 4296589824 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296606208 ++wrote 8192/8192 bytes at offset 4296606208 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296622592 ++wrote 8192/8192 bytes at offset 4296622592 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296638976 ++wrote 8192/8192 bytes at offset 4296638976 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296655360 ++wrote 8192/8192 bytes at offset 4296655360 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296671744 ++wrote 8192/8192 bytes at offset 4296671744 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296688128 ++wrote 8192/8192 bytes at offset 4296688128 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296704512 ++wrote 8192/8192 bytes at offset 4296704512 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296720896 ++wrote 8192/8192 bytes at offset 4296720896 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 137 +-qemu-io> wrote 8192/8192 bytes at offset 4296741376 ++=== IO: pattern 137 ++wrote 8192/8192 bytes at offset 4296741376 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296757760 ++wrote 8192/8192 bytes at offset 4296757760 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296774144 ++wrote 8192/8192 bytes at offset 4296774144 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296790528 ++wrote 8192/8192 bytes at offset 4296790528 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296806912 ++wrote 8192/8192 bytes at offset 4296806912 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296823296 ++wrote 8192/8192 bytes at offset 4296823296 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296839680 ++wrote 8192/8192 bytes at offset 4296839680 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296856064 ++wrote 8192/8192 bytes at offset 4296856064 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296872448 ++wrote 8192/8192 bytes at offset 4296872448 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296888832 ++wrote 8192/8192 bytes at offset 4296888832 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296905216 ++wrote 8192/8192 bytes at offset 4296905216 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296921600 ++wrote 8192/8192 bytes at offset 4296921600 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296937984 ++wrote 8192/8192 bytes at offset 4296937984 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296954368 ++wrote 8192/8192 bytes at offset 4296954368 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296970752 ++wrote 8192/8192 bytes at offset 4296970752 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4296987136 ++wrote 8192/8192 bytes at offset 4296987136 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4297003520 ++wrote 8192/8192 bytes at offset 4297003520 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4297019904 ++wrote 8192/8192 bytes at offset 4297019904 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4297036288 ++wrote 8192/8192 bytes at offset 4297036288 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4297052672 ++wrote 8192/8192 bytes at offset 4297052672 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4297069056 ++wrote 8192/8192 bytes at offset 4297069056 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4297085440 ++wrote 8192/8192 bytes at offset 4297085440 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4297101824 ++wrote 8192/8192 bytes at offset 4297101824 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4297118208 ++wrote 8192/8192 bytes at offset 4297118208 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4297134592 ++wrote 8192/8192 bytes at offset 4297134592 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4297150976 ++wrote 8192/8192 bytes at offset 4297150976 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4297167360 ++wrote 8192/8192 bytes at offset 4297167360 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4297183744 ++wrote 8192/8192 bytes at offset 4297183744 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4297200128 ++wrote 8192/8192 bytes at offset 4297200128 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4297216512 ++wrote 8192/8192 bytes at offset 4297216512 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4297232896 ++wrote 8192/8192 bytes at offset 4297232896 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4297249280 ++wrote 8192/8192 bytes at offset 4297249280 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4297265664 ++wrote 8192/8192 bytes at offset 4297265664 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4297282048 ++wrote 8192/8192 bytes at offset 4297282048 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4297298432 ++wrote 8192/8192 bytes at offset 4297298432 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 8192/8192 bytes at offset 4297314816 ++wrote 8192/8192 bytes at offset 4297314816 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 17 +-qemu-io> wrote 32768/32768 bytes at offset 4297335296 ++=== IO: pattern 17 ++wrote 32768/32768 bytes at offset 4297335296 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4297384448 ++wrote 32768/32768 bytes at offset 4297384448 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4297433600 ++wrote 32768/32768 bytes at offset 4297433600 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4297482752 ++wrote 32768/32768 bytes at offset 4297482752 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4297531904 ++wrote 32768/32768 bytes at offset 4297531904 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4297581056 ++wrote 32768/32768 bytes at offset 4297581056 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4297630208 ++wrote 32768/32768 bytes at offset 4297630208 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4297679360 ++wrote 32768/32768 bytes at offset 4297679360 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4297728512 ++wrote 32768/32768 bytes at offset 4297728512 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 208 +-qemu-io> wrote 49152/49152 bytes at offset 4328497152 ++=== IO: pattern 208 ++wrote 49152/49152 bytes at offset 4328497152 + 48 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 49152/49152 bytes at offset 4362059776 ++wrote 49152/49152 bytes at offset 4362059776 + 48 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 49152/49152 bytes at offset 4395622400 ++wrote 49152/49152 bytes at offset 4395622400 + 48 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 1 +-qemu-io> read 16384/16384 bytes at offset 4294967808 ++=== IO: pattern 1 ++read 16384/16384 bytes at offset 4294967808 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4294984192 ++read 16384/16384 bytes at offset 4294984192 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295000576 ++read 16384/16384 bytes at offset 4295000576 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295016960 ++read 16384/16384 bytes at offset 4295016960 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295033344 ++read 16384/16384 bytes at offset 4295033344 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295049728 ++read 16384/16384 bytes at offset 4295049728 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295066112 ++read 16384/16384 bytes at offset 4295066112 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295082496 ++read 16384/16384 bytes at offset 4295082496 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295098880 ++read 16384/16384 bytes at offset 4295098880 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295115264 ++read 16384/16384 bytes at offset 4295115264 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295131648 ++read 16384/16384 bytes at offset 4295131648 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295148032 ++read 16384/16384 bytes at offset 4295148032 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295164416 ++read 16384/16384 bytes at offset 4295164416 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295180800 ++read 16384/16384 bytes at offset 4295180800 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295197184 ++read 16384/16384 bytes at offset 4295197184 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295213568 ++read 16384/16384 bytes at offset 4295213568 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295229952 ++read 16384/16384 bytes at offset 4295229952 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295246336 ++read 16384/16384 bytes at offset 4295246336 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295262720 ++read 16384/16384 bytes at offset 4295262720 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295279104 ++read 16384/16384 bytes at offset 4295279104 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295295488 ++read 16384/16384 bytes at offset 4295295488 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295311872 ++read 16384/16384 bytes at offset 4295311872 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295328256 ++read 16384/16384 bytes at offset 4295328256 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295344640 ++read 16384/16384 bytes at offset 4295344640 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295361024 ++read 16384/16384 bytes at offset 4295361024 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295377408 ++read 16384/16384 bytes at offset 4295377408 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295393792 ++read 16384/16384 bytes at offset 4295393792 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295410176 ++read 16384/16384 bytes at offset 4295410176 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295426560 ++read 16384/16384 bytes at offset 4295426560 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295442944 ++read 16384/16384 bytes at offset 4295442944 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295459328 ++read 16384/16384 bytes at offset 4295459328 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295475712 ++read 16384/16384 bytes at offset 4295475712 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295492096 ++read 16384/16384 bytes at offset 4295492096 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295508480 ++read 16384/16384 bytes at offset 4295508480 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295524864 ++read 16384/16384 bytes at offset 4295524864 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295541248 ++read 16384/16384 bytes at offset 4295541248 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 145 +-qemu-io> read 8192/8192 bytes at offset 4295565824 ++=== IO: pattern 145 ++read 8192/8192 bytes at offset 4295565824 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295582208 ++read 8192/8192 bytes at offset 4295582208 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295598592 ++read 8192/8192 bytes at offset 4295598592 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295614976 ++read 8192/8192 bytes at offset 4295614976 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295631360 ++read 8192/8192 bytes at offset 4295631360 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295647744 ++read 8192/8192 bytes at offset 4295647744 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295664128 ++read 8192/8192 bytes at offset 4295664128 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295680512 ++read 8192/8192 bytes at offset 4295680512 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295696896 ++read 8192/8192 bytes at offset 4295696896 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295713280 ++read 8192/8192 bytes at offset 4295713280 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295729664 ++read 8192/8192 bytes at offset 4295729664 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295746048 ++read 8192/8192 bytes at offset 4295746048 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295762432 ++read 8192/8192 bytes at offset 4295762432 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295778816 ++read 8192/8192 bytes at offset 4295778816 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295795200 ++read 8192/8192 bytes at offset 4295795200 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295811584 ++read 8192/8192 bytes at offset 4295811584 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295827968 ++read 8192/8192 bytes at offset 4295827968 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295844352 ++read 8192/8192 bytes at offset 4295844352 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295860736 ++read 8192/8192 bytes at offset 4295860736 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295877120 ++read 8192/8192 bytes at offset 4295877120 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295893504 ++read 8192/8192 bytes at offset 4295893504 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295909888 ++read 8192/8192 bytes at offset 4295909888 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295926272 ++read 8192/8192 bytes at offset 4295926272 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295942656 ++read 8192/8192 bytes at offset 4295942656 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295959040 ++read 8192/8192 bytes at offset 4295959040 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295975424 ++read 8192/8192 bytes at offset 4295975424 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4295991808 ++read 8192/8192 bytes at offset 4295991808 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296008192 ++read 8192/8192 bytes at offset 4296008192 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296024576 ++read 8192/8192 bytes at offset 4296024576 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296040960 ++read 8192/8192 bytes at offset 4296040960 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296057344 ++read 8192/8192 bytes at offset 4296057344 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296073728 ++read 8192/8192 bytes at offset 4296073728 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296090112 ++read 8192/8192 bytes at offset 4296090112 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296106496 ++read 8192/8192 bytes at offset 4296106496 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296122880 ++read 8192/8192 bytes at offset 4296122880 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296139264 ++read 8192/8192 bytes at offset 4296139264 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 1 +-qemu-io> read 8192/8192 bytes at offset 4296147456 ++=== IO: pattern 1 ++read 8192/8192 bytes at offset 4296147456 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296163840 ++read 8192/8192 bytes at offset 4296163840 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296180224 ++read 8192/8192 bytes at offset 4296180224 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296196608 ++read 8192/8192 bytes at offset 4296196608 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296212992 ++read 8192/8192 bytes at offset 4296212992 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296229376 ++read 8192/8192 bytes at offset 4296229376 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296245760 ++read 8192/8192 bytes at offset 4296245760 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296262144 ++read 8192/8192 bytes at offset 4296262144 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296278528 ++read 8192/8192 bytes at offset 4296278528 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296294912 ++read 8192/8192 bytes at offset 4296294912 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296311296 ++read 8192/8192 bytes at offset 4296311296 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296327680 ++read 8192/8192 bytes at offset 4296327680 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296344064 ++read 8192/8192 bytes at offset 4296344064 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296360448 ++read 8192/8192 bytes at offset 4296360448 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296376832 ++read 8192/8192 bytes at offset 4296376832 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296393216 ++read 8192/8192 bytes at offset 4296393216 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296409600 ++read 8192/8192 bytes at offset 4296409600 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296425984 ++read 8192/8192 bytes at offset 4296425984 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296442368 ++read 8192/8192 bytes at offset 4296442368 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296458752 ++read 8192/8192 bytes at offset 4296458752 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296475136 ++read 8192/8192 bytes at offset 4296475136 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296491520 ++read 8192/8192 bytes at offset 4296491520 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296507904 ++read 8192/8192 bytes at offset 4296507904 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296524288 ++read 8192/8192 bytes at offset 4296524288 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296540672 ++read 8192/8192 bytes at offset 4296540672 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296557056 ++read 8192/8192 bytes at offset 4296557056 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296573440 ++read 8192/8192 bytes at offset 4296573440 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296589824 ++read 8192/8192 bytes at offset 4296589824 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296606208 ++read 8192/8192 bytes at offset 4296606208 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296622592 ++read 8192/8192 bytes at offset 4296622592 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296638976 ++read 8192/8192 bytes at offset 4296638976 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296655360 ++read 8192/8192 bytes at offset 4296655360 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296671744 ++read 8192/8192 bytes at offset 4296671744 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296688128 ++read 8192/8192 bytes at offset 4296688128 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296704512 ++read 8192/8192 bytes at offset 4296704512 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296720896 ++read 8192/8192 bytes at offset 4296720896 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 137 +-qemu-io> read 8192/8192 bytes at offset 4296741376 ++=== IO: pattern 137 ++read 8192/8192 bytes at offset 4296741376 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296757760 ++read 8192/8192 bytes at offset 4296757760 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296774144 ++read 8192/8192 bytes at offset 4296774144 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296790528 ++read 8192/8192 bytes at offset 4296790528 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296806912 ++read 8192/8192 bytes at offset 4296806912 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296823296 ++read 8192/8192 bytes at offset 4296823296 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296839680 ++read 8192/8192 bytes at offset 4296839680 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296856064 ++read 8192/8192 bytes at offset 4296856064 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296872448 ++read 8192/8192 bytes at offset 4296872448 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296888832 ++read 8192/8192 bytes at offset 4296888832 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296905216 ++read 8192/8192 bytes at offset 4296905216 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296921600 ++read 8192/8192 bytes at offset 4296921600 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296937984 ++read 8192/8192 bytes at offset 4296937984 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296954368 ++read 8192/8192 bytes at offset 4296954368 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296970752 ++read 8192/8192 bytes at offset 4296970752 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4296987136 ++read 8192/8192 bytes at offset 4296987136 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297003520 ++read 8192/8192 bytes at offset 4297003520 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297019904 ++read 8192/8192 bytes at offset 4297019904 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297036288 ++read 8192/8192 bytes at offset 4297036288 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297052672 ++read 8192/8192 bytes at offset 4297052672 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297069056 ++read 8192/8192 bytes at offset 4297069056 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297085440 ++read 8192/8192 bytes at offset 4297085440 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297101824 ++read 8192/8192 bytes at offset 4297101824 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297118208 ++read 8192/8192 bytes at offset 4297118208 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297134592 ++read 8192/8192 bytes at offset 4297134592 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297150976 ++read 8192/8192 bytes at offset 4297150976 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297167360 ++read 8192/8192 bytes at offset 4297167360 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297183744 ++read 8192/8192 bytes at offset 4297183744 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297200128 ++read 8192/8192 bytes at offset 4297200128 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297216512 ++read 8192/8192 bytes at offset 4297216512 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297232896 ++read 8192/8192 bytes at offset 4297232896 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297249280 ++read 8192/8192 bytes at offset 4297249280 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297265664 ++read 8192/8192 bytes at offset 4297265664 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297282048 ++read 8192/8192 bytes at offset 4297282048 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297298432 ++read 8192/8192 bytes at offset 4297298432 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 4297314816 ++read 8192/8192 bytes at offset 4297314816 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 17 +-qemu-io> read 32768/32768 bytes at offset 4297335296 ++=== IO: pattern 17 ++read 32768/32768 bytes at offset 4297335296 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4297384448 ++read 32768/32768 bytes at offset 4297384448 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4297433600 ++read 32768/32768 bytes at offset 4297433600 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4297482752 ++read 32768/32768 bytes at offset 4297482752 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4297531904 ++read 32768/32768 bytes at offset 4297531904 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4297581056 ++read 32768/32768 bytes at offset 4297581056 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4297630208 ++read 32768/32768 bytes at offset 4297630208 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4297679360 ++read 32768/32768 bytes at offset 4297679360 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4297728512 ++read 32768/32768 bytes at offset 4297728512 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 208 +-qemu-io> read 49152/49152 bytes at offset 4328497152 ++=== IO: pattern 208 ++read 49152/49152 bytes at offset 4328497152 + 48 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 49152/49152 bytes at offset 4362059776 ++read 49152/49152 bytes at offset 4362059776 + 48 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 49152/49152 bytes at offset 4395622400 ++read 49152/49152 bytes at offset 4395622400 + 48 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> No errors were found on the image. ++No errors were found on the image. + Creating another new image + + Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=8589934592 +@@ -18882,221 +18882,221 @@ More complex patterns + test2: With offset 0 + === Clusters to be compressed [1] + === IO: pattern 165 +-qemu-io> wrote 16384/16384 bytes at offset 65536 ++wrote 16384/16384 bytes at offset 65536 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 212992 ++wrote 16384/16384 bytes at offset 212992 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 360448 ++wrote 16384/16384 bytes at offset 360448 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 507904 ++wrote 16384/16384 bytes at offset 507904 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === Clusters to be compressed [2] ++=== Clusters to be compressed [2] + === IO: pattern 165 +-qemu-io> wrote 16384/16384 bytes at offset 81920 ++wrote 16384/16384 bytes at offset 81920 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 229376 ++wrote 16384/16384 bytes at offset 229376 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 376832 ++wrote 16384/16384 bytes at offset 376832 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 524288 ++wrote 16384/16384 bytes at offset 524288 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === Clusters to be compressed [3] ++=== Clusters to be compressed [3] + === IO: pattern 165 +-qemu-io> wrote 16384/16384 bytes at offset 131072 ++wrote 16384/16384 bytes at offset 131072 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 278528 ++wrote 16384/16384 bytes at offset 278528 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 425984 ++wrote 16384/16384 bytes at offset 425984 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 573440 ++wrote 16384/16384 bytes at offset 573440 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === Used clusters [1] ++=== Used clusters [1] + === IO: pattern 165 +-qemu-io> wrote 16384/16384 bytes at offset 0 ++wrote 16384/16384 bytes at offset 0 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 147456 ++wrote 16384/16384 bytes at offset 147456 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 294912 ++wrote 16384/16384 bytes at offset 294912 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 442368 ++wrote 16384/16384 bytes at offset 442368 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === Used clusters [2] ++=== Used clusters [2] + === IO: pattern 165 +-qemu-io> wrote 16384/16384 bytes at offset 16384 ++wrote 16384/16384 bytes at offset 16384 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 163840 ++wrote 16384/16384 bytes at offset 163840 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 311296 ++wrote 16384/16384 bytes at offset 311296 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 458752 ++wrote 16384/16384 bytes at offset 458752 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === Used clusters [3] ++=== Used clusters [3] + === IO: pattern 165 +-qemu-io> wrote 16384/16384 bytes at offset 49152 ++wrote 16384/16384 bytes at offset 49152 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 196608 ++wrote 16384/16384 bytes at offset 196608 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 344064 ++wrote 16384/16384 bytes at offset 344064 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 491520 ++wrote 16384/16384 bytes at offset 491520 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === Read used/compressed clusters ++=== Read used/compressed clusters + === IO: pattern 165 +-qemu-io> read 32768/32768 bytes at offset 0 ++read 32768/32768 bytes at offset 0 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 147456 ++read 32768/32768 bytes at offset 147456 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 294912 ++read 32768/32768 bytes at offset 294912 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 442368 ++read 32768/32768 bytes at offset 442368 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 165 +-qemu-io> read 49152/49152 bytes at offset 49152 ++=== IO: pattern 165 ++read 49152/49152 bytes at offset 49152 + 48 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 49152/49152 bytes at offset 196608 ++read 49152/49152 bytes at offset 196608 + 48 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 49152/49152 bytes at offset 344064 ++read 49152/49152 bytes at offset 344064 + 48 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 49152/49152 bytes at offset 491520 ++read 49152/49152 bytes at offset 491520 + 48 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 165 +-qemu-io> read 16384/16384 bytes at offset 131072 ++=== IO: pattern 165 ++read 16384/16384 bytes at offset 131072 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 278528 ++read 16384/16384 bytes at offset 278528 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 425984 ++read 16384/16384 bytes at offset 425984 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 573440 ++read 16384/16384 bytes at offset 573440 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === Read zeros ++=== Read zeros + === IO: pattern 0 +-qemu-io> read 16384/16384 bytes at offset 32768 ++read 16384/16384 bytes at offset 32768 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 180224 ++read 16384/16384 bytes at offset 180224 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 327680 ++read 16384/16384 bytes at offset 327680 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 475136 ++read 16384/16384 bytes at offset 475136 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> read 32768/32768 bytes at offset 98304 ++=== IO: pattern 0 ++read 32768/32768 bytes at offset 98304 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 245760 ++read 32768/32768 bytes at offset 245760 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 393216 ++read 32768/32768 bytes at offset 393216 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 540672 ++read 32768/32768 bytes at offset 540672 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> No errors were found on the image. ++No errors were found on the image. + test2: With offset 4294967296 + === Clusters to be compressed [1] + === IO: pattern 165 +-qemu-io> wrote 16384/16384 bytes at offset 4295032832 ++wrote 16384/16384 bytes at offset 4295032832 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295180288 ++wrote 16384/16384 bytes at offset 4295180288 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295327744 ++wrote 16384/16384 bytes at offset 4295327744 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295475200 ++wrote 16384/16384 bytes at offset 4295475200 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === Clusters to be compressed [2] ++=== Clusters to be compressed [2] + === IO: pattern 165 +-qemu-io> wrote 16384/16384 bytes at offset 4295049216 ++wrote 16384/16384 bytes at offset 4295049216 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295196672 ++wrote 16384/16384 bytes at offset 4295196672 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295344128 ++wrote 16384/16384 bytes at offset 4295344128 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295491584 ++wrote 16384/16384 bytes at offset 4295491584 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === Clusters to be compressed [3] ++=== Clusters to be compressed [3] + === IO: pattern 165 +-qemu-io> wrote 16384/16384 bytes at offset 4295098368 ++wrote 16384/16384 bytes at offset 4295098368 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295245824 ++wrote 16384/16384 bytes at offset 4295245824 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295393280 ++wrote 16384/16384 bytes at offset 4295393280 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295540736 ++wrote 16384/16384 bytes at offset 4295540736 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === Used clusters [1] ++=== Used clusters [1] + === IO: pattern 165 +-qemu-io> wrote 16384/16384 bytes at offset 4294967296 ++wrote 16384/16384 bytes at offset 4294967296 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295114752 ++wrote 16384/16384 bytes at offset 4295114752 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295262208 ++wrote 16384/16384 bytes at offset 4295262208 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295409664 ++wrote 16384/16384 bytes at offset 4295409664 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === Used clusters [2] ++=== Used clusters [2] + === IO: pattern 165 +-qemu-io> wrote 16384/16384 bytes at offset 4294983680 ++wrote 16384/16384 bytes at offset 4294983680 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295131136 ++wrote 16384/16384 bytes at offset 4295131136 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295278592 ++wrote 16384/16384 bytes at offset 4295278592 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295426048 ++wrote 16384/16384 bytes at offset 4295426048 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === Used clusters [3] ++=== Used clusters [3] + === IO: pattern 165 +-qemu-io> wrote 16384/16384 bytes at offset 4295016448 ++wrote 16384/16384 bytes at offset 4295016448 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295163904 ++wrote 16384/16384 bytes at offset 4295163904 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295311360 ++wrote 16384/16384 bytes at offset 4295311360 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 16384/16384 bytes at offset 4295458816 ++wrote 16384/16384 bytes at offset 4295458816 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === Read used/compressed clusters ++=== Read used/compressed clusters + === IO: pattern 165 +-qemu-io> read 32768/32768 bytes at offset 4294967296 ++read 32768/32768 bytes at offset 4294967296 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4295114752 ++read 32768/32768 bytes at offset 4295114752 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4295262208 ++read 32768/32768 bytes at offset 4295262208 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4295409664 ++read 32768/32768 bytes at offset 4295409664 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 165 +-qemu-io> read 49152/49152 bytes at offset 4295016448 ++=== IO: pattern 165 ++read 49152/49152 bytes at offset 4295016448 + 48 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 49152/49152 bytes at offset 4295163904 ++read 49152/49152 bytes at offset 4295163904 + 48 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 49152/49152 bytes at offset 4295311360 ++read 49152/49152 bytes at offset 4295311360 + 48 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 49152/49152 bytes at offset 4295458816 ++read 49152/49152 bytes at offset 4295458816 + 48 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 165 +-qemu-io> read 16384/16384 bytes at offset 4295098368 ++=== IO: pattern 165 ++read 16384/16384 bytes at offset 4295098368 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295245824 ++read 16384/16384 bytes at offset 4295245824 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295393280 ++read 16384/16384 bytes at offset 4295393280 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295540736 ++read 16384/16384 bytes at offset 4295540736 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === Read zeros ++=== Read zeros + === IO: pattern 0 +-qemu-io> read 16384/16384 bytes at offset 4295000064 ++read 16384/16384 bytes at offset 4295000064 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295147520 ++read 16384/16384 bytes at offset 4295147520 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295294976 ++read 16384/16384 bytes at offset 4295294976 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4295442432 ++read 16384/16384 bytes at offset 4295442432 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> read 32768/32768 bytes at offset 4295065600 ++=== IO: pattern 0 ++read 32768/32768 bytes at offset 4295065600 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4295213056 ++read 32768/32768 bytes at offset 4295213056 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4295360512 ++read 32768/32768 bytes at offset 4295360512 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4295507968 ++read 32768/32768 bytes at offset 4295507968 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> No errors were found on the image. ++No errors were found on the image. + Creating new image; cluster size: 65536 + + Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=8589934592 +@@ -19104,6382 +19104,6382 @@ Testing empty image + + At offset 0: + === IO: pattern 0 +-qemu-io> wrote 65536/65536 bytes at offset 0 ++wrote 65536/65536 bytes at offset 0 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 65536 ++wrote 65536/65536 bytes at offset 65536 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 131072 ++wrote 65536/65536 bytes at offset 131072 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 196608 ++wrote 65536/65536 bytes at offset 196608 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 262144 ++wrote 65536/65536 bytes at offset 262144 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 327680 ++wrote 65536/65536 bytes at offset 327680 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 393216 ++wrote 65536/65536 bytes at offset 393216 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 458752 ++wrote 65536/65536 bytes at offset 458752 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 524288 ++wrote 65536/65536 bytes at offset 524288 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 589824 ++wrote 65536/65536 bytes at offset 589824 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 655360 ++wrote 65536/65536 bytes at offset 655360 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 720896 ++wrote 65536/65536 bytes at offset 720896 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 786432 ++wrote 65536/65536 bytes at offset 786432 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 851968 ++wrote 65536/65536 bytes at offset 851968 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 917504 ++wrote 65536/65536 bytes at offset 917504 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 983040 ++wrote 65536/65536 bytes at offset 983040 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 1048576 ++wrote 65536/65536 bytes at offset 1048576 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 1114112 ++wrote 65536/65536 bytes at offset 1114112 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 1179648 ++wrote 65536/65536 bytes at offset 1179648 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 1245184 ++wrote 65536/65536 bytes at offset 1245184 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 1310720 ++wrote 65536/65536 bytes at offset 1310720 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 1376256 ++wrote 65536/65536 bytes at offset 1376256 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 1441792 ++wrote 65536/65536 bytes at offset 1441792 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 1507328 ++wrote 65536/65536 bytes at offset 1507328 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 1572864 ++wrote 65536/65536 bytes at offset 1572864 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 1638400 ++wrote 65536/65536 bytes at offset 1638400 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 1703936 ++wrote 65536/65536 bytes at offset 1703936 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 1769472 ++wrote 65536/65536 bytes at offset 1769472 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 1835008 ++wrote 65536/65536 bytes at offset 1835008 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 1900544 ++wrote 65536/65536 bytes at offset 1900544 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 1966080 ++wrote 65536/65536 bytes at offset 1966080 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 2031616 ++wrote 65536/65536 bytes at offset 2031616 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 2097152 ++wrote 65536/65536 bytes at offset 2097152 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 2162688 ++wrote 65536/65536 bytes at offset 2162688 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 2228224 ++wrote 65536/65536 bytes at offset 2228224 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 2293760 ++wrote 65536/65536 bytes at offset 2293760 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 64 +-qemu-io> wrote 32768/32768 bytes at offset 2392064 ++=== IO: pattern 64 ++wrote 32768/32768 bytes at offset 2392064 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 2457600 ++wrote 32768/32768 bytes at offset 2457600 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 2523136 ++wrote 32768/32768 bytes at offset 2523136 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 2588672 ++wrote 32768/32768 bytes at offset 2588672 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 2654208 ++wrote 32768/32768 bytes at offset 2654208 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 2719744 ++wrote 32768/32768 bytes at offset 2719744 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 2785280 ++wrote 32768/32768 bytes at offset 2785280 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 2850816 ++wrote 32768/32768 bytes at offset 2850816 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 2916352 ++wrote 32768/32768 bytes at offset 2916352 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 2981888 ++wrote 32768/32768 bytes at offset 2981888 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 3047424 ++wrote 32768/32768 bytes at offset 3047424 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 3112960 ++wrote 32768/32768 bytes at offset 3112960 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 3178496 ++wrote 32768/32768 bytes at offset 3178496 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 3244032 ++wrote 32768/32768 bytes at offset 3244032 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 3309568 ++wrote 32768/32768 bytes at offset 3309568 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 3375104 ++wrote 32768/32768 bytes at offset 3375104 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 3440640 ++wrote 32768/32768 bytes at offset 3440640 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 3506176 ++wrote 32768/32768 bytes at offset 3506176 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 3571712 ++wrote 32768/32768 bytes at offset 3571712 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 3637248 ++wrote 32768/32768 bytes at offset 3637248 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 3702784 ++wrote 32768/32768 bytes at offset 3702784 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 3768320 ++wrote 32768/32768 bytes at offset 3768320 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 3833856 ++wrote 32768/32768 bytes at offset 3833856 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 3899392 ++wrote 32768/32768 bytes at offset 3899392 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 3964928 ++wrote 32768/32768 bytes at offset 3964928 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4030464 ++wrote 32768/32768 bytes at offset 4030464 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4096000 ++wrote 32768/32768 bytes at offset 4096000 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4161536 ++wrote 32768/32768 bytes at offset 4161536 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4227072 ++wrote 32768/32768 bytes at offset 4227072 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4292608 ++wrote 32768/32768 bytes at offset 4292608 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4358144 ++wrote 32768/32768 bytes at offset 4358144 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4423680 ++wrote 32768/32768 bytes at offset 4423680 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4489216 ++wrote 32768/32768 bytes at offset 4489216 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4554752 ++wrote 32768/32768 bytes at offset 4554752 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4620288 ++wrote 32768/32768 bytes at offset 4620288 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4685824 ++wrote 32768/32768 bytes at offset 4685824 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> wrote 32768/32768 bytes at offset 4718592 ++=== IO: pattern 0 ++wrote 32768/32768 bytes at offset 4718592 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4784128 ++wrote 32768/32768 bytes at offset 4784128 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4849664 ++wrote 32768/32768 bytes at offset 4849664 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4915200 ++wrote 32768/32768 bytes at offset 4915200 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4980736 ++wrote 32768/32768 bytes at offset 4980736 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 5046272 ++wrote 32768/32768 bytes at offset 5046272 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 5111808 ++wrote 32768/32768 bytes at offset 5111808 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 5177344 ++wrote 32768/32768 bytes at offset 5177344 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 5242880 ++wrote 32768/32768 bytes at offset 5242880 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 5308416 ++wrote 32768/32768 bytes at offset 5308416 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 5373952 ++wrote 32768/32768 bytes at offset 5373952 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 5439488 ++wrote 32768/32768 bytes at offset 5439488 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 5505024 ++wrote 32768/32768 bytes at offset 5505024 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 5570560 ++wrote 32768/32768 bytes at offset 5570560 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 5636096 ++wrote 32768/32768 bytes at offset 5636096 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 5701632 ++wrote 32768/32768 bytes at offset 5701632 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 5767168 ++wrote 32768/32768 bytes at offset 5767168 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 5832704 ++wrote 32768/32768 bytes at offset 5832704 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 5898240 ++wrote 32768/32768 bytes at offset 5898240 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 5963776 ++wrote 32768/32768 bytes at offset 5963776 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 6029312 ++wrote 32768/32768 bytes at offset 6029312 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 6094848 ++wrote 32768/32768 bytes at offset 6094848 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 6160384 ++wrote 32768/32768 bytes at offset 6160384 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 6225920 ++wrote 32768/32768 bytes at offset 6225920 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 6291456 ++wrote 32768/32768 bytes at offset 6291456 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 6356992 ++wrote 32768/32768 bytes at offset 6356992 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 6422528 ++wrote 32768/32768 bytes at offset 6422528 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 6488064 ++wrote 32768/32768 bytes at offset 6488064 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 6553600 ++wrote 32768/32768 bytes at offset 6553600 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 6619136 ++wrote 32768/32768 bytes at offset 6619136 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 6684672 ++wrote 32768/32768 bytes at offset 6684672 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 6750208 ++wrote 32768/32768 bytes at offset 6750208 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 6815744 ++wrote 32768/32768 bytes at offset 6815744 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 6881280 ++wrote 32768/32768 bytes at offset 6881280 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 6946816 ++wrote 32768/32768 bytes at offset 6946816 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 7012352 ++wrote 32768/32768 bytes at offset 7012352 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 32 +-qemu-io> wrote 32768/32768 bytes at offset 7094272 ++=== IO: pattern 32 ++wrote 32768/32768 bytes at offset 7094272 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 7159808 ++wrote 32768/32768 bytes at offset 7159808 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 7225344 ++wrote 32768/32768 bytes at offset 7225344 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 7290880 ++wrote 32768/32768 bytes at offset 7290880 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 7356416 ++wrote 32768/32768 bytes at offset 7356416 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 7421952 ++wrote 32768/32768 bytes at offset 7421952 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 7487488 ++wrote 32768/32768 bytes at offset 7487488 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 7553024 ++wrote 32768/32768 bytes at offset 7553024 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 7618560 ++wrote 32768/32768 bytes at offset 7618560 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 7684096 ++wrote 32768/32768 bytes at offset 7684096 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 7749632 ++wrote 32768/32768 bytes at offset 7749632 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 7815168 ++wrote 32768/32768 bytes at offset 7815168 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 7880704 ++wrote 32768/32768 bytes at offset 7880704 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 7946240 ++wrote 32768/32768 bytes at offset 7946240 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 8011776 ++wrote 32768/32768 bytes at offset 8011776 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 8077312 ++wrote 32768/32768 bytes at offset 8077312 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 8142848 ++wrote 32768/32768 bytes at offset 8142848 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 8208384 ++wrote 32768/32768 bytes at offset 8208384 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 8273920 ++wrote 32768/32768 bytes at offset 8273920 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 8339456 ++wrote 32768/32768 bytes at offset 8339456 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 8404992 ++wrote 32768/32768 bytes at offset 8404992 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 8470528 ++wrote 32768/32768 bytes at offset 8470528 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 8536064 ++wrote 32768/32768 bytes at offset 8536064 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 8601600 ++wrote 32768/32768 bytes at offset 8601600 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 8667136 ++wrote 32768/32768 bytes at offset 8667136 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 8732672 ++wrote 32768/32768 bytes at offset 8732672 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 8798208 ++wrote 32768/32768 bytes at offset 8798208 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 8863744 ++wrote 32768/32768 bytes at offset 8863744 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 8929280 ++wrote 32768/32768 bytes at offset 8929280 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 8994816 ++wrote 32768/32768 bytes at offset 8994816 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 9060352 ++wrote 32768/32768 bytes at offset 9060352 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 9125888 ++wrote 32768/32768 bytes at offset 9125888 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 9191424 ++wrote 32768/32768 bytes at offset 9191424 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 9256960 ++wrote 32768/32768 bytes at offset 9256960 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 9322496 ++wrote 32768/32768 bytes at offset 9322496 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 9388032 ++wrote 32768/32768 bytes at offset 9388032 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 64 +-qemu-io> wrote 131072/131072 bytes at offset 9469952 ++=== IO: pattern 64 ++wrote 131072/131072 bytes at offset 9469952 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 131072/131072 bytes at offset 9666560 ++wrote 131072/131072 bytes at offset 9666560 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 131072/131072 bytes at offset 9863168 ++wrote 131072/131072 bytes at offset 9863168 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 131072/131072 bytes at offset 10059776 ++wrote 131072/131072 bytes at offset 10059776 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 131072/131072 bytes at offset 10256384 ++wrote 131072/131072 bytes at offset 10256384 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 131072/131072 bytes at offset 10452992 ++wrote 131072/131072 bytes at offset 10452992 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 131072/131072 bytes at offset 10649600 ++wrote 131072/131072 bytes at offset 10649600 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 131072/131072 bytes at offset 10846208 ++wrote 131072/131072 bytes at offset 10846208 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 131072/131072 bytes at offset 11042816 ++wrote 131072/131072 bytes at offset 11042816 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 64 +-qemu-io> wrote 196608/196608 bytes at offset 536772608 ++=== IO: pattern 64 ++wrote 196608/196608 bytes at offset 536772608 + 192 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 196608/196608 bytes at offset 1073676288 ++wrote 196608/196608 bytes at offset 1073676288 + 192 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 196608/196608 bytes at offset 1610579968 ++wrote 196608/196608 bytes at offset 1610579968 + 192 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> read 65536/65536 bytes at offset 0 ++=== IO: pattern 0 ++read 65536/65536 bytes at offset 0 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 65536 ++read 65536/65536 bytes at offset 65536 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 131072 ++read 65536/65536 bytes at offset 131072 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 196608 ++read 65536/65536 bytes at offset 196608 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 262144 ++read 65536/65536 bytes at offset 262144 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 327680 ++read 65536/65536 bytes at offset 327680 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 393216 ++read 65536/65536 bytes at offset 393216 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 458752 ++read 65536/65536 bytes at offset 458752 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 524288 ++read 65536/65536 bytes at offset 524288 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 589824 ++read 65536/65536 bytes at offset 589824 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 655360 ++read 65536/65536 bytes at offset 655360 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 720896 ++read 65536/65536 bytes at offset 720896 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 786432 ++read 65536/65536 bytes at offset 786432 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 851968 ++read 65536/65536 bytes at offset 851968 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 917504 ++read 65536/65536 bytes at offset 917504 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 983040 ++read 65536/65536 bytes at offset 983040 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 1048576 ++read 65536/65536 bytes at offset 1048576 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 1114112 ++read 65536/65536 bytes at offset 1114112 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 1179648 ++read 65536/65536 bytes at offset 1179648 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 1245184 ++read 65536/65536 bytes at offset 1245184 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 1310720 ++read 65536/65536 bytes at offset 1310720 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 1376256 ++read 65536/65536 bytes at offset 1376256 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 1441792 ++read 65536/65536 bytes at offset 1441792 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 1507328 ++read 65536/65536 bytes at offset 1507328 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 1572864 ++read 65536/65536 bytes at offset 1572864 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 1638400 ++read 65536/65536 bytes at offset 1638400 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 1703936 ++read 65536/65536 bytes at offset 1703936 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 1769472 ++read 65536/65536 bytes at offset 1769472 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 1835008 ++read 65536/65536 bytes at offset 1835008 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 1900544 ++read 65536/65536 bytes at offset 1900544 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 1966080 ++read 65536/65536 bytes at offset 1966080 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 2031616 ++read 65536/65536 bytes at offset 2031616 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 2097152 ++read 65536/65536 bytes at offset 2097152 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 2162688 ++read 65536/65536 bytes at offset 2162688 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 2228224 ++read 65536/65536 bytes at offset 2228224 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 2293760 ++read 65536/65536 bytes at offset 2293760 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 64 +-qemu-io> read 32768/32768 bytes at offset 2392064 ++=== IO: pattern 64 ++read 32768/32768 bytes at offset 2392064 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 2457600 ++read 32768/32768 bytes at offset 2457600 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 2523136 ++read 32768/32768 bytes at offset 2523136 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 2588672 ++read 32768/32768 bytes at offset 2588672 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 2654208 ++read 32768/32768 bytes at offset 2654208 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 2719744 ++read 32768/32768 bytes at offset 2719744 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 2785280 ++read 32768/32768 bytes at offset 2785280 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 2850816 ++read 32768/32768 bytes at offset 2850816 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 2916352 ++read 32768/32768 bytes at offset 2916352 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 2981888 ++read 32768/32768 bytes at offset 2981888 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 3047424 ++read 32768/32768 bytes at offset 3047424 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 3112960 ++read 32768/32768 bytes at offset 3112960 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 3178496 ++read 32768/32768 bytes at offset 3178496 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 3244032 ++read 32768/32768 bytes at offset 3244032 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 3309568 ++read 32768/32768 bytes at offset 3309568 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 3375104 ++read 32768/32768 bytes at offset 3375104 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 3440640 ++read 32768/32768 bytes at offset 3440640 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 3506176 ++read 32768/32768 bytes at offset 3506176 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 3571712 ++read 32768/32768 bytes at offset 3571712 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 3637248 ++read 32768/32768 bytes at offset 3637248 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 3702784 ++read 32768/32768 bytes at offset 3702784 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 3768320 ++read 32768/32768 bytes at offset 3768320 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 3833856 ++read 32768/32768 bytes at offset 3833856 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 3899392 ++read 32768/32768 bytes at offset 3899392 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 3964928 ++read 32768/32768 bytes at offset 3964928 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4030464 ++read 32768/32768 bytes at offset 4030464 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4096000 ++read 32768/32768 bytes at offset 4096000 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4161536 ++read 32768/32768 bytes at offset 4161536 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4227072 ++read 32768/32768 bytes at offset 4227072 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4292608 ++read 32768/32768 bytes at offset 4292608 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4358144 ++read 32768/32768 bytes at offset 4358144 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4423680 ++read 32768/32768 bytes at offset 4423680 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4489216 ++read 32768/32768 bytes at offset 4489216 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4554752 ++read 32768/32768 bytes at offset 4554752 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4620288 ++read 32768/32768 bytes at offset 4620288 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4685824 ++read 32768/32768 bytes at offset 4685824 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> read 32768/32768 bytes at offset 4718592 ++=== IO: pattern 0 ++read 32768/32768 bytes at offset 4718592 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4784128 ++read 32768/32768 bytes at offset 4784128 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4849664 ++read 32768/32768 bytes at offset 4849664 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4915200 ++read 32768/32768 bytes at offset 4915200 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4980736 ++read 32768/32768 bytes at offset 4980736 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 5046272 ++read 32768/32768 bytes at offset 5046272 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 5111808 ++read 32768/32768 bytes at offset 5111808 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 5177344 ++read 32768/32768 bytes at offset 5177344 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 5242880 ++read 32768/32768 bytes at offset 5242880 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 5308416 ++read 32768/32768 bytes at offset 5308416 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 5373952 ++read 32768/32768 bytes at offset 5373952 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 5439488 ++read 32768/32768 bytes at offset 5439488 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 5505024 ++read 32768/32768 bytes at offset 5505024 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 5570560 ++read 32768/32768 bytes at offset 5570560 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 5636096 ++read 32768/32768 bytes at offset 5636096 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 5701632 ++read 32768/32768 bytes at offset 5701632 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 5767168 ++read 32768/32768 bytes at offset 5767168 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 5832704 ++read 32768/32768 bytes at offset 5832704 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 5898240 ++read 32768/32768 bytes at offset 5898240 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 5963776 ++read 32768/32768 bytes at offset 5963776 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 6029312 ++read 32768/32768 bytes at offset 6029312 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 6094848 ++read 32768/32768 bytes at offset 6094848 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 6160384 ++read 32768/32768 bytes at offset 6160384 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 6225920 ++read 32768/32768 bytes at offset 6225920 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 6291456 ++read 32768/32768 bytes at offset 6291456 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 6356992 ++read 32768/32768 bytes at offset 6356992 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 6422528 ++read 32768/32768 bytes at offset 6422528 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 6488064 ++read 32768/32768 bytes at offset 6488064 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 6553600 ++read 32768/32768 bytes at offset 6553600 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 6619136 ++read 32768/32768 bytes at offset 6619136 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 6684672 ++read 32768/32768 bytes at offset 6684672 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 6750208 ++read 32768/32768 bytes at offset 6750208 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 6815744 ++read 32768/32768 bytes at offset 6815744 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 6881280 ++read 32768/32768 bytes at offset 6881280 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 6946816 ++read 32768/32768 bytes at offset 6946816 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 7012352 ++read 32768/32768 bytes at offset 7012352 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 32 +-qemu-io> read 32768/32768 bytes at offset 7094272 ++=== IO: pattern 32 ++read 32768/32768 bytes at offset 7094272 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 7159808 ++read 32768/32768 bytes at offset 7159808 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 7225344 ++read 32768/32768 bytes at offset 7225344 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 7290880 ++read 32768/32768 bytes at offset 7290880 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 7356416 ++read 32768/32768 bytes at offset 7356416 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 7421952 ++read 32768/32768 bytes at offset 7421952 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 7487488 ++read 32768/32768 bytes at offset 7487488 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 7553024 ++read 32768/32768 bytes at offset 7553024 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 7618560 ++read 32768/32768 bytes at offset 7618560 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 7684096 ++read 32768/32768 bytes at offset 7684096 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 7749632 ++read 32768/32768 bytes at offset 7749632 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 7815168 ++read 32768/32768 bytes at offset 7815168 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 7880704 ++read 32768/32768 bytes at offset 7880704 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 7946240 ++read 32768/32768 bytes at offset 7946240 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 8011776 ++read 32768/32768 bytes at offset 8011776 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 8077312 ++read 32768/32768 bytes at offset 8077312 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 8142848 ++read 32768/32768 bytes at offset 8142848 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 8208384 ++read 32768/32768 bytes at offset 8208384 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 8273920 ++read 32768/32768 bytes at offset 8273920 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 8339456 ++read 32768/32768 bytes at offset 8339456 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 8404992 ++read 32768/32768 bytes at offset 8404992 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 8470528 ++read 32768/32768 bytes at offset 8470528 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 8536064 ++read 32768/32768 bytes at offset 8536064 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 8601600 ++read 32768/32768 bytes at offset 8601600 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 8667136 ++read 32768/32768 bytes at offset 8667136 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 8732672 ++read 32768/32768 bytes at offset 8732672 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 8798208 ++read 32768/32768 bytes at offset 8798208 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 8863744 ++read 32768/32768 bytes at offset 8863744 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 8929280 ++read 32768/32768 bytes at offset 8929280 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 8994816 ++read 32768/32768 bytes at offset 8994816 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 9060352 ++read 32768/32768 bytes at offset 9060352 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 9125888 ++read 32768/32768 bytes at offset 9125888 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 9191424 ++read 32768/32768 bytes at offset 9191424 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 9256960 ++read 32768/32768 bytes at offset 9256960 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 9322496 ++read 32768/32768 bytes at offset 9322496 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 9388032 ++read 32768/32768 bytes at offset 9388032 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 64 +-qemu-io> read 131072/131072 bytes at offset 9469952 ++=== IO: pattern 64 ++read 131072/131072 bytes at offset 9469952 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 131072/131072 bytes at offset 9666560 ++read 131072/131072 bytes at offset 9666560 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 131072/131072 bytes at offset 9863168 ++read 131072/131072 bytes at offset 9863168 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 131072/131072 bytes at offset 10059776 ++read 131072/131072 bytes at offset 10059776 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 131072/131072 bytes at offset 10256384 ++read 131072/131072 bytes at offset 10256384 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 131072/131072 bytes at offset 10452992 ++read 131072/131072 bytes at offset 10452992 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 131072/131072 bytes at offset 10649600 ++read 131072/131072 bytes at offset 10649600 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 131072/131072 bytes at offset 10846208 ++read 131072/131072 bytes at offset 10846208 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 131072/131072 bytes at offset 11042816 ++read 131072/131072 bytes at offset 11042816 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 64 +-qemu-io> read 196608/196608 bytes at offset 536772608 ++=== IO: pattern 64 ++read 196608/196608 bytes at offset 536772608 + 192 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 196608/196608 bytes at offset 1073676288 ++read 196608/196608 bytes at offset 1073676288 + 192 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 196608/196608 bytes at offset 1610579968 ++read 196608/196608 bytes at offset 1610579968 + 192 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> wrote 65536/65536 bytes at offset 0 ++=== IO: pattern 0 ++wrote 65536/65536 bytes at offset 0 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 65536 ++wrote 65536/65536 bytes at offset 65536 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 131072 ++wrote 65536/65536 bytes at offset 131072 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 196608 ++wrote 65536/65536 bytes at offset 196608 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 262144 ++wrote 65536/65536 bytes at offset 262144 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 327680 ++wrote 65536/65536 bytes at offset 327680 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 393216 ++wrote 65536/65536 bytes at offset 393216 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 458752 ++wrote 65536/65536 bytes at offset 458752 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 524288 ++wrote 65536/65536 bytes at offset 524288 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 589824 ++wrote 65536/65536 bytes at offset 589824 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 655360 ++wrote 65536/65536 bytes at offset 655360 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 720896 ++wrote 65536/65536 bytes at offset 720896 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 786432 ++wrote 65536/65536 bytes at offset 786432 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 851968 ++wrote 65536/65536 bytes at offset 851968 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 917504 ++wrote 65536/65536 bytes at offset 917504 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 983040 ++wrote 65536/65536 bytes at offset 983040 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 1048576 ++wrote 65536/65536 bytes at offset 1048576 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 1114112 ++wrote 65536/65536 bytes at offset 1114112 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 1179648 ++wrote 65536/65536 bytes at offset 1179648 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 1245184 ++wrote 65536/65536 bytes at offset 1245184 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 1310720 ++wrote 65536/65536 bytes at offset 1310720 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 1376256 ++wrote 65536/65536 bytes at offset 1376256 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 1441792 ++wrote 65536/65536 bytes at offset 1441792 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 1507328 ++wrote 65536/65536 bytes at offset 1507328 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 1572864 ++wrote 65536/65536 bytes at offset 1572864 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 1638400 ++wrote 65536/65536 bytes at offset 1638400 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 1703936 ++wrote 65536/65536 bytes at offset 1703936 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 1769472 ++wrote 65536/65536 bytes at offset 1769472 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 1835008 ++wrote 65536/65536 bytes at offset 1835008 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 1900544 ++wrote 65536/65536 bytes at offset 1900544 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 1966080 ++wrote 65536/65536 bytes at offset 1966080 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 2031616 ++wrote 65536/65536 bytes at offset 2031616 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 2097152 ++wrote 65536/65536 bytes at offset 2097152 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 2162688 ++wrote 65536/65536 bytes at offset 2162688 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 2228224 ++wrote 65536/65536 bytes at offset 2228224 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 2293760 ++wrote 65536/65536 bytes at offset 2293760 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 64 +-qemu-io> wrote 32768/32768 bytes at offset 2392064 ++=== IO: pattern 64 ++wrote 32768/32768 bytes at offset 2392064 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 2457600 ++wrote 32768/32768 bytes at offset 2457600 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 2523136 ++wrote 32768/32768 bytes at offset 2523136 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 2588672 ++wrote 32768/32768 bytes at offset 2588672 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 2654208 ++wrote 32768/32768 bytes at offset 2654208 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 2719744 ++wrote 32768/32768 bytes at offset 2719744 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 2785280 ++wrote 32768/32768 bytes at offset 2785280 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 2850816 ++wrote 32768/32768 bytes at offset 2850816 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 2916352 ++wrote 32768/32768 bytes at offset 2916352 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 2981888 ++wrote 32768/32768 bytes at offset 2981888 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 3047424 ++wrote 32768/32768 bytes at offset 3047424 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 3112960 ++wrote 32768/32768 bytes at offset 3112960 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 3178496 ++wrote 32768/32768 bytes at offset 3178496 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 3244032 ++wrote 32768/32768 bytes at offset 3244032 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 3309568 ++wrote 32768/32768 bytes at offset 3309568 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 3375104 ++wrote 32768/32768 bytes at offset 3375104 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 3440640 ++wrote 32768/32768 bytes at offset 3440640 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 3506176 ++wrote 32768/32768 bytes at offset 3506176 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 3571712 ++wrote 32768/32768 bytes at offset 3571712 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 3637248 ++wrote 32768/32768 bytes at offset 3637248 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 3702784 ++wrote 32768/32768 bytes at offset 3702784 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 3768320 ++wrote 32768/32768 bytes at offset 3768320 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 3833856 ++wrote 32768/32768 bytes at offset 3833856 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 3899392 ++wrote 32768/32768 bytes at offset 3899392 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 3964928 ++wrote 32768/32768 bytes at offset 3964928 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4030464 ++wrote 32768/32768 bytes at offset 4030464 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4096000 ++wrote 32768/32768 bytes at offset 4096000 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4161536 ++wrote 32768/32768 bytes at offset 4161536 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4227072 ++wrote 32768/32768 bytes at offset 4227072 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4292608 ++wrote 32768/32768 bytes at offset 4292608 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4358144 ++wrote 32768/32768 bytes at offset 4358144 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4423680 ++wrote 32768/32768 bytes at offset 4423680 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4489216 ++wrote 32768/32768 bytes at offset 4489216 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4554752 ++wrote 32768/32768 bytes at offset 4554752 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4620288 ++wrote 32768/32768 bytes at offset 4620288 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4685824 ++wrote 32768/32768 bytes at offset 4685824 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> wrote 32768/32768 bytes at offset 4718592 ++=== IO: pattern 0 ++wrote 32768/32768 bytes at offset 4718592 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4784128 ++wrote 32768/32768 bytes at offset 4784128 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4849664 ++wrote 32768/32768 bytes at offset 4849664 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4915200 ++wrote 32768/32768 bytes at offset 4915200 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4980736 ++wrote 32768/32768 bytes at offset 4980736 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 5046272 ++wrote 32768/32768 bytes at offset 5046272 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 5111808 ++wrote 32768/32768 bytes at offset 5111808 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 5177344 ++wrote 32768/32768 bytes at offset 5177344 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 5242880 ++wrote 32768/32768 bytes at offset 5242880 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 5308416 ++wrote 32768/32768 bytes at offset 5308416 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 5373952 ++wrote 32768/32768 bytes at offset 5373952 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 5439488 ++wrote 32768/32768 bytes at offset 5439488 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 5505024 ++wrote 32768/32768 bytes at offset 5505024 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 5570560 ++wrote 32768/32768 bytes at offset 5570560 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 5636096 ++wrote 32768/32768 bytes at offset 5636096 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 5701632 ++wrote 32768/32768 bytes at offset 5701632 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 5767168 ++wrote 32768/32768 bytes at offset 5767168 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 5832704 ++wrote 32768/32768 bytes at offset 5832704 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 5898240 ++wrote 32768/32768 bytes at offset 5898240 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 5963776 ++wrote 32768/32768 bytes at offset 5963776 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 6029312 ++wrote 32768/32768 bytes at offset 6029312 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 6094848 ++wrote 32768/32768 bytes at offset 6094848 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 6160384 ++wrote 32768/32768 bytes at offset 6160384 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 6225920 ++wrote 32768/32768 bytes at offset 6225920 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 6291456 ++wrote 32768/32768 bytes at offset 6291456 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 6356992 ++wrote 32768/32768 bytes at offset 6356992 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 6422528 ++wrote 32768/32768 bytes at offset 6422528 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 6488064 ++wrote 32768/32768 bytes at offset 6488064 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 6553600 ++wrote 32768/32768 bytes at offset 6553600 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 6619136 ++wrote 32768/32768 bytes at offset 6619136 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 6684672 ++wrote 32768/32768 bytes at offset 6684672 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 6750208 ++wrote 32768/32768 bytes at offset 6750208 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 6815744 ++wrote 32768/32768 bytes at offset 6815744 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 6881280 ++wrote 32768/32768 bytes at offset 6881280 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 6946816 ++wrote 32768/32768 bytes at offset 6946816 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 7012352 ++wrote 32768/32768 bytes at offset 7012352 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 32 +-qemu-io> wrote 32768/32768 bytes at offset 7094272 ++=== IO: pattern 32 ++wrote 32768/32768 bytes at offset 7094272 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 7159808 ++wrote 32768/32768 bytes at offset 7159808 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 7225344 ++wrote 32768/32768 bytes at offset 7225344 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 7290880 ++wrote 32768/32768 bytes at offset 7290880 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 7356416 ++wrote 32768/32768 bytes at offset 7356416 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 7421952 ++wrote 32768/32768 bytes at offset 7421952 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 7487488 ++wrote 32768/32768 bytes at offset 7487488 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 7553024 ++wrote 32768/32768 bytes at offset 7553024 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 7618560 ++wrote 32768/32768 bytes at offset 7618560 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 7684096 ++wrote 32768/32768 bytes at offset 7684096 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 7749632 ++wrote 32768/32768 bytes at offset 7749632 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 7815168 ++wrote 32768/32768 bytes at offset 7815168 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 7880704 ++wrote 32768/32768 bytes at offset 7880704 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 7946240 ++wrote 32768/32768 bytes at offset 7946240 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 8011776 ++wrote 32768/32768 bytes at offset 8011776 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 8077312 ++wrote 32768/32768 bytes at offset 8077312 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 8142848 ++wrote 32768/32768 bytes at offset 8142848 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 8208384 ++wrote 32768/32768 bytes at offset 8208384 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 8273920 ++wrote 32768/32768 bytes at offset 8273920 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 8339456 ++wrote 32768/32768 bytes at offset 8339456 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 8404992 ++wrote 32768/32768 bytes at offset 8404992 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 8470528 ++wrote 32768/32768 bytes at offset 8470528 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 8536064 ++wrote 32768/32768 bytes at offset 8536064 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 8601600 ++wrote 32768/32768 bytes at offset 8601600 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 8667136 ++wrote 32768/32768 bytes at offset 8667136 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 8732672 ++wrote 32768/32768 bytes at offset 8732672 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 8798208 ++wrote 32768/32768 bytes at offset 8798208 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 8863744 ++wrote 32768/32768 bytes at offset 8863744 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 8929280 ++wrote 32768/32768 bytes at offset 8929280 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 8994816 ++wrote 32768/32768 bytes at offset 8994816 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 9060352 ++wrote 32768/32768 bytes at offset 9060352 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 9125888 ++wrote 32768/32768 bytes at offset 9125888 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 9191424 ++wrote 32768/32768 bytes at offset 9191424 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 9256960 ++wrote 32768/32768 bytes at offset 9256960 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 9322496 ++wrote 32768/32768 bytes at offset 9322496 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 9388032 ++wrote 32768/32768 bytes at offset 9388032 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 64 +-qemu-io> wrote 131072/131072 bytes at offset 9469952 ++=== IO: pattern 64 ++wrote 131072/131072 bytes at offset 9469952 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 131072/131072 bytes at offset 9666560 ++wrote 131072/131072 bytes at offset 9666560 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 131072/131072 bytes at offset 9863168 ++wrote 131072/131072 bytes at offset 9863168 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 131072/131072 bytes at offset 10059776 ++wrote 131072/131072 bytes at offset 10059776 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 131072/131072 bytes at offset 10256384 ++wrote 131072/131072 bytes at offset 10256384 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 131072/131072 bytes at offset 10452992 ++wrote 131072/131072 bytes at offset 10452992 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 131072/131072 bytes at offset 10649600 ++wrote 131072/131072 bytes at offset 10649600 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 131072/131072 bytes at offset 10846208 ++wrote 131072/131072 bytes at offset 10846208 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 131072/131072 bytes at offset 11042816 ++wrote 131072/131072 bytes at offset 11042816 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 64 +-qemu-io> wrote 196608/196608 bytes at offset 536772608 ++=== IO: pattern 64 ++wrote 196608/196608 bytes at offset 536772608 + 192 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 196608/196608 bytes at offset 1073676288 ++wrote 196608/196608 bytes at offset 1073676288 + 192 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 196608/196608 bytes at offset 1610579968 ++wrote 196608/196608 bytes at offset 1610579968 + 192 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> read 65536/65536 bytes at offset 0 ++=== IO: pattern 0 ++read 65536/65536 bytes at offset 0 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 65536 ++read 65536/65536 bytes at offset 65536 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 131072 ++read 65536/65536 bytes at offset 131072 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 196608 ++read 65536/65536 bytes at offset 196608 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 262144 ++read 65536/65536 bytes at offset 262144 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 327680 ++read 65536/65536 bytes at offset 327680 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 393216 ++read 65536/65536 bytes at offset 393216 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 458752 ++read 65536/65536 bytes at offset 458752 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 524288 ++read 65536/65536 bytes at offset 524288 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 589824 ++read 65536/65536 bytes at offset 589824 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 655360 ++read 65536/65536 bytes at offset 655360 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 720896 ++read 65536/65536 bytes at offset 720896 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 786432 ++read 65536/65536 bytes at offset 786432 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 851968 ++read 65536/65536 bytes at offset 851968 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 917504 ++read 65536/65536 bytes at offset 917504 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 983040 ++read 65536/65536 bytes at offset 983040 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 1048576 ++read 65536/65536 bytes at offset 1048576 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 1114112 ++read 65536/65536 bytes at offset 1114112 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 1179648 ++read 65536/65536 bytes at offset 1179648 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 1245184 ++read 65536/65536 bytes at offset 1245184 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 1310720 ++read 65536/65536 bytes at offset 1310720 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 1376256 ++read 65536/65536 bytes at offset 1376256 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 1441792 ++read 65536/65536 bytes at offset 1441792 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 1507328 ++read 65536/65536 bytes at offset 1507328 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 1572864 ++read 65536/65536 bytes at offset 1572864 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 1638400 ++read 65536/65536 bytes at offset 1638400 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 1703936 ++read 65536/65536 bytes at offset 1703936 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 1769472 ++read 65536/65536 bytes at offset 1769472 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 1835008 ++read 65536/65536 bytes at offset 1835008 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 1900544 ++read 65536/65536 bytes at offset 1900544 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 1966080 ++read 65536/65536 bytes at offset 1966080 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 2031616 ++read 65536/65536 bytes at offset 2031616 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 2097152 ++read 65536/65536 bytes at offset 2097152 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 2162688 ++read 65536/65536 bytes at offset 2162688 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 2228224 ++read 65536/65536 bytes at offset 2228224 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 2293760 ++read 65536/65536 bytes at offset 2293760 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 64 +-qemu-io> read 32768/32768 bytes at offset 2392064 ++=== IO: pattern 64 ++read 32768/32768 bytes at offset 2392064 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 2457600 ++read 32768/32768 bytes at offset 2457600 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 2523136 ++read 32768/32768 bytes at offset 2523136 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 2588672 ++read 32768/32768 bytes at offset 2588672 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 2654208 ++read 32768/32768 bytes at offset 2654208 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 2719744 ++read 32768/32768 bytes at offset 2719744 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 2785280 ++read 32768/32768 bytes at offset 2785280 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 2850816 ++read 32768/32768 bytes at offset 2850816 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 2916352 ++read 32768/32768 bytes at offset 2916352 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 2981888 ++read 32768/32768 bytes at offset 2981888 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 3047424 ++read 32768/32768 bytes at offset 3047424 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 3112960 ++read 32768/32768 bytes at offset 3112960 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 3178496 ++read 32768/32768 bytes at offset 3178496 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 3244032 ++read 32768/32768 bytes at offset 3244032 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 3309568 ++read 32768/32768 bytes at offset 3309568 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 3375104 ++read 32768/32768 bytes at offset 3375104 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 3440640 ++read 32768/32768 bytes at offset 3440640 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 3506176 ++read 32768/32768 bytes at offset 3506176 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 3571712 ++read 32768/32768 bytes at offset 3571712 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 3637248 ++read 32768/32768 bytes at offset 3637248 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 3702784 ++read 32768/32768 bytes at offset 3702784 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 3768320 ++read 32768/32768 bytes at offset 3768320 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 3833856 ++read 32768/32768 bytes at offset 3833856 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 3899392 ++read 32768/32768 bytes at offset 3899392 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 3964928 ++read 32768/32768 bytes at offset 3964928 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4030464 ++read 32768/32768 bytes at offset 4030464 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4096000 ++read 32768/32768 bytes at offset 4096000 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4161536 ++read 32768/32768 bytes at offset 4161536 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4227072 ++read 32768/32768 bytes at offset 4227072 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4292608 ++read 32768/32768 bytes at offset 4292608 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4358144 ++read 32768/32768 bytes at offset 4358144 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4423680 ++read 32768/32768 bytes at offset 4423680 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4489216 ++read 32768/32768 bytes at offset 4489216 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4554752 ++read 32768/32768 bytes at offset 4554752 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4620288 ++read 32768/32768 bytes at offset 4620288 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4685824 ++read 32768/32768 bytes at offset 4685824 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> read 32768/32768 bytes at offset 4718592 ++=== IO: pattern 0 ++read 32768/32768 bytes at offset 4718592 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4784128 ++read 32768/32768 bytes at offset 4784128 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4849664 ++read 32768/32768 bytes at offset 4849664 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4915200 ++read 32768/32768 bytes at offset 4915200 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4980736 ++read 32768/32768 bytes at offset 4980736 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 5046272 ++read 32768/32768 bytes at offset 5046272 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 5111808 ++read 32768/32768 bytes at offset 5111808 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 5177344 ++read 32768/32768 bytes at offset 5177344 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 5242880 ++read 32768/32768 bytes at offset 5242880 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 5308416 ++read 32768/32768 bytes at offset 5308416 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 5373952 ++read 32768/32768 bytes at offset 5373952 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 5439488 ++read 32768/32768 bytes at offset 5439488 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 5505024 ++read 32768/32768 bytes at offset 5505024 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 5570560 ++read 32768/32768 bytes at offset 5570560 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 5636096 ++read 32768/32768 bytes at offset 5636096 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 5701632 ++read 32768/32768 bytes at offset 5701632 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 5767168 ++read 32768/32768 bytes at offset 5767168 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 5832704 ++read 32768/32768 bytes at offset 5832704 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 5898240 ++read 32768/32768 bytes at offset 5898240 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 5963776 ++read 32768/32768 bytes at offset 5963776 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 6029312 ++read 32768/32768 bytes at offset 6029312 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 6094848 ++read 32768/32768 bytes at offset 6094848 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 6160384 ++read 32768/32768 bytes at offset 6160384 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 6225920 ++read 32768/32768 bytes at offset 6225920 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 6291456 ++read 32768/32768 bytes at offset 6291456 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 6356992 ++read 32768/32768 bytes at offset 6356992 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 6422528 ++read 32768/32768 bytes at offset 6422528 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 6488064 ++read 32768/32768 bytes at offset 6488064 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 6553600 ++read 32768/32768 bytes at offset 6553600 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 6619136 ++read 32768/32768 bytes at offset 6619136 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 6684672 ++read 32768/32768 bytes at offset 6684672 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 6750208 ++read 32768/32768 bytes at offset 6750208 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 6815744 ++read 32768/32768 bytes at offset 6815744 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 6881280 ++read 32768/32768 bytes at offset 6881280 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 6946816 ++read 32768/32768 bytes at offset 6946816 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 7012352 ++read 32768/32768 bytes at offset 7012352 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 32 +-qemu-io> read 32768/32768 bytes at offset 7094272 ++=== IO: pattern 32 ++read 32768/32768 bytes at offset 7094272 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 7159808 ++read 32768/32768 bytes at offset 7159808 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 7225344 ++read 32768/32768 bytes at offset 7225344 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 7290880 ++read 32768/32768 bytes at offset 7290880 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 7356416 ++read 32768/32768 bytes at offset 7356416 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 7421952 ++read 32768/32768 bytes at offset 7421952 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 7487488 ++read 32768/32768 bytes at offset 7487488 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 7553024 ++read 32768/32768 bytes at offset 7553024 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 7618560 ++read 32768/32768 bytes at offset 7618560 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 7684096 ++read 32768/32768 bytes at offset 7684096 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 7749632 ++read 32768/32768 bytes at offset 7749632 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 7815168 ++read 32768/32768 bytes at offset 7815168 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 7880704 ++read 32768/32768 bytes at offset 7880704 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 7946240 ++read 32768/32768 bytes at offset 7946240 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 8011776 ++read 32768/32768 bytes at offset 8011776 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 8077312 ++read 32768/32768 bytes at offset 8077312 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 8142848 ++read 32768/32768 bytes at offset 8142848 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 8208384 ++read 32768/32768 bytes at offset 8208384 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 8273920 ++read 32768/32768 bytes at offset 8273920 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 8339456 ++read 32768/32768 bytes at offset 8339456 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 8404992 ++read 32768/32768 bytes at offset 8404992 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 8470528 ++read 32768/32768 bytes at offset 8470528 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 8536064 ++read 32768/32768 bytes at offset 8536064 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 8601600 ++read 32768/32768 bytes at offset 8601600 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 8667136 ++read 32768/32768 bytes at offset 8667136 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 8732672 ++read 32768/32768 bytes at offset 8732672 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 8798208 ++read 32768/32768 bytes at offset 8798208 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 8863744 ++read 32768/32768 bytes at offset 8863744 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 8929280 ++read 32768/32768 bytes at offset 8929280 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 8994816 ++read 32768/32768 bytes at offset 8994816 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 9060352 ++read 32768/32768 bytes at offset 9060352 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 9125888 ++read 32768/32768 bytes at offset 9125888 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 9191424 ++read 32768/32768 bytes at offset 9191424 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 9256960 ++read 32768/32768 bytes at offset 9256960 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 9322496 ++read 32768/32768 bytes at offset 9322496 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 9388032 ++read 32768/32768 bytes at offset 9388032 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 64 +-qemu-io> read 131072/131072 bytes at offset 9469952 ++=== IO: pattern 64 ++read 131072/131072 bytes at offset 9469952 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 131072/131072 bytes at offset 9666560 ++read 131072/131072 bytes at offset 9666560 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 131072/131072 bytes at offset 9863168 ++read 131072/131072 bytes at offset 9863168 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 131072/131072 bytes at offset 10059776 ++read 131072/131072 bytes at offset 10059776 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 131072/131072 bytes at offset 10256384 ++read 131072/131072 bytes at offset 10256384 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 131072/131072 bytes at offset 10452992 ++read 131072/131072 bytes at offset 10452992 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 131072/131072 bytes at offset 10649600 ++read 131072/131072 bytes at offset 10649600 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 131072/131072 bytes at offset 10846208 ++read 131072/131072 bytes at offset 10846208 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 131072/131072 bytes at offset 11042816 ++read 131072/131072 bytes at offset 11042816 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 64 +-qemu-io> read 196608/196608 bytes at offset 536772608 ++=== IO: pattern 64 ++read 196608/196608 bytes at offset 536772608 + 192 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 196608/196608 bytes at offset 1073676288 ++read 196608/196608 bytes at offset 1073676288 + 192 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 196608/196608 bytes at offset 1610579968 ++read 196608/196608 bytes at offset 1610579968 + 192 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> No errors were found on the image. ++No errors were found on the image. + At offset 4294967296: + === IO: pattern 0 +-qemu-io> wrote 65536/65536 bytes at offset 4294967296 ++wrote 65536/65536 bytes at offset 4294967296 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4295032832 ++wrote 65536/65536 bytes at offset 4295032832 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4295098368 ++wrote 65536/65536 bytes at offset 4295098368 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4295163904 ++wrote 65536/65536 bytes at offset 4295163904 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4295229440 ++wrote 65536/65536 bytes at offset 4295229440 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4295294976 ++wrote 65536/65536 bytes at offset 4295294976 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4295360512 ++wrote 65536/65536 bytes at offset 4295360512 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4295426048 ++wrote 65536/65536 bytes at offset 4295426048 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4295491584 ++wrote 65536/65536 bytes at offset 4295491584 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4295557120 ++wrote 65536/65536 bytes at offset 4295557120 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4295622656 ++wrote 65536/65536 bytes at offset 4295622656 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4295688192 ++wrote 65536/65536 bytes at offset 4295688192 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4295753728 ++wrote 65536/65536 bytes at offset 4295753728 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4295819264 ++wrote 65536/65536 bytes at offset 4295819264 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4295884800 ++wrote 65536/65536 bytes at offset 4295884800 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4295950336 ++wrote 65536/65536 bytes at offset 4295950336 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4296015872 ++wrote 65536/65536 bytes at offset 4296015872 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4296081408 ++wrote 65536/65536 bytes at offset 4296081408 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4296146944 ++wrote 65536/65536 bytes at offset 4296146944 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4296212480 ++wrote 65536/65536 bytes at offset 4296212480 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4296278016 ++wrote 65536/65536 bytes at offset 4296278016 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4296343552 ++wrote 65536/65536 bytes at offset 4296343552 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4296409088 ++wrote 65536/65536 bytes at offset 4296409088 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4296474624 ++wrote 65536/65536 bytes at offset 4296474624 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4296540160 ++wrote 65536/65536 bytes at offset 4296540160 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4296605696 ++wrote 65536/65536 bytes at offset 4296605696 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4296671232 ++wrote 65536/65536 bytes at offset 4296671232 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4296736768 ++wrote 65536/65536 bytes at offset 4296736768 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4296802304 ++wrote 65536/65536 bytes at offset 4296802304 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4296867840 ++wrote 65536/65536 bytes at offset 4296867840 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4296933376 ++wrote 65536/65536 bytes at offset 4296933376 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4296998912 ++wrote 65536/65536 bytes at offset 4296998912 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4297064448 ++wrote 65536/65536 bytes at offset 4297064448 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4297129984 ++wrote 65536/65536 bytes at offset 4297129984 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4297195520 ++wrote 65536/65536 bytes at offset 4297195520 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4297261056 ++wrote 65536/65536 bytes at offset 4297261056 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 64 +-qemu-io> wrote 32768/32768 bytes at offset 4297359360 ++=== IO: pattern 64 ++wrote 32768/32768 bytes at offset 4297359360 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4297424896 ++wrote 32768/32768 bytes at offset 4297424896 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4297490432 ++wrote 32768/32768 bytes at offset 4297490432 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4297555968 ++wrote 32768/32768 bytes at offset 4297555968 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4297621504 ++wrote 32768/32768 bytes at offset 4297621504 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4297687040 ++wrote 32768/32768 bytes at offset 4297687040 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4297752576 ++wrote 32768/32768 bytes at offset 4297752576 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4297818112 ++wrote 32768/32768 bytes at offset 4297818112 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4297883648 ++wrote 32768/32768 bytes at offset 4297883648 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4297949184 ++wrote 32768/32768 bytes at offset 4297949184 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4298014720 ++wrote 32768/32768 bytes at offset 4298014720 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4298080256 ++wrote 32768/32768 bytes at offset 4298080256 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4298145792 ++wrote 32768/32768 bytes at offset 4298145792 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4298211328 ++wrote 32768/32768 bytes at offset 4298211328 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4298276864 ++wrote 32768/32768 bytes at offset 4298276864 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4298342400 ++wrote 32768/32768 bytes at offset 4298342400 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4298407936 ++wrote 32768/32768 bytes at offset 4298407936 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4298473472 ++wrote 32768/32768 bytes at offset 4298473472 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4298539008 ++wrote 32768/32768 bytes at offset 4298539008 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4298604544 ++wrote 32768/32768 bytes at offset 4298604544 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4298670080 ++wrote 32768/32768 bytes at offset 4298670080 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4298735616 ++wrote 32768/32768 bytes at offset 4298735616 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4298801152 ++wrote 32768/32768 bytes at offset 4298801152 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4298866688 ++wrote 32768/32768 bytes at offset 4298866688 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4298932224 ++wrote 32768/32768 bytes at offset 4298932224 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4298997760 ++wrote 32768/32768 bytes at offset 4298997760 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4299063296 ++wrote 32768/32768 bytes at offset 4299063296 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4299128832 ++wrote 32768/32768 bytes at offset 4299128832 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4299194368 ++wrote 32768/32768 bytes at offset 4299194368 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4299259904 ++wrote 32768/32768 bytes at offset 4299259904 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4299325440 ++wrote 32768/32768 bytes at offset 4299325440 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4299390976 ++wrote 32768/32768 bytes at offset 4299390976 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4299456512 ++wrote 32768/32768 bytes at offset 4299456512 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4299522048 ++wrote 32768/32768 bytes at offset 4299522048 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4299587584 ++wrote 32768/32768 bytes at offset 4299587584 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4299653120 ++wrote 32768/32768 bytes at offset 4299653120 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> wrote 32768/32768 bytes at offset 4299685888 ++=== IO: pattern 0 ++wrote 32768/32768 bytes at offset 4299685888 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4299751424 ++wrote 32768/32768 bytes at offset 4299751424 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4299816960 ++wrote 32768/32768 bytes at offset 4299816960 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4299882496 ++wrote 32768/32768 bytes at offset 4299882496 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4299948032 ++wrote 32768/32768 bytes at offset 4299948032 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4300013568 ++wrote 32768/32768 bytes at offset 4300013568 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4300079104 ++wrote 32768/32768 bytes at offset 4300079104 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4300144640 ++wrote 32768/32768 bytes at offset 4300144640 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4300210176 ++wrote 32768/32768 bytes at offset 4300210176 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4300275712 ++wrote 32768/32768 bytes at offset 4300275712 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4300341248 ++wrote 32768/32768 bytes at offset 4300341248 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4300406784 ++wrote 32768/32768 bytes at offset 4300406784 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4300472320 ++wrote 32768/32768 bytes at offset 4300472320 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4300537856 ++wrote 32768/32768 bytes at offset 4300537856 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4300603392 ++wrote 32768/32768 bytes at offset 4300603392 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4300668928 ++wrote 32768/32768 bytes at offset 4300668928 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4300734464 ++wrote 32768/32768 bytes at offset 4300734464 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4300800000 ++wrote 32768/32768 bytes at offset 4300800000 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4300865536 ++wrote 32768/32768 bytes at offset 4300865536 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4300931072 ++wrote 32768/32768 bytes at offset 4300931072 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4300996608 ++wrote 32768/32768 bytes at offset 4300996608 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4301062144 ++wrote 32768/32768 bytes at offset 4301062144 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4301127680 ++wrote 32768/32768 bytes at offset 4301127680 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4301193216 ++wrote 32768/32768 bytes at offset 4301193216 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4301258752 ++wrote 32768/32768 bytes at offset 4301258752 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4301324288 ++wrote 32768/32768 bytes at offset 4301324288 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4301389824 ++wrote 32768/32768 bytes at offset 4301389824 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4301455360 ++wrote 32768/32768 bytes at offset 4301455360 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4301520896 ++wrote 32768/32768 bytes at offset 4301520896 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4301586432 ++wrote 32768/32768 bytes at offset 4301586432 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4301651968 ++wrote 32768/32768 bytes at offset 4301651968 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4301717504 ++wrote 32768/32768 bytes at offset 4301717504 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4301783040 ++wrote 32768/32768 bytes at offset 4301783040 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4301848576 ++wrote 32768/32768 bytes at offset 4301848576 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4301914112 ++wrote 32768/32768 bytes at offset 4301914112 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4301979648 ++wrote 32768/32768 bytes at offset 4301979648 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 32 +-qemu-io> wrote 32768/32768 bytes at offset 4302061568 ++=== IO: pattern 32 ++wrote 32768/32768 bytes at offset 4302061568 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4302127104 ++wrote 32768/32768 bytes at offset 4302127104 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4302192640 ++wrote 32768/32768 bytes at offset 4302192640 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4302258176 ++wrote 32768/32768 bytes at offset 4302258176 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4302323712 ++wrote 32768/32768 bytes at offset 4302323712 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4302389248 ++wrote 32768/32768 bytes at offset 4302389248 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4302454784 ++wrote 32768/32768 bytes at offset 4302454784 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4302520320 ++wrote 32768/32768 bytes at offset 4302520320 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4302585856 ++wrote 32768/32768 bytes at offset 4302585856 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4302651392 ++wrote 32768/32768 bytes at offset 4302651392 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4302716928 ++wrote 32768/32768 bytes at offset 4302716928 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4302782464 ++wrote 32768/32768 bytes at offset 4302782464 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4302848000 ++wrote 32768/32768 bytes at offset 4302848000 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4302913536 ++wrote 32768/32768 bytes at offset 4302913536 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4302979072 ++wrote 32768/32768 bytes at offset 4302979072 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4303044608 ++wrote 32768/32768 bytes at offset 4303044608 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4303110144 ++wrote 32768/32768 bytes at offset 4303110144 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4303175680 ++wrote 32768/32768 bytes at offset 4303175680 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4303241216 ++wrote 32768/32768 bytes at offset 4303241216 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4303306752 ++wrote 32768/32768 bytes at offset 4303306752 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4303372288 ++wrote 32768/32768 bytes at offset 4303372288 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4303437824 ++wrote 32768/32768 bytes at offset 4303437824 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4303503360 ++wrote 32768/32768 bytes at offset 4303503360 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4303568896 ++wrote 32768/32768 bytes at offset 4303568896 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4303634432 ++wrote 32768/32768 bytes at offset 4303634432 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4303699968 ++wrote 32768/32768 bytes at offset 4303699968 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4303765504 ++wrote 32768/32768 bytes at offset 4303765504 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4303831040 ++wrote 32768/32768 bytes at offset 4303831040 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4303896576 ++wrote 32768/32768 bytes at offset 4303896576 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4303962112 ++wrote 32768/32768 bytes at offset 4303962112 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4304027648 ++wrote 32768/32768 bytes at offset 4304027648 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4304093184 ++wrote 32768/32768 bytes at offset 4304093184 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4304158720 ++wrote 32768/32768 bytes at offset 4304158720 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4304224256 ++wrote 32768/32768 bytes at offset 4304224256 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4304289792 ++wrote 32768/32768 bytes at offset 4304289792 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4304355328 ++wrote 32768/32768 bytes at offset 4304355328 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 64 +-qemu-io> wrote 131072/131072 bytes at offset 4304437248 ++=== IO: pattern 64 ++wrote 131072/131072 bytes at offset 4304437248 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 131072/131072 bytes at offset 4304633856 ++wrote 131072/131072 bytes at offset 4304633856 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 131072/131072 bytes at offset 4304830464 ++wrote 131072/131072 bytes at offset 4304830464 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 131072/131072 bytes at offset 4305027072 ++wrote 131072/131072 bytes at offset 4305027072 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 131072/131072 bytes at offset 4305223680 ++wrote 131072/131072 bytes at offset 4305223680 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 131072/131072 bytes at offset 4305420288 ++wrote 131072/131072 bytes at offset 4305420288 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 131072/131072 bytes at offset 4305616896 ++wrote 131072/131072 bytes at offset 4305616896 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 131072/131072 bytes at offset 4305813504 ++wrote 131072/131072 bytes at offset 4305813504 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 131072/131072 bytes at offset 4306010112 ++wrote 131072/131072 bytes at offset 4306010112 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 64 +-qemu-io> wrote 196608/196608 bytes at offset 4831739904 ++=== IO: pattern 64 ++wrote 196608/196608 bytes at offset 4831739904 + 192 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 196608/196608 bytes at offset 5368643584 ++wrote 196608/196608 bytes at offset 5368643584 + 192 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 196608/196608 bytes at offset 5905547264 ++wrote 196608/196608 bytes at offset 5905547264 + 192 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> read 65536/65536 bytes at offset 4294967296 ++=== IO: pattern 0 ++read 65536/65536 bytes at offset 4294967296 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4295032832 ++read 65536/65536 bytes at offset 4295032832 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4295098368 ++read 65536/65536 bytes at offset 4295098368 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4295163904 ++read 65536/65536 bytes at offset 4295163904 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4295229440 ++read 65536/65536 bytes at offset 4295229440 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4295294976 ++read 65536/65536 bytes at offset 4295294976 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4295360512 ++read 65536/65536 bytes at offset 4295360512 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4295426048 ++read 65536/65536 bytes at offset 4295426048 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4295491584 ++read 65536/65536 bytes at offset 4295491584 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4295557120 ++read 65536/65536 bytes at offset 4295557120 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4295622656 ++read 65536/65536 bytes at offset 4295622656 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4295688192 ++read 65536/65536 bytes at offset 4295688192 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4295753728 ++read 65536/65536 bytes at offset 4295753728 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4295819264 ++read 65536/65536 bytes at offset 4295819264 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4295884800 ++read 65536/65536 bytes at offset 4295884800 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4295950336 ++read 65536/65536 bytes at offset 4295950336 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4296015872 ++read 65536/65536 bytes at offset 4296015872 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4296081408 ++read 65536/65536 bytes at offset 4296081408 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4296146944 ++read 65536/65536 bytes at offset 4296146944 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4296212480 ++read 65536/65536 bytes at offset 4296212480 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4296278016 ++read 65536/65536 bytes at offset 4296278016 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4296343552 ++read 65536/65536 bytes at offset 4296343552 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4296409088 ++read 65536/65536 bytes at offset 4296409088 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4296474624 ++read 65536/65536 bytes at offset 4296474624 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4296540160 ++read 65536/65536 bytes at offset 4296540160 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4296605696 ++read 65536/65536 bytes at offset 4296605696 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4296671232 ++read 65536/65536 bytes at offset 4296671232 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4296736768 ++read 65536/65536 bytes at offset 4296736768 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4296802304 ++read 65536/65536 bytes at offset 4296802304 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4296867840 ++read 65536/65536 bytes at offset 4296867840 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4296933376 ++read 65536/65536 bytes at offset 4296933376 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4296998912 ++read 65536/65536 bytes at offset 4296998912 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4297064448 ++read 65536/65536 bytes at offset 4297064448 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4297129984 ++read 65536/65536 bytes at offset 4297129984 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4297195520 ++read 65536/65536 bytes at offset 4297195520 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4297261056 ++read 65536/65536 bytes at offset 4297261056 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 64 +-qemu-io> read 32768/32768 bytes at offset 4297359360 ++=== IO: pattern 64 ++read 32768/32768 bytes at offset 4297359360 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4297424896 ++read 32768/32768 bytes at offset 4297424896 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4297490432 ++read 32768/32768 bytes at offset 4297490432 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4297555968 ++read 32768/32768 bytes at offset 4297555968 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4297621504 ++read 32768/32768 bytes at offset 4297621504 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4297687040 ++read 32768/32768 bytes at offset 4297687040 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4297752576 ++read 32768/32768 bytes at offset 4297752576 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4297818112 ++read 32768/32768 bytes at offset 4297818112 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4297883648 ++read 32768/32768 bytes at offset 4297883648 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4297949184 ++read 32768/32768 bytes at offset 4297949184 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4298014720 ++read 32768/32768 bytes at offset 4298014720 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4298080256 ++read 32768/32768 bytes at offset 4298080256 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4298145792 ++read 32768/32768 bytes at offset 4298145792 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4298211328 ++read 32768/32768 bytes at offset 4298211328 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4298276864 ++read 32768/32768 bytes at offset 4298276864 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4298342400 ++read 32768/32768 bytes at offset 4298342400 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4298407936 ++read 32768/32768 bytes at offset 4298407936 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4298473472 ++read 32768/32768 bytes at offset 4298473472 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4298539008 ++read 32768/32768 bytes at offset 4298539008 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4298604544 ++read 32768/32768 bytes at offset 4298604544 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4298670080 ++read 32768/32768 bytes at offset 4298670080 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4298735616 ++read 32768/32768 bytes at offset 4298735616 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4298801152 ++read 32768/32768 bytes at offset 4298801152 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4298866688 ++read 32768/32768 bytes at offset 4298866688 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4298932224 ++read 32768/32768 bytes at offset 4298932224 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4298997760 ++read 32768/32768 bytes at offset 4298997760 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4299063296 ++read 32768/32768 bytes at offset 4299063296 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4299128832 ++read 32768/32768 bytes at offset 4299128832 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4299194368 ++read 32768/32768 bytes at offset 4299194368 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4299259904 ++read 32768/32768 bytes at offset 4299259904 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4299325440 ++read 32768/32768 bytes at offset 4299325440 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4299390976 ++read 32768/32768 bytes at offset 4299390976 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4299456512 ++read 32768/32768 bytes at offset 4299456512 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4299522048 ++read 32768/32768 bytes at offset 4299522048 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4299587584 ++read 32768/32768 bytes at offset 4299587584 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4299653120 ++read 32768/32768 bytes at offset 4299653120 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> read 32768/32768 bytes at offset 4299685888 ++=== IO: pattern 0 ++read 32768/32768 bytes at offset 4299685888 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4299751424 ++read 32768/32768 bytes at offset 4299751424 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4299816960 ++read 32768/32768 bytes at offset 4299816960 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4299882496 ++read 32768/32768 bytes at offset 4299882496 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4299948032 ++read 32768/32768 bytes at offset 4299948032 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4300013568 ++read 32768/32768 bytes at offset 4300013568 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4300079104 ++read 32768/32768 bytes at offset 4300079104 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4300144640 ++read 32768/32768 bytes at offset 4300144640 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4300210176 ++read 32768/32768 bytes at offset 4300210176 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4300275712 ++read 32768/32768 bytes at offset 4300275712 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4300341248 ++read 32768/32768 bytes at offset 4300341248 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4300406784 ++read 32768/32768 bytes at offset 4300406784 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4300472320 ++read 32768/32768 bytes at offset 4300472320 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4300537856 ++read 32768/32768 bytes at offset 4300537856 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4300603392 ++read 32768/32768 bytes at offset 4300603392 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4300668928 ++read 32768/32768 bytes at offset 4300668928 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4300734464 ++read 32768/32768 bytes at offset 4300734464 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4300800000 ++read 32768/32768 bytes at offset 4300800000 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4300865536 ++read 32768/32768 bytes at offset 4300865536 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4300931072 ++read 32768/32768 bytes at offset 4300931072 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4300996608 ++read 32768/32768 bytes at offset 4300996608 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4301062144 ++read 32768/32768 bytes at offset 4301062144 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4301127680 ++read 32768/32768 bytes at offset 4301127680 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4301193216 ++read 32768/32768 bytes at offset 4301193216 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4301258752 ++read 32768/32768 bytes at offset 4301258752 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4301324288 ++read 32768/32768 bytes at offset 4301324288 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4301389824 ++read 32768/32768 bytes at offset 4301389824 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4301455360 ++read 32768/32768 bytes at offset 4301455360 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4301520896 ++read 32768/32768 bytes at offset 4301520896 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4301586432 ++read 32768/32768 bytes at offset 4301586432 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4301651968 ++read 32768/32768 bytes at offset 4301651968 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4301717504 ++read 32768/32768 bytes at offset 4301717504 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4301783040 ++read 32768/32768 bytes at offset 4301783040 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4301848576 ++read 32768/32768 bytes at offset 4301848576 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4301914112 ++read 32768/32768 bytes at offset 4301914112 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4301979648 ++read 32768/32768 bytes at offset 4301979648 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 32 +-qemu-io> read 32768/32768 bytes at offset 4302061568 ++=== IO: pattern 32 ++read 32768/32768 bytes at offset 4302061568 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4302127104 ++read 32768/32768 bytes at offset 4302127104 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4302192640 ++read 32768/32768 bytes at offset 4302192640 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4302258176 ++read 32768/32768 bytes at offset 4302258176 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4302323712 ++read 32768/32768 bytes at offset 4302323712 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4302389248 ++read 32768/32768 bytes at offset 4302389248 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4302454784 ++read 32768/32768 bytes at offset 4302454784 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4302520320 ++read 32768/32768 bytes at offset 4302520320 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4302585856 ++read 32768/32768 bytes at offset 4302585856 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4302651392 ++read 32768/32768 bytes at offset 4302651392 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4302716928 ++read 32768/32768 bytes at offset 4302716928 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4302782464 ++read 32768/32768 bytes at offset 4302782464 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4302848000 ++read 32768/32768 bytes at offset 4302848000 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4302913536 ++read 32768/32768 bytes at offset 4302913536 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4302979072 ++read 32768/32768 bytes at offset 4302979072 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4303044608 ++read 32768/32768 bytes at offset 4303044608 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4303110144 ++read 32768/32768 bytes at offset 4303110144 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4303175680 ++read 32768/32768 bytes at offset 4303175680 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4303241216 ++read 32768/32768 bytes at offset 4303241216 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4303306752 ++read 32768/32768 bytes at offset 4303306752 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4303372288 ++read 32768/32768 bytes at offset 4303372288 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4303437824 ++read 32768/32768 bytes at offset 4303437824 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4303503360 ++read 32768/32768 bytes at offset 4303503360 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4303568896 ++read 32768/32768 bytes at offset 4303568896 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4303634432 ++read 32768/32768 bytes at offset 4303634432 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4303699968 ++read 32768/32768 bytes at offset 4303699968 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4303765504 ++read 32768/32768 bytes at offset 4303765504 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4303831040 ++read 32768/32768 bytes at offset 4303831040 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4303896576 ++read 32768/32768 bytes at offset 4303896576 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4303962112 ++read 32768/32768 bytes at offset 4303962112 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4304027648 ++read 32768/32768 bytes at offset 4304027648 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4304093184 ++read 32768/32768 bytes at offset 4304093184 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4304158720 ++read 32768/32768 bytes at offset 4304158720 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4304224256 ++read 32768/32768 bytes at offset 4304224256 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4304289792 ++read 32768/32768 bytes at offset 4304289792 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4304355328 ++read 32768/32768 bytes at offset 4304355328 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 64 +-qemu-io> read 131072/131072 bytes at offset 4304437248 ++=== IO: pattern 64 ++read 131072/131072 bytes at offset 4304437248 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 131072/131072 bytes at offset 4304633856 ++read 131072/131072 bytes at offset 4304633856 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 131072/131072 bytes at offset 4304830464 ++read 131072/131072 bytes at offset 4304830464 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 131072/131072 bytes at offset 4305027072 ++read 131072/131072 bytes at offset 4305027072 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 131072/131072 bytes at offset 4305223680 ++read 131072/131072 bytes at offset 4305223680 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 131072/131072 bytes at offset 4305420288 ++read 131072/131072 bytes at offset 4305420288 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 131072/131072 bytes at offset 4305616896 ++read 131072/131072 bytes at offset 4305616896 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 131072/131072 bytes at offset 4305813504 ++read 131072/131072 bytes at offset 4305813504 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 131072/131072 bytes at offset 4306010112 ++read 131072/131072 bytes at offset 4306010112 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 64 +-qemu-io> read 196608/196608 bytes at offset 4831739904 ++=== IO: pattern 64 ++read 196608/196608 bytes at offset 4831739904 + 192 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 196608/196608 bytes at offset 5368643584 ++read 196608/196608 bytes at offset 5368643584 + 192 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 196608/196608 bytes at offset 5905547264 ++read 196608/196608 bytes at offset 5905547264 + 192 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> wrote 65536/65536 bytes at offset 4294967296 ++=== IO: pattern 0 ++wrote 65536/65536 bytes at offset 4294967296 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4295032832 ++wrote 65536/65536 bytes at offset 4295032832 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4295098368 ++wrote 65536/65536 bytes at offset 4295098368 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4295163904 ++wrote 65536/65536 bytes at offset 4295163904 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4295229440 ++wrote 65536/65536 bytes at offset 4295229440 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4295294976 ++wrote 65536/65536 bytes at offset 4295294976 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4295360512 ++wrote 65536/65536 bytes at offset 4295360512 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4295426048 ++wrote 65536/65536 bytes at offset 4295426048 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4295491584 ++wrote 65536/65536 bytes at offset 4295491584 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4295557120 ++wrote 65536/65536 bytes at offset 4295557120 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4295622656 ++wrote 65536/65536 bytes at offset 4295622656 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4295688192 ++wrote 65536/65536 bytes at offset 4295688192 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4295753728 ++wrote 65536/65536 bytes at offset 4295753728 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4295819264 ++wrote 65536/65536 bytes at offset 4295819264 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4295884800 ++wrote 65536/65536 bytes at offset 4295884800 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4295950336 ++wrote 65536/65536 bytes at offset 4295950336 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4296015872 ++wrote 65536/65536 bytes at offset 4296015872 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4296081408 ++wrote 65536/65536 bytes at offset 4296081408 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4296146944 ++wrote 65536/65536 bytes at offset 4296146944 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4296212480 ++wrote 65536/65536 bytes at offset 4296212480 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4296278016 ++wrote 65536/65536 bytes at offset 4296278016 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4296343552 ++wrote 65536/65536 bytes at offset 4296343552 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4296409088 ++wrote 65536/65536 bytes at offset 4296409088 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4296474624 ++wrote 65536/65536 bytes at offset 4296474624 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4296540160 ++wrote 65536/65536 bytes at offset 4296540160 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4296605696 ++wrote 65536/65536 bytes at offset 4296605696 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4296671232 ++wrote 65536/65536 bytes at offset 4296671232 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4296736768 ++wrote 65536/65536 bytes at offset 4296736768 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4296802304 ++wrote 65536/65536 bytes at offset 4296802304 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4296867840 ++wrote 65536/65536 bytes at offset 4296867840 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4296933376 ++wrote 65536/65536 bytes at offset 4296933376 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4296998912 ++wrote 65536/65536 bytes at offset 4296998912 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4297064448 ++wrote 65536/65536 bytes at offset 4297064448 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4297129984 ++wrote 65536/65536 bytes at offset 4297129984 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4297195520 ++wrote 65536/65536 bytes at offset 4297195520 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4297261056 ++wrote 65536/65536 bytes at offset 4297261056 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 64 +-qemu-io> wrote 32768/32768 bytes at offset 4297359360 ++=== IO: pattern 64 ++wrote 32768/32768 bytes at offset 4297359360 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4297424896 ++wrote 32768/32768 bytes at offset 4297424896 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4297490432 ++wrote 32768/32768 bytes at offset 4297490432 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4297555968 ++wrote 32768/32768 bytes at offset 4297555968 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4297621504 ++wrote 32768/32768 bytes at offset 4297621504 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4297687040 ++wrote 32768/32768 bytes at offset 4297687040 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4297752576 ++wrote 32768/32768 bytes at offset 4297752576 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4297818112 ++wrote 32768/32768 bytes at offset 4297818112 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4297883648 ++wrote 32768/32768 bytes at offset 4297883648 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4297949184 ++wrote 32768/32768 bytes at offset 4297949184 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4298014720 ++wrote 32768/32768 bytes at offset 4298014720 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4298080256 ++wrote 32768/32768 bytes at offset 4298080256 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4298145792 ++wrote 32768/32768 bytes at offset 4298145792 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4298211328 ++wrote 32768/32768 bytes at offset 4298211328 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4298276864 ++wrote 32768/32768 bytes at offset 4298276864 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4298342400 ++wrote 32768/32768 bytes at offset 4298342400 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4298407936 ++wrote 32768/32768 bytes at offset 4298407936 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4298473472 ++wrote 32768/32768 bytes at offset 4298473472 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4298539008 ++wrote 32768/32768 bytes at offset 4298539008 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4298604544 ++wrote 32768/32768 bytes at offset 4298604544 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4298670080 ++wrote 32768/32768 bytes at offset 4298670080 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4298735616 ++wrote 32768/32768 bytes at offset 4298735616 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4298801152 ++wrote 32768/32768 bytes at offset 4298801152 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4298866688 ++wrote 32768/32768 bytes at offset 4298866688 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4298932224 ++wrote 32768/32768 bytes at offset 4298932224 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4298997760 ++wrote 32768/32768 bytes at offset 4298997760 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4299063296 ++wrote 32768/32768 bytes at offset 4299063296 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4299128832 ++wrote 32768/32768 bytes at offset 4299128832 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4299194368 ++wrote 32768/32768 bytes at offset 4299194368 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4299259904 ++wrote 32768/32768 bytes at offset 4299259904 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4299325440 ++wrote 32768/32768 bytes at offset 4299325440 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4299390976 ++wrote 32768/32768 bytes at offset 4299390976 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4299456512 ++wrote 32768/32768 bytes at offset 4299456512 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4299522048 ++wrote 32768/32768 bytes at offset 4299522048 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4299587584 ++wrote 32768/32768 bytes at offset 4299587584 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4299653120 ++wrote 32768/32768 bytes at offset 4299653120 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> wrote 32768/32768 bytes at offset 4299685888 ++=== IO: pattern 0 ++wrote 32768/32768 bytes at offset 4299685888 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4299751424 ++wrote 32768/32768 bytes at offset 4299751424 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4299816960 ++wrote 32768/32768 bytes at offset 4299816960 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4299882496 ++wrote 32768/32768 bytes at offset 4299882496 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4299948032 ++wrote 32768/32768 bytes at offset 4299948032 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4300013568 ++wrote 32768/32768 bytes at offset 4300013568 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4300079104 ++wrote 32768/32768 bytes at offset 4300079104 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4300144640 ++wrote 32768/32768 bytes at offset 4300144640 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4300210176 ++wrote 32768/32768 bytes at offset 4300210176 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4300275712 ++wrote 32768/32768 bytes at offset 4300275712 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4300341248 ++wrote 32768/32768 bytes at offset 4300341248 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4300406784 ++wrote 32768/32768 bytes at offset 4300406784 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4300472320 ++wrote 32768/32768 bytes at offset 4300472320 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4300537856 ++wrote 32768/32768 bytes at offset 4300537856 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4300603392 ++wrote 32768/32768 bytes at offset 4300603392 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4300668928 ++wrote 32768/32768 bytes at offset 4300668928 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4300734464 ++wrote 32768/32768 bytes at offset 4300734464 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4300800000 ++wrote 32768/32768 bytes at offset 4300800000 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4300865536 ++wrote 32768/32768 bytes at offset 4300865536 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4300931072 ++wrote 32768/32768 bytes at offset 4300931072 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4300996608 ++wrote 32768/32768 bytes at offset 4300996608 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4301062144 ++wrote 32768/32768 bytes at offset 4301062144 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4301127680 ++wrote 32768/32768 bytes at offset 4301127680 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4301193216 ++wrote 32768/32768 bytes at offset 4301193216 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4301258752 ++wrote 32768/32768 bytes at offset 4301258752 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4301324288 ++wrote 32768/32768 bytes at offset 4301324288 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4301389824 ++wrote 32768/32768 bytes at offset 4301389824 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4301455360 ++wrote 32768/32768 bytes at offset 4301455360 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4301520896 ++wrote 32768/32768 bytes at offset 4301520896 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4301586432 ++wrote 32768/32768 bytes at offset 4301586432 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4301651968 ++wrote 32768/32768 bytes at offset 4301651968 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4301717504 ++wrote 32768/32768 bytes at offset 4301717504 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4301783040 ++wrote 32768/32768 bytes at offset 4301783040 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4301848576 ++wrote 32768/32768 bytes at offset 4301848576 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4301914112 ++wrote 32768/32768 bytes at offset 4301914112 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4301979648 ++wrote 32768/32768 bytes at offset 4301979648 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 32 +-qemu-io> wrote 32768/32768 bytes at offset 4302061568 ++=== IO: pattern 32 ++wrote 32768/32768 bytes at offset 4302061568 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4302127104 ++wrote 32768/32768 bytes at offset 4302127104 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4302192640 ++wrote 32768/32768 bytes at offset 4302192640 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4302258176 ++wrote 32768/32768 bytes at offset 4302258176 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4302323712 ++wrote 32768/32768 bytes at offset 4302323712 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4302389248 ++wrote 32768/32768 bytes at offset 4302389248 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4302454784 ++wrote 32768/32768 bytes at offset 4302454784 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4302520320 ++wrote 32768/32768 bytes at offset 4302520320 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4302585856 ++wrote 32768/32768 bytes at offset 4302585856 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4302651392 ++wrote 32768/32768 bytes at offset 4302651392 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4302716928 ++wrote 32768/32768 bytes at offset 4302716928 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4302782464 ++wrote 32768/32768 bytes at offset 4302782464 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4302848000 ++wrote 32768/32768 bytes at offset 4302848000 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4302913536 ++wrote 32768/32768 bytes at offset 4302913536 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4302979072 ++wrote 32768/32768 bytes at offset 4302979072 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4303044608 ++wrote 32768/32768 bytes at offset 4303044608 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4303110144 ++wrote 32768/32768 bytes at offset 4303110144 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4303175680 ++wrote 32768/32768 bytes at offset 4303175680 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4303241216 ++wrote 32768/32768 bytes at offset 4303241216 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4303306752 ++wrote 32768/32768 bytes at offset 4303306752 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4303372288 ++wrote 32768/32768 bytes at offset 4303372288 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4303437824 ++wrote 32768/32768 bytes at offset 4303437824 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4303503360 ++wrote 32768/32768 bytes at offset 4303503360 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4303568896 ++wrote 32768/32768 bytes at offset 4303568896 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4303634432 ++wrote 32768/32768 bytes at offset 4303634432 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4303699968 ++wrote 32768/32768 bytes at offset 4303699968 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4303765504 ++wrote 32768/32768 bytes at offset 4303765504 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4303831040 ++wrote 32768/32768 bytes at offset 4303831040 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4303896576 ++wrote 32768/32768 bytes at offset 4303896576 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4303962112 ++wrote 32768/32768 bytes at offset 4303962112 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4304027648 ++wrote 32768/32768 bytes at offset 4304027648 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4304093184 ++wrote 32768/32768 bytes at offset 4304093184 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4304158720 ++wrote 32768/32768 bytes at offset 4304158720 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4304224256 ++wrote 32768/32768 bytes at offset 4304224256 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4304289792 ++wrote 32768/32768 bytes at offset 4304289792 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4304355328 ++wrote 32768/32768 bytes at offset 4304355328 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 64 +-qemu-io> wrote 131072/131072 bytes at offset 4304437248 ++=== IO: pattern 64 ++wrote 131072/131072 bytes at offset 4304437248 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 131072/131072 bytes at offset 4304633856 ++wrote 131072/131072 bytes at offset 4304633856 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 131072/131072 bytes at offset 4304830464 ++wrote 131072/131072 bytes at offset 4304830464 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 131072/131072 bytes at offset 4305027072 ++wrote 131072/131072 bytes at offset 4305027072 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 131072/131072 bytes at offset 4305223680 ++wrote 131072/131072 bytes at offset 4305223680 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 131072/131072 bytes at offset 4305420288 ++wrote 131072/131072 bytes at offset 4305420288 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 131072/131072 bytes at offset 4305616896 ++wrote 131072/131072 bytes at offset 4305616896 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 131072/131072 bytes at offset 4305813504 ++wrote 131072/131072 bytes at offset 4305813504 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 131072/131072 bytes at offset 4306010112 ++wrote 131072/131072 bytes at offset 4306010112 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 64 +-qemu-io> wrote 196608/196608 bytes at offset 4831739904 ++=== IO: pattern 64 ++wrote 196608/196608 bytes at offset 4831739904 + 192 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 196608/196608 bytes at offset 5368643584 ++wrote 196608/196608 bytes at offset 5368643584 + 192 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 196608/196608 bytes at offset 5905547264 ++wrote 196608/196608 bytes at offset 5905547264 + 192 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> read 65536/65536 bytes at offset 4294967296 ++=== IO: pattern 0 ++read 65536/65536 bytes at offset 4294967296 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4295032832 ++read 65536/65536 bytes at offset 4295032832 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4295098368 ++read 65536/65536 bytes at offset 4295098368 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4295163904 ++read 65536/65536 bytes at offset 4295163904 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4295229440 ++read 65536/65536 bytes at offset 4295229440 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4295294976 ++read 65536/65536 bytes at offset 4295294976 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4295360512 ++read 65536/65536 bytes at offset 4295360512 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4295426048 ++read 65536/65536 bytes at offset 4295426048 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4295491584 ++read 65536/65536 bytes at offset 4295491584 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4295557120 ++read 65536/65536 bytes at offset 4295557120 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4295622656 ++read 65536/65536 bytes at offset 4295622656 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4295688192 ++read 65536/65536 bytes at offset 4295688192 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4295753728 ++read 65536/65536 bytes at offset 4295753728 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4295819264 ++read 65536/65536 bytes at offset 4295819264 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4295884800 ++read 65536/65536 bytes at offset 4295884800 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4295950336 ++read 65536/65536 bytes at offset 4295950336 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4296015872 ++read 65536/65536 bytes at offset 4296015872 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4296081408 ++read 65536/65536 bytes at offset 4296081408 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4296146944 ++read 65536/65536 bytes at offset 4296146944 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4296212480 ++read 65536/65536 bytes at offset 4296212480 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4296278016 ++read 65536/65536 bytes at offset 4296278016 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4296343552 ++read 65536/65536 bytes at offset 4296343552 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4296409088 ++read 65536/65536 bytes at offset 4296409088 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4296474624 ++read 65536/65536 bytes at offset 4296474624 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4296540160 ++read 65536/65536 bytes at offset 4296540160 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4296605696 ++read 65536/65536 bytes at offset 4296605696 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4296671232 ++read 65536/65536 bytes at offset 4296671232 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4296736768 ++read 65536/65536 bytes at offset 4296736768 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4296802304 ++read 65536/65536 bytes at offset 4296802304 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4296867840 ++read 65536/65536 bytes at offset 4296867840 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4296933376 ++read 65536/65536 bytes at offset 4296933376 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4296998912 ++read 65536/65536 bytes at offset 4296998912 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4297064448 ++read 65536/65536 bytes at offset 4297064448 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4297129984 ++read 65536/65536 bytes at offset 4297129984 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4297195520 ++read 65536/65536 bytes at offset 4297195520 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4297261056 ++read 65536/65536 bytes at offset 4297261056 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 64 +-qemu-io> read 32768/32768 bytes at offset 4297359360 ++=== IO: pattern 64 ++read 32768/32768 bytes at offset 4297359360 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4297424896 ++read 32768/32768 bytes at offset 4297424896 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4297490432 ++read 32768/32768 bytes at offset 4297490432 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4297555968 ++read 32768/32768 bytes at offset 4297555968 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4297621504 ++read 32768/32768 bytes at offset 4297621504 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4297687040 ++read 32768/32768 bytes at offset 4297687040 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4297752576 ++read 32768/32768 bytes at offset 4297752576 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4297818112 ++read 32768/32768 bytes at offset 4297818112 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4297883648 ++read 32768/32768 bytes at offset 4297883648 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4297949184 ++read 32768/32768 bytes at offset 4297949184 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4298014720 ++read 32768/32768 bytes at offset 4298014720 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4298080256 ++read 32768/32768 bytes at offset 4298080256 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4298145792 ++read 32768/32768 bytes at offset 4298145792 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4298211328 ++read 32768/32768 bytes at offset 4298211328 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4298276864 ++read 32768/32768 bytes at offset 4298276864 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4298342400 ++read 32768/32768 bytes at offset 4298342400 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4298407936 ++read 32768/32768 bytes at offset 4298407936 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4298473472 ++read 32768/32768 bytes at offset 4298473472 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4298539008 ++read 32768/32768 bytes at offset 4298539008 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4298604544 ++read 32768/32768 bytes at offset 4298604544 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4298670080 ++read 32768/32768 bytes at offset 4298670080 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4298735616 ++read 32768/32768 bytes at offset 4298735616 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4298801152 ++read 32768/32768 bytes at offset 4298801152 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4298866688 ++read 32768/32768 bytes at offset 4298866688 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4298932224 ++read 32768/32768 bytes at offset 4298932224 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4298997760 ++read 32768/32768 bytes at offset 4298997760 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4299063296 ++read 32768/32768 bytes at offset 4299063296 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4299128832 ++read 32768/32768 bytes at offset 4299128832 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4299194368 ++read 32768/32768 bytes at offset 4299194368 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4299259904 ++read 32768/32768 bytes at offset 4299259904 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4299325440 ++read 32768/32768 bytes at offset 4299325440 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4299390976 ++read 32768/32768 bytes at offset 4299390976 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4299456512 ++read 32768/32768 bytes at offset 4299456512 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4299522048 ++read 32768/32768 bytes at offset 4299522048 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4299587584 ++read 32768/32768 bytes at offset 4299587584 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4299653120 ++read 32768/32768 bytes at offset 4299653120 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> read 32768/32768 bytes at offset 4299685888 ++=== IO: pattern 0 ++read 32768/32768 bytes at offset 4299685888 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4299751424 ++read 32768/32768 bytes at offset 4299751424 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4299816960 ++read 32768/32768 bytes at offset 4299816960 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4299882496 ++read 32768/32768 bytes at offset 4299882496 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4299948032 ++read 32768/32768 bytes at offset 4299948032 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4300013568 ++read 32768/32768 bytes at offset 4300013568 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4300079104 ++read 32768/32768 bytes at offset 4300079104 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4300144640 ++read 32768/32768 bytes at offset 4300144640 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4300210176 ++read 32768/32768 bytes at offset 4300210176 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4300275712 ++read 32768/32768 bytes at offset 4300275712 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4300341248 ++read 32768/32768 bytes at offset 4300341248 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4300406784 ++read 32768/32768 bytes at offset 4300406784 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4300472320 ++read 32768/32768 bytes at offset 4300472320 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4300537856 ++read 32768/32768 bytes at offset 4300537856 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4300603392 ++read 32768/32768 bytes at offset 4300603392 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4300668928 ++read 32768/32768 bytes at offset 4300668928 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4300734464 ++read 32768/32768 bytes at offset 4300734464 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4300800000 ++read 32768/32768 bytes at offset 4300800000 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4300865536 ++read 32768/32768 bytes at offset 4300865536 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4300931072 ++read 32768/32768 bytes at offset 4300931072 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4300996608 ++read 32768/32768 bytes at offset 4300996608 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4301062144 ++read 32768/32768 bytes at offset 4301062144 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4301127680 ++read 32768/32768 bytes at offset 4301127680 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4301193216 ++read 32768/32768 bytes at offset 4301193216 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4301258752 ++read 32768/32768 bytes at offset 4301258752 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4301324288 ++read 32768/32768 bytes at offset 4301324288 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4301389824 ++read 32768/32768 bytes at offset 4301389824 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4301455360 ++read 32768/32768 bytes at offset 4301455360 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4301520896 ++read 32768/32768 bytes at offset 4301520896 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4301586432 ++read 32768/32768 bytes at offset 4301586432 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4301651968 ++read 32768/32768 bytes at offset 4301651968 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4301717504 ++read 32768/32768 bytes at offset 4301717504 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4301783040 ++read 32768/32768 bytes at offset 4301783040 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4301848576 ++read 32768/32768 bytes at offset 4301848576 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4301914112 ++read 32768/32768 bytes at offset 4301914112 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4301979648 ++read 32768/32768 bytes at offset 4301979648 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 32 +-qemu-io> read 32768/32768 bytes at offset 4302061568 ++=== IO: pattern 32 ++read 32768/32768 bytes at offset 4302061568 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4302127104 ++read 32768/32768 bytes at offset 4302127104 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4302192640 ++read 32768/32768 bytes at offset 4302192640 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4302258176 ++read 32768/32768 bytes at offset 4302258176 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4302323712 ++read 32768/32768 bytes at offset 4302323712 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4302389248 ++read 32768/32768 bytes at offset 4302389248 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4302454784 ++read 32768/32768 bytes at offset 4302454784 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4302520320 ++read 32768/32768 bytes at offset 4302520320 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4302585856 ++read 32768/32768 bytes at offset 4302585856 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4302651392 ++read 32768/32768 bytes at offset 4302651392 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4302716928 ++read 32768/32768 bytes at offset 4302716928 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4302782464 ++read 32768/32768 bytes at offset 4302782464 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4302848000 ++read 32768/32768 bytes at offset 4302848000 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4302913536 ++read 32768/32768 bytes at offset 4302913536 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4302979072 ++read 32768/32768 bytes at offset 4302979072 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4303044608 ++read 32768/32768 bytes at offset 4303044608 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4303110144 ++read 32768/32768 bytes at offset 4303110144 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4303175680 ++read 32768/32768 bytes at offset 4303175680 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4303241216 ++read 32768/32768 bytes at offset 4303241216 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4303306752 ++read 32768/32768 bytes at offset 4303306752 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4303372288 ++read 32768/32768 bytes at offset 4303372288 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4303437824 ++read 32768/32768 bytes at offset 4303437824 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4303503360 ++read 32768/32768 bytes at offset 4303503360 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4303568896 ++read 32768/32768 bytes at offset 4303568896 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4303634432 ++read 32768/32768 bytes at offset 4303634432 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4303699968 ++read 32768/32768 bytes at offset 4303699968 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4303765504 ++read 32768/32768 bytes at offset 4303765504 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4303831040 ++read 32768/32768 bytes at offset 4303831040 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4303896576 ++read 32768/32768 bytes at offset 4303896576 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4303962112 ++read 32768/32768 bytes at offset 4303962112 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4304027648 ++read 32768/32768 bytes at offset 4304027648 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4304093184 ++read 32768/32768 bytes at offset 4304093184 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4304158720 ++read 32768/32768 bytes at offset 4304158720 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4304224256 ++read 32768/32768 bytes at offset 4304224256 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4304289792 ++read 32768/32768 bytes at offset 4304289792 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4304355328 ++read 32768/32768 bytes at offset 4304355328 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 64 +-qemu-io> read 131072/131072 bytes at offset 4304437248 ++=== IO: pattern 64 ++read 131072/131072 bytes at offset 4304437248 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 131072/131072 bytes at offset 4304633856 ++read 131072/131072 bytes at offset 4304633856 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 131072/131072 bytes at offset 4304830464 ++read 131072/131072 bytes at offset 4304830464 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 131072/131072 bytes at offset 4305027072 ++read 131072/131072 bytes at offset 4305027072 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 131072/131072 bytes at offset 4305223680 ++read 131072/131072 bytes at offset 4305223680 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 131072/131072 bytes at offset 4305420288 ++read 131072/131072 bytes at offset 4305420288 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 131072/131072 bytes at offset 4305616896 ++read 131072/131072 bytes at offset 4305616896 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 131072/131072 bytes at offset 4305813504 ++read 131072/131072 bytes at offset 4305813504 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 131072/131072 bytes at offset 4306010112 ++read 131072/131072 bytes at offset 4306010112 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 64 +-qemu-io> read 196608/196608 bytes at offset 4831739904 ++=== IO: pattern 64 ++read 196608/196608 bytes at offset 4831739904 + 192 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 196608/196608 bytes at offset 5368643584 ++read 196608/196608 bytes at offset 5368643584 + 192 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 196608/196608 bytes at offset 5905547264 ++read 196608/196608 bytes at offset 5905547264 + 192 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> No errors were found on the image. ++No errors were found on the image. + Compressing image + + Testing compressed image + + With offset 0: + === IO: pattern 0 +-qemu-io> read 65536/65536 bytes at offset 0 ++read 65536/65536 bytes at offset 0 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 65536 ++read 65536/65536 bytes at offset 65536 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 131072 ++read 65536/65536 bytes at offset 131072 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 196608 ++read 65536/65536 bytes at offset 196608 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 262144 ++read 65536/65536 bytes at offset 262144 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 327680 ++read 65536/65536 bytes at offset 327680 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 393216 ++read 65536/65536 bytes at offset 393216 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 458752 ++read 65536/65536 bytes at offset 458752 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 524288 ++read 65536/65536 bytes at offset 524288 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 589824 ++read 65536/65536 bytes at offset 589824 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 655360 ++read 65536/65536 bytes at offset 655360 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 720896 ++read 65536/65536 bytes at offset 720896 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 786432 ++read 65536/65536 bytes at offset 786432 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 851968 ++read 65536/65536 bytes at offset 851968 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 917504 ++read 65536/65536 bytes at offset 917504 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 983040 ++read 65536/65536 bytes at offset 983040 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 1048576 ++read 65536/65536 bytes at offset 1048576 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 1114112 ++read 65536/65536 bytes at offset 1114112 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 1179648 ++read 65536/65536 bytes at offset 1179648 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 1245184 ++read 65536/65536 bytes at offset 1245184 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 1310720 ++read 65536/65536 bytes at offset 1310720 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 1376256 ++read 65536/65536 bytes at offset 1376256 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 1441792 ++read 65536/65536 bytes at offset 1441792 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 1507328 ++read 65536/65536 bytes at offset 1507328 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 1572864 ++read 65536/65536 bytes at offset 1572864 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 1638400 ++read 65536/65536 bytes at offset 1638400 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 1703936 ++read 65536/65536 bytes at offset 1703936 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 1769472 ++read 65536/65536 bytes at offset 1769472 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 1835008 ++read 65536/65536 bytes at offset 1835008 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 1900544 ++read 65536/65536 bytes at offset 1900544 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 1966080 ++read 65536/65536 bytes at offset 1966080 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 2031616 ++read 65536/65536 bytes at offset 2031616 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 2097152 ++read 65536/65536 bytes at offset 2097152 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 2162688 ++read 65536/65536 bytes at offset 2162688 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 2228224 ++read 65536/65536 bytes at offset 2228224 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 2293760 ++read 65536/65536 bytes at offset 2293760 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 64 +-qemu-io> read 32768/32768 bytes at offset 2392064 ++=== IO: pattern 64 ++read 32768/32768 bytes at offset 2392064 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 2457600 ++read 32768/32768 bytes at offset 2457600 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 2523136 ++read 32768/32768 bytes at offset 2523136 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 2588672 ++read 32768/32768 bytes at offset 2588672 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 2654208 ++read 32768/32768 bytes at offset 2654208 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 2719744 ++read 32768/32768 bytes at offset 2719744 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 2785280 ++read 32768/32768 bytes at offset 2785280 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 2850816 ++read 32768/32768 bytes at offset 2850816 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 2916352 ++read 32768/32768 bytes at offset 2916352 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 2981888 ++read 32768/32768 bytes at offset 2981888 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 3047424 ++read 32768/32768 bytes at offset 3047424 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 3112960 ++read 32768/32768 bytes at offset 3112960 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 3178496 ++read 32768/32768 bytes at offset 3178496 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 3244032 ++read 32768/32768 bytes at offset 3244032 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 3309568 ++read 32768/32768 bytes at offset 3309568 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 3375104 ++read 32768/32768 bytes at offset 3375104 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 3440640 ++read 32768/32768 bytes at offset 3440640 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 3506176 ++read 32768/32768 bytes at offset 3506176 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 3571712 ++read 32768/32768 bytes at offset 3571712 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 3637248 ++read 32768/32768 bytes at offset 3637248 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 3702784 ++read 32768/32768 bytes at offset 3702784 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 3768320 ++read 32768/32768 bytes at offset 3768320 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 3833856 ++read 32768/32768 bytes at offset 3833856 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 3899392 ++read 32768/32768 bytes at offset 3899392 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 3964928 ++read 32768/32768 bytes at offset 3964928 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4030464 ++read 32768/32768 bytes at offset 4030464 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4096000 ++read 32768/32768 bytes at offset 4096000 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4161536 ++read 32768/32768 bytes at offset 4161536 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4227072 ++read 32768/32768 bytes at offset 4227072 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4292608 ++read 32768/32768 bytes at offset 4292608 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4358144 ++read 32768/32768 bytes at offset 4358144 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4423680 ++read 32768/32768 bytes at offset 4423680 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4489216 ++read 32768/32768 bytes at offset 4489216 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4554752 ++read 32768/32768 bytes at offset 4554752 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4620288 ++read 32768/32768 bytes at offset 4620288 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4685824 ++read 32768/32768 bytes at offset 4685824 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> read 32768/32768 bytes at offset 4718592 ++=== IO: pattern 0 ++read 32768/32768 bytes at offset 4718592 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4784128 ++read 32768/32768 bytes at offset 4784128 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4849664 ++read 32768/32768 bytes at offset 4849664 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4915200 ++read 32768/32768 bytes at offset 4915200 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4980736 ++read 32768/32768 bytes at offset 4980736 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 5046272 ++read 32768/32768 bytes at offset 5046272 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 5111808 ++read 32768/32768 bytes at offset 5111808 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 5177344 ++read 32768/32768 bytes at offset 5177344 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 5242880 ++read 32768/32768 bytes at offset 5242880 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 5308416 ++read 32768/32768 bytes at offset 5308416 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 5373952 ++read 32768/32768 bytes at offset 5373952 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 5439488 ++read 32768/32768 bytes at offset 5439488 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 5505024 ++read 32768/32768 bytes at offset 5505024 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 5570560 ++read 32768/32768 bytes at offset 5570560 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 5636096 ++read 32768/32768 bytes at offset 5636096 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 5701632 ++read 32768/32768 bytes at offset 5701632 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 5767168 ++read 32768/32768 bytes at offset 5767168 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 5832704 ++read 32768/32768 bytes at offset 5832704 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 5898240 ++read 32768/32768 bytes at offset 5898240 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 5963776 ++read 32768/32768 bytes at offset 5963776 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 6029312 ++read 32768/32768 bytes at offset 6029312 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 6094848 ++read 32768/32768 bytes at offset 6094848 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 6160384 ++read 32768/32768 bytes at offset 6160384 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 6225920 ++read 32768/32768 bytes at offset 6225920 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 6291456 ++read 32768/32768 bytes at offset 6291456 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 6356992 ++read 32768/32768 bytes at offset 6356992 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 6422528 ++read 32768/32768 bytes at offset 6422528 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 6488064 ++read 32768/32768 bytes at offset 6488064 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 6553600 ++read 32768/32768 bytes at offset 6553600 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 6619136 ++read 32768/32768 bytes at offset 6619136 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 6684672 ++read 32768/32768 bytes at offset 6684672 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 6750208 ++read 32768/32768 bytes at offset 6750208 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 6815744 ++read 32768/32768 bytes at offset 6815744 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 6881280 ++read 32768/32768 bytes at offset 6881280 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 6946816 ++read 32768/32768 bytes at offset 6946816 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 7012352 ++read 32768/32768 bytes at offset 7012352 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 32 +-qemu-io> read 32768/32768 bytes at offset 7094272 ++=== IO: pattern 32 ++read 32768/32768 bytes at offset 7094272 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 7159808 ++read 32768/32768 bytes at offset 7159808 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 7225344 ++read 32768/32768 bytes at offset 7225344 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 7290880 ++read 32768/32768 bytes at offset 7290880 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 7356416 ++read 32768/32768 bytes at offset 7356416 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 7421952 ++read 32768/32768 bytes at offset 7421952 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 7487488 ++read 32768/32768 bytes at offset 7487488 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 7553024 ++read 32768/32768 bytes at offset 7553024 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 7618560 ++read 32768/32768 bytes at offset 7618560 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 7684096 ++read 32768/32768 bytes at offset 7684096 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 7749632 ++read 32768/32768 bytes at offset 7749632 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 7815168 ++read 32768/32768 bytes at offset 7815168 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 7880704 ++read 32768/32768 bytes at offset 7880704 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 7946240 ++read 32768/32768 bytes at offset 7946240 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 8011776 ++read 32768/32768 bytes at offset 8011776 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 8077312 ++read 32768/32768 bytes at offset 8077312 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 8142848 ++read 32768/32768 bytes at offset 8142848 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 8208384 ++read 32768/32768 bytes at offset 8208384 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 8273920 ++read 32768/32768 bytes at offset 8273920 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 8339456 ++read 32768/32768 bytes at offset 8339456 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 8404992 ++read 32768/32768 bytes at offset 8404992 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 8470528 ++read 32768/32768 bytes at offset 8470528 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 8536064 ++read 32768/32768 bytes at offset 8536064 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 8601600 ++read 32768/32768 bytes at offset 8601600 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 8667136 ++read 32768/32768 bytes at offset 8667136 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 8732672 ++read 32768/32768 bytes at offset 8732672 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 8798208 ++read 32768/32768 bytes at offset 8798208 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 8863744 ++read 32768/32768 bytes at offset 8863744 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 8929280 ++read 32768/32768 bytes at offset 8929280 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 8994816 ++read 32768/32768 bytes at offset 8994816 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 9060352 ++read 32768/32768 bytes at offset 9060352 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 9125888 ++read 32768/32768 bytes at offset 9125888 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 9191424 ++read 32768/32768 bytes at offset 9191424 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 9256960 ++read 32768/32768 bytes at offset 9256960 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 9322496 ++read 32768/32768 bytes at offset 9322496 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 9388032 ++read 32768/32768 bytes at offset 9388032 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 64 +-qemu-io> read 131072/131072 bytes at offset 9469952 ++=== IO: pattern 64 ++read 131072/131072 bytes at offset 9469952 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 131072/131072 bytes at offset 9666560 ++read 131072/131072 bytes at offset 9666560 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 131072/131072 bytes at offset 9863168 ++read 131072/131072 bytes at offset 9863168 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 131072/131072 bytes at offset 10059776 ++read 131072/131072 bytes at offset 10059776 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 131072/131072 bytes at offset 10256384 ++read 131072/131072 bytes at offset 10256384 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 131072/131072 bytes at offset 10452992 ++read 131072/131072 bytes at offset 10452992 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 131072/131072 bytes at offset 10649600 ++read 131072/131072 bytes at offset 10649600 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 131072/131072 bytes at offset 10846208 ++read 131072/131072 bytes at offset 10846208 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 131072/131072 bytes at offset 11042816 ++read 131072/131072 bytes at offset 11042816 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 64 +-qemu-io> read 196608/196608 bytes at offset 536772608 ++=== IO: pattern 64 ++read 196608/196608 bytes at offset 536772608 + 192 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 196608/196608 bytes at offset 1073676288 ++read 196608/196608 bytes at offset 1073676288 + 192 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 196608/196608 bytes at offset 1610579968 ++read 196608/196608 bytes at offset 1610579968 + 192 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> read 65536/65536 bytes at offset 0 ++=== IO: pattern 0 ++read 65536/65536 bytes at offset 0 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 65536 ++read 65536/65536 bytes at offset 65536 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 131072 ++read 65536/65536 bytes at offset 131072 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 196608 ++read 65536/65536 bytes at offset 196608 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 262144 ++read 65536/65536 bytes at offset 262144 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 327680 ++read 65536/65536 bytes at offset 327680 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 393216 ++read 65536/65536 bytes at offset 393216 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 458752 ++read 65536/65536 bytes at offset 458752 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 524288 ++read 65536/65536 bytes at offset 524288 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 589824 ++read 65536/65536 bytes at offset 589824 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 655360 ++read 65536/65536 bytes at offset 655360 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 720896 ++read 65536/65536 bytes at offset 720896 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 786432 ++read 65536/65536 bytes at offset 786432 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 851968 ++read 65536/65536 bytes at offset 851968 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 917504 ++read 65536/65536 bytes at offset 917504 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 983040 ++read 65536/65536 bytes at offset 983040 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 1048576 ++read 65536/65536 bytes at offset 1048576 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 1114112 ++read 65536/65536 bytes at offset 1114112 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 1179648 ++read 65536/65536 bytes at offset 1179648 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 1245184 ++read 65536/65536 bytes at offset 1245184 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 1310720 ++read 65536/65536 bytes at offset 1310720 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 1376256 ++read 65536/65536 bytes at offset 1376256 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 1441792 ++read 65536/65536 bytes at offset 1441792 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 1507328 ++read 65536/65536 bytes at offset 1507328 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 1572864 ++read 65536/65536 bytes at offset 1572864 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 1638400 ++read 65536/65536 bytes at offset 1638400 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 1703936 ++read 65536/65536 bytes at offset 1703936 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 1769472 ++read 65536/65536 bytes at offset 1769472 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 1835008 ++read 65536/65536 bytes at offset 1835008 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 1900544 ++read 65536/65536 bytes at offset 1900544 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 1966080 ++read 65536/65536 bytes at offset 1966080 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 2031616 ++read 65536/65536 bytes at offset 2031616 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 2097152 ++read 65536/65536 bytes at offset 2097152 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 2162688 ++read 65536/65536 bytes at offset 2162688 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 2228224 ++read 65536/65536 bytes at offset 2228224 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 2293760 ++read 65536/65536 bytes at offset 2293760 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 64 +-qemu-io> read 32768/32768 bytes at offset 2392064 ++=== IO: pattern 64 ++read 32768/32768 bytes at offset 2392064 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 2457600 ++read 32768/32768 bytes at offset 2457600 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 2523136 ++read 32768/32768 bytes at offset 2523136 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 2588672 ++read 32768/32768 bytes at offset 2588672 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 2654208 ++read 32768/32768 bytes at offset 2654208 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 2719744 ++read 32768/32768 bytes at offset 2719744 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 2785280 ++read 32768/32768 bytes at offset 2785280 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 2850816 ++read 32768/32768 bytes at offset 2850816 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 2916352 ++read 32768/32768 bytes at offset 2916352 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 2981888 ++read 32768/32768 bytes at offset 2981888 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 3047424 ++read 32768/32768 bytes at offset 3047424 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 3112960 ++read 32768/32768 bytes at offset 3112960 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 3178496 ++read 32768/32768 bytes at offset 3178496 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 3244032 ++read 32768/32768 bytes at offset 3244032 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 3309568 ++read 32768/32768 bytes at offset 3309568 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 3375104 ++read 32768/32768 bytes at offset 3375104 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 3440640 ++read 32768/32768 bytes at offset 3440640 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 3506176 ++read 32768/32768 bytes at offset 3506176 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 3571712 ++read 32768/32768 bytes at offset 3571712 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 3637248 ++read 32768/32768 bytes at offset 3637248 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 3702784 ++read 32768/32768 bytes at offset 3702784 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 3768320 ++read 32768/32768 bytes at offset 3768320 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 3833856 ++read 32768/32768 bytes at offset 3833856 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 3899392 ++read 32768/32768 bytes at offset 3899392 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 3964928 ++read 32768/32768 bytes at offset 3964928 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4030464 ++read 32768/32768 bytes at offset 4030464 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4096000 ++read 32768/32768 bytes at offset 4096000 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4161536 ++read 32768/32768 bytes at offset 4161536 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4227072 ++read 32768/32768 bytes at offset 4227072 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4292608 ++read 32768/32768 bytes at offset 4292608 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4358144 ++read 32768/32768 bytes at offset 4358144 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4423680 ++read 32768/32768 bytes at offset 4423680 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4489216 ++read 32768/32768 bytes at offset 4489216 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4554752 ++read 32768/32768 bytes at offset 4554752 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4620288 ++read 32768/32768 bytes at offset 4620288 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4685824 ++read 32768/32768 bytes at offset 4685824 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> read 32768/32768 bytes at offset 4718592 ++=== IO: pattern 0 ++read 32768/32768 bytes at offset 4718592 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4784128 ++read 32768/32768 bytes at offset 4784128 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4849664 ++read 32768/32768 bytes at offset 4849664 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4915200 ++read 32768/32768 bytes at offset 4915200 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4980736 ++read 32768/32768 bytes at offset 4980736 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 5046272 ++read 32768/32768 bytes at offset 5046272 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 5111808 ++read 32768/32768 bytes at offset 5111808 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 5177344 ++read 32768/32768 bytes at offset 5177344 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 5242880 ++read 32768/32768 bytes at offset 5242880 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 5308416 ++read 32768/32768 bytes at offset 5308416 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 5373952 ++read 32768/32768 bytes at offset 5373952 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 5439488 ++read 32768/32768 bytes at offset 5439488 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 5505024 ++read 32768/32768 bytes at offset 5505024 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 5570560 ++read 32768/32768 bytes at offset 5570560 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 5636096 ++read 32768/32768 bytes at offset 5636096 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 5701632 ++read 32768/32768 bytes at offset 5701632 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 5767168 ++read 32768/32768 bytes at offset 5767168 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 5832704 ++read 32768/32768 bytes at offset 5832704 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 5898240 ++read 32768/32768 bytes at offset 5898240 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 5963776 ++read 32768/32768 bytes at offset 5963776 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 6029312 ++read 32768/32768 bytes at offset 6029312 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 6094848 ++read 32768/32768 bytes at offset 6094848 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 6160384 ++read 32768/32768 bytes at offset 6160384 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 6225920 ++read 32768/32768 bytes at offset 6225920 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 6291456 ++read 32768/32768 bytes at offset 6291456 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 6356992 ++read 32768/32768 bytes at offset 6356992 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 6422528 ++read 32768/32768 bytes at offset 6422528 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 6488064 ++read 32768/32768 bytes at offset 6488064 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 6553600 ++read 32768/32768 bytes at offset 6553600 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 6619136 ++read 32768/32768 bytes at offset 6619136 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 6684672 ++read 32768/32768 bytes at offset 6684672 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 6750208 ++read 32768/32768 bytes at offset 6750208 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 6815744 ++read 32768/32768 bytes at offset 6815744 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 6881280 ++read 32768/32768 bytes at offset 6881280 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 6946816 ++read 32768/32768 bytes at offset 6946816 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 7012352 ++read 32768/32768 bytes at offset 7012352 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 32 +-qemu-io> read 32768/32768 bytes at offset 7094272 ++=== IO: pattern 32 ++read 32768/32768 bytes at offset 7094272 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 7159808 ++read 32768/32768 bytes at offset 7159808 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 7225344 ++read 32768/32768 bytes at offset 7225344 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 7290880 ++read 32768/32768 bytes at offset 7290880 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 7356416 ++read 32768/32768 bytes at offset 7356416 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 7421952 ++read 32768/32768 bytes at offset 7421952 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 7487488 ++read 32768/32768 bytes at offset 7487488 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 7553024 ++read 32768/32768 bytes at offset 7553024 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 7618560 ++read 32768/32768 bytes at offset 7618560 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 7684096 ++read 32768/32768 bytes at offset 7684096 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 7749632 ++read 32768/32768 bytes at offset 7749632 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 7815168 ++read 32768/32768 bytes at offset 7815168 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 7880704 ++read 32768/32768 bytes at offset 7880704 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 7946240 ++read 32768/32768 bytes at offset 7946240 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 8011776 ++read 32768/32768 bytes at offset 8011776 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 8077312 ++read 32768/32768 bytes at offset 8077312 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 8142848 ++read 32768/32768 bytes at offset 8142848 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 8208384 ++read 32768/32768 bytes at offset 8208384 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 8273920 ++read 32768/32768 bytes at offset 8273920 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 8339456 ++read 32768/32768 bytes at offset 8339456 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 8404992 ++read 32768/32768 bytes at offset 8404992 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 8470528 ++read 32768/32768 bytes at offset 8470528 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 8536064 ++read 32768/32768 bytes at offset 8536064 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 8601600 ++read 32768/32768 bytes at offset 8601600 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 8667136 ++read 32768/32768 bytes at offset 8667136 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 8732672 ++read 32768/32768 bytes at offset 8732672 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 8798208 ++read 32768/32768 bytes at offset 8798208 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 8863744 ++read 32768/32768 bytes at offset 8863744 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 8929280 ++read 32768/32768 bytes at offset 8929280 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 8994816 ++read 32768/32768 bytes at offset 8994816 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 9060352 ++read 32768/32768 bytes at offset 9060352 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 9125888 ++read 32768/32768 bytes at offset 9125888 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 9191424 ++read 32768/32768 bytes at offset 9191424 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 9256960 ++read 32768/32768 bytes at offset 9256960 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 9322496 ++read 32768/32768 bytes at offset 9322496 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 9388032 ++read 32768/32768 bytes at offset 9388032 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 64 +-qemu-io> read 131072/131072 bytes at offset 9469952 ++=== IO: pattern 64 ++read 131072/131072 bytes at offset 9469952 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 131072/131072 bytes at offset 9666560 ++read 131072/131072 bytes at offset 9666560 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 131072/131072 bytes at offset 9863168 ++read 131072/131072 bytes at offset 9863168 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 131072/131072 bytes at offset 10059776 ++read 131072/131072 bytes at offset 10059776 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 131072/131072 bytes at offset 10256384 ++read 131072/131072 bytes at offset 10256384 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 131072/131072 bytes at offset 10452992 ++read 131072/131072 bytes at offset 10452992 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 131072/131072 bytes at offset 10649600 ++read 131072/131072 bytes at offset 10649600 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 131072/131072 bytes at offset 10846208 ++read 131072/131072 bytes at offset 10846208 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 131072/131072 bytes at offset 11042816 ++read 131072/131072 bytes at offset 11042816 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 64 +-qemu-io> read 196608/196608 bytes at offset 536772608 ++=== IO: pattern 64 ++read 196608/196608 bytes at offset 536772608 + 192 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 196608/196608 bytes at offset 1073676288 ++read 196608/196608 bytes at offset 1073676288 + 192 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 196608/196608 bytes at offset 1610579968 ++read 196608/196608 bytes at offset 1610579968 + 192 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> No errors were found on the image. ++No errors were found on the image. + With offset 4294967296: + === IO: pattern 0 +-qemu-io> read 65536/65536 bytes at offset 4294967296 ++read 65536/65536 bytes at offset 4294967296 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4295032832 ++read 65536/65536 bytes at offset 4295032832 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4295098368 ++read 65536/65536 bytes at offset 4295098368 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4295163904 ++read 65536/65536 bytes at offset 4295163904 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4295229440 ++read 65536/65536 bytes at offset 4295229440 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4295294976 ++read 65536/65536 bytes at offset 4295294976 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4295360512 ++read 65536/65536 bytes at offset 4295360512 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4295426048 ++read 65536/65536 bytes at offset 4295426048 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4295491584 ++read 65536/65536 bytes at offset 4295491584 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4295557120 ++read 65536/65536 bytes at offset 4295557120 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4295622656 ++read 65536/65536 bytes at offset 4295622656 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4295688192 ++read 65536/65536 bytes at offset 4295688192 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4295753728 ++read 65536/65536 bytes at offset 4295753728 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4295819264 ++read 65536/65536 bytes at offset 4295819264 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4295884800 ++read 65536/65536 bytes at offset 4295884800 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4295950336 ++read 65536/65536 bytes at offset 4295950336 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4296015872 ++read 65536/65536 bytes at offset 4296015872 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4296081408 ++read 65536/65536 bytes at offset 4296081408 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4296146944 ++read 65536/65536 bytes at offset 4296146944 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4296212480 ++read 65536/65536 bytes at offset 4296212480 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4296278016 ++read 65536/65536 bytes at offset 4296278016 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4296343552 ++read 65536/65536 bytes at offset 4296343552 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4296409088 ++read 65536/65536 bytes at offset 4296409088 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4296474624 ++read 65536/65536 bytes at offset 4296474624 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4296540160 ++read 65536/65536 bytes at offset 4296540160 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4296605696 ++read 65536/65536 bytes at offset 4296605696 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4296671232 ++read 65536/65536 bytes at offset 4296671232 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4296736768 ++read 65536/65536 bytes at offset 4296736768 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4296802304 ++read 65536/65536 bytes at offset 4296802304 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4296867840 ++read 65536/65536 bytes at offset 4296867840 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4296933376 ++read 65536/65536 bytes at offset 4296933376 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4296998912 ++read 65536/65536 bytes at offset 4296998912 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4297064448 ++read 65536/65536 bytes at offset 4297064448 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4297129984 ++read 65536/65536 bytes at offset 4297129984 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4297195520 ++read 65536/65536 bytes at offset 4297195520 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4297261056 ++read 65536/65536 bytes at offset 4297261056 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 64 +-qemu-io> read 32768/32768 bytes at offset 4297359360 ++=== IO: pattern 64 ++read 32768/32768 bytes at offset 4297359360 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4297424896 ++read 32768/32768 bytes at offset 4297424896 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4297490432 ++read 32768/32768 bytes at offset 4297490432 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4297555968 ++read 32768/32768 bytes at offset 4297555968 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4297621504 ++read 32768/32768 bytes at offset 4297621504 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4297687040 ++read 32768/32768 bytes at offset 4297687040 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4297752576 ++read 32768/32768 bytes at offset 4297752576 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4297818112 ++read 32768/32768 bytes at offset 4297818112 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4297883648 ++read 32768/32768 bytes at offset 4297883648 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4297949184 ++read 32768/32768 bytes at offset 4297949184 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4298014720 ++read 32768/32768 bytes at offset 4298014720 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4298080256 ++read 32768/32768 bytes at offset 4298080256 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4298145792 ++read 32768/32768 bytes at offset 4298145792 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4298211328 ++read 32768/32768 bytes at offset 4298211328 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4298276864 ++read 32768/32768 bytes at offset 4298276864 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4298342400 ++read 32768/32768 bytes at offset 4298342400 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4298407936 ++read 32768/32768 bytes at offset 4298407936 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4298473472 ++read 32768/32768 bytes at offset 4298473472 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4298539008 ++read 32768/32768 bytes at offset 4298539008 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4298604544 ++read 32768/32768 bytes at offset 4298604544 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4298670080 ++read 32768/32768 bytes at offset 4298670080 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4298735616 ++read 32768/32768 bytes at offset 4298735616 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4298801152 ++read 32768/32768 bytes at offset 4298801152 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4298866688 ++read 32768/32768 bytes at offset 4298866688 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4298932224 ++read 32768/32768 bytes at offset 4298932224 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4298997760 ++read 32768/32768 bytes at offset 4298997760 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4299063296 ++read 32768/32768 bytes at offset 4299063296 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4299128832 ++read 32768/32768 bytes at offset 4299128832 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4299194368 ++read 32768/32768 bytes at offset 4299194368 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4299259904 ++read 32768/32768 bytes at offset 4299259904 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4299325440 ++read 32768/32768 bytes at offset 4299325440 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4299390976 ++read 32768/32768 bytes at offset 4299390976 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4299456512 ++read 32768/32768 bytes at offset 4299456512 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4299522048 ++read 32768/32768 bytes at offset 4299522048 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4299587584 ++read 32768/32768 bytes at offset 4299587584 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4299653120 ++read 32768/32768 bytes at offset 4299653120 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> read 32768/32768 bytes at offset 4299685888 ++=== IO: pattern 0 ++read 32768/32768 bytes at offset 4299685888 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4299751424 ++read 32768/32768 bytes at offset 4299751424 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4299816960 ++read 32768/32768 bytes at offset 4299816960 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4299882496 ++read 32768/32768 bytes at offset 4299882496 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4299948032 ++read 32768/32768 bytes at offset 4299948032 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4300013568 ++read 32768/32768 bytes at offset 4300013568 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4300079104 ++read 32768/32768 bytes at offset 4300079104 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4300144640 ++read 32768/32768 bytes at offset 4300144640 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4300210176 ++read 32768/32768 bytes at offset 4300210176 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4300275712 ++read 32768/32768 bytes at offset 4300275712 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4300341248 ++read 32768/32768 bytes at offset 4300341248 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4300406784 ++read 32768/32768 bytes at offset 4300406784 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4300472320 ++read 32768/32768 bytes at offset 4300472320 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4300537856 ++read 32768/32768 bytes at offset 4300537856 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4300603392 ++read 32768/32768 bytes at offset 4300603392 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4300668928 ++read 32768/32768 bytes at offset 4300668928 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4300734464 ++read 32768/32768 bytes at offset 4300734464 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4300800000 ++read 32768/32768 bytes at offset 4300800000 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4300865536 ++read 32768/32768 bytes at offset 4300865536 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4300931072 ++read 32768/32768 bytes at offset 4300931072 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4300996608 ++read 32768/32768 bytes at offset 4300996608 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4301062144 ++read 32768/32768 bytes at offset 4301062144 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4301127680 ++read 32768/32768 bytes at offset 4301127680 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4301193216 ++read 32768/32768 bytes at offset 4301193216 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4301258752 ++read 32768/32768 bytes at offset 4301258752 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4301324288 ++read 32768/32768 bytes at offset 4301324288 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4301389824 ++read 32768/32768 bytes at offset 4301389824 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4301455360 ++read 32768/32768 bytes at offset 4301455360 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4301520896 ++read 32768/32768 bytes at offset 4301520896 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4301586432 ++read 32768/32768 bytes at offset 4301586432 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4301651968 ++read 32768/32768 bytes at offset 4301651968 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4301717504 ++read 32768/32768 bytes at offset 4301717504 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4301783040 ++read 32768/32768 bytes at offset 4301783040 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4301848576 ++read 32768/32768 bytes at offset 4301848576 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4301914112 ++read 32768/32768 bytes at offset 4301914112 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4301979648 ++read 32768/32768 bytes at offset 4301979648 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 32 +-qemu-io> read 32768/32768 bytes at offset 4302061568 ++=== IO: pattern 32 ++read 32768/32768 bytes at offset 4302061568 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4302127104 ++read 32768/32768 bytes at offset 4302127104 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4302192640 ++read 32768/32768 bytes at offset 4302192640 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4302258176 ++read 32768/32768 bytes at offset 4302258176 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4302323712 ++read 32768/32768 bytes at offset 4302323712 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4302389248 ++read 32768/32768 bytes at offset 4302389248 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4302454784 ++read 32768/32768 bytes at offset 4302454784 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4302520320 ++read 32768/32768 bytes at offset 4302520320 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4302585856 ++read 32768/32768 bytes at offset 4302585856 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4302651392 ++read 32768/32768 bytes at offset 4302651392 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4302716928 ++read 32768/32768 bytes at offset 4302716928 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4302782464 ++read 32768/32768 bytes at offset 4302782464 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4302848000 ++read 32768/32768 bytes at offset 4302848000 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4302913536 ++read 32768/32768 bytes at offset 4302913536 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4302979072 ++read 32768/32768 bytes at offset 4302979072 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4303044608 ++read 32768/32768 bytes at offset 4303044608 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4303110144 ++read 32768/32768 bytes at offset 4303110144 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4303175680 ++read 32768/32768 bytes at offset 4303175680 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4303241216 ++read 32768/32768 bytes at offset 4303241216 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4303306752 ++read 32768/32768 bytes at offset 4303306752 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4303372288 ++read 32768/32768 bytes at offset 4303372288 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4303437824 ++read 32768/32768 bytes at offset 4303437824 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4303503360 ++read 32768/32768 bytes at offset 4303503360 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4303568896 ++read 32768/32768 bytes at offset 4303568896 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4303634432 ++read 32768/32768 bytes at offset 4303634432 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4303699968 ++read 32768/32768 bytes at offset 4303699968 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4303765504 ++read 32768/32768 bytes at offset 4303765504 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4303831040 ++read 32768/32768 bytes at offset 4303831040 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4303896576 ++read 32768/32768 bytes at offset 4303896576 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4303962112 ++read 32768/32768 bytes at offset 4303962112 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4304027648 ++read 32768/32768 bytes at offset 4304027648 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4304093184 ++read 32768/32768 bytes at offset 4304093184 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4304158720 ++read 32768/32768 bytes at offset 4304158720 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4304224256 ++read 32768/32768 bytes at offset 4304224256 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4304289792 ++read 32768/32768 bytes at offset 4304289792 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4304355328 ++read 32768/32768 bytes at offset 4304355328 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 64 +-qemu-io> read 131072/131072 bytes at offset 4304437248 ++=== IO: pattern 64 ++read 131072/131072 bytes at offset 4304437248 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 131072/131072 bytes at offset 4304633856 ++read 131072/131072 bytes at offset 4304633856 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 131072/131072 bytes at offset 4304830464 ++read 131072/131072 bytes at offset 4304830464 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 131072/131072 bytes at offset 4305027072 ++read 131072/131072 bytes at offset 4305027072 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 131072/131072 bytes at offset 4305223680 ++read 131072/131072 bytes at offset 4305223680 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 131072/131072 bytes at offset 4305420288 ++read 131072/131072 bytes at offset 4305420288 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 131072/131072 bytes at offset 4305616896 ++read 131072/131072 bytes at offset 4305616896 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 131072/131072 bytes at offset 4305813504 ++read 131072/131072 bytes at offset 4305813504 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 131072/131072 bytes at offset 4306010112 ++read 131072/131072 bytes at offset 4306010112 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 64 +-qemu-io> read 196608/196608 bytes at offset 4831739904 ++=== IO: pattern 64 ++read 196608/196608 bytes at offset 4831739904 + 192 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 196608/196608 bytes at offset 5368643584 ++read 196608/196608 bytes at offset 5368643584 + 192 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 196608/196608 bytes at offset 5905547264 ++read 196608/196608 bytes at offset 5905547264 + 192 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> read 65536/65536 bytes at offset 4294967296 ++=== IO: pattern 0 ++read 65536/65536 bytes at offset 4294967296 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4295032832 ++read 65536/65536 bytes at offset 4295032832 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4295098368 ++read 65536/65536 bytes at offset 4295098368 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4295163904 ++read 65536/65536 bytes at offset 4295163904 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4295229440 ++read 65536/65536 bytes at offset 4295229440 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4295294976 ++read 65536/65536 bytes at offset 4295294976 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4295360512 ++read 65536/65536 bytes at offset 4295360512 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4295426048 ++read 65536/65536 bytes at offset 4295426048 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4295491584 ++read 65536/65536 bytes at offset 4295491584 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4295557120 ++read 65536/65536 bytes at offset 4295557120 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4295622656 ++read 65536/65536 bytes at offset 4295622656 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4295688192 ++read 65536/65536 bytes at offset 4295688192 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4295753728 ++read 65536/65536 bytes at offset 4295753728 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4295819264 ++read 65536/65536 bytes at offset 4295819264 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4295884800 ++read 65536/65536 bytes at offset 4295884800 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4295950336 ++read 65536/65536 bytes at offset 4295950336 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4296015872 ++read 65536/65536 bytes at offset 4296015872 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4296081408 ++read 65536/65536 bytes at offset 4296081408 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4296146944 ++read 65536/65536 bytes at offset 4296146944 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4296212480 ++read 65536/65536 bytes at offset 4296212480 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4296278016 ++read 65536/65536 bytes at offset 4296278016 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4296343552 ++read 65536/65536 bytes at offset 4296343552 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4296409088 ++read 65536/65536 bytes at offset 4296409088 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4296474624 ++read 65536/65536 bytes at offset 4296474624 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4296540160 ++read 65536/65536 bytes at offset 4296540160 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4296605696 ++read 65536/65536 bytes at offset 4296605696 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4296671232 ++read 65536/65536 bytes at offset 4296671232 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4296736768 ++read 65536/65536 bytes at offset 4296736768 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4296802304 ++read 65536/65536 bytes at offset 4296802304 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4296867840 ++read 65536/65536 bytes at offset 4296867840 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4296933376 ++read 65536/65536 bytes at offset 4296933376 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4296998912 ++read 65536/65536 bytes at offset 4296998912 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4297064448 ++read 65536/65536 bytes at offset 4297064448 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4297129984 ++read 65536/65536 bytes at offset 4297129984 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4297195520 ++read 65536/65536 bytes at offset 4297195520 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4297261056 ++read 65536/65536 bytes at offset 4297261056 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 64 +-qemu-io> read 32768/32768 bytes at offset 4297359360 ++=== IO: pattern 64 ++read 32768/32768 bytes at offset 4297359360 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4297424896 ++read 32768/32768 bytes at offset 4297424896 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4297490432 ++read 32768/32768 bytes at offset 4297490432 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4297555968 ++read 32768/32768 bytes at offset 4297555968 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4297621504 ++read 32768/32768 bytes at offset 4297621504 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4297687040 ++read 32768/32768 bytes at offset 4297687040 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4297752576 ++read 32768/32768 bytes at offset 4297752576 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4297818112 ++read 32768/32768 bytes at offset 4297818112 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4297883648 ++read 32768/32768 bytes at offset 4297883648 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4297949184 ++read 32768/32768 bytes at offset 4297949184 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4298014720 ++read 32768/32768 bytes at offset 4298014720 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4298080256 ++read 32768/32768 bytes at offset 4298080256 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4298145792 ++read 32768/32768 bytes at offset 4298145792 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4298211328 ++read 32768/32768 bytes at offset 4298211328 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4298276864 ++read 32768/32768 bytes at offset 4298276864 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4298342400 ++read 32768/32768 bytes at offset 4298342400 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4298407936 ++read 32768/32768 bytes at offset 4298407936 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4298473472 ++read 32768/32768 bytes at offset 4298473472 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4298539008 ++read 32768/32768 bytes at offset 4298539008 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4298604544 ++read 32768/32768 bytes at offset 4298604544 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4298670080 ++read 32768/32768 bytes at offset 4298670080 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4298735616 ++read 32768/32768 bytes at offset 4298735616 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4298801152 ++read 32768/32768 bytes at offset 4298801152 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4298866688 ++read 32768/32768 bytes at offset 4298866688 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4298932224 ++read 32768/32768 bytes at offset 4298932224 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4298997760 ++read 32768/32768 bytes at offset 4298997760 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4299063296 ++read 32768/32768 bytes at offset 4299063296 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4299128832 ++read 32768/32768 bytes at offset 4299128832 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4299194368 ++read 32768/32768 bytes at offset 4299194368 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4299259904 ++read 32768/32768 bytes at offset 4299259904 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4299325440 ++read 32768/32768 bytes at offset 4299325440 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4299390976 ++read 32768/32768 bytes at offset 4299390976 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4299456512 ++read 32768/32768 bytes at offset 4299456512 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4299522048 ++read 32768/32768 bytes at offset 4299522048 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4299587584 ++read 32768/32768 bytes at offset 4299587584 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4299653120 ++read 32768/32768 bytes at offset 4299653120 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> read 32768/32768 bytes at offset 4299685888 ++=== IO: pattern 0 ++read 32768/32768 bytes at offset 4299685888 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4299751424 ++read 32768/32768 bytes at offset 4299751424 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4299816960 ++read 32768/32768 bytes at offset 4299816960 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4299882496 ++read 32768/32768 bytes at offset 4299882496 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4299948032 ++read 32768/32768 bytes at offset 4299948032 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4300013568 ++read 32768/32768 bytes at offset 4300013568 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4300079104 ++read 32768/32768 bytes at offset 4300079104 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4300144640 ++read 32768/32768 bytes at offset 4300144640 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4300210176 ++read 32768/32768 bytes at offset 4300210176 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4300275712 ++read 32768/32768 bytes at offset 4300275712 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4300341248 ++read 32768/32768 bytes at offset 4300341248 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4300406784 ++read 32768/32768 bytes at offset 4300406784 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4300472320 ++read 32768/32768 bytes at offset 4300472320 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4300537856 ++read 32768/32768 bytes at offset 4300537856 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4300603392 ++read 32768/32768 bytes at offset 4300603392 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4300668928 ++read 32768/32768 bytes at offset 4300668928 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4300734464 ++read 32768/32768 bytes at offset 4300734464 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4300800000 ++read 32768/32768 bytes at offset 4300800000 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4300865536 ++read 32768/32768 bytes at offset 4300865536 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4300931072 ++read 32768/32768 bytes at offset 4300931072 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4300996608 ++read 32768/32768 bytes at offset 4300996608 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4301062144 ++read 32768/32768 bytes at offset 4301062144 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4301127680 ++read 32768/32768 bytes at offset 4301127680 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4301193216 ++read 32768/32768 bytes at offset 4301193216 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4301258752 ++read 32768/32768 bytes at offset 4301258752 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4301324288 ++read 32768/32768 bytes at offset 4301324288 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4301389824 ++read 32768/32768 bytes at offset 4301389824 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4301455360 ++read 32768/32768 bytes at offset 4301455360 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4301520896 ++read 32768/32768 bytes at offset 4301520896 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4301586432 ++read 32768/32768 bytes at offset 4301586432 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4301651968 ++read 32768/32768 bytes at offset 4301651968 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4301717504 ++read 32768/32768 bytes at offset 4301717504 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4301783040 ++read 32768/32768 bytes at offset 4301783040 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4301848576 ++read 32768/32768 bytes at offset 4301848576 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4301914112 ++read 32768/32768 bytes at offset 4301914112 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4301979648 ++read 32768/32768 bytes at offset 4301979648 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 32 +-qemu-io> read 32768/32768 bytes at offset 4302061568 ++=== IO: pattern 32 ++read 32768/32768 bytes at offset 4302061568 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4302127104 ++read 32768/32768 bytes at offset 4302127104 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4302192640 ++read 32768/32768 bytes at offset 4302192640 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4302258176 ++read 32768/32768 bytes at offset 4302258176 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4302323712 ++read 32768/32768 bytes at offset 4302323712 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4302389248 ++read 32768/32768 bytes at offset 4302389248 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4302454784 ++read 32768/32768 bytes at offset 4302454784 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4302520320 ++read 32768/32768 bytes at offset 4302520320 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4302585856 ++read 32768/32768 bytes at offset 4302585856 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4302651392 ++read 32768/32768 bytes at offset 4302651392 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4302716928 ++read 32768/32768 bytes at offset 4302716928 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4302782464 ++read 32768/32768 bytes at offset 4302782464 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4302848000 ++read 32768/32768 bytes at offset 4302848000 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4302913536 ++read 32768/32768 bytes at offset 4302913536 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4302979072 ++read 32768/32768 bytes at offset 4302979072 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4303044608 ++read 32768/32768 bytes at offset 4303044608 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4303110144 ++read 32768/32768 bytes at offset 4303110144 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4303175680 ++read 32768/32768 bytes at offset 4303175680 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4303241216 ++read 32768/32768 bytes at offset 4303241216 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4303306752 ++read 32768/32768 bytes at offset 4303306752 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4303372288 ++read 32768/32768 bytes at offset 4303372288 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4303437824 ++read 32768/32768 bytes at offset 4303437824 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4303503360 ++read 32768/32768 bytes at offset 4303503360 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4303568896 ++read 32768/32768 bytes at offset 4303568896 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4303634432 ++read 32768/32768 bytes at offset 4303634432 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4303699968 ++read 32768/32768 bytes at offset 4303699968 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4303765504 ++read 32768/32768 bytes at offset 4303765504 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4303831040 ++read 32768/32768 bytes at offset 4303831040 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4303896576 ++read 32768/32768 bytes at offset 4303896576 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4303962112 ++read 32768/32768 bytes at offset 4303962112 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4304027648 ++read 32768/32768 bytes at offset 4304027648 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4304093184 ++read 32768/32768 bytes at offset 4304093184 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4304158720 ++read 32768/32768 bytes at offset 4304158720 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4304224256 ++read 32768/32768 bytes at offset 4304224256 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4304289792 ++read 32768/32768 bytes at offset 4304289792 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4304355328 ++read 32768/32768 bytes at offset 4304355328 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 64 +-qemu-io> read 131072/131072 bytes at offset 4304437248 ++=== IO: pattern 64 ++read 131072/131072 bytes at offset 4304437248 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 131072/131072 bytes at offset 4304633856 ++read 131072/131072 bytes at offset 4304633856 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 131072/131072 bytes at offset 4304830464 ++read 131072/131072 bytes at offset 4304830464 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 131072/131072 bytes at offset 4305027072 ++read 131072/131072 bytes at offset 4305027072 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 131072/131072 bytes at offset 4305223680 ++read 131072/131072 bytes at offset 4305223680 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 131072/131072 bytes at offset 4305420288 ++read 131072/131072 bytes at offset 4305420288 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 131072/131072 bytes at offset 4305616896 ++read 131072/131072 bytes at offset 4305616896 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 131072/131072 bytes at offset 4305813504 ++read 131072/131072 bytes at offset 4305813504 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 131072/131072 bytes at offset 4306010112 ++read 131072/131072 bytes at offset 4306010112 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 64 +-qemu-io> read 196608/196608 bytes at offset 4831739904 ++=== IO: pattern 64 ++read 196608/196608 bytes at offset 4831739904 + 192 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 196608/196608 bytes at offset 5368643584 ++read 196608/196608 bytes at offset 5368643584 + 192 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 196608/196608 bytes at offset 5905547264 ++read 196608/196608 bytes at offset 5905547264 + 192 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> No errors were found on the image. ++No errors were found on the image. + Testing compressed image with odd offsets + + With offset 512: + === IO: pattern 1 +-qemu-io> wrote 65536/65536 bytes at offset 512 ++wrote 65536/65536 bytes at offset 512 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 66048 ++wrote 65536/65536 bytes at offset 66048 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 131584 ++wrote 65536/65536 bytes at offset 131584 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 197120 ++wrote 65536/65536 bytes at offset 197120 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 262656 ++wrote 65536/65536 bytes at offset 262656 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 328192 ++wrote 65536/65536 bytes at offset 328192 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 393728 ++wrote 65536/65536 bytes at offset 393728 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 459264 ++wrote 65536/65536 bytes at offset 459264 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 524800 ++wrote 65536/65536 bytes at offset 524800 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 590336 ++wrote 65536/65536 bytes at offset 590336 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 655872 ++wrote 65536/65536 bytes at offset 655872 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 721408 ++wrote 65536/65536 bytes at offset 721408 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 786944 ++wrote 65536/65536 bytes at offset 786944 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 852480 ++wrote 65536/65536 bytes at offset 852480 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 918016 ++wrote 65536/65536 bytes at offset 918016 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 983552 ++wrote 65536/65536 bytes at offset 983552 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 1049088 ++wrote 65536/65536 bytes at offset 1049088 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 1114624 ++wrote 65536/65536 bytes at offset 1114624 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 1180160 ++wrote 65536/65536 bytes at offset 1180160 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 1245696 ++wrote 65536/65536 bytes at offset 1245696 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 1311232 ++wrote 65536/65536 bytes at offset 1311232 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 1376768 ++wrote 65536/65536 bytes at offset 1376768 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 1442304 ++wrote 65536/65536 bytes at offset 1442304 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 1507840 ++wrote 65536/65536 bytes at offset 1507840 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 1573376 ++wrote 65536/65536 bytes at offset 1573376 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 1638912 ++wrote 65536/65536 bytes at offset 1638912 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 1704448 ++wrote 65536/65536 bytes at offset 1704448 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 1769984 ++wrote 65536/65536 bytes at offset 1769984 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 1835520 ++wrote 65536/65536 bytes at offset 1835520 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 1901056 ++wrote 65536/65536 bytes at offset 1901056 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 1966592 ++wrote 65536/65536 bytes at offset 1966592 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 2032128 ++wrote 65536/65536 bytes at offset 2032128 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 2097664 ++wrote 65536/65536 bytes at offset 2097664 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 2163200 ++wrote 65536/65536 bytes at offset 2163200 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 2228736 ++wrote 65536/65536 bytes at offset 2228736 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 2294272 ++wrote 65536/65536 bytes at offset 2294272 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 65 +-qemu-io> wrote 32768/32768 bytes at offset 2392576 ++=== IO: pattern 65 ++wrote 32768/32768 bytes at offset 2392576 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 2458112 ++wrote 32768/32768 bytes at offset 2458112 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 2523648 ++wrote 32768/32768 bytes at offset 2523648 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 2589184 ++wrote 32768/32768 bytes at offset 2589184 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 2654720 ++wrote 32768/32768 bytes at offset 2654720 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 2720256 ++wrote 32768/32768 bytes at offset 2720256 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 2785792 ++wrote 32768/32768 bytes at offset 2785792 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 2851328 ++wrote 32768/32768 bytes at offset 2851328 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 2916864 ++wrote 32768/32768 bytes at offset 2916864 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 2982400 ++wrote 32768/32768 bytes at offset 2982400 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 3047936 ++wrote 32768/32768 bytes at offset 3047936 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 3113472 ++wrote 32768/32768 bytes at offset 3113472 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 3179008 ++wrote 32768/32768 bytes at offset 3179008 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 3244544 ++wrote 32768/32768 bytes at offset 3244544 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 3310080 ++wrote 32768/32768 bytes at offset 3310080 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 3375616 ++wrote 32768/32768 bytes at offset 3375616 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 3441152 ++wrote 32768/32768 bytes at offset 3441152 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 3506688 ++wrote 32768/32768 bytes at offset 3506688 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 3572224 ++wrote 32768/32768 bytes at offset 3572224 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 3637760 ++wrote 32768/32768 bytes at offset 3637760 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 3703296 ++wrote 32768/32768 bytes at offset 3703296 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 3768832 ++wrote 32768/32768 bytes at offset 3768832 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 3834368 ++wrote 32768/32768 bytes at offset 3834368 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 3899904 ++wrote 32768/32768 bytes at offset 3899904 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 3965440 ++wrote 32768/32768 bytes at offset 3965440 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4030976 ++wrote 32768/32768 bytes at offset 4030976 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4096512 ++wrote 32768/32768 bytes at offset 4096512 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4162048 ++wrote 32768/32768 bytes at offset 4162048 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4227584 ++wrote 32768/32768 bytes at offset 4227584 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4293120 ++wrote 32768/32768 bytes at offset 4293120 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4358656 ++wrote 32768/32768 bytes at offset 4358656 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4424192 ++wrote 32768/32768 bytes at offset 4424192 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4489728 ++wrote 32768/32768 bytes at offset 4489728 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4555264 ++wrote 32768/32768 bytes at offset 4555264 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4620800 ++wrote 32768/32768 bytes at offset 4620800 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4686336 ++wrote 32768/32768 bytes at offset 4686336 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 1 +-qemu-io> wrote 32768/32768 bytes at offset 4719104 ++=== IO: pattern 1 ++wrote 32768/32768 bytes at offset 4719104 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4784640 ++wrote 32768/32768 bytes at offset 4784640 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4850176 ++wrote 32768/32768 bytes at offset 4850176 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4915712 ++wrote 32768/32768 bytes at offset 4915712 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4981248 ++wrote 32768/32768 bytes at offset 4981248 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 5046784 ++wrote 32768/32768 bytes at offset 5046784 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 5112320 ++wrote 32768/32768 bytes at offset 5112320 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 5177856 ++wrote 32768/32768 bytes at offset 5177856 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 5243392 ++wrote 32768/32768 bytes at offset 5243392 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 5308928 ++wrote 32768/32768 bytes at offset 5308928 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 5374464 ++wrote 32768/32768 bytes at offset 5374464 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 5440000 ++wrote 32768/32768 bytes at offset 5440000 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 5505536 ++wrote 32768/32768 bytes at offset 5505536 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 5571072 ++wrote 32768/32768 bytes at offset 5571072 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 5636608 ++wrote 32768/32768 bytes at offset 5636608 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 5702144 ++wrote 32768/32768 bytes at offset 5702144 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 5767680 ++wrote 32768/32768 bytes at offset 5767680 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 5833216 ++wrote 32768/32768 bytes at offset 5833216 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 5898752 ++wrote 32768/32768 bytes at offset 5898752 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 5964288 ++wrote 32768/32768 bytes at offset 5964288 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 6029824 ++wrote 32768/32768 bytes at offset 6029824 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 6095360 ++wrote 32768/32768 bytes at offset 6095360 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 6160896 ++wrote 32768/32768 bytes at offset 6160896 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 6226432 ++wrote 32768/32768 bytes at offset 6226432 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 6291968 ++wrote 32768/32768 bytes at offset 6291968 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 6357504 ++wrote 32768/32768 bytes at offset 6357504 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 6423040 ++wrote 32768/32768 bytes at offset 6423040 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 6488576 ++wrote 32768/32768 bytes at offset 6488576 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 6554112 ++wrote 32768/32768 bytes at offset 6554112 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 6619648 ++wrote 32768/32768 bytes at offset 6619648 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 6685184 ++wrote 32768/32768 bytes at offset 6685184 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 6750720 ++wrote 32768/32768 bytes at offset 6750720 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 6816256 ++wrote 32768/32768 bytes at offset 6816256 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 6881792 ++wrote 32768/32768 bytes at offset 6881792 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 6947328 ++wrote 32768/32768 bytes at offset 6947328 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 7012864 ++wrote 32768/32768 bytes at offset 7012864 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 33 +-qemu-io> wrote 32768/32768 bytes at offset 7094784 ++=== IO: pattern 33 ++wrote 32768/32768 bytes at offset 7094784 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 7160320 ++wrote 32768/32768 bytes at offset 7160320 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 7225856 ++wrote 32768/32768 bytes at offset 7225856 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 7291392 ++wrote 32768/32768 bytes at offset 7291392 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 7356928 ++wrote 32768/32768 bytes at offset 7356928 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 7422464 ++wrote 32768/32768 bytes at offset 7422464 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 7488000 ++wrote 32768/32768 bytes at offset 7488000 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 7553536 ++wrote 32768/32768 bytes at offset 7553536 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 7619072 ++wrote 32768/32768 bytes at offset 7619072 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 7684608 ++wrote 32768/32768 bytes at offset 7684608 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 7750144 ++wrote 32768/32768 bytes at offset 7750144 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 7815680 ++wrote 32768/32768 bytes at offset 7815680 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 7881216 ++wrote 32768/32768 bytes at offset 7881216 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 7946752 ++wrote 32768/32768 bytes at offset 7946752 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 8012288 ++wrote 32768/32768 bytes at offset 8012288 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 8077824 ++wrote 32768/32768 bytes at offset 8077824 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 8143360 ++wrote 32768/32768 bytes at offset 8143360 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 8208896 ++wrote 32768/32768 bytes at offset 8208896 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 8274432 ++wrote 32768/32768 bytes at offset 8274432 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 8339968 ++wrote 32768/32768 bytes at offset 8339968 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 8405504 ++wrote 32768/32768 bytes at offset 8405504 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 8471040 ++wrote 32768/32768 bytes at offset 8471040 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 8536576 ++wrote 32768/32768 bytes at offset 8536576 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 8602112 ++wrote 32768/32768 bytes at offset 8602112 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 8667648 ++wrote 32768/32768 bytes at offset 8667648 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 8733184 ++wrote 32768/32768 bytes at offset 8733184 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 8798720 ++wrote 32768/32768 bytes at offset 8798720 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 8864256 ++wrote 32768/32768 bytes at offset 8864256 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 8929792 ++wrote 32768/32768 bytes at offset 8929792 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 8995328 ++wrote 32768/32768 bytes at offset 8995328 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 9060864 ++wrote 32768/32768 bytes at offset 9060864 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 9126400 ++wrote 32768/32768 bytes at offset 9126400 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 9191936 ++wrote 32768/32768 bytes at offset 9191936 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 9257472 ++wrote 32768/32768 bytes at offset 9257472 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 9323008 ++wrote 32768/32768 bytes at offset 9323008 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 9388544 ++wrote 32768/32768 bytes at offset 9388544 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 65 +-qemu-io> wrote 131072/131072 bytes at offset 9470464 ++=== IO: pattern 65 ++wrote 131072/131072 bytes at offset 9470464 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 131072/131072 bytes at offset 9667072 ++wrote 131072/131072 bytes at offset 9667072 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 131072/131072 bytes at offset 9863680 ++wrote 131072/131072 bytes at offset 9863680 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 131072/131072 bytes at offset 10060288 ++wrote 131072/131072 bytes at offset 10060288 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 131072/131072 bytes at offset 10256896 ++wrote 131072/131072 bytes at offset 10256896 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 131072/131072 bytes at offset 10453504 ++wrote 131072/131072 bytes at offset 10453504 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 131072/131072 bytes at offset 10650112 ++wrote 131072/131072 bytes at offset 10650112 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 131072/131072 bytes at offset 10846720 ++wrote 131072/131072 bytes at offset 10846720 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 131072/131072 bytes at offset 11043328 ++wrote 131072/131072 bytes at offset 11043328 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 64 +-qemu-io> wrote 196608/196608 bytes at offset 536772608 ++=== IO: pattern 64 ++wrote 196608/196608 bytes at offset 536772608 + 192 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 196608/196608 bytes at offset 1073676288 ++wrote 196608/196608 bytes at offset 1073676288 + 192 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 196608/196608 bytes at offset 1610579968 ++wrote 196608/196608 bytes at offset 1610579968 + 192 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 1 +-qemu-io> read 65536/65536 bytes at offset 512 ++=== IO: pattern 1 ++read 65536/65536 bytes at offset 512 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 66048 ++read 65536/65536 bytes at offset 66048 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 131584 ++read 65536/65536 bytes at offset 131584 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 197120 ++read 65536/65536 bytes at offset 197120 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 262656 ++read 65536/65536 bytes at offset 262656 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 328192 ++read 65536/65536 bytes at offset 328192 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 393728 ++read 65536/65536 bytes at offset 393728 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 459264 ++read 65536/65536 bytes at offset 459264 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 524800 ++read 65536/65536 bytes at offset 524800 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 590336 ++read 65536/65536 bytes at offset 590336 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 655872 ++read 65536/65536 bytes at offset 655872 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 721408 ++read 65536/65536 bytes at offset 721408 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 786944 ++read 65536/65536 bytes at offset 786944 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 852480 ++read 65536/65536 bytes at offset 852480 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 918016 ++read 65536/65536 bytes at offset 918016 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 983552 ++read 65536/65536 bytes at offset 983552 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 1049088 ++read 65536/65536 bytes at offset 1049088 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 1114624 ++read 65536/65536 bytes at offset 1114624 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 1180160 ++read 65536/65536 bytes at offset 1180160 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 1245696 ++read 65536/65536 bytes at offset 1245696 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 1311232 ++read 65536/65536 bytes at offset 1311232 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 1376768 ++read 65536/65536 bytes at offset 1376768 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 1442304 ++read 65536/65536 bytes at offset 1442304 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 1507840 ++read 65536/65536 bytes at offset 1507840 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 1573376 ++read 65536/65536 bytes at offset 1573376 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 1638912 ++read 65536/65536 bytes at offset 1638912 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 1704448 ++read 65536/65536 bytes at offset 1704448 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 1769984 ++read 65536/65536 bytes at offset 1769984 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 1835520 ++read 65536/65536 bytes at offset 1835520 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 1901056 ++read 65536/65536 bytes at offset 1901056 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 1966592 ++read 65536/65536 bytes at offset 1966592 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 2032128 ++read 65536/65536 bytes at offset 2032128 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 2097664 ++read 65536/65536 bytes at offset 2097664 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 2163200 ++read 65536/65536 bytes at offset 2163200 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 2228736 ++read 65536/65536 bytes at offset 2228736 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 2294272 ++read 65536/65536 bytes at offset 2294272 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 65 +-qemu-io> read 32768/32768 bytes at offset 2392576 ++=== IO: pattern 65 ++read 32768/32768 bytes at offset 2392576 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 2458112 ++read 32768/32768 bytes at offset 2458112 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 2523648 ++read 32768/32768 bytes at offset 2523648 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 2589184 ++read 32768/32768 bytes at offset 2589184 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 2654720 ++read 32768/32768 bytes at offset 2654720 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 2720256 ++read 32768/32768 bytes at offset 2720256 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 2785792 ++read 32768/32768 bytes at offset 2785792 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 2851328 ++read 32768/32768 bytes at offset 2851328 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 2916864 ++read 32768/32768 bytes at offset 2916864 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 2982400 ++read 32768/32768 bytes at offset 2982400 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 3047936 ++read 32768/32768 bytes at offset 3047936 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 3113472 ++read 32768/32768 bytes at offset 3113472 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 3179008 ++read 32768/32768 bytes at offset 3179008 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 3244544 ++read 32768/32768 bytes at offset 3244544 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 3310080 ++read 32768/32768 bytes at offset 3310080 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 3375616 ++read 32768/32768 bytes at offset 3375616 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 3441152 ++read 32768/32768 bytes at offset 3441152 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 3506688 ++read 32768/32768 bytes at offset 3506688 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 3572224 ++read 32768/32768 bytes at offset 3572224 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 3637760 ++read 32768/32768 bytes at offset 3637760 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 3703296 ++read 32768/32768 bytes at offset 3703296 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 3768832 ++read 32768/32768 bytes at offset 3768832 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 3834368 ++read 32768/32768 bytes at offset 3834368 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 3899904 ++read 32768/32768 bytes at offset 3899904 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 3965440 ++read 32768/32768 bytes at offset 3965440 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4030976 ++read 32768/32768 bytes at offset 4030976 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4096512 ++read 32768/32768 bytes at offset 4096512 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4162048 ++read 32768/32768 bytes at offset 4162048 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4227584 ++read 32768/32768 bytes at offset 4227584 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4293120 ++read 32768/32768 bytes at offset 4293120 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4358656 ++read 32768/32768 bytes at offset 4358656 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4424192 ++read 32768/32768 bytes at offset 4424192 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4489728 ++read 32768/32768 bytes at offset 4489728 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4555264 ++read 32768/32768 bytes at offset 4555264 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4620800 ++read 32768/32768 bytes at offset 4620800 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4686336 ++read 32768/32768 bytes at offset 4686336 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 1 +-qemu-io> read 32768/32768 bytes at offset 4719104 ++=== IO: pattern 1 ++read 32768/32768 bytes at offset 4719104 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4784640 ++read 32768/32768 bytes at offset 4784640 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4850176 ++read 32768/32768 bytes at offset 4850176 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4915712 ++read 32768/32768 bytes at offset 4915712 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4981248 ++read 32768/32768 bytes at offset 4981248 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 5046784 ++read 32768/32768 bytes at offset 5046784 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 5112320 ++read 32768/32768 bytes at offset 5112320 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 5177856 ++read 32768/32768 bytes at offset 5177856 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 5243392 ++read 32768/32768 bytes at offset 5243392 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 5308928 ++read 32768/32768 bytes at offset 5308928 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 5374464 ++read 32768/32768 bytes at offset 5374464 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 5440000 ++read 32768/32768 bytes at offset 5440000 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 5505536 ++read 32768/32768 bytes at offset 5505536 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 5571072 ++read 32768/32768 bytes at offset 5571072 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 5636608 ++read 32768/32768 bytes at offset 5636608 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 5702144 ++read 32768/32768 bytes at offset 5702144 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 5767680 ++read 32768/32768 bytes at offset 5767680 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 5833216 ++read 32768/32768 bytes at offset 5833216 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 5898752 ++read 32768/32768 bytes at offset 5898752 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 5964288 ++read 32768/32768 bytes at offset 5964288 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 6029824 ++read 32768/32768 bytes at offset 6029824 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 6095360 ++read 32768/32768 bytes at offset 6095360 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 6160896 ++read 32768/32768 bytes at offset 6160896 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 6226432 ++read 32768/32768 bytes at offset 6226432 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 6291968 ++read 32768/32768 bytes at offset 6291968 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 6357504 ++read 32768/32768 bytes at offset 6357504 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 6423040 ++read 32768/32768 bytes at offset 6423040 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 6488576 ++read 32768/32768 bytes at offset 6488576 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 6554112 ++read 32768/32768 bytes at offset 6554112 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 6619648 ++read 32768/32768 bytes at offset 6619648 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 6685184 ++read 32768/32768 bytes at offset 6685184 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 6750720 ++read 32768/32768 bytes at offset 6750720 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 6816256 ++read 32768/32768 bytes at offset 6816256 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 6881792 ++read 32768/32768 bytes at offset 6881792 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 6947328 ++read 32768/32768 bytes at offset 6947328 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 7012864 ++read 32768/32768 bytes at offset 7012864 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 33 +-qemu-io> read 32768/32768 bytes at offset 7094784 ++=== IO: pattern 33 ++read 32768/32768 bytes at offset 7094784 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 7160320 ++read 32768/32768 bytes at offset 7160320 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 7225856 ++read 32768/32768 bytes at offset 7225856 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 7291392 ++read 32768/32768 bytes at offset 7291392 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 7356928 ++read 32768/32768 bytes at offset 7356928 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 7422464 ++read 32768/32768 bytes at offset 7422464 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 7488000 ++read 32768/32768 bytes at offset 7488000 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 7553536 ++read 32768/32768 bytes at offset 7553536 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 7619072 ++read 32768/32768 bytes at offset 7619072 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 7684608 ++read 32768/32768 bytes at offset 7684608 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 7750144 ++read 32768/32768 bytes at offset 7750144 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 7815680 ++read 32768/32768 bytes at offset 7815680 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 7881216 ++read 32768/32768 bytes at offset 7881216 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 7946752 ++read 32768/32768 bytes at offset 7946752 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 8012288 ++read 32768/32768 bytes at offset 8012288 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 8077824 ++read 32768/32768 bytes at offset 8077824 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 8143360 ++read 32768/32768 bytes at offset 8143360 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 8208896 ++read 32768/32768 bytes at offset 8208896 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 8274432 ++read 32768/32768 bytes at offset 8274432 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 8339968 ++read 32768/32768 bytes at offset 8339968 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 8405504 ++read 32768/32768 bytes at offset 8405504 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 8471040 ++read 32768/32768 bytes at offset 8471040 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 8536576 ++read 32768/32768 bytes at offset 8536576 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 8602112 ++read 32768/32768 bytes at offset 8602112 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 8667648 ++read 32768/32768 bytes at offset 8667648 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 8733184 ++read 32768/32768 bytes at offset 8733184 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 8798720 ++read 32768/32768 bytes at offset 8798720 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 8864256 ++read 32768/32768 bytes at offset 8864256 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 8929792 ++read 32768/32768 bytes at offset 8929792 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 8995328 ++read 32768/32768 bytes at offset 8995328 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 9060864 ++read 32768/32768 bytes at offset 9060864 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 9126400 ++read 32768/32768 bytes at offset 9126400 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 9191936 ++read 32768/32768 bytes at offset 9191936 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 9257472 ++read 32768/32768 bytes at offset 9257472 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 9323008 ++read 32768/32768 bytes at offset 9323008 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 9388544 ++read 32768/32768 bytes at offset 9388544 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 65 +-qemu-io> read 131072/131072 bytes at offset 9470464 ++=== IO: pattern 65 ++read 131072/131072 bytes at offset 9470464 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 131072/131072 bytes at offset 9667072 ++read 131072/131072 bytes at offset 9667072 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 131072/131072 bytes at offset 9863680 ++read 131072/131072 bytes at offset 9863680 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 131072/131072 bytes at offset 10060288 ++read 131072/131072 bytes at offset 10060288 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 131072/131072 bytes at offset 10256896 ++read 131072/131072 bytes at offset 10256896 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 131072/131072 bytes at offset 10453504 ++read 131072/131072 bytes at offset 10453504 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 131072/131072 bytes at offset 10650112 ++read 131072/131072 bytes at offset 10650112 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 131072/131072 bytes at offset 10846720 ++read 131072/131072 bytes at offset 10846720 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 131072/131072 bytes at offset 11043328 ++read 131072/131072 bytes at offset 11043328 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 64 +-qemu-io> read 196608/196608 bytes at offset 536772608 ++=== IO: pattern 64 ++read 196608/196608 bytes at offset 536772608 + 192 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 196608/196608 bytes at offset 1073676288 ++read 196608/196608 bytes at offset 1073676288 + 192 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 196608/196608 bytes at offset 1610579968 ++read 196608/196608 bytes at offset 1610579968 + 192 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 1 +-qemu-io> wrote 65536/65536 bytes at offset 512 ++=== IO: pattern 1 ++wrote 65536/65536 bytes at offset 512 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 66048 ++wrote 65536/65536 bytes at offset 66048 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 131584 ++wrote 65536/65536 bytes at offset 131584 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 197120 ++wrote 65536/65536 bytes at offset 197120 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 262656 ++wrote 65536/65536 bytes at offset 262656 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 328192 ++wrote 65536/65536 bytes at offset 328192 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 393728 ++wrote 65536/65536 bytes at offset 393728 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 459264 ++wrote 65536/65536 bytes at offset 459264 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 524800 ++wrote 65536/65536 bytes at offset 524800 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 590336 ++wrote 65536/65536 bytes at offset 590336 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 655872 ++wrote 65536/65536 bytes at offset 655872 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 721408 ++wrote 65536/65536 bytes at offset 721408 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 786944 ++wrote 65536/65536 bytes at offset 786944 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 852480 ++wrote 65536/65536 bytes at offset 852480 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 918016 ++wrote 65536/65536 bytes at offset 918016 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 983552 ++wrote 65536/65536 bytes at offset 983552 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 1049088 ++wrote 65536/65536 bytes at offset 1049088 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 1114624 ++wrote 65536/65536 bytes at offset 1114624 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 1180160 ++wrote 65536/65536 bytes at offset 1180160 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 1245696 ++wrote 65536/65536 bytes at offset 1245696 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 1311232 ++wrote 65536/65536 bytes at offset 1311232 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 1376768 ++wrote 65536/65536 bytes at offset 1376768 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 1442304 ++wrote 65536/65536 bytes at offset 1442304 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 1507840 ++wrote 65536/65536 bytes at offset 1507840 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 1573376 ++wrote 65536/65536 bytes at offset 1573376 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 1638912 ++wrote 65536/65536 bytes at offset 1638912 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 1704448 ++wrote 65536/65536 bytes at offset 1704448 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 1769984 ++wrote 65536/65536 bytes at offset 1769984 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 1835520 ++wrote 65536/65536 bytes at offset 1835520 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 1901056 ++wrote 65536/65536 bytes at offset 1901056 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 1966592 ++wrote 65536/65536 bytes at offset 1966592 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 2032128 ++wrote 65536/65536 bytes at offset 2032128 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 2097664 ++wrote 65536/65536 bytes at offset 2097664 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 2163200 ++wrote 65536/65536 bytes at offset 2163200 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 2228736 ++wrote 65536/65536 bytes at offset 2228736 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 2294272 ++wrote 65536/65536 bytes at offset 2294272 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 65 +-qemu-io> wrote 32768/32768 bytes at offset 2392576 ++=== IO: pattern 65 ++wrote 32768/32768 bytes at offset 2392576 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 2458112 ++wrote 32768/32768 bytes at offset 2458112 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 2523648 ++wrote 32768/32768 bytes at offset 2523648 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 2589184 ++wrote 32768/32768 bytes at offset 2589184 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 2654720 ++wrote 32768/32768 bytes at offset 2654720 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 2720256 ++wrote 32768/32768 bytes at offset 2720256 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 2785792 ++wrote 32768/32768 bytes at offset 2785792 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 2851328 ++wrote 32768/32768 bytes at offset 2851328 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 2916864 ++wrote 32768/32768 bytes at offset 2916864 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 2982400 ++wrote 32768/32768 bytes at offset 2982400 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 3047936 ++wrote 32768/32768 bytes at offset 3047936 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 3113472 ++wrote 32768/32768 bytes at offset 3113472 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 3179008 ++wrote 32768/32768 bytes at offset 3179008 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 3244544 ++wrote 32768/32768 bytes at offset 3244544 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 3310080 ++wrote 32768/32768 bytes at offset 3310080 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 3375616 ++wrote 32768/32768 bytes at offset 3375616 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 3441152 ++wrote 32768/32768 bytes at offset 3441152 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 3506688 ++wrote 32768/32768 bytes at offset 3506688 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 3572224 ++wrote 32768/32768 bytes at offset 3572224 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 3637760 ++wrote 32768/32768 bytes at offset 3637760 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 3703296 ++wrote 32768/32768 bytes at offset 3703296 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 3768832 ++wrote 32768/32768 bytes at offset 3768832 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 3834368 ++wrote 32768/32768 bytes at offset 3834368 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 3899904 ++wrote 32768/32768 bytes at offset 3899904 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 3965440 ++wrote 32768/32768 bytes at offset 3965440 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4030976 ++wrote 32768/32768 bytes at offset 4030976 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4096512 ++wrote 32768/32768 bytes at offset 4096512 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4162048 ++wrote 32768/32768 bytes at offset 4162048 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4227584 ++wrote 32768/32768 bytes at offset 4227584 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4293120 ++wrote 32768/32768 bytes at offset 4293120 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4358656 ++wrote 32768/32768 bytes at offset 4358656 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4424192 ++wrote 32768/32768 bytes at offset 4424192 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4489728 ++wrote 32768/32768 bytes at offset 4489728 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4555264 ++wrote 32768/32768 bytes at offset 4555264 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4620800 ++wrote 32768/32768 bytes at offset 4620800 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4686336 ++wrote 32768/32768 bytes at offset 4686336 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 1 +-qemu-io> wrote 32768/32768 bytes at offset 4719104 ++=== IO: pattern 1 ++wrote 32768/32768 bytes at offset 4719104 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4784640 ++wrote 32768/32768 bytes at offset 4784640 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4850176 ++wrote 32768/32768 bytes at offset 4850176 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4915712 ++wrote 32768/32768 bytes at offset 4915712 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4981248 ++wrote 32768/32768 bytes at offset 4981248 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 5046784 ++wrote 32768/32768 bytes at offset 5046784 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 5112320 ++wrote 32768/32768 bytes at offset 5112320 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 5177856 ++wrote 32768/32768 bytes at offset 5177856 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 5243392 ++wrote 32768/32768 bytes at offset 5243392 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 5308928 ++wrote 32768/32768 bytes at offset 5308928 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 5374464 ++wrote 32768/32768 bytes at offset 5374464 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 5440000 ++wrote 32768/32768 bytes at offset 5440000 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 5505536 ++wrote 32768/32768 bytes at offset 5505536 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 5571072 ++wrote 32768/32768 bytes at offset 5571072 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 5636608 ++wrote 32768/32768 bytes at offset 5636608 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 5702144 ++wrote 32768/32768 bytes at offset 5702144 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 5767680 ++wrote 32768/32768 bytes at offset 5767680 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 5833216 ++wrote 32768/32768 bytes at offset 5833216 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 5898752 ++wrote 32768/32768 bytes at offset 5898752 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 5964288 ++wrote 32768/32768 bytes at offset 5964288 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 6029824 ++wrote 32768/32768 bytes at offset 6029824 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 6095360 ++wrote 32768/32768 bytes at offset 6095360 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 6160896 ++wrote 32768/32768 bytes at offset 6160896 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 6226432 ++wrote 32768/32768 bytes at offset 6226432 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 6291968 ++wrote 32768/32768 bytes at offset 6291968 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 6357504 ++wrote 32768/32768 bytes at offset 6357504 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 6423040 ++wrote 32768/32768 bytes at offset 6423040 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 6488576 ++wrote 32768/32768 bytes at offset 6488576 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 6554112 ++wrote 32768/32768 bytes at offset 6554112 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 6619648 ++wrote 32768/32768 bytes at offset 6619648 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 6685184 ++wrote 32768/32768 bytes at offset 6685184 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 6750720 ++wrote 32768/32768 bytes at offset 6750720 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 6816256 ++wrote 32768/32768 bytes at offset 6816256 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 6881792 ++wrote 32768/32768 bytes at offset 6881792 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 6947328 ++wrote 32768/32768 bytes at offset 6947328 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 7012864 ++wrote 32768/32768 bytes at offset 7012864 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 33 +-qemu-io> wrote 32768/32768 bytes at offset 7094784 ++=== IO: pattern 33 ++wrote 32768/32768 bytes at offset 7094784 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 7160320 ++wrote 32768/32768 bytes at offset 7160320 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 7225856 ++wrote 32768/32768 bytes at offset 7225856 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 7291392 ++wrote 32768/32768 bytes at offset 7291392 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 7356928 ++wrote 32768/32768 bytes at offset 7356928 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 7422464 ++wrote 32768/32768 bytes at offset 7422464 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 7488000 ++wrote 32768/32768 bytes at offset 7488000 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 7553536 ++wrote 32768/32768 bytes at offset 7553536 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 7619072 ++wrote 32768/32768 bytes at offset 7619072 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 7684608 ++wrote 32768/32768 bytes at offset 7684608 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 7750144 ++wrote 32768/32768 bytes at offset 7750144 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 7815680 ++wrote 32768/32768 bytes at offset 7815680 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 7881216 ++wrote 32768/32768 bytes at offset 7881216 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 7946752 ++wrote 32768/32768 bytes at offset 7946752 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 8012288 ++wrote 32768/32768 bytes at offset 8012288 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 8077824 ++wrote 32768/32768 bytes at offset 8077824 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 8143360 ++wrote 32768/32768 bytes at offset 8143360 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 8208896 ++wrote 32768/32768 bytes at offset 8208896 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 8274432 ++wrote 32768/32768 bytes at offset 8274432 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 8339968 ++wrote 32768/32768 bytes at offset 8339968 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 8405504 ++wrote 32768/32768 bytes at offset 8405504 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 8471040 ++wrote 32768/32768 bytes at offset 8471040 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 8536576 ++wrote 32768/32768 bytes at offset 8536576 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 8602112 ++wrote 32768/32768 bytes at offset 8602112 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 8667648 ++wrote 32768/32768 bytes at offset 8667648 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 8733184 ++wrote 32768/32768 bytes at offset 8733184 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 8798720 ++wrote 32768/32768 bytes at offset 8798720 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 8864256 ++wrote 32768/32768 bytes at offset 8864256 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 8929792 ++wrote 32768/32768 bytes at offset 8929792 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 8995328 ++wrote 32768/32768 bytes at offset 8995328 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 9060864 ++wrote 32768/32768 bytes at offset 9060864 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 9126400 ++wrote 32768/32768 bytes at offset 9126400 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 9191936 ++wrote 32768/32768 bytes at offset 9191936 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 9257472 ++wrote 32768/32768 bytes at offset 9257472 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 9323008 ++wrote 32768/32768 bytes at offset 9323008 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 9388544 ++wrote 32768/32768 bytes at offset 9388544 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 65 +-qemu-io> wrote 131072/131072 bytes at offset 9470464 ++=== IO: pattern 65 ++wrote 131072/131072 bytes at offset 9470464 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 131072/131072 bytes at offset 9667072 ++wrote 131072/131072 bytes at offset 9667072 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 131072/131072 bytes at offset 9863680 ++wrote 131072/131072 bytes at offset 9863680 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 131072/131072 bytes at offset 10060288 ++wrote 131072/131072 bytes at offset 10060288 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 131072/131072 bytes at offset 10256896 ++wrote 131072/131072 bytes at offset 10256896 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 131072/131072 bytes at offset 10453504 ++wrote 131072/131072 bytes at offset 10453504 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 131072/131072 bytes at offset 10650112 ++wrote 131072/131072 bytes at offset 10650112 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 131072/131072 bytes at offset 10846720 ++wrote 131072/131072 bytes at offset 10846720 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 131072/131072 bytes at offset 11043328 ++wrote 131072/131072 bytes at offset 11043328 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 64 +-qemu-io> wrote 196608/196608 bytes at offset 536772608 ++=== IO: pattern 64 ++wrote 196608/196608 bytes at offset 536772608 + 192 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 196608/196608 bytes at offset 1073676288 ++wrote 196608/196608 bytes at offset 1073676288 + 192 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 196608/196608 bytes at offset 1610579968 ++wrote 196608/196608 bytes at offset 1610579968 + 192 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 1 +-qemu-io> read 65536/65536 bytes at offset 512 ++=== IO: pattern 1 ++read 65536/65536 bytes at offset 512 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 66048 ++read 65536/65536 bytes at offset 66048 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 131584 ++read 65536/65536 bytes at offset 131584 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 197120 ++read 65536/65536 bytes at offset 197120 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 262656 ++read 65536/65536 bytes at offset 262656 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 328192 ++read 65536/65536 bytes at offset 328192 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 393728 ++read 65536/65536 bytes at offset 393728 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 459264 ++read 65536/65536 bytes at offset 459264 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 524800 ++read 65536/65536 bytes at offset 524800 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 590336 ++read 65536/65536 bytes at offset 590336 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 655872 ++read 65536/65536 bytes at offset 655872 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 721408 ++read 65536/65536 bytes at offset 721408 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 786944 ++read 65536/65536 bytes at offset 786944 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 852480 ++read 65536/65536 bytes at offset 852480 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 918016 ++read 65536/65536 bytes at offset 918016 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 983552 ++read 65536/65536 bytes at offset 983552 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 1049088 ++read 65536/65536 bytes at offset 1049088 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 1114624 ++read 65536/65536 bytes at offset 1114624 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 1180160 ++read 65536/65536 bytes at offset 1180160 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 1245696 ++read 65536/65536 bytes at offset 1245696 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 1311232 ++read 65536/65536 bytes at offset 1311232 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 1376768 ++read 65536/65536 bytes at offset 1376768 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 1442304 ++read 65536/65536 bytes at offset 1442304 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 1507840 ++read 65536/65536 bytes at offset 1507840 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 1573376 ++read 65536/65536 bytes at offset 1573376 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 1638912 ++read 65536/65536 bytes at offset 1638912 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 1704448 ++read 65536/65536 bytes at offset 1704448 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 1769984 ++read 65536/65536 bytes at offset 1769984 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 1835520 ++read 65536/65536 bytes at offset 1835520 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 1901056 ++read 65536/65536 bytes at offset 1901056 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 1966592 ++read 65536/65536 bytes at offset 1966592 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 2032128 ++read 65536/65536 bytes at offset 2032128 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 2097664 ++read 65536/65536 bytes at offset 2097664 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 2163200 ++read 65536/65536 bytes at offset 2163200 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 2228736 ++read 65536/65536 bytes at offset 2228736 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 2294272 ++read 65536/65536 bytes at offset 2294272 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 65 +-qemu-io> read 32768/32768 bytes at offset 2392576 ++=== IO: pattern 65 ++read 32768/32768 bytes at offset 2392576 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 2458112 ++read 32768/32768 bytes at offset 2458112 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 2523648 ++read 32768/32768 bytes at offset 2523648 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 2589184 ++read 32768/32768 bytes at offset 2589184 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 2654720 ++read 32768/32768 bytes at offset 2654720 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 2720256 ++read 32768/32768 bytes at offset 2720256 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 2785792 ++read 32768/32768 bytes at offset 2785792 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 2851328 ++read 32768/32768 bytes at offset 2851328 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 2916864 ++read 32768/32768 bytes at offset 2916864 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 2982400 ++read 32768/32768 bytes at offset 2982400 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 3047936 ++read 32768/32768 bytes at offset 3047936 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 3113472 ++read 32768/32768 bytes at offset 3113472 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 3179008 ++read 32768/32768 bytes at offset 3179008 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 3244544 ++read 32768/32768 bytes at offset 3244544 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 3310080 ++read 32768/32768 bytes at offset 3310080 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 3375616 ++read 32768/32768 bytes at offset 3375616 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 3441152 ++read 32768/32768 bytes at offset 3441152 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 3506688 ++read 32768/32768 bytes at offset 3506688 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 3572224 ++read 32768/32768 bytes at offset 3572224 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 3637760 ++read 32768/32768 bytes at offset 3637760 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 3703296 ++read 32768/32768 bytes at offset 3703296 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 3768832 ++read 32768/32768 bytes at offset 3768832 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 3834368 ++read 32768/32768 bytes at offset 3834368 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 3899904 ++read 32768/32768 bytes at offset 3899904 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 3965440 ++read 32768/32768 bytes at offset 3965440 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4030976 ++read 32768/32768 bytes at offset 4030976 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4096512 ++read 32768/32768 bytes at offset 4096512 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4162048 ++read 32768/32768 bytes at offset 4162048 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4227584 ++read 32768/32768 bytes at offset 4227584 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4293120 ++read 32768/32768 bytes at offset 4293120 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4358656 ++read 32768/32768 bytes at offset 4358656 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4424192 ++read 32768/32768 bytes at offset 4424192 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4489728 ++read 32768/32768 bytes at offset 4489728 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4555264 ++read 32768/32768 bytes at offset 4555264 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4620800 ++read 32768/32768 bytes at offset 4620800 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4686336 ++read 32768/32768 bytes at offset 4686336 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 1 +-qemu-io> read 32768/32768 bytes at offset 4719104 ++=== IO: pattern 1 ++read 32768/32768 bytes at offset 4719104 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4784640 ++read 32768/32768 bytes at offset 4784640 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4850176 ++read 32768/32768 bytes at offset 4850176 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4915712 ++read 32768/32768 bytes at offset 4915712 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4981248 ++read 32768/32768 bytes at offset 4981248 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 5046784 ++read 32768/32768 bytes at offset 5046784 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 5112320 ++read 32768/32768 bytes at offset 5112320 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 5177856 ++read 32768/32768 bytes at offset 5177856 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 5243392 ++read 32768/32768 bytes at offset 5243392 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 5308928 ++read 32768/32768 bytes at offset 5308928 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 5374464 ++read 32768/32768 bytes at offset 5374464 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 5440000 ++read 32768/32768 bytes at offset 5440000 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 5505536 ++read 32768/32768 bytes at offset 5505536 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 5571072 ++read 32768/32768 bytes at offset 5571072 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 5636608 ++read 32768/32768 bytes at offset 5636608 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 5702144 ++read 32768/32768 bytes at offset 5702144 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 5767680 ++read 32768/32768 bytes at offset 5767680 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 5833216 ++read 32768/32768 bytes at offset 5833216 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 5898752 ++read 32768/32768 bytes at offset 5898752 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 5964288 ++read 32768/32768 bytes at offset 5964288 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 6029824 ++read 32768/32768 bytes at offset 6029824 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 6095360 ++read 32768/32768 bytes at offset 6095360 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 6160896 ++read 32768/32768 bytes at offset 6160896 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 6226432 ++read 32768/32768 bytes at offset 6226432 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 6291968 ++read 32768/32768 bytes at offset 6291968 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 6357504 ++read 32768/32768 bytes at offset 6357504 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 6423040 ++read 32768/32768 bytes at offset 6423040 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 6488576 ++read 32768/32768 bytes at offset 6488576 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 6554112 ++read 32768/32768 bytes at offset 6554112 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 6619648 ++read 32768/32768 bytes at offset 6619648 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 6685184 ++read 32768/32768 bytes at offset 6685184 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 6750720 ++read 32768/32768 bytes at offset 6750720 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 6816256 ++read 32768/32768 bytes at offset 6816256 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 6881792 ++read 32768/32768 bytes at offset 6881792 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 6947328 ++read 32768/32768 bytes at offset 6947328 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 7012864 ++read 32768/32768 bytes at offset 7012864 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 33 +-qemu-io> read 32768/32768 bytes at offset 7094784 ++=== IO: pattern 33 ++read 32768/32768 bytes at offset 7094784 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 7160320 ++read 32768/32768 bytes at offset 7160320 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 7225856 ++read 32768/32768 bytes at offset 7225856 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 7291392 ++read 32768/32768 bytes at offset 7291392 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 7356928 ++read 32768/32768 bytes at offset 7356928 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 7422464 ++read 32768/32768 bytes at offset 7422464 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 7488000 ++read 32768/32768 bytes at offset 7488000 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 7553536 ++read 32768/32768 bytes at offset 7553536 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 7619072 ++read 32768/32768 bytes at offset 7619072 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 7684608 ++read 32768/32768 bytes at offset 7684608 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 7750144 ++read 32768/32768 bytes at offset 7750144 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 7815680 ++read 32768/32768 bytes at offset 7815680 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 7881216 ++read 32768/32768 bytes at offset 7881216 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 7946752 ++read 32768/32768 bytes at offset 7946752 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 8012288 ++read 32768/32768 bytes at offset 8012288 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 8077824 ++read 32768/32768 bytes at offset 8077824 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 8143360 ++read 32768/32768 bytes at offset 8143360 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 8208896 ++read 32768/32768 bytes at offset 8208896 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 8274432 ++read 32768/32768 bytes at offset 8274432 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 8339968 ++read 32768/32768 bytes at offset 8339968 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 8405504 ++read 32768/32768 bytes at offset 8405504 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 8471040 ++read 32768/32768 bytes at offset 8471040 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 8536576 ++read 32768/32768 bytes at offset 8536576 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 8602112 ++read 32768/32768 bytes at offset 8602112 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 8667648 ++read 32768/32768 bytes at offset 8667648 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 8733184 ++read 32768/32768 bytes at offset 8733184 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 8798720 ++read 32768/32768 bytes at offset 8798720 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 8864256 ++read 32768/32768 bytes at offset 8864256 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 8929792 ++read 32768/32768 bytes at offset 8929792 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 8995328 ++read 32768/32768 bytes at offset 8995328 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 9060864 ++read 32768/32768 bytes at offset 9060864 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 9126400 ++read 32768/32768 bytes at offset 9126400 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 9191936 ++read 32768/32768 bytes at offset 9191936 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 9257472 ++read 32768/32768 bytes at offset 9257472 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 9323008 ++read 32768/32768 bytes at offset 9323008 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 9388544 ++read 32768/32768 bytes at offset 9388544 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 65 +-qemu-io> read 131072/131072 bytes at offset 9470464 ++=== IO: pattern 65 ++read 131072/131072 bytes at offset 9470464 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 131072/131072 bytes at offset 9667072 ++read 131072/131072 bytes at offset 9667072 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 131072/131072 bytes at offset 9863680 ++read 131072/131072 bytes at offset 9863680 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 131072/131072 bytes at offset 10060288 ++read 131072/131072 bytes at offset 10060288 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 131072/131072 bytes at offset 10256896 ++read 131072/131072 bytes at offset 10256896 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 131072/131072 bytes at offset 10453504 ++read 131072/131072 bytes at offset 10453504 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 131072/131072 bytes at offset 10650112 ++read 131072/131072 bytes at offset 10650112 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 131072/131072 bytes at offset 10846720 ++read 131072/131072 bytes at offset 10846720 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 131072/131072 bytes at offset 11043328 ++read 131072/131072 bytes at offset 11043328 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 64 +-qemu-io> read 196608/196608 bytes at offset 536772608 ++=== IO: pattern 64 ++read 196608/196608 bytes at offset 536772608 + 192 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 196608/196608 bytes at offset 1073676288 ++read 196608/196608 bytes at offset 1073676288 + 192 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 196608/196608 bytes at offset 1610579968 ++read 196608/196608 bytes at offset 1610579968 + 192 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> No errors were found on the image. ++No errors were found on the image. + With offset 4294967808: + === IO: pattern 1 +-qemu-io> wrote 65536/65536 bytes at offset 4294967808 ++wrote 65536/65536 bytes at offset 4294967808 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4295033344 ++wrote 65536/65536 bytes at offset 4295033344 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4295098880 ++wrote 65536/65536 bytes at offset 4295098880 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4295164416 ++wrote 65536/65536 bytes at offset 4295164416 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4295229952 ++wrote 65536/65536 bytes at offset 4295229952 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4295295488 ++wrote 65536/65536 bytes at offset 4295295488 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4295361024 ++wrote 65536/65536 bytes at offset 4295361024 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4295426560 ++wrote 65536/65536 bytes at offset 4295426560 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4295492096 ++wrote 65536/65536 bytes at offset 4295492096 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4295557632 ++wrote 65536/65536 bytes at offset 4295557632 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4295623168 ++wrote 65536/65536 bytes at offset 4295623168 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4295688704 ++wrote 65536/65536 bytes at offset 4295688704 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4295754240 ++wrote 65536/65536 bytes at offset 4295754240 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4295819776 ++wrote 65536/65536 bytes at offset 4295819776 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4295885312 ++wrote 65536/65536 bytes at offset 4295885312 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4295950848 ++wrote 65536/65536 bytes at offset 4295950848 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4296016384 ++wrote 65536/65536 bytes at offset 4296016384 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4296081920 ++wrote 65536/65536 bytes at offset 4296081920 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4296147456 ++wrote 65536/65536 bytes at offset 4296147456 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4296212992 ++wrote 65536/65536 bytes at offset 4296212992 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4296278528 ++wrote 65536/65536 bytes at offset 4296278528 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4296344064 ++wrote 65536/65536 bytes at offset 4296344064 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4296409600 ++wrote 65536/65536 bytes at offset 4296409600 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4296475136 ++wrote 65536/65536 bytes at offset 4296475136 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4296540672 ++wrote 65536/65536 bytes at offset 4296540672 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4296606208 ++wrote 65536/65536 bytes at offset 4296606208 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4296671744 ++wrote 65536/65536 bytes at offset 4296671744 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4296737280 ++wrote 65536/65536 bytes at offset 4296737280 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4296802816 ++wrote 65536/65536 bytes at offset 4296802816 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4296868352 ++wrote 65536/65536 bytes at offset 4296868352 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4296933888 ++wrote 65536/65536 bytes at offset 4296933888 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4296999424 ++wrote 65536/65536 bytes at offset 4296999424 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4297064960 ++wrote 65536/65536 bytes at offset 4297064960 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4297130496 ++wrote 65536/65536 bytes at offset 4297130496 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4297196032 ++wrote 65536/65536 bytes at offset 4297196032 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4297261568 ++wrote 65536/65536 bytes at offset 4297261568 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 65 +-qemu-io> wrote 32768/32768 bytes at offset 4297359872 ++=== IO: pattern 65 ++wrote 32768/32768 bytes at offset 4297359872 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4297425408 ++wrote 32768/32768 bytes at offset 4297425408 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4297490944 ++wrote 32768/32768 bytes at offset 4297490944 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4297556480 ++wrote 32768/32768 bytes at offset 4297556480 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4297622016 ++wrote 32768/32768 bytes at offset 4297622016 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4297687552 ++wrote 32768/32768 bytes at offset 4297687552 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4297753088 ++wrote 32768/32768 bytes at offset 4297753088 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4297818624 ++wrote 32768/32768 bytes at offset 4297818624 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4297884160 ++wrote 32768/32768 bytes at offset 4297884160 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4297949696 ++wrote 32768/32768 bytes at offset 4297949696 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4298015232 ++wrote 32768/32768 bytes at offset 4298015232 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4298080768 ++wrote 32768/32768 bytes at offset 4298080768 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4298146304 ++wrote 32768/32768 bytes at offset 4298146304 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4298211840 ++wrote 32768/32768 bytes at offset 4298211840 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4298277376 ++wrote 32768/32768 bytes at offset 4298277376 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4298342912 ++wrote 32768/32768 bytes at offset 4298342912 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4298408448 ++wrote 32768/32768 bytes at offset 4298408448 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4298473984 ++wrote 32768/32768 bytes at offset 4298473984 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4298539520 ++wrote 32768/32768 bytes at offset 4298539520 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4298605056 ++wrote 32768/32768 bytes at offset 4298605056 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4298670592 ++wrote 32768/32768 bytes at offset 4298670592 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4298736128 ++wrote 32768/32768 bytes at offset 4298736128 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4298801664 ++wrote 32768/32768 bytes at offset 4298801664 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4298867200 ++wrote 32768/32768 bytes at offset 4298867200 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4298932736 ++wrote 32768/32768 bytes at offset 4298932736 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4298998272 ++wrote 32768/32768 bytes at offset 4298998272 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4299063808 ++wrote 32768/32768 bytes at offset 4299063808 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4299129344 ++wrote 32768/32768 bytes at offset 4299129344 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4299194880 ++wrote 32768/32768 bytes at offset 4299194880 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4299260416 ++wrote 32768/32768 bytes at offset 4299260416 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4299325952 ++wrote 32768/32768 bytes at offset 4299325952 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4299391488 ++wrote 32768/32768 bytes at offset 4299391488 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4299457024 ++wrote 32768/32768 bytes at offset 4299457024 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4299522560 ++wrote 32768/32768 bytes at offset 4299522560 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4299588096 ++wrote 32768/32768 bytes at offset 4299588096 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4299653632 ++wrote 32768/32768 bytes at offset 4299653632 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 1 +-qemu-io> wrote 32768/32768 bytes at offset 4299686400 ++=== IO: pattern 1 ++wrote 32768/32768 bytes at offset 4299686400 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4299751936 ++wrote 32768/32768 bytes at offset 4299751936 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4299817472 ++wrote 32768/32768 bytes at offset 4299817472 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4299883008 ++wrote 32768/32768 bytes at offset 4299883008 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4299948544 ++wrote 32768/32768 bytes at offset 4299948544 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4300014080 ++wrote 32768/32768 bytes at offset 4300014080 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4300079616 ++wrote 32768/32768 bytes at offset 4300079616 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4300145152 ++wrote 32768/32768 bytes at offset 4300145152 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4300210688 ++wrote 32768/32768 bytes at offset 4300210688 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4300276224 ++wrote 32768/32768 bytes at offset 4300276224 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4300341760 ++wrote 32768/32768 bytes at offset 4300341760 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4300407296 ++wrote 32768/32768 bytes at offset 4300407296 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4300472832 ++wrote 32768/32768 bytes at offset 4300472832 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4300538368 ++wrote 32768/32768 bytes at offset 4300538368 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4300603904 ++wrote 32768/32768 bytes at offset 4300603904 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4300669440 ++wrote 32768/32768 bytes at offset 4300669440 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4300734976 ++wrote 32768/32768 bytes at offset 4300734976 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4300800512 ++wrote 32768/32768 bytes at offset 4300800512 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4300866048 ++wrote 32768/32768 bytes at offset 4300866048 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4300931584 ++wrote 32768/32768 bytes at offset 4300931584 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4300997120 ++wrote 32768/32768 bytes at offset 4300997120 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4301062656 ++wrote 32768/32768 bytes at offset 4301062656 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4301128192 ++wrote 32768/32768 bytes at offset 4301128192 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4301193728 ++wrote 32768/32768 bytes at offset 4301193728 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4301259264 ++wrote 32768/32768 bytes at offset 4301259264 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4301324800 ++wrote 32768/32768 bytes at offset 4301324800 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4301390336 ++wrote 32768/32768 bytes at offset 4301390336 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4301455872 ++wrote 32768/32768 bytes at offset 4301455872 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4301521408 ++wrote 32768/32768 bytes at offset 4301521408 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4301586944 ++wrote 32768/32768 bytes at offset 4301586944 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4301652480 ++wrote 32768/32768 bytes at offset 4301652480 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4301718016 ++wrote 32768/32768 bytes at offset 4301718016 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4301783552 ++wrote 32768/32768 bytes at offset 4301783552 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4301849088 ++wrote 32768/32768 bytes at offset 4301849088 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4301914624 ++wrote 32768/32768 bytes at offset 4301914624 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4301980160 ++wrote 32768/32768 bytes at offset 4301980160 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 33 +-qemu-io> wrote 32768/32768 bytes at offset 4302062080 ++=== IO: pattern 33 ++wrote 32768/32768 bytes at offset 4302062080 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4302127616 ++wrote 32768/32768 bytes at offset 4302127616 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4302193152 ++wrote 32768/32768 bytes at offset 4302193152 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4302258688 ++wrote 32768/32768 bytes at offset 4302258688 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4302324224 ++wrote 32768/32768 bytes at offset 4302324224 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4302389760 ++wrote 32768/32768 bytes at offset 4302389760 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4302455296 ++wrote 32768/32768 bytes at offset 4302455296 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4302520832 ++wrote 32768/32768 bytes at offset 4302520832 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4302586368 ++wrote 32768/32768 bytes at offset 4302586368 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4302651904 ++wrote 32768/32768 bytes at offset 4302651904 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4302717440 ++wrote 32768/32768 bytes at offset 4302717440 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4302782976 ++wrote 32768/32768 bytes at offset 4302782976 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4302848512 ++wrote 32768/32768 bytes at offset 4302848512 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4302914048 ++wrote 32768/32768 bytes at offset 4302914048 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4302979584 ++wrote 32768/32768 bytes at offset 4302979584 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4303045120 ++wrote 32768/32768 bytes at offset 4303045120 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4303110656 ++wrote 32768/32768 bytes at offset 4303110656 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4303176192 ++wrote 32768/32768 bytes at offset 4303176192 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4303241728 ++wrote 32768/32768 bytes at offset 4303241728 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4303307264 ++wrote 32768/32768 bytes at offset 4303307264 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4303372800 ++wrote 32768/32768 bytes at offset 4303372800 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4303438336 ++wrote 32768/32768 bytes at offset 4303438336 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4303503872 ++wrote 32768/32768 bytes at offset 4303503872 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4303569408 ++wrote 32768/32768 bytes at offset 4303569408 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4303634944 ++wrote 32768/32768 bytes at offset 4303634944 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4303700480 ++wrote 32768/32768 bytes at offset 4303700480 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4303766016 ++wrote 32768/32768 bytes at offset 4303766016 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4303831552 ++wrote 32768/32768 bytes at offset 4303831552 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4303897088 ++wrote 32768/32768 bytes at offset 4303897088 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4303962624 ++wrote 32768/32768 bytes at offset 4303962624 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4304028160 ++wrote 32768/32768 bytes at offset 4304028160 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4304093696 ++wrote 32768/32768 bytes at offset 4304093696 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4304159232 ++wrote 32768/32768 bytes at offset 4304159232 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4304224768 ++wrote 32768/32768 bytes at offset 4304224768 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4304290304 ++wrote 32768/32768 bytes at offset 4304290304 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4304355840 ++wrote 32768/32768 bytes at offset 4304355840 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 65 +-qemu-io> wrote 131072/131072 bytes at offset 4304437760 ++=== IO: pattern 65 ++wrote 131072/131072 bytes at offset 4304437760 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 131072/131072 bytes at offset 4304634368 ++wrote 131072/131072 bytes at offset 4304634368 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 131072/131072 bytes at offset 4304830976 ++wrote 131072/131072 bytes at offset 4304830976 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 131072/131072 bytes at offset 4305027584 ++wrote 131072/131072 bytes at offset 4305027584 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 131072/131072 bytes at offset 4305224192 ++wrote 131072/131072 bytes at offset 4305224192 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 131072/131072 bytes at offset 4305420800 ++wrote 131072/131072 bytes at offset 4305420800 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 131072/131072 bytes at offset 4305617408 ++wrote 131072/131072 bytes at offset 4305617408 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 131072/131072 bytes at offset 4305814016 ++wrote 131072/131072 bytes at offset 4305814016 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 131072/131072 bytes at offset 4306010624 ++wrote 131072/131072 bytes at offset 4306010624 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 64 +-qemu-io> wrote 196608/196608 bytes at offset 4831739904 ++=== IO: pattern 64 ++wrote 196608/196608 bytes at offset 4831739904 + 192 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 196608/196608 bytes at offset 5368643584 ++wrote 196608/196608 bytes at offset 5368643584 + 192 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 196608/196608 bytes at offset 5905547264 ++wrote 196608/196608 bytes at offset 5905547264 + 192 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 1 +-qemu-io> read 65536/65536 bytes at offset 4294967808 ++=== IO: pattern 1 ++read 65536/65536 bytes at offset 4294967808 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4295033344 ++read 65536/65536 bytes at offset 4295033344 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4295098880 ++read 65536/65536 bytes at offset 4295098880 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4295164416 ++read 65536/65536 bytes at offset 4295164416 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4295229952 ++read 65536/65536 bytes at offset 4295229952 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4295295488 ++read 65536/65536 bytes at offset 4295295488 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4295361024 ++read 65536/65536 bytes at offset 4295361024 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4295426560 ++read 65536/65536 bytes at offset 4295426560 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4295492096 ++read 65536/65536 bytes at offset 4295492096 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4295557632 ++read 65536/65536 bytes at offset 4295557632 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4295623168 ++read 65536/65536 bytes at offset 4295623168 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4295688704 ++read 65536/65536 bytes at offset 4295688704 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4295754240 ++read 65536/65536 bytes at offset 4295754240 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4295819776 ++read 65536/65536 bytes at offset 4295819776 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4295885312 ++read 65536/65536 bytes at offset 4295885312 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4295950848 ++read 65536/65536 bytes at offset 4295950848 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4296016384 ++read 65536/65536 bytes at offset 4296016384 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4296081920 ++read 65536/65536 bytes at offset 4296081920 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4296147456 ++read 65536/65536 bytes at offset 4296147456 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4296212992 ++read 65536/65536 bytes at offset 4296212992 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4296278528 ++read 65536/65536 bytes at offset 4296278528 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4296344064 ++read 65536/65536 bytes at offset 4296344064 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4296409600 ++read 65536/65536 bytes at offset 4296409600 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4296475136 ++read 65536/65536 bytes at offset 4296475136 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4296540672 ++read 65536/65536 bytes at offset 4296540672 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4296606208 ++read 65536/65536 bytes at offset 4296606208 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4296671744 ++read 65536/65536 bytes at offset 4296671744 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4296737280 ++read 65536/65536 bytes at offset 4296737280 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4296802816 ++read 65536/65536 bytes at offset 4296802816 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4296868352 ++read 65536/65536 bytes at offset 4296868352 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4296933888 ++read 65536/65536 bytes at offset 4296933888 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4296999424 ++read 65536/65536 bytes at offset 4296999424 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4297064960 ++read 65536/65536 bytes at offset 4297064960 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4297130496 ++read 65536/65536 bytes at offset 4297130496 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4297196032 ++read 65536/65536 bytes at offset 4297196032 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4297261568 ++read 65536/65536 bytes at offset 4297261568 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 65 +-qemu-io> read 32768/32768 bytes at offset 4297359872 ++=== IO: pattern 65 ++read 32768/32768 bytes at offset 4297359872 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4297425408 ++read 32768/32768 bytes at offset 4297425408 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4297490944 ++read 32768/32768 bytes at offset 4297490944 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4297556480 ++read 32768/32768 bytes at offset 4297556480 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4297622016 ++read 32768/32768 bytes at offset 4297622016 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4297687552 ++read 32768/32768 bytes at offset 4297687552 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4297753088 ++read 32768/32768 bytes at offset 4297753088 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4297818624 ++read 32768/32768 bytes at offset 4297818624 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4297884160 ++read 32768/32768 bytes at offset 4297884160 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4297949696 ++read 32768/32768 bytes at offset 4297949696 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4298015232 ++read 32768/32768 bytes at offset 4298015232 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4298080768 ++read 32768/32768 bytes at offset 4298080768 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4298146304 ++read 32768/32768 bytes at offset 4298146304 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4298211840 ++read 32768/32768 bytes at offset 4298211840 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4298277376 ++read 32768/32768 bytes at offset 4298277376 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4298342912 ++read 32768/32768 bytes at offset 4298342912 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4298408448 ++read 32768/32768 bytes at offset 4298408448 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4298473984 ++read 32768/32768 bytes at offset 4298473984 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4298539520 ++read 32768/32768 bytes at offset 4298539520 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4298605056 ++read 32768/32768 bytes at offset 4298605056 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4298670592 ++read 32768/32768 bytes at offset 4298670592 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4298736128 ++read 32768/32768 bytes at offset 4298736128 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4298801664 ++read 32768/32768 bytes at offset 4298801664 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4298867200 ++read 32768/32768 bytes at offset 4298867200 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4298932736 ++read 32768/32768 bytes at offset 4298932736 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4298998272 ++read 32768/32768 bytes at offset 4298998272 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4299063808 ++read 32768/32768 bytes at offset 4299063808 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4299129344 ++read 32768/32768 bytes at offset 4299129344 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4299194880 ++read 32768/32768 bytes at offset 4299194880 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4299260416 ++read 32768/32768 bytes at offset 4299260416 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4299325952 ++read 32768/32768 bytes at offset 4299325952 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4299391488 ++read 32768/32768 bytes at offset 4299391488 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4299457024 ++read 32768/32768 bytes at offset 4299457024 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4299522560 ++read 32768/32768 bytes at offset 4299522560 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4299588096 ++read 32768/32768 bytes at offset 4299588096 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4299653632 ++read 32768/32768 bytes at offset 4299653632 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 1 +-qemu-io> read 32768/32768 bytes at offset 4299686400 ++=== IO: pattern 1 ++read 32768/32768 bytes at offset 4299686400 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4299751936 ++read 32768/32768 bytes at offset 4299751936 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4299817472 ++read 32768/32768 bytes at offset 4299817472 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4299883008 ++read 32768/32768 bytes at offset 4299883008 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4299948544 ++read 32768/32768 bytes at offset 4299948544 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4300014080 ++read 32768/32768 bytes at offset 4300014080 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4300079616 ++read 32768/32768 bytes at offset 4300079616 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4300145152 ++read 32768/32768 bytes at offset 4300145152 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4300210688 ++read 32768/32768 bytes at offset 4300210688 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4300276224 ++read 32768/32768 bytes at offset 4300276224 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4300341760 ++read 32768/32768 bytes at offset 4300341760 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4300407296 ++read 32768/32768 bytes at offset 4300407296 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4300472832 ++read 32768/32768 bytes at offset 4300472832 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4300538368 ++read 32768/32768 bytes at offset 4300538368 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4300603904 ++read 32768/32768 bytes at offset 4300603904 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4300669440 ++read 32768/32768 bytes at offset 4300669440 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4300734976 ++read 32768/32768 bytes at offset 4300734976 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4300800512 ++read 32768/32768 bytes at offset 4300800512 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4300866048 ++read 32768/32768 bytes at offset 4300866048 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4300931584 ++read 32768/32768 bytes at offset 4300931584 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4300997120 ++read 32768/32768 bytes at offset 4300997120 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4301062656 ++read 32768/32768 bytes at offset 4301062656 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4301128192 ++read 32768/32768 bytes at offset 4301128192 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4301193728 ++read 32768/32768 bytes at offset 4301193728 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4301259264 ++read 32768/32768 bytes at offset 4301259264 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4301324800 ++read 32768/32768 bytes at offset 4301324800 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4301390336 ++read 32768/32768 bytes at offset 4301390336 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4301455872 ++read 32768/32768 bytes at offset 4301455872 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4301521408 ++read 32768/32768 bytes at offset 4301521408 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4301586944 ++read 32768/32768 bytes at offset 4301586944 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4301652480 ++read 32768/32768 bytes at offset 4301652480 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4301718016 ++read 32768/32768 bytes at offset 4301718016 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4301783552 ++read 32768/32768 bytes at offset 4301783552 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4301849088 ++read 32768/32768 bytes at offset 4301849088 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4301914624 ++read 32768/32768 bytes at offset 4301914624 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4301980160 ++read 32768/32768 bytes at offset 4301980160 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 33 +-qemu-io> read 32768/32768 bytes at offset 4302062080 ++=== IO: pattern 33 ++read 32768/32768 bytes at offset 4302062080 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4302127616 ++read 32768/32768 bytes at offset 4302127616 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4302193152 ++read 32768/32768 bytes at offset 4302193152 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4302258688 ++read 32768/32768 bytes at offset 4302258688 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4302324224 ++read 32768/32768 bytes at offset 4302324224 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4302389760 ++read 32768/32768 bytes at offset 4302389760 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4302455296 ++read 32768/32768 bytes at offset 4302455296 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4302520832 ++read 32768/32768 bytes at offset 4302520832 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4302586368 ++read 32768/32768 bytes at offset 4302586368 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4302651904 ++read 32768/32768 bytes at offset 4302651904 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4302717440 ++read 32768/32768 bytes at offset 4302717440 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4302782976 ++read 32768/32768 bytes at offset 4302782976 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4302848512 ++read 32768/32768 bytes at offset 4302848512 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4302914048 ++read 32768/32768 bytes at offset 4302914048 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4302979584 ++read 32768/32768 bytes at offset 4302979584 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4303045120 ++read 32768/32768 bytes at offset 4303045120 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4303110656 ++read 32768/32768 bytes at offset 4303110656 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4303176192 ++read 32768/32768 bytes at offset 4303176192 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4303241728 ++read 32768/32768 bytes at offset 4303241728 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4303307264 ++read 32768/32768 bytes at offset 4303307264 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4303372800 ++read 32768/32768 bytes at offset 4303372800 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4303438336 ++read 32768/32768 bytes at offset 4303438336 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4303503872 ++read 32768/32768 bytes at offset 4303503872 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4303569408 ++read 32768/32768 bytes at offset 4303569408 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4303634944 ++read 32768/32768 bytes at offset 4303634944 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4303700480 ++read 32768/32768 bytes at offset 4303700480 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4303766016 ++read 32768/32768 bytes at offset 4303766016 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4303831552 ++read 32768/32768 bytes at offset 4303831552 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4303897088 ++read 32768/32768 bytes at offset 4303897088 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4303962624 ++read 32768/32768 bytes at offset 4303962624 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4304028160 ++read 32768/32768 bytes at offset 4304028160 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4304093696 ++read 32768/32768 bytes at offset 4304093696 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4304159232 ++read 32768/32768 bytes at offset 4304159232 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4304224768 ++read 32768/32768 bytes at offset 4304224768 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4304290304 ++read 32768/32768 bytes at offset 4304290304 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4304355840 ++read 32768/32768 bytes at offset 4304355840 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 65 +-qemu-io> read 131072/131072 bytes at offset 4304437760 ++=== IO: pattern 65 ++read 131072/131072 bytes at offset 4304437760 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 131072/131072 bytes at offset 4304634368 ++read 131072/131072 bytes at offset 4304634368 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 131072/131072 bytes at offset 4304830976 ++read 131072/131072 bytes at offset 4304830976 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 131072/131072 bytes at offset 4305027584 ++read 131072/131072 bytes at offset 4305027584 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 131072/131072 bytes at offset 4305224192 ++read 131072/131072 bytes at offset 4305224192 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 131072/131072 bytes at offset 4305420800 ++read 131072/131072 bytes at offset 4305420800 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 131072/131072 bytes at offset 4305617408 ++read 131072/131072 bytes at offset 4305617408 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 131072/131072 bytes at offset 4305814016 ++read 131072/131072 bytes at offset 4305814016 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 131072/131072 bytes at offset 4306010624 ++read 131072/131072 bytes at offset 4306010624 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 64 +-qemu-io> read 196608/196608 bytes at offset 4831739904 ++=== IO: pattern 64 ++read 196608/196608 bytes at offset 4831739904 + 192 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 196608/196608 bytes at offset 5368643584 ++read 196608/196608 bytes at offset 5368643584 + 192 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 196608/196608 bytes at offset 5905547264 ++read 196608/196608 bytes at offset 5905547264 + 192 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 1 +-qemu-io> wrote 65536/65536 bytes at offset 4294967808 ++=== IO: pattern 1 ++wrote 65536/65536 bytes at offset 4294967808 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4295033344 ++wrote 65536/65536 bytes at offset 4295033344 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4295098880 ++wrote 65536/65536 bytes at offset 4295098880 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4295164416 ++wrote 65536/65536 bytes at offset 4295164416 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4295229952 ++wrote 65536/65536 bytes at offset 4295229952 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4295295488 ++wrote 65536/65536 bytes at offset 4295295488 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4295361024 ++wrote 65536/65536 bytes at offset 4295361024 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4295426560 ++wrote 65536/65536 bytes at offset 4295426560 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4295492096 ++wrote 65536/65536 bytes at offset 4295492096 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4295557632 ++wrote 65536/65536 bytes at offset 4295557632 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4295623168 ++wrote 65536/65536 bytes at offset 4295623168 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4295688704 ++wrote 65536/65536 bytes at offset 4295688704 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4295754240 ++wrote 65536/65536 bytes at offset 4295754240 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4295819776 ++wrote 65536/65536 bytes at offset 4295819776 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4295885312 ++wrote 65536/65536 bytes at offset 4295885312 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4295950848 ++wrote 65536/65536 bytes at offset 4295950848 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4296016384 ++wrote 65536/65536 bytes at offset 4296016384 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4296081920 ++wrote 65536/65536 bytes at offset 4296081920 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4296147456 ++wrote 65536/65536 bytes at offset 4296147456 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4296212992 ++wrote 65536/65536 bytes at offset 4296212992 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4296278528 ++wrote 65536/65536 bytes at offset 4296278528 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4296344064 ++wrote 65536/65536 bytes at offset 4296344064 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4296409600 ++wrote 65536/65536 bytes at offset 4296409600 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4296475136 ++wrote 65536/65536 bytes at offset 4296475136 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4296540672 ++wrote 65536/65536 bytes at offset 4296540672 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4296606208 ++wrote 65536/65536 bytes at offset 4296606208 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4296671744 ++wrote 65536/65536 bytes at offset 4296671744 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4296737280 ++wrote 65536/65536 bytes at offset 4296737280 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4296802816 ++wrote 65536/65536 bytes at offset 4296802816 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4296868352 ++wrote 65536/65536 bytes at offset 4296868352 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4296933888 ++wrote 65536/65536 bytes at offset 4296933888 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4296999424 ++wrote 65536/65536 bytes at offset 4296999424 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4297064960 ++wrote 65536/65536 bytes at offset 4297064960 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4297130496 ++wrote 65536/65536 bytes at offset 4297130496 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4297196032 ++wrote 65536/65536 bytes at offset 4297196032 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4297261568 ++wrote 65536/65536 bytes at offset 4297261568 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 65 +-qemu-io> wrote 32768/32768 bytes at offset 4297359872 ++=== IO: pattern 65 ++wrote 32768/32768 bytes at offset 4297359872 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4297425408 ++wrote 32768/32768 bytes at offset 4297425408 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4297490944 ++wrote 32768/32768 bytes at offset 4297490944 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4297556480 ++wrote 32768/32768 bytes at offset 4297556480 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4297622016 ++wrote 32768/32768 bytes at offset 4297622016 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4297687552 ++wrote 32768/32768 bytes at offset 4297687552 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4297753088 ++wrote 32768/32768 bytes at offset 4297753088 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4297818624 ++wrote 32768/32768 bytes at offset 4297818624 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4297884160 ++wrote 32768/32768 bytes at offset 4297884160 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4297949696 ++wrote 32768/32768 bytes at offset 4297949696 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4298015232 ++wrote 32768/32768 bytes at offset 4298015232 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4298080768 ++wrote 32768/32768 bytes at offset 4298080768 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4298146304 ++wrote 32768/32768 bytes at offset 4298146304 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4298211840 ++wrote 32768/32768 bytes at offset 4298211840 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4298277376 ++wrote 32768/32768 bytes at offset 4298277376 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4298342912 ++wrote 32768/32768 bytes at offset 4298342912 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4298408448 ++wrote 32768/32768 bytes at offset 4298408448 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4298473984 ++wrote 32768/32768 bytes at offset 4298473984 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4298539520 ++wrote 32768/32768 bytes at offset 4298539520 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4298605056 ++wrote 32768/32768 bytes at offset 4298605056 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4298670592 ++wrote 32768/32768 bytes at offset 4298670592 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4298736128 ++wrote 32768/32768 bytes at offset 4298736128 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4298801664 ++wrote 32768/32768 bytes at offset 4298801664 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4298867200 ++wrote 32768/32768 bytes at offset 4298867200 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4298932736 ++wrote 32768/32768 bytes at offset 4298932736 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4298998272 ++wrote 32768/32768 bytes at offset 4298998272 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4299063808 ++wrote 32768/32768 bytes at offset 4299063808 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4299129344 ++wrote 32768/32768 bytes at offset 4299129344 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4299194880 ++wrote 32768/32768 bytes at offset 4299194880 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4299260416 ++wrote 32768/32768 bytes at offset 4299260416 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4299325952 ++wrote 32768/32768 bytes at offset 4299325952 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4299391488 ++wrote 32768/32768 bytes at offset 4299391488 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4299457024 ++wrote 32768/32768 bytes at offset 4299457024 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4299522560 ++wrote 32768/32768 bytes at offset 4299522560 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4299588096 ++wrote 32768/32768 bytes at offset 4299588096 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4299653632 ++wrote 32768/32768 bytes at offset 4299653632 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 1 +-qemu-io> wrote 32768/32768 bytes at offset 4299686400 ++=== IO: pattern 1 ++wrote 32768/32768 bytes at offset 4299686400 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4299751936 ++wrote 32768/32768 bytes at offset 4299751936 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4299817472 ++wrote 32768/32768 bytes at offset 4299817472 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4299883008 ++wrote 32768/32768 bytes at offset 4299883008 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4299948544 ++wrote 32768/32768 bytes at offset 4299948544 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4300014080 ++wrote 32768/32768 bytes at offset 4300014080 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4300079616 ++wrote 32768/32768 bytes at offset 4300079616 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4300145152 ++wrote 32768/32768 bytes at offset 4300145152 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4300210688 ++wrote 32768/32768 bytes at offset 4300210688 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4300276224 ++wrote 32768/32768 bytes at offset 4300276224 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4300341760 ++wrote 32768/32768 bytes at offset 4300341760 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4300407296 ++wrote 32768/32768 bytes at offset 4300407296 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4300472832 ++wrote 32768/32768 bytes at offset 4300472832 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4300538368 ++wrote 32768/32768 bytes at offset 4300538368 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4300603904 ++wrote 32768/32768 bytes at offset 4300603904 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4300669440 ++wrote 32768/32768 bytes at offset 4300669440 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4300734976 ++wrote 32768/32768 bytes at offset 4300734976 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4300800512 ++wrote 32768/32768 bytes at offset 4300800512 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4300866048 ++wrote 32768/32768 bytes at offset 4300866048 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4300931584 ++wrote 32768/32768 bytes at offset 4300931584 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4300997120 ++wrote 32768/32768 bytes at offset 4300997120 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4301062656 ++wrote 32768/32768 bytes at offset 4301062656 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4301128192 ++wrote 32768/32768 bytes at offset 4301128192 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4301193728 ++wrote 32768/32768 bytes at offset 4301193728 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4301259264 ++wrote 32768/32768 bytes at offset 4301259264 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4301324800 ++wrote 32768/32768 bytes at offset 4301324800 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4301390336 ++wrote 32768/32768 bytes at offset 4301390336 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4301455872 ++wrote 32768/32768 bytes at offset 4301455872 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4301521408 ++wrote 32768/32768 bytes at offset 4301521408 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4301586944 ++wrote 32768/32768 bytes at offset 4301586944 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4301652480 ++wrote 32768/32768 bytes at offset 4301652480 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4301718016 ++wrote 32768/32768 bytes at offset 4301718016 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4301783552 ++wrote 32768/32768 bytes at offset 4301783552 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4301849088 ++wrote 32768/32768 bytes at offset 4301849088 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4301914624 ++wrote 32768/32768 bytes at offset 4301914624 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4301980160 ++wrote 32768/32768 bytes at offset 4301980160 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 33 +-qemu-io> wrote 32768/32768 bytes at offset 4302062080 ++=== IO: pattern 33 ++wrote 32768/32768 bytes at offset 4302062080 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4302127616 ++wrote 32768/32768 bytes at offset 4302127616 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4302193152 ++wrote 32768/32768 bytes at offset 4302193152 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4302258688 ++wrote 32768/32768 bytes at offset 4302258688 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4302324224 ++wrote 32768/32768 bytes at offset 4302324224 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4302389760 ++wrote 32768/32768 bytes at offset 4302389760 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4302455296 ++wrote 32768/32768 bytes at offset 4302455296 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4302520832 ++wrote 32768/32768 bytes at offset 4302520832 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4302586368 ++wrote 32768/32768 bytes at offset 4302586368 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4302651904 ++wrote 32768/32768 bytes at offset 4302651904 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4302717440 ++wrote 32768/32768 bytes at offset 4302717440 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4302782976 ++wrote 32768/32768 bytes at offset 4302782976 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4302848512 ++wrote 32768/32768 bytes at offset 4302848512 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4302914048 ++wrote 32768/32768 bytes at offset 4302914048 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4302979584 ++wrote 32768/32768 bytes at offset 4302979584 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4303045120 ++wrote 32768/32768 bytes at offset 4303045120 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4303110656 ++wrote 32768/32768 bytes at offset 4303110656 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4303176192 ++wrote 32768/32768 bytes at offset 4303176192 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4303241728 ++wrote 32768/32768 bytes at offset 4303241728 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4303307264 ++wrote 32768/32768 bytes at offset 4303307264 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4303372800 ++wrote 32768/32768 bytes at offset 4303372800 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4303438336 ++wrote 32768/32768 bytes at offset 4303438336 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4303503872 ++wrote 32768/32768 bytes at offset 4303503872 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4303569408 ++wrote 32768/32768 bytes at offset 4303569408 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4303634944 ++wrote 32768/32768 bytes at offset 4303634944 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4303700480 ++wrote 32768/32768 bytes at offset 4303700480 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4303766016 ++wrote 32768/32768 bytes at offset 4303766016 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4303831552 ++wrote 32768/32768 bytes at offset 4303831552 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4303897088 ++wrote 32768/32768 bytes at offset 4303897088 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4303962624 ++wrote 32768/32768 bytes at offset 4303962624 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4304028160 ++wrote 32768/32768 bytes at offset 4304028160 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4304093696 ++wrote 32768/32768 bytes at offset 4304093696 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4304159232 ++wrote 32768/32768 bytes at offset 4304159232 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4304224768 ++wrote 32768/32768 bytes at offset 4304224768 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4304290304 ++wrote 32768/32768 bytes at offset 4304290304 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset 4304355840 ++wrote 32768/32768 bytes at offset 4304355840 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 65 +-qemu-io> wrote 131072/131072 bytes at offset 4304437760 ++=== IO: pattern 65 ++wrote 131072/131072 bytes at offset 4304437760 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 131072/131072 bytes at offset 4304634368 ++wrote 131072/131072 bytes at offset 4304634368 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 131072/131072 bytes at offset 4304830976 ++wrote 131072/131072 bytes at offset 4304830976 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 131072/131072 bytes at offset 4305027584 ++wrote 131072/131072 bytes at offset 4305027584 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 131072/131072 bytes at offset 4305224192 ++wrote 131072/131072 bytes at offset 4305224192 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 131072/131072 bytes at offset 4305420800 ++wrote 131072/131072 bytes at offset 4305420800 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 131072/131072 bytes at offset 4305617408 ++wrote 131072/131072 bytes at offset 4305617408 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 131072/131072 bytes at offset 4305814016 ++wrote 131072/131072 bytes at offset 4305814016 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 131072/131072 bytes at offset 4306010624 ++wrote 131072/131072 bytes at offset 4306010624 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 64 +-qemu-io> wrote 196608/196608 bytes at offset 4831739904 ++=== IO: pattern 64 ++wrote 196608/196608 bytes at offset 4831739904 + 192 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 196608/196608 bytes at offset 5368643584 ++wrote 196608/196608 bytes at offset 5368643584 + 192 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 196608/196608 bytes at offset 5905547264 ++wrote 196608/196608 bytes at offset 5905547264 + 192 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 1 +-qemu-io> read 65536/65536 bytes at offset 4294967808 ++=== IO: pattern 1 ++read 65536/65536 bytes at offset 4294967808 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4295033344 ++read 65536/65536 bytes at offset 4295033344 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4295098880 ++read 65536/65536 bytes at offset 4295098880 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4295164416 ++read 65536/65536 bytes at offset 4295164416 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4295229952 ++read 65536/65536 bytes at offset 4295229952 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4295295488 ++read 65536/65536 bytes at offset 4295295488 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4295361024 ++read 65536/65536 bytes at offset 4295361024 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4295426560 ++read 65536/65536 bytes at offset 4295426560 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4295492096 ++read 65536/65536 bytes at offset 4295492096 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4295557632 ++read 65536/65536 bytes at offset 4295557632 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4295623168 ++read 65536/65536 bytes at offset 4295623168 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4295688704 ++read 65536/65536 bytes at offset 4295688704 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4295754240 ++read 65536/65536 bytes at offset 4295754240 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4295819776 ++read 65536/65536 bytes at offset 4295819776 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4295885312 ++read 65536/65536 bytes at offset 4295885312 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4295950848 ++read 65536/65536 bytes at offset 4295950848 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4296016384 ++read 65536/65536 bytes at offset 4296016384 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4296081920 ++read 65536/65536 bytes at offset 4296081920 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4296147456 ++read 65536/65536 bytes at offset 4296147456 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4296212992 ++read 65536/65536 bytes at offset 4296212992 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4296278528 ++read 65536/65536 bytes at offset 4296278528 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4296344064 ++read 65536/65536 bytes at offset 4296344064 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4296409600 ++read 65536/65536 bytes at offset 4296409600 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4296475136 ++read 65536/65536 bytes at offset 4296475136 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4296540672 ++read 65536/65536 bytes at offset 4296540672 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4296606208 ++read 65536/65536 bytes at offset 4296606208 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4296671744 ++read 65536/65536 bytes at offset 4296671744 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4296737280 ++read 65536/65536 bytes at offset 4296737280 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4296802816 ++read 65536/65536 bytes at offset 4296802816 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4296868352 ++read 65536/65536 bytes at offset 4296868352 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4296933888 ++read 65536/65536 bytes at offset 4296933888 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4296999424 ++read 65536/65536 bytes at offset 4296999424 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4297064960 ++read 65536/65536 bytes at offset 4297064960 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4297130496 ++read 65536/65536 bytes at offset 4297130496 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4297196032 ++read 65536/65536 bytes at offset 4297196032 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4297261568 ++read 65536/65536 bytes at offset 4297261568 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 65 +-qemu-io> read 32768/32768 bytes at offset 4297359872 ++=== IO: pattern 65 ++read 32768/32768 bytes at offset 4297359872 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4297425408 ++read 32768/32768 bytes at offset 4297425408 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4297490944 ++read 32768/32768 bytes at offset 4297490944 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4297556480 ++read 32768/32768 bytes at offset 4297556480 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4297622016 ++read 32768/32768 bytes at offset 4297622016 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4297687552 ++read 32768/32768 bytes at offset 4297687552 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4297753088 ++read 32768/32768 bytes at offset 4297753088 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4297818624 ++read 32768/32768 bytes at offset 4297818624 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4297884160 ++read 32768/32768 bytes at offset 4297884160 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4297949696 ++read 32768/32768 bytes at offset 4297949696 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4298015232 ++read 32768/32768 bytes at offset 4298015232 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4298080768 ++read 32768/32768 bytes at offset 4298080768 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4298146304 ++read 32768/32768 bytes at offset 4298146304 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4298211840 ++read 32768/32768 bytes at offset 4298211840 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4298277376 ++read 32768/32768 bytes at offset 4298277376 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4298342912 ++read 32768/32768 bytes at offset 4298342912 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4298408448 ++read 32768/32768 bytes at offset 4298408448 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4298473984 ++read 32768/32768 bytes at offset 4298473984 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4298539520 ++read 32768/32768 bytes at offset 4298539520 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4298605056 ++read 32768/32768 bytes at offset 4298605056 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4298670592 ++read 32768/32768 bytes at offset 4298670592 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4298736128 ++read 32768/32768 bytes at offset 4298736128 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4298801664 ++read 32768/32768 bytes at offset 4298801664 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4298867200 ++read 32768/32768 bytes at offset 4298867200 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4298932736 ++read 32768/32768 bytes at offset 4298932736 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4298998272 ++read 32768/32768 bytes at offset 4298998272 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4299063808 ++read 32768/32768 bytes at offset 4299063808 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4299129344 ++read 32768/32768 bytes at offset 4299129344 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4299194880 ++read 32768/32768 bytes at offset 4299194880 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4299260416 ++read 32768/32768 bytes at offset 4299260416 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4299325952 ++read 32768/32768 bytes at offset 4299325952 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4299391488 ++read 32768/32768 bytes at offset 4299391488 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4299457024 ++read 32768/32768 bytes at offset 4299457024 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4299522560 ++read 32768/32768 bytes at offset 4299522560 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4299588096 ++read 32768/32768 bytes at offset 4299588096 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4299653632 ++read 32768/32768 bytes at offset 4299653632 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 1 +-qemu-io> read 32768/32768 bytes at offset 4299686400 ++=== IO: pattern 1 ++read 32768/32768 bytes at offset 4299686400 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4299751936 ++read 32768/32768 bytes at offset 4299751936 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4299817472 ++read 32768/32768 bytes at offset 4299817472 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4299883008 ++read 32768/32768 bytes at offset 4299883008 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4299948544 ++read 32768/32768 bytes at offset 4299948544 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4300014080 ++read 32768/32768 bytes at offset 4300014080 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4300079616 ++read 32768/32768 bytes at offset 4300079616 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4300145152 ++read 32768/32768 bytes at offset 4300145152 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4300210688 ++read 32768/32768 bytes at offset 4300210688 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4300276224 ++read 32768/32768 bytes at offset 4300276224 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4300341760 ++read 32768/32768 bytes at offset 4300341760 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4300407296 ++read 32768/32768 bytes at offset 4300407296 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4300472832 ++read 32768/32768 bytes at offset 4300472832 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4300538368 ++read 32768/32768 bytes at offset 4300538368 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4300603904 ++read 32768/32768 bytes at offset 4300603904 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4300669440 ++read 32768/32768 bytes at offset 4300669440 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4300734976 ++read 32768/32768 bytes at offset 4300734976 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4300800512 ++read 32768/32768 bytes at offset 4300800512 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4300866048 ++read 32768/32768 bytes at offset 4300866048 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4300931584 ++read 32768/32768 bytes at offset 4300931584 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4300997120 ++read 32768/32768 bytes at offset 4300997120 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4301062656 ++read 32768/32768 bytes at offset 4301062656 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4301128192 ++read 32768/32768 bytes at offset 4301128192 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4301193728 ++read 32768/32768 bytes at offset 4301193728 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4301259264 ++read 32768/32768 bytes at offset 4301259264 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4301324800 ++read 32768/32768 bytes at offset 4301324800 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4301390336 ++read 32768/32768 bytes at offset 4301390336 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4301455872 ++read 32768/32768 bytes at offset 4301455872 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4301521408 ++read 32768/32768 bytes at offset 4301521408 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4301586944 ++read 32768/32768 bytes at offset 4301586944 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4301652480 ++read 32768/32768 bytes at offset 4301652480 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4301718016 ++read 32768/32768 bytes at offset 4301718016 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4301783552 ++read 32768/32768 bytes at offset 4301783552 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4301849088 ++read 32768/32768 bytes at offset 4301849088 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4301914624 ++read 32768/32768 bytes at offset 4301914624 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4301980160 ++read 32768/32768 bytes at offset 4301980160 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 33 +-qemu-io> read 32768/32768 bytes at offset 4302062080 ++=== IO: pattern 33 ++read 32768/32768 bytes at offset 4302062080 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4302127616 ++read 32768/32768 bytes at offset 4302127616 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4302193152 ++read 32768/32768 bytes at offset 4302193152 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4302258688 ++read 32768/32768 bytes at offset 4302258688 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4302324224 ++read 32768/32768 bytes at offset 4302324224 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4302389760 ++read 32768/32768 bytes at offset 4302389760 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4302455296 ++read 32768/32768 bytes at offset 4302455296 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4302520832 ++read 32768/32768 bytes at offset 4302520832 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4302586368 ++read 32768/32768 bytes at offset 4302586368 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4302651904 ++read 32768/32768 bytes at offset 4302651904 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4302717440 ++read 32768/32768 bytes at offset 4302717440 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4302782976 ++read 32768/32768 bytes at offset 4302782976 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4302848512 ++read 32768/32768 bytes at offset 4302848512 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4302914048 ++read 32768/32768 bytes at offset 4302914048 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4302979584 ++read 32768/32768 bytes at offset 4302979584 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4303045120 ++read 32768/32768 bytes at offset 4303045120 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4303110656 ++read 32768/32768 bytes at offset 4303110656 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4303176192 ++read 32768/32768 bytes at offset 4303176192 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4303241728 ++read 32768/32768 bytes at offset 4303241728 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4303307264 ++read 32768/32768 bytes at offset 4303307264 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4303372800 ++read 32768/32768 bytes at offset 4303372800 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4303438336 ++read 32768/32768 bytes at offset 4303438336 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4303503872 ++read 32768/32768 bytes at offset 4303503872 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4303569408 ++read 32768/32768 bytes at offset 4303569408 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4303634944 ++read 32768/32768 bytes at offset 4303634944 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4303700480 ++read 32768/32768 bytes at offset 4303700480 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4303766016 ++read 32768/32768 bytes at offset 4303766016 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4303831552 ++read 32768/32768 bytes at offset 4303831552 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4303897088 ++read 32768/32768 bytes at offset 4303897088 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4303962624 ++read 32768/32768 bytes at offset 4303962624 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4304028160 ++read 32768/32768 bytes at offset 4304028160 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4304093696 ++read 32768/32768 bytes at offset 4304093696 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4304159232 ++read 32768/32768 bytes at offset 4304159232 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4304224768 ++read 32768/32768 bytes at offset 4304224768 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4304290304 ++read 32768/32768 bytes at offset 4304290304 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4304355840 ++read 32768/32768 bytes at offset 4304355840 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 65 +-qemu-io> read 131072/131072 bytes at offset 4304437760 ++=== IO: pattern 65 ++read 131072/131072 bytes at offset 4304437760 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 131072/131072 bytes at offset 4304634368 ++read 131072/131072 bytes at offset 4304634368 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 131072/131072 bytes at offset 4304830976 ++read 131072/131072 bytes at offset 4304830976 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 131072/131072 bytes at offset 4305027584 ++read 131072/131072 bytes at offset 4305027584 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 131072/131072 bytes at offset 4305224192 ++read 131072/131072 bytes at offset 4305224192 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 131072/131072 bytes at offset 4305420800 ++read 131072/131072 bytes at offset 4305420800 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 131072/131072 bytes at offset 4305617408 ++read 131072/131072 bytes at offset 4305617408 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 131072/131072 bytes at offset 4305814016 ++read 131072/131072 bytes at offset 4305814016 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 131072/131072 bytes at offset 4306010624 ++read 131072/131072 bytes at offset 4306010624 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 64 +-qemu-io> read 196608/196608 bytes at offset 4831739904 ++=== IO: pattern 64 ++read 196608/196608 bytes at offset 4831739904 + 192 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 196608/196608 bytes at offset 5368643584 ++read 196608/196608 bytes at offset 5368643584 + 192 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 196608/196608 bytes at offset 5905547264 ++read 196608/196608 bytes at offset 5905547264 + 192 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> No errors were found on the image. ++No errors were found on the image. + Creating another new image + + Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=8589934592 +@@ -25488,219 +25488,219 @@ More complex patterns + test2: With offset 0 + === Clusters to be compressed [1] + === IO: pattern 165 +-qemu-io> wrote 65536/65536 bytes at offset 262144 ++wrote 65536/65536 bytes at offset 262144 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 851968 ++wrote 65536/65536 bytes at offset 851968 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 1441792 ++wrote 65536/65536 bytes at offset 1441792 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 2031616 ++wrote 65536/65536 bytes at offset 2031616 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === Clusters to be compressed [2] ++=== Clusters to be compressed [2] + === IO: pattern 165 +-qemu-io> wrote 65536/65536 bytes at offset 327680 ++wrote 65536/65536 bytes at offset 327680 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 917504 ++wrote 65536/65536 bytes at offset 917504 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 1507328 ++wrote 65536/65536 bytes at offset 1507328 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 2097152 ++wrote 65536/65536 bytes at offset 2097152 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === Clusters to be compressed [3] ++=== Clusters to be compressed [3] + === IO: pattern 165 +-qemu-io> wrote 65536/65536 bytes at offset 524288 ++wrote 65536/65536 bytes at offset 524288 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 1114112 ++wrote 65536/65536 bytes at offset 1114112 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 1703936 ++wrote 65536/65536 bytes at offset 1703936 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 2293760 ++wrote 65536/65536 bytes at offset 2293760 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === Used clusters [1] ++=== Used clusters [1] + === IO: pattern 165 +-qemu-io> wrote 65536/65536 bytes at offset 0 ++wrote 65536/65536 bytes at offset 0 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 589824 ++wrote 65536/65536 bytes at offset 589824 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 1179648 ++wrote 65536/65536 bytes at offset 1179648 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 1769472 ++wrote 65536/65536 bytes at offset 1769472 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === Used clusters [2] ++=== Used clusters [2] + === IO: pattern 165 +-qemu-io> wrote 65536/65536 bytes at offset 65536 ++wrote 65536/65536 bytes at offset 65536 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 655360 ++wrote 65536/65536 bytes at offset 655360 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 1245184 ++wrote 65536/65536 bytes at offset 1245184 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 1835008 ++wrote 65536/65536 bytes at offset 1835008 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === Used clusters [3] ++=== Used clusters [3] + === IO: pattern 165 +-qemu-io> wrote 65536/65536 bytes at offset 196608 ++wrote 65536/65536 bytes at offset 196608 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 786432 ++wrote 65536/65536 bytes at offset 786432 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 1376256 ++wrote 65536/65536 bytes at offset 1376256 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 1966080 ++wrote 65536/65536 bytes at offset 1966080 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === Read used/compressed clusters ++=== Read used/compressed clusters + === IO: pattern 165 +-qemu-io> read 131072/131072 bytes at offset 0 ++read 131072/131072 bytes at offset 0 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 131072/131072 bytes at offset 589824 ++read 131072/131072 bytes at offset 589824 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 131072/131072 bytes at offset 1179648 ++read 131072/131072 bytes at offset 1179648 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 131072/131072 bytes at offset 1769472 ++read 131072/131072 bytes at offset 1769472 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 165 +-qemu-io> read 196608/196608 bytes at offset 196608 ++=== IO: pattern 165 ++read 196608/196608 bytes at offset 196608 + 192 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 196608/196608 bytes at offset 786432 ++read 196608/196608 bytes at offset 786432 + 192 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 196608/196608 bytes at offset 1376256 ++read 196608/196608 bytes at offset 1376256 + 192 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 196608/196608 bytes at offset 1966080 ++read 196608/196608 bytes at offset 1966080 + 192 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 165 +-qemu-io> read 65536/65536 bytes at offset 524288 ++=== IO: pattern 165 ++read 65536/65536 bytes at offset 524288 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 1114112 ++read 65536/65536 bytes at offset 1114112 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 1703936 ++read 65536/65536 bytes at offset 1703936 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 2293760 ++read 65536/65536 bytes at offset 2293760 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === Read zeros ++=== Read zeros + === IO: pattern 0 +-qemu-io> read 65536/65536 bytes at offset 131072 ++read 65536/65536 bytes at offset 131072 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 720896 ++read 65536/65536 bytes at offset 720896 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 1310720 ++read 65536/65536 bytes at offset 1310720 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 1900544 ++read 65536/65536 bytes at offset 1900544 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> read 131072/131072 bytes at offset 393216 ++=== IO: pattern 0 ++read 131072/131072 bytes at offset 393216 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 131072/131072 bytes at offset 983040 ++read 131072/131072 bytes at offset 983040 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 131072/131072 bytes at offset 1572864 ++read 131072/131072 bytes at offset 1572864 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 131072/131072 bytes at offset 2162688 ++read 131072/131072 bytes at offset 2162688 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> No errors were found on the image. ++No errors were found on the image. + test2: With offset 4294967296 + === Clusters to be compressed [1] + === IO: pattern 165 +-qemu-io> wrote 65536/65536 bytes at offset 4295229440 ++wrote 65536/65536 bytes at offset 4295229440 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4295819264 ++wrote 65536/65536 bytes at offset 4295819264 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4296409088 ++wrote 65536/65536 bytes at offset 4296409088 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4296998912 ++wrote 65536/65536 bytes at offset 4296998912 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === Clusters to be compressed [2] ++=== Clusters to be compressed [2] + === IO: pattern 165 +-qemu-io> wrote 65536/65536 bytes at offset 4295294976 ++wrote 65536/65536 bytes at offset 4295294976 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4295884800 ++wrote 65536/65536 bytes at offset 4295884800 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4296474624 ++wrote 65536/65536 bytes at offset 4296474624 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4297064448 ++wrote 65536/65536 bytes at offset 4297064448 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === Clusters to be compressed [3] ++=== Clusters to be compressed [3] + === IO: pattern 165 +-qemu-io> wrote 65536/65536 bytes at offset 4295491584 ++wrote 65536/65536 bytes at offset 4295491584 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4296081408 ++wrote 65536/65536 bytes at offset 4296081408 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4296671232 ++wrote 65536/65536 bytes at offset 4296671232 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4297261056 ++wrote 65536/65536 bytes at offset 4297261056 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === Used clusters [1] ++=== Used clusters [1] + === IO: pattern 165 +-qemu-io> wrote 65536/65536 bytes at offset 4294967296 ++wrote 65536/65536 bytes at offset 4294967296 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4295557120 ++wrote 65536/65536 bytes at offset 4295557120 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4296146944 ++wrote 65536/65536 bytes at offset 4296146944 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4296736768 ++wrote 65536/65536 bytes at offset 4296736768 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === Used clusters [2] ++=== Used clusters [2] + === IO: pattern 165 +-qemu-io> wrote 65536/65536 bytes at offset 4295032832 ++wrote 65536/65536 bytes at offset 4295032832 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4295622656 ++wrote 65536/65536 bytes at offset 4295622656 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4296212480 ++wrote 65536/65536 bytes at offset 4296212480 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4296802304 ++wrote 65536/65536 bytes at offset 4296802304 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === Used clusters [3] ++=== Used clusters [3] + === IO: pattern 165 +-qemu-io> wrote 65536/65536 bytes at offset 4295163904 ++wrote 65536/65536 bytes at offset 4295163904 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4295753728 ++wrote 65536/65536 bytes at offset 4295753728 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4296343552 ++wrote 65536/65536 bytes at offset 4296343552 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4296933376 ++wrote 65536/65536 bytes at offset 4296933376 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === Read used/compressed clusters ++=== Read used/compressed clusters + === IO: pattern 165 +-qemu-io> read 131072/131072 bytes at offset 4294967296 ++read 131072/131072 bytes at offset 4294967296 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 131072/131072 bytes at offset 4295557120 ++read 131072/131072 bytes at offset 4295557120 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 131072/131072 bytes at offset 4296146944 ++read 131072/131072 bytes at offset 4296146944 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 131072/131072 bytes at offset 4296736768 ++read 131072/131072 bytes at offset 4296736768 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 165 +-qemu-io> read 196608/196608 bytes at offset 4295163904 ++=== IO: pattern 165 ++read 196608/196608 bytes at offset 4295163904 + 192 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 196608/196608 bytes at offset 4295753728 ++read 196608/196608 bytes at offset 4295753728 + 192 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 196608/196608 bytes at offset 4296343552 ++read 196608/196608 bytes at offset 4296343552 + 192 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 196608/196608 bytes at offset 4296933376 ++read 196608/196608 bytes at offset 4296933376 + 192 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 165 +-qemu-io> read 65536/65536 bytes at offset 4295491584 ++=== IO: pattern 165 ++read 65536/65536 bytes at offset 4295491584 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4296081408 ++read 65536/65536 bytes at offset 4296081408 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4296671232 ++read 65536/65536 bytes at offset 4296671232 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4297261056 ++read 65536/65536 bytes at offset 4297261056 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === Read zeros ++=== Read zeros + === IO: pattern 0 +-qemu-io> read 65536/65536 bytes at offset 4295098368 ++read 65536/65536 bytes at offset 4295098368 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4295688192 ++read 65536/65536 bytes at offset 4295688192 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4296278016 ++read 65536/65536 bytes at offset 4296278016 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4296867840 ++read 65536/65536 bytes at offset 4296867840 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> read 131072/131072 bytes at offset 4295360512 ++=== IO: pattern 0 ++read 131072/131072 bytes at offset 4295360512 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 131072/131072 bytes at offset 4295950336 ++read 131072/131072 bytes at offset 4295950336 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 131072/131072 bytes at offset 4296540160 ++read 131072/131072 bytes at offset 4296540160 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 131072/131072 bytes at offset 4297129984 ++read 131072/131072 bytes at offset 4297129984 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> No errors were found on the image. ++No errors were found on the image. + *** done +diff --git a/tests/qemu-iotests/024.out b/tests/qemu-iotests/024.out +index 072207c..e84b973 100644 +--- a/tests/qemu-iotests/024.out ++++ b/tests/qemu-iotests/024.out +@@ -3,142 +3,142 @@ Creating backing file + + Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824 + === IO: pattern 0x11 +-qemu-io> wrote 65536/65536 bytes at offset 0 ++wrote 65536/65536 bytes at offset 0 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 131072 ++wrote 65536/65536 bytes at offset 131072 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 262144 ++wrote 65536/65536 bytes at offset 262144 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 393216 ++wrote 65536/65536 bytes at offset 393216 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 524288 ++wrote 65536/65536 bytes at offset 524288 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 655360 ++wrote 65536/65536 bytes at offset 655360 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 786432 ++wrote 65536/65536 bytes at offset 786432 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 917504 ++wrote 65536/65536 bytes at offset 917504 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> Creating new backing file ++Creating new backing file + + Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824 + === IO: pattern 0x22 +-qemu-io> wrote 131072/131072 bytes at offset 0 ++wrote 131072/131072 bytes at offset 0 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 131072/131072 bytes at offset 262144 ++wrote 131072/131072 bytes at offset 262144 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 131072/131072 bytes at offset 524288 ++wrote 131072/131072 bytes at offset 524288 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 131072/131072 bytes at offset 786432 ++wrote 131072/131072 bytes at offset 786432 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> Creating COW image ++Creating COW image + + Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824 backing_file='TEST_DIR/t.IMGFMT.base_old' + === IO: pattern 0x33 +-qemu-io> wrote 262144/262144 bytes at offset 0 ++wrote 262144/262144 bytes at offset 0 + 256 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0x33 +-qemu-io> wrote 262144/262144 bytes at offset 524288 ++=== IO: pattern 0x33 ++wrote 262144/262144 bytes at offset 524288 + 256 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> Read before the rebase to make sure everything is set up correctly ++Read before the rebase to make sure everything is set up correctly + + === IO: pattern 0x33 +-qemu-io> read 65536/65536 bytes at offset 0 ++read 65536/65536 bytes at offset 0 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0x33 +-qemu-io> read 65536/65536 bytes at offset 65536 ++=== IO: pattern 0x33 ++read 65536/65536 bytes at offset 65536 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0x33 +-qemu-io> read 65536/65536 bytes at offset 131072 ++=== IO: pattern 0x33 ++read 65536/65536 bytes at offset 131072 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0x33 +-qemu-io> read 65536/65536 bytes at offset 196608 ++=== IO: pattern 0x33 ++read 65536/65536 bytes at offset 196608 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0x11 +-qemu-io> read 65536/65536 bytes at offset 262144 ++=== IO: pattern 0x11 ++read 65536/65536 bytes at offset 262144 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0x00 +-qemu-io> read 65536/65536 bytes at offset 327680 ++=== IO: pattern 0x00 ++read 65536/65536 bytes at offset 327680 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0x11 +-qemu-io> read 65536/65536 bytes at offset 393216 ++=== IO: pattern 0x11 ++read 65536/65536 bytes at offset 393216 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0x00 +-qemu-io> read 65536/65536 bytes at offset 458752 ++=== IO: pattern 0x00 ++read 65536/65536 bytes at offset 458752 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0x33 +-qemu-io> read 65536/65536 bytes at offset 524288 ++=== IO: pattern 0x33 ++read 65536/65536 bytes at offset 524288 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0x33 +-qemu-io> read 65536/65536 bytes at offset 589824 ++=== IO: pattern 0x33 ++read 65536/65536 bytes at offset 589824 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0x33 +-qemu-io> read 65536/65536 bytes at offset 655360 ++=== IO: pattern 0x33 ++read 65536/65536 bytes at offset 655360 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0x33 +-qemu-io> read 65536/65536 bytes at offset 720896 ++=== IO: pattern 0x33 ++read 65536/65536 bytes at offset 720896 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0x11 +-qemu-io> read 65536/65536 bytes at offset 786432 ++=== IO: pattern 0x11 ++read 65536/65536 bytes at offset 786432 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0x00 +-qemu-io> read 65536/65536 bytes at offset 851968 ++=== IO: pattern 0x00 ++read 65536/65536 bytes at offset 851968 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0x11 +-qemu-io> read 65536/65536 bytes at offset 917504 ++=== IO: pattern 0x11 ++read 65536/65536 bytes at offset 917504 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0x00 +-qemu-io> read 65536/65536 bytes at offset 983040 ++=== IO: pattern 0x00 ++read 65536/65536 bytes at offset 983040 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> ++ + Rebase and test again + + === IO: pattern 0x33 +-qemu-io> read 65536/65536 bytes at offset 0 ++read 65536/65536 bytes at offset 0 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0x33 +-qemu-io> read 65536/65536 bytes at offset 65536 ++=== IO: pattern 0x33 ++read 65536/65536 bytes at offset 65536 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0x33 +-qemu-io> read 65536/65536 bytes at offset 131072 ++=== IO: pattern 0x33 ++read 65536/65536 bytes at offset 131072 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0x33 +-qemu-io> read 65536/65536 bytes at offset 196608 ++=== IO: pattern 0x33 ++read 65536/65536 bytes at offset 196608 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0x11 +-qemu-io> read 65536/65536 bytes at offset 262144 ++=== IO: pattern 0x11 ++read 65536/65536 bytes at offset 262144 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0x00 +-qemu-io> read 65536/65536 bytes at offset 327680 ++=== IO: pattern 0x00 ++read 65536/65536 bytes at offset 327680 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0x11 +-qemu-io> read 65536/65536 bytes at offset 393216 ++=== IO: pattern 0x11 ++read 65536/65536 bytes at offset 393216 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0x00 +-qemu-io> read 65536/65536 bytes at offset 458752 ++=== IO: pattern 0x00 ++read 65536/65536 bytes at offset 458752 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0x33 +-qemu-io> read 65536/65536 bytes at offset 524288 ++=== IO: pattern 0x33 ++read 65536/65536 bytes at offset 524288 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0x33 +-qemu-io> read 65536/65536 bytes at offset 589824 ++=== IO: pattern 0x33 ++read 65536/65536 bytes at offset 589824 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0x33 +-qemu-io> read 65536/65536 bytes at offset 655360 ++=== IO: pattern 0x33 ++read 65536/65536 bytes at offset 655360 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0x33 +-qemu-io> read 65536/65536 bytes at offset 720896 ++=== IO: pattern 0x33 ++read 65536/65536 bytes at offset 720896 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0x11 +-qemu-io> read 65536/65536 bytes at offset 786432 ++=== IO: pattern 0x11 ++read 65536/65536 bytes at offset 786432 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0x00 +-qemu-io> read 65536/65536 bytes at offset 851968 ++=== IO: pattern 0x00 ++read 65536/65536 bytes at offset 851968 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0x11 +-qemu-io> read 65536/65536 bytes at offset 917504 ++=== IO: pattern 0x11 ++read 65536/65536 bytes at offset 917504 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0x00 +-qemu-io> read 65536/65536 bytes at offset 983040 ++=== IO: pattern 0x00 ++read 65536/65536 bytes at offset 983040 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> *** done ++*** done +diff --git a/tests/qemu-iotests/025.out b/tests/qemu-iotests/025.out +index d245727..8c695e6 100644 +--- a/tests/qemu-iotests/025.out ++++ b/tests/qemu-iotests/025.out +@@ -5,23 +5,23 @@ Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=134217728 + + === Writing whole image + === IO: pattern 0xc5 +-qemu-io> wrote 134217728/134217728 bytes at offset 0 ++wrote 134217728/134217728 bytes at offset 0 + 128 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> No errors were found on the image. ++No errors were found on the image. + + === Resizing image +-qemu-io> 128 MiB +-qemu-io> qemu-io> 384 MiB +-qemu-io> No errors were found on the image. ++128 MiB ++384 MiB ++No errors were found on the image. + + === Verifying image size after reopen + 384 MiB + + === Verifying resized image + === IO: pattern 0xc5 +-qemu-io> read 134217728/134217728 bytes at offset 0 ++read 134217728/134217728 bytes at offset 0 + 128 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> read 268435456/268435456 bytes at offset 134217728 ++=== IO: pattern 0 ++read 268435456/268435456 bytes at offset 134217728 + 256 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> *** done ++*** done +diff --git a/tests/qemu-iotests/028.out b/tests/qemu-iotests/028.out +index 8b6cfcb..8affb7f 100644 +--- a/tests/qemu-iotests/028.out ++++ b/tests/qemu-iotests/028.out +@@ -3,467 +3,467 @@ Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=3221227008 + Filling base image + + === IO: pattern 195 +-qemu-io> wrote 512/512 bytes at offset 3221194240 ++wrote 512/512 bytes at offset 3221194240 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 3221195264 ++wrote 512/512 bytes at offset 3221195264 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 3221196288 ++wrote 512/512 bytes at offset 3221196288 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 3221197312 ++wrote 512/512 bytes at offset 3221197312 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 3221198336 ++wrote 512/512 bytes at offset 3221198336 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 3221199360 ++wrote 512/512 bytes at offset 3221199360 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 3221200384 ++wrote 512/512 bytes at offset 3221200384 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 3221201408 ++wrote 512/512 bytes at offset 3221201408 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 3221202432 ++wrote 512/512 bytes at offset 3221202432 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 3221203456 ++wrote 512/512 bytes at offset 3221203456 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 3221204480 ++wrote 512/512 bytes at offset 3221204480 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 3221205504 ++wrote 512/512 bytes at offset 3221205504 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 3221206528 ++wrote 512/512 bytes at offset 3221206528 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 3221207552 ++wrote 512/512 bytes at offset 3221207552 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 3221208576 ++wrote 512/512 bytes at offset 3221208576 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 3221209600 ++wrote 512/512 bytes at offset 3221209600 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 3221210624 ++wrote 512/512 bytes at offset 3221210624 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 3221211648 ++wrote 512/512 bytes at offset 3221211648 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 3221212672 ++wrote 512/512 bytes at offset 3221212672 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 3221213696 ++wrote 512/512 bytes at offset 3221213696 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 3221214720 ++wrote 512/512 bytes at offset 3221214720 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 3221215744 ++wrote 512/512 bytes at offset 3221215744 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 3221216768 ++wrote 512/512 bytes at offset 3221216768 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 3221217792 ++wrote 512/512 bytes at offset 3221217792 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 3221218816 ++wrote 512/512 bytes at offset 3221218816 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 3221219840 ++wrote 512/512 bytes at offset 3221219840 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 3221220864 ++wrote 512/512 bytes at offset 3221220864 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 3221221888 ++wrote 512/512 bytes at offset 3221221888 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 3221222912 ++wrote 512/512 bytes at offset 3221222912 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 3221223936 ++wrote 512/512 bytes at offset 3221223936 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 3221224960 ++wrote 512/512 bytes at offset 3221224960 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 3221225984 ++wrote 512/512 bytes at offset 3221225984 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> No errors were found on the image. ++No errors were found on the image. + Creating test image with backing file + + Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=4294968832 backing_file='TEST_DIR/t.IMGFMT.base' + Filling test image + + === IO: pattern 196 +-qemu-io> wrote 512/512 bytes at offset 3221194752 ++wrote 512/512 bytes at offset 3221194752 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 3221195776 ++wrote 512/512 bytes at offset 3221195776 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 3221196800 ++wrote 512/512 bytes at offset 3221196800 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 3221197824 ++wrote 512/512 bytes at offset 3221197824 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 3221198848 ++wrote 512/512 bytes at offset 3221198848 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 3221199872 ++wrote 512/512 bytes at offset 3221199872 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 3221200896 ++wrote 512/512 bytes at offset 3221200896 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 3221201920 ++wrote 512/512 bytes at offset 3221201920 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 3221202944 ++wrote 512/512 bytes at offset 3221202944 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 3221203968 ++wrote 512/512 bytes at offset 3221203968 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 3221204992 ++wrote 512/512 bytes at offset 3221204992 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 3221206016 ++wrote 512/512 bytes at offset 3221206016 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 3221207040 ++wrote 512/512 bytes at offset 3221207040 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 3221208064 ++wrote 512/512 bytes at offset 3221208064 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 3221209088 ++wrote 512/512 bytes at offset 3221209088 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 3221210112 ++wrote 512/512 bytes at offset 3221210112 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 3221211136 ++wrote 512/512 bytes at offset 3221211136 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 3221212160 ++wrote 512/512 bytes at offset 3221212160 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 3221213184 ++wrote 512/512 bytes at offset 3221213184 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 3221214208 ++wrote 512/512 bytes at offset 3221214208 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 3221215232 ++wrote 512/512 bytes at offset 3221215232 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 3221216256 ++wrote 512/512 bytes at offset 3221216256 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 3221217280 ++wrote 512/512 bytes at offset 3221217280 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 3221218304 ++wrote 512/512 bytes at offset 3221218304 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 3221219328 ++wrote 512/512 bytes at offset 3221219328 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 3221220352 ++wrote 512/512 bytes at offset 3221220352 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 3221221376 ++wrote 512/512 bytes at offset 3221221376 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 3221222400 ++wrote 512/512 bytes at offset 3221222400 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 3221223424 ++wrote 512/512 bytes at offset 3221223424 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 3221224448 ++wrote 512/512 bytes at offset 3221224448 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 3221225472 ++wrote 512/512 bytes at offset 3221225472 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 3221226496 ++wrote 512/512 bytes at offset 3221226496 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 3221227520 ++wrote 512/512 bytes at offset 3221227520 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 3221228544 ++wrote 512/512 bytes at offset 3221228544 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 3221229568 ++wrote 512/512 bytes at offset 3221229568 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 3221230592 ++wrote 512/512 bytes at offset 3221230592 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 3221231616 ++wrote 512/512 bytes at offset 3221231616 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 3221232640 ++wrote 512/512 bytes at offset 3221232640 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 3221233664 ++wrote 512/512 bytes at offset 3221233664 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 3221234688 ++wrote 512/512 bytes at offset 3221234688 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 3221235712 ++wrote 512/512 bytes at offset 3221235712 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 3221236736 ++wrote 512/512 bytes at offset 3221236736 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 3221237760 ++wrote 512/512 bytes at offset 3221237760 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 3221238784 ++wrote 512/512 bytes at offset 3221238784 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 3221239808 ++wrote 512/512 bytes at offset 3221239808 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 3221240832 ++wrote 512/512 bytes at offset 3221240832 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 3221241856 ++wrote 512/512 bytes at offset 3221241856 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 3221242880 ++wrote 512/512 bytes at offset 3221242880 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 3221243904 ++wrote 512/512 bytes at offset 3221243904 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 3221244928 ++wrote 512/512 bytes at offset 3221244928 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 3221245952 ++wrote 512/512 bytes at offset 3221245952 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 3221246976 ++wrote 512/512 bytes at offset 3221246976 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 3221248000 ++wrote 512/512 bytes at offset 3221248000 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 3221249024 ++wrote 512/512 bytes at offset 3221249024 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 3221250048 ++wrote 512/512 bytes at offset 3221250048 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 3221251072 ++wrote 512/512 bytes at offset 3221251072 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 3221252096 ++wrote 512/512 bytes at offset 3221252096 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 3221253120 ++wrote 512/512 bytes at offset 3221253120 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 3221254144 ++wrote 512/512 bytes at offset 3221254144 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 3221255168 ++wrote 512/512 bytes at offset 3221255168 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 3221256192 ++wrote 512/512 bytes at offset 3221256192 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 3221257216 ++wrote 512/512 bytes at offset 3221257216 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 3221258240 ++wrote 512/512 bytes at offset 3221258240 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 3221259264 ++wrote 512/512 bytes at offset 3221259264 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> No errors were found on the image. ++No errors were found on the image. + Reading + + === IO: pattern 195 +-qemu-io> read 512/512 bytes at offset 3221194240 ++read 512/512 bytes at offset 3221194240 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221195264 ++read 512/512 bytes at offset 3221195264 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221196288 ++read 512/512 bytes at offset 3221196288 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221197312 ++read 512/512 bytes at offset 3221197312 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221198336 ++read 512/512 bytes at offset 3221198336 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221199360 ++read 512/512 bytes at offset 3221199360 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221200384 ++read 512/512 bytes at offset 3221200384 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221201408 ++read 512/512 bytes at offset 3221201408 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221202432 ++read 512/512 bytes at offset 3221202432 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221203456 ++read 512/512 bytes at offset 3221203456 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221204480 ++read 512/512 bytes at offset 3221204480 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221205504 ++read 512/512 bytes at offset 3221205504 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221206528 ++read 512/512 bytes at offset 3221206528 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221207552 ++read 512/512 bytes at offset 3221207552 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221208576 ++read 512/512 bytes at offset 3221208576 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221209600 ++read 512/512 bytes at offset 3221209600 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221210624 ++read 512/512 bytes at offset 3221210624 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221211648 ++read 512/512 bytes at offset 3221211648 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221212672 ++read 512/512 bytes at offset 3221212672 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221213696 ++read 512/512 bytes at offset 3221213696 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221214720 ++read 512/512 bytes at offset 3221214720 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221215744 ++read 512/512 bytes at offset 3221215744 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221216768 ++read 512/512 bytes at offset 3221216768 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221217792 ++read 512/512 bytes at offset 3221217792 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221218816 ++read 512/512 bytes at offset 3221218816 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221219840 ++read 512/512 bytes at offset 3221219840 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221220864 ++read 512/512 bytes at offset 3221220864 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221221888 ++read 512/512 bytes at offset 3221221888 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221222912 ++read 512/512 bytes at offset 3221222912 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221223936 ++read 512/512 bytes at offset 3221223936 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221224960 ++read 512/512 bytes at offset 3221224960 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221225984 ++read 512/512 bytes at offset 3221225984 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 196 +-qemu-io> read 512/512 bytes at offset 3221194752 ++=== IO: pattern 196 ++read 512/512 bytes at offset 3221194752 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221195776 ++read 512/512 bytes at offset 3221195776 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221196800 ++read 512/512 bytes at offset 3221196800 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221197824 ++read 512/512 bytes at offset 3221197824 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221198848 ++read 512/512 bytes at offset 3221198848 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221199872 ++read 512/512 bytes at offset 3221199872 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221200896 ++read 512/512 bytes at offset 3221200896 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221201920 ++read 512/512 bytes at offset 3221201920 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221202944 ++read 512/512 bytes at offset 3221202944 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221203968 ++read 512/512 bytes at offset 3221203968 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221204992 ++read 512/512 bytes at offset 3221204992 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221206016 ++read 512/512 bytes at offset 3221206016 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221207040 ++read 512/512 bytes at offset 3221207040 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221208064 ++read 512/512 bytes at offset 3221208064 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221209088 ++read 512/512 bytes at offset 3221209088 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221210112 ++read 512/512 bytes at offset 3221210112 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221211136 ++read 512/512 bytes at offset 3221211136 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221212160 ++read 512/512 bytes at offset 3221212160 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221213184 ++read 512/512 bytes at offset 3221213184 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221214208 ++read 512/512 bytes at offset 3221214208 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221215232 ++read 512/512 bytes at offset 3221215232 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221216256 ++read 512/512 bytes at offset 3221216256 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221217280 ++read 512/512 bytes at offset 3221217280 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221218304 ++read 512/512 bytes at offset 3221218304 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221219328 ++read 512/512 bytes at offset 3221219328 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221220352 ++read 512/512 bytes at offset 3221220352 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221221376 ++read 512/512 bytes at offset 3221221376 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221222400 ++read 512/512 bytes at offset 3221222400 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221223424 ++read 512/512 bytes at offset 3221223424 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221224448 ++read 512/512 bytes at offset 3221224448 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221225472 ++read 512/512 bytes at offset 3221225472 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221226496 ++read 512/512 bytes at offset 3221226496 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221227520 ++read 512/512 bytes at offset 3221227520 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221228544 ++read 512/512 bytes at offset 3221228544 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221229568 ++read 512/512 bytes at offset 3221229568 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221230592 ++read 512/512 bytes at offset 3221230592 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221231616 ++read 512/512 bytes at offset 3221231616 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221232640 ++read 512/512 bytes at offset 3221232640 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221233664 ++read 512/512 bytes at offset 3221233664 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221234688 ++read 512/512 bytes at offset 3221234688 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221235712 ++read 512/512 bytes at offset 3221235712 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221236736 ++read 512/512 bytes at offset 3221236736 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221237760 ++read 512/512 bytes at offset 3221237760 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221238784 ++read 512/512 bytes at offset 3221238784 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221239808 ++read 512/512 bytes at offset 3221239808 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221240832 ++read 512/512 bytes at offset 3221240832 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221241856 ++read 512/512 bytes at offset 3221241856 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221242880 ++read 512/512 bytes at offset 3221242880 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221243904 ++read 512/512 bytes at offset 3221243904 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221244928 ++read 512/512 bytes at offset 3221244928 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221245952 ++read 512/512 bytes at offset 3221245952 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221246976 ++read 512/512 bytes at offset 3221246976 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221248000 ++read 512/512 bytes at offset 3221248000 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221249024 ++read 512/512 bytes at offset 3221249024 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221250048 ++read 512/512 bytes at offset 3221250048 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221251072 ++read 512/512 bytes at offset 3221251072 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221252096 ++read 512/512 bytes at offset 3221252096 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221253120 ++read 512/512 bytes at offset 3221253120 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221254144 ++read 512/512 bytes at offset 3221254144 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221255168 ++read 512/512 bytes at offset 3221255168 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221256192 ++read 512/512 bytes at offset 3221256192 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221257216 ++read 512/512 bytes at offset 3221257216 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221258240 ++read 512/512 bytes at offset 3221258240 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221259264 ++read 512/512 bytes at offset 3221259264 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> === IO: pattern 0 +-qemu-io> read 512/512 bytes at offset 3221227008 ++=== IO: pattern 0 ++read 512/512 bytes at offset 3221227008 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221228032 ++read 512/512 bytes at offset 3221228032 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221229056 ++read 512/512 bytes at offset 3221229056 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221230080 ++read 512/512 bytes at offset 3221230080 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221231104 ++read 512/512 bytes at offset 3221231104 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221232128 ++read 512/512 bytes at offset 3221232128 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221233152 ++read 512/512 bytes at offset 3221233152 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221234176 ++read 512/512 bytes at offset 3221234176 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221235200 ++read 512/512 bytes at offset 3221235200 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221236224 ++read 512/512 bytes at offset 3221236224 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221237248 ++read 512/512 bytes at offset 3221237248 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221238272 ++read 512/512 bytes at offset 3221238272 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221239296 ++read 512/512 bytes at offset 3221239296 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221240320 ++read 512/512 bytes at offset 3221240320 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221241344 ++read 512/512 bytes at offset 3221241344 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221242368 ++read 512/512 bytes at offset 3221242368 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221243392 ++read 512/512 bytes at offset 3221243392 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221244416 ++read 512/512 bytes at offset 3221244416 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221245440 ++read 512/512 bytes at offset 3221245440 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221246464 ++read 512/512 bytes at offset 3221246464 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221247488 ++read 512/512 bytes at offset 3221247488 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221248512 ++read 512/512 bytes at offset 3221248512 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221249536 ++read 512/512 bytes at offset 3221249536 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221250560 ++read 512/512 bytes at offset 3221250560 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221251584 ++read 512/512 bytes at offset 3221251584 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221252608 ++read 512/512 bytes at offset 3221252608 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221253632 ++read 512/512 bytes at offset 3221253632 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221254656 ++read 512/512 bytes at offset 3221254656 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221255680 ++read 512/512 bytes at offset 3221255680 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221256704 ++read 512/512 bytes at offset 3221256704 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221257728 ++read 512/512 bytes at offset 3221257728 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3221258752 ++read 512/512 bytes at offset 3221258752 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> No errors were found on the image. ++No errors were found on the image. + No errors were found on the image. + *** done +diff --git a/tests/qemu-iotests/032.out b/tests/qemu-iotests/032.out +index 7272ac2..ca20de6 100644 +--- a/tests/qemu-iotests/032.out ++++ b/tests/qemu-iotests/032.out +@@ -3,73 +3,73 @@ QA output created by 032 + === Prepare image === + + Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864 +-qemu-io> wrote 65536/65536 bytes at offset 0 ++wrote 65536/65536 bytes at offset 0 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 131072 ++wrote 65536/65536 bytes at offset 131072 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 262144 ++wrote 65536/65536 bytes at offset 262144 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 393216 ++wrote 65536/65536 bytes at offset 393216 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 524288 ++wrote 65536/65536 bytes at offset 524288 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 655360 ++wrote 65536/65536 bytes at offset 655360 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 786432 ++wrote 65536/65536 bytes at offset 786432 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 917504 ++wrote 65536/65536 bytes at offset 917504 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 1048576 ++wrote 65536/65536 bytes at offset 1048576 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 1179648 ++wrote 65536/65536 bytes at offset 1179648 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 1310720 ++wrote 65536/65536 bytes at offset 1310720 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 1441792 ++wrote 65536/65536 bytes at offset 1441792 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 1572864 ++wrote 65536/65536 bytes at offset 1572864 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 1703936 ++wrote 65536/65536 bytes at offset 1703936 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 1835008 ++wrote 65536/65536 bytes at offset 1835008 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 1966080 ++wrote 65536/65536 bytes at offset 1966080 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 2097152 ++wrote 65536/65536 bytes at offset 2097152 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 2228224 ++wrote 65536/65536 bytes at offset 2228224 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 2359296 ++wrote 65536/65536 bytes at offset 2359296 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 2490368 ++wrote 65536/65536 bytes at offset 2490368 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 2621440 ++wrote 65536/65536 bytes at offset 2621440 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 2752512 ++wrote 65536/65536 bytes at offset 2752512 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 2883584 ++wrote 65536/65536 bytes at offset 2883584 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 3014656 ++wrote 65536/65536 bytes at offset 3014656 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 3145728 ++wrote 65536/65536 bytes at offset 3145728 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 3276800 ++wrote 65536/65536 bytes at offset 3276800 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 3407872 ++wrote 65536/65536 bytes at offset 3407872 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 3538944 ++wrote 65536/65536 bytes at offset 3538944 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 3670016 ++wrote 65536/65536 bytes at offset 3670016 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 3801088 ++wrote 65536/65536 bytes at offset 3801088 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 3932160 ++wrote 65536/65536 bytes at offset 3932160 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4063232 ++wrote 65536/65536 bytes at offset 4063232 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4194304 ++wrote 65536/65536 bytes at offset 4194304 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> ++ + === AIO request during close === + + wrote 4194304/4194304 bytes at offset 0 +diff --git a/tests/qemu-iotests/035.out b/tests/qemu-iotests/035.out +index 0c2279f..cde21d8 100644 +--- a/tests/qemu-iotests/035.out ++++ b/tests/qemu-iotests/035.out +@@ -2,7 +2,7 @@ QA output created by 035 + + creating image + Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=6442450944 +-qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> wrote 512/512 bytes at offset XXX ++wrote 512/512 bytes at offset XXX + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) + wrote 512/512 bytes at offset XXX + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +diff --git a/tests/qemu-iotests/037.out b/tests/qemu-iotests/037.out +index deb8a3b..4eb84ed 100644 +--- a/tests/qemu-iotests/037.out ++++ b/tests/qemu-iotests/037.out +@@ -2,519 +2,519 @@ QA output created by 037 + + == creating backing file for COW tests == + Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=134217728 +-qemu-io> wrote 512/512 bytes at offset 0 ++wrote 512/512 bytes at offset 0 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 512 ++wrote 512/512 bytes at offset 512 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 1024 ++wrote 512/512 bytes at offset 1024 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 1536 ++wrote 512/512 bytes at offset 1536 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 2048 ++wrote 512/512 bytes at offset 2048 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 2560 ++wrote 512/512 bytes at offset 2560 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 3072 ++wrote 512/512 bytes at offset 3072 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 3584 ++wrote 512/512 bytes at offset 3584 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4096 ++wrote 512/512 bytes at offset 4096 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 4608 ++wrote 512/512 bytes at offset 4608 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 5120 ++wrote 512/512 bytes at offset 5120 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 5632 ++wrote 512/512 bytes at offset 5632 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 6144 ++wrote 512/512 bytes at offset 6144 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 6656 ++wrote 512/512 bytes at offset 6656 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 7168 ++wrote 512/512 bytes at offset 7168 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 7680 ++wrote 512/512 bytes at offset 7680 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 8192 ++wrote 512/512 bytes at offset 8192 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 8704 ++wrote 512/512 bytes at offset 8704 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 9216 ++wrote 512/512 bytes at offset 9216 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 9728 ++wrote 512/512 bytes at offset 9728 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 10240 ++wrote 512/512 bytes at offset 10240 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 10752 ++wrote 512/512 bytes at offset 10752 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 11264 ++wrote 512/512 bytes at offset 11264 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 11776 ++wrote 512/512 bytes at offset 11776 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 12288 ++wrote 512/512 bytes at offset 12288 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 12800 ++wrote 512/512 bytes at offset 12800 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 13312 ++wrote 512/512 bytes at offset 13312 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 13824 ++wrote 512/512 bytes at offset 13824 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 14336 ++wrote 512/512 bytes at offset 14336 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 14848 ++wrote 512/512 bytes at offset 14848 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 15360 ++wrote 512/512 bytes at offset 15360 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 15872 ++wrote 512/512 bytes at offset 15872 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 16384 ++wrote 512/512 bytes at offset 16384 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 16896 ++wrote 512/512 bytes at offset 16896 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 17408 ++wrote 512/512 bytes at offset 17408 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 17920 ++wrote 512/512 bytes at offset 17920 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 18432 ++wrote 512/512 bytes at offset 18432 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 18944 ++wrote 512/512 bytes at offset 18944 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 19456 ++wrote 512/512 bytes at offset 19456 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 19968 ++wrote 512/512 bytes at offset 19968 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 20480 ++wrote 512/512 bytes at offset 20480 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 20992 ++wrote 512/512 bytes at offset 20992 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 21504 ++wrote 512/512 bytes at offset 21504 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 22016 ++wrote 512/512 bytes at offset 22016 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 22528 ++wrote 512/512 bytes at offset 22528 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 23040 ++wrote 512/512 bytes at offset 23040 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 23552 ++wrote 512/512 bytes at offset 23552 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 24064 ++wrote 512/512 bytes at offset 24064 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 24576 ++wrote 512/512 bytes at offset 24576 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 25088 ++wrote 512/512 bytes at offset 25088 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 25600 ++wrote 512/512 bytes at offset 25600 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 26112 ++wrote 512/512 bytes at offset 26112 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 26624 ++wrote 512/512 bytes at offset 26624 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 27136 ++wrote 512/512 bytes at offset 27136 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 27648 ++wrote 512/512 bytes at offset 27648 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 28160 ++wrote 512/512 bytes at offset 28160 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 28672 ++wrote 512/512 bytes at offset 28672 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 29184 ++wrote 512/512 bytes at offset 29184 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 29696 ++wrote 512/512 bytes at offset 29696 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 30208 ++wrote 512/512 bytes at offset 30208 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 30720 ++wrote 512/512 bytes at offset 30720 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 31232 ++wrote 512/512 bytes at offset 31232 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 31744 ++wrote 512/512 bytes at offset 31744 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 32256 ++wrote 512/512 bytes at offset 32256 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 32768 ++wrote 512/512 bytes at offset 32768 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 33280 ++wrote 512/512 bytes at offset 33280 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 33792 ++wrote 512/512 bytes at offset 33792 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 34304 ++wrote 512/512 bytes at offset 34304 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 34816 ++wrote 512/512 bytes at offset 34816 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 35328 ++wrote 512/512 bytes at offset 35328 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 35840 ++wrote 512/512 bytes at offset 35840 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 36352 ++wrote 512/512 bytes at offset 36352 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 36864 ++wrote 512/512 bytes at offset 36864 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 37376 ++wrote 512/512 bytes at offset 37376 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 37888 ++wrote 512/512 bytes at offset 37888 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 38400 ++wrote 512/512 bytes at offset 38400 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 38912 ++wrote 512/512 bytes at offset 38912 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 39424 ++wrote 512/512 bytes at offset 39424 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 39936 ++wrote 512/512 bytes at offset 39936 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 40448 ++wrote 512/512 bytes at offset 40448 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 40960 ++wrote 512/512 bytes at offset 40960 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 41472 ++wrote 512/512 bytes at offset 41472 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 41984 ++wrote 512/512 bytes at offset 41984 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 42496 ++wrote 512/512 bytes at offset 42496 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 43008 ++wrote 512/512 bytes at offset 43008 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 43520 ++wrote 512/512 bytes at offset 43520 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 44032 ++wrote 512/512 bytes at offset 44032 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 44544 ++wrote 512/512 bytes at offset 44544 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 45056 ++wrote 512/512 bytes at offset 45056 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 45568 ++wrote 512/512 bytes at offset 45568 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 46080 ++wrote 512/512 bytes at offset 46080 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 46592 ++wrote 512/512 bytes at offset 46592 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 47104 ++wrote 512/512 bytes at offset 47104 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 47616 ++wrote 512/512 bytes at offset 47616 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 48128 ++wrote 512/512 bytes at offset 48128 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 48640 ++wrote 512/512 bytes at offset 48640 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 49152 ++wrote 512/512 bytes at offset 49152 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 49664 ++wrote 512/512 bytes at offset 49664 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 50176 ++wrote 512/512 bytes at offset 50176 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 50688 ++wrote 512/512 bytes at offset 50688 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 51200 ++wrote 512/512 bytes at offset 51200 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 51712 ++wrote 512/512 bytes at offset 51712 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 52224 ++wrote 512/512 bytes at offset 52224 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 52736 ++wrote 512/512 bytes at offset 52736 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 53248 ++wrote 512/512 bytes at offset 53248 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 53760 ++wrote 512/512 bytes at offset 53760 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 54272 ++wrote 512/512 bytes at offset 54272 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 54784 ++wrote 512/512 bytes at offset 54784 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 55296 ++wrote 512/512 bytes at offset 55296 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 55808 ++wrote 512/512 bytes at offset 55808 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 56320 ++wrote 512/512 bytes at offset 56320 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 56832 ++wrote 512/512 bytes at offset 56832 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 57344 ++wrote 512/512 bytes at offset 57344 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 57856 ++wrote 512/512 bytes at offset 57856 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 58368 ++wrote 512/512 bytes at offset 58368 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 58880 ++wrote 512/512 bytes at offset 58880 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 59392 ++wrote 512/512 bytes at offset 59392 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 59904 ++wrote 512/512 bytes at offset 59904 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 60416 ++wrote 512/512 bytes at offset 60416 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 60928 ++wrote 512/512 bytes at offset 60928 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 61440 ++wrote 512/512 bytes at offset 61440 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 61952 ++wrote 512/512 bytes at offset 61952 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 62464 ++wrote 512/512 bytes at offset 62464 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 62976 ++wrote 512/512 bytes at offset 62976 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 63488 ++wrote 512/512 bytes at offset 63488 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 64000 ++wrote 512/512 bytes at offset 64000 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 64512 ++wrote 512/512 bytes at offset 64512 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 65024 ++wrote 512/512 bytes at offset 65024 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 65536 ++wrote 512/512 bytes at offset 65536 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 66048 ++wrote 512/512 bytes at offset 66048 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 66560 ++wrote 512/512 bytes at offset 66560 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 67072 ++wrote 512/512 bytes at offset 67072 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 67584 ++wrote 512/512 bytes at offset 67584 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 68096 ++wrote 512/512 bytes at offset 68096 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 68608 ++wrote 512/512 bytes at offset 68608 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 69120 ++wrote 512/512 bytes at offset 69120 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 69632 ++wrote 512/512 bytes at offset 69632 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 70144 ++wrote 512/512 bytes at offset 70144 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 70656 ++wrote 512/512 bytes at offset 70656 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 71168 ++wrote 512/512 bytes at offset 71168 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 71680 ++wrote 512/512 bytes at offset 71680 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 72192 ++wrote 512/512 bytes at offset 72192 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 72704 ++wrote 512/512 bytes at offset 72704 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 73216 ++wrote 512/512 bytes at offset 73216 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 73728 ++wrote 512/512 bytes at offset 73728 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 74240 ++wrote 512/512 bytes at offset 74240 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 74752 ++wrote 512/512 bytes at offset 74752 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 75264 ++wrote 512/512 bytes at offset 75264 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 75776 ++wrote 512/512 bytes at offset 75776 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 76288 ++wrote 512/512 bytes at offset 76288 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 76800 ++wrote 512/512 bytes at offset 76800 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 77312 ++wrote 512/512 bytes at offset 77312 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 77824 ++wrote 512/512 bytes at offset 77824 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 78336 ++wrote 512/512 bytes at offset 78336 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 78848 ++wrote 512/512 bytes at offset 78848 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 79360 ++wrote 512/512 bytes at offset 79360 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 79872 ++wrote 512/512 bytes at offset 79872 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 80384 ++wrote 512/512 bytes at offset 80384 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 80896 ++wrote 512/512 bytes at offset 80896 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 81408 ++wrote 512/512 bytes at offset 81408 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 81920 ++wrote 512/512 bytes at offset 81920 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 82432 ++wrote 512/512 bytes at offset 82432 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 82944 ++wrote 512/512 bytes at offset 82944 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 83456 ++wrote 512/512 bytes at offset 83456 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 83968 ++wrote 512/512 bytes at offset 83968 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 84480 ++wrote 512/512 bytes at offset 84480 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 84992 ++wrote 512/512 bytes at offset 84992 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 85504 ++wrote 512/512 bytes at offset 85504 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 86016 ++wrote 512/512 bytes at offset 86016 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 86528 ++wrote 512/512 bytes at offset 86528 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 87040 ++wrote 512/512 bytes at offset 87040 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 87552 ++wrote 512/512 bytes at offset 87552 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 88064 ++wrote 512/512 bytes at offset 88064 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 88576 ++wrote 512/512 bytes at offset 88576 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 89088 ++wrote 512/512 bytes at offset 89088 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 89600 ++wrote 512/512 bytes at offset 89600 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 90112 ++wrote 512/512 bytes at offset 90112 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 90624 ++wrote 512/512 bytes at offset 90624 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 91136 ++wrote 512/512 bytes at offset 91136 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 91648 ++wrote 512/512 bytes at offset 91648 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 92160 ++wrote 512/512 bytes at offset 92160 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 92672 ++wrote 512/512 bytes at offset 92672 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 93184 ++wrote 512/512 bytes at offset 93184 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 93696 ++wrote 512/512 bytes at offset 93696 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 94208 ++wrote 512/512 bytes at offset 94208 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 94720 ++wrote 512/512 bytes at offset 94720 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 95232 ++wrote 512/512 bytes at offset 95232 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 95744 ++wrote 512/512 bytes at offset 95744 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 96256 ++wrote 512/512 bytes at offset 96256 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 96768 ++wrote 512/512 bytes at offset 96768 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 97280 ++wrote 512/512 bytes at offset 97280 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 97792 ++wrote 512/512 bytes at offset 97792 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 98304 ++wrote 512/512 bytes at offset 98304 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 98816 ++wrote 512/512 bytes at offset 98816 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 99328 ++wrote 512/512 bytes at offset 99328 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 99840 ++wrote 512/512 bytes at offset 99840 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 100352 ++wrote 512/512 bytes at offset 100352 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 100864 ++wrote 512/512 bytes at offset 100864 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 101376 ++wrote 512/512 bytes at offset 101376 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 101888 ++wrote 512/512 bytes at offset 101888 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 102400 ++wrote 512/512 bytes at offset 102400 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 102912 ++wrote 512/512 bytes at offset 102912 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 103424 ++wrote 512/512 bytes at offset 103424 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 103936 ++wrote 512/512 bytes at offset 103936 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 104448 ++wrote 512/512 bytes at offset 104448 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 104960 ++wrote 512/512 bytes at offset 104960 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 105472 ++wrote 512/512 bytes at offset 105472 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 105984 ++wrote 512/512 bytes at offset 105984 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 106496 ++wrote 512/512 bytes at offset 106496 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 107008 ++wrote 512/512 bytes at offset 107008 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 107520 ++wrote 512/512 bytes at offset 107520 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 108032 ++wrote 512/512 bytes at offset 108032 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 108544 ++wrote 512/512 bytes at offset 108544 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 109056 ++wrote 512/512 bytes at offset 109056 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 109568 ++wrote 512/512 bytes at offset 109568 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 110080 ++wrote 512/512 bytes at offset 110080 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 110592 ++wrote 512/512 bytes at offset 110592 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 111104 ++wrote 512/512 bytes at offset 111104 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 111616 ++wrote 512/512 bytes at offset 111616 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 112128 ++wrote 512/512 bytes at offset 112128 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 112640 ++wrote 512/512 bytes at offset 112640 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 113152 ++wrote 512/512 bytes at offset 113152 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 113664 ++wrote 512/512 bytes at offset 113664 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 114176 ++wrote 512/512 bytes at offset 114176 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 114688 ++wrote 512/512 bytes at offset 114688 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 115200 ++wrote 512/512 bytes at offset 115200 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 115712 ++wrote 512/512 bytes at offset 115712 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 116224 ++wrote 512/512 bytes at offset 116224 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 116736 ++wrote 512/512 bytes at offset 116736 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 117248 ++wrote 512/512 bytes at offset 117248 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 117760 ++wrote 512/512 bytes at offset 117760 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 118272 ++wrote 512/512 bytes at offset 118272 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 118784 ++wrote 512/512 bytes at offset 118784 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 119296 ++wrote 512/512 bytes at offset 119296 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 119808 ++wrote 512/512 bytes at offset 119808 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 120320 ++wrote 512/512 bytes at offset 120320 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 120832 ++wrote 512/512 bytes at offset 120832 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 121344 ++wrote 512/512 bytes at offset 121344 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 121856 ++wrote 512/512 bytes at offset 121856 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 122368 ++wrote 512/512 bytes at offset 122368 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 122880 ++wrote 512/512 bytes at offset 122880 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 123392 ++wrote 512/512 bytes at offset 123392 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 123904 ++wrote 512/512 bytes at offset 123904 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 124416 ++wrote 512/512 bytes at offset 124416 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 124928 ++wrote 512/512 bytes at offset 124928 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 125440 ++wrote 512/512 bytes at offset 125440 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 125952 ++wrote 512/512 bytes at offset 125952 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 126464 ++wrote 512/512 bytes at offset 126464 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 126976 ++wrote 512/512 bytes at offset 126976 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 127488 ++wrote 512/512 bytes at offset 127488 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 128000 ++wrote 512/512 bytes at offset 128000 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 128512 ++wrote 512/512 bytes at offset 128512 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 129024 ++wrote 512/512 bytes at offset 129024 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 129536 ++wrote 512/512 bytes at offset 129536 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 130048 ++wrote 512/512 bytes at offset 130048 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 512/512 bytes at offset 130560 ++wrote 512/512 bytes at offset 130560 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=6442450944 backing_file='TEST_DIR/t.IMGFMT.base' ++Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=6442450944 backing_file='TEST_DIR/t.IMGFMT.base' + + == COW in a single cluster == + wrote 2048/2048 bytes at offset 0 +@@ -525,35 +525,35 @@ wrote 2048/2048 bytes at offset 9216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) + read 2048/2048 bytes at offset 0 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 2048 ++read 512/512 bytes at offset 2048 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 2560 ++read 512/512 bytes at offset 2560 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3072 ++read 512/512 bytes at offset 3072 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 3584 ++read 512/512 bytes at offset 3584 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4096 ++read 512/512 bytes at offset 4096 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 4608 ++read 512/512 bytes at offset 4608 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 5120 ++read 512/512 bytes at offset 5120 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 5632 ++read 512/512 bytes at offset 5632 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 6144 ++read 2048/2048 bytes at offset 6144 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 8192 ++read 512/512 bytes at offset 8192 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 8704 ++read 512/512 bytes at offset 8704 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 2048/2048 bytes at offset 9216 ++read 2048/2048 bytes at offset 9216 + 2 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 11264 ++read 512/512 bytes at offset 11264 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 11776 ++read 512/512 bytes at offset 11776 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> ++ + == COW in two-cluster allocations == + wrote 6144/6144 bytes at offset 16384 + 6 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +@@ -563,39 +563,39 @@ wrote 5120/5120 bytes at offset 33792 + 5 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) + read 6144/6144 bytes at offset 16384 + 6 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 22528 ++read 512/512 bytes at offset 22528 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 23040 ++read 512/512 bytes at offset 23040 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 23552 ++read 512/512 bytes at offset 23552 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 24064 ++read 512/512 bytes at offset 24064 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 24576 ++read 512/512 bytes at offset 24576 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 25088 ++read 512/512 bytes at offset 25088 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 25600 ++read 512/512 bytes at offset 25600 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 26112 ++read 512/512 bytes at offset 26112 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 6144/6144 bytes at offset 26624 ++read 6144/6144 bytes at offset 26624 + 6 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 32768 ++read 512/512 bytes at offset 32768 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 33280 ++read 512/512 bytes at offset 33280 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 5120/5120 bytes at offset 33792 ++read 5120/5120 bytes at offset 33792 + 5 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 38912 ++read 512/512 bytes at offset 38912 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 39424 ++read 512/512 bytes at offset 39424 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 39936 ++read 512/512 bytes at offset 39936 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 40448 ++read 512/512 bytes at offset 40448 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> ++ + == COW in multi-cluster allocations == + wrote 15360/15360 bytes at offset 49152 + 15 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +@@ -605,41 +605,41 @@ wrote 15360/15360 bytes at offset 84992 + 15 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) + read 15360/15360 bytes at offset 49152 + 15 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 64512 ++read 512/512 bytes at offset 64512 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 65024 ++read 512/512 bytes at offset 65024 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 65536 ++read 512/512 bytes at offset 65536 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 66048 ++read 512/512 bytes at offset 66048 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 66560 ++read 512/512 bytes at offset 66560 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 67072 ++read 512/512 bytes at offset 67072 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 14336/14336 bytes at offset 67584 ++read 14336/14336 bytes at offset 67584 + 14 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 81920 ++read 512/512 bytes at offset 81920 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 82432 ++read 512/512 bytes at offset 82432 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 82944 ++read 512/512 bytes at offset 82944 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 83456 ++read 512/512 bytes at offset 83456 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 83968 ++read 512/512 bytes at offset 83968 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 84480 ++read 512/512 bytes at offset 84480 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 15360/15360 bytes at offset 84992 ++read 15360/15360 bytes at offset 84992 + 15 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 100352 ++read 512/512 bytes at offset 100352 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 100864 ++read 512/512 bytes at offset 100864 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 101376 ++read 512/512 bytes at offset 101376 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 512/512 bytes at offset 101888 ++read 512/512 bytes at offset 101888 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> No errors were found on the image. ++No errors were found on the image. + *** done +diff --git a/tests/qemu-iotests/038.out b/tests/qemu-iotests/038.out +index 96c2f84..a71c3fa 100644 +--- a/tests/qemu-iotests/038.out ++++ b/tests/qemu-iotests/038.out +@@ -2,519 +2,519 @@ QA output created by 038 + + == creating backing file for COW tests == + Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=134217728 +-qemu-io> wrote 65536/65536 bytes at offset 0 ++wrote 65536/65536 bytes at offset 0 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 65536 ++wrote 65536/65536 bytes at offset 65536 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 131072 ++wrote 65536/65536 bytes at offset 131072 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 196608 ++wrote 65536/65536 bytes at offset 196608 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 262144 ++wrote 65536/65536 bytes at offset 262144 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 327680 ++wrote 65536/65536 bytes at offset 327680 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 393216 ++wrote 65536/65536 bytes at offset 393216 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 458752 ++wrote 65536/65536 bytes at offset 458752 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 524288 ++wrote 65536/65536 bytes at offset 524288 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 589824 ++wrote 65536/65536 bytes at offset 589824 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 655360 ++wrote 65536/65536 bytes at offset 655360 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 720896 ++wrote 65536/65536 bytes at offset 720896 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 786432 ++wrote 65536/65536 bytes at offset 786432 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 851968 ++wrote 65536/65536 bytes at offset 851968 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 917504 ++wrote 65536/65536 bytes at offset 917504 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 983040 ++wrote 65536/65536 bytes at offset 983040 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 1048576 ++wrote 65536/65536 bytes at offset 1048576 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 1114112 ++wrote 65536/65536 bytes at offset 1114112 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 1179648 ++wrote 65536/65536 bytes at offset 1179648 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 1245184 ++wrote 65536/65536 bytes at offset 1245184 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 1310720 ++wrote 65536/65536 bytes at offset 1310720 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 1376256 ++wrote 65536/65536 bytes at offset 1376256 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 1441792 ++wrote 65536/65536 bytes at offset 1441792 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 1507328 ++wrote 65536/65536 bytes at offset 1507328 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 1572864 ++wrote 65536/65536 bytes at offset 1572864 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 1638400 ++wrote 65536/65536 bytes at offset 1638400 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 1703936 ++wrote 65536/65536 bytes at offset 1703936 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 1769472 ++wrote 65536/65536 bytes at offset 1769472 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 1835008 ++wrote 65536/65536 bytes at offset 1835008 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 1900544 ++wrote 65536/65536 bytes at offset 1900544 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 1966080 ++wrote 65536/65536 bytes at offset 1966080 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 2031616 ++wrote 65536/65536 bytes at offset 2031616 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 2097152 ++wrote 65536/65536 bytes at offset 2097152 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 2162688 ++wrote 65536/65536 bytes at offset 2162688 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 2228224 ++wrote 65536/65536 bytes at offset 2228224 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 2293760 ++wrote 65536/65536 bytes at offset 2293760 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 2359296 ++wrote 65536/65536 bytes at offset 2359296 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 2424832 ++wrote 65536/65536 bytes at offset 2424832 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 2490368 ++wrote 65536/65536 bytes at offset 2490368 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 2555904 ++wrote 65536/65536 bytes at offset 2555904 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 2621440 ++wrote 65536/65536 bytes at offset 2621440 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 2686976 ++wrote 65536/65536 bytes at offset 2686976 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 2752512 ++wrote 65536/65536 bytes at offset 2752512 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 2818048 ++wrote 65536/65536 bytes at offset 2818048 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 2883584 ++wrote 65536/65536 bytes at offset 2883584 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 2949120 ++wrote 65536/65536 bytes at offset 2949120 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 3014656 ++wrote 65536/65536 bytes at offset 3014656 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 3080192 ++wrote 65536/65536 bytes at offset 3080192 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 3145728 ++wrote 65536/65536 bytes at offset 3145728 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 3211264 ++wrote 65536/65536 bytes at offset 3211264 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 3276800 ++wrote 65536/65536 bytes at offset 3276800 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 3342336 ++wrote 65536/65536 bytes at offset 3342336 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 3407872 ++wrote 65536/65536 bytes at offset 3407872 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 3473408 ++wrote 65536/65536 bytes at offset 3473408 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 3538944 ++wrote 65536/65536 bytes at offset 3538944 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 3604480 ++wrote 65536/65536 bytes at offset 3604480 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 3670016 ++wrote 65536/65536 bytes at offset 3670016 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 3735552 ++wrote 65536/65536 bytes at offset 3735552 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 3801088 ++wrote 65536/65536 bytes at offset 3801088 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 3866624 ++wrote 65536/65536 bytes at offset 3866624 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 3932160 ++wrote 65536/65536 bytes at offset 3932160 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 3997696 ++wrote 65536/65536 bytes at offset 3997696 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4063232 ++wrote 65536/65536 bytes at offset 4063232 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4128768 ++wrote 65536/65536 bytes at offset 4128768 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4194304 ++wrote 65536/65536 bytes at offset 4194304 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4259840 ++wrote 65536/65536 bytes at offset 4259840 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4325376 ++wrote 65536/65536 bytes at offset 4325376 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4390912 ++wrote 65536/65536 bytes at offset 4390912 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4456448 ++wrote 65536/65536 bytes at offset 4456448 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4521984 ++wrote 65536/65536 bytes at offset 4521984 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4587520 ++wrote 65536/65536 bytes at offset 4587520 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4653056 ++wrote 65536/65536 bytes at offset 4653056 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4718592 ++wrote 65536/65536 bytes at offset 4718592 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4784128 ++wrote 65536/65536 bytes at offset 4784128 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4849664 ++wrote 65536/65536 bytes at offset 4849664 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4915200 ++wrote 65536/65536 bytes at offset 4915200 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 4980736 ++wrote 65536/65536 bytes at offset 4980736 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 5046272 ++wrote 65536/65536 bytes at offset 5046272 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 5111808 ++wrote 65536/65536 bytes at offset 5111808 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 5177344 ++wrote 65536/65536 bytes at offset 5177344 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 5242880 ++wrote 65536/65536 bytes at offset 5242880 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 5308416 ++wrote 65536/65536 bytes at offset 5308416 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 5373952 ++wrote 65536/65536 bytes at offset 5373952 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 5439488 ++wrote 65536/65536 bytes at offset 5439488 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 5505024 ++wrote 65536/65536 bytes at offset 5505024 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 5570560 ++wrote 65536/65536 bytes at offset 5570560 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 5636096 ++wrote 65536/65536 bytes at offset 5636096 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 5701632 ++wrote 65536/65536 bytes at offset 5701632 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 5767168 ++wrote 65536/65536 bytes at offset 5767168 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 5832704 ++wrote 65536/65536 bytes at offset 5832704 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 5898240 ++wrote 65536/65536 bytes at offset 5898240 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 5963776 ++wrote 65536/65536 bytes at offset 5963776 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 6029312 ++wrote 65536/65536 bytes at offset 6029312 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 6094848 ++wrote 65536/65536 bytes at offset 6094848 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 6160384 ++wrote 65536/65536 bytes at offset 6160384 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 6225920 ++wrote 65536/65536 bytes at offset 6225920 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 6291456 ++wrote 65536/65536 bytes at offset 6291456 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 6356992 ++wrote 65536/65536 bytes at offset 6356992 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 6422528 ++wrote 65536/65536 bytes at offset 6422528 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 6488064 ++wrote 65536/65536 bytes at offset 6488064 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 6553600 ++wrote 65536/65536 bytes at offset 6553600 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 6619136 ++wrote 65536/65536 bytes at offset 6619136 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 6684672 ++wrote 65536/65536 bytes at offset 6684672 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 6750208 ++wrote 65536/65536 bytes at offset 6750208 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 6815744 ++wrote 65536/65536 bytes at offset 6815744 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 6881280 ++wrote 65536/65536 bytes at offset 6881280 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 6946816 ++wrote 65536/65536 bytes at offset 6946816 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 7012352 ++wrote 65536/65536 bytes at offset 7012352 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 7077888 ++wrote 65536/65536 bytes at offset 7077888 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 7143424 ++wrote 65536/65536 bytes at offset 7143424 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 7208960 ++wrote 65536/65536 bytes at offset 7208960 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 7274496 ++wrote 65536/65536 bytes at offset 7274496 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 7340032 ++wrote 65536/65536 bytes at offset 7340032 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 7405568 ++wrote 65536/65536 bytes at offset 7405568 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 7471104 ++wrote 65536/65536 bytes at offset 7471104 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 7536640 ++wrote 65536/65536 bytes at offset 7536640 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 7602176 ++wrote 65536/65536 bytes at offset 7602176 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 7667712 ++wrote 65536/65536 bytes at offset 7667712 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 7733248 ++wrote 65536/65536 bytes at offset 7733248 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 7798784 ++wrote 65536/65536 bytes at offset 7798784 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 7864320 ++wrote 65536/65536 bytes at offset 7864320 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 7929856 ++wrote 65536/65536 bytes at offset 7929856 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 7995392 ++wrote 65536/65536 bytes at offset 7995392 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 8060928 ++wrote 65536/65536 bytes at offset 8060928 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 8126464 ++wrote 65536/65536 bytes at offset 8126464 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 8192000 ++wrote 65536/65536 bytes at offset 8192000 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 8257536 ++wrote 65536/65536 bytes at offset 8257536 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 8323072 ++wrote 65536/65536 bytes at offset 8323072 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 8388608 ++wrote 65536/65536 bytes at offset 8388608 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 8454144 ++wrote 65536/65536 bytes at offset 8454144 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 8519680 ++wrote 65536/65536 bytes at offset 8519680 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 8585216 ++wrote 65536/65536 bytes at offset 8585216 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 8650752 ++wrote 65536/65536 bytes at offset 8650752 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 8716288 ++wrote 65536/65536 bytes at offset 8716288 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 8781824 ++wrote 65536/65536 bytes at offset 8781824 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 8847360 ++wrote 65536/65536 bytes at offset 8847360 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 8912896 ++wrote 65536/65536 bytes at offset 8912896 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 8978432 ++wrote 65536/65536 bytes at offset 8978432 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 9043968 ++wrote 65536/65536 bytes at offset 9043968 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 9109504 ++wrote 65536/65536 bytes at offset 9109504 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 9175040 ++wrote 65536/65536 bytes at offset 9175040 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 9240576 ++wrote 65536/65536 bytes at offset 9240576 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 9306112 ++wrote 65536/65536 bytes at offset 9306112 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 9371648 ++wrote 65536/65536 bytes at offset 9371648 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 9437184 ++wrote 65536/65536 bytes at offset 9437184 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 9502720 ++wrote 65536/65536 bytes at offset 9502720 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 9568256 ++wrote 65536/65536 bytes at offset 9568256 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 9633792 ++wrote 65536/65536 bytes at offset 9633792 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 9699328 ++wrote 65536/65536 bytes at offset 9699328 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 9764864 ++wrote 65536/65536 bytes at offset 9764864 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 9830400 ++wrote 65536/65536 bytes at offset 9830400 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 9895936 ++wrote 65536/65536 bytes at offset 9895936 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 9961472 ++wrote 65536/65536 bytes at offset 9961472 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 10027008 ++wrote 65536/65536 bytes at offset 10027008 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 10092544 ++wrote 65536/65536 bytes at offset 10092544 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 10158080 ++wrote 65536/65536 bytes at offset 10158080 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 10223616 ++wrote 65536/65536 bytes at offset 10223616 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 10289152 ++wrote 65536/65536 bytes at offset 10289152 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 10354688 ++wrote 65536/65536 bytes at offset 10354688 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 10420224 ++wrote 65536/65536 bytes at offset 10420224 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 10485760 ++wrote 65536/65536 bytes at offset 10485760 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 10551296 ++wrote 65536/65536 bytes at offset 10551296 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 10616832 ++wrote 65536/65536 bytes at offset 10616832 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 10682368 ++wrote 65536/65536 bytes at offset 10682368 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 10747904 ++wrote 65536/65536 bytes at offset 10747904 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 10813440 ++wrote 65536/65536 bytes at offset 10813440 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 10878976 ++wrote 65536/65536 bytes at offset 10878976 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 10944512 ++wrote 65536/65536 bytes at offset 10944512 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 11010048 ++wrote 65536/65536 bytes at offset 11010048 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 11075584 ++wrote 65536/65536 bytes at offset 11075584 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 11141120 ++wrote 65536/65536 bytes at offset 11141120 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 11206656 ++wrote 65536/65536 bytes at offset 11206656 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 11272192 ++wrote 65536/65536 bytes at offset 11272192 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 11337728 ++wrote 65536/65536 bytes at offset 11337728 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 11403264 ++wrote 65536/65536 bytes at offset 11403264 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 11468800 ++wrote 65536/65536 bytes at offset 11468800 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 11534336 ++wrote 65536/65536 bytes at offset 11534336 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 11599872 ++wrote 65536/65536 bytes at offset 11599872 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 11665408 ++wrote 65536/65536 bytes at offset 11665408 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 11730944 ++wrote 65536/65536 bytes at offset 11730944 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 11796480 ++wrote 65536/65536 bytes at offset 11796480 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 11862016 ++wrote 65536/65536 bytes at offset 11862016 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 11927552 ++wrote 65536/65536 bytes at offset 11927552 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 11993088 ++wrote 65536/65536 bytes at offset 11993088 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 12058624 ++wrote 65536/65536 bytes at offset 12058624 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 12124160 ++wrote 65536/65536 bytes at offset 12124160 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 12189696 ++wrote 65536/65536 bytes at offset 12189696 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 12255232 ++wrote 65536/65536 bytes at offset 12255232 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 12320768 ++wrote 65536/65536 bytes at offset 12320768 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 12386304 ++wrote 65536/65536 bytes at offset 12386304 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 12451840 ++wrote 65536/65536 bytes at offset 12451840 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 12517376 ++wrote 65536/65536 bytes at offset 12517376 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 12582912 ++wrote 65536/65536 bytes at offset 12582912 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 12648448 ++wrote 65536/65536 bytes at offset 12648448 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 12713984 ++wrote 65536/65536 bytes at offset 12713984 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 12779520 ++wrote 65536/65536 bytes at offset 12779520 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 12845056 ++wrote 65536/65536 bytes at offset 12845056 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 12910592 ++wrote 65536/65536 bytes at offset 12910592 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 12976128 ++wrote 65536/65536 bytes at offset 12976128 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 13041664 ++wrote 65536/65536 bytes at offset 13041664 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 13107200 ++wrote 65536/65536 bytes at offset 13107200 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 13172736 ++wrote 65536/65536 bytes at offset 13172736 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 13238272 ++wrote 65536/65536 bytes at offset 13238272 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 13303808 ++wrote 65536/65536 bytes at offset 13303808 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 13369344 ++wrote 65536/65536 bytes at offset 13369344 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 13434880 ++wrote 65536/65536 bytes at offset 13434880 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 13500416 ++wrote 65536/65536 bytes at offset 13500416 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 13565952 ++wrote 65536/65536 bytes at offset 13565952 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 13631488 ++wrote 65536/65536 bytes at offset 13631488 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 13697024 ++wrote 65536/65536 bytes at offset 13697024 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 13762560 ++wrote 65536/65536 bytes at offset 13762560 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 13828096 ++wrote 65536/65536 bytes at offset 13828096 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 13893632 ++wrote 65536/65536 bytes at offset 13893632 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 13959168 ++wrote 65536/65536 bytes at offset 13959168 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 14024704 ++wrote 65536/65536 bytes at offset 14024704 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 14090240 ++wrote 65536/65536 bytes at offset 14090240 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 14155776 ++wrote 65536/65536 bytes at offset 14155776 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 14221312 ++wrote 65536/65536 bytes at offset 14221312 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 14286848 ++wrote 65536/65536 bytes at offset 14286848 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 14352384 ++wrote 65536/65536 bytes at offset 14352384 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 14417920 ++wrote 65536/65536 bytes at offset 14417920 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 14483456 ++wrote 65536/65536 bytes at offset 14483456 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 14548992 ++wrote 65536/65536 bytes at offset 14548992 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 14614528 ++wrote 65536/65536 bytes at offset 14614528 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 14680064 ++wrote 65536/65536 bytes at offset 14680064 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 14745600 ++wrote 65536/65536 bytes at offset 14745600 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 14811136 ++wrote 65536/65536 bytes at offset 14811136 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 14876672 ++wrote 65536/65536 bytes at offset 14876672 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 14942208 ++wrote 65536/65536 bytes at offset 14942208 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 15007744 ++wrote 65536/65536 bytes at offset 15007744 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 15073280 ++wrote 65536/65536 bytes at offset 15073280 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 15138816 ++wrote 65536/65536 bytes at offset 15138816 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 15204352 ++wrote 65536/65536 bytes at offset 15204352 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 15269888 ++wrote 65536/65536 bytes at offset 15269888 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 15335424 ++wrote 65536/65536 bytes at offset 15335424 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 15400960 ++wrote 65536/65536 bytes at offset 15400960 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 15466496 ++wrote 65536/65536 bytes at offset 15466496 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 15532032 ++wrote 65536/65536 bytes at offset 15532032 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 15597568 ++wrote 65536/65536 bytes at offset 15597568 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 15663104 ++wrote 65536/65536 bytes at offset 15663104 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 15728640 ++wrote 65536/65536 bytes at offset 15728640 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 15794176 ++wrote 65536/65536 bytes at offset 15794176 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 15859712 ++wrote 65536/65536 bytes at offset 15859712 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 15925248 ++wrote 65536/65536 bytes at offset 15925248 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 15990784 ++wrote 65536/65536 bytes at offset 15990784 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 16056320 ++wrote 65536/65536 bytes at offset 16056320 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 16121856 ++wrote 65536/65536 bytes at offset 16121856 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 16187392 ++wrote 65536/65536 bytes at offset 16187392 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 16252928 ++wrote 65536/65536 bytes at offset 16252928 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 16318464 ++wrote 65536/65536 bytes at offset 16318464 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 16384000 ++wrote 65536/65536 bytes at offset 16384000 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 16449536 ++wrote 65536/65536 bytes at offset 16449536 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 16515072 ++wrote 65536/65536 bytes at offset 16515072 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 16580608 ++wrote 65536/65536 bytes at offset 16580608 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 16646144 ++wrote 65536/65536 bytes at offset 16646144 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 16711680 ++wrote 65536/65536 bytes at offset 16711680 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=6442450944 backing_file='TEST_DIR/t.IMGFMT.base' ++Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=6442450944 backing_file='TEST_DIR/t.IMGFMT.base' + + == Some concurrent requests touching the same cluster == + wrote 65536/65536 bytes at offset XXX +@@ -707,203 +707,203 @@ wrote 81920/81920 bytes at offset XXX + 80 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) + + == Verify image content == +-qemu-io> read 4096/4096 bytes at offset 2064384 ++read 4096/4096 bytes at offset 2064384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 81920/81920 bytes at offset 2068480 ++read 81920/81920 bytes at offset 2068480 + 80 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 12288/12288 bytes at offset 2150400 ++read 12288/12288 bytes at offset 2150400 + 12 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 2162688 ++read 65536/65536 bytes at offset 2162688 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 4161536 ++read 16384/16384 bytes at offset 4161536 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 81920/81920 bytes at offset 4177920 ++read 81920/81920 bytes at offset 4177920 + 80 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 4259840 ++read 65536/65536 bytes at offset 4259840 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 98304/98304 bytes at offset 0 ++read 98304/98304 bytes at offset 0 + 96 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 98304/98304 bytes at offset 131072 ++read 98304/98304 bytes at offset 131072 + 96 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 98304/98304 bytes at offset 262144 ++read 98304/98304 bytes at offset 262144 + 96 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 98304/98304 bytes at offset 393216 ++read 98304/98304 bytes at offset 393216 + 96 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 98304/98304 bytes at offset 524288 ++read 98304/98304 bytes at offset 524288 + 96 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 98304/98304 bytes at offset 655360 ++read 98304/98304 bytes at offset 655360 + 96 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 98304/98304 bytes at offset 786432 ++read 98304/98304 bytes at offset 786432 + 96 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 98304/98304 bytes at offset 917504 ++read 98304/98304 bytes at offset 917504 + 96 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 98304/98304 bytes at offset 1048576 ++read 98304/98304 bytes at offset 1048576 + 96 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 98304/98304 bytes at offset 1179648 ++read 98304/98304 bytes at offset 1179648 + 96 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 98304/98304 bytes at offset 1310720 ++read 98304/98304 bytes at offset 1310720 + 96 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 98304/98304 bytes at offset 1441792 ++read 98304/98304 bytes at offset 1441792 + 96 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 98304/98304 bytes at offset 1572864 ++read 98304/98304 bytes at offset 1572864 + 96 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 98304/98304 bytes at offset 1703936 ++read 98304/98304 bytes at offset 1703936 + 96 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 98304/98304 bytes at offset 1835008 ++read 98304/98304 bytes at offset 1835008 + 96 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 98304/98304 bytes at offset 1966080 ++read 98304/98304 bytes at offset 1966080 + 96 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 98304/98304 bytes at offset 2228224 ++read 98304/98304 bytes at offset 2228224 + 96 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 98304/98304 bytes at offset 2359296 ++read 98304/98304 bytes at offset 2359296 + 96 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 98304/98304 bytes at offset 2490368 ++read 98304/98304 bytes at offset 2490368 + 96 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 98304/98304 bytes at offset 2621440 ++read 98304/98304 bytes at offset 2621440 + 96 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 98304/98304 bytes at offset 2752512 ++read 98304/98304 bytes at offset 2752512 + 96 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 98304/98304 bytes at offset 2883584 ++read 98304/98304 bytes at offset 2883584 + 96 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 98304/98304 bytes at offset 3014656 ++read 98304/98304 bytes at offset 3014656 + 96 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 98304/98304 bytes at offset 3145728 ++read 98304/98304 bytes at offset 3145728 + 96 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 98304/98304 bytes at offset 3276800 ++read 98304/98304 bytes at offset 3276800 + 96 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 98304/98304 bytes at offset 3407872 ++read 98304/98304 bytes at offset 3407872 + 96 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 98304/98304 bytes at offset 3538944 ++read 98304/98304 bytes at offset 3538944 + 96 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 98304/98304 bytes at offset 3670016 ++read 98304/98304 bytes at offset 3670016 + 96 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 98304/98304 bytes at offset 3801088 ++read 98304/98304 bytes at offset 3801088 + 96 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 98304/98304 bytes at offset 3932160 ++read 98304/98304 bytes at offset 3932160 + 96 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 98304/98304 bytes at offset 4063232 ++read 98304/98304 bytes at offset 4063232 + 96 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 98304/98304 bytes at offset 4325376 ++read 98304/98304 bytes at offset 4325376 + 96 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 98304/98304 bytes at offset 4456448 ++read 98304/98304 bytes at offset 4456448 + 96 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 98304/98304 bytes at offset 4587520 ++read 98304/98304 bytes at offset 4587520 + 96 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 98304/98304 bytes at offset 4718592 ++read 98304/98304 bytes at offset 4718592 + 96 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 98304/98304 bytes at offset 4849664 ++read 98304/98304 bytes at offset 4849664 + 96 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 98304/98304 bytes at offset 4980736 ++read 98304/98304 bytes at offset 4980736 + 96 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 98304/98304 bytes at offset 5111808 ++read 98304/98304 bytes at offset 5111808 + 96 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 98304/98304 bytes at offset 5242880 ++read 98304/98304 bytes at offset 5242880 + 96 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 98304/98304 bytes at offset 5373952 ++read 98304/98304 bytes at offset 5373952 + 96 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 98304/98304 bytes at offset 5505024 ++read 98304/98304 bytes at offset 5505024 + 96 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 98304/98304 bytes at offset 5636096 ++read 98304/98304 bytes at offset 5636096 + 96 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 98304/98304 bytes at offset 5767168 ++read 98304/98304 bytes at offset 5767168 + 96 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 98304/98304 bytes at offset 5898240 ++read 98304/98304 bytes at offset 5898240 + 96 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 98304/98304 bytes at offset 6029312 ++read 98304/98304 bytes at offset 6029312 + 96 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 98304/98304 bytes at offset 6160384 ++read 98304/98304 bytes at offset 6160384 + 96 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 98304 ++read 32768/32768 bytes at offset 98304 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 229376 ++read 32768/32768 bytes at offset 229376 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 360448 ++read 32768/32768 bytes at offset 360448 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 491520 ++read 32768/32768 bytes at offset 491520 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 622592 ++read 32768/32768 bytes at offset 622592 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 753664 ++read 32768/32768 bytes at offset 753664 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 884736 ++read 32768/32768 bytes at offset 884736 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 1015808 ++read 32768/32768 bytes at offset 1015808 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 1146880 ++read 32768/32768 bytes at offset 1146880 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 1277952 ++read 32768/32768 bytes at offset 1277952 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 1409024 ++read 32768/32768 bytes at offset 1409024 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 1540096 ++read 32768/32768 bytes at offset 1540096 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 1671168 ++read 32768/32768 bytes at offset 1671168 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 1802240 ++read 32768/32768 bytes at offset 1802240 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 1933312 ++read 32768/32768 bytes at offset 1933312 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 2195456 ++read 32768/32768 bytes at offset 2195456 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 2326528 ++read 32768/32768 bytes at offset 2326528 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 2457600 ++read 32768/32768 bytes at offset 2457600 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 2588672 ++read 32768/32768 bytes at offset 2588672 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 2719744 ++read 32768/32768 bytes at offset 2719744 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 2850816 ++read 32768/32768 bytes at offset 2850816 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 2981888 ++read 32768/32768 bytes at offset 2981888 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 3112960 ++read 32768/32768 bytes at offset 3112960 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 3244032 ++read 32768/32768 bytes at offset 3244032 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 3375104 ++read 32768/32768 bytes at offset 3375104 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 3506176 ++read 32768/32768 bytes at offset 3506176 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 3637248 ++read 32768/32768 bytes at offset 3637248 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 3768320 ++read 32768/32768 bytes at offset 3768320 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 3899392 ++read 32768/32768 bytes at offset 3899392 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4030464 ++read 32768/32768 bytes at offset 4030464 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4292608 ++read 32768/32768 bytes at offset 4292608 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4423680 ++read 32768/32768 bytes at offset 4423680 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4554752 ++read 32768/32768 bytes at offset 4554752 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4685824 ++read 32768/32768 bytes at offset 4685824 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4816896 ++read 32768/32768 bytes at offset 4816896 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 4947968 ++read 32768/32768 bytes at offset 4947968 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 5079040 ++read 32768/32768 bytes at offset 5079040 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 5210112 ++read 32768/32768 bytes at offset 5210112 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 5341184 ++read 32768/32768 bytes at offset 5341184 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 5472256 ++read 32768/32768 bytes at offset 5472256 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 5603328 ++read 32768/32768 bytes at offset 5603328 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 5734400 ++read 32768/32768 bytes at offset 5734400 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 5865472 ++read 32768/32768 bytes at offset 5865472 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 5996544 ++read 32768/32768 bytes at offset 5996544 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 6127616 ++read 32768/32768 bytes at offset 6127616 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 6258688 ++read 32768/32768 bytes at offset 6258688 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> No errors were found on the image. ++No errors were found on the image. + *** done +diff --git a/tests/qemu-iotests/046.out b/tests/qemu-iotests/046.out +index 4b50a17..65d584b 100644 +--- a/tests/qemu-iotests/046.out ++++ b/tests/qemu-iotests/046.out +@@ -2,238 +2,238 @@ QA output created by 046 + + == creating backing file for COW tests == + Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=134217728 +-qemu-io> wrote 65536/65536 bytes at offset 0 ++wrote 65536/65536 bytes at offset 0 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 65536 ++wrote 65536/65536 bytes at offset 65536 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 131072 ++wrote 65536/65536 bytes at offset 131072 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 196608 ++wrote 65536/65536 bytes at offset 196608 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 262144 ++wrote 65536/65536 bytes at offset 262144 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 327680 ++wrote 65536/65536 bytes at offset 327680 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 393216 ++wrote 65536/65536 bytes at offset 393216 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 458752 ++wrote 65536/65536 bytes at offset 458752 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 524288 ++wrote 65536/65536 bytes at offset 524288 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 589824 ++wrote 65536/65536 bytes at offset 589824 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 655360 ++wrote 65536/65536 bytes at offset 655360 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 720896 ++wrote 65536/65536 bytes at offset 720896 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 786432 ++wrote 65536/65536 bytes at offset 786432 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 851968 ++wrote 65536/65536 bytes at offset 851968 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 917504 ++wrote 65536/65536 bytes at offset 917504 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 983040 ++wrote 65536/65536 bytes at offset 983040 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 1048576 ++wrote 65536/65536 bytes at offset 1048576 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 1114112 ++wrote 65536/65536 bytes at offset 1114112 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 1179648 ++wrote 65536/65536 bytes at offset 1179648 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 1245184 ++wrote 65536/65536 bytes at offset 1245184 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 1310720 ++wrote 65536/65536 bytes at offset 1310720 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 1376256 ++wrote 65536/65536 bytes at offset 1376256 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 1441792 ++wrote 65536/65536 bytes at offset 1441792 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 1507328 ++wrote 65536/65536 bytes at offset 1507328 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 1572864 ++wrote 65536/65536 bytes at offset 1572864 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 1638400 ++wrote 65536/65536 bytes at offset 1638400 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 1703936 ++wrote 65536/65536 bytes at offset 1703936 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 1769472 ++wrote 65536/65536 bytes at offset 1769472 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 1835008 ++wrote 65536/65536 bytes at offset 1835008 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 1900544 ++wrote 65536/65536 bytes at offset 1900544 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 1966080 ++wrote 65536/65536 bytes at offset 1966080 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset 2031616 ++wrote 65536/65536 bytes at offset 2031616 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=6442450944 backing_file='TEST_DIR/t.IMGFMT.base' ++Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=6442450944 backing_file='TEST_DIR/t.IMGFMT.base' + + == Some concurrent requests touching the same cluster == +-qemu-io> qemu-io> qemu-io> blkdebug: Suspended request 'A' +-qemu-io> qemu-io> qemu-io> qemu-io> qemu-io> blkdebug: Resuming request 'A' +-qemu-io> wrote 8192/8192 bytes at offset XXX ++blkdebug: Suspended request 'A' ++blkdebug: Resuming request 'A' ++wrote 8192/8192 bytes at offset XXX + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) + wrote 8192/8192 bytes at offset XXX + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) + wrote 8192/8192 bytes at offset XXX + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> qemu-io> blkdebug: Suspended request 'A' +-qemu-io> qemu-io> qemu-io> blkdebug: Resuming request 'A' +-qemu-io> wrote 8192/8192 bytes at offset XXX ++blkdebug: Suspended request 'A' ++blkdebug: Resuming request 'A' ++wrote 8192/8192 bytes at offset XXX + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) + wrote 65536/65536 bytes at offset XXX + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> qemu-io> blkdebug: Suspended request 'A' +-qemu-io> qemu-io> qemu-io> blkdebug: Resuming request 'A' +-qemu-io> wrote 8192/8192 bytes at offset XXX ++blkdebug: Suspended request 'A' ++blkdebug: Resuming request 'A' ++wrote 8192/8192 bytes at offset XXX + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) + wrote 65536/65536 bytes at offset XXX + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset XXX ++wrote 32768/32768 bytes at offset XXX + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> qemu-io> qemu-io> blkdebug: Suspended request 'A' +-qemu-io> qemu-io> qemu-io> blkdebug: Resuming request 'A' +-qemu-io> wrote 8192/8192 bytes at offset XXX ++blkdebug: Suspended request 'A' ++blkdebug: Resuming request 'A' ++wrote 8192/8192 bytes at offset XXX + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) + wrote 57344/57344 bytes at offset XXX + 56 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset XXX ++wrote 4096/4096 bytes at offset XXX + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 32768/32768 bytes at offset XXX ++wrote 32768/32768 bytes at offset XXX + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> qemu-io> discard 65536/65536 bytes at offset XXX ++discard 65536/65536 bytes at offset XXX + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> qemu-io> qemu-io> blkdebug: Suspended request 'A' +-qemu-io> qemu-io> qemu-io> blkdebug: Resuming request 'A' +-qemu-io> wrote 8192/8192 bytes at offset XXX ++blkdebug: Suspended request 'A' ++blkdebug: Resuming request 'A' ++wrote 8192/8192 bytes at offset XXX + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) + wrote 57344/57344 bytes at offset XXX + 56 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset XXX ++wrote 4096/4096 bytes at offset XXX + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 65536/65536 bytes at offset XXX ++wrote 65536/65536 bytes at offset XXX + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> qemu-io> discard 65536/65536 bytes at offset XXX ++discard 65536/65536 bytes at offset XXX + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> qemu-io> qemu-io> blkdebug: Suspended request 'A' +-qemu-io> qemu-io> qemu-io> blkdebug: Resuming request 'A' +-qemu-io> wrote 8192/8192 bytes at offset XXX ++blkdebug: Suspended request 'A' ++blkdebug: Resuming request 'A' ++wrote 8192/8192 bytes at offset XXX + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) + wrote 57344/57344 bytes at offset XXX + 56 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> qemu-io> blkdebug: Suspended request 'A' +-qemu-io> qemu-io> qemu-io> blkdebug: Resuming request 'A' +-qemu-io> wrote 8192/8192 bytes at offset XXX ++blkdebug: Suspended request 'A' ++blkdebug: Resuming request 'A' ++wrote 8192/8192 bytes at offset XXX + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) + wrote 98304/98304 bytes at offset XXX + 96 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> qemu-io> blkdebug: Suspended request 'A' +-qemu-io> qemu-io> qemu-io> blkdebug: Resuming request 'A' +-qemu-io> wrote 8192/8192 bytes at offset XXX ++blkdebug: Suspended request 'A' ++blkdebug: Resuming request 'A' ++wrote 8192/8192 bytes at offset XXX + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) + wrote 81920/81920 bytes at offset XXX + 80 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> qemu-io> blkdebug: Suspended request 'A' +-qemu-io> qemu-io> qemu-io> blkdebug: Resuming request 'A' +-qemu-io> wrote 32768/32768 bytes at offset XXX ++blkdebug: Suspended request 'A' ++blkdebug: Resuming request 'A' ++wrote 32768/32768 bytes at offset XXX + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) + wrote 98304/98304 bytes at offset XXX + 96 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> ++ + == Verify image content == +-qemu-io> read 65536/65536 bytes at offset 0 ++read 65536/65536 bytes at offset 0 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 65536 ++read 8192/8192 bytes at offset 65536 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 73728 ++read 8192/8192 bytes at offset 73728 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 81920 ++read 16384/16384 bytes at offset 81920 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 98304 ++read 8192/8192 bytes at offset 98304 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 106496 ++read 8192/8192 bytes at offset 106496 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 114688 ++read 8192/8192 bytes at offset 114688 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 122880 ++read 8192/8192 bytes at offset 122880 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 131072 ++read 32768/32768 bytes at offset 131072 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 163840 ++read 8192/8192 bytes at offset 163840 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 172032 ++read 65536/65536 bytes at offset 172032 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 24576/24576 bytes at offset 237568 ++read 24576/24576 bytes at offset 237568 + 24 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 262144 ++read 32768/32768 bytes at offset 262144 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 294912 ++read 8192/8192 bytes at offset 294912 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 303104 ++read 8192/8192 bytes at offset 303104 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 65536/65536 bytes at offset 311296 ++read 65536/65536 bytes at offset 311296 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 376832 ++read 16384/16384 bytes at offset 376832 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 24576/24576 bytes at offset 393216 ++read 24576/24576 bytes at offset 393216 + 24 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 417792 ++read 8192/8192 bytes at offset 417792 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 425984 ++read 8192/8192 bytes at offset 425984 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 57344/57344 bytes at offset 434176 ++read 57344/57344 bytes at offset 434176 + 56 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 24576/24576 bytes at offset 491520 ++read 24576/24576 bytes at offset 491520 + 24 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 516096 ++read 8192/8192 bytes at offset 516096 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 24576/24576 bytes at offset 524288 ++read 24576/24576 bytes at offset 524288 + 24 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 548864 ++read 8192/8192 bytes at offset 548864 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 557056 ++read 8192/8192 bytes at offset 557056 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 57344/57344 bytes at offset 565248 ++read 57344/57344 bytes at offset 565248 + 56 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 24576/24576 bytes at offset 622592 ++read 24576/24576 bytes at offset 622592 + 24 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 647168 ++read 8192/8192 bytes at offset 647168 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 24576/24576 bytes at offset 655360 ++read 24576/24576 bytes at offset 655360 + 24 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 679936 ++read 8192/8192 bytes at offset 679936 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 688128 ++read 8192/8192 bytes at offset 688128 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 57344/57344 bytes at offset 696320 ++read 57344/57344 bytes at offset 696320 + 56 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 753664 ++read 32768/32768 bytes at offset 753664 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 786432 ++read 16384/16384 bytes at offset 786432 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 98304/98304 bytes at offset 802816 ++read 98304/98304 bytes at offset 802816 + 96 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 901120 ++read 8192/8192 bytes at offset 901120 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 909312 ++read 8192/8192 bytes at offset 909312 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 917504 ++read 16384/16384 bytes at offset 917504 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 81920/81920 bytes at offset 933888 ++read 81920/81920 bytes at offset 933888 + 80 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 1015808 ++read 16384/16384 bytes at offset 1015808 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1032192 ++read 8192/8192 bytes at offset 1032192 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 8192/8192 bytes at offset 1040384 ++read 8192/8192 bytes at offset 1040384 + 8 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 1048576 ++read 16384/16384 bytes at offset 1048576 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 1064960 ++read 32768/32768 bytes at offset 1064960 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 32768/32768 bytes at offset 1130496 ++read 32768/32768 bytes at offset 1130496 + 32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 16384/16384 bytes at offset 1163264 ++read 16384/16384 bytes at offset 1163264 + 16 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> No errors were found on the image. ++No errors were found on the image. + *** done +diff --git a/tests/qemu-iotests/047.out b/tests/qemu-iotests/047.out +index 81b2ff7..959f2af 100644 +--- a/tests/qemu-iotests/047.out ++++ b/tests/qemu-iotests/047.out +@@ -1,22 +1,22 @@ + QA output created by 047 + Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=134217728 +-qemu-io> wrote 327680/327680 bytes at offset 0 ++wrote 327680/327680 bytes at offset 0 + 320 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 131072/131072 bytes at offset 327680 ++wrote 131072/131072 bytes at offset 327680 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 131072/131072 bytes at offset 1048576 ++wrote 131072/131072 bytes at offset 1048576 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 131072/131072 bytes at offset 458752 ++wrote 131072/131072 bytes at offset 458752 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> discard 131072/131072 bytes at offset 327680 ++discard 131072/131072 bytes at offset 327680 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> qemu-io> qemu-io> wrote 491520/491520 bytes at offset 0 ++wrote 491520/491520 bytes at offset 0 + 480 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> qemu-io> qemu-io> read 491520/491520 bytes at offset 0 ++read 491520/491520 bytes at offset 0 + 480 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 98304/98304 bytes at offset 491520 ++read 98304/98304 bytes at offset 491520 + 96 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> read 131072/131072 bytes at offset 1048576 ++read 131072/131072 bytes at offset 1048576 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> No errors were found on the image. ++No errors were found on the image. + *** done +diff --git a/tests/qemu-iotests/048.out b/tests/qemu-iotests/048.out +index 68f65d5..75f6a15 100644 +--- a/tests/qemu-iotests/048.out ++++ b/tests/qemu-iotests/048.out +@@ -1,15 +1,15 @@ + QA output created by 048 + Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824 + === IO: pattern 45 +-qemu-io> wrote 4096/4096 bytes at offset 524288 ++wrote 4096/4096 bytes at offset 524288 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 528384 ++wrote 4096/4096 bytes at offset 528384 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 532480 ++wrote 4096/4096 bytes at offset 532480 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> wrote 4096/4096 bytes at offset 536576 ++wrote 4096/4096 bytes at offset 536576 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> Images are identical. ++Images are identical. + 0 + 0 + Image resized. +@@ -19,13 +19,13 @@ Images are identical. + Strict mode: Image size mismatch! + 1 + === IO: pattern 67 +-qemu-io> wrote 4096/4096 bytes at offset 1228800 ++wrote 4096/4096 bytes at offset 1228800 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> Content mismatch at offset 1228800! ++Content mismatch at offset 1228800! + 1 + === IO: pattern 123 +-qemu-io> wrote 4096/4096 bytes at offset 0 ++wrote 4096/4096 bytes at offset 0 + 4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-qemu-io> Content mismatch at offset 0! ++Content mismatch at offset 0! + 1 + Cleanup +diff --git a/tests/qemu-iotests/common.filter b/tests/qemu-iotests/common.filter +index 8e7b1a4..9c82c77 100644 +--- a/tests/qemu-iotests/common.filter ++++ b/tests/qemu-iotests/common.filter +@@ -149,7 +149,8 @@ _filter_win32() + # sanitize qemu-io output + _filter_qemu_io() + { +- _filter_win32 | sed -e "s/[0-9]* ops\; [0-9/:. sec]* ([0-9/.inf]* [EPTGMKiBbytes]*\/sec and [0-9/.inf]* ops\/sec)/X ops\; XX:XX:XX.X (XXX YYY\/sec and XXX ops\/sec)/" ++ _filter_win32 | sed -e "s/[0-9]* ops\; [0-9/:. sec]* ([0-9/.inf]* [EPTGMKiBbytes]*\/sec and [0-9/.inf]* ops\/sec)/X ops\; XX:XX:XX.X (XXX YYY\/sec and XXX ops\/sec)/" \ ++ -e "s/qemu-io> //g" + } + + # replace occurrences of QEMU_PROG with "qemu" +-- +1.7.1 + diff --git a/SOURCES/kvm-qemu-iotests-Fix-test-041.patch b/SOURCES/kvm-qemu-iotests-Fix-test-041.patch new file mode 100644 index 0000000..043b15f --- /dev/null +++ b/SOURCES/kvm-qemu-iotests-Fix-test-041.patch @@ -0,0 +1,102 @@ +From 8a95de5d6c85d1db0f32ab5083ff9e00166a7ee8 Mon Sep 17 00:00:00 2001 +From: Max Reitz +Date: Sun, 19 Jan 2014 18:08:01 +0100 +Subject: [PATCH 27/34] qemu-iotests: Fix test 041 + +RH-Author: Max Reitz +Message-id: <1390154881-17140-8-git-send-email-mreitz@redhat.com> +Patchwork-id: 56820 +O-Subject: [RHEL-7.0 qemu-kvm PATCH v2 7/7] qemu-iotests: Fix test 041 +Bugzilla: 921890 +RH-Acked-by: Fam Zheng +RH-Acked-by: Kevin Wolf +RH-Acked-by: Jeffrey Cody + +BZ: 921890 + +Performing multiple drive-mirror blockjobs on the same qemu instance +results in the image file used for the block device being replaced by +the newly mirrored file, which is not what we want. + +Fix this by performing one dedicated test per sync mode. + +Signed-off-by: Max Reitz +Reviewed-by: Paolo Bonzini +Reviewed-by: Kevin Wolf +Reviewed-by: Eric Blake +Message-id: 1385407736-13941-3-git-send-email-mreitz@redhat.com +Signed-off-by: Anthony Liguori +(cherry picked from commit 171d64319c9604228429b0580edf764a69b67c75) + +Signed-off-by: Max Reitz +--- + tests/qemu-iotests/041 | 32 ++++++++++++++++++++++++-------- + tests/qemu-iotests/041.out | 4 ++-- + 2 files changed, 26 insertions(+), 10 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + tests/qemu-iotests/041 | 32 ++++++++++++++++++++++++-------- + tests/qemu-iotests/041.out | 4 ++-- + 2 files changed, 26 insertions(+), 10 deletions(-) + +diff --git a/tests/qemu-iotests/041 b/tests/qemu-iotests/041 +index eccfe38..bcfb759 100755 +--- a/tests/qemu-iotests/041 ++++ b/tests/qemu-iotests/041 +@@ -750,16 +750,32 @@ class TestUnbackedSource(ImageMirroringTestCase): + os.remove(test_img) + os.remove(target_img) + +- def test_absolute_paths(self): ++ def test_absolute_paths_full(self): ++ self.assert_no_active_block_jobs() ++ result = self.vm.qmp('drive-mirror', device='drive0', ++ sync='full', target=target_img, ++ mode='absolute-paths') ++ self.assert_qmp(result, 'return', {}) ++ self.complete_and_wait() ++ self.assert_no_active_block_jobs() ++ ++ def test_absolute_paths_top(self): ++ self.assert_no_active_block_jobs() ++ result = self.vm.qmp('drive-mirror', device='drive0', ++ sync='top', target=target_img, ++ mode='absolute-paths') ++ self.assert_qmp(result, 'return', {}) ++ self.complete_and_wait() + self.assert_no_active_block_jobs() + +- for sync_mode in ['full', 'top', 'none']: +- result = self.vm.qmp('drive-mirror', device='drive0', +- sync=sync_mode, target=target_img, +- mode='absolute-paths') +- self.assert_qmp(result, 'return', {}) +- self.complete_and_wait() +- self.assert_no_active_block_jobs() ++ def test_absolute_paths_none(self): ++ self.assert_no_active_block_jobs() ++ result = self.vm.qmp('drive-mirror', device='drive0', ++ sync='none', target=target_img, ++ mode='absolute-paths') ++ self.assert_qmp(result, 'return', {}) ++ self.complete_and_wait() ++ self.assert_no_active_block_jobs() + + if __name__ == '__main__': + iotests.main(supported_fmts=['qcow2', 'qed']) +diff --git a/tests/qemu-iotests/041.out b/tests/qemu-iotests/041.out +index 4fd1c2d..6d9bee1 100644 +--- a/tests/qemu-iotests/041.out ++++ b/tests/qemu-iotests/041.out +@@ -1,5 +1,5 @@ +-......................... ++........................... + ---------------------------------------------------------------------- +-Ran 25 tests ++Ran 27 tests + + OK +-- +1.7.1 + diff --git a/SOURCES/kvm-qemu-iotests-New-test-case-in-061.patch b/SOURCES/kvm-qemu-iotests-New-test-case-in-061.patch new file mode 100644 index 0000000..c0a92bb --- /dev/null +++ b/SOURCES/kvm-qemu-iotests-New-test-case-in-061.patch @@ -0,0 +1,128 @@ +From af156d9a912c96203f26cde732f95357d7f63cd4 Mon Sep 17 00:00:00 2001 +From: Max Reitz +Date: Tue, 7 Jan 2014 21:57:18 +0100 +Subject: [PATCH 13/14] qemu-iotests: New test case in 061 + +RH-Author: Max Reitz +Message-id: <1389131839-12920-14-git-send-email-mreitz@redhat.com> +Patchwork-id: 56549 +O-Subject: [RHEL-7.0 qemu-kvm PATCH v2 13/14] qemu-iotests: New test case in 061 +Bugzilla: 1033490 +RH-Acked-by: Kevin Wolf +RH-Acked-by: Fam Zheng +RH-Acked-by: Stefan Hajnoczi + +BZ: 1033490 + +Add one test case for zero cluster expansion on qcow2 version downgrade +in shared L2 tables (i.e., L2 tables with a refcount > 1) and one for +zero expansion on backed clusters in shared L2 tables. + +Signed-off-by: Max Reitz +Signed-off-by: Kevin Wolf +(cherry picked from commit d982919d3897f36d79e215c46e3bc27fd6e27bf8) + +Signed-off-by: Max Reitz +--- + tests/qemu-iotests/061 | 28 ++++++++++++++++++++++++++++ + tests/qemu-iotests/061.out | 27 +++++++++++++++++++++++++++ + 2 files changed, 55 insertions(+) + +Signed-off-by: Miroslav Rezanina +--- + tests/qemu-iotests/061 | 28 ++++++++++++++++++++++++++++ + tests/qemu-iotests/061.out | 27 +++++++++++++++++++++++++++ + 2 files changed, 55 insertions(+), 0 deletions(-) + +diff --git a/tests/qemu-iotests/061 b/tests/qemu-iotests/061 +index 86404e6..5f04bfa 100644 +--- a/tests/qemu-iotests/061 ++++ b/tests/qemu-iotests/061 +@@ -146,6 +146,19 @@ _check_test_img + $QEMU_IO -c "read -P 0 0 128k" "$TEST_IMG" | _filter_qemu_io + + echo ++echo "=== Testing zero expansion on shared L2 table ===" ++echo ++IMGOPTS="compat=1.1" _make_test_img 64M ++$QEMU_IO -c "write -z 0 128k" "$TEST_IMG" | _filter_qemu_io ++$QEMU_IMG snapshot -c foo "$TEST_IMG" ++$QEMU_IMG amend -o "compat=0.10" "$TEST_IMG" ++_check_test_img ++$QEMU_IO -c "read -P 0 0 128k" "$TEST_IMG" | _filter_qemu_io ++$QEMU_IMG snapshot -a foo "$TEST_IMG" ++_check_test_img ++$QEMU_IO -c "read -P 0 0 128k" "$TEST_IMG" | _filter_qemu_io ++ ++echo + echo "=== Testing zero expansion on backed image ===" + echo + IMGOPTS="compat=1.1" TEST_IMG="$TEST_IMG.base" _make_test_img 64M +@@ -172,6 +185,21 @@ $QEMU_IMG snapshot -a foo "$TEST_IMG" + _check_test_img + $QEMU_IO -c "read -P 0 0 64k" -c "read -P 0x2a 64k 64k" "$TEST_IMG" | _filter_qemu_io + ++echo ++echo "=== Testing zero expansion on backed image with shared L2 table ===" ++echo ++IMGOPTS="compat=1.1" TEST_IMG="$TEST_IMG.base" _make_test_img 64M ++$QEMU_IO -c "write -P 0x2a 0 128k" "$TEST_IMG.base" | _filter_qemu_io ++IMGOPTS="compat=1.1,backing_file=$TEST_IMG.base" _make_test_img 64M ++$QEMU_IO -c "write -z 0 128k" "$TEST_IMG" | _filter_qemu_io ++$QEMU_IMG snapshot -c foo "$TEST_IMG" ++$QEMU_IMG amend -o "compat=0.10" "$TEST_IMG" ++_check_test_img ++$QEMU_IO -c "read -P 0 0 128k" "$TEST_IMG" | _filter_qemu_io ++$QEMU_IMG snapshot -a foo "$TEST_IMG" ++_check_test_img ++$QEMU_IO -c "read -P 0 0 128k" "$TEST_IMG" | _filter_qemu_io ++ + # success, all done + echo "*** done" + rm -f $seq.full +diff --git a/tests/qemu-iotests/061.out b/tests/qemu-iotests/061.out +index 05bd1d5..d42127f 100644 +--- a/tests/qemu-iotests/061.out ++++ b/tests/qemu-iotests/061.out +@@ -312,6 +312,18 @@ No errors were found on the image. + read 131072/131072 bytes at offset 0 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) + ++=== Testing zero expansion on shared L2 table === ++ ++Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864 ++wrote 131072/131072 bytes at offset 0 ++128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) ++No errors were found on the image. ++read 131072/131072 bytes at offset 0 ++128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) ++No errors were found on the image. ++read 131072/131072 bytes at offset 0 ++128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) ++ + === Testing zero expansion on backed image === + + Formatting 'TEST_DIR/t.IMGFMT.base', fmt=IMGFMT size=67108864 +@@ -346,4 +358,19 @@ read 65536/65536 bytes at offset 0 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) + read 65536/65536 bytes at offset 65536 + 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) ++ ++=== Testing zero expansion on backed image with shared L2 table === ++ ++Formatting 'TEST_DIR/t.IMGFMT.base', fmt=IMGFMT size=67108864 ++wrote 131072/131072 bytes at offset 0 ++128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) ++Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864 backing_file='TEST_DIR/t.IMGFMT.base' ++wrote 131072/131072 bytes at offset 0 ++128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) ++No errors were found on the image. ++read 131072/131072 bytes at offset 0 ++128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) ++No errors were found on the image. ++read 131072/131072 bytes at offset 0 ++128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) + *** done +-- +1.7.1 + diff --git a/SOURCES/kvm-qemu-iotests-Preallocated-zero-clusters-in-061.patch b/SOURCES/kvm-qemu-iotests-Preallocated-zero-clusters-in-061.patch new file mode 100644 index 0000000..bdb0dc7 --- /dev/null +++ b/SOURCES/kvm-qemu-iotests-Preallocated-zero-clusters-in-061.patch @@ -0,0 +1,78 @@ +From 6c3f41d4c4e48cb641c8cf17f6df7b60558427ac Mon Sep 17 00:00:00 2001 +From: Max Reitz +Date: Tue, 7 Jan 2014 21:57:19 +0100 +Subject: [PATCH 14/14] qemu-iotests: Preallocated zero clusters in 061 + +RH-Author: Max Reitz +Message-id: <1389131839-12920-15-git-send-email-mreitz@redhat.com> +Patchwork-id: 56550 +O-Subject: [RHEL-7.0 qemu-kvm PATCH v2 14/14] qemu-iotests: Preallocated zero clusters in 061 +Bugzilla: 1033490 +RH-Acked-by: Kevin Wolf +RH-Acked-by: Fam Zheng +RH-Acked-by: Stefan Hajnoczi + +BZ: 1033490 + +Add a test case for zero cluster expansion on an image completely filled +with preallocated zero clusters to test 061. + +Signed-off-by: Max Reitz +Signed-off-by: Kevin Wolf +(cherry picked from commit fd9e03e6060b3a64099d17e4a886421b21dd7341) + +Signed-off-by: Max Reitz +--- + tests/qemu-iotests/061 | 9 +++++++++ + tests/qemu-iotests/061.out | 11 +++++++++++ + 2 files changed, 20 insertions(+) + +Signed-off-by: Miroslav Rezanina +--- + tests/qemu-iotests/061 | 9 +++++++++ + tests/qemu-iotests/061.out | 11 +++++++++++ + 2 files changed, 20 insertions(+), 0 deletions(-) + +diff --git a/tests/qemu-iotests/061 b/tests/qemu-iotests/061 +index 5f04bfa..fa9319d 100644 +--- a/tests/qemu-iotests/061 ++++ b/tests/qemu-iotests/061 +@@ -200,6 +200,15 @@ $QEMU_IMG snapshot -a foo "$TEST_IMG" + _check_test_img + $QEMU_IO -c "read -P 0 0 128k" "$TEST_IMG" | _filter_qemu_io + ++echo ++echo "=== Testing preallocated zero expansion on full image ===" ++echo ++IMGOPTS="compat=1.1" TEST_IMG="$TEST_IMG" _make_test_img 64M ++$QEMU_IO -c "write -P 0x2a 0 64M" "$TEST_IMG" -c "write -z 0 64M" | _filter_qemu_io ++$QEMU_IMG amend -o "compat=0.10" "$TEST_IMG" ++_check_test_img ++$QEMU_IO -c "read -P 0 0 64M" "$TEST_IMG" | _filter_qemu_io ++ + # success, all done + echo "*** done" + rm -f $seq.full +diff --git a/tests/qemu-iotests/061.out b/tests/qemu-iotests/061.out +index d42127f..4027e00 100644 +--- a/tests/qemu-iotests/061.out ++++ b/tests/qemu-iotests/061.out +@@ -373,4 +373,15 @@ read 131072/131072 bytes at offset 0 + No errors were found on the image. + read 131072/131072 bytes at offset 0 + 128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) ++ ++=== Testing preallocated zero expansion on full image === ++ ++Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864 ++wrote 67108864/67108864 bytes at offset 0 ++64 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) ++wrote 67108864/67108864 bytes at offset 0 ++64 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) ++No errors were found on the image. ++read 67108864/67108864 bytes at offset 0 ++64 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) + *** done +-- +1.7.1 + diff --git a/SOURCES/kvm-qemu-iotests-Remaining-error-propagation-adjustments.patch b/SOURCES/kvm-qemu-iotests-Remaining-error-propagation-adjustments.patch new file mode 100644 index 0000000..31c929a --- /dev/null +++ b/SOURCES/kvm-qemu-iotests-Remaining-error-propagation-adjustments.patch @@ -0,0 +1,100 @@ +From b1ee83f0ffaac613717792a9681b0f1f79fcc108 Mon Sep 17 00:00:00 2001 +From: Max Reitz +Date: Sun, 29 Dec 2013 22:06:55 +0100 +Subject: [PATCH 4/8] qemu-iotests: Remaining error propagation adjustments + +RH-Author: Max Reitz +Message-id: <1388354817-3013-4-git-send-email-mreitz@redhat.com> +Patchwork-id: 56445 +O-Subject: [RHEL-7.0 qemu-kvm PATCH 3/5] qemu-iotests: Remaining error propagation adjustments +Bugzilla: 1004347 +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Fam Zheng +RH-Acked-by: Kevin Wolf + +BZ: 1004347 + +This downstream-only patch contains the hunks which have been omitted +when aaf2d00ea8cd6479c5dd15773660e0699472af1c was cherry-picked from +2c78857bf6a9b5d06e17533b8f40fee14e087987, i.e., fixes tests 054 and 060. + +Furthermore, this sets the executable bit for the tests 060, 063 and 067 +(which, for some reason, have been cleared until now). + +Signed-off-by: Max Reitz +--- + tests/qemu-iotests/054.out | 4 ++-- + tests/qemu-iotests/060 | 2 +- + tests/qemu-iotests/060.out | 3 +-- + tests/qemu-iotests/063 | 0 + tests/qemu-iotests/067 | 0 + 5 files changed, 4 insertions(+), 5 deletions(-) + mode change 100644 => 100755 tests/qemu-iotests/060 + mode change 100644 => 100755 tests/qemu-iotests/063 + mode change 100644 => 100755 tests/qemu-iotests/067 + +diff --git a/tests/qemu-iotests/060 b/tests/qemu-iotests/060 +old mode 100644 +new mode 100755 +index 65bb09f..9bbc43b +diff --git a/tests/qemu-iotests/063 b/tests/qemu-iotests/063 +old mode 100644 +new mode 100755 +diff --git a/tests/qemu-iotests/067 b/tests/qemu-iotests/067 +old mode 100644 +new mode 100755 + +Signed-off-by: Miroslav Rezanina +--- + tests/qemu-iotests/054.out | 4 ++-- + tests/qemu-iotests/060 | 2 +- + tests/qemu-iotests/060.out | 3 +-- + 3 files changed, 4 insertions(+), 5 deletions(-) + +diff --git a/tests/qemu-iotests/054.out b/tests/qemu-iotests/054.out +index 0b2fe30..7161d6e 100644 +--- a/tests/qemu-iotests/054.out ++++ b/tests/qemu-iotests/054.out +@@ -1,10 +1,10 @@ + QA output created by 054 + + creating too large image (1 EB) +-qemu-img: The image size is too large for file format 'qcow2' ++qemu-img: TEST_DIR/t.IMGFMT: The image size is too large for file format 'IMGFMT' (try using a larger cluster size) + Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1152921504606846976 + + creating too large image (1 EB) using qcow2.py + Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=4294967296 +-qemu-img: Could not open 'TEST_DIR/t.qcow2': File too large ++qemu-img: Could not open 'TEST_DIR/t.qcow2': Image is too big + *** done +diff --git a/tests/qemu-iotests/060 b/tests/qemu-iotests/060 +index 65bb09f..9bbc43b 100644 +--- a/tests/qemu-iotests/060 ++++ b/tests/qemu-iotests/060 +@@ -71,7 +71,7 @@ $QEMU_IO -c "write -P 0x2a 0 512" "$TEST_IMG" | _filter_qemu_io + ./qcow2.py "$TEST_IMG" dump-header | grep incompatible_features + + # Try to open the image R/W (which should fail) +-$QEMU_IO -c "read 0 512" "$TEST_IMG" 2>&1 | _filter_qemu_io | sed -e "s/can't open device .*$/can't open device/" ++$QEMU_IO -c "read 0 512" "$TEST_IMG" 2>&1 | _filter_qemu_io | _filter_testdir | _filter_imgfmt + + # Try to open it RO (which should succeed) + $QEMU_IO -c "read 0 512" -r "$TEST_IMG" | _filter_qemu_io +diff --git a/tests/qemu-iotests/060.out b/tests/qemu-iotests/060.out +index ca4583a..648f743 100644 +--- a/tests/qemu-iotests/060.out ++++ b/tests/qemu-iotests/060.out +@@ -11,8 +11,7 @@ incompatible_features 0x0 + qcow2: Preventing invalid write on metadata (overlaps with active L1 table); image marked as corrupt. + write failed: Input/output error + incompatible_features 0x2 +-qcow2: Image is corrupt; cannot be opened read/write. +-qemu-io: can't open device ++qemu-io: can't open device TEST_DIR/t.IMGFMT: IMGFMT: Image is corrupt; cannot be opened read/write + no file open, try 'help open' + read 512/512 bytes at offset 0 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +-- +1.7.1 + diff --git a/SOURCES/kvm-qemu-iotests-Snapshotting-zero-clusters.patch b/SOURCES/kvm-qemu-iotests-Snapshotting-zero-clusters.patch new file mode 100644 index 0000000..23bbbcf --- /dev/null +++ b/SOURCES/kvm-qemu-iotests-Snapshotting-zero-clusters.patch @@ -0,0 +1,143 @@ +From 36be200f11e87ccd97a54236550be41bc3ec6862 Mon Sep 17 00:00:00 2001 +From: Max Reitz +Date: Thu, 9 Jan 2014 09:11:13 +0100 +Subject: [PATCH 03/14] qemu-iotests: Snapshotting zero clusters + +Message-id: <1389131839-12920-4-git-send-email-mreitz@redhat.com> +Patchwork-id: 56539 +O-Subject: [RHEL-7.0 qemu-kvm PATCH v2 03/14] qemu-iotests: Snapshotting zero clusters +Bugzilla: 1033490 +RH-Acked-by: Kevin Wolf +RH-Acked-by: Fam Zheng +RH-Acked-by: Stefan Hajnoczi + +BZ: 1033490 + +This test creates an image with unallocated zero clusters, then creates +a snapshot. Afterwards, there should be neither any errors nor leaks. + +Signed-off-by: Max Reitz +Signed-off-by: Kevin Wolf +(cherry picked from commit 449df7063815489a0b091bcb3afa9ae80ae3acbf) + +Signed-off-by: Max Reitz + +Conflicts: + tests/qemu-iotests/group +--- + tests/qemu-iotests/062 | 64 ++++++++++++++++++++++++++++++++++++++++++++++ + tests/qemu-iotests/062.out | 9 +++++++ + tests/qemu-iotests/group | 1 + + 3 files changed, 74 insertions(+) + create mode 100755 tests/qemu-iotests/062 + create mode 100644 tests/qemu-iotests/062.out + +Signed-off-by: Miroslav Rezanina +--- + tests/qemu-iotests/062 | 64 ++++++++++++++++++++++++++++++++++++++++++++ + tests/qemu-iotests/062.out | 9 ++++++ + tests/qemu-iotests/group | 1 + + 3 files changed, 74 insertions(+), 0 deletions(-) + create mode 100644 tests/qemu-iotests/062 + create mode 100644 tests/qemu-iotests/062.out + +diff --git a/tests/qemu-iotests/062 b/tests/qemu-iotests/062 +new file mode 100644 +index 0000000..0511246 +--- /dev/null ++++ b/tests/qemu-iotests/062 +@@ -0,0 +1,64 @@ ++#!/bin/bash ++# ++# Test case for snapshotting images with unallocated zero clusters in ++# qcow2 ++# ++# Copyright (C) 2013 Red Hat, Inc. ++# ++# This program is free software; you can redistribute it and/or modify ++# it under the terms of the GNU General Public License as published by ++# the Free Software Foundation; either version 2 of the License, or ++# (at your option) any later version. ++# ++# This program is distributed in the hope that it will be useful, ++# but WITHOUT ANY WARRANTY; without even the implied warranty of ++# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++# GNU General Public License for more details. ++# ++# You should have received a copy of the GNU General Public License ++# along with this program. If not, see . ++# ++ ++# creator ++owner=mreitz@redhat.com ++ ++seq=`basename $0` ++echo "QA output created by $seq" ++ ++here=`pwd` ++tmp=/tmp/$$ ++status=1 # failure is the default! ++ ++_cleanup() ++{ ++ _cleanup_test_img ++} ++trap "_cleanup; exit \$status" 0 1 2 3 15 ++ ++# get standard environment, filters and checks ++. ./common.rc ++. ./common.filter ++ ++# This tests qocw2-specific low-level functionality ++_supported_fmt qcow2 ++_supported_proto generic ++_supported_os Linux ++ ++IMGOPTS="compat=1.1" ++IMG_SIZE=64M ++ ++echo ++echo "=== Testing snapshotting an image with zero clusters ===" ++echo ++_make_test_img $IMG_SIZE ++# Write some zero clusters ++$QEMU_IO -c "write -z 0 256k" "$TEST_IMG" | _filter_qemu_io ++# Create a snapshot ++$QEMU_IMG snapshot -c foo "$TEST_IMG" ++# Check the image (there shouldn't be any errors or leaks) ++_check_test_img ++ ++# success, all done ++echo "*** done" ++rm -f $seq.full ++status=0 +diff --git a/tests/qemu-iotests/062.out b/tests/qemu-iotests/062.out +new file mode 100644 +index 0000000..442d761 +--- /dev/null ++++ b/tests/qemu-iotests/062.out +@@ -0,0 +1,9 @@ ++QA output created by 062 ++ ++=== Testing snapshotting an image with zero clusters === ++ ++Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864 ++wrote 262144/262144 bytes at offset 0 ++256 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) ++No errors were found on the image. ++*** done +diff --git a/tests/qemu-iotests/group b/tests/qemu-iotests/group +index 0867b0f..2d0aba0 100644 +--- a/tests/qemu-iotests/group ++++ b/tests/qemu-iotests/group +@@ -63,6 +63,7 @@ + 054 rw auto + 059 rw auto + 060 rw auto ++062 rw auto + 063 rw auto + 064 rw auto + 065 rw auto +-- +1.7.1 + diff --git a/SOURCES/kvm-qemu-iotests-Support-for-bochs-format.patch b/SOURCES/kvm-qemu-iotests-Support-for-bochs-format.patch new file mode 100644 index 0000000..8c19a55 --- /dev/null +++ b/SOURCES/kvm-qemu-iotests-Support-for-bochs-format.patch @@ -0,0 +1,146 @@ +From a510cccdd420d33dc4c12eb5f638521f8d951e22 Mon Sep 17 00:00:00 2001 +From: Kevin Wolf +Date: Tue, 25 Mar 2014 14:23:16 +0100 +Subject: [PATCH 09/49] qemu-iotests: Support for bochs format + +RH-Author: Kevin Wolf +Message-id: <1395753835-7591-10-git-send-email-kwolf@redhat.com> +Patchwork-id: n/a +O-Subject: [virt-devel] [EMBARGOED RHEL-7.0 qemu-kvm PATCH 09/48] qemu-iotests: Support for bochs format +Bugzilla: 1066691 +RH-Acked-by: Jeff Cody +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Paolo Bonzini + +Bugzilla: https://bugzilla.redhat.com/show_bug.cgi?id=1066691 +Upstream status: Series embargoed + +Signed-off-by: Kevin Wolf +Reviewed-by: Stefan Hajnoczi + +Conflicts: +tests/qemu-iotests/group + +Signed-off-by: Kevin Wolf +--- + tests/qemu-iotests/078 | 53 ++++++++++++++++++++++ + tests/qemu-iotests/078.out | 6 +++ + tests/qemu-iotests/common | 7 +++ + tests/qemu-iotests/group | 1 + + tests/qemu-iotests/sample_images/empty.bochs.bz2 | Bin 0 -> 118 bytes + 5 files changed, 67 insertions(+), 0 deletions(-) + create mode 100755 tests/qemu-iotests/078 + create mode 100644 tests/qemu-iotests/078.out + create mode 100644 tests/qemu-iotests/sample_images/empty.bochs.bz2 + +diff --git a/tests/qemu-iotests/078 b/tests/qemu-iotests/078 +new file mode 100755 +index 0000000..f55f46d +--- /dev/null ++++ b/tests/qemu-iotests/078 +@@ -0,0 +1,53 @@ ++#!/bin/bash ++# ++# bochs format input validation tests ++# ++# Copyright (C) 2013 Red Hat, Inc. ++# ++# This program is free software; you can redistribute it and/or modify ++# it under the terms of the GNU General Public License as published by ++# the Free Software Foundation; either version 2 of the License, or ++# (at your option) any later version. ++# ++# This program is distributed in the hope that it will be useful, ++# but WITHOUT ANY WARRANTY; without even the implied warranty of ++# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++# GNU General Public License for more details. ++# ++# You should have received a copy of the GNU General Public License ++# along with this program. If not, see . ++# ++ ++# creator ++owner=kwolf@redhat.com ++ ++seq=`basename $0` ++echo "QA output created by $seq" ++ ++here=`pwd` ++tmp=/tmp/$$ ++status=1 # failure is the default! ++ ++_cleanup() ++{ ++ _cleanup_test_img ++} ++trap "_cleanup; exit \$status" 0 1 2 3 15 ++ ++# get standard environment, filters and checks ++. ./common.rc ++. ./common.filter ++ ++_supported_fmt bochs ++_supported_proto generic ++_supported_os Linux ++ ++echo ++echo "== Read from a valid image ==" ++_use_sample_img empty.bochs.bz2 ++{ $QEMU_IO -c "read 0 512" $TEST_IMG; } 2>&1 | _filter_qemu_io | _filter_testdir ++ ++# success, all done ++echo "*** done" ++rm -f $seq.full ++status=0 +diff --git a/tests/qemu-iotests/078.out b/tests/qemu-iotests/078.out +new file mode 100644 +index 0000000..25d37c5 +--- /dev/null ++++ b/tests/qemu-iotests/078.out +@@ -0,0 +1,6 @@ ++QA output created by 078 ++ ++== Read from a valid image == ++read 512/512 bytes at offset 0 ++512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) ++*** done +diff --git a/tests/qemu-iotests/common b/tests/qemu-iotests/common +index b5043fc..35abbfc 100644 +--- a/tests/qemu-iotests/common ++++ b/tests/qemu-iotests/common +@@ -128,6 +128,7 @@ common options + + check options + -raw test raw (default) ++ -bochs test bochs + -cow test cow + -cloop test cloop + -qcow test qcow +@@ -163,6 +164,12 @@ testlist options + xpand=false + ;; + ++ -bochs) ++ IMGFMT=bochs ++ IMGFMT_GENERIC=false ++ xpand=false ++ ;; ++ + -cow) + IMGFMT=cow + xpand=false +diff --git a/tests/qemu-iotests/group b/tests/qemu-iotests/group +index 427818c..30a0fd8 100644 +--- a/tests/qemu-iotests/group ++++ b/tests/qemu-iotests/group +@@ -73,6 +73,7 @@ + 070 rw auto + 075 rw auto + 077 rw auto ++078 rw auto + 079 rw auto + 082 rw auto quick + 086 rw auto quick +-- +1.7.1 + diff --git a/SOURCES/kvm-qemu-iotests-Test-progress-output-for-conversion.patch b/SOURCES/kvm-qemu-iotests-Test-progress-output-for-conversion.patch new file mode 100644 index 0000000..2f12d8b --- /dev/null +++ b/SOURCES/kvm-qemu-iotests-Test-progress-output-for-conversion.patch @@ -0,0 +1,146 @@ +From c75a52dd49f8b6f888a21952a30b5e3590093fd7 Mon Sep 17 00:00:00 2001 +From: Kevin Wolf +Date: Mon, 10 Mar 2014 10:33:23 +0100 +Subject: [PATCH 12/16] qemu-iotests: Test progress output for conversion + +RH-Author: Kevin Wolf +Message-id: <1394447603-30527-3-git-send-email-kwolf@redhat.com> +Patchwork-id: 58061 +O-Subject: [RHEL-7.0 qemu-kvm PATCH 2/2] qemu-iotests: Test progress output for conversion +Bugzilla: 1073728 +RH-Acked-by: Laszlo Ersek +RH-Acked-by: Max Reitz +RH-Acked-by: Jeffrey Cody +RH-Acked-by: Stefan Hajnoczi + +Signed-off-by: Kevin Wolf +(cherry picked from commit 2fa4c042bc55ec10b9ca16163697d02cddd2d768) + +Percentages in the output differ from upstream because RHEL 7 doesnt' +have upstream commit 802c3d4c. + +Signed-off-by: Kevin Wolf +--- + tests/qemu-iotests/086 | 65 ++++++++++++++++++++++++++++++++++++++++++++++ + tests/qemu-iotests/086.out | 18 +++++++++++++ + tests/qemu-iotests/group | 1 + + 3 files changed, 84 insertions(+) + create mode 100755 tests/qemu-iotests/086 + create mode 100644 tests/qemu-iotests/086.out + +Signed-off-by: Miroslav Rezanina +--- + tests/qemu-iotests/086 | 65 ++++++++++++++++++++++++++++++++++++++++++++ + tests/qemu-iotests/086.out | 18 ++++++++++++ + tests/qemu-iotests/group | 1 + + 3 files changed, 84 insertions(+), 0 deletions(-) + create mode 100755 tests/qemu-iotests/086 + create mode 100644 tests/qemu-iotests/086.out + +diff --git a/tests/qemu-iotests/086 b/tests/qemu-iotests/086 +new file mode 100755 +index 0000000..48fe85b +--- /dev/null ++++ b/tests/qemu-iotests/086 +@@ -0,0 +1,65 @@ ++#!/bin/bash ++# ++# Test qemu-img progress output ++# ++# Copyright (C) 2014 Red Hat, Inc. ++# ++# This program is free software; you can redistribute it and/or modify ++# it under the terms of the GNU General Public License as published by ++# the Free Software Foundation; either version 2 of the License, or ++# (at your option) any later version. ++# ++# This program is distributed in the hope that it will be useful, ++# but WITHOUT ANY WARRANTY; without even the implied warranty of ++# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++# GNU General Public License for more details. ++# ++# You should have received a copy of the GNU General Public License ++# along with this program. If not, see . ++# ++ ++# creator ++owner=kwolf@redhat.com ++ ++seq=`basename $0` ++echo "QA output created by $seq" ++ ++here=`pwd` ++tmp=/tmp/$$ ++status=1 # failure is the default! ++ ++_cleanup() ++{ ++ _cleanup_test_img ++} ++trap "_cleanup; exit \$status" 0 1 2 3 15 ++ ++# get standard environment, filters and checks ++. ./common.rc ++. ./common.filter ++ ++_supported_fmt qcow2 ++_supported_proto file ++_supported_os Linux ++ ++function run_qemu_img() ++{ ++ echo ++ echo Testing: "$@" | _filter_testdir ++} ++ ++size=128M ++ ++_make_test_img $size ++$QEMU_IO -c 'write 0 1M' $TEST_IMG | _filter_qemu_io ++$QEMU_IO -c 'write 2M 1M' $TEST_IMG | _filter_qemu_io ++$QEMU_IO -c 'write 4M 1M' $TEST_IMG | _filter_qemu_io ++$QEMU_IO -c 'write 32M 1M' $TEST_IMG | _filter_qemu_io ++ ++$QEMU_IMG convert -p -O $IMGFMT -f $IMGFMT "$TEST_IMG" "$TEST_IMG".base 2>&1 |\ ++ _filter_testdir | sed -e 's/\r/\n/g' ++ ++# success, all done ++echo "*** done" ++rm -f $seq.full ++status=0 +diff --git a/tests/qemu-iotests/086.out b/tests/qemu-iotests/086.out +new file mode 100644 +index 0000000..fcf4425 +--- /dev/null ++++ b/tests/qemu-iotests/086.out +@@ -0,0 +1,18 @@ ++QA output created by 086 ++Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=134217728 ++wrote 1048576/1048576 bytes at offset 0 ++1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) ++wrote 1048576/1048576 bytes at offset 2097152 ++1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) ++wrote 1048576/1048576 bytes at offset 4194304 ++1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) ++wrote 1048576/1048576 bytes at offset 33554432 ++1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) ++ (0.00/100%) ++ (1.56/100%) ++ (3.12/100%) ++ (4.69/100%) ++ (26.56/100%) ++ (100.00/100%) ++ ++*** done +diff --git a/tests/qemu-iotests/group b/tests/qemu-iotests/group +index ee95d6e..51e7f58 100644 +--- a/tests/qemu-iotests/group ++++ b/tests/qemu-iotests/group +@@ -74,3 +74,4 @@ + 077 rw auto + 079 rw auto + 082 rw auto quick ++086 rw auto quick +-- +1.7.1 + diff --git a/SOURCES/kvm-qemu-iotests-Test-pwritev-RMW-logic.patch b/SOURCES/kvm-qemu-iotests-Test-pwritev-RMW-logic.patch new file mode 100644 index 0000000..03216db --- /dev/null +++ b/SOURCES/kvm-qemu-iotests-Test-pwritev-RMW-logic.patch @@ -0,0 +1,636 @@ +From df86b255911f2a682ffd411f4924442d6b007624 Mon Sep 17 00:00:00 2001 +From: Kevin Wolf +Date: Tue, 14 Jan 2014 15:37:03 +0100 +Subject: [PATCH 35/37] qemu-iotests: Test pwritev RMW logic + +Message-id: <1392117622-28812-35-git-send-email-kwolf@redhat.com> +Patchwork-id: 57199 +O-Subject: [RHEL-7.0 qemu-kvm PATCH v2 35/37] qemu-iotests: Test pwritev RMW logic +Bugzilla: 748906 +RH-Acked-by: Laszlo Ersek +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Max Reitz + +Signed-off-by: Kevin Wolf +Reviewed-by: Max Reitz +(cherry picked from commit 9e1cb96d9a5e434f389a4d7b7ff4dcdd71e8ec0f) + +Conflicts: + block.c + block/blkdebug.c + include/block/block.h + tests/qemu-iotests/group + +Conflicts because RHEL 7 doesn't have all blkdebug events that upstream +has. (Plus group from qemu-iotests.) + +Signed-off-by: Kevin Wolf +--- + block.c | 7 ++ + block/blkdebug.c | 8 ++ + include/block/block.h | 8 ++ + tests/qemu-iotests/077 | 278 +++++++++++++++++++++++++++++++++++++++++++++ + tests/qemu-iotests/077.out | 202 ++++++++++++++++++++++++++++++++ + tests/qemu-iotests/group | 1 + + 6 files changed, 504 insertions(+) + create mode 100755 tests/qemu-iotests/077 + create mode 100644 tests/qemu-iotests/077.out +--- + block.c | 7 + + block/blkdebug.c | 8 ++ + include/block/block.h | 8 ++ + tests/qemu-iotests/077 | 278 ++++++++++++++++++++++++++++++++++++++++++++ + tests/qemu-iotests/077.out | 202 ++++++++++++++++++++++++++++++++ + tests/qemu-iotests/group | 1 + + 6 files changed, 504 insertions(+), 0 deletions(-) + create mode 100755 tests/qemu-iotests/077 + create mode 100644 tests/qemu-iotests/077.out + +diff --git a/block.c b/block.c +index d18c2df..d063924 100644 +--- a/block.c ++++ b/block.c +@@ -2982,10 +2982,13 @@ static int coroutine_fn bdrv_aligned_pwritev(BlockDriverState *bs, + assert(!waited || !req->serialising); + + if (flags & BDRV_REQ_ZERO_WRITE) { ++ BLKDBG_EVENT(bs, BLKDBG_PWRITEV_ZERO); + ret = bdrv_co_do_write_zeroes(bs, sector_num, nb_sectors, flags); + } else { ++ BLKDBG_EVENT(bs, BLKDBG_PWRITEV); + ret = drv->bdrv_co_writev(bs, sector_num, nb_sectors, qiov); + } ++ BLKDBG_EVENT(bs, BLKDBG_PWRITEV_DONE); + + if (ret == 0 && !bs->enable_write_cache) { + ret = bdrv_co_flush(bs); +@@ -3058,11 +3061,13 @@ static int coroutine_fn bdrv_co_do_pwritev(BlockDriverState *bs, + }; + qemu_iovec_init_external(&head_qiov, &head_iov, 1); + ++ BLKDBG_EVENT(bs, BLKDBG_PWRITEV_RMW_HEAD); + ret = bdrv_aligned_preadv(bs, &req, offset & ~(align - 1), align, + align, &head_qiov, 0); + if (ret < 0) { + goto fail; + } ++ BLKDBG_EVENT(bs, BLKDBG_PWRITEV_RMW_AFTER_HEAD); + + qemu_iovec_init(&local_qiov, qiov->niov + 2); + qemu_iovec_add(&local_qiov, head_buf, offset & (align - 1)); +@@ -3090,11 +3095,13 @@ static int coroutine_fn bdrv_co_do_pwritev(BlockDriverState *bs, + }; + qemu_iovec_init_external(&tail_qiov, &tail_iov, 1); + ++ BLKDBG_EVENT(bs, BLKDBG_PWRITEV_RMW_TAIL); + ret = bdrv_aligned_preadv(bs, &req, (offset + bytes) & ~(align - 1), align, + align, &tail_qiov, 0); + if (ret < 0) { + goto fail; + } ++ BLKDBG_EVENT(bs, BLKDBG_PWRITEV_RMW_AFTER_TAIL); + + if (!use_local_qiov) { + qemu_iovec_init(&local_qiov, qiov->niov + 1); +diff --git a/block/blkdebug.c b/block/blkdebug.c +index 1e772a5..c61ce52 100644 +--- a/block/blkdebug.c ++++ b/block/blkdebug.c +@@ -183,6 +183,14 @@ static const char *event_names[BLKDBG_EVENT_MAX] = { + [BLKDBG_CLUSTER_ALLOC] = "cluster_alloc", + [BLKDBG_CLUSTER_ALLOC_BYTES] = "cluster_alloc_bytes", + [BLKDBG_CLUSTER_FREE] = "cluster_free", ++ ++ [BLKDBG_PWRITEV_RMW_HEAD] = "pwritev_rmw.head", ++ [BLKDBG_PWRITEV_RMW_AFTER_HEAD] = "pwritev_rmw.after_head", ++ [BLKDBG_PWRITEV_RMW_TAIL] = "pwritev_rmw.tail", ++ [BLKDBG_PWRITEV_RMW_AFTER_TAIL] = "pwritev_rmw.after_tail", ++ [BLKDBG_PWRITEV] = "pwritev", ++ [BLKDBG_PWRITEV_ZERO] = "pwritev_zero", ++ [BLKDBG_PWRITEV_DONE] = "pwritev_done", + }; + + static int get_event_by_name(const char *name, BlkDebugEvent *event) +diff --git a/include/block/block.h b/include/block/block.h +index feb1926..13ef173 100644 +--- a/include/block/block.h ++++ b/include/block/block.h +@@ -498,6 +498,14 @@ typedef enum { + BLKDBG_CLUSTER_ALLOC_BYTES, + BLKDBG_CLUSTER_FREE, + ++ BLKDBG_PWRITEV_RMW_HEAD, ++ BLKDBG_PWRITEV_RMW_AFTER_HEAD, ++ BLKDBG_PWRITEV_RMW_TAIL, ++ BLKDBG_PWRITEV_RMW_AFTER_TAIL, ++ BLKDBG_PWRITEV, ++ BLKDBG_PWRITEV_ZERO, ++ BLKDBG_PWRITEV_DONE, ++ + BLKDBG_EVENT_MAX, + } BlkDebugEvent; + +diff --git a/tests/qemu-iotests/077 b/tests/qemu-iotests/077 +new file mode 100755 +index 0000000..bbf7b51 +--- /dev/null ++++ b/tests/qemu-iotests/077 +@@ -0,0 +1,278 @@ ++#!/bin/bash ++# ++# Test concurrent pread/pwrite ++# ++# Copyright (C) 2014 Red Hat, Inc. ++# ++# This program is free software; you can redistribute it and/or modify ++# it under the terms of the GNU General Public License as published by ++# the Free Software Foundation; either version 2 of the License, or ++# (at your option) any later version. ++# ++# This program is distributed in the hope that it will be useful, ++# but WITHOUT ANY WARRANTY; without even the implied warranty of ++# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++# GNU General Public License for more details. ++# ++# You should have received a copy of the GNU General Public License ++# along with this program. If not, see . ++# ++ ++# creator ++owner=kwolf@redhat.com ++ ++seq=`basename $0` ++echo "QA output created by $seq" ++ ++here=`pwd` ++tmp=/tmp/$$ ++status=1 # failure is the default! ++ ++_cleanup() ++{ ++ _cleanup_test_img ++} ++trap "_cleanup; exit \$status" 0 1 2 3 15 ++ ++# get standard environment, filters and checks ++. ./common.rc ++. ./common.filter ++ ++_supported_fmt generic ++_supported_proto generic ++_supported_os Linux ++ ++CLUSTER_SIZE=4k ++size=128M ++ ++_make_test_img $size ++ ++echo ++echo "== Some concurrent requests involving RMW ==" ++ ++function test_io() ++{ ++echo "open -o file.align=4k blkdebug::$TEST_IMG" ++# A simple RMW request ++cat < +Date: Fri, 17 Jan 2014 03:08:02 +0100 +Subject: [PATCH 19/34] qemu-iotests: Update test cases for commit active + +RH-Author: Fam Zheng +Message-id: <1389928083-8921-18-git-send-email-famz@redhat.com> +Patchwork-id: 56779 +O-Subject: [RHEL-7 qemu-kvm PATCH 17/18] qemu-iotests: Update test cases for commit active +Bugzilla: 1041301 +RH-Acked-by: Jeffrey Cody +RH-Acked-by: Kevin Wolf +RH-Acked-by: Stefan Hajnoczi + +Factor out commit test common logic into super class, and update test +of committing the active image. + +Signed-off-by: Fam Zheng +Signed-off-by: Stefan Hajnoczi +(cherry picked from commit 4de43470f2f35762b4b3e6a59b4aed55e239024a) +Signed-off-by: Fam Zheng + +Conflicts: + tests/qemu-iotests/040 + +Conflict because "b59b3d5 qemu-iotests: Make test case 030, 040 and 055 +deterministic" and "2499a09 qemu-iotests: make create_image() common" +are not backported yet. + +Signed-off-by: Fam Zheng +--- + tests/qemu-iotests/040 | 74 ++++++++++++++++++++++---------------------------- + 1 file changed, 32 insertions(+), 42 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + tests/qemu-iotests/040 | 74 ++++++++++++++++++++--------------------------- + 1 files changed, 32 insertions(+), 42 deletions(-) + +diff --git a/tests/qemu-iotests/040 b/tests/qemu-iotests/040 +index aad535a..f210fb7 100755 +--- a/tests/qemu-iotests/040 ++++ b/tests/qemu-iotests/040 +@@ -63,6 +63,28 @@ class ImageCommitTestCase(iotests.QMPTestCase): + i = i + 512 + file.close() + ++ def run_commit_test(self, top, base): ++ self.assert_no_active_commit() ++ result = self.vm.qmp('block-commit', device='drive0', top=top, base=base) ++ self.assert_qmp(result, 'return', {}) ++ ++ completed = False ++ while not completed: ++ for event in self.vm.get_qmp_events(wait=True): ++ if event['event'] == 'BLOCK_JOB_COMPLETED': ++ self.assert_qmp(event, 'data/type', 'commit') ++ self.assert_qmp(event, 'data/device', 'drive0') ++ self.assert_qmp(event, 'data/offset', self.image_len) ++ self.assert_qmp(event, 'data/len', self.image_len) ++ completed = True ++ elif event['event'] == 'BLOCK_JOB_READY': ++ self.assert_qmp(event, 'data/type', 'commit') ++ self.assert_qmp(event, 'data/device', 'drive0') ++ self.assert_qmp(event, 'data/len', self.image_len) ++ self.vm.qmp('block-job-complete', device='drive0') ++ ++ self.assert_no_active_commit() ++ self.vm.shutdown() + + class TestSingleDrive(ImageCommitTestCase): + image_len = 1 * 1024 * 1024 +@@ -84,23 +106,7 @@ class TestSingleDrive(ImageCommitTestCase): + os.remove(backing_img) + + def test_commit(self): +- self.assert_no_active_commit() +- result = self.vm.qmp('block-commit', device='drive0', top='%s' % mid_img) +- self.assert_qmp(result, 'return', {}) +- +- completed = False +- while not completed: +- for event in self.vm.get_qmp_events(wait=True): +- if event['event'] == 'BLOCK_JOB_COMPLETED': +- self.assert_qmp(event, 'data/type', 'commit') +- self.assert_qmp(event, 'data/device', 'drive0') +- self.assert_qmp(event, 'data/offset', self.image_len) +- self.assert_qmp(event, 'data/len', self.image_len) +- completed = True +- +- self.assert_no_active_commit() +- self.vm.shutdown() +- ++ self.run_commit_test(mid_img, backing_img) + self.assertEqual(-1, qemu_io('-c', 'read -P 0xab 0 524288', backing_img).find("verification failed")) + self.assertEqual(-1, qemu_io('-c', 'read -P 0xef 524288 524288', backing_img).find("verification failed")) + +@@ -127,10 +133,9 @@ class TestSingleDrive(ImageCommitTestCase): + self.assert_qmp(result, 'error/desc', 'Base \'badfile\' not found') + + def test_top_is_active(self): +- self.assert_no_active_commit() +- result = self.vm.qmp('block-commit', device='drive0', top='%s' % test_img, base='%s' % backing_img) +- self.assert_qmp(result, 'error/class', 'GenericError') +- self.assert_qmp(result, 'error/desc', 'Top image as the active layer is currently unsupported') ++ self.run_commit_test(test_img, backing_img) ++ self.assertEqual(-1, qemu_io('-c', 'read -P 0xab 0 524288', backing_img).find("verification failed")) ++ self.assertEqual(-1, qemu_io('-c', 'read -P 0xef 524288 524288', backing_img).find("verification failed")) + + def test_top_and_base_reversed(self): + self.assert_no_active_commit() +@@ -191,23 +196,7 @@ class TestRelativePaths(ImageCommitTestCase): + raise + + def test_commit(self): +- self.assert_no_active_commit() +- result = self.vm.qmp('block-commit', device='drive0', top='%s' % self.mid_img) +- self.assert_qmp(result, 'return', {}) +- +- completed = False +- while not completed: +- for event in self.vm.get_qmp_events(wait=True): +- if event['event'] == 'BLOCK_JOB_COMPLETED': +- self.assert_qmp(event, 'data/type', 'commit') +- self.assert_qmp(event, 'data/device', 'drive0') +- self.assert_qmp(event, 'data/offset', self.image_len) +- self.assert_qmp(event, 'data/len', self.image_len) +- completed = True +- +- self.assert_no_active_commit() +- self.vm.shutdown() +- ++ self.run_commit_test(self.mid_img, self.backing_img) + self.assertEqual(-1, qemu_io('-c', 'read -P 0xab 0 524288', self.backing_img_abs).find("verification failed")) + self.assertEqual(-1, qemu_io('-c', 'read -P 0xef 524288 524288', self.backing_img_abs).find("verification failed")) + +@@ -234,10 +223,9 @@ class TestRelativePaths(ImageCommitTestCase): + self.assert_qmp(result, 'error/desc', 'Base \'badfile\' not found') + + def test_top_is_active(self): +- self.assert_no_active_commit() +- result = self.vm.qmp('block-commit', device='drive0', top='%s' % self.test_img, base='%s' % self.backing_img) +- self.assert_qmp(result, 'error/class', 'GenericError') +- self.assert_qmp(result, 'error/desc', 'Top image as the active layer is currently unsupported') ++ self.run_commit_test(self.test_img, self.backing_img) ++ self.assertEqual(-1, qemu_io('-c', 'read -P 0xab 0 524288', self.backing_img_abs).find("verification failed")) ++ self.assertEqual(-1, qemu_io('-c', 'read -P 0xef 524288 524288', self.backing_img_abs).find("verification failed")) + + def test_top_and_base_reversed(self): + self.assert_no_active_commit() +@@ -253,6 +241,8 @@ class TestSetSpeed(ImageCommitTestCase): + qemu_img('create', backing_img, str(TestSetSpeed.image_len)) + qemu_img('create', '-f', iotests.imgfmt, '-o', 'backing_file=%s' % backing_img, mid_img) + qemu_img('create', '-f', iotests.imgfmt, '-o', 'backing_file=%s' % mid_img, test_img) ++ qemu_io('-c', 'write -P 0x1 0 512', test_img) ++ qemu_io('-c', 'write -P 0xef 524288 524288', mid_img) + self.vm = iotests.VM().add_drive(test_img) + self.vm.launch() + +-- +1.7.1 + diff --git a/SOURCES/kvm-qemu-iotests-add-.-check-cloop-support.patch b/SOURCES/kvm-qemu-iotests-add-.-check-cloop-support.patch new file mode 100644 index 0000000..15a9cef --- /dev/null +++ b/SOURCES/kvm-qemu-iotests-add-.-check-cloop-support.patch @@ -0,0 +1,70 @@ +From 5be29b09f5d571260cb48bc4a24f32265662fed1 Mon Sep 17 00:00:00 2001 +From: Stefan Hajnoczi +Date: Tue, 25 Mar 2014 14:23:09 +0100 +Subject: [PATCH 02/49] qemu-iotests: add ./check -cloop support + +RH-Author: Kevin Wolf +Message-id: <1395753835-7591-3-git-send-email-kwolf@redhat.com> +Patchwork-id: n/a +O-Subject: [virt-devel] [EMBARGOED RHEL-7.0 qemu-kvm PATCH 02/48] qemu-iotests: add ./check -cloop support +Bugzilla: 1066691 +RH-Acked-by: Jeff Cody +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Paolo Bonzini + +From: Stefan Hajnoczi + +Bugzilla: https://bugzilla.redhat.com/show_bug.cgi?id=1066691 +Upstream status: Series embargoed + +Add the cloop block driver to qemu-iotests. + +Signed-off-by: Stefan Hajnoczi +Signed-off-by: Kevin Wolf +--- + tests/qemu-iotests/common | 7 +++++++ + tests/qemu-iotests/common.rc | 3 +++ + 2 files changed, 10 insertions(+), 0 deletions(-) + +diff --git a/tests/qemu-iotests/common b/tests/qemu-iotests/common +index 8cde7f1..b5043fc 100644 +--- a/tests/qemu-iotests/common ++++ b/tests/qemu-iotests/common +@@ -129,6 +129,7 @@ common options + check options + -raw test raw (default) + -cow test cow ++ -cloop test cloop + -qcow test qcow + -qcow2 test qcow2 + -qed test qed +@@ -167,6 +168,12 @@ testlist options + xpand=false + ;; + ++ -cloop) ++ IMGFMT=cloop ++ IMGFMT_GENERIC=false ++ xpand=false ++ ;; ++ + -qcow) + IMGFMT=qcow + xpand=false +diff --git a/tests/qemu-iotests/common.rc b/tests/qemu-iotests/common.rc +index 7f62457..65c5bc1 100644 +--- a/tests/qemu-iotests/common.rc ++++ b/tests/qemu-iotests/common.rc +@@ -350,6 +350,9 @@ _fail() + # + _supported_fmt() + { ++ # "generic" is suitable for most image formats. For some formats it doesn't ++ # work, however (most notably read-only formats), so they can opt out by ++ # setting IMGFMT_GENERIC to false. + for f; do + if [ "$f" = "$IMGFMT" -o "$f" = "generic" -a "$IMGFMT_GENERIC" = "true" ]; then + return +-- +1.7.1 + diff --git a/SOURCES/kvm-qemu-iotests-add-cloop-input-validation-tests.patch b/SOURCES/kvm-qemu-iotests-add-cloop-input-validation-tests.patch new file mode 100644 index 0000000..2ede23a --- /dev/null +++ b/SOURCES/kvm-qemu-iotests-add-cloop-input-validation-tests.patch @@ -0,0 +1,125 @@ +From 1b87276ff64d27cf2ab9096f7e18ad0d71ae79ac Mon Sep 17 00:00:00 2001 +From: Stefan Hajnoczi +Date: Tue, 25 Mar 2014 14:23:10 +0100 +Subject: [PATCH 03/49] qemu-iotests: add cloop input validation tests + +RH-Author: Kevin Wolf +Message-id: <1395753835-7591-4-git-send-email-kwolf@redhat.com> +Patchwork-id: n/a +O-Subject: [virt-devel] [EMBARGOED RHEL-7.0 qemu-kvm PATCH 03/48] qemu-iotests: add cloop input validation tests +Bugzilla: 1066691 +RH-Acked-by: Jeff Cody +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Paolo Bonzini + +From: Stefan Hajnoczi + +Bugzilla: https://bugzilla.redhat.com/show_bug.cgi?id=1066691 +Upstream status: Series embargoed + +Add a cloop format-specific test case. Later patches add tests for +input validation to the script. + +Signed-off-by: Stefan Hajnoczi +Signed-off-by: Kevin Wolf + +Conflicts: +tests/qemu-iotests/group + +Signed-off-by: Kevin Wolf +--- + tests/qemu-iotests/075 | 53 ++++++++++++++++++++ + tests/qemu-iotests/075.out | 6 ++ + tests/qemu-iotests/group | 1 + + .../sample_images/simple-pattern.cloop.bz2 | Bin 0 -> 488 bytes + 4 files changed, 60 insertions(+), 0 deletions(-) + create mode 100755 tests/qemu-iotests/075 + create mode 100644 tests/qemu-iotests/075.out + create mode 100644 tests/qemu-iotests/sample_images/simple-pattern.cloop.bz2 + +diff --git a/tests/qemu-iotests/075 b/tests/qemu-iotests/075 +new file mode 100755 +index 0000000..88ae8bb +--- /dev/null ++++ b/tests/qemu-iotests/075 +@@ -0,0 +1,53 @@ ++#!/bin/bash ++# ++# cloop format input validation tests ++# ++# Copyright (C) 2013 Red Hat, Inc. ++# ++# This program is free software; you can redistribute it and/or modify ++# it under the terms of the GNU General Public License as published by ++# the Free Software Foundation; either version 2 of the License, or ++# (at your option) any later version. ++# ++# This program is distributed in the hope that it will be useful, ++# but WITHOUT ANY WARRANTY; without even the implied warranty of ++# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++# GNU General Public License for more details. ++# ++# You should have received a copy of the GNU General Public License ++# along with this program. If not, see . ++# ++ ++# creator ++owner=stefanha@redhat.com ++ ++seq=`basename $0` ++echo "QA output created by $seq" ++ ++here=`pwd` ++tmp=/tmp/$$ ++status=1 # failure is the default! ++ ++_cleanup() ++{ ++ _cleanup_test_img ++} ++trap "_cleanup; exit \$status" 0 1 2 3 15 ++ ++# get standard environment, filters and checks ++. ./common.rc ++. ./common.filter ++ ++_supported_fmt cloop ++_supported_proto generic ++_supported_os Linux ++ ++echo ++echo "== check that the first sector can be read ==" ++_use_sample_img simple-pattern.cloop.bz2 ++$QEMU_IO -c "read 0 512" $TEST_IMG 2>&1 | _filter_qemu_io | _filter_testdir ++ ++# success, all done ++echo "*** done" ++rm -f $seq.full ++status=0 +diff --git a/tests/qemu-iotests/075.out b/tests/qemu-iotests/075.out +new file mode 100644 +index 0000000..26661fa +--- /dev/null ++++ b/tests/qemu-iotests/075.out +@@ -0,0 +1,6 @@ ++QA output created by 075 ++ ++== check that the first sector can be read == ++read 512/512 bytes at offset 0 ++512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) ++*** done +diff --git a/tests/qemu-iotests/group b/tests/qemu-iotests/group +index 51e7f58..427818c 100644 +--- a/tests/qemu-iotests/group ++++ b/tests/qemu-iotests/group +@@ -71,6 +71,7 @@ + 067 rw auto + 068 rw auto + 070 rw auto ++075 rw auto + 077 rw auto + 079 rw auto + 082 rw auto quick +-- +1.7.1 + diff --git a/SOURCES/kvm-qemu-iotests-add-test-for-qcow2-preallocation-with-d.patch b/SOURCES/kvm-qemu-iotests-add-test-for-qcow2-preallocation-with-d.patch new file mode 100644 index 0000000..c1db5e4 --- /dev/null +++ b/SOURCES/kvm-qemu-iotests-add-test-for-qcow2-preallocation-with-d.patch @@ -0,0 +1,161 @@ +From a3a428e70ae71ec09d66cd405bf6a0ef7c42feb4 Mon Sep 17 00:00:00 2001 +From: Max Reitz +Date: Sat, 15 Feb 2014 16:03:50 +0100 +Subject: [PATCH 5/5] qemu-iotests: add test for qcow2 preallocation with different cluster sizes + +RH-Author: Max Reitz +Message-id: <1392480230-24011-5-git-send-email-mreitz@redhat.com> +Patchwork-id: 57295 +O-Subject: [RHEL-7.0 qemu-kvm PATCH 4/4] qemu-iotests: add test for qcow2 preallocation with different cluster sizes +Bugzilla: 1055848 +RH-Acked-by: Kevin Wolf +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Fam Zheng + +From: Hu Tao + +BZ: 1049176 +BZ: 1055848 + +Reviewed-by: Max Reitz +Signed-off-by: Hu Tao +Signed-off-by: Kevin Wolf +(cherry picked from commit 693a50ade339e3ef9b042fd73a3b81405101ba3d) + +Signed-off-by: Max Reitz +--- + tests/qemu-iotests/079 | 63 ++++++++++++++++++++++++++++++++++++++++++++++ + tests/qemu-iotests/079.out | 32 +++++++++++++++++++++++ + tests/qemu-iotests/group | 1 + + 3 files changed, 96 insertions(+) + create mode 100755 tests/qemu-iotests/079 + create mode 100644 tests/qemu-iotests/079.out + +Signed-off-by: Miroslav Rezanina +--- + tests/qemu-iotests/079 | 63 ++++++++++++++++++++++++++++++++++++++++++++ + tests/qemu-iotests/079.out | 32 ++++++++++++++++++++++ + tests/qemu-iotests/group | 1 + + 3 files changed, 96 insertions(+), 0 deletions(-) + create mode 100755 tests/qemu-iotests/079 + create mode 100644 tests/qemu-iotests/079.out + +diff --git a/tests/qemu-iotests/079 b/tests/qemu-iotests/079 +new file mode 100755 +index 0000000..2142bbb +--- /dev/null ++++ b/tests/qemu-iotests/079 +@@ -0,0 +1,63 @@ ++#!/bin/bash ++# ++# Test qcow2 preallocation with different cluster_sizes ++# ++# Copyright (C) 2014 Fujitsu. ++# ++# This program is free software; you can redistribute it and/or modify ++# it under the terms of the GNU General Public License as published by ++# the Free Software Foundation; either version 2 of the License, or ++# (at your option) any later version. ++# ++# This program is distributed in the hope that it will be useful, ++# but WITHOUT ANY WARRANTY; without even the implied warranty of ++# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++# GNU General Public License for more details. ++# ++# You should have received a copy of the GNU General Public License ++# along with this program. If not, see . ++# ++ ++# creator ++owner=hutao@cn.fujitsu.com ++ ++seq=`basename $0` ++echo "QA output created by $seq" ++ ++here=`pwd` ++tmp=/tmp/$$ ++status=1 # failure is the default! ++ ++_cleanup() ++{ ++ _cleanup_test_img ++} ++trap "_cleanup; exit \$status" 0 1 2 3 15 ++ ++# get standard environment, filters and checks ++. ./common.rc ++. ./common.filter ++ ++_supported_fmt qcow2 ++_supported_proto file ++_supported_os Linux ++ ++function test_qemu_img() ++{ ++ echo qemu-img "$@" | _filter_testdir ++ $QEMU_IMG "$@" 2>&1 | _filter_testdir ++ echo ++} ++ ++echo "=== Check option preallocation and cluster_size ===" ++echo ++cluster_sizes="16384 32768 65536 131072 262144 524288 1048576 2097152 4194304" ++ ++for s in $cluster_sizes; do ++ test_qemu_img create -f $IMGFMT -o preallocation=metadata,cluster_size=$s "$TEST_IMG" 4G ++done ++ ++# success, all done ++echo "*** done" ++rm -f $seq.full ++status=0 +diff --git a/tests/qemu-iotests/079.out b/tests/qemu-iotests/079.out +new file mode 100644 +index 0000000..ef4b8c9 +--- /dev/null ++++ b/tests/qemu-iotests/079.out +@@ -0,0 +1,32 @@ ++QA output created by 079 ++=== Check option preallocation and cluster_size === ++ ++qemu-img create -f qcow2 -o preallocation=metadata,cluster_size=16384 TEST_DIR/t.qcow2 4G ++Formatting 'TEST_DIR/t.qcow2', fmt=qcow2 size=4294967296 encryption=off cluster_size=16384 preallocation='metadata' lazy_refcounts=off ++ ++qemu-img create -f qcow2 -o preallocation=metadata,cluster_size=32768 TEST_DIR/t.qcow2 4G ++Formatting 'TEST_DIR/t.qcow2', fmt=qcow2 size=4294967296 encryption=off cluster_size=32768 preallocation='metadata' lazy_refcounts=off ++ ++qemu-img create -f qcow2 -o preallocation=metadata,cluster_size=65536 TEST_DIR/t.qcow2 4G ++Formatting 'TEST_DIR/t.qcow2', fmt=qcow2 size=4294967296 encryption=off cluster_size=65536 preallocation='metadata' lazy_refcounts=off ++ ++qemu-img create -f qcow2 -o preallocation=metadata,cluster_size=131072 TEST_DIR/t.qcow2 4G ++Formatting 'TEST_DIR/t.qcow2', fmt=qcow2 size=4294967296 encryption=off cluster_size=131072 preallocation='metadata' lazy_refcounts=off ++ ++qemu-img create -f qcow2 -o preallocation=metadata,cluster_size=262144 TEST_DIR/t.qcow2 4G ++Formatting 'TEST_DIR/t.qcow2', fmt=qcow2 size=4294967296 encryption=off cluster_size=262144 preallocation='metadata' lazy_refcounts=off ++ ++qemu-img create -f qcow2 -o preallocation=metadata,cluster_size=524288 TEST_DIR/t.qcow2 4G ++Formatting 'TEST_DIR/t.qcow2', fmt=qcow2 size=4294967296 encryption=off cluster_size=524288 preallocation='metadata' lazy_refcounts=off ++ ++qemu-img create -f qcow2 -o preallocation=metadata,cluster_size=1048576 TEST_DIR/t.qcow2 4G ++Formatting 'TEST_DIR/t.qcow2', fmt=qcow2 size=4294967296 encryption=off cluster_size=1048576 preallocation='metadata' lazy_refcounts=off ++ ++qemu-img create -f qcow2 -o preallocation=metadata,cluster_size=2097152 TEST_DIR/t.qcow2 4G ++Formatting 'TEST_DIR/t.qcow2', fmt=qcow2 size=4294967296 encryption=off cluster_size=2097152 preallocation='metadata' lazy_refcounts=off ++ ++qemu-img create -f qcow2 -o preallocation=metadata,cluster_size=4194304 TEST_DIR/t.qcow2 4G ++qemu-img: TEST_DIR/t.qcow2: Cluster size must be a power of two between 512 and 2048k ++Formatting 'TEST_DIR/t.qcow2', fmt=qcow2 size=4294967296 encryption=off cluster_size=4194304 preallocation='metadata' lazy_refcounts=off ++ ++*** done +diff --git a/tests/qemu-iotests/group b/tests/qemu-iotests/group +index dd70acb..fce6ca8 100644 +--- a/tests/qemu-iotests/group ++++ b/tests/qemu-iotests/group +@@ -72,3 +72,4 @@ + 068 rw auto + 070 rw auto + 077 rw auto ++079 rw auto +-- +1.7.1 + diff --git a/SOURCES/kvm-qemu-iotests-make-assert_no_active_block_jobs-common.patch b/SOURCES/kvm-qemu-iotests-make-assert_no_active_block_jobs-common.patch new file mode 100644 index 0000000..ab11f47 --- /dev/null +++ b/SOURCES/kvm-qemu-iotests-make-assert_no_active_block_jobs-common.patch @@ -0,0 +1,536 @@ +From dc76b8c7582d037b1b150f9d809deb05d1a31b05 Mon Sep 17 00:00:00 2001 +From: Max Reitz +Date: Sun, 19 Jan 2014 18:07:56 +0100 +Subject: [PATCH 22/34] qemu-iotests: make assert_no_active_block_jobs() common + +RH-Author: Max Reitz +Message-id: <1390154881-17140-3-git-send-email-mreitz@redhat.com> +Patchwork-id: 56815 +O-Subject: [RHEL-7.0 qemu-kvm PATCH v2 2/7] qemu-iotests: make assert_no_active_block_jobs() common +Bugzilla: 921890 +RH-Acked-by: Fam Zheng +RH-Acked-by: Kevin Wolf +RH-Acked-by: Jeffrey Cody + +From: Stefan Hajnoczi + +BZ: 921890 + +Tests 030 and 041 both use query-block-jobs to check whether any block +jobs are active. Make this code common so that 'drive-backup' and other +new feature tests will be able to reuse it. + +Suggested-by: Kevin Wolf +Signed-off-by: Stefan Hajnoczi +Signed-off-by: Kevin Wolf +(cherry picked from commit ecc1c88efddb376687084c3387c38b3a458c5892) + +Signed-off-by: Max Reitz +--- + tests/qemu-iotests/030 | 54 ++++++++++++++++++-------------------- + tests/qemu-iotests/041 | 60 ++++++++++++++++++++----------------------- + tests/qemu-iotests/iotests.py | 4 +++ + 3 files changed, 57 insertions(+), 61 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + tests/qemu-iotests/030 | 54 +++++++++++++++++------------------- + tests/qemu-iotests/041 | 60 +++++++++++++++++++---------------------- + tests/qemu-iotests/iotests.py | 4 +++ + 3 files changed, 57 insertions(+), 61 deletions(-) + +diff --git a/tests/qemu-iotests/030 b/tests/qemu-iotests/030 +index 3d128b3..9cf256b 100755 +--- a/tests/qemu-iotests/030 ++++ b/tests/qemu-iotests/030 +@@ -31,10 +31,6 @@ test_img = os.path.join(iotests.test_dir, 'test.img') + class ImageStreamingTestCase(iotests.QMPTestCase): + '''Abstract base class for image streaming test cases''' + +- def assert_no_active_streams(self): +- result = self.vm.qmp('query-block-jobs') +- self.assert_qmp(result, 'return', []) +- + def cancel_and_wait(self, drive='drive0'): + '''Cancel a block job and wait for it to finish''' + result = self.vm.qmp('block-job-cancel', device=drive) +@@ -48,7 +44,7 @@ class ImageStreamingTestCase(iotests.QMPTestCase): + self.assert_qmp(event, 'data/device', drive) + cancelled = True + +- self.assert_no_active_streams() ++ self.assert_no_active_block_jobs() + + def create_image(self, name, size): + file = open(name, 'w') +@@ -77,7 +73,7 @@ class TestSingleDrive(ImageStreamingTestCase): + os.remove(backing_img) + + def test_stream(self): +- self.assert_no_active_streams() ++ self.assert_no_active_block_jobs() + + result = self.vm.qmp('block-stream', device='drive0') + self.assert_qmp(result, 'return', {}) +@@ -92,7 +88,7 @@ class TestSingleDrive(ImageStreamingTestCase): + self.assert_qmp(event, 'data/len', self.image_len) + completed = True + +- self.assert_no_active_streams() ++ self.assert_no_active_block_jobs() + self.vm.shutdown() + + self.assertEqual(qemu_io('-c', 'map', backing_img), +@@ -100,7 +96,7 @@ class TestSingleDrive(ImageStreamingTestCase): + 'image file map does not match backing file after streaming') + + def test_stream_pause(self): +- self.assert_no_active_streams() ++ self.assert_no_active_block_jobs() + + result = self.vm.qmp('block-stream', device='drive0') + self.assert_qmp(result, 'return', {}) +@@ -129,7 +125,7 @@ class TestSingleDrive(ImageStreamingTestCase): + self.assert_qmp(event, 'data/len', self.image_len) + completed = True + +- self.assert_no_active_streams() ++ self.assert_no_active_block_jobs() + self.vm.shutdown() + + self.assertEqual(qemu_io('-c', 'map', backing_img), +@@ -137,7 +133,7 @@ class TestSingleDrive(ImageStreamingTestCase): + 'image file map does not match backing file after streaming') + + def test_stream_partial(self): +- self.assert_no_active_streams() ++ self.assert_no_active_block_jobs() + + result = self.vm.qmp('block-stream', device='drive0', base=mid_img) + self.assert_qmp(result, 'return', {}) +@@ -152,7 +148,7 @@ class TestSingleDrive(ImageStreamingTestCase): + self.assert_qmp(event, 'data/len', self.image_len) + completed = True + +- self.assert_no_active_streams() ++ self.assert_no_active_block_jobs() + self.vm.shutdown() + + self.assertEqual(qemu_io('-c', 'map', mid_img), +@@ -177,7 +173,7 @@ class TestSmallerBackingFile(ImageStreamingTestCase): + # If this hangs, then you are missing a fix to complete streaming when the + # end of the backing file is reached. + def test_stream(self): +- self.assert_no_active_streams() ++ self.assert_no_active_block_jobs() + + result = self.vm.qmp('block-stream', device='drive0') + self.assert_qmp(result, 'return', {}) +@@ -192,7 +188,7 @@ class TestSmallerBackingFile(ImageStreamingTestCase): + self.assert_qmp(event, 'data/len', self.image_len) + completed = True + +- self.assert_no_active_streams() ++ self.assert_no_active_block_jobs() + self.vm.shutdown() + + class TestErrors(ImageStreamingTestCase): +@@ -243,7 +239,7 @@ class TestEIO(TestErrors): + os.remove(self.blkdebug_file) + + def test_report(self): +- self.assert_no_active_streams() ++ self.assert_no_active_block_jobs() + + result = self.vm.qmp('block-stream', device='drive0') + self.assert_qmp(result, 'return', {}) +@@ -265,11 +261,11 @@ class TestEIO(TestErrors): + self.assert_qmp(event, 'data/len', self.image_len) + completed = True + +- self.assert_no_active_streams() ++ self.assert_no_active_block_jobs() + self.vm.shutdown() + + def test_ignore(self): +- self.assert_no_active_streams() ++ self.assert_no_active_block_jobs() + + result = self.vm.qmp('block-stream', device='drive0', on_error='ignore') + self.assert_qmp(result, 'return', {}) +@@ -293,11 +289,11 @@ class TestEIO(TestErrors): + self.assert_qmp(event, 'data/len', self.image_len) + completed = True + +- self.assert_no_active_streams() ++ self.assert_no_active_block_jobs() + self.vm.shutdown() + + def test_stop(self): +- self.assert_no_active_streams() ++ self.assert_no_active_block_jobs() + + result = self.vm.qmp('block-stream', device='drive0', on_error='stop') + self.assert_qmp(result, 'return', {}) +@@ -331,11 +327,11 @@ class TestEIO(TestErrors): + self.assert_qmp(event, 'data/len', self.image_len) + completed = True + +- self.assert_no_active_streams() ++ self.assert_no_active_block_jobs() + self.vm.shutdown() + + def test_enospc(self): +- self.assert_no_active_streams() ++ self.assert_no_active_block_jobs() + + result = self.vm.qmp('block-stream', device='drive0', on_error='enospc') + self.assert_qmp(result, 'return', {}) +@@ -357,7 +353,7 @@ class TestEIO(TestErrors): + self.assert_qmp(event, 'data/len', self.image_len) + completed = True + +- self.assert_no_active_streams() ++ self.assert_no_active_block_jobs() + self.vm.shutdown() + + class TestENOSPC(TestErrors): +@@ -379,7 +375,7 @@ class TestENOSPC(TestErrors): + os.remove(self.blkdebug_file) + + def test_enospc(self): +- self.assert_no_active_streams() ++ self.assert_no_active_block_jobs() + + result = self.vm.qmp('block-stream', device='drive0', on_error='enospc') + self.assert_qmp(result, 'return', {}) +@@ -413,7 +409,7 @@ class TestENOSPC(TestErrors): + self.assert_qmp(event, 'data/len', self.image_len) + completed = True + +- self.assert_no_active_streams() ++ self.assert_no_active_block_jobs() + self.vm.shutdown() + + class TestStreamStop(ImageStreamingTestCase): +@@ -433,7 +429,7 @@ class TestStreamStop(ImageStreamingTestCase): + os.remove(backing_img) + + def test_stream_stop(self): +- self.assert_no_active_streams() ++ self.assert_no_active_block_jobs() + + result = self.vm.qmp('block-stream', device='drive0') + self.assert_qmp(result, 'return', {}) +@@ -463,7 +459,7 @@ class TestSetSpeed(ImageStreamingTestCase): + # This is a short performance test which is not run by default. + # Invoke "IMGFMT=qed ./030 TestSetSpeed.perf_test_throughput" + def perf_test_throughput(self): +- self.assert_no_active_streams() ++ self.assert_no_active_block_jobs() + + result = self.vm.qmp('block-stream', device='drive0') + self.assert_qmp(result, 'return', {}) +@@ -481,10 +477,10 @@ class TestSetSpeed(ImageStreamingTestCase): + self.assert_qmp(event, 'data/len', self.image_len) + completed = True + +- self.assert_no_active_streams() ++ self.assert_no_active_block_jobs() + + def test_set_speed(self): +- self.assert_no_active_streams() ++ self.assert_no_active_block_jobs() + + result = self.vm.qmp('block-stream', device='drive0') + self.assert_qmp(result, 'return', {}) +@@ -515,12 +511,12 @@ class TestSetSpeed(ImageStreamingTestCase): + self.cancel_and_wait() + + def test_set_speed_invalid(self): +- self.assert_no_active_streams() ++ self.assert_no_active_block_jobs() + + result = self.vm.qmp('block-stream', device='drive0', speed=-1) + self.assert_qmp(result, 'error/class', 'GenericError') + +- self.assert_no_active_streams() ++ self.assert_no_active_block_jobs() + + result = self.vm.qmp('block-stream', device='drive0') + self.assert_qmp(result, 'return', {}) +diff --git a/tests/qemu-iotests/041 b/tests/qemu-iotests/041 +index 720eeff..ff89427 100755 +--- a/tests/qemu-iotests/041 ++++ b/tests/qemu-iotests/041 +@@ -32,10 +32,6 @@ target_img = os.path.join(iotests.test_dir, 'target.img') + class ImageMirroringTestCase(iotests.QMPTestCase): + '''Abstract base class for image mirroring test cases''' + +- def assert_no_active_mirrors(self): +- result = self.vm.qmp('query-block-jobs') +- self.assert_qmp(result, 'return', []) +- + def cancel_and_wait(self, drive='drive0', wait_ready=True): + '''Cancel a block job and wait for it to finish''' + if wait_ready: +@@ -64,7 +60,7 @@ class ImageMirroringTestCase(iotests.QMPTestCase): + self.assert_qmp(event, 'data/len', self.image_len) + cancelled = True + +- self.assert_no_active_mirrors() ++ self.assert_no_active_block_jobs() + + def complete_and_wait(self, drive='drive0', wait_ready=True): + '''Complete a block job and wait for it to finish''' +@@ -91,7 +87,7 @@ class ImageMirroringTestCase(iotests.QMPTestCase): + self.assert_qmp(event, 'data/len', self.image_len) + completed = True + +- self.assert_no_active_mirrors() ++ self.assert_no_active_block_jobs() + + def create_image(self, name, size): + file = open(name, 'w') +@@ -142,7 +138,7 @@ class TestSingleDrive(ImageMirroringTestCase): + pass + + def test_complete(self): +- self.assert_no_active_mirrors() ++ self.assert_no_active_block_jobs() + + result = self.vm.qmp('drive-mirror', device='drive0', sync='full', + target=target_img) +@@ -156,7 +152,7 @@ class TestSingleDrive(ImageMirroringTestCase): + 'target image does not match source after mirroring') + + def test_cancel(self): +- self.assert_no_active_mirrors() ++ self.assert_no_active_block_jobs() + + result = self.vm.qmp('drive-mirror', device='drive0', sync='full', + target=target_img) +@@ -168,7 +164,7 @@ class TestSingleDrive(ImageMirroringTestCase): + self.vm.shutdown() + + def test_cancel_after_ready(self): +- self.assert_no_active_mirrors() ++ self.assert_no_active_block_jobs() + + result = self.vm.qmp('drive-mirror', device='drive0', sync='full', + target=target_img) +@@ -182,7 +178,7 @@ class TestSingleDrive(ImageMirroringTestCase): + 'target image does not match source after mirroring') + + def test_pause(self): +- self.assert_no_active_mirrors() ++ self.assert_no_active_block_jobs() + + result = self.vm.qmp('drive-mirror', device='drive0', sync='full', + target=target_img) +@@ -208,7 +204,7 @@ class TestSingleDrive(ImageMirroringTestCase): + 'target image does not match source after mirroring') + + def test_small_buffer(self): +- self.assert_no_active_mirrors() ++ self.assert_no_active_block_jobs() + + # A small buffer is rounded up automatically + result = self.vm.qmp('drive-mirror', device='drive0', sync='full', +@@ -223,7 +219,7 @@ class TestSingleDrive(ImageMirroringTestCase): + 'target image does not match source after mirroring') + + def test_small_buffer2(self): +- self.assert_no_active_mirrors() ++ self.assert_no_active_block_jobs() + + qemu_img('create', '-f', iotests.imgfmt, '-o', 'cluster_size=%d,size=%d' + % (TestSingleDrive.image_len, TestSingleDrive.image_len), target_img) +@@ -239,7 +235,7 @@ class TestSingleDrive(ImageMirroringTestCase): + 'target image does not match source after mirroring') + + def test_large_cluster(self): +- self.assert_no_active_mirrors() ++ self.assert_no_active_block_jobs() + + qemu_img('create', '-f', iotests.imgfmt, '-o', 'cluster_size=%d,backing_file=%s' + % (TestSingleDrive.image_len, backing_img), target_img) +@@ -294,7 +290,7 @@ class TestMirrorNoBacking(ImageMirroringTestCase): + os.remove(target_img) + + def test_complete(self): +- self.assert_no_active_mirrors() ++ self.assert_no_active_block_jobs() + + qemu_img('create', '-f', iotests.imgfmt, '-o', 'backing_file=%s' % backing_img, target_img) + result = self.vm.qmp('drive-mirror', device='drive0', sync='full', +@@ -309,7 +305,7 @@ class TestMirrorNoBacking(ImageMirroringTestCase): + 'target image does not match source after mirroring') + + def test_cancel(self): +- self.assert_no_active_mirrors() ++ self.assert_no_active_block_jobs() + + qemu_img('create', '-f', iotests.imgfmt, '-o', 'backing_file=%s' % backing_img, target_img) + result = self.vm.qmp('drive-mirror', device='drive0', sync='full', +@@ -324,7 +320,7 @@ class TestMirrorNoBacking(ImageMirroringTestCase): + 'target image does not match source after mirroring') + + def test_large_cluster(self): +- self.assert_no_active_mirrors() ++ self.assert_no_active_block_jobs() + + # qemu-img create fails if the image is not there + qemu_img('create', '-f', iotests.imgfmt, '-o', 'size=%d' +@@ -365,7 +361,7 @@ class TestMirrorResized(ImageMirroringTestCase): + pass + + def test_complete_top(self): +- self.assert_no_active_mirrors() ++ self.assert_no_active_block_jobs() + + result = self.vm.qmp('drive-mirror', device='drive0', sync='top', + target=target_img) +@@ -379,7 +375,7 @@ class TestMirrorResized(ImageMirroringTestCase): + 'target image does not match source after mirroring') + + def test_complete_full(self): +- self.assert_no_active_mirrors() ++ self.assert_no_active_block_jobs() + + result = self.vm.qmp('drive-mirror', device='drive0', sync='full', + target=target_img) +@@ -443,7 +439,7 @@ new_state = "1" + os.remove(self.blkdebug_file) + + def test_report_read(self): +- self.assert_no_active_mirrors() ++ self.assert_no_active_block_jobs() + + result = self.vm.qmp('drive-mirror', device='drive0', sync='full', + target=target_img) +@@ -467,11 +463,11 @@ new_state = "1" + self.assert_qmp(event, 'data/len', self.image_len) + completed = True + +- self.assert_no_active_mirrors() ++ self.assert_no_active_block_jobs() + self.vm.shutdown() + + def test_ignore_read(self): +- self.assert_no_active_mirrors() ++ self.assert_no_active_block_jobs() + + result = self.vm.qmp('drive-mirror', device='drive0', sync='full', + target=target_img, on_source_error='ignore') +@@ -487,7 +483,7 @@ new_state = "1" + self.vm.shutdown() + + def test_large_cluster(self): +- self.assert_no_active_mirrors() ++ self.assert_no_active_block_jobs() + + # Test COW into the target image. The first half of the + # cluster at MIRROR_GRANULARITY has to be copied from +@@ -513,7 +509,7 @@ new_state = "1" + 'target image does not match source after mirroring') + + def test_stop_read(self): +- self.assert_no_active_mirrors() ++ self.assert_no_active_block_jobs() + + result = self.vm.qmp('drive-mirror', device='drive0', sync='full', + target=target_img, on_source_error='stop') +@@ -544,7 +540,7 @@ new_state = "1" + self.assert_qmp(result, 'return[0]/io-status', 'ok') + + self.complete_and_wait(wait_ready=False) +- self.assert_no_active_mirrors() ++ self.assert_no_active_block_jobs() + self.vm.shutdown() + + class TestWriteErrors(ImageMirroringTestCase): +@@ -594,7 +590,7 @@ new_state = "1" + os.remove(self.blkdebug_file) + + def test_report_write(self): +- self.assert_no_active_mirrors() ++ self.assert_no_active_block_jobs() + + result = self.vm.qmp('drive-mirror', device='drive0', sync='full', + mode='existing', target=self.target_img) +@@ -618,11 +614,11 @@ new_state = "1" + self.assert_qmp(event, 'data/len', self.image_len) + completed = True + +- self.assert_no_active_mirrors() ++ self.assert_no_active_block_jobs() + self.vm.shutdown() + + def test_ignore_write(self): +- self.assert_no_active_mirrors() ++ self.assert_no_active_block_jobs() + + result = self.vm.qmp('drive-mirror', device='drive0', sync='full', + mode='existing', target=self.target_img, +@@ -639,7 +635,7 @@ new_state = "1" + self.vm.shutdown() + + def test_stop_write(self): +- self.assert_no_active_mirrors() ++ self.assert_no_active_block_jobs() + + result = self.vm.qmp('drive-mirror', device='drive0', sync='full', + mode='existing', target=self.target_img, +@@ -671,7 +667,7 @@ new_state = "1" + ready = True + + self.complete_and_wait(wait_ready=False) +- self.assert_no_active_mirrors() ++ self.assert_no_active_block_jobs() + self.vm.shutdown() + + class TestSetSpeed(ImageMirroringTestCase): +@@ -690,7 +686,7 @@ class TestSetSpeed(ImageMirroringTestCase): + os.remove(target_img) + + def test_set_speed(self): +- self.assert_no_active_mirrors() ++ self.assert_no_active_block_jobs() + + result = self.vm.qmp('drive-mirror', device='drive0', sync='full', + target=target_img) +@@ -723,13 +719,13 @@ class TestSetSpeed(ImageMirroringTestCase): + self.cancel_and_wait() + + def test_set_speed_invalid(self): +- self.assert_no_active_mirrors() ++ self.assert_no_active_block_jobs() + + result = self.vm.qmp('drive-mirror', device='drive0', sync='full', + target=target_img, speed=-1) + self.assert_qmp(result, 'error/class', 'GenericError') + +- self.assert_no_active_mirrors() ++ self.assert_no_active_block_jobs() + + result = self.vm.qmp('drive-mirror', device='drive0', sync='full', + target=target_img) +diff --git a/tests/qemu-iotests/iotests.py b/tests/qemu-iotests/iotests.py +index 5cbac82..740464a 100644 +--- a/tests/qemu-iotests/iotests.py ++++ b/tests/qemu-iotests/iotests.py +@@ -174,6 +174,10 @@ class QMPTestCase(unittest.TestCase): + result = self.dictpath(d, path) + self.assertEqual(result, value, 'values not equal "%s" and "%s"' % (str(result), str(value))) + ++ def assert_no_active_block_jobs(self): ++ result = self.vm.qmp('query-block-jobs') ++ self.assert_qmp(result, 'return', []) ++ + def notrun(reason): + '''Skip this test suite''' + # Each test in qemu-iotests has a number ("seq") +-- +1.7.1 + diff --git a/SOURCES/kvm-qemu-iotests-prefill-some-data-to-test-image.patch b/SOURCES/kvm-qemu-iotests-prefill-some-data-to-test-image.patch new file mode 100644 index 0000000..2b00be6 --- /dev/null +++ b/SOURCES/kvm-qemu-iotests-prefill-some-data-to-test-image.patch @@ -0,0 +1,64 @@ +From 33e66fa335c602b53302cd2838d075a8c05509d6 Mon Sep 17 00:00:00 2001 +From: Fam Zheng +Date: Fri, 17 Jan 2014 03:08:01 +0100 +Subject: [PATCH 18/34] qemu-iotests: prefill some data to test image + +RH-Author: Fam Zheng +Message-id: <1389928083-8921-17-git-send-email-famz@redhat.com> +Patchwork-id: 56778 +O-Subject: [RHEL-7 qemu-kvm PATCH 16/18] qemu-iotests: prefill some data to test image +Bugzilla: 1041301 +RH-Acked-by: Jeffrey Cody +RH-Acked-by: Kevin Wolf +RH-Acked-by: Stefan Hajnoczi + +Case 030 occasionally fails because of block job compltes too fast to be +captured by script, and 'unexpected qmp event' of job completion causes +the test failure. + +Simply fill in some data to the test image to make this false alarm less +likely to happen. + +(For other benefits to prefill data to test image, see also commit +ab68cdfaa). + +Signed-off-by: Fam Zheng +Signed-off-by: Kevin Wolf +(cherry picked from commit 7890111b642e8e03430c3bf8bd6cedee26cec4fe) +Signed-off-by: Fam Zheng +--- + tests/qemu-iotests/030 | 4 ++++ + 1 file changed, 4 insertions(+) + +Signed-off-by: Miroslav Rezanina +--- + tests/qemu-iotests/030 | 4 ++++ + 1 files changed, 4 insertions(+), 0 deletions(-) + +diff --git a/tests/qemu-iotests/030 b/tests/qemu-iotests/030 +index dd4ef11..3d128b3 100755 +--- a/tests/qemu-iotests/030 ++++ b/tests/qemu-iotests/030 +@@ -421,7 +421,9 @@ class TestStreamStop(ImageStreamingTestCase): + + def setUp(self): + qemu_img('create', backing_img, str(TestStreamStop.image_len)) ++ qemu_io('-c', 'write -P 0x1 0 32M', backing_img) + qemu_img('create', '-f', iotests.imgfmt, '-o', 'backing_file=%s' % backing_img, test_img) ++ qemu_io('-c', 'write -P 0x1 32M 32M', test_img) + self.vm = iotests.VM().add_drive(test_img) + self.vm.launch() + +@@ -447,7 +449,9 @@ class TestSetSpeed(ImageStreamingTestCase): + + def setUp(self): + qemu_img('create', backing_img, str(TestSetSpeed.image_len)) ++ qemu_io('-c', 'write -P 0x1 0 32M', backing_img) + qemu_img('create', '-f', iotests.imgfmt, '-o', 'backing_file=%s' % backing_img, test_img) ++ qemu_io('-c', 'write -P 0x1 32M 32M', test_img) + self.vm = iotests.VM().add_drive(test_img) + self.vm.launch() + +-- +1.7.1 + diff --git a/SOURCES/kvm-qemu-option-has_help_option-and-is_valid_option_list.patch b/SOURCES/kvm-qemu-option-has_help_option-and-is_valid_option_list.patch new file mode 100644 index 0000000..608cb0c --- /dev/null +++ b/SOURCES/kvm-qemu-option-has_help_option-and-is_valid_option_list.patch @@ -0,0 +1,114 @@ +From 8720a390e468547c84e8143ee5cf81263d0fb4f3 Mon Sep 17 00:00:00 2001 +From: Kevin Wolf +Date: Tue, 25 Feb 2014 15:00:00 +0100 +Subject: [PATCH 2/7] qemu-option: has_help_option() and is_valid_option_list() + +RH-Author: Kevin Wolf +Message-id: <1393340405-9936-2-git-send-email-kwolf@redhat.com> +Patchwork-id: 57793 +O-Subject: [RHEL-7.0 qemu-kvm PATCH 1/6] qemu-option: has_help_option() and is_valid_option_list() +Bugzilla: 1065873 +RH-Acked-by: Juan Quintela +RH-Acked-by: Fam Zheng +RH-Acked-by: Miroslav Rezanina + +has_help_option() checks if any help option ('help' or '?') occurs +anywhere in an option string, so that things like 'cluster_size=4k,help' +are recognised. + +is_valid_option_list() ensures that the option list doesn't have options +with leading commas or trailing unescaped commas. + +Signed-off-by: Kevin Wolf +Reviewed-by: Jeff Cody +Reviewed-by: Eric Blake +(cherry picked from commit 7cc07ab8daa01f100f36ab63382d491f2d278c64) + +Signed-off-by: Kevin Wolf +--- + include/qemu/option.h | 2 ++ + util/qemu-option.c | 49 +++++++++++++++++++++++++++++++++++++++++++++++++ + 2 files changed, 51 insertions(+) + +Signed-off-by: Miroslav Rezanina +--- + include/qemu/option.h | 2 ++ + util/qemu-option.c | 49 +++++++++++++++++++++++++++++++++++++++++++++++++ + 2 files changed, 51 insertions(+), 0 deletions(-) + +diff --git a/include/qemu/option.h b/include/qemu/option.h +index 5c0c6dd..e1d3dd0 100644 +--- a/include/qemu/option.h ++++ b/include/qemu/option.h +@@ -79,6 +79,8 @@ void parse_option_size(const char *name, const char *value, + void free_option_parameters(QEMUOptionParameter *list); + void print_option_parameters(QEMUOptionParameter *list); + void print_option_help(QEMUOptionParameter *list); ++bool has_help_option(const char *param); ++bool is_valid_option_list(const char *param); + + /* ------------------------------------------------------------------ */ + +diff --git a/util/qemu-option.c b/util/qemu-option.c +index 2445406..4de5d13 100644 +--- a/util/qemu-option.c ++++ b/util/qemu-option.c +@@ -450,6 +450,55 @@ fail: + return NULL; + } + ++bool has_help_option(const char *param) ++{ ++ size_t buflen = strlen(param) + 1; ++ char *buf = g_malloc0(buflen); ++ const char *p = param; ++ bool result = false; ++ ++ while (*p) { ++ p = get_opt_value(buf, buflen, p); ++ if (*p) { ++ p++; ++ } ++ ++ if (is_help_option(buf)) { ++ result = true; ++ goto out; ++ } ++ } ++ ++out: ++ free(buf); ++ return result; ++} ++ ++bool is_valid_option_list(const char *param) ++{ ++ size_t buflen = strlen(param) + 1; ++ char *buf = g_malloc0(buflen); ++ const char *p = param; ++ bool result = true; ++ ++ while (*p) { ++ p = get_opt_value(buf, buflen, p); ++ if (*p && !*++p) { ++ result = false; ++ goto out; ++ } ++ ++ if (!*buf || *buf == ',') { ++ result = false; ++ goto out; ++ } ++ } ++ ++out: ++ free(buf); ++ return result; ++} ++ + /* + * Prints all options of a list that have a value to stdout + */ +-- +1.7.1 + diff --git a/SOURCES/kvm-qemu-progress-Drop-unused-include.patch b/SOURCES/kvm-qemu-progress-Drop-unused-include.patch new file mode 100644 index 0000000..57d693a --- /dev/null +++ b/SOURCES/kvm-qemu-progress-Drop-unused-include.patch @@ -0,0 +1,43 @@ +From ea55137cc4a565a2917267dcdd62cc7d53493135 Mon Sep 17 00:00:00 2001 +From: Kevin Wolf +Date: Tue, 11 Feb 2014 16:24:42 +0100 +Subject: [PATCH 25/28] qemu-progress: Drop unused include + +RH-Author: Kevin Wolf +Message-id: <1392135884-10508-2-git-send-email-kwolf@redhat.com> +Patchwork-id: 57221 +O-Subject: [RHEL-7.0 qemu-kvm PATCH 1/3] qemu-progress: Drop unused include +Bugzilla: 997878 +RH-Acked-by: Laszlo Ersek +RH-Acked-by: Jeffrey Cody +RH-Acked-by: Markus Armbruster + +Signed-off-by: Kevin Wolf +Reviewed-by: Benoit Canet +(cherry picked from commit e69968d472bd020a08c677c814237548090d2e59) + +Signed-off-by: Kevin Wolf +--- + util/qemu-progress.c | 1 - + 1 file changed, 1 deletion(-) + +Signed-off-by: Miroslav Rezanina +--- + util/qemu-progress.c | 1 - + 1 files changed, 0 insertions(+), 1 deletions(-) + +diff --git a/util/qemu-progress.c b/util/qemu-progress.c +index 9a3f96c..ad33fee 100644 +--- a/util/qemu-progress.c ++++ b/util/qemu-progress.c +@@ -24,7 +24,6 @@ + + #include "qemu-common.h" + #include "qemu/osdep.h" +-#include "sysemu/sysemu.h" + #include + + struct progress_state { +-- +1.7.1 + diff --git a/SOURCES/kvm-qemu-progress-Fix-progress-printing-on-SIGUSR1.patch b/SOURCES/kvm-qemu-progress-Fix-progress-printing-on-SIGUSR1.patch new file mode 100644 index 0000000..c407576 --- /dev/null +++ b/SOURCES/kvm-qemu-progress-Fix-progress-printing-on-SIGUSR1.patch @@ -0,0 +1,63 @@ +From a06249cc31c0f8c2ae37c7e0ff047a922a265e7c Mon Sep 17 00:00:00 2001 +From: Kevin Wolf +Date: Tue, 11 Feb 2014 16:24:43 +0100 +Subject: [PATCH 26/28] qemu-progress: Fix progress printing on SIGUSR1 + +RH-Author: Kevin Wolf +Message-id: <1392135884-10508-3-git-send-email-kwolf@redhat.com> +Patchwork-id: 57223 +O-Subject: [RHEL-7.0 qemu-kvm PATCH 2/3] qemu-progress: Fix progress printing on SIGUSR1 +Bugzilla: 997878 +RH-Acked-by: Laszlo Ersek +RH-Acked-by: Jeffrey Cody +RH-Acked-by: Markus Armbruster + +Since commit a7aae221 ('Switch SIG_IPI to SIGUSR1'), SIGUSR1 is blocked +during startup, breaking the progress report in tools. + +This patch reenables the signal when initialising a progress report. + +Signed-off-by: Kevin Wolf +Reviewed-by: Benoit Canet +(cherry picked from commit 3c4b4e383e82ab3db307ee01f12ab0d4a28584dc) + +Signed-off-by: Kevin Wolf +--- + util/qemu-progress.c | 10 ++++++++++ + 1 file changed, 10 insertions(+) + +Signed-off-by: Miroslav Rezanina +--- + util/qemu-progress.c | 10 ++++++++++ + 1 files changed, 10 insertions(+), 0 deletions(-) + +diff --git a/util/qemu-progress.c b/util/qemu-progress.c +index ad33fee..4ee5cd0 100644 +--- a/util/qemu-progress.c ++++ b/util/qemu-progress.c +@@ -82,12 +82,22 @@ static void progress_dummy_init(void) + { + #ifdef CONFIG_POSIX + struct sigaction action; ++ sigset_t set; + + memset(&action, 0, sizeof(action)); + sigfillset(&action.sa_mask); + action.sa_handler = sigusr_print; + action.sa_flags = 0; + sigaction(SIGUSR1, &action, NULL); ++ ++ /* ++ * SIGUSR1 is SIG_IPI and gets blocked in qemu_init_main_loop(). In the ++ * tools that use the progress report SIGUSR1 isn't used in this meaning ++ * and instead should print the progress, so reenable it. ++ */ ++ sigemptyset(&set); ++ sigaddset(&set, SIGUSR1); ++ pthread_sigmask(SIG_UNBLOCK, &set, NULL); + #endif + + state.print = progress_dummy_print; +-- +1.7.1 + diff --git a/SOURCES/kvm-qemu_file-Fix-mismerge-of-use-fwrite-correctly.patch b/SOURCES/kvm-qemu_file-Fix-mismerge-of-use-fwrite-correctly.patch new file mode 100644 index 0000000..04c9ccb --- /dev/null +++ b/SOURCES/kvm-qemu_file-Fix-mismerge-of-use-fwrite-correctly.patch @@ -0,0 +1,58 @@ +From 28c5321911bde483484eb95d0bef2e8e65a3593b Mon Sep 17 00:00:00 2001 +From: Dr. David Alan Gilbert (git) +Date: Mon, 10 Mar 2014 17:41:44 +0100 +Subject: [PATCH 16/16] qemu_file: Fix mismerge of "use fwrite() correctly" + +RH-Author: Dr. David Alan Gilbert (git) +Message-id: <1394473304-7190-3-git-send-email-dgilbert@redhat.com> +Patchwork-id: 58074 +O-Subject: [RHEL-7.0 qemu-kvm PATCH v2 2/2] qemu_file: Fix mismerge of "use fwrite() correctly" +Bugzilla: 1005103 +RH-Acked-by: Juan Quintela +RH-Acked-by: Eric Blake +RH-Acked-by: Amit Shah + +From: Markus Armbruster + +Reviewers accepted v2 of the patch, but what got committed was v1, +with the R-bys for v2. This is the v1->v2 followup fix. + +[Amit: + This fixes commit aded6539d983280212e08d09f14157b1cb4d58cc +] + +Signed-off-by: Markus Armbruster +Reviewed-by: Eric Blake +Reviewed-by: Amit Shah +Signed-off-by: Amit Shah +Signed-off-by: Juan Quintela +(cherry picked from commit ac4df4e608e84da135eacecd7bba7c6e9e9a63b7) + +Conflicts: + qemu-file.c +was still in savevm.c +--- + savevm.c | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +Signed-off-by: Miroslav Rezanina +--- + savevm.c | 2 +- + 1 files changed, 1 insertions(+), 1 deletions(-) + +diff --git a/savevm.c b/savevm.c +index 94121a2..4d92a7b 100644 +--- a/savevm.c ++++ b/savevm.c +@@ -216,7 +216,7 @@ static int stdio_put_buffer(void *opaque, const uint8_t *buf, int64_t pos, int s + res = fwrite(buf, 1, size, s->stdio_file); + + if (res != size) { +- return -EIO; /* fake errno value */ ++ return -errno; + } + return res; + } +-- +1.7.1 + diff --git a/SOURCES/kvm-qemu_file-use-fwrite-correctly.patch b/SOURCES/kvm-qemu_file-use-fwrite-correctly.patch new file mode 100644 index 0000000..745b4a6 --- /dev/null +++ b/SOURCES/kvm-qemu_file-use-fwrite-correctly.patch @@ -0,0 +1,72 @@ +From 2f66e62873ef54bd27ec6e063c8b4f3f11e2413d Mon Sep 17 00:00:00 2001 +From: Dr. David Alan Gilbert (git) +Date: Mon, 10 Mar 2014 17:41:43 +0100 +Subject: [PATCH 15/16] qemu_file: use fwrite() correctly + +RH-Author: Dr. David Alan Gilbert (git) +Message-id: <1394473304-7190-2-git-send-email-dgilbert@redhat.com> +Patchwork-id: 58073 +O-Subject: [RHEL-7.0 qemu-kvm PATCH v2 1/2] qemu_file: use fwrite() correctly +Bugzilla: 1005103 +RH-Acked-by: Juan Quintela +RH-Acked-by: Eric Blake +RH-Acked-by: Amit Shah + +From: Juan Quintela + +fwrite() returns the number of items written. But when there is one +error, it can return a short write. + +In the particular bug that I was tracking, I did a migration to a +read-only filesystem. And it was able to finish the migration +correctly. fwrite() never returned a negative error code, nor zero, +always 4096. (migration writes chunks of about 14000 bytes). And it +was able to "complete" the migration with success (yes, reading the +file was a bit more difficult). + +To add insult to injury, if your amount of memory was big enough (12GB +on my case), it overwrote some important structure, and from them, +malloc failed. This check makes the problem go away. + +Signed-off-by: Juan Quintela +Reviewed-by: Eric Blake +Reviewed-by: Markus Armbruster +Signed-off-by: Juan Quintela +(cherry picked from commit aded6539d983280212e08d09f14157b1cb4d58cc) + +Conflicts: + qemu-file.c + +Code still in savevm.c +--- + savevm.c | 9 ++++++++- + 1 file changed, 8 insertions(+), 1 deletion(-) + +Signed-off-by: Miroslav Rezanina +--- + savevm.c | 9 ++++++++- + 1 files changed, 8 insertions(+), 1 deletions(-) + +diff --git a/savevm.c b/savevm.c +index bd37959..94121a2 100644 +--- a/savevm.c ++++ b/savevm.c +@@ -211,7 +211,14 @@ static int stdio_get_fd(void *opaque) + static int stdio_put_buffer(void *opaque, const uint8_t *buf, int64_t pos, int size) + { + QEMUFileStdio *s = opaque; +- return fwrite(buf, 1, size, s->stdio_file); ++ int res; ++ ++ res = fwrite(buf, 1, size, s->stdio_file); ++ ++ if (res != size) { ++ return -EIO; /* fake errno value */ ++ } ++ return res; + } + + static int stdio_get_buffer(void *opaque, uint8_t *buf, int64_t pos, int size) +-- +1.7.1 + diff --git a/SOURCES/kvm-qemu_memalign-Allow-small-alignments.patch b/SOURCES/kvm-qemu_memalign-Allow-small-alignments.patch new file mode 100644 index 0000000..c41115d --- /dev/null +++ b/SOURCES/kvm-qemu_memalign-Allow-small-alignments.patch @@ -0,0 +1,52 @@ +From 3e92f885201f2ddf30d093f34a02630ca3324b0b Mon Sep 17 00:00:00 2001 +From: Kevin Wolf +Date: Fri, 29 Nov 2013 21:29:17 +0100 +Subject: [PATCH 06/37] qemu_memalign: Allow small alignments +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +Message-id: <1392117622-28812-7-git-send-email-kwolf@redhat.com> +Patchwork-id: 57171 +O-Subject: [RHEL-7.0 qemu-kvm PATCH v2 06/37] qemu_memalign: Allow small alignments +Bugzilla: 748906 +RH-Acked-by: Laszlo Ersek +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Max Reitz + +The functions used by qemu_memalign() require an alignment that is at +least sizeof(void*). Adjust it if it is too small. + +Signed-off-by: Kevin Wolf +Reviewed-by: Wenchao Xia +Reviewed-by: Max Reitz +Reviewed-by: Benoît Canet +(cherry picked from commit e5354657a626b325c31888f33de88ac6d39e2fcb) + +Signed-off-by: Kevin Wolf +--- + util/oslib-posix.c | 5 +++++ + 1 file changed, 5 insertions(+) +--- + util/oslib-posix.c | 5 +++++ + 1 files changed, 5 insertions(+), 0 deletions(-) + +diff --git a/util/oslib-posix.c b/util/oslib-posix.c +index 253bc3d..2c756c7 100644 +--- a/util/oslib-posix.c ++++ b/util/oslib-posix.c +@@ -85,6 +85,11 @@ void *qemu_oom_check(void *ptr) + void *qemu_memalign(size_t alignment, size_t size) + { + void *ptr; ++ ++ if (alignment < sizeof(void*)) { ++ alignment = sizeof(void*); ++ } ++ + #if defined(_POSIX_C_SOURCE) && !defined(__sun__) + int ret; + ret = posix_memalign(&ptr, alignment, size); +-- +1.7.1 + diff --git a/SOURCES/kvm-qmp-access-the-local-QemuOptsLists-for-drive-option.patch b/SOURCES/kvm-qmp-access-the-local-QemuOptsLists-for-drive-option.patch new file mode 100644 index 0000000..6c9ce7d --- /dev/null +++ b/SOURCES/kvm-qmp-access-the-local-QemuOptsLists-for-drive-option.patch @@ -0,0 +1,214 @@ +From 6d981002b5ccbcb4905e5fa45b4606cf4ddc9c9e Mon Sep 17 00:00:00 2001 +From: Amos Kong +Date: Tue, 25 Feb 2014 07:56:50 +0100 +Subject: [PATCH 1/6] qmp: access the local QemuOptsLists for drive option + +RH-Author: Amos Kong +Message-id: <1393315010-20614-1-git-send-email-akong@redhat.com> +Patchwork-id: 57771 +O-Subject: [RHEL-7.0 qemu-kvm PATCH v3] qmp: access the local QemuOptsLists for drive option +Bugzilla: 1026184 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Eduardo Habkost +RH-Acked-by: Fam Zheng + +Bugzilla: 1026184 +Brew: http://brewweb.devel.redhat.com/brew/taskinfo?taskID=7104270 + +Currently we have three QemuOptsList (qemu_common_drive_opts, +qemu_legacy_drive_opts, and qemu_drive_opts), only qemu_drive_opts +is added to vm_config_groups[]. + +This patch changes query-command-line-options to access three local +QemuOptsLists for drive option, and merge the description items +together. + +Signed-off-by: Amos Kong +Signed-off-by: Kevin Wolf +(cherry picked from commit 968854c8a106243eae7a68394ce1cb85dc138837) +--- +v2: re-backport when patch is merged to mainline +v3: rebase to latest qemu-kvm-rhel7 +--- +redo/fix query-command-line-options isn't finished, let's fix the +blkdev issue in rhel7.0 by this backport. +--- + blockdev.c | 1 - + include/qemu/config-file.h | 1 + + include/sysemu/sysemu.h | 2 + + util/qemu-config.c | 77 +++++++++++++++++++++++++++++++++++++++++++- + vl.c | 3 ++ + 5 files changed, 82 insertions(+), 2 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + blockdev.c | 1 - + include/qemu/config-file.h | 1 + + include/sysemu/sysemu.h | 2 + + util/qemu-config.c | 77 +++++++++++++++++++++++++++++++++++++++++++- + vl.c | 3 ++ + 5 files changed, 82 insertions(+), 2 deletions(-) + +diff --git a/blockdev.c b/blockdev.c +index 80c6bb4..e51203c 100644 +--- a/blockdev.c ++++ b/blockdev.c +@@ -47,7 +47,6 @@ + #include "sysemu/arch_init.h" + + static QTAILQ_HEAD(drivelist, DriveInfo) drives = QTAILQ_HEAD_INITIALIZER(drives); +-extern QemuOptsList qemu_common_drive_opts; + + static const char *const if_name[IF_COUNT] = { + [IF_NONE] = "none", +diff --git a/include/qemu/config-file.h b/include/qemu/config-file.h +index ccfccae..3f92282 100644 +--- a/include/qemu/config-file.h ++++ b/include/qemu/config-file.h +@@ -9,6 +9,7 @@ + QemuOptsList *qemu_find_opts(const char *group); + QemuOptsList *qemu_find_opts_err(const char *group, Error **errp); + void qemu_add_opts(QemuOptsList *list); ++void qemu_add_drive_opts(QemuOptsList *list); + int qemu_set_option(const char *str); + int qemu_global_option(const char *str); + void qemu_add_globals(void); +diff --git a/include/sysemu/sysemu.h b/include/sysemu/sysemu.h +index c70d2dd..8dc0a4c 100644 +--- a/include/sysemu/sysemu.h ++++ b/include/sysemu/sysemu.h +@@ -191,6 +191,8 @@ QemuOpts *qemu_get_machine_opts(void); + + bool usb_enabled(bool default_usb); + ++extern QemuOptsList qemu_legacy_drive_opts; ++extern QemuOptsList qemu_common_drive_opts; + extern QemuOptsList qemu_drive_opts; + extern QemuOptsList qemu_simple_drive_opts; + extern QemuOptsList qemu_chardev_opts; +diff --git a/util/qemu-config.c b/util/qemu-config.c +index a59568d..04da942 100644 +--- a/util/qemu-config.c ++++ b/util/qemu-config.c +@@ -8,6 +8,7 @@ + #include "qmp-commands.h" + + static QemuOptsList *vm_config_groups[32]; ++static QemuOptsList *drive_config_groups[4]; + + static QemuOptsList *find_list(QemuOptsList **lists, const char *group, + Error **errp) +@@ -77,6 +78,59 @@ static CommandLineParameterInfoList *query_option_descs(const QemuOptDesc *desc) + return param_list; + } + ++/* remove repeated entry from the info list */ ++static void cleanup_infolist(CommandLineParameterInfoList *head) ++{ ++ CommandLineParameterInfoList *pre_entry, *cur, *del_entry; ++ ++ cur = head; ++ while (cur->next) { ++ pre_entry = head; ++ while (pre_entry != cur->next) { ++ if (!strcmp(pre_entry->value->name, cur->next->value->name)) { ++ del_entry = cur->next; ++ cur->next = cur->next->next; ++ g_free(del_entry); ++ break; ++ } ++ pre_entry = pre_entry->next; ++ } ++ cur = cur->next; ++ } ++} ++ ++/* merge the description items of two parameter infolists */ ++static void connect_infolist(CommandLineParameterInfoList *head, ++ CommandLineParameterInfoList *new) ++{ ++ CommandLineParameterInfoList *cur; ++ ++ cur = head; ++ while (cur->next) { ++ cur = cur->next; ++ } ++ cur->next = new; ++} ++ ++/* access all the local QemuOptsLists for drive option */ ++static CommandLineParameterInfoList *get_drive_infolist(void) ++{ ++ CommandLineParameterInfoList *head = NULL, *cur; ++ int i; ++ ++ for (i = 0; drive_config_groups[i] != NULL; i++) { ++ if (!head) { ++ head = query_option_descs(drive_config_groups[i]->desc); ++ } else { ++ cur = query_option_descs(drive_config_groups[i]->desc); ++ connect_infolist(head, cur); ++ } ++ } ++ cleanup_infolist(head); ++ ++ return head; ++} ++ + CommandLineOptionInfoList *qmp_query_command_line_options(bool has_option, + const char *option, + Error **errp) +@@ -89,7 +143,12 @@ CommandLineOptionInfoList *qmp_query_command_line_options(bool has_option, + if (!has_option || !strcmp(option, vm_config_groups[i]->name)) { + info = g_malloc0(sizeof(*info)); + info->option = g_strdup(vm_config_groups[i]->name); +- info->parameters = query_option_descs(vm_config_groups[i]->desc); ++ if (!strcmp("drive", vm_config_groups[i]->name)) { ++ info->parameters = get_drive_infolist(); ++ } else { ++ info->parameters = ++ query_option_descs(vm_config_groups[i]->desc); ++ } + entry = g_malloc0(sizeof(*entry)); + entry->value = info; + entry->next = conf_list; +@@ -109,6 +168,22 @@ QemuOptsList *qemu_find_opts_err(const char *group, Error **errp) + return find_list(vm_config_groups, group, errp); + } + ++void qemu_add_drive_opts(QemuOptsList *list) ++{ ++ int entries, i; ++ ++ entries = ARRAY_SIZE(drive_config_groups); ++ entries--; /* keep list NULL terminated */ ++ for (i = 0; i < entries; i++) { ++ if (drive_config_groups[i] == NULL) { ++ drive_config_groups[i] = list; ++ return; ++ } ++ } ++ fprintf(stderr, "ran out of space in drive_config_groups"); ++ abort(); ++} ++ + void qemu_add_opts(QemuOptsList *list) + { + int entries, i; +diff --git a/vl.c b/vl.c +index deb5884..51300e7 100644 +--- a/vl.c ++++ b/vl.c +@@ -2851,6 +2851,9 @@ int main(int argc, char **argv, char **envp) + + qemu_add_opts(&qemu_drive_opts); + qemu_add_opts(&qemu_simple_drive_opts); ++ qemu_add_drive_opts(&qemu_legacy_drive_opts); ++ qemu_add_drive_opts(&qemu_common_drive_opts); ++ qemu_add_drive_opts(&qemu_drive_opts); + qemu_add_opts(&qemu_chardev_opts); + qemu_add_opts(&qemu_device_opts); + qemu_add_opts(&qemu_netdev_opts); +-- +1.7.1 + diff --git a/SOURCES/kvm-qom-Fix-memory-leak-in-object_property_set_link.patch b/SOURCES/kvm-qom-Fix-memory-leak-in-object_property_set_link.patch new file mode 100644 index 0000000..4364dce --- /dev/null +++ b/SOURCES/kvm-qom-Fix-memory-leak-in-object_property_set_link.patch @@ -0,0 +1,59 @@ +From 709b3788e91957a9cff1adbe8ceac45daa2fa2bd Mon Sep 17 00:00:00 2001 +Message-Id: <709b3788e91957a9cff1adbe8ceac45daa2fa2bd.1387276076.git.minovotn@redhat.com> +In-Reply-To: +References: +From: Amos Kong +Date: Sat, 23 Nov 2013 03:17:44 +0100 +Subject: [PATCH 04/16] qom: Fix memory leak in object_property_set_link() +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +RH-Author: Amos Kong +Message-id: <1385176664-3852-3-git-send-email-akong@redhat.com> +Patchwork-id: 55867 +O-Subject: [RHEL-7.0 qemu-kvm PATCH 2/2] qom: Fix memory leak in object_property_set_link() +Bugzilla: 1033810 +RH-Acked-by: Vlad Yasevich +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Igor Mammedov + +From: Vlad Yasevich + +Save the result of the call to object_get_canonical_path() +so we can free it. + +Cc: qemu-stable@nongnu.org +Signed-off-by: Vlad Yasevich +Reviewed-by: Amos Kong +Reviewed-by: Stefan Hajnoczi +Signed-off-by: Andreas Färber +(cherry picked from commit 2d3aa28cc2cf382aa04cd577e0be542175eea9bd) +--- + qom/object.c | 5 +++-- + 1 files changed, 3 insertions(+), 2 deletions(-) + +Signed-off-by: Michal Novotny +--- + qom/object.c | 5 +++-- + 1 file changed, 3 insertions(+), 2 deletions(-) + +diff --git a/qom/object.c b/qom/object.c +index b7ecb9f..05e2636 100644 +--- a/qom/object.c ++++ b/qom/object.c +@@ -824,8 +824,9 @@ char *object_property_get_str(Object *obj, const char *name, + void object_property_set_link(Object *obj, Object *value, + const char *name, Error **errp) + { +- object_property_set_str(obj, object_get_canonical_path(value), +- name, errp); ++ gchar *path = object_get_canonical_path(value); ++ object_property_set_str(obj, path, name, errp); ++ g_free(path); + } + + Object *object_property_get_link(Object *obj, const char *name, +-- +1.7.11.7 + diff --git a/SOURCES/kvm-qom-add-pointer-to-int-property-helpers.patch b/SOURCES/kvm-qom-add-pointer-to-int-property-helpers.patch new file mode 100644 index 0000000..6cdaad4 --- /dev/null +++ b/SOURCES/kvm-qom-add-pointer-to-int-property-helpers.patch @@ -0,0 +1,144 @@ +From 5b321366d742d4efe826036108b06796563ea0ed Mon Sep 17 00:00:00 2001 +Message-Id: <5b321366d742d4efe826036108b06796563ea0ed.1387298827.git.minovotn@redhat.com> +In-Reply-To: <3ed0fb61a3dc912ef036d7ef450bed192090709e.1387298827.git.minovotn@redhat.com> +References: <3ed0fb61a3dc912ef036d7ef450bed192090709e.1387298827.git.minovotn@redhat.com> +From: "Michael S. Tsirkin" +Date: Tue, 17 Dec 2013 15:17:53 +0100 +Subject: [PATCH 25/56] qom: add pointer to int property helpers + +RH-Author: Michael S. Tsirkin +Message-id: <1387293161-4085-26-git-send-email-mst@redhat.com> +Patchwork-id: 56331 +O-Subject: [PATCH qemu-kvm RHEL7.0 v2 25/57] qom: add pointer to int property helpers +Bugzilla: 1034876 +RH-Acked-by: Igor Mammedov +RH-Acked-by: Marcel Apfelbaum +RH-Acked-by: Laszlo Ersek + +Make it easy to add read-only helpers for simple +integer properties in memory. + +Reviewed-by: Paolo Bonzini +Reviewed-by: Gerd Hoffmann +Tested-by: Gerd Hoffmann +Reviewed-by: Igor Mammedov +Tested-by: Igor Mammedov +Signed-off-by: Michael S. Tsirkin +(cherry picked from commit e732ea638705da35445a42dee32691fbe813d3e0) +--- + include/qom/object.h | 21 ++++++++++++++++++ + qom/object.c | 60 ++++++++++++++++++++++++++++++++++++++++++++++++++++ + 2 files changed, 81 insertions(+) + +Signed-off-by: Michal Novotny +--- + include/qom/object.h | 21 ++++++++++++++++++ + qom/object.c | 60 ++++++++++++++++++++++++++++++++++++++++++++++++++++ + 2 files changed, 81 insertions(+) + +diff --git a/include/qom/object.h b/include/qom/object.h +index dbe1413..193bfeb 100644 +--- a/include/qom/object.h ++++ b/include/qom/object.h +@@ -790,6 +790,27 @@ void object_property_add(Object *obj, const char *name, const char *type, + void object_property_del(Object *obj, const char *name, Error **errp); + + /** ++ * object_property_add_uint8_ptr: ++ * object_property_add_uint16_ptr: ++ * object_property_add_uint32_ptr: ++ * object_property_add_uint64_ptr: ++ * @obj: the object to add a property to ++ * @name: the name of the property ++ * @v: pointer to value ++ * ++ * Add an integer property in memory. This function will add a ++ * property of the appropriate type. ++ */ ++void object_property_add_uint8_ptr(Object *obj, const char *name, ++ const uint8_t *v, Error **errp); ++void object_property_add_uint16_ptr(Object *obj, const char *name, ++ const uint16_t *v, Error **errp); ++void object_property_add_uint32_ptr(Object *obj, const char *name, ++ const uint32_t *v, Error **errp); ++void object_property_add_uint64_ptr(Object *obj, const char *name, ++ const uint64_t *v, Error **Errp); ++ ++/** + * object_property_find: + * @obj: the object + * @name: the name of the property +diff --git a/qom/object.c b/qom/object.c +index 05e2636..d04a96b 100644 +--- a/qom/object.c ++++ b/qom/object.c +@@ -1331,6 +1331,66 @@ static char *qdev_get_type(Object *obj, Error **errp) + return g_strdup(object_get_typename(obj)); + } + ++static void property_get_uint8_ptr(Object *obj, Visitor *v, ++ void *opaque, const char *name, ++ Error **errp) ++{ ++ uint8_t value = *(uint8_t *)opaque; ++ visit_type_uint8(v, &value, name, errp); ++} ++ ++static void property_get_uint16_ptr(Object *obj, Visitor *v, ++ void *opaque, const char *name, ++ Error **errp) ++{ ++ uint16_t value = *(uint16_t *)opaque; ++ visit_type_uint16(v, &value, name, errp); ++} ++ ++static void property_get_uint32_ptr(Object *obj, Visitor *v, ++ void *opaque, const char *name, ++ Error **errp) ++{ ++ uint32_t value = *(uint32_t *)opaque; ++ visit_type_uint32(v, &value, name, errp); ++} ++ ++static void property_get_uint64_ptr(Object *obj, Visitor *v, ++ void *opaque, const char *name, ++ Error **errp) ++{ ++ uint64_t value = *(uint64_t *)opaque; ++ visit_type_uint64(v, &value, name, errp); ++} ++ ++void object_property_add_uint8_ptr(Object *obj, const char *name, ++ const uint8_t *v, Error **errp) ++{ ++ object_property_add(obj, name, "uint8", property_get_uint8_ptr, ++ NULL, NULL, (void *)v, errp); ++} ++ ++void object_property_add_uint16_ptr(Object *obj, const char *name, ++ const uint16_t *v, Error **errp) ++{ ++ object_property_add(obj, name, "uint16", property_get_uint16_ptr, ++ NULL, NULL, (void *)v, errp); ++} ++ ++void object_property_add_uint32_ptr(Object *obj, const char *name, ++ const uint32_t *v, Error **errp) ++{ ++ object_property_add(obj, name, "uint32", property_get_uint32_ptr, ++ NULL, NULL, (void *)v, errp); ++} ++ ++void object_property_add_uint64_ptr(Object *obj, const char *name, ++ const uint64_t *v, Error **errp) ++{ ++ object_property_add(obj, name, "uint64", property_get_uint64_ptr, ++ NULL, NULL, (void *)v, errp); ++} ++ + static void object_instance_init(Object *obj) + { + object_property_add_str(obj, "type", qdev_get_type, NULL, NULL); +-- +1.7.11.7 + diff --git a/SOURCES/kvm-qom-cleanup-struct-Error-references.patch b/SOURCES/kvm-qom-cleanup-struct-Error-references.patch new file mode 100644 index 0000000..4d14555 --- /dev/null +++ b/SOURCES/kvm-qom-cleanup-struct-Error-references.patch @@ -0,0 +1,234 @@ +From d8f12c525de1b28b9505d38842b5dece8cbcd61a Mon Sep 17 00:00:00 2001 +Message-Id: +In-Reply-To: <3ed0fb61a3dc912ef036d7ef450bed192090709e.1387298827.git.minovotn@redhat.com> +References: <3ed0fb61a3dc912ef036d7ef450bed192090709e.1387298827.git.minovotn@redhat.com> +From: "Michael S. Tsirkin" +Date: Tue, 17 Dec 2013 15:17:50 +0100 +Subject: [PATCH 24/56] qom: cleanup struct Error references + +RH-Author: Michael S. Tsirkin +Message-id: <1387293161-4085-25-git-send-email-mst@redhat.com> +Patchwork-id: 56330 +O-Subject: [PATCH qemu-kvm RHEL7.0 v2 24/57] qom: cleanup struct Error references +Bugzilla: 1034876 +RH-Acked-by: Igor Mammedov +RH-Acked-by: Marcel Apfelbaum +RH-Acked-by: Laszlo Ersek + +now that a typedef for struct Error is available, +use it in qom/object.h to match coding style rules. + +Reviewed-by: Paolo Bonzini +Reviewed-by: Gerd Hoffmann +Tested-by: Gerd Hoffmann +Reviewed-by: Igor Mammedov +Tested-by: Igor Mammedov +Signed-off-by: Michael S. Tsirkin +(cherry picked from commit e82df24873970742778e4a960f059ba9f8b1b2a7) +--- + include/qom/object.h | 50 +++++++++++++++++++++++++------------------------- + 1 file changed, 25 insertions(+), 25 deletions(-) + +Signed-off-by: Michal Novotny +--- + include/qom/object.h | 50 +++++++++++++++++++++++++------------------------- + 1 file changed, 25 insertions(+), 25 deletions(-) + +diff --git a/include/qom/object.h b/include/qom/object.h +index c37f3ca..dbe1413 100644 +--- a/include/qom/object.h ++++ b/include/qom/object.h +@@ -301,7 +301,7 @@ typedef void (ObjectPropertyAccessor)(Object *obj, + struct Visitor *v, + void *opaque, + const char *name, +- struct Error **errp); ++ Error **errp); + + /** + * ObjectPropertyRelease: +@@ -785,9 +785,9 @@ void object_property_add(Object *obj, const char *name, const char *type, + ObjectPropertyAccessor *get, + ObjectPropertyAccessor *set, + ObjectPropertyRelease *release, +- void *opaque, struct Error **errp); ++ void *opaque, Error **errp); + +-void object_property_del(Object *obj, const char *name, struct Error **errp); ++void object_property_del(Object *obj, const char *name, Error **errp); + + /** + * object_property_find: +@@ -798,7 +798,7 @@ void object_property_del(Object *obj, const char *name, struct Error **errp); + * Look up a property for an object and return its #ObjectProperty if found. + */ + ObjectProperty *object_property_find(Object *obj, const char *name, +- struct Error **errp); ++ Error **errp); + + void object_unparent(Object *obj); + +@@ -813,7 +813,7 @@ void object_unparent(Object *obj); + * Reads a property from a object. + */ + void object_property_get(Object *obj, struct Visitor *v, const char *name, +- struct Error **errp); ++ Error **errp); + + /** + * object_property_set_str: +@@ -824,7 +824,7 @@ void object_property_get(Object *obj, struct Visitor *v, const char *name, + * Writes a string value to a property. + */ + void object_property_set_str(Object *obj, const char *value, +- const char *name, struct Error **errp); ++ const char *name, Error **errp); + + /** + * object_property_get_str: +@@ -837,7 +837,7 @@ void object_property_set_str(Object *obj, const char *value, + * The caller should free the string. + */ + char *object_property_get_str(Object *obj, const char *name, +- struct Error **errp); ++ Error **errp); + + /** + * object_property_set_link: +@@ -848,7 +848,7 @@ char *object_property_get_str(Object *obj, const char *name, + * Writes an object's canonical path to a property. + */ + void object_property_set_link(Object *obj, Object *value, +- const char *name, struct Error **errp); ++ const char *name, Error **errp); + + /** + * object_property_get_link: +@@ -861,7 +861,7 @@ void object_property_set_link(Object *obj, Object *value, + * string or not a valid object path). + */ + Object *object_property_get_link(Object *obj, const char *name, +- struct Error **errp); ++ Error **errp); + + /** + * object_property_set_bool: +@@ -872,7 +872,7 @@ Object *object_property_get_link(Object *obj, const char *name, + * Writes a bool value to a property. + */ + void object_property_set_bool(Object *obj, bool value, +- const char *name, struct Error **errp); ++ const char *name, Error **errp); + + /** + * object_property_get_bool: +@@ -884,7 +884,7 @@ void object_property_set_bool(Object *obj, bool value, + * an error occurs (including when the property value is not a bool). + */ + bool object_property_get_bool(Object *obj, const char *name, +- struct Error **errp); ++ Error **errp); + + /** + * object_property_set_int: +@@ -895,7 +895,7 @@ bool object_property_get_bool(Object *obj, const char *name, + * Writes an integer value to a property. + */ + void object_property_set_int(Object *obj, int64_t value, +- const char *name, struct Error **errp); ++ const char *name, Error **errp); + + /** + * object_property_get_int: +@@ -907,7 +907,7 @@ void object_property_set_int(Object *obj, int64_t value, + * an error occurs (including when the property value is not an integer). + */ + int64_t object_property_get_int(Object *obj, const char *name, +- struct Error **errp); ++ Error **errp); + + /** + * object_property_set: +@@ -921,7 +921,7 @@ int64_t object_property_get_int(Object *obj, const char *name, + * Writes a property to a object. + */ + void object_property_set(Object *obj, struct Visitor *v, const char *name, +- struct Error **errp); ++ Error **errp); + + /** + * object_property_parse: +@@ -933,7 +933,7 @@ void object_property_set(Object *obj, struct Visitor *v, const char *name, + * Parses a string and writes the result into a property of an object. + */ + void object_property_parse(Object *obj, const char *string, +- const char *name, struct Error **errp); ++ const char *name, Error **errp); + + /** + * object_property_print: +@@ -945,7 +945,7 @@ void object_property_parse(Object *obj, const char *string, + * caller shall free the string. + */ + char *object_property_print(Object *obj, const char *name, +- struct Error **errp); ++ Error **errp); + + /** + * object_property_get_type: +@@ -956,7 +956,7 @@ char *object_property_print(Object *obj, const char *name, + * Returns: The type name of the property. + */ + const char *object_property_get_type(Object *obj, const char *name, +- struct Error **errp); ++ Error **errp); + + /** + * object_get_root: +@@ -1049,7 +1049,7 @@ Object *object_resolve_path_component(Object *parent, const gchar *part); + * The child object itself can be retrieved using object_property_get_link(). + */ + void object_property_add_child(Object *obj, const char *name, +- Object *child, struct Error **errp); ++ Object *child, Error **errp); + + /** + * object_property_add_link: +@@ -1072,7 +1072,7 @@ void object_property_add_child(Object *obj, const char *name, + */ + void object_property_add_link(Object *obj, const char *name, + const char *type, Object **child, +- struct Error **errp); ++ Error **errp); + + /** + * object_property_add_str: +@@ -1087,9 +1087,9 @@ void object_property_add_link(Object *obj, const char *name, + * property of type 'string'. + */ + void object_property_add_str(Object *obj, const char *name, +- char *(*get)(Object *, struct Error **), +- void (*set)(Object *, const char *, struct Error **), +- struct Error **errp); ++ char *(*get)(Object *, Error **), ++ void (*set)(Object *, const char *, Error **), ++ Error **errp); + + /** + * object_property_add_bool: +@@ -1103,9 +1103,9 @@ void object_property_add_str(Object *obj, const char *name, + * property of type 'bool'. + */ + void object_property_add_bool(Object *obj, const char *name, +- bool (*get)(Object *, struct Error **), +- void (*set)(Object *, bool, struct Error **), +- struct Error **errp); ++ bool (*get)(Object *, Error **), ++ void (*set)(Object *, bool, Error **), ++ Error **errp); + + /** + * object_child_foreach: +-- +1.7.11.7 + diff --git a/SOURCES/kvm-qtest-Use-display-none-by-default.patch b/SOURCES/kvm-qtest-Use-display-none-by-default.patch new file mode 100644 index 0000000..ae48a7d --- /dev/null +++ b/SOURCES/kvm-qtest-Use-display-none-by-default.patch @@ -0,0 +1,181 @@ +From 3f51f5d57b5a4c5de484db56175c58e1825d6aa9 Mon Sep 17 00:00:00 2001 +Message-Id: <3f51f5d57b5a4c5de484db56175c58e1825d6aa9.1387288155.git.minovotn@redhat.com> +In-Reply-To: <527da6c2ce2c09d0183aa8595fc95f136f61b6df.1387288155.git.minovotn@redhat.com> +References: <527da6c2ce2c09d0183aa8595fc95f136f61b6df.1387288155.git.minovotn@redhat.com> +From: Stefan Hajnoczi +Date: Thu, 12 Dec 2013 16:21:28 +0100 +Subject: [PATCH 8/8] qtest: Use -display none by default +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +RH-Author: Stefan Hajnoczi +Message-id: <1386865288-1575-9-git-send-email-stefanha@redhat.com> +Patchwork-id: 56262 +O-Subject: [RHEL7 qemu-kvm PATCH 8/8] qtest: Use -display none by default +Bugzilla: 1003773 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Jeffrey Cody +RH-Acked-by: Markus Armbruster + +From: Andreas Färber + +This avoids each test needing to add it to suppress windows popping up. + +[Commit 7ceeedd016facf8d58e14a0d1417fa7225d71072 ("blockdev-test: add +test case for drive_add duplicate IDs") and commit +43cd209803d6cffb1e1a028c9ff2fd0ff4fce954 ("qdev-monitor-test: add +device_add leak test cases") added qtest tests without specifying +-display none. + +As a result, "make check" now tries to use graphics (GTK or SDL). Since +graphics are not used by the test and inappropriate for headless "make +check" runs, add the missing -display none. + +This fixes "make check" in the QEMU buildbot. +-- Stefan] + +Signed-off-by: Andreas Färber +Signed-off-by: Stefan Hajnoczi +(cherry picked from commit 2ad645d2854746b55ddfd1d8e951f689cca5d78f) +Signed-off-by: Stefan Hajnoczi + +Conflicts: + tests/boot-order-test.c + tests/endianness-test.c + tests/qom-test.c + +qom-test.c and endianness-test.c do not exist in RHEL. + +boot-order-test.c is slightly older but the conflict is simple to +resolve. +--- + tests/boot-order-test.c | 2 +- + tests/fw_cfg-test.c | 3 +-- + tests/hd-geo-test.c | 2 +- + tests/i440fx-test.c | 2 +- + tests/libqtest.c | 1 + + tests/m48t59-test.c | 2 +- + tests/rtc-test.c | 2 +- + tests/tmp105-test.c | 2 +- + 8 files changed, 8 insertions(+), 8 deletions(-) + +Signed-off-by: Michal Novotny +--- + tests/boot-order-test.c | 2 +- + tests/fw_cfg-test.c | 3 +-- + tests/hd-geo-test.c | 2 +- + tests/i440fx-test.c | 2 +- + tests/libqtest.c | 1 + + tests/m48t59-test.c | 2 +- + tests/rtc-test.c | 2 +- + tests/tmp105-test.c | 2 +- + 8 files changed, 8 insertions(+), 8 deletions(-) + +diff --git a/tests/boot-order-test.c b/tests/boot-order-test.c +index a35e9f7..f386600 100644 +--- a/tests/boot-order-test.c ++++ b/tests/boot-order-test.c +@@ -32,7 +32,7 @@ static void test_pc_with_args(const char *test_args, + uint8_t boot1, uint8_t boot2, + uint8_t reboot1, uint8_t reboot2) + { +- char *args = g_strdup_printf("-nodefaults -display none %s", test_args); ++ char *args = g_strdup_printf("-nodefaults %s", test_args); + + qtest_start(args); + test_pc_cmos(boot1, boot2); +diff --git a/tests/fw_cfg-test.c b/tests/fw_cfg-test.c +index c284c4d..3428dca 100644 +--- a/tests/fw_cfg-test.c ++++ b/tests/fw_cfg-test.c +@@ -126,8 +126,7 @@ int main(int argc, char **argv) + g_test_add_func("/fw_cfg/numa", test_fw_cfg_numa); + g_test_add_func("/fw_cfg/boot_menu", test_fw_cfg_boot_menu); + +- cmdline = g_strdup_printf("-display none " +- "-uuid 4600cb32-38ec-4b2f-8acb-81c6ea54f2d8 "); ++ cmdline = g_strdup_printf("-uuid 4600cb32-38ec-4b2f-8acb-81c6ea54f2d8 "); + s = qtest_start(cmdline); + g_free(cmdline); + +diff --git a/tests/hd-geo-test.c b/tests/hd-geo-test.c +index b72042e..c84d1e7 100644 +--- a/tests/hd-geo-test.c ++++ b/tests/hd-geo-test.c +@@ -171,7 +171,7 @@ static int setup_common(char *argv[], int argv_sz) + { + memset(cur_ide, 0, sizeof(cur_ide)); + return append_arg(0, argv, argv_sz, +- g_strdup("-nodefaults -display none")); ++ g_strdup("-nodefaults")); + } + + static void setup_mbr(int img_idx, MBRcontents mbr) +diff --git a/tests/i440fx-test.c b/tests/i440fx-test.c +index 08ce820..65c786c 100644 +--- a/tests/i440fx-test.c ++++ b/tests/i440fx-test.c +@@ -265,7 +265,7 @@ int main(int argc, char **argv) + + data.num_cpus = 1; + +- cmdline = g_strdup_printf("-display none -smp %d", data.num_cpus); ++ cmdline = g_strdup_printf("-smp %d", data.num_cpus); + s = qtest_start(cmdline); + g_free(cmdline); + +diff --git a/tests/libqtest.c b/tests/libqtest.c +index 83424c3..359d571 100644 +--- a/tests/libqtest.c ++++ b/tests/libqtest.c +@@ -135,6 +135,7 @@ QTestState *qtest_init(const char *extra_args) + "-qmp unix:%s,nowait " + "-pidfile %s " + "-machine accel=qtest " ++ "-display none " + "%s", qemu_binary, s->socket_path, + s->qmp_socket_path, pid_file, + extra_args ?: ""); +diff --git a/tests/m48t59-test.c b/tests/m48t59-test.c +index 4081a5f..6abc4c8 100644 +--- a/tests/m48t59-test.c ++++ b/tests/m48t59-test.c +@@ -249,7 +249,7 @@ int main(int argc, char **argv) + + g_test_init(&argc, &argv, NULL); + +- s = qtest_start("-display none -rtc clock=vm"); ++ s = qtest_start("-rtc clock=vm"); + + qtest_add_func("/rtc/bcd/check-time", bcd_check_time); + qtest_add_func("/rtc/fuzz-registers", fuzz_registers); +diff --git a/tests/rtc-test.c b/tests/rtc-test.c +index 3395d7f..f1b123f 100644 +--- a/tests/rtc-test.c ++++ b/tests/rtc-test.c +@@ -552,7 +552,7 @@ int main(int argc, char **argv) + + g_test_init(&argc, &argv, NULL); + +- s = qtest_start("-display none -rtc clock=vm"); ++ s = qtest_start("-rtc clock=vm"); + qtest_irq_intercept_in(s, "ioapic"); + + qtest_add_func("/rtc/check-time/bcd", bcd_check_time); +diff --git a/tests/tmp105-test.c b/tests/tmp105-test.c +index fecd6dc..5ac48e2 100644 +--- a/tests/tmp105-test.c ++++ b/tests/tmp105-test.c +@@ -59,7 +59,7 @@ int main(int argc, char **argv) + + g_test_init(&argc, &argv, NULL); + +- s = qtest_start("-display none -machine n800"); ++ s = qtest_start("-machine n800"); + i2c = omap_i2c_create(OMAP2_I2C_1_BASE); + addr = N8X0_ADDR; + +-- +1.7.11.7 + diff --git a/SOURCES/kvm-qxl-add-sanity-check.patch b/SOURCES/kvm-qxl-add-sanity-check.patch new file mode 100644 index 0000000..010e307 --- /dev/null +++ b/SOURCES/kvm-qxl-add-sanity-check.patch @@ -0,0 +1,55 @@ +From c5e26182fedef98b73f50e9fac3ae09696e59880 Mon Sep 17 00:00:00 2001 +From: Gerd Hoffmann +Date: Wed, 26 Feb 2014 11:44:47 +0100 +Subject: [PATCH 2/6] qxl: add sanity check + +RH-Author: Gerd Hoffmann +Message-id: <1393415087-3776-2-git-send-email-kraxel@redhat.com> +Patchwork-id: 57815 +O-Subject: [RHEL-7 qemu-kvm PATCH 1/1] qxl: add sanity check +Bugzilla: 751937 +RH-Acked-by: Laszlo Ersek +RH-Acked-by: Dr. David Alan Gilbert (git) +RH-Acked-by: Paolo Bonzini + +Signed-off-by: Gerd Hoffmann +Reviewed-by: Laszlo Ersek +(cherry picked from commit 9c70434f825fd0d2e89d1aa0f872159378d0aab3) +--- + hw/display/qxl.c | 8 +++++++- + 1 file changed, 7 insertions(+), 1 deletion(-) + +Signed-off-by: Miroslav Rezanina +--- + hw/display/qxl.c | 8 +++++++- + 1 files changed, 7 insertions(+), 1 deletions(-) + +diff --git a/hw/display/qxl.c b/hw/display/qxl.c +index 4381d97..4fe4f1b 100644 +--- a/hw/display/qxl.c ++++ b/hw/display/qxl.c +@@ -1417,7 +1417,7 @@ static int qxl_destroy_primary(PCIQXLDevice *d, qxl_async_io async) + return 1; + } + +-static void qxl_set_mode(PCIQXLDevice *d, int modenr, int loadvm) ++static void qxl_set_mode(PCIQXLDevice *d, unsigned int modenr, int loadvm) + { + pcibus_t start = d->pci.io_regions[QXL_RAM_RANGE_INDEX].addr; + pcibus_t end = d->pci.io_regions[QXL_RAM_RANGE_INDEX].size + start; +@@ -1427,6 +1427,12 @@ static void qxl_set_mode(PCIQXLDevice *d, int modenr, int loadvm) + .mem_start = start, + .mem_end = end + }; ++ ++ if (modenr >= d->modes->n_modes) { ++ qxl_set_guest_bug(d, "mode number out of range"); ++ return; ++ } ++ + QXLSurfaceCreate surface = { + .width = mode->x_res, + .height = mode->y_res, +-- +1.7.1 + diff --git a/SOURCES/kvm-qxl-replace-pipe-signaling-with-bottom-half.patch b/SOURCES/kvm-qxl-replace-pipe-signaling-with-bottom-half.patch new file mode 100644 index 0000000..d9c50a0 --- /dev/null +++ b/SOURCES/kvm-qxl-replace-pipe-signaling-with-bottom-half.patch @@ -0,0 +1,108 @@ +From bf9b8d36996ecbe78f1561404a355af6f7c5d4f6 Mon Sep 17 00:00:00 2001 +From: Gerd Hoffmann +Date: Tue, 21 Jan 2014 11:25:17 -0500 +Subject: [PATCH 6/6] qxl: replace pipe signaling with bottom half + +Message-id: <1390303517-20167-3-git-send-email-kraxel@redhat.com> +Patchwork-id: 56865 +O-Subject: [RHEL-7 qemu-kvm PATCH 2/2] qxl: replace pipe signaling with bottom half +Bugzilla: 1009297 +RH-Acked-by: Laszlo Ersek +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Miroslav Rezanina + +qxl creates a pipe, then writes something to it to wake up the iothread +from the spice server thread to raise an irq. These days qemu bottom +halves can be scheduled from threads and signals, so there is no reason +to do this any more. Time to clean it up. + +Signed-off-by: Gerd Hoffmann +(cherry picked from commit 4a46c99c8118586f19894fe66fc6e353f159d4d9) +--- + hw/display/qxl.c | 33 +++------------------------------ + hw/display/qxl.h | 3 +-- + 2 files changed, 4 insertions(+), 32 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + hw/display/qxl.c | 33 +++------------------------------ + hw/display/qxl.h | 3 +-- + 2 files changed, 4 insertions(+), 32 deletions(-) + +diff --git a/hw/display/qxl.c b/hw/display/qxl.c +index 830b3c5..4381d97 100644 +--- a/hw/display/qxl.c ++++ b/hw/display/qxl.c +@@ -1702,15 +1702,9 @@ static const MemoryRegionOps qxl_io_ops = { + }, + }; + +-static void pipe_read(void *opaque) ++static void qxl_update_irq_bh(void *opaque) + { + PCIQXLDevice *d = opaque; +- char dummy; +- int len; +- +- do { +- len = read(d->pipe[0], &dummy, sizeof(dummy)); +- } while (len == sizeof(dummy)); + qxl_update_irq(d); + } + +@@ -1731,28 +1725,7 @@ static void qxl_send_events(PCIQXLDevice *d, uint32_t events) + if ((old_pending & le_events) == le_events) { + return; + } +- if (qemu_thread_is_self(&d->main)) { +- qxl_update_irq(d); +- } else { +- if (write(d->pipe[1], d, 1) != 1) { +- dprint(d, 1, "%s: write to pipe failed\n", __func__); +- } +- } +-} +- +-static void init_pipe_signaling(PCIQXLDevice *d) +-{ +- if (pipe(d->pipe) < 0) { +- fprintf(stderr, "%s:%s: qxl pipe creation failed\n", +- __FILE__, __func__); +- exit(1); +- } +- fcntl(d->pipe[0], F_SETFL, O_NONBLOCK); +- fcntl(d->pipe[1], F_SETFL, O_NONBLOCK); +- fcntl(d->pipe[0], F_SETOWN, getpid()); +- +- qemu_thread_get_self(&d->main); +- qemu_set_fd_handler(d->pipe[0], pipe_read, NULL, d); ++ qemu_bh_schedule(d->update_irq); + } + + /* graphics console */ +@@ -2044,7 +2017,7 @@ static int qxl_init_common(PCIQXLDevice *qxl) + } + qemu_add_vm_change_state_handler(qxl_vm_change_state_handler, qxl); + +- init_pipe_signaling(qxl); ++ qxl->update_irq = qemu_bh_new(qxl_update_irq_bh, qxl); + qxl_reset_state(qxl); + + qxl->update_area_bh = qemu_bh_new(qxl_render_update_area_bh, qxl); +diff --git a/hw/display/qxl.h b/hw/display/qxl.h +index 8e9b0c2..5da33e2 100644 +--- a/hw/display/qxl.h ++++ b/hw/display/qxl.h +@@ -78,8 +78,7 @@ typedef struct PCIQXLDevice { + QemuMutex track_lock; + + /* thread signaling */ +- QemuThread main; +- int pipe[2]; ++ QEMUBH *update_irq; + + /* ram pci bar */ + QXLRam *ram; +-- +1.8.3.1 + diff --git a/SOURCES/kvm-ram-split-function-that-synchronizes-a-range.patch b/SOURCES/kvm-ram-split-function-that-synchronizes-a-range.patch new file mode 100644 index 0000000..9ea39ed --- /dev/null +++ b/SOURCES/kvm-ram-split-function-that-synchronizes-a-range.patch @@ -0,0 +1,98 @@ +From 14eb19d20c600001321edcc664614b9f5f2bb758 Mon Sep 17 00:00:00 2001 +From: Juan Quintela +Date: Tue, 14 Jan 2014 15:07:50 +0100 +Subject: [PATCH 39/40] ram: split function that synchronizes a range + +RH-Author: Juan Quintela +Message-id: <1389712071-23303-40-git-send-email-quintela@redhat.com> +Patchwork-id: 56694 +O-Subject: [RHEL7 qemu-kvm PATCH 39/40] ram: split function that synchronizes a range +Bugzilla: 997559 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Orit Wasserman +RH-Acked-by: Dr. David Alan Gilbert (git) + +This function is the only bit where we care about speed. + +Signed-off-by: Juan Quintela +Reviewed-by: Orit Wasserman +(cherry picked from commit 791fa2a2451799232d6bc0c29c0fbb13b5293eeb) +Signed-off-by: Juan Quintela +--- + arch_init.c | 34 ++++++++++++++++++++-------------- + 1 file changed, 20 insertions(+), 14 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + arch_init.c | 34 ++++++++++++++++++++-------------- + 1 files changed, 20 insertions(+), 14 deletions(-) + +diff --git a/arch_init.c b/arch_init.c +index 41da357..23650e7 100644 +--- a/arch_init.c ++++ b/arch_init.c +@@ -360,11 +360,10 @@ ram_addr_t migration_bitmap_find_and_reset_dirty(MemoryRegion *mr, + return (next - base) << TARGET_PAGE_BITS; + } + +-static inline bool migration_bitmap_set_dirty(MemoryRegion *mr, +- ram_addr_t offset) ++static inline bool migration_bitmap_set_dirty(ram_addr_t addr) + { + bool ret; +- int nr = (mr->ram_addr + offset) >> TARGET_PAGE_BITS; ++ int nr = addr >> TARGET_PAGE_BITS; + + ret = test_and_set_bit(nr, migration_bitmap); + +@@ -374,12 +373,28 @@ static inline bool migration_bitmap_set_dirty(MemoryRegion *mr, + return ret; + } + ++static void migration_bitmap_sync_range(ram_addr_t start, ram_addr_t length) ++{ ++ ram_addr_t addr; ++ ++ for (addr = 0; addr < length; addr += TARGET_PAGE_SIZE) { ++ if (cpu_physical_memory_get_dirty(start + addr, ++ TARGET_PAGE_SIZE, ++ DIRTY_MEMORY_MIGRATION)) { ++ cpu_physical_memory_reset_dirty(start + addr, ++ TARGET_PAGE_SIZE, ++ DIRTY_MEMORY_MIGRATION); ++ migration_bitmap_set_dirty(start + addr); ++ } ++ } ++} ++ ++ + /* Needs iothread lock! */ + + static void migration_bitmap_sync(void) + { + RAMBlock *block; +- ram_addr_t addr; + uint64_t num_dirty_pages_init = migration_dirty_pages; + MigrationState *s = migrate_get_current(); + static int64_t start_time; +@@ -400,16 +415,7 @@ static void migration_bitmap_sync(void) + memory_global_sync_dirty_bitmap(get_system_memory()); + + QTAILQ_FOREACH(block, &ram_list.blocks, next) { +- for (addr = 0; addr < block->length; addr += TARGET_PAGE_SIZE) { +- if (cpu_physical_memory_get_dirty(block->mr->ram_addr + addr, +- TARGET_PAGE_SIZE, +- DIRTY_MEMORY_MIGRATION)) { +- cpu_physical_memory_reset_dirty(block->mr->ram_addr + addr, +- TARGET_PAGE_SIZE, +- DIRTY_MEMORY_MIGRATION); +- migration_bitmap_set_dirty(block->mr, addr); +- } +- } ++ migration_bitmap_sync_range(block->mr->ram_addr, block->length); + } + trace_migration_bitmap_sync_end(migration_dirty_pages + - num_dirty_pages_init); +-- +1.7.1 + diff --git a/SOURCES/kvm-range-add-Range-structure.patch b/SOURCES/kvm-range-add-Range-structure.patch new file mode 100644 index 0000000..c77aed6 --- /dev/null +++ b/SOURCES/kvm-range-add-Range-structure.patch @@ -0,0 +1,65 @@ +From 3ed0fb61a3dc912ef036d7ef450bed192090709e Mon Sep 17 00:00:00 2001 +Message-Id: <3ed0fb61a3dc912ef036d7ef450bed192090709e.1387298827.git.minovotn@redhat.com> +From: "Michael S. Tsirkin" +Date: Tue, 17 Dec 2013 15:16:49 +0100 +Subject: [PATCH 01/56] range: add Range structure + +RH-Author: Michael S. Tsirkin +Message-id: <1387293161-4085-2-git-send-email-mst@redhat.com> +Patchwork-id: 56306 +O-Subject: [PATCH qemu-kvm RHEL7.0 v2 01/57] range: add Range structure +Bugzilla: 1034876 +RH-Acked-by: Igor Mammedov +RH-Acked-by: Marcel Apfelbaum +RH-Acked-by: Laszlo Ersek + +Sometimes we need to pass ranges around, add a +handy structure for this purpose. + +Note: memory.c defines its own concept of AddrRange structure for +working with 128 addresses. It's necessary there for doing range math. +This is not needed for most users: struct Range is +much simpler, and is only used for passing the range around. + +Cc: Peter Maydell +Signed-off-by: Michael S. Tsirkin +(cherry picked from commit 620ac82eb0fc4218fb6a4937bcef3fdab3126703) +--- + include/qemu/range.h | 16 ++++++++++++++++ + 1 file changed, 16 insertions(+) + +Signed-off-by: Michal Novotny +--- + include/qemu/range.h | 16 ++++++++++++++++ + 1 file changed, 16 insertions(+) + +diff --git a/include/qemu/range.h b/include/qemu/range.h +index 3502372..b76cc0d 100644 +--- a/include/qemu/range.h ++++ b/include/qemu/range.h +@@ -1,6 +1,22 @@ + #ifndef QEMU_RANGE_H + #define QEMU_RANGE_H + ++#include ++ ++/* ++ * Operations on 64 bit address ranges. ++ * Notes: ++ * - ranges must not wrap around 0, but can include the last byte ~0x0LL. ++ * - this can not represent a full 0 to ~0x0LL range. ++ */ ++ ++/* A structure representing a range of addresses. */ ++struct Range { ++ uint64_t begin; /* First byte of the range, or 0 if empty. */ ++ uint64_t end; /* 1 + the last byte. 0 if range empty or ends at ~0x0LL. */ ++}; ++typedef struct Range Range; ++ + /* Get last byte of a range from offset + length. + * Undefined for ranges that wrap around 0. */ + static inline uint64_t range_get_last(uint64_t offset, uint64_t len) +-- +1.7.11.7 + diff --git a/SOURCES/kvm-range-add-Range-to-typedefs.patch b/SOURCES/kvm-range-add-Range-to-typedefs.patch new file mode 100644 index 0000000..aed9594 --- /dev/null +++ b/SOURCES/kvm-range-add-Range-to-typedefs.patch @@ -0,0 +1,66 @@ +From 46223e9568b32a876f4b4432adec3d21f44f0924 Mon Sep 17 00:00:00 2001 +Message-Id: <46223e9568b32a876f4b4432adec3d21f44f0924.1387298827.git.minovotn@redhat.com> +In-Reply-To: <3ed0fb61a3dc912ef036d7ef450bed192090709e.1387298827.git.minovotn@redhat.com> +References: <3ed0fb61a3dc912ef036d7ef450bed192090709e.1387298827.git.minovotn@redhat.com> +From: "Michael S. Tsirkin" +Date: Tue, 17 Dec 2013 15:16:52 +0100 +Subject: [PATCH 02/56] range: add Range to typedefs + +RH-Author: Michael S. Tsirkin +Message-id: <1387293161-4085-3-git-send-email-mst@redhat.com> +Patchwork-id: 56307 +O-Subject: [PATCH qemu-kvm RHEL7.0 v2 02/57] range: add Range to typedefs +Bugzilla: 1034876 +RH-Acked-by: Igor Mammedov +RH-Acked-by: Marcel Apfelbaum +RH-Acked-by: Laszlo Ersek + +will help simplify header dependencies. + +Signed-off-by: Michael S. Tsirkin +(cherry picked from commit cfe25e2bcada943984e27ee63918fd75dc4563ac) +--- + include/qemu/range.h | 2 +- + include/qemu/typedefs.h | 1 + + 2 files changed, 2 insertions(+), 1 deletion(-) + +Signed-off-by: Michal Novotny +--- + include/qemu/range.h | 2 +- + include/qemu/typedefs.h | 1 + + 2 files changed, 2 insertions(+), 1 deletion(-) + +diff --git a/include/qemu/range.h b/include/qemu/range.h +index b76cc0d..4a0780d 100644 +--- a/include/qemu/range.h ++++ b/include/qemu/range.h +@@ -2,6 +2,7 @@ + #define QEMU_RANGE_H + + #include ++#include + + /* + * Operations on 64 bit address ranges. +@@ -15,7 +16,6 @@ struct Range { + uint64_t begin; /* First byte of the range, or 0 if empty. */ + uint64_t end; /* 1 + the last byte. 0 if range empty or ends at ~0x0LL. */ + }; +-typedef struct Range Range; + + /* Get last byte of a range from offset + length. + * Undefined for ranges that wrap around 0. */ +diff --git a/include/qemu/typedefs.h b/include/qemu/typedefs.h +index 1218a61..2e7d942 100644 +--- a/include/qemu/typedefs.h ++++ b/include/qemu/typedefs.h +@@ -63,5 +63,6 @@ typedef struct EventNotifier EventNotifier; + typedef struct VirtIODevice VirtIODevice; + typedef struct QEMUSGList QEMUSGList; + typedef struct SHPCDevice SHPCDevice; ++typedef struct Range Range; + + #endif /* QEMU_TYPEDEFS_H */ +-- +1.7.11.7 + diff --git a/SOURCES/kvm-range-add-min-max-operations-on-ranges.patch b/SOURCES/kvm-range-add-min-max-operations-on-ranges.patch new file mode 100644 index 0000000..9698eda --- /dev/null +++ b/SOURCES/kvm-range-add-min-max-operations-on-ranges.patch @@ -0,0 +1,60 @@ +From 5b9d5a4f0e351dc73b31507b56334f7ef692f20c Mon Sep 17 00:00:00 2001 +Message-Id: <5b9d5a4f0e351dc73b31507b56334f7ef692f20c.1387298827.git.minovotn@redhat.com> +In-Reply-To: <3ed0fb61a3dc912ef036d7ef450bed192090709e.1387298827.git.minovotn@redhat.com> +References: <3ed0fb61a3dc912ef036d7ef450bed192090709e.1387298827.git.minovotn@redhat.com> +From: "Michael S. Tsirkin" +Date: Tue, 17 Dec 2013 15:16:55 +0100 +Subject: [PATCH 03/56] range: add min/max operations on ranges + +RH-Author: Michael S. Tsirkin +Message-id: <1387293161-4085-4-git-send-email-mst@redhat.com> +Patchwork-id: 56308 +O-Subject: [PATCH qemu-kvm RHEL7.0 v2 03/57] range: add min/max operations on ranges +Bugzilla: 1034876 +RH-Acked-by: Igor Mammedov +RH-Acked-by: Marcel Apfelbaum +RH-Acked-by: Laszlo Ersek + +Signed-off-by: Michael S. Tsirkin +(cherry picked from commit c5a22c4344f17169bb20e122e9d935c62aedc063) +--- + include/qemu/range.h | 18 ++++++++++++++++++ + 1 file changed, 18 insertions(+) + +Signed-off-by: Michal Novotny +--- + include/qemu/range.h | 18 ++++++++++++++++++ + 1 file changed, 18 insertions(+) + +diff --git a/include/qemu/range.h b/include/qemu/range.h +index 4a0780d..aae9720 100644 +--- a/include/qemu/range.h ++++ b/include/qemu/range.h +@@ -17,6 +17,24 @@ struct Range { + uint64_t end; /* 1 + the last byte. 0 if range empty or ends at ~0x0LL. */ + }; + ++static inline void range_extend(Range *range, Range *extend_by) ++{ ++ if (!extend_by->begin && !extend_by->end) { ++ return; ++ } ++ if (!range->begin && !range->end) { ++ *range = *extend_by; ++ return; ++ } ++ if (range->begin > extend_by->begin) { ++ range->begin = extend_by->begin; ++ } ++ /* Compare last byte in case region ends at ~0x0LL */ ++ if (range->end - 1 < extend_by->end - 1) { ++ range->end = extend_by->end; ++ } ++} ++ + /* Get last byte of a range from offset + length. + * Undefined for ranges that wrap around 0. */ + static inline uint64_t range_get_last(uint64_t offset, uint64_t len) +-- +1.7.11.7 + diff --git a/SOURCES/kvm-raw-Fix-BlockLimits-passthrough.patch b/SOURCES/kvm-raw-Fix-BlockLimits-passthrough.patch new file mode 100644 index 0000000..fa8911a --- /dev/null +++ b/SOURCES/kvm-raw-Fix-BlockLimits-passthrough.patch @@ -0,0 +1,75 @@ +From 524a3586abb4a10aa87f1b36518f6645caf586c8 Mon Sep 17 00:00:00 2001 +From: Kevin Wolf +Date: Tue, 4 Feb 2014 11:54:13 +0100 +Subject: [PATCH 03/37] raw: Fix BlockLimits passthrough + +Message-id: <1392117622-28812-4-git-send-email-kwolf@redhat.com> +Patchwork-id: 57168 +O-Subject: [RHEL-7.0 qemu-kvm PATCH v2 03/37] raw: Fix BlockLimits passthrough +Bugzilla: 748906 +RH-Acked-by: Laszlo Ersek +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Max Reitz + +raw copies over the BlockLimits of bs->file during bdrv_open(). +However, since commit d34682cd it is immediately overwritten during +bdrv_refresh_limits(). This caused all fields except for +opt_transfer_length and opt_mem_alignment (which happen to be correctly +inherited in generic code) to be zeroed. + +Move the BlockLimit assignment to a .bdrv_refresh_limits() callback to +make it work again for all fields. + +Reported-by: Laszlo Ersek +Signed-off-by: Kevin Wolf +Reviewed-by: Laszlo Ersek + +Conflicts: + block/raw_bsd.c + +Conflicts because RHEL 7 still has the old raw driver. + +Signed-off-by: Kevin Wolf +--- + block/raw.c | 8 +++++++- + 1 file changed, 7 insertions(+), 1 deletion(-) +--- + block/raw.c | 8 +++++++- + 1 files changed, 7 insertions(+), 1 deletions(-) + +diff --git a/block/raw.c b/block/raw.c +index c853258..eeadba5 100644 +--- a/block/raw.c ++++ b/block/raw.c +@@ -7,7 +7,6 @@ static int raw_open(BlockDriverState *bs, QDict *options, int flags, + Error **errp) + { + bs->sg = bs->file->sg; +- bs->bl = bs->file->bl; + return 0; + } + +@@ -59,6 +58,12 @@ static int64_t raw_getlength(BlockDriverState *bs) + return bdrv_getlength(bs->file); + } + ++static int raw_refresh_limits(BlockDriverState *bs) ++{ ++ bs->bl = bs->file->bl; ++ return 0; ++} ++ + static int raw_truncate(BlockDriverState *bs, int64_t offset) + { + return bdrv_truncate(bs->file, offset); +@@ -154,6 +159,7 @@ static BlockDriver bdrv_raw = { + .bdrv_probe = raw_probe, + .bdrv_getlength = raw_getlength, + .has_variable_length = true, ++ .bdrv_refresh_limits = raw_refresh_limits, + .bdrv_truncate = raw_truncate, + + .bdrv_is_inserted = raw_is_inserted, +-- +1.7.1 + diff --git a/SOURCES/kvm-raw-Probe-required-direct-I-O-alignment.patch b/SOURCES/kvm-raw-Probe-required-direct-I-O-alignment.patch new file mode 100644 index 0000000..8eaab77 --- /dev/null +++ b/SOURCES/kvm-raw-Probe-required-direct-I-O-alignment.patch @@ -0,0 +1,316 @@ +From de29d97cab7b97d776cbb1077079eff0bfc46186 Mon Sep 17 00:00:00 2001 +From: Kevin Wolf +Date: Tue, 29 Nov 2011 12:42:20 +0100 +Subject: [PATCH 10/37] raw: Probe required direct I/O alignment + +Message-id: <1392117622-28812-11-git-send-email-kwolf@redhat.com> +Patchwork-id: 57175 +O-Subject: [RHEL-7.0 qemu-kvm PATCH v2 10/37] raw: Probe required direct I/O alignment +Bugzilla: 748906 +RH-Acked-by: Laszlo Ersek +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Max Reitz + +From: Paolo Bonzini + +Add a bs->request_alignment field that contains the required +offset/length alignment for I/O requests and fill it in the raw block +drivers. Use ioctls if possible, else see what alignment it takes for +O_DIRECT to succeed. + +While at it, also expose the memory alignment requirements, which may be +(and in practice are) different from the disk alignment requirements. + +Signed-off-by: Paolo Bonzini +Signed-off-by: Kevin Wolf +Reviewed-by: Max Reitz +(cherry picked from commit c25f53b06eba1575d5d0e92a0132455c97825b83) + +Signed-off-by: Kevin Wolf +--- + block.c | 3 ++ + block/raw-posix.c | 102 ++++++++++++++++++++++++++++++++++++++-------- + block/raw-win32.c | 41 +++++++++++++++++++ + include/block/block_int.h | 3 ++ + 4 files changed, 132 insertions(+), 17 deletions(-) +--- + block.c | 3 + + block/raw-posix.c | 102 +++++++++++++++++++++++++++++++++++++------- + block/raw-win32.c | 41 ++++++++++++++++++ + include/block/block_int.h | 3 + + 4 files changed, 132 insertions(+), 17 deletions(-) + +diff --git a/block.c b/block.c +index f2102bc..40a4a34 100644 +--- a/block.c ++++ b/block.c +@@ -780,6 +780,7 @@ static int bdrv_open_common(BlockDriverState *bs, BlockDriverState *file, + + bs->open_flags = flags; + bs->guest_block_size = 512; ++ bs->request_alignment = 512; + bs->zero_beyond_eof = true; + open_flags = bdrv_open_flags(bs, flags); + bs->read_only = !(open_flags & BDRV_O_RDWR); +@@ -845,6 +846,8 @@ static int bdrv_open_common(BlockDriverState *bs, BlockDriverState *file, + } + + bdrv_refresh_limits(bs); ++ assert(bdrv_opt_mem_align(bs) != 0); ++ assert(bs->request_alignment != 0); + + #ifndef _WIN32 + if (bs->is_temporary) { +diff --git a/block/raw-posix.c b/block/raw-posix.c +index f410668..9ee5b8e 100644 +--- a/block/raw-posix.c ++++ b/block/raw-posix.c +@@ -127,6 +127,8 @@ typedef struct BDRVRawState { + int fd; + int type; + int open_flags; ++ size_t buf_align; ++ + #if defined(__linux__) + /* linux floppy specific */ + int64_t fd_open_time; +@@ -213,6 +215,76 @@ static int raw_normalize_devicepath(const char **filename) + } + #endif + ++static void raw_probe_alignment(BlockDriverState *bs) ++{ ++ BDRVRawState *s = bs->opaque; ++ char *buf; ++ unsigned int sector_size; ++ ++ /* For /dev/sg devices the alignment is not really used. ++ With buffered I/O, we don't have any restrictions. */ ++ if (bs->sg || !(s->open_flags & O_DIRECT)) { ++ bs->request_alignment = 1; ++ s->buf_align = 1; ++ return; ++ } ++ ++ /* Try a few ioctls to get the right size */ ++ bs->request_alignment = 0; ++ s->buf_align = 0; ++ ++#ifdef BLKSSZGET ++ if (ioctl(s->fd, BLKSSZGET, §or_size) >= 0) { ++ bs->request_alignment = sector_size; ++ } ++#endif ++#ifdef DKIOCGETBLOCKSIZE ++ if (ioctl(s->fd, DKIOCGETBLOCKSIZE, §or_size) >= 0) { ++ bs->request_alignment = sector_size; ++ } ++#endif ++#ifdef DIOCGSECTORSIZE ++ if (ioctl(s->fd, DIOCGSECTORSIZE, §or_size) >= 0) { ++ bs->request_alignment = sector_size; ++ } ++#endif ++#ifdef CONFIG_XFS ++ if (s->is_xfs) { ++ struct dioattr da; ++ if (xfsctl(NULL, s->fd, XFS_IOC_DIOINFO, &da) >= 0) { ++ bs->request_alignment = da.d_miniosz; ++ /* The kernel returns wrong information for d_mem */ ++ /* s->buf_align = da.d_mem; */ ++ } ++ } ++#endif ++ ++ /* If we could not get the sizes so far, we can only guess them */ ++ if (!s->buf_align) { ++ size_t align; ++ buf = qemu_memalign(MAX_BLOCKSIZE, 2 * MAX_BLOCKSIZE); ++ for (align = 512; align <= MAX_BLOCKSIZE; align <<= 1) { ++ if (pread(s->fd, buf + align, MAX_BLOCKSIZE, 0) >= 0) { ++ s->buf_align = align; ++ break; ++ } ++ } ++ qemu_vfree(buf); ++ } ++ ++ if (!bs->request_alignment) { ++ size_t align; ++ buf = qemu_memalign(s->buf_align, MAX_BLOCKSIZE); ++ for (align = 512; align <= MAX_BLOCKSIZE; align <<= 1) { ++ if (pread(s->fd, buf, align, 0) >= 0) { ++ bs->request_alignment = align; ++ break; ++ } ++ } ++ qemu_vfree(buf); ++ } ++} ++ + static void raw_parse_flags(int bdrv_flags, int *open_flags) + { + assert(open_flags != NULL); +@@ -464,7 +536,6 @@ static int raw_reopen_prepare(BDRVReopenState *state, + return ret; + } + +- + static void raw_reopen_commit(BDRVReopenState *state) + { + BDRVRawReopenState *raw_s = state->opaque; +@@ -500,23 +571,15 @@ static void raw_reopen_abort(BDRVReopenState *state) + state->opaque = NULL; + } + ++static int raw_refresh_limits(BlockDriverState *bs) ++{ ++ BDRVRawState *s = bs->opaque; + +-/* XXX: use host sector size if necessary with: +-#ifdef DIOCGSECTORSIZE +- { +- unsigned int sectorsize = 512; +- if (!ioctl(fd, DIOCGSECTORSIZE, §orsize) && +- sectorsize > bufsize) +- bufsize = sectorsize; +- } +-#endif +-#ifdef CONFIG_COCOA +- uint32_t blockSize = 512; +- if ( !ioctl( fd, DKIOCGETBLOCKSIZE, &blockSize ) && blockSize > bufsize) { +- bufsize = blockSize; +- } +-#endif +-*/ ++ raw_probe_alignment(bs); ++ bs->bl.opt_mem_alignment = s->buf_align; ++ ++ return 0; ++} + + static ssize_t handle_aiocb_ioctl(RawPosixAIOData *aiocb) + { +@@ -1363,6 +1426,7 @@ static BlockDriver bdrv_file = { + .bdrv_aio_writev = raw_aio_writev, + .bdrv_aio_flush = raw_aio_flush, + .bdrv_aio_discard = raw_aio_discard, ++ .bdrv_refresh_limits = raw_refresh_limits, + + .bdrv_truncate = raw_truncate, + .bdrv_getlength = raw_getlength, +@@ -1739,6 +1803,7 @@ static BlockDriver bdrv_host_device = { + .bdrv_aio_writev = raw_aio_writev, + .bdrv_aio_flush = raw_aio_flush, + .bdrv_aio_discard = hdev_aio_discard, ++ .bdrv_refresh_limits = raw_refresh_limits, + + .bdrv_truncate = raw_truncate, + .bdrv_getlength = raw_getlength, +@@ -1869,6 +1934,7 @@ static BlockDriver bdrv_host_floppy = { + .bdrv_aio_readv = raw_aio_readv, + .bdrv_aio_writev = raw_aio_writev, + .bdrv_aio_flush = raw_aio_flush, ++ .bdrv_refresh_limits = raw_refresh_limits, + + .bdrv_truncate = raw_truncate, + .bdrv_getlength = raw_getlength, +@@ -1978,6 +2044,7 @@ static BlockDriver bdrv_host_cdrom = { + .bdrv_aio_readv = raw_aio_readv, + .bdrv_aio_writev = raw_aio_writev, + .bdrv_aio_flush = raw_aio_flush, ++ .bdrv_refresh_limits = raw_refresh_limits, + + .bdrv_truncate = raw_truncate, + .bdrv_getlength = raw_getlength, +@@ -2105,6 +2172,7 @@ static BlockDriver bdrv_host_cdrom = { + .bdrv_aio_readv = raw_aio_readv, + .bdrv_aio_writev = raw_aio_writev, + .bdrv_aio_flush = raw_aio_flush, ++ .bdrv_refresh_limits = raw_refresh_limits, + + .bdrv_truncate = raw_truncate, + .bdrv_getlength = raw_getlength, +diff --git a/block/raw-win32.c b/block/raw-win32.c +index 6ac3797..ac20370 100644 +--- a/block/raw-win32.c ++++ b/block/raw-win32.c +@@ -201,6 +201,35 @@ static int set_sparse(int fd) + NULL, 0, NULL, 0, &returned, NULL); + } + ++static void raw_probe_alignment(BlockDriverState *bs) ++{ ++ BDRVRawState *s = bs->opaque; ++ DWORD sectorsPerCluster, freeClusters, totalClusters, count; ++ DISK_GEOMETRY_EX dg; ++ BOOL status; ++ ++ if (s->type == FTYPE_CD) { ++ bs->request_alignment = 2048; ++ return; ++ } ++ if (s->type == FTYPE_HARDDISK) { ++ status = DeviceIoControl(s->hfile, IOCTL_DISK_GET_DRIVE_GEOMETRY_EX, ++ NULL, 0, &dg, sizeof(dg), &count, NULL); ++ if (status != 0) { ++ bs->request_alignment = dg.Geometry.BytesPerSector; ++ return; ++ } ++ /* try GetDiskFreeSpace too */ ++ } ++ ++ if (s->drive_path[0]) { ++ GetDiskFreeSpace(s->drive_path, §orsPerCluster, ++ &dg.Geometry.BytesPerSector, ++ &freeClusters, &totalClusters); ++ bs->request_alignment = dg.Geometry.BytesPerSector; ++ } ++} ++ + static void raw_parse_flags(int flags, int *access_flags, DWORD *overlapped) + { + assert(access_flags != NULL); +@@ -268,6 +297,17 @@ static int raw_open(BlockDriverState *bs, QDict *options, int flags, + } + } + ++ if (filename[0] && filename[1] == ':') { ++ snprintf(s->drive_path, sizeof(s->drive_path), "%c:\\", filename[0]); ++ } else if (filename[0] == '\\' && filename[1] == '\\') { ++ s->drive_path[0] = 0; ++ } else { ++ /* Relative path. */ ++ char buf[MAX_PATH]; ++ GetCurrentDirectory(MAX_PATH, buf); ++ snprintf(s->drive_path, sizeof(s->drive_path), "%c:\\", buf[0]); ++ } ++ + s->hfile = CreateFile(filename, access_flags, + FILE_SHARE_READ, NULL, + OPEN_EXISTING, overlapped, NULL); +@@ -293,6 +333,7 @@ static int raw_open(BlockDriverState *bs, QDict *options, int flags, + s->aio = aio; + } + ++ raw_probe_alignment(bs); + ret = 0; + fail: + qemu_opts_del(opts); +diff --git a/include/block/block_int.h b/include/block/block_int.h +index 0445e6b..e66bd5f 100644 +--- a/include/block/block_int.h ++++ b/include/block/block_int.h +@@ -307,6 +307,9 @@ struct BlockDriverState { + /* Whether produces zeros when read beyond eof */ + bool zero_beyond_eof; + ++ /* Alignment requirement for offset/length of I/O requests */ ++ unsigned int request_alignment; ++ + /* the block size for which the guest device expects atomicity */ + int guest_block_size; + +-- +1.7.1 + diff --git a/SOURCES/kvm-raw-posix-add-support-for-write_zeroes-on-XFS-and-bl.patch.patch b/SOURCES/kvm-raw-posix-add-support-for-write_zeroes-on-XFS-and-bl.patch.patch new file mode 100644 index 0000000..6059b8c --- /dev/null +++ b/SOURCES/kvm-raw-posix-add-support-for-write_zeroes-on-XFS-and-bl.patch.patch @@ -0,0 +1,225 @@ +From adf32529b8b95ed360356f13bd9a7f2a4b707412 Mon Sep 17 00:00:00 2001 +Message-Id: +In-Reply-To: +References: +From: Paolo Bonzini +Date: Mon, 9 Dec 2013 14:09:29 +0100 +Subject: [PATCH 41/50] raw-posix: add support for write_zeroes on XFS and + block devices + +RH-Author: Paolo Bonzini +Message-id: <1386598178-11845-44-git-send-email-pbonzini@redhat.com> +Patchwork-id: 56080 +O-Subject: [RHEL 7.0 qemu-kvm PATCH 43/52] raw-posix: add support for write_zeroes on XFS and block devices +Bugzilla: 1007815 +RH-Acked-by: Jeffrey Cody +RH-Acked-by: Fam Zheng +RH-Acked-by: Stefan Hajnoczi + +The code is similar to the implementation of discard and write_zeroes +with UNMAP. However, failure must be propagated up to block.c. + +The stale page cache problem can be reproduced as follows: + + # modprobe scsi-debug lbpws=1 lbprz=1 + # ./qemu-io /dev/sdXX + qemu-io> write -P 0xcc 0 2M + qemu-io> write -z 0 1M + qemu-io> read -P 0x00 0 512 + Pattern verification failed at offset 0, 512 bytes + qemu-io> read -v 0 512 + 00000000: cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc ................ + ... + + # ./qemu-io --cache=none /dev/sdXX + qemu-io> write -P 0xcc 0 2M + qemu-io> write -z 0 1M + qemu-io> read -P 0x00 0 512 + qemu-io> read -v 0 512 + 00000000: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................ + ... + +And similarly with discard instead of "write -z". + +Signed-off-by: Paolo Bonzini +Signed-off-by: Stefan Hajnoczi +(cherry picked from commit 97a2ae34537882df34810d538ab1f51085499d2c) +--- + block/raw-aio.h | 3 +- + block/raw-posix.c | 84 +++++++++++++++++++++++++++++++++++++++++++++++-------- + 2 files changed, 74 insertions(+), 13 deletions(-) + +Signed-off-by: Michal Novotny +--- + block/raw-aio.h | 3 +- + block/raw-posix.c | 84 +++++++++++++++++++++++++++++++++++++++++++++++-------- + 2 files changed, 74 insertions(+), 13 deletions(-) + +diff --git a/block/raw-aio.h b/block/raw-aio.h +index c61f159..7ad0a8a 100644 +--- a/block/raw-aio.h ++++ b/block/raw-aio.h +@@ -21,9 +21,10 @@ + #define QEMU_AIO_IOCTL 0x0004 + #define QEMU_AIO_FLUSH 0x0008 + #define QEMU_AIO_DISCARD 0x0010 ++#define QEMU_AIO_WRITE_ZEROES 0x0020 + #define QEMU_AIO_TYPE_MASK \ + (QEMU_AIO_READ|QEMU_AIO_WRITE|QEMU_AIO_IOCTL|QEMU_AIO_FLUSH| \ +- QEMU_AIO_DISCARD) ++ QEMU_AIO_DISCARD|QEMU_AIO_WRITE_ZEROES) + + /* AIO flags */ + #define QEMU_AIO_MISALIGNED 0x1000 +diff --git a/block/raw-posix.c b/block/raw-posix.c +index 815a80b..f410668 100644 +--- a/block/raw-posix.c ++++ b/block/raw-posix.c +@@ -142,6 +142,7 @@ typedef struct BDRVRawState { + bool is_xfs:1; + #endif + bool has_discard:1; ++ bool has_write_zeroes:1; + bool discard_zeroes:1; + } BDRVRawState; + +@@ -327,6 +328,7 @@ static int raw_open_common(BlockDriverState *bs, QDict *options, + #endif + + s->has_discard = true; ++ s->has_write_zeroes = true; + + if (fstat(s->fd, &st) < 0) { + error_setg_errno(errp, errno, "Could not stat file"); +@@ -345,9 +347,11 @@ static int raw_open_common(BlockDriverState *bs, QDict *options, + #ifdef __linux__ + /* On Linux 3.10, BLKDISCARD leaves stale data in the page cache. Do + * not rely on the contents of discarded blocks unless using O_DIRECT. ++ * Same for BLKZEROOUT. + */ + if (!(bs->open_flags & BDRV_O_NOCACHE)) { + s->discard_zeroes = false; ++ s->has_write_zeroes = false; + } + #endif + } +@@ -703,6 +707,23 @@ static ssize_t handle_aiocb_rw(RawPosixAIOData *aiocb) + } + + #ifdef CONFIG_XFS ++static int xfs_write_zeroes(BDRVRawState *s, int64_t offset, uint64_t bytes) ++{ ++ struct xfs_flock64 fl; ++ ++ memset(&fl, 0, sizeof(fl)); ++ fl.l_whence = SEEK_SET; ++ fl.l_start = offset; ++ fl.l_len = bytes; ++ ++ if (xfsctl(NULL, s->fd, XFS_IOC_ZERO_RANGE, &fl) < 0) { ++ DEBUG_BLOCK_PRINT("cannot write zero range (%s)\n", strerror(errno)); ++ return -errno; ++ } ++ ++ return 0; ++} ++ + static int xfs_discard(BDRVRawState *s, int64_t offset, uint64_t bytes) + { + struct xfs_flock64 fl; +@@ -721,6 +742,42 @@ static int xfs_discard(BDRVRawState *s, int64_t offset, uint64_t bytes) + } + #endif + ++static ssize_t handle_aiocb_write_zeroes(RawPosixAIOData *aiocb) ++{ ++ int ret = -EOPNOTSUPP; ++ BDRVRawState *s = aiocb->bs->opaque; ++ ++ if (s->has_write_zeroes == 0) { ++ return -ENOTSUP; ++ } ++ ++ if (aiocb->aio_type & QEMU_AIO_BLKDEV) { ++#ifdef BLKZEROOUT ++ do { ++ uint64_t range[2] = { aiocb->aio_offset, aiocb->aio_nbytes }; ++ if (ioctl(aiocb->aio_fildes, BLKZEROOUT, range) == 0) { ++ return 0; ++ } ++ } while (errno == EINTR); ++ ++ ret = -errno; ++#endif ++ } else { ++#ifdef CONFIG_XFS ++ if (s->is_xfs) { ++ return xfs_write_zeroes(s, aiocb->aio_offset, aiocb->aio_nbytes); ++ } ++#endif ++ } ++ ++ if (ret == -ENODEV || ret == -ENOSYS || ret == -EOPNOTSUPP || ++ ret == -ENOTTY) { ++ s->has_write_zeroes = false; ++ ret = -ENOTSUP; ++ } ++ return ret; ++} ++ + static ssize_t handle_aiocb_discard(RawPosixAIOData *aiocb) + { + int ret = -EOPNOTSUPP; +@@ -805,6 +862,9 @@ static int aio_worker(void *arg) + case QEMU_AIO_DISCARD: + ret = handle_aiocb_discard(aiocb); + break; ++ case QEMU_AIO_WRITE_ZEROES: ++ ret = handle_aiocb_write_zeroes(aiocb); ++ break; + default: + fprintf(stderr, "invalid aio request (0x%x)\n", aiocb->aio_type); + ret = -EINVAL; +@@ -1257,13 +1317,13 @@ static int coroutine_fn raw_co_write_zeroes( + BDRVRawState *s = bs->opaque; + + if (!(flags & BDRV_REQ_MAY_UNMAP)) { +- return -ENOTSUP; +- } +- if (!s->discard_zeroes) { +- return -ENOTSUP; ++ return paio_submit_co(bs, s->fd, sector_num, NULL, nb_sectors, ++ QEMU_AIO_WRITE_ZEROES); ++ } else if (s->discard_zeroes) { ++ return paio_submit_co(bs, s->fd, sector_num, NULL, nb_sectors, ++ QEMU_AIO_DISCARD); + } +- return paio_submit_co(bs, s->fd, sector_num, NULL, nb_sectors, +- QEMU_AIO_DISCARD); ++ return -ENOTSUP; + } + + static int raw_get_info(BlockDriverState *bs, BlockDriverInfo *bdi) +@@ -1613,13 +1673,13 @@ static coroutine_fn int hdev_co_write_zeroes(BlockDriverState *bs, + return rc; + } + if (!(flags & BDRV_REQ_MAY_UNMAP)) { +- return -ENOTSUP; +- } +- if (!s->discard_zeroes) { +- return -ENOTSUP; ++ return paio_submit_co(bs, s->fd, sector_num, NULL, nb_sectors, ++ QEMU_AIO_WRITE_ZEROES|QEMU_AIO_BLKDEV); ++ } else if (s->discard_zeroes) { ++ return paio_submit_co(bs, s->fd, sector_num, NULL, nb_sectors, ++ QEMU_AIO_DISCARD|QEMU_AIO_BLKDEV); + } +- return paio_submit_co(bs, s->fd, sector_num, NULL, nb_sectors, +- QEMU_AIO_DISCARD|QEMU_AIO_BLKDEV); ++ return -ENOTSUP; + } + + static int hdev_create(const char *filename, QEMUOptionParameter *options, +-- +1.7.11.7 + diff --git a/SOURCES/kvm-raw-posix-implement-write_zeroes-with-MAY_UNMAP-for-.patch.patch.patch.patch b/SOURCES/kvm-raw-posix-implement-write_zeroes-with-MAY_UNMAP-for-.patch.patch.patch.patch new file mode 100644 index 0000000..4a2d1ce --- /dev/null +++ b/SOURCES/kvm-raw-posix-implement-write_zeroes-with-MAY_UNMAP-for-.patch.patch.patch.patch @@ -0,0 +1,180 @@ +From 4a5025f224c53d2194e2f62cb730a1fef961ff45 Mon Sep 17 00:00:00 2001 +Message-Id: <4a5025f224c53d2194e2f62cb730a1fef961ff45.1389014116.git.minovotn@redhat.com> +In-Reply-To: +References: +From: Paolo Bonzini +Date: Mon, 9 Dec 2013 14:09:27 +0100 +Subject: [PATCH 39/50] raw-posix: implement write_zeroes with MAY_UNMAP for + files + +RH-Author: Paolo Bonzini +Message-id: <1386598178-11845-42-git-send-email-pbonzini@redhat.com> +Patchwork-id: 56078 +O-Subject: [RHEL 7.0 qemu-kvm PATCH 41/52] raw-posix: implement write_zeroes with MAY_UNMAP for files +Bugzilla: 1007815 +RH-Acked-by: Jeffrey Cody +RH-Acked-by: Fam Zheng +RH-Acked-by: Stefan Hajnoczi + +Writing zeroes to a file can be done by punching a hole if +MAY_UNMAP is set. + +Note that in this case ENOTSUP is not ignored, but makes +the block layer fall back to the generic implementation. + +Signed-off-by: Paolo Bonzini +Signed-off-by: Stefan Hajnoczi +(cherry picked from commit 260a82e524b7f86c12b8e39d4c3f208af95645f7) +--- + block/raw-posix.c | 66 +++++++++++++++++++++++++++++++++++++++++++++++++++++-- + trace-events | 1 + + 2 files changed, 65 insertions(+), 2 deletions(-) + +Signed-off-by: Michal Novotny +--- + block/raw-posix.c | 66 +++++++++++++++++++++++++++++++++++++++++++++++++++++-- + trace-events | 1 + + 2 files changed, 65 insertions(+), 2 deletions(-) + +diff --git a/block/raw-posix.c b/block/raw-posix.c +index 7a140b0..ca5bcb3 100644 +--- a/block/raw-posix.c ++++ b/block/raw-posix.c +@@ -139,9 +139,10 @@ typedef struct BDRVRawState { + void *aio_ctx; + #endif + #ifdef CONFIG_XFS +- bool is_xfs : 1; ++ bool is_xfs:1; + #endif +- bool has_discard : 1; ++ bool has_discard:1; ++ bool discard_zeroes:1; + } BDRVRawState; + + typedef struct BDRVRawReopenState { +@@ -283,6 +284,7 @@ static int raw_open_common(BlockDriverState *bs, QDict *options, + Error *local_err = NULL; + const char *filename; + int fd, ret; ++ struct stat st; + + opts = qemu_opts_create_nofail(&raw_runtime_opts); + qemu_opts_absorb_qdict(opts, options, &local_err); +@@ -325,6 +327,15 @@ static int raw_open_common(BlockDriverState *bs, QDict *options, + #endif + + s->has_discard = true; ++ ++ if (fstat(s->fd, &st) < 0) { ++ error_setg_errno(errp, errno, "Could not stat file"); ++ goto fail; ++ } ++ if (S_ISREG(st.st_mode)) { ++ s->discard_zeroes = true; ++ } ++ + #ifdef CONFIG_XFS + if (platform_test_xfs_fd(s->fd)) { + s->is_xfs = true; +@@ -788,6 +799,29 @@ static int aio_worker(void *arg) + return ret; + } + ++static int paio_submit_co(BlockDriverState *bs, int fd, ++ int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, ++ int type) ++{ ++ RawPosixAIOData *acb = g_slice_new(RawPosixAIOData); ++ ThreadPool *pool; ++ ++ acb->bs = bs; ++ acb->aio_type = type; ++ acb->aio_fildes = fd; ++ ++ if (qiov) { ++ acb->aio_iov = qiov->iov; ++ acb->aio_niov = qiov->niov; ++ } ++ acb->aio_nbytes = nb_sectors * 512; ++ acb->aio_offset = sector_num * 512; ++ ++ trace_paio_submit_co(sector_num, nb_sectors, type); ++ pool = aio_get_thread_pool(bdrv_get_aio_context(bs)); ++ return thread_pool_submit_co(pool, aio_worker, acb); ++} ++ + static BlockDriverAIOCB *paio_submit(BlockDriverState *bs, int fd, + int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, + BlockDriverCompletionFunc *cb, void *opaque, int type) +@@ -1200,6 +1234,31 @@ static coroutine_fn BlockDriverAIOCB *raw_aio_discard(BlockDriverState *bs, + cb, opaque, QEMU_AIO_DISCARD); + } + ++static int coroutine_fn raw_co_write_zeroes( ++ BlockDriverState *bs, int64_t sector_num, ++ int nb_sectors, BdrvRequestFlags flags) ++{ ++ BDRVRawState *s = bs->opaque; ++ ++ if (!(flags & BDRV_REQ_MAY_UNMAP)) { ++ return -ENOTSUP; ++ } ++ if (!s->discard_zeroes) { ++ return -ENOTSUP; ++ } ++ return paio_submit_co(bs, s->fd, sector_num, NULL, nb_sectors, ++ QEMU_AIO_DISCARD); ++} ++ ++static int raw_get_info(BlockDriverState *bs, BlockDriverInfo *bdi) ++{ ++ BDRVRawState *s = bs->opaque; ++ ++ bdi->unallocated_blocks_are_zero = s->discard_zeroes; ++ bdi->can_write_zeroes_with_unmap = s->discard_zeroes; ++ return 0; ++} ++ + static QEMUOptionParameter raw_create_options[] = { + { + .name = BLOCK_OPT_SIZE, +@@ -1222,6 +1281,7 @@ static BlockDriver bdrv_file = { + .bdrv_create = raw_create, + .bdrv_has_zero_init = bdrv_has_zero_init_1, + .bdrv_co_get_block_status = raw_co_get_block_status, ++ .bdrv_co_write_zeroes = raw_co_write_zeroes, + + .bdrv_aio_readv = raw_aio_readv, + .bdrv_aio_writev = raw_aio_writev, +@@ -1230,6 +1290,7 @@ static BlockDriver bdrv_file = { + + .bdrv_truncate = raw_truncate, + .bdrv_getlength = raw_getlength, ++ .bdrv_get_info = raw_get_info, + .bdrv_get_allocated_file_size + = raw_get_allocated_file_size, + +@@ -1584,6 +1645,7 @@ static BlockDriver bdrv_host_device = { + + .bdrv_truncate = raw_truncate, + .bdrv_getlength = raw_getlength, ++ .bdrv_get_info = raw_get_info, + .bdrv_get_allocated_file_size + = raw_get_allocated_file_size, + +diff --git a/trace-events b/trace-events +index 40d4312..e9ee94f 100644 +--- a/trace-events ++++ b/trace-events +@@ -120,6 +120,7 @@ thread_pool_cancel(void *req, void *opaque) "req %p opaque %p" + + # block/raw-win32.c + # block/raw-posix.c ++paio_submit_co(int64_t sector_num, int nb_sectors, int type) "sector_num %"PRId64" nb_sectors %d type %d" + paio_submit(void *acb, void *opaque, int64_t sector_num, int nb_sectors, int type) "acb %p opaque %p sector_num %"PRId64" nb_sectors %d type %d" + + # ioport.c +-- +1.7.11.7 + diff --git a/SOURCES/kvm-raw-posix-implement-write_zeroes-with-MAY_UNMAP-for-.patch.patch.patch.patch.patch b/SOURCES/kvm-raw-posix-implement-write_zeroes-with-MAY_UNMAP-for-.patch.patch.patch.patch.patch new file mode 100644 index 0000000..749bb0d --- /dev/null +++ b/SOURCES/kvm-raw-posix-implement-write_zeroes-with-MAY_UNMAP-for-.patch.patch.patch.patch.patch @@ -0,0 +1,98 @@ +From f1b8961cbef828b62ba1ca7da79cd516f7dfc52b Mon Sep 17 00:00:00 2001 +Message-Id: +In-Reply-To: +References: +From: Paolo Bonzini +Date: Mon, 9 Dec 2013 14:09:28 +0100 +Subject: [PATCH 40/50] raw-posix: implement write_zeroes with MAY_UNMAP for + block devices + +RH-Author: Paolo Bonzini +Message-id: <1386598178-11845-43-git-send-email-pbonzini@redhat.com> +Patchwork-id: 56079 +O-Subject: [RHEL 7.0 qemu-kvm PATCH 42/52] raw-posix: implement write_zeroes with MAY_UNMAP for block devices +Bugzilla: 1007815 +RH-Acked-by: Jeffrey Cody +RH-Acked-by: Fam Zheng +RH-Acked-by: Stefan Hajnoczi + +See the next commit for the description of the Linux kernel problem +that is worked around in raw_open_common. + +Signed-off-by: Paolo Bonzini +Signed-off-by: Stefan Hajnoczi +(cherry picked from commit d0b4503ed2d8713791c38839341b023f78d1a3d9) +--- + block/raw-posix.c | 37 +++++++++++++++++++++++++++++++++++++ + 1 file changed, 37 insertions(+) + +Signed-off-by: Michal Novotny +--- + block/raw-posix.c | 37 +++++++++++++++++++++++++++++++++++++ + 1 file changed, 37 insertions(+) + +diff --git a/block/raw-posix.c b/block/raw-posix.c +index ca5bcb3..815a80b 100644 +--- a/block/raw-posix.c ++++ b/block/raw-posix.c +@@ -335,6 +335,22 @@ static int raw_open_common(BlockDriverState *bs, QDict *options, + if (S_ISREG(st.st_mode)) { + s->discard_zeroes = true; + } ++ if (S_ISBLK(st.st_mode)) { ++#ifdef BLKDISCARDZEROES ++ unsigned int arg; ++ if (ioctl(s->fd, BLKDISCARDZEROES, &arg) == 0 && arg) { ++ s->discard_zeroes = true; ++ } ++#endif ++#ifdef __linux__ ++ /* On Linux 3.10, BLKDISCARD leaves stale data in the page cache. Do ++ * not rely on the contents of discarded blocks unless using O_DIRECT. ++ */ ++ if (!(bs->open_flags & BDRV_O_NOCACHE)) { ++ s->discard_zeroes = false; ++ } ++#endif ++ } + + #ifdef CONFIG_XFS + if (platform_test_xfs_fd(s->fd)) { +@@ -1586,6 +1602,26 @@ static coroutine_fn BlockDriverAIOCB *hdev_aio_discard(BlockDriverState *bs, + cb, opaque, QEMU_AIO_DISCARD|QEMU_AIO_BLKDEV); + } + ++static coroutine_fn int hdev_co_write_zeroes(BlockDriverState *bs, ++ int64_t sector_num, int nb_sectors, BdrvRequestFlags flags) ++{ ++ BDRVRawState *s = bs->opaque; ++ int rc; ++ ++ rc = fd_open(bs); ++ if (rc < 0) { ++ return rc; ++ } ++ if (!(flags & BDRV_REQ_MAY_UNMAP)) { ++ return -ENOTSUP; ++ } ++ if (!s->discard_zeroes) { ++ return -ENOTSUP; ++ } ++ return paio_submit_co(bs, s->fd, sector_num, NULL, nb_sectors, ++ QEMU_AIO_DISCARD|QEMU_AIO_BLKDEV); ++} ++ + static int hdev_create(const char *filename, QEMUOptionParameter *options, + Error **errp) + { +@@ -1637,6 +1673,7 @@ static BlockDriver bdrv_host_device = { + .bdrv_reopen_abort = raw_reopen_abort, + .bdrv_create = hdev_create, + .create_options = raw_create_options, ++ .bdrv_co_write_zeroes = hdev_co_write_zeroes, + + .bdrv_aio_readv = raw_aio_readv, + .bdrv_aio_writev = raw_aio_writev, +-- +1.7.11.7 + diff --git a/SOURCES/kvm-rdma-IPv6-over-Ethernet-RoCE-is-broken-in-linux-work.patch b/SOURCES/kvm-rdma-IPv6-over-Ethernet-RoCE-is-broken-in-linux-work.patch new file mode 100644 index 0000000..f4ba1d1 --- /dev/null +++ b/SOURCES/kvm-rdma-IPv6-over-Ethernet-RoCE-is-broken-in-linux-work.patch @@ -0,0 +1,380 @@ +From 876b9284b61269d977d0b6b8585ba29758957622 Mon Sep 17 00:00:00 2001 +Message-Id: <876b9284b61269d977d0b6b8585ba29758957622.1387382496.git.minovotn@redhat.com> +In-Reply-To: +References: +From: Nigel Croxon +Date: Thu, 14 Nov 2013 22:53:07 +0100 +Subject: [PATCH 31/46] rdma: IPv6 over Ethernet (RoCE) is broken in linux - + workaround + +RH-Author: Nigel Croxon +Message-id: <1384469598-13137-32-git-send-email-ncroxon@redhat.com> +Patchwork-id: 55713 +O-Subject: [RHEL7.0 PATCH 31/42] rdma: IPv6 over Ethernet (RoCE) is broken in linux - workaround +Bugzilla: 1011720 +RH-Acked-by: Orit Wasserman +RH-Acked-by: Amit Shah +RH-Acked-by: Paolo Bonzini + +Bugzilla: 1011720 +https://bugzilla.redhat.com/show_bug.cgi?id=1011720 + +>From commit ID: +commit 7fc5b13fd7b05babc7bcad9dcb8281ae202a9494 +Author: Michael R. Hines +Date: Fri Aug 9 16:05:44 2013 -0400 + + rdma: IPv6 over Ethernet (RoCE) is broken in linux - workaround + + We've gotten reports from multiple testers (including Frank Yangjie + and myself) that RDMA IPv6 support over RocE (Ethernet) is broken + in linux. + + A patch to Linux is still in review: + + http://comments.gmane.org/gmane.linux.drivers.rdma/16448 + + If the user is listening on '[::]', then we will not have a opened a device + yet and have no way of verifying if the device is RoCE or not. + + In this case, the source VM will throw an error for ALL types of + connections (both IPv4 and IPv6) if the destination machine does not have + a regular infiniband network available for use. + + The only way to gaurantee that an error is thrown for broken kernels is + for the management software to choose a *specific* interface at bind time + and validate what time of hardware it is. + + Unfortunately, this puts the user in a fix: + + If the source VM connects with an IPv4 address without knowing that the + destination has bound to '[::]' the migration will unconditionally fail + unless the management software is not explicitly listening on the the IPv4 + address while using a RoCE-based device. + + If the source VM connects with an IPv6 address, then we're OK because we can + throw an error on the source (and similarly on the destination). + + But in mixed environments, this will be broken for a while until it is fixed + inside linux. + + We do provide a *tiny* bit of help in mixed environments, though in this patch: + + We can list all of the devices in the system and check to see if all the + devices are RoCE or Infiniband. + + If we detect that we have a *pure* RoCE environment, then we can safely + thrown an error even if the management sofware has specified '[::]' as the + bind address. + + However, if there is are multiple hetergeneous devices, then we cannot make + this assumption and the user just has to be sure they know what they are doing. + + Signed-off-by: Michael R. Hines + Message-id: 1376078746-24948-6-git-send-email-mrhines@linux.vnet.ibm.com + Signed-off-by: Anthony Liguori +--- + migration-rdma.c | 189 ++++++++++++++++++++++++++++++++++++++++++++++++------ + 1 files changed, 169 insertions(+), 20 deletions(-) + +Signed-off-by: Michal Novotny +--- + migration-rdma.c | 189 +++++++++++++++++++++++++++++++++++++++++++++++++------ + 1 file changed, 169 insertions(+), 20 deletions(-) + +diff --git a/migration-rdma.c b/migration-rdma.c +index e6fd77a..ada488e 100644 +--- a/migration-rdma.c ++++ b/migration-rdma.c +@@ -707,15 +707,27 @@ static int __qemu_rdma_delete_block(RDMAContext *rdma, ram_addr_t block_offset) + */ + static void qemu_rdma_dump_id(const char *who, struct ibv_context *verbs) + { ++ struct ibv_port_attr port; ++ ++ if (ibv_query_port(verbs, 1, &port)) { ++ fprintf(stderr, "FAILED TO QUERY PORT INFORMATION!\n"); ++ return; ++ } ++ + printf("%s RDMA Device opened: kernel name %s " + "uverbs device name %s, " +- "infiniband_verbs class device path %s," +- " infiniband class device path %s\n", ++ "infiniband_verbs class device path %s, " ++ "infiniband class device path %s, " ++ "transport: (%d) %s\n", + who, + verbs->device->name, + verbs->device->dev_name, + verbs->device->dev_path, +- verbs->device->ibdev_path); ++ verbs->device->ibdev_path, ++ port.link_layer, ++ (port.link_layer == IBV_LINK_LAYER_INFINIBAND) ? "Infiniband" : ++ ((port.link_layer == IBV_LINK_LAYER_ETHERNET) ++ ? "Ethernet" : "Unknown")); + } + + /* +@@ -733,6 +745,132 @@ static void qemu_rdma_dump_gid(const char *who, struct rdma_cm_id *id) + } + + /* ++ * As of now, IPv6 over RoCE / iWARP is not supported by linux. ++ * We will try the next addrinfo struct, and fail if there are ++ * no other valid addresses to bind against. ++ * ++ * If user is listening on '[::]', then we will not have a opened a device ++ * yet and have no way of verifying if the device is RoCE or not. ++ * ++ * In this case, the source VM will throw an error for ALL types of ++ * connections (both IPv4 and IPv6) if the destination machine does not have ++ * a regular infiniband network available for use. ++ * ++ * The only way to gaurantee that an error is thrown for broken kernels is ++ * for the management software to choose a *specific* interface at bind time ++ * and validate what time of hardware it is. ++ * ++ * Unfortunately, this puts the user in a fix: ++ * ++ * If the source VM connects with an IPv4 address without knowing that the ++ * destination has bound to '[::]' the migration will unconditionally fail ++ * unless the management software is explicitly listening on the the IPv4 ++ * address while using a RoCE-based device. ++ * ++ * If the source VM connects with an IPv6 address, then we're OK because we can ++ * throw an error on the source (and similarly on the destination). ++ * ++ * But in mixed environments, this will be broken for a while until it is fixed ++ * inside linux. ++ * ++ * We do provide a *tiny* bit of help in this function: We can list all of the ++ * devices in the system and check to see if all the devices are RoCE or ++ * Infiniband. ++ * ++ * If we detect that we have a *pure* RoCE environment, then we can safely ++ * thrown an error even if the management sofware has specified '[::]' as the ++ * bind address. ++ * ++ * However, if there is are multiple hetergeneous devices, then we cannot make ++ * this assumption and the user just has to be sure they know what they are ++ * doing. ++ * ++ * Patches are being reviewed on linux-rdma. ++ */ ++static int qemu_rdma_broken_ipv6_kernel(Error **errp, struct ibv_context *verbs) ++{ ++ struct ibv_port_attr port_attr; ++ ++ /* This bug only exists in linux, to our knowledge. */ ++#ifdef CONFIG_LINUX ++ ++ /* ++ * Verbs are only NULL if management has bound to '[::]'. ++ * ++ * Let's iterate through all the devices and see if there any pure IB ++ * devices (non-ethernet). ++ * ++ * If not, then we can safely proceed with the migration. ++ * Otherwise, there are no gaurantees until the bug is fixed in linux. ++ */ ++ if (!verbs) { ++ int num_devices, x; ++ struct ibv_device ** dev_list = ibv_get_device_list(&num_devices); ++ bool roce_found = false; ++ bool ib_found = false; ++ ++ for (x = 0; x < num_devices; x++) { ++ verbs = ibv_open_device(dev_list[x]); ++ ++ if (ibv_query_port(verbs, 1, &port_attr)) { ++ ibv_close_device(verbs); ++ ERROR(errp, "Could not query initial IB port"); ++ return -EINVAL; ++ } ++ ++ if (port_attr.link_layer == IBV_LINK_LAYER_INFINIBAND) { ++ ib_found = true; ++ } else if (port_attr.link_layer == IBV_LINK_LAYER_ETHERNET) { ++ roce_found = true; ++ } ++ ++ ibv_close_device(verbs); ++ ++ } ++ ++ if (roce_found) { ++ if (ib_found) { ++ fprintf(stderr, "WARN: migrations may fail:" ++ " IPv6 over RoCE / iWARP in linux" ++ " is broken. But since you appear to have a" ++ " mixed RoCE / IB environment, be sure to only" ++ " migrate over the IB fabric until the kernel " ++ " fixes the bug.\n"); ++ } else { ++ ERROR(errp, "You only have RoCE / iWARP devices in your systems" ++ " and your management software has specified '[::]'" ++ ", but IPv6 over RoCE / iWARP is not supported in Linux."); ++ return -ENONET; ++ } ++ } ++ ++ return 0; ++ } ++ ++ /* ++ * If we have a verbs context, that means that some other than '[::]' was ++ * used by the management software for binding. In which case we can actually ++ * warn the user about a potential broken kernel; ++ */ ++ ++ /* IB ports start with 1, not 0 */ ++ if (ibv_query_port(verbs, 1, &port_attr)) { ++ ERROR(errp, "Could not query initial IB port"); ++ return -EINVAL; ++ } ++ ++ if (port_attr.link_layer == IBV_LINK_LAYER_ETHERNET) { ++ ERROR(errp, "Linux kernel's RoCE / iWARP does not support IPv6 " ++ "(but patches on linux-rdma in progress)"); ++ return -ENONET; ++ } ++ ++#endif ++ ++ return 0; ++} ++ ++/* + * Figure out which RDMA device corresponds to the requested IP hostname + * Also create the initial connection manager identifiers for opening + * the connection. +@@ -740,22 +878,22 @@ static void qemu_rdma_dump_gid(const char *who, struct rdma_cm_id *id) + static int qemu_rdma_resolve_host(RDMAContext *rdma, Error **errp) + { + int ret; +- struct addrinfo *res; ++ struct rdma_addrinfo *res; + char port_str[16]; + struct rdma_cm_event *cm_event; + char ip[40] = "unknown"; +- struct addrinfo *e; ++ struct rdma_addrinfo *e; + + if (rdma->host == NULL || !strcmp(rdma->host, "")) { + ERROR(errp, "RDMA hostname has not been set"); +- return -1; ++ return -EINVAL; + } + + /* create CM channel */ + rdma->channel = rdma_create_event_channel(); + if (!rdma->channel) { + ERROR(errp, "could not create CM channel"); +- return -1; ++ return -EINVAL; + } + + /* create CM id */ +@@ -768,21 +906,24 @@ static int qemu_rdma_resolve_host(RDMAContext *rdma, Error **errp) + snprintf(port_str, 16, "%d", rdma->port); + port_str[15] = '\0'; + +- ret = getaddrinfo(rdma->host, port_str, NULL, &res); ++ ret = rdma_getaddrinfo(rdma->host, port_str, NULL, &res); + if (ret < 0) { +- ERROR(errp, "could not getaddrinfo address %s", rdma->host); ++ ERROR(errp, "could not rdma_getaddrinfo address %s", rdma->host); + goto err_resolve_get_addr; + } + + for (e = res; e != NULL; e = e->ai_next) { + inet_ntop(e->ai_family, +- &((struct sockaddr_in *) e->ai_addr)->sin_addr, ip, sizeof ip); ++ &((struct sockaddr_in *) e->ai_dst_addr)->sin_addr, ip, sizeof ip); + DPRINTF("Trying %s => %s\n", rdma->host, ip); + +- /* resolve the first address */ +- ret = rdma_resolve_addr(rdma->cm_id, NULL, e->ai_addr, ++ ret = rdma_resolve_addr(rdma->cm_id, NULL, e->ai_dst_addr, + RDMA_RESOLVE_TIMEOUT_MS); + if (!ret) { ++ ret = qemu_rdma_broken_ipv6_kernel(errp, rdma->cm_id->verbs); ++ if (ret) { ++ continue; ++ } + goto route; + } + } +@@ -803,6 +944,7 @@ route: + ERROR(errp, "result not equal to event_addr_resolved %s", + rdma_event_str(cm_event->event)); + perror("rdma_resolve_addr"); ++ ret = -EINVAL; + goto err_resolve_get_addr; + } + rdma_ack_cm_event(cm_event); +@@ -823,6 +965,7 @@ route: + ERROR(errp, "result not equal to event_route_resolved: %s", + rdma_event_str(cm_event->event)); + rdma_ack_cm_event(cm_event); ++ ret = -EINVAL; + goto err_resolve_get_addr; + } + rdma_ack_cm_event(cm_event); +@@ -837,8 +980,7 @@ err_resolve_get_addr: + err_resolve_create_id: + rdma_destroy_event_channel(rdma->channel); + rdma->channel = NULL; +- +- return -1; ++ return ret; + } + + /* +@@ -2266,7 +2408,7 @@ static int qemu_rdma_dest_init(RDMAContext *rdma, Error **errp) + int ret = -EINVAL, idx; + struct rdma_cm_id *listen_id; + char ip[40] = "unknown"; +- struct addrinfo *res; ++ struct rdma_addrinfo *res; + char port_str[16]; + + for (idx = 0; idx < RDMA_WRID_MAX; idx++) { +@@ -2298,20 +2440,27 @@ static int qemu_rdma_dest_init(RDMAContext *rdma, Error **errp) + port_str[15] = '\0'; + + if (rdma->host && strcmp("", rdma->host)) { +- struct addrinfo *e; ++ struct rdma_addrinfo *e; + +- ret = getaddrinfo(rdma->host, port_str, NULL, &res); ++ ret = rdma_getaddrinfo(rdma->host, port_str, NULL, &res); + if (ret < 0) { +- ERROR(errp, "could not getaddrinfo address %s", rdma->host); ++ ERROR(errp, "could not rdma_getaddrinfo address %s", rdma->host); + goto err_dest_init_bind_addr; + } + + for (e = res; e != NULL; e = e->ai_next) { + inet_ntop(e->ai_family, +- &((struct sockaddr_in *) e->ai_addr)->sin_addr, ip, sizeof ip); ++ &((struct sockaddr_in *) e->ai_dst_addr)->sin_addr, ip, sizeof ip); + DPRINTF("Trying %s => %s\n", rdma->host, ip); +- ret = rdma_bind_addr(listen_id, e->ai_addr); ++ ret = rdma_bind_addr(listen_id, e->ai_dst_addr); + if (!ret) { ++ if (e->ai_family == AF_INET6) { ++ ret = qemu_rdma_broken_ipv6_kernel(errp, listen_id->verbs); ++ if (ret) { ++ continue; ++ } ++ } ++ + goto listen; + } + } +-- +1.7.11.7 + diff --git a/SOURCES/kvm-rdma-account-for-the-time-spent-in-MIG_STATE_SETUP-t.patch b/SOURCES/kvm-rdma-account-for-the-time-spent-in-MIG_STATE_SETUP-t.patch new file mode 100644 index 0000000..f3dad17 --- /dev/null +++ b/SOURCES/kvm-rdma-account-for-the-time-spent-in-MIG_STATE_SETUP-t.patch @@ -0,0 +1,158 @@ +From 55c36d5525751d4b2676e206680762769758d934 Mon Sep 17 00:00:00 2001 +Message-Id: <55c36d5525751d4b2676e206680762769758d934.1387382496.git.minovotn@redhat.com> +In-Reply-To: +References: +From: Nigel Croxon +Date: Thu, 14 Nov 2013 22:52:55 +0100 +Subject: [PATCH 19/46] rdma: account for the time spent in MIG_STATE_SETUP + through QMP + +RH-Author: Nigel Croxon +Message-id: <1384469598-13137-20-git-send-email-ncroxon@redhat.com> +Patchwork-id: 55701 +O-Subject: [RHEL7.0 PATCH 19/42] rdma: account for the time spent in MIG_STATE_SETUP through QMP +Bugzilla: 1011720 +RH-Acked-by: Orit Wasserman +RH-Acked-by: Amit Shah +RH-Acked-by: Paolo Bonzini + +Bugzilla: 1011720 +https://bugzilla.redhat.com/show_bug.cgi?id=1011720 + +>From commit ID: +commit ed4fbd10823a7b0dbded6b481a68973e47f7e14d +Author: Michael R. Hines +Date: Mon Jul 22 10:01:58 2013 -0400 + + rdma: account for the time spent in MIG_STATE_SETUP through QMP + + Using the previous patches, we're now able to timestamp the SETUP + state. Once we have this time, let the user know about it in the + schema. + + Reviewed-by: Juan Quintela + Reviewed-by: Eric Blake + Signed-off-by: Michael R. Hines + Signed-off-by: Juan Quintela +--- + hmp.c | 4 ++++ + include/migration/migration.h | 1 + + migration.c | 9 +++++++++ + qapi-schema.json | 9 ++++++++- + 4 files changed, 22 insertions(+), 1 deletions(-) + +Signed-off-by: Michal Novotny +--- + hmp.c | 4 ++++ + include/migration/migration.h | 1 + + migration.c | 9 +++++++++ + qapi-schema.json | 9 ++++++++- + 4 files changed, 22 insertions(+), 1 deletion(-) + +diff --git a/hmp.c b/hmp.c +index 316e6a1..841929d 100644 +--- a/hmp.c ++++ b/hmp.c +@@ -162,6 +162,10 @@ void hmp_info_migrate(Monitor *mon, const QDict *qdict) + monitor_printf(mon, "downtime: %" PRIu64 " milliseconds\n", + info->downtime); + } ++ if (info->has_setup_time) { ++ monitor_printf(mon, "setup: %" PRIu64 " milliseconds\n", ++ info->setup_time); ++ } + } + + if (info->has_ram) { +diff --git a/include/migration/migration.h b/include/migration/migration.h +index 13a9629..08c772d 100644 +--- a/include/migration/migration.h ++++ b/include/migration/migration.h +@@ -49,6 +49,7 @@ struct MigrationState + int64_t dirty_bytes_rate; + bool enabled_capabilities[MIGRATION_CAPABILITY_MAX]; + int64_t xbzrle_cache_size; ++ int64_t setup_time; + }; + + void process_incoming_migration(QEMUFile *f); +diff --git a/migration.c b/migration.c +index ddbfd45..4f070a3 100644 +--- a/migration.c ++++ b/migration.c +@@ -191,6 +191,7 @@ MigrationInfo *qmp_query_migrate(Error **errp) + case MIG_STATE_SETUP: + info->has_status = true; + info->status = g_strdup("setup"); ++ info->has_total_time = false; + break; + case MIG_STATE_ACTIVE: + info->has_status = true; +@@ -200,6 +201,8 @@ MigrationInfo *qmp_query_migrate(Error **errp) + - s->total_time; + info->has_expected_downtime = true; + info->expected_downtime = s->expected_downtime; ++ info->has_setup_time = true; ++ info->setup_time = s->setup_time; + + info->has_ram = true; + info->ram = g_malloc0(sizeof(*info->ram)); +@@ -232,6 +235,8 @@ MigrationInfo *qmp_query_migrate(Error **errp) + info->total_time = s->total_time; + info->has_downtime = true; + info->downtime = s->downtime; ++ info->has_setup_time = true; ++ info->setup_time = s->setup_time; + + info->has_ram = true; + info->ram = g_malloc0(sizeof(*info->ram)); +@@ -548,6 +553,7 @@ static void *migration_thread(void *opaque) + { + MigrationState *s = opaque; + int64_t initial_time = qemu_get_clock_ms(rt_clock); ++ int64_t setup_start = qemu_get_clock_ms(host_clock); + int64_t initial_bytes = 0; + int64_t max_size = 0; + int64_t start_time = initial_time; +@@ -556,8 +562,11 @@ static void *migration_thread(void *opaque) + DPRINTF("beginning savevm\n"); + qemu_savevm_state_begin(s->file, &s->params); + ++ s->setup_time = qemu_get_clock_ms(host_clock) - setup_start; + migrate_set_state(s, MIG_STATE_SETUP, MIG_STATE_ACTIVE); + ++ DPRINTF("setup complete\n"); ++ + while (s->state == MIG_STATE_ACTIVE) { + int64_t current_time; + uint64_t pending_size; +diff --git a/qapi-schema.json b/qapi-schema.json +index bf1fe68..7333b8f 100644 +--- a/qapi-schema.json ++++ b/qapi-schema.json +@@ -634,6 +634,12 @@ + # expected downtime in milliseconds for the guest in last walk + # of the dirty bitmap. (since 1.3) + # ++# @setup-time: #optional amount of setup time in milliseconds _before_ the ++# iterations begin but _after_ the QMP command is issued. This is designed ++# to provide an accounting of any activities (such as RDMA pinning) which ++# may be expensive, but do not actually occur during the iterative ++# migration rounds themselves. (since 1.6) ++# + # Since: 0.14.0 + ## + { 'type': 'MigrationInfo', +@@ -642,7 +648,8 @@ + '*xbzrle-cache': 'XBZRLECacheStats', + '*total-time': 'int', + '*expected-downtime': 'int', +- '*downtime': 'int'} } ++ '*downtime': 'int', ++ '*setup-time': 'int'} } + + ## + # @query-migrate +-- +1.7.11.7 + diff --git a/SOURCES/kvm-rdma-add-documentation.patch b/SOURCES/kvm-rdma-add-documentation.patch new file mode 100644 index 0000000..14a5b42 --- /dev/null +++ b/SOURCES/kvm-rdma-add-documentation.patch @@ -0,0 +1,472 @@ +From 7c25e4dc9a5a8d07f2c59fd2160bb22c774d1d7a Mon Sep 17 00:00:00 2001 +Message-Id: <7c25e4dc9a5a8d07f2c59fd2160bb22c774d1d7a.1387382496.git.minovotn@redhat.com> +In-Reply-To: +References: +From: Nigel Croxon +Date: Thu, 14 Nov 2013 22:52:40 +0100 +Subject: [PATCH 04/46] rdma: add documentation + +RH-Author: Nigel Croxon +Message-id: <1384469598-13137-5-git-send-email-ncroxon@redhat.com> +Patchwork-id: 55688 +O-Subject: [RHEL7.0 PATCH 04/42] rdma: add documentation +Bugzilla: 1011720 +RH-Acked-by: Orit Wasserman +RH-Acked-by: Amit Shah +RH-Acked-by: Paolo Bonzini + +Bugzilla: 1011720 +https://bugzilla.redhat.com/show_bug.cgi?id=1011720 + +>From commit ID: +commit f4abc9d621823b14a6cd508c66c1ecb21f96349e +Author: Michael R. Hines +Date: Tue Jun 25 21:35:27 2013 -0400 + + rdma: add documentation + + docs/rdma.txt contains full documentation, + wiki links, github url and contact information. + + Reviewed-by: Juan Quintela + Reviewed-by: Paolo Bonzini + Reviewed-by: Chegu Vinod + Tested-by: Chegu Vinod + Tested-by: Michael R. Hines + Signed-off-by: Michael R. Hines + Signed-off-by: Juan Quintela +--- + docs/rdma.txt | 415 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + 1 files changed, 415 insertions(+), 0 deletions(-) + create mode 100644 docs/rdma.txt + +Signed-off-by: Michal Novotny +--- + docs/rdma.txt | 415 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + 1 file changed, 415 insertions(+) + create mode 100644 docs/rdma.txt + +diff --git a/docs/rdma.txt b/docs/rdma.txt +new file mode 100644 +index 0000000..45a4b1d +--- /dev/null ++++ b/docs/rdma.txt +@@ -0,0 +1,415 @@ ++(RDMA: Remote Direct Memory Access) ++RDMA Live Migration Specification, Version # 1 ++============================================== ++Wiki: http://wiki.qemu.org/Features/RDMALiveMigration ++Github: git@github.com:hinesmr/qemu.git, 'rdma' branch ++ ++Copyright (C) 2013 Michael R. Hines ++ ++An *exhaustive* paper (2010) shows additional performance details ++linked on the QEMU wiki above. ++ ++Contents: ++========= ++* Introduction ++* Before running ++* Running ++* Performance ++* RDMA Migration Protocol Description ++* Versioning and Capabilities ++* QEMUFileRDMA Interface ++* Migration of pc.ram ++* Error handling ++* TODO ++ ++Introduction: ++============= ++ ++RDMA helps make your migration more deterministic under heavy load because ++of the significantly lower latency and higher throughput over TCP/IP. This is ++because the RDMA I/O architecture reduces the number of interrupts and ++data copies by bypassing the host networking stack. In particular, a TCP-based ++migration, under certain types of memory-bound workloads, may take a more ++unpredicatable amount of time to complete the migration if the amount of ++memory tracked during each live migration iteration round cannot keep pace ++with the rate of dirty memory produced by the workload. ++ ++RDMA currently comes in two flavors: both Ethernet based (RoCE, or RDMA ++over Convered Ethernet) as well as Infiniband-based. This implementation of ++migration using RDMA is capable of using both technologies because of ++the use of the OpenFabrics OFED software stack that abstracts out the ++programming model irrespective of the underlying hardware. ++ ++Refer to openfabrics.org or your respective RDMA hardware vendor for ++an understanding on how to verify that you have the OFED software stack ++installed in your environment. You should be able to successfully link ++against the "librdmacm" and "libibverbs" libraries and development headers ++for a working build of QEMU to run successfully using RDMA Migration. ++ ++BEFORE RUNNING: ++=============== ++ ++Use of RDMA during migration requires pinning and registering memory ++with the hardware. This means that memory must be physically resident ++before the hardware can transmit that memory to another machine. ++If this is not acceptable for your application or product, then the use ++of RDMA migration may in fact be harmful to co-located VMs or other ++software on the machine if there is not sufficient memory available to ++relocate the entire footprint of the virtual machine. If so, then the ++use of RDMA is discouraged and it is recommended to use standard TCP migration. ++ ++Experimental: Next, decide if you want dynamic page registration. ++For example, if you have an 8GB RAM virtual machine, but only 1GB ++is in active use, then enabling this feature will cause all 8GB to ++be pinned and resident in memory. This feature mostly affects the ++bulk-phase round of the migration and can be enabled for extremely ++high-performance RDMA hardware using the following command: ++ ++QEMU Monitor Command: ++$ migrate_set_capability x-rdma-pin-all on # disabled by default ++ ++Performing this action will cause all 8GB to be pinned, so if that's ++not what you want, then please ignore this step altogether. ++ ++On the other hand, this will also significantly speed up the bulk round ++of the migration, which can greatly reduce the "total" time of your migration. ++Example performance of this using an idle VM in the previous example ++can be found in the "Performance" section. ++ ++Note: for very large virtual machines (hundreds of GBs), pinning all ++*all* of the memory of your virtual machine in the kernel is very expensive ++may extend the initial bulk iteration time by many seconds, ++and thus extending the total migration time. However, this will not ++affect the determinism or predictability of your migration you will ++still gain from the benefits of advanced pinning with RDMA. ++ ++RUNNING: ++======== ++ ++First, set the migration speed to match your hardware's capabilities: ++ ++QEMU Monitor Command: ++$ migrate_set_speed 40g # or whatever is the MAX of your RDMA device ++ ++Next, on the destination machine, add the following to the QEMU command line: ++ ++qemu ..... -incoming x-rdma:host:port ++ ++Finally, perform the actual migration on the source machine: ++ ++QEMU Monitor Command: ++$ migrate -d x-rdma:host:port ++ ++PERFORMANCE ++=========== ++ ++Here is a brief summary of total migration time and downtime using RDMA: ++Using a 40gbps infiniband link performing a worst-case stress test, ++using an 8GB RAM virtual machine: ++ ++Using the following command: ++$ apt-get install stress ++$ stress --vm-bytes 7500M --vm 1 --vm-keep ++ ++1. Migration throughput: 26 gigabits/second. ++2. Downtime (stop time) varies between 15 and 100 milliseconds. ++ ++EFFECTS of memory registration on bulk phase round: ++ ++For example, in the same 8GB RAM example with all 8GB of memory in ++active use and the VM itself is completely idle using the same 40 gbps ++infiniband link: ++ ++1. x-rdma-pin-all disabled total time: approximately 7.5 seconds @ 9.5 Gbps ++2. x-rdma-pin-all enabled total time: approximately 4 seconds @ 26 Gbps ++ ++These numbers would of course scale up to whatever size virtual machine ++you have to migrate using RDMA. ++ ++Enabling this feature does *not* have any measurable affect on ++migration *downtime*. This is because, without this feature, all of the ++memory will have already been registered already in advance during ++the bulk round and does not need to be re-registered during the successive ++iteration rounds. ++ ++RDMA Protocol Description: ++========================== ++ ++Migration with RDMA is separated into two parts: ++ ++1. The transmission of the pages using RDMA ++2. Everything else (a control channel is introduced) ++ ++"Everything else" is transmitted using a formal ++protocol now, consisting of infiniband SEND messages. ++ ++An infiniband SEND message is the standard ibverbs ++message used by applications of infiniband hardware. ++The only difference between a SEND message and an RDMA ++message is that SEND messages cause notifications ++to be posted to the completion queue (CQ) on the ++infiniband receiver side, whereas RDMA messages (used ++for pc.ram) do not (to behave like an actual DMA). ++ ++Messages in infiniband require two things: ++ ++1. registration of the memory that will be transmitted ++2. (SEND only) work requests to be posted on both ++ sides of the network before the actual transmission ++ can occur. ++ ++RDMA messages are much easier to deal with. Once the memory ++on the receiver side is registered and pinned, we're ++basically done. All that is required is for the sender ++side to start dumping bytes onto the link. ++ ++(Memory is not released from pinning until the migration ++completes, given that RDMA migrations are very fast.) ++ ++SEND messages require more coordination because the ++receiver must have reserved space (using a receive ++work request) on the receive queue (RQ) before QEMUFileRDMA ++can start using them to carry all the bytes as ++a control transport for migration of device state. ++ ++To begin the migration, the initial connection setup is ++as follows (migration-rdma.c): ++ ++1. Receiver and Sender are started (command line or libvirt): ++2. Both sides post two RQ work requests ++3. Receiver does listen() ++4. Sender does connect() ++5. Receiver accept() ++6. Check versioning and capabilities (described later) ++ ++At this point, we define a control channel on top of SEND messages ++which is described by a formal protocol. Each SEND message has a ++header portion and a data portion (but together are transmitted ++as a single SEND message). ++ ++Header: ++ * Length (of the data portion, uint32, network byte order) ++ * Type (what command to perform, uint32, network byte order) ++ * Repeat (Number of commands in data portion, same type only) ++ ++The 'Repeat' field is here to support future multiple page registrations ++in a single message without any need to change the protocol itself ++so that the protocol is compatible against multiple versions of QEMU. ++Version #1 requires that all server implementations of the protocol must ++check this field and register all requests found in the array of commands located ++in the data portion and return an equal number of results in the response. ++The maximum number of repeats is hard-coded to 4096. This is a conservative ++limit based on the maximum size of a SEND message along with emperical ++observations on the maximum future benefit of simultaneous page registrations. ++ ++The 'type' field has 10 different command values: ++ 1. Unused ++ 2. Error (sent to the source during bad things) ++ 3. Ready (control-channel is available) ++ 4. QEMU File (for sending non-live device state) ++ 5. RAM Blocks request (used right after connection setup) ++ 6. RAM Blocks result (used right after connection setup) ++ 7. Compress page (zap zero page and skip registration) ++ 8. Register request (dynamic chunk registration) ++ 9. Register result ('rkey' to be used by sender) ++ 10. Register finished (registration for current iteration finished) ++ ++A single control message, as hinted above, can contain within the data ++portion an array of many commands of the same type. If there is more than ++one command, then the 'repeat' field will be greater than 1. ++ ++After connection setup, message 5 & 6 are used to exchange ram block ++information and optionally pin all the memory if requested by the user. ++ ++After ram block exchange is completed, we have two protocol-level ++functions, responsible for communicating control-channel commands ++using the above list of values: ++ ++Logically: ++ ++qemu_rdma_exchange_recv(header, expected command type) ++ ++1. We transmit a READY command to let the sender know that ++ we are *ready* to receive some data bytes on the control channel. ++2. Before attempting to receive the expected command, we post another ++ RQ work request to replace the one we just used up. ++3. Block on a CQ event channel and wait for the SEND to arrive. ++4. When the send arrives, librdmacm will unblock us. ++5. Verify that the command-type and version received matches the one we expected. ++ ++qemu_rdma_exchange_send(header, data, optional response header & data): ++ ++1. Block on the CQ event channel waiting for a READY command ++ from the receiver to tell us that the receiver ++ is *ready* for us to transmit some new bytes. ++2. Optionally: if we are expecting a response from the command ++ (that we have no yet transmitted), let's post an RQ ++ work request to receive that data a few moments later. ++3. When the READY arrives, librdmacm will ++ unblock us and we immediately post a RQ work request ++ to replace the one we just used up. ++4. Now, we can actually post the work request to SEND ++ the requested command type of the header we were asked for. ++5. Optionally, if we are expecting a response (as before), ++ we block again and wait for that response using the additional ++ work request we previously posted. (This is used to carry ++ 'Register result' commands #6 back to the sender which ++ hold the rkey need to perform RDMA. Note that the virtual address ++ corresponding to this rkey was already exchanged at the beginning ++ of the connection (described below). ++ ++All of the remaining command types (not including 'ready') ++described above all use the aformentioned two functions to do the hard work: ++ ++1. After connection setup, RAMBlock information is exchanged using ++ this protocol before the actual migration begins. This information includes ++ a description of each RAMBlock on the server side as well as the virtual addresses ++ and lengths of each RAMBlock. This is used by the client to determine the ++ start and stop locations of chunks and how to register them dynamically ++ before performing the RDMA operations. ++2. During runtime, once a 'chunk' becomes full of pages ready to ++ be sent with RDMA, the registration commands are used to ask the ++ other side to register the memory for this chunk and respond ++ with the result (rkey) of the registration. ++3. Also, the QEMUFile interfaces also call these functions (described below) ++ when transmitting non-live state, such as devices or to send ++ its own protocol information during the migration process. ++4. Finally, zero pages are only checked if a page has not yet been registered ++ using chunk registration (or not checked at all and unconditionally ++ written if chunk registration is disabled. This is accomplished using ++ the "Compress" command listed above. If the page *has* been registered ++ then we check the entire chunk for zero. Only if the entire chunk is ++ zero, then we send a compress command to zap the page on the other side. ++ ++Versioning and Capabilities ++=========================== ++Current version of the protocol is version #1. ++ ++The same version applies to both for protocol traffic and capabilities ++negotiation. (i.e. There is only one version number that is referred to ++by all communication). ++ ++librdmacm provides the user with a 'private data' area to be exchanged ++at connection-setup time before any infiniband traffic is generated. ++ ++Header: ++ * Version (protocol version validated before send/recv occurs), uint32, network byte order ++ * Flags (bitwise OR of each capability), uint32, network byte order ++ ++There is no data portion of this header right now, so there is ++no length field. The maximum size of the 'private data' section ++is only 192 bytes per the Infiniband specification, so it's not ++very useful for data anyway. This structure needs to remain small. ++ ++This private data area is a convenient place to check for protocol ++versioning because the user does not need to register memory to ++transmit a few bytes of version information. ++ ++This is also a convenient place to negotiate capabilities ++(like dynamic page registration). ++ ++If the version is invalid, we throw an error. ++ ++If the version is new, we only negotiate the capabilities that the ++requested version is able to perform and ignore the rest. ++ ++Currently there is only *one* capability in Version #1: dynamic page registration ++ ++Finally: Negotiation happens with the Flags field: If the primary-VM ++sets a flag, but the destination does not support this capability, it ++will return a zero-bit for that flag and the primary-VM will understand ++that as not being an available capability and will thus disable that ++capability on the primary-VM side. ++ ++QEMUFileRDMA Interface: ++======================= ++ ++QEMUFileRDMA introduces a couple of new functions: ++ ++1. qemu_rdma_get_buffer() (QEMUFileOps rdma_read_ops) ++2. qemu_rdma_put_buffer() (QEMUFileOps rdma_write_ops) ++ ++These two functions are very short and simply use the protocol ++describe above to deliver bytes without changing the upper-level ++users of QEMUFile that depend on a bytestream abstraction. ++ ++Finally, how do we handoff the actual bytes to get_buffer()? ++ ++Again, because we're trying to "fake" a bytestream abstraction ++using an analogy not unlike individual UDP frames, we have ++to hold on to the bytes received from control-channel's SEND ++messages in memory. ++ ++Each time we receive a complete "QEMU File" control-channel ++message, the bytes from SEND are copied into a small local holding area. ++ ++Then, we return the number of bytes requested by get_buffer() ++and leave the remaining bytes in the holding area until get_buffer() ++comes around for another pass. ++ ++If the buffer is empty, then we follow the same steps ++listed above and issue another "QEMU File" protocol command, ++asking for a new SEND message to re-fill the buffer. ++ ++Migration of pc.ram: ++==================== ++ ++At the beginning of the migration, (migration-rdma.c), ++the sender and the receiver populate the list of RAMBlocks ++to be registered with each other into a structure. ++Then, using the aforementioned protocol, they exchange a ++description of these blocks with each other, to be used later ++during the iteration of main memory. This description includes ++a list of all the RAMBlocks, their offsets and lengths, virtual ++addresses and possibly includes pre-registered RDMA keys in case dynamic ++page registration was disabled on the server-side, otherwise not. ++ ++Main memory is not migrated with the aforementioned protocol, ++but is instead migrated with normal RDMA Write operations. ++ ++Pages are migrated in "chunks" (hard-coded to 1 Megabyte right now). ++Chunk size is not dynamic, but it could be in a future implementation. ++There's nothing to indicate that this is useful right now. ++ ++When a chunk is full (or a flush() occurs), the memory backed by ++the chunk is registered with librdmacm is pinned in memory on ++both sides using the aforementioned protocol. ++After pinning, an RDMA Write is generated and transmitted ++for the entire chunk. ++ ++Chunks are also transmitted in batches: This means that we ++do not request that the hardware signal the completion queue ++for the completion of *every* chunk. The current batch size ++is about 64 chunks (corresponding to 64 MB of memory). ++Only the last chunk in a batch must be signaled. ++This helps keep everything as asynchronous as possible ++and helps keep the hardware busy performing RDMA operations. ++ ++Error-handling: ++=============== ++ ++Infiniband has what is called a "Reliable, Connected" ++link (one of 4 choices). This is the mode in which ++we use for RDMA migration. ++ ++If a *single* message fails, ++the decision is to abort the migration entirely and ++cleanup all the RDMA descriptors and unregister all ++the memory. ++ ++After cleanup, the Virtual Machine is returned to normal ++operation the same way that would happen if the TCP ++socket is broken during a non-RDMA based migration. ++ ++TODO: ++===== ++1. 'migrate x-rdma:host:port' and '-incoming x-rdma' options will be ++ renamed to 'rdma' after the experimental phase of this work has ++ completed upstream. ++2. Currently, 'ulimit -l' mlock() limits as well as cgroups swap limits ++ are not compatible with infinband memory pinning and will result in ++ an aborted migration (but with the source VM left unaffected). ++3. Use of the recent /proc//pagemap would likely speed up ++ the use of KSM and ballooning while using RDMA. ++4. Also, some form of balloon-device usage tracking would also ++ help alleviate some issues. +-- +1.7.11.7 + diff --git a/SOURCES/kvm-rdma-allow-state-transitions-between-other-states-be.patch b/SOURCES/kvm-rdma-allow-state-transitions-between-other-states-be.patch new file mode 100644 index 0000000..8db0278 --- /dev/null +++ b/SOURCES/kvm-rdma-allow-state-transitions-between-other-states-be.patch @@ -0,0 +1,110 @@ +From d6d76951c7e02baad0ee5944d4a6b5a5468d0d40 Mon Sep 17 00:00:00 2001 +Message-Id: +In-Reply-To: +References: +From: Nigel Croxon +Date: Thu, 14 Nov 2013 22:52:53 +0100 +Subject: [PATCH 17/46] rdma: allow state transitions between other states + besides ACTIVE + +RH-Author: Nigel Croxon +Message-id: <1384469598-13137-18-git-send-email-ncroxon@redhat.com> +Patchwork-id: 55705 +O-Subject: [RHEL7.0 PATCH 17/42] rdma: allow state transitions between other states besides ACTIVE +Bugzilla: 1011720 +RH-Acked-by: Orit Wasserman +RH-Acked-by: Amit Shah +RH-Acked-by: Paolo Bonzini + +Bugzilla: 1011720 +https://bugzilla.redhat.com/show_bug.cgi?id=1011720 + +>From commit ID: +commit d58f574bf39796ed2396dfd1e308352fbb03f944 +Author: Michael R. Hines +Date: Mon Jul 22 10:01:56 2013 -0400 + + rdma: allow state transitions between other states besides ACTIVE + + This patch is in preparation for the next ones: Until now the MIG_STATE_SETUP + state was not really a 'formal' state. It has been used as a 'zero' state + and QEMU has been unconditionally transitioning into this state when + the QMP migrate command was called. In preparation for timing this state, + we have to make this state a a 'real' state which actually gets transitioned + from later in the migration_thread() from SETUP => ACTIVE, rather than just + automatically dropping into this state at the beginninig of the migration. + + This means that the state transition function (migration_finish_set_state()) + needs to be capable of transitioning from valid states _other_ than just + MIG_STATE_ACTIVE. + + The function is in fact already capable of doing that, but was not allowing the + old state to be a parameter specified as an input. + + This patch fixes that and only makes the transition if the current state + matches the old state that the caller intended to transition from. + + Reviewed-by: Juan Quintela + Tested-by: Michael R. Hines + Signed-off-by: Michael R. Hines + Signed-off-by: Juan Quintela +--- + migration.c | 12 ++++++------ + 1 files changed, 6 insertions(+), 6 deletions(-) + +Signed-off-by: Michal Novotny +--- + migration.c | 12 ++++++------ + 1 file changed, 6 insertions(+), 6 deletions(-) + +diff --git a/migration.c b/migration.c +index 2fa0237..e885bb7 100644 +--- a/migration.c ++++ b/migration.c +@@ -296,9 +296,9 @@ static void migrate_fd_cleanup(void *opaque) + notifier_list_notify(&migration_state_notifiers, s); + } + +-static void migrate_finish_set_state(MigrationState *s, int new_state) ++static void migrate_set_state(MigrationState *s, int old_state, int new_state) + { +- if (atomic_cmpxchg(&s->state, MIG_STATE_ACTIVE, new_state) == new_state) { ++ if (atomic_cmpxchg(&s->state, old_state, new_state) == new_state) { + trace_migrate_set_state(new_state); + } + } +@@ -316,7 +316,7 @@ static void migrate_fd_cancel(MigrationState *s) + { + DPRINTF("cancelling migration\n"); + +- migrate_finish_set_state(s, MIG_STATE_CANCELLED); ++ migrate_set_state(s, s->state, MIG_STATE_CANCELLED); + } + + void add_migration_state_change_notifier(Notifier *notify) +@@ -578,19 +578,19 @@ static void *migration_thread(void *opaque) + qemu_mutex_unlock_iothread(); + + if (ret < 0) { +- migrate_finish_set_state(s, MIG_STATE_ERROR); ++ migrate_set_state(s, MIG_STATE_ACTIVE, MIG_STATE_ERROR); + break; + } + + if (!qemu_file_get_error(s->file)) { +- migrate_finish_set_state(s, MIG_STATE_COMPLETED); ++ migrate_set_state(s, MIG_STATE_ACTIVE, MIG_STATE_COMPLETED); + break; + } + } + } + + if (qemu_file_get_error(s->file)) { +- migrate_finish_set_state(s, MIG_STATE_ERROR); ++ migrate_set_state(s, MIG_STATE_ACTIVE, MIG_STATE_ERROR); + break; + } + current_time = qemu_get_clock_ms(rt_clock); +-- +1.7.11.7 + diff --git a/SOURCES/kvm-rdma-bugfix-make-IPv6-support-work.patch b/SOURCES/kvm-rdma-bugfix-make-IPv6-support-work.patch new file mode 100644 index 0000000..810933a --- /dev/null +++ b/SOURCES/kvm-rdma-bugfix-make-IPv6-support-work.patch @@ -0,0 +1,143 @@ +From e61f1896870d99e21879b95f538b15114d65e9d0 Mon Sep 17 00:00:00 2001 +Message-Id: +In-Reply-To: +References: +From: Nigel Croxon +Date: Thu, 14 Nov 2013 22:52:56 +0100 +Subject: [PATCH 20/46] rdma: bugfix: make IPv6 support work + +RH-Author: Nigel Croxon +Message-id: <1384469598-13137-21-git-send-email-ncroxon@redhat.com> +Patchwork-id: 55725 +O-Subject: [RHEL7.0 PATCH 20/42] rdma: bugfix: make IPv6 support work +Bugzilla: 1011720 +RH-Acked-by: Orit Wasserman +RH-Acked-by: Amit Shah +RH-Acked-by: Paolo Bonzini + +Bugzilla: 1011720 +https://bugzilla.redhat.com/show_bug.cgi?id=1011720 + +>From commit ID: +commit b58c8552bd466aaab67c59dedeb846838082cad6 +Author: Michael R. Hines +Date: Sat Aug 3 22:54:48 2013 -0400 + + rdma: bugfix: make IPv6 support work + + RDMA does not use sockets, so we cannot use many of the socket + helper functions, but we *do* use inet_parse() which gives + RDMA all the necessary details of the connection parameters. + + However, when testing with libvirt, a simple IPv6 migration test failed + because we were not using getaddrinfo() properly. + + This makes IPv6 migration over RDMA work. + + Signed-off-by: Michael R. Hines + Message-id: 1375584894-9917-2-git-send-email-mrhines@linux.vnet.ibm.com + Signed-off-by: Anthony Liguori +--- + migration-rdma.c | 33 +++++++++++++++++++++------------ + 1 files changed, 21 insertions(+), 12 deletions(-) + +Signed-off-by: Michal Novotny +--- + migration-rdma.c | 33 +++++++++++++++++++++------------ + 1 file changed, 21 insertions(+), 12 deletions(-) + +diff --git a/migration-rdma.c b/migration-rdma.c +index d044830..9cf73e3 100644 +--- a/migration-rdma.c ++++ b/migration-rdma.c +@@ -392,6 +392,7 @@ typedef struct RDMAContext { + uint64_t unregistrations[RDMA_SIGNALED_SEND_MAX]; + + GHashTable *blockmap; ++ bool ipv6; + } RDMAContext; + + /* +@@ -744,6 +745,7 @@ static int qemu_rdma_resolve_host(RDMAContext *rdma, Error **errp) + char port_str[16]; + struct rdma_cm_event *cm_event; + char ip[40] = "unknown"; ++ int af = rdma->ipv6 ? PF_INET6 : PF_INET; + + if (rdma->host == NULL || !strcmp(rdma->host, "")) { + ERROR(errp, "RDMA hostname has not been set\n"); +@@ -773,7 +775,7 @@ static int qemu_rdma_resolve_host(RDMAContext *rdma, Error **errp) + goto err_resolve_get_addr; + } + +- inet_ntop(AF_INET, &((struct sockaddr_in *) res->ai_addr)->sin_addr, ++ inet_ntop(af, &((struct sockaddr_in *) res->ai_addr)->sin_addr, + ip, sizeof ip); + DPRINTF("%s => %s\n", rdma->host, ip); + +@@ -2236,9 +2238,12 @@ err_rdma_source_connect: + static int qemu_rdma_dest_init(RDMAContext *rdma, Error **errp) + { + int ret = -EINVAL, idx; ++ int af = rdma->ipv6 ? PF_INET6 : PF_INET; + struct sockaddr_in sin; + struct rdma_cm_id *listen_id; + char ip[40] = "unknown"; ++ struct addrinfo *res; ++ char port_str[16]; + + for (idx = 0; idx <= RDMA_WRID_MAX; idx++) { + rdma->wr_data[idx].control_len = 0; +@@ -2266,27 +2271,30 @@ static int qemu_rdma_dest_init(RDMAContext *rdma, Error **errp) + } + + memset(&sin, 0, sizeof(sin)); +- sin.sin_family = AF_INET; ++ sin.sin_family = af; + sin.sin_port = htons(rdma->port); ++ snprintf(port_str, 16, "%d", rdma->port); ++ port_str[15] = '\0'; + + if (rdma->host && strcmp("", rdma->host)) { +- struct hostent *dest_addr; +- dest_addr = gethostbyname(rdma->host); +- if (!dest_addr) { +- ERROR(errp, "migration could not gethostbyname!\n"); +- ret = -EINVAL; ++ ret = getaddrinfo(rdma->host, port_str, NULL, &res); ++ if (ret < 0) { ++ ERROR(errp, "could not getaddrinfo address %s\n", rdma->host); + goto err_dest_init_bind_addr; + } +- memcpy(&sin.sin_addr.s_addr, dest_addr->h_addr, +- dest_addr->h_length); +- inet_ntop(AF_INET, dest_addr->h_addr, ip, sizeof ip); ++ ++ ++ inet_ntop(af, &((struct sockaddr_in *) res->ai_addr)->sin_addr, ++ ip, sizeof ip); + } else { +- sin.sin_addr.s_addr = INADDR_ANY; ++ ERROR(errp, "migration host and port not specified!\n"); ++ ret = -EINVAL; ++ goto err_dest_init_bind_addr; + } + + DPRINTF("%s => %s\n", rdma->host, ip); + +- ret = rdma_bind_addr(listen_id, (struct sockaddr *)&sin); ++ ret = rdma_bind_addr(listen_id, res->ai_addr); + if (ret) { + ERROR(errp, "Error: could not rdma_bind_addr!\n"); + goto err_dest_init_bind_addr; +@@ -2321,6 +2329,7 @@ static void *qemu_rdma_data_init(const char *host_port, Error **errp) + if (addr != NULL) { + rdma->port = atoi(addr->port); + rdma->host = g_strdup(addr->host); ++ rdma->ipv6 = addr->ipv6; + } else { + ERROR(errp, "bad RDMA migration address '%s'", host_port); + g_free(rdma); +-- +1.7.11.7 + diff --git a/SOURCES/kvm-rdma-bugfix-ram_control_save_page.patch b/SOURCES/kvm-rdma-bugfix-ram_control_save_page.patch new file mode 100644 index 0000000..dc90268 --- /dev/null +++ b/SOURCES/kvm-rdma-bugfix-ram_control_save_page.patch @@ -0,0 +1,57 @@ +From e5cb4139f938fd2f8e6910f92b15173083a3a517 Mon Sep 17 00:00:00 2001 +Message-Id: +In-Reply-To: +References: +From: Nigel Croxon +Date: Thu, 14 Nov 2013 22:52:49 +0100 +Subject: [PATCH 13/46] rdma: bugfix: ram_control_save_page() + +RH-Author: Nigel Croxon +Message-id: <1384469598-13137-14-git-send-email-ncroxon@redhat.com> +Patchwork-id: 55695 +O-Subject: [RHEL7.0 PATCH 13/42] rdma: bugfix: ram_control_save_page() +Bugzilla: 1011720 +RH-Acked-by: Orit Wasserman +RH-Acked-by: Amit Shah +RH-Acked-by: Paolo Bonzini + +Bugzilla: 1011720 +https://bugzilla.redhat.com/show_bug.cgi?id=1011720 + +>From commit ID: +commit de7b685c9e1cf606e37e7116e4c4f03a6ae2d14f +Author: Michael R. Hines +Date: Mon Jul 22 10:01:52 2013 -0400 + + rdma: bugfix: ram_control_save_page() + + We were not checking for a valid 'bytes_sent' pointer before accessing it. + + Reviewed-by: Eric Blake + Signed-off-by: Michael R. Hines + Signed-off-by: Juan Quintela +--- + savevm.c | 2 +- + 1 files changed, 1 insertions(+), 1 deletions(-) + +Signed-off-by: Michal Novotny +--- + savevm.c | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/savevm.c b/savevm.c +index e0491e7..03fc4d9 100644 +--- a/savevm.c ++++ b/savevm.c +@@ -662,7 +662,7 @@ size_t ram_control_save_page(QEMUFile *f, ram_addr_t block_offset, + offset, size, bytes_sent); + + if (ret != RAM_SAVE_CONTROL_DELAYED) { +- if (*bytes_sent > 0) { ++ if (bytes_sent && *bytes_sent > 0) { + qemu_update_position(f, *bytes_sent); + } else if (ret < 0) { + qemu_file_set_error(f, ret); +-- +1.7.11.7 + diff --git a/SOURCES/kvm-rdma-check-if-RDMAControlHeader-len-match-transferre.patch b/SOURCES/kvm-rdma-check-if-RDMAControlHeader-len-match-transferre.patch new file mode 100644 index 0000000..ff1d364 --- /dev/null +++ b/SOURCES/kvm-rdma-check-if-RDMAControlHeader-len-match-transferre.patch @@ -0,0 +1,169 @@ +From 90c28e632cce2d60c8242f5fb3e93f630e6211bc Mon Sep 17 00:00:00 2001 +Message-Id: <90c28e632cce2d60c8242f5fb3e93f630e6211bc.1387382496.git.minovotn@redhat.com> +In-Reply-To: +References: +From: Nigel Croxon +Date: Thu, 14 Nov 2013 22:53:05 +0100 +Subject: [PATCH 29/46] rdma: check if RDMAControlHeader::len match + transferred byte + +RH-Author: Nigel Croxon +Message-id: <1384469598-13137-30-git-send-email-ncroxon@redhat.com> +Patchwork-id: 55718 +O-Subject: [RHEL7.0 PATCH 29/42] rdma: check if RDMAControlHeader::len match transferred byte +Bugzilla: 1011720 +RH-Acked-by: Orit Wasserman +RH-Acked-by: Amit Shah +RH-Acked-by: Paolo Bonzini + +Bugzilla: 1011720 +https://bugzilla.redhat.com/show_bug.cgi?id=1011720 + +>From commit ID: +commit 88571882516a7cb4291a329c537eb79fd126e1f2 +Author: Isaku Yamahata +Date: Fri Aug 9 16:05:42 2013 -0400 + + rdma: check if RDMAControlHeader::len match transferred byte + + RDMAControlHeader::len is provided from remote, so check if the value + match the actual transferred byte_len. + + Reviewed-by: Orit Wasserman + Reviewed-by: Michael R. Hines + Signed-off-by: Isaku Yamahata + Signed-off-by: Michael R. Hines + Message-id: 1376078746-24948-4-git-send-email-mrhines@linux.vnet.ibm.com + Signed-off-by: Anthony Liguori +--- + migration-rdma.c | 32 ++++++++++++++++++++++---------- + 1 files changed, 22 insertions(+), 10 deletions(-) + +Signed-off-by: Michal Novotny +--- + migration-rdma.c | 32 ++++++++++++++++++++++---------- + 1 file changed, 22 insertions(+), 10 deletions(-) + +diff --git a/migration-rdma.c b/migration-rdma.c +index 140d930..9c02ad3 100644 +--- a/migration-rdma.c ++++ b/migration-rdma.c +@@ -1214,7 +1214,8 @@ static void qemu_rdma_signal_unregister(RDMAContext *rdma, uint64_t index, + * (of any kind) has completed. + * Return the work request ID that completed. + */ +-static uint64_t qemu_rdma_poll(RDMAContext *rdma, uint64_t *wr_id_out) ++static uint64_t qemu_rdma_poll(RDMAContext *rdma, uint64_t *wr_id_out, ++ uint32_t *byte_len) + { + int ret; + struct ibv_wc wc; +@@ -1285,6 +1286,9 @@ static uint64_t qemu_rdma_poll(RDMAContext *rdma, uint64_t *wr_id_out) + } + + *wr_id_out = wc.wr_id; ++ if (byte_len) { ++ *byte_len = wc.byte_len; ++ } + + return 0; + } +@@ -1302,7 +1306,8 @@ static uint64_t qemu_rdma_poll(RDMAContext *rdma, uint64_t *wr_id_out) + * completions only need to be recorded, but do not actually + * need further processing. + */ +-static int qemu_rdma_block_for_wrid(RDMAContext *rdma, int wrid_requested) ++static int qemu_rdma_block_for_wrid(RDMAContext *rdma, int wrid_requested, ++ uint32_t *byte_len) + { + int num_cq_events = 0, ret = 0; + struct ibv_cq *cq; +@@ -1314,7 +1319,7 @@ static int qemu_rdma_block_for_wrid(RDMAContext *rdma, int wrid_requested) + } + /* poll cq first */ + while (wr_id != wrid_requested) { +- ret = qemu_rdma_poll(rdma, &wr_id_in); ++ ret = qemu_rdma_poll(rdma, &wr_id_in, byte_len); + if (ret < 0) { + return ret; + } +@@ -1356,7 +1361,7 @@ static int qemu_rdma_block_for_wrid(RDMAContext *rdma, int wrid_requested) + } + + while (wr_id != wrid_requested) { +- ret = qemu_rdma_poll(rdma, &wr_id_in); ++ ret = qemu_rdma_poll(rdma, &wr_id_in, byte_len); + if (ret < 0) { + goto err_block_for_wrid; + } +@@ -1442,7 +1447,7 @@ static int qemu_rdma_post_send_control(RDMAContext *rdma, uint8_t *buf, + return ret; + } + +- ret = qemu_rdma_block_for_wrid(rdma, RDMA_WRID_SEND_CONTROL); ++ ret = qemu_rdma_block_for_wrid(rdma, RDMA_WRID_SEND_CONTROL, NULL); + if (ret < 0) { + fprintf(stderr, "rdma migration: send polling control error!\n"); + } +@@ -1483,7 +1488,9 @@ static int qemu_rdma_post_recv_control(RDMAContext *rdma, int idx) + static int qemu_rdma_exchange_get_response(RDMAContext *rdma, + RDMAControlHeader *head, int expecting, int idx) + { +- int ret = qemu_rdma_block_for_wrid(rdma, RDMA_WRID_RECV_CONTROL + idx); ++ uint32_t byte_len; ++ int ret = qemu_rdma_block_for_wrid(rdma, RDMA_WRID_RECV_CONTROL + idx, ++ &byte_len); + + if (ret < 0) { + fprintf(stderr, "rdma migration: recv polling control error!\n"); +@@ -1509,6 +1516,11 @@ static int qemu_rdma_exchange_get_response(RDMAContext *rdma, + fprintf(stderr, "too long length: %d\n", head->len); + return -EINVAL; + } ++ if (sizeof(*head) + head->len != byte_len) { ++ fprintf(stderr, "Malformed length: %d byte_len %d\n", ++ head->len, byte_len); ++ return -EINVAL; ++ } + + return 0; + } +@@ -1738,7 +1750,7 @@ retry: + count++, current_index, chunk, + sge.addr, length, rdma->nb_sent, block->nb_chunks); + +- ret = qemu_rdma_block_for_wrid(rdma, RDMA_WRID_RDMA_WRITE); ++ ret = qemu_rdma_block_for_wrid(rdma, RDMA_WRID_RDMA_WRITE, NULL); + + if (ret < 0) { + fprintf(stderr, "Failed to Wait for previous write to complete " +@@ -1882,7 +1894,7 @@ retry: + + if (ret == ENOMEM) { + DDPRINTF("send queue is full. wait a little....\n"); +- ret = qemu_rdma_block_for_wrid(rdma, RDMA_WRID_RDMA_WRITE); ++ ret = qemu_rdma_block_for_wrid(rdma, RDMA_WRID_RDMA_WRITE, NULL); + if (ret < 0) { + fprintf(stderr, "rdma migration: failed to make " + "room in full send queue! %d\n", ret); +@@ -2471,7 +2483,7 @@ static int qemu_rdma_drain_cq(QEMUFile *f, RDMAContext *rdma) + } + + while (rdma->nb_sent) { +- ret = qemu_rdma_block_for_wrid(rdma, RDMA_WRID_RDMA_WRITE); ++ ret = qemu_rdma_block_for_wrid(rdma, RDMA_WRID_RDMA_WRITE, NULL); + if (ret < 0) { + fprintf(stderr, "rdma migration: complete polling error!\n"); + return -EIO; +@@ -2607,7 +2619,7 @@ static size_t qemu_rdma_save_page(QEMUFile *f, void *opaque, + */ + while (1) { + uint64_t wr_id, wr_id_in; +- int ret = qemu_rdma_poll(rdma, &wr_id_in); ++ int ret = qemu_rdma_poll(rdma, &wr_id_in, NULL); + if (ret < 0) { + fprintf(stderr, "rdma migration: polling error! %d\n", ret); + goto err; +-- +1.7.11.7 + diff --git a/SOURCES/kvm-rdma-clean-up-of-qemu_rdma_cleanup.patch b/SOURCES/kvm-rdma-clean-up-of-qemu_rdma_cleanup.patch new file mode 100644 index 0000000..140151c --- /dev/null +++ b/SOURCES/kvm-rdma-clean-up-of-qemu_rdma_cleanup.patch @@ -0,0 +1,104 @@ +From d54fad56d67682c441b6e79a14df9ab9867a7b21 Mon Sep 17 00:00:00 2001 +Message-Id: +In-Reply-To: +References: +From: Nigel Croxon +Date: Thu, 14 Nov 2013 22:53:12 +0100 +Subject: [PATCH 36/46] rdma: clean up of qemu_rdma_cleanup() + +RH-Author: Nigel Croxon +Message-id: <1384469598-13137-37-git-send-email-ncroxon@redhat.com> +Patchwork-id: 55726 +O-Subject: [RHEL7.0 PATCH 36/42] rdma: clean up of qemu_rdma_cleanup() +Bugzilla: 1011720 +RH-Acked-by: Orit Wasserman +RH-Acked-by: Amit Shah +RH-Acked-by: Paolo Bonzini + +Bugzilla: 1011720 +https://bugzilla.redhat.com/show_bug.cgi?id=1011720 + +>From commit ID: +commit 5a91337cdf343b94474f8bbecab85a8c00f6d2a1 +Author: Isaku Yamahata +Date: Tue Aug 13 11:12:43 2013 +0900 + + rdma: clean up of qemu_rdma_cleanup() + + - It can't be determined by RDMAContext::cm_id != NULL if the connection + is established or not. + - RDMAContext::cm_id is leaked and not destroyed because it is set to NULL + too early. + - RDMAContext::qp is created by rdma_create_qp() so that it should be destroyed + by rdma_destroy_qp(). not ibv_destroy_qp() + + Cc: Michael R. Hines + Signed-off-by: Isaku Yamahata + Signed-off-by: Juan Quintela +--- + migration-rdma.c | 9 ++++++--- + 1 files changed, 6 insertions(+), 3 deletions(-) + +Signed-off-by: Michal Novotny +--- + migration-rdma.c | 9 ++++++--- + 1 file changed, 6 insertions(+), 3 deletions(-) + +diff --git a/migration-rdma.c b/migration-rdma.c +index 943496f..be3d984 100644 +--- a/migration-rdma.c ++++ b/migration-rdma.c +@@ -356,6 +356,7 @@ typedef struct RDMAContext { + */ + struct rdma_cm_id *cm_id; /* connection manager ID */ + struct rdma_cm_id *listen_id; ++ bool connected; + + struct ibv_context *verbs; + struct rdma_event_channel *channel; +@@ -2194,7 +2195,7 @@ static void qemu_rdma_cleanup(RDMAContext *rdma) + struct rdma_cm_event *cm_event; + int ret, idx; + +- if (rdma->cm_id) { ++ if (rdma->cm_id && rdma->connected) { + if (rdma->error_state) { + RDMAControlHeader head = { .len = 0, + .type = RDMA_CONTROL_ERROR, +@@ -2213,7 +2214,7 @@ static void qemu_rdma_cleanup(RDMAContext *rdma) + } + } + DDPRINTF("Disconnected.\n"); +- rdma->cm_id = NULL; ++ rdma->connected = false; + } + + g_free(rdma->block); +@@ -2235,7 +2236,7 @@ static void qemu_rdma_cleanup(RDMAContext *rdma) + } + + if (rdma->qp) { +- ibv_destroy_qp(rdma->qp); ++ rdma_destroy_qp(rdma->cm_id); + rdma->qp = NULL; + } + if (rdma->cq) { +@@ -2372,6 +2373,7 @@ static int qemu_rdma_connect(RDMAContext *rdma, Error **errp) + rdma->cm_id = NULL; + goto err_rdma_source_connect; + } ++ rdma->connected = true; + + memcpy(&cap, cm_event->param.conn.private_data, sizeof(cap)); + network_to_caps(&cap); +@@ -2906,6 +2908,7 @@ static int qemu_rdma_accept(RDMAContext *rdma) + } + + rdma_ack_cm_event(cm_event); ++ rdma->connected = true; + + ret = qemu_rdma_post_recv_control(rdma, RDMA_WRID_READY); + if (ret) { +-- +1.7.11.7 + diff --git a/SOURCES/kvm-rdma-constify-ram_chunk_-index-start-end.patch b/SOURCES/kvm-rdma-constify-ram_chunk_-index-start-end.patch new file mode 100644 index 0000000..7a48722 --- /dev/null +++ b/SOURCES/kvm-rdma-constify-ram_chunk_-index-start-end.patch @@ -0,0 +1,70 @@ +From 46ab899a1dd2c704e18b5542aa2297d6e342e803 Mon Sep 17 00:00:00 2001 +Message-Id: <46ab899a1dd2c704e18b5542aa2297d6e342e803.1387382496.git.minovotn@redhat.com> +In-Reply-To: +References: +From: Nigel Croxon +Date: Thu, 14 Nov 2013 22:53:13 +0100 +Subject: [PATCH 37/46] rdma: constify ram_chunk_{index, start, end} + +RH-Author: Nigel Croxon +Message-id: <1384469598-13137-38-git-send-email-ncroxon@redhat.com> +Patchwork-id: 55721 +O-Subject: [RHEL7.0 PATCH 37/42] rdma: constify ram_chunk_{index, start, end} +Bugzilla: 1011720 +RH-Acked-by: Orit Wasserman +RH-Acked-by: Amit Shah +RH-Acked-by: Paolo Bonzini + +Bugzilla: 1011720 +https://bugzilla.redhat.com/show_bug.cgi?id=1011720 + +>From commit ID: +commit dd286ed700c6ca2768ac3452bc5b79af1709296a +Author: Isaku Yamahata +Date: Wed Sep 4 11:32:19 2013 +0900 + + rdma: constify ram_chunk_{index, start, end} + + Signed-off-by: Isaku Yamahata + Signed-off-by: Juan Quintela +--- + migration-rdma.c | 8 +++++--- + 1 files changed, 5 insertions(+), 3 deletions(-) + +Signed-off-by: Michal Novotny +--- + migration-rdma.c | 8 +++++--- + 1 file changed, 5 insertions(+), 3 deletions(-) + +diff --git a/migration-rdma.c b/migration-rdma.c +index be3d984..f79be20 100644 +--- a/migration-rdma.c ++++ b/migration-rdma.c +@@ -511,19 +511,21 @@ static int qemu_rdma_exchange_send(RDMAContext *rdma, RDMAControlHeader *head, + int *resp_idx, + int (*callback)(RDMAContext *rdma)); + +-static inline uint64_t ram_chunk_index(uint8_t *start, uint8_t *host) ++static inline uint64_t ram_chunk_index(const uint8_t *start, ++ const uint8_t *host) + { + return ((uintptr_t) host - (uintptr_t) start) >> RDMA_REG_CHUNK_SHIFT; + } + +-static inline uint8_t *ram_chunk_start(RDMALocalBlock *rdma_ram_block, ++static inline uint8_t *ram_chunk_start(const RDMALocalBlock *rdma_ram_block, + uint64_t i) + { + return (uint8_t *) (((uintptr_t) rdma_ram_block->local_host_addr) + + (i << RDMA_REG_CHUNK_SHIFT)); + } + +-static inline uint8_t *ram_chunk_end(RDMALocalBlock *rdma_ram_block, uint64_t i) ++static inline uint8_t *ram_chunk_end(const RDMALocalBlock *rdma_ram_block, ++ uint64_t i) + { + uint8_t *result = ram_chunk_start(rdma_ram_block, i) + + (1UL << RDMA_REG_CHUNK_SHIFT); +-- +1.7.11.7 + diff --git a/SOURCES/kvm-rdma-core-logic.patch b/SOURCES/kvm-rdma-core-logic.patch new file mode 100644 index 0000000..7a43469 --- /dev/null +++ b/SOURCES/kvm-rdma-core-logic.patch @@ -0,0 +1,3468 @@ +From 5d7481d76a57e533f521a5d99ba8d35b5d69625c Mon Sep 17 00:00:00 2001 +Message-Id: <5d7481d76a57e533f521a5d99ba8d35b5d69625c.1387382496.git.minovotn@redhat.com> +In-Reply-To: +References: +From: Nigel Croxon +Date: Thu, 14 Nov 2013 22:52:51 +0100 +Subject: [PATCH 15/46] rdma: core logic + +RH-Author: Nigel Croxon +Message-id: <1384469598-13137-16-git-send-email-ncroxon@redhat.com> +Patchwork-id: 55697 +O-Subject: [RHEL7.0 PATCH 15/42] rdma: core logic +Bugzilla: 1011720 +RH-Acked-by: Orit Wasserman +RH-Acked-by: Amit Shah +RH-Acked-by: Paolo Bonzini + +Bugzilla: 1011720 +https://bugzilla.redhat.com/show_bug.cgi?id=1011720 + +>From commit ID: +commit 2da776db4846eadcb808598a5d3484d149773c05 +Author: Michael R. Hines +Date: Mon Jul 22 10:01:54 2013 -0400 + + rdma: core logic + + Code that does need to be visible is kept + well contained inside this file and this is the only + new additional file to the entire patch. + + This file includes the entire protocol and interfaces + required to perform RDMA migration. + + Also, the configure and Makefile modifications to link + this file are included. + + Full documentation is in docs/rdma.txt + + Reviewed-by: Paolo Bonzini + Reviewed-by: Chegu Vinod + Tested-by: Chegu Vinod + Tested-by: Michael R. Hines + Signed-off-by: Michael R. Hines + Signed-off-by: Juan Quintela +--- + Makefile.objs | 1 + + configure | 40 + + include/migration/migration.h | 4 + + migration-rdma.c | 3249 +++++++++++++++++++++++++++++++++++++++++ + migration.c | 8 + + 5 files changed, 3302 insertions(+), 0 deletions(-) + create mode 100644 migration-rdma.c + +Signed-off-by: Michal Novotny +--- + Makefile.objs | 1 + + configure | 40 + + include/migration/migration.h | 4 + + migration-rdma.c | 3249 +++++++++++++++++++++++++++++++++++++++++ + migration.c | 8 + + 5 files changed, 3302 insertions(+) + create mode 100644 migration-rdma.c + +diff --git a/Makefile.objs b/Makefile.objs +index 286ce06..67b4a28 100644 +--- a/Makefile.objs ++++ b/Makefile.objs +@@ -50,6 +50,7 @@ common-obj-$(CONFIG_POSIX) += os-posix.o + common-obj-$(CONFIG_LINUX) += fsdev/ + + common-obj-y += migration.o migration-tcp.o ++common-obj-$(CONFIG_RDMA) += migration-rdma.o + common-obj-y += qemu-char.o #aio.o + common-obj-y += block-migration.o + common-obj-y += page_cache.o xbzrle.o +diff --git a/configure b/configure +index 0a729ac..33235c4 100755 +--- a/configure ++++ b/configure +@@ -181,6 +181,7 @@ xfs="" + vhost_net="no" + vhost_scsi="no" + kvm="no" ++rdma="" + gprof="no" + debug_tcg="no" + debug="no" +@@ -925,6 +926,10 @@ for opt do + ;; + --enable-gtk) gtk="yes" + ;; ++ --enable-rdma) rdma="yes" ++ ;; ++ --disable-rdma) rdma="no" ++ ;; + --with-gtkabi=*) gtkabi="$optarg" + ;; + --enable-tpm) tpm="yes" +@@ -1151,6 +1156,8 @@ echo " --enable-bluez enable bluez stack connectivity" + echo " --disable-slirp disable SLIRP userspace network connectivity" + echo " --disable-kvm disable KVM acceleration support" + echo " --enable-kvm enable KVM acceleration support" ++echo " --disable-rdma disable RDMA-based migration support" ++echo " --enable-rdma enable RDMA-based migration support" + echo " --enable-tcg-interpreter enable TCG with bytecode interpreter (TCI)" + echo " --disable-nptl disable usermode NPTL support" + echo " --enable-nptl enable usermode NPTL support" +@@ -1846,6 +1853,30 @@ EOF + fi + + ########################################## ++# RDMA needs OpenFabrics libraries ++if test "$rdma" != "no" ; then ++ cat > $TMPC < ++int main(void) { return 0; } ++EOF ++ rdma_libs="-lrdmacm -libverbs" ++ if compile_prog "" "$rdma_libs" ; then ++ rdma="yes" ++ libs_softmmu="$libs_softmmu $rdma_libs" ++ else ++ if test "$rdma" = "yes" ; then ++ error_exit \ ++ " OpenFabrics librdmacm/libibverbs not present." \ ++ " Your options:" \ ++ " (1) Fast: Install infiniband packages from your distro." \ ++ " (2) Cleanest: Install libraries from www.openfabrics.org" \ ++ " (3) Also: Install softiwarp if you don't have RDMA hardware" ++ fi ++ rdma="no" ++ fi ++fi ++ ++########################################## + # VNC TLS/WS detection + if test "$vnc" = "yes" -a \( "$vnc_tls" != "no" -o "$vnc_ws" != "no" \) ; then + cat > $TMPC <> $config_host_mak + fi + ++if test "$rdma" = "yes" ; then ++ echo "CONFIG_RDMA=y" >> $config_host_mak ++fi ++ + if test "$tcg_interpreter" = "yes"; then + QEMU_INCLUDES="-I\$(SRC_PATH)/tcg/tci $QEMU_INCLUDES" + elif test "$ARCH" = "sparc64" ; then +@@ -4506,6 +4542,10 @@ if [ "$pixman" = "internal" ]; then + echo "config-host.h: subdir-pixman" >> $config_host_mak + fi + ++if test "$rdma" = "yes" ; then ++echo "CONFIG_RDMA=y" >> $config_host_mak ++fi ++ + if [ "$dtc_internal" = "yes" ]; then + echo "config-host.h: subdir-dtc" >> $config_host_mak + fi +diff --git a/include/migration/migration.h b/include/migration/migration.h +index 90b5021..13a9629 100644 +--- a/include/migration/migration.h ++++ b/include/migration/migration.h +@@ -77,6 +77,10 @@ void fd_start_incoming_migration(const char *path, Error **errp); + + void fd_start_outgoing_migration(MigrationState *s, const char *fdname, Error **errp); + ++void rdma_start_outgoing_migration(void *opaque, const char *host_port, Error **errp); ++ ++void rdma_start_incoming_migration(const char *host_port, Error **errp); ++ + void migrate_fd_error(MigrationState *s); + + void migrate_fd_connect(MigrationState *s); +diff --git a/migration-rdma.c b/migration-rdma.c +new file mode 100644 +index 0000000..d044830 +--- /dev/null ++++ b/migration-rdma.c +@@ -0,0 +1,3249 @@ ++/* ++ * RDMA protocol and interfaces ++ * ++ * Copyright IBM, Corp. 2010-2013 ++ * ++ * Authors: ++ * Michael R. Hines ++ * Jiuxing Liu ++ * ++ * This work is licensed under the terms of the GNU GPL, version 2 or ++ * later. See the COPYING file in the top-level directory. ++ * ++ */ ++#include "qemu-common.h" ++#include "migration/migration.h" ++#include "migration/qemu-file.h" ++#include "exec/cpu-common.h" ++#include "qemu/main-loop.h" ++#include "qemu/sockets.h" ++#include "qemu/bitmap.h" ++#include "block/coroutine.h" ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++ ++#define DEBUG_RDMA ++//#define DEBUG_RDMA_VERBOSE ++//#define DEBUG_RDMA_REALLY_VERBOSE ++ ++#ifdef DEBUG_RDMA ++#define DPRINTF(fmt, ...) \ ++ do { printf("rdma: " fmt, ## __VA_ARGS__); } while (0) ++#else ++#define DPRINTF(fmt, ...) \ ++ do { } while (0) ++#endif ++ ++#ifdef DEBUG_RDMA_VERBOSE ++#define DDPRINTF(fmt, ...) \ ++ do { printf("rdma: " fmt, ## __VA_ARGS__); } while (0) ++#else ++#define DDPRINTF(fmt, ...) \ ++ do { } while (0) ++#endif ++ ++#ifdef DEBUG_RDMA_REALLY_VERBOSE ++#define DDDPRINTF(fmt, ...) \ ++ do { printf("rdma: " fmt, ## __VA_ARGS__); } while (0) ++#else ++#define DDDPRINTF(fmt, ...) \ ++ do { } while (0) ++#endif ++ ++/* ++ * Print and error on both the Monitor and the Log file. ++ */ ++#define ERROR(errp, fmt, ...) \ ++ do { \ ++ fprintf(stderr, "RDMA ERROR: " fmt, ## __VA_ARGS__); \ ++ if (errp && (*(errp) == NULL)) { \ ++ error_setg(errp, "RDMA ERROR: " fmt, ## __VA_ARGS__); \ ++ } \ ++ } while (0) ++ ++#define RDMA_RESOLVE_TIMEOUT_MS 10000 ++ ++/* Do not merge data if larger than this. */ ++#define RDMA_MERGE_MAX (2 * 1024 * 1024) ++#define RDMA_SIGNALED_SEND_MAX (RDMA_MERGE_MAX / 4096) ++ ++#define RDMA_REG_CHUNK_SHIFT 20 /* 1 MB */ ++ ++/* ++ * This is only for non-live state being migrated. ++ * Instead of RDMA_WRITE messages, we use RDMA_SEND ++ * messages for that state, which requires a different ++ * delivery design than main memory. ++ */ ++#define RDMA_SEND_INCREMENT 32768 ++ ++/* ++ * Maximum size infiniband SEND message ++ */ ++#define RDMA_CONTROL_MAX_BUFFER (512 * 1024) ++#define RDMA_CONTROL_MAX_COMMANDS_PER_MESSAGE 4096 ++ ++#define RDMA_CONTROL_VERSION_CURRENT 1 ++/* ++ * Capabilities for negotiation. ++ */ ++#define RDMA_CAPABILITY_PIN_ALL 0x01 ++ ++/* ++ * Add the other flags above to this list of known capabilities ++ * as they are introduced. ++ */ ++static uint32_t known_capabilities = RDMA_CAPABILITY_PIN_ALL; ++ ++#define CHECK_ERROR_STATE() \ ++ do { \ ++ if (rdma->error_state) { \ ++ if (!rdma->error_reported) { \ ++ fprintf(stderr, "RDMA is in an error state waiting migration" \ ++ " to abort!\n"); \ ++ rdma->error_reported = 1; \ ++ } \ ++ return rdma->error_state; \ ++ } \ ++ } while (0); ++ ++/* ++ * A work request ID is 64-bits and we split up these bits ++ * into 3 parts: ++ * ++ * bits 0-15 : type of control message, 2^16 ++ * bits 16-29: ram block index, 2^14 ++ * bits 30-63: ram block chunk number, 2^34 ++ * ++ * The last two bit ranges are only used for RDMA writes, ++ * in order to track their completion and potentially ++ * also track unregistration status of the message. ++ */ ++#define RDMA_WRID_TYPE_SHIFT 0UL ++#define RDMA_WRID_BLOCK_SHIFT 16UL ++#define RDMA_WRID_CHUNK_SHIFT 30UL ++ ++#define RDMA_WRID_TYPE_MASK \ ++ ((1UL << RDMA_WRID_BLOCK_SHIFT) - 1UL) ++ ++#define RDMA_WRID_BLOCK_MASK \ ++ (~RDMA_WRID_TYPE_MASK & ((1UL << RDMA_WRID_CHUNK_SHIFT) - 1UL)) ++ ++#define RDMA_WRID_CHUNK_MASK (~RDMA_WRID_BLOCK_MASK & ~RDMA_WRID_TYPE_MASK) ++ ++/* ++ * RDMA migration protocol: ++ * 1. RDMA Writes (data messages, i.e. RAM) ++ * 2. IB Send/Recv (control channel messages) ++ */ ++enum { ++ RDMA_WRID_NONE = 0, ++ RDMA_WRID_RDMA_WRITE = 1, ++ RDMA_WRID_SEND_CONTROL = 2000, ++ RDMA_WRID_RECV_CONTROL = 4000, ++}; ++ ++const char *wrid_desc[] = { ++ [RDMA_WRID_NONE] = "NONE", ++ [RDMA_WRID_RDMA_WRITE] = "WRITE RDMA", ++ [RDMA_WRID_SEND_CONTROL] = "CONTROL SEND", ++ [RDMA_WRID_RECV_CONTROL] = "CONTROL RECV", ++}; ++ ++/* ++ * Work request IDs for IB SEND messages only (not RDMA writes). ++ * This is used by the migration protocol to transmit ++ * control messages (such as device state and registration commands) ++ * ++ * We could use more WRs, but we have enough for now. ++ */ ++enum { ++ RDMA_WRID_READY = 0, ++ RDMA_WRID_DATA, ++ RDMA_WRID_CONTROL, ++ RDMA_WRID_MAX, ++}; ++ ++/* ++ * SEND/RECV IB Control Messages. ++ */ ++enum { ++ RDMA_CONTROL_NONE = 0, ++ RDMA_CONTROL_ERROR, ++ RDMA_CONTROL_READY, /* ready to receive */ ++ RDMA_CONTROL_QEMU_FILE, /* QEMUFile-transmitted bytes */ ++ RDMA_CONTROL_RAM_BLOCKS_REQUEST, /* RAMBlock synchronization */ ++ RDMA_CONTROL_RAM_BLOCKS_RESULT, /* RAMBlock synchronization */ ++ RDMA_CONTROL_COMPRESS, /* page contains repeat values */ ++ RDMA_CONTROL_REGISTER_REQUEST, /* dynamic page registration */ ++ RDMA_CONTROL_REGISTER_RESULT, /* key to use after registration */ ++ RDMA_CONTROL_REGISTER_FINISHED, /* current iteration finished */ ++ RDMA_CONTROL_UNREGISTER_REQUEST, /* dynamic UN-registration */ ++ RDMA_CONTROL_UNREGISTER_FINISHED, /* unpinning finished */ ++}; ++ ++const char *control_desc[] = { ++ [RDMA_CONTROL_NONE] = "NONE", ++ [RDMA_CONTROL_ERROR] = "ERROR", ++ [RDMA_CONTROL_READY] = "READY", ++ [RDMA_CONTROL_QEMU_FILE] = "QEMU FILE", ++ [RDMA_CONTROL_RAM_BLOCKS_REQUEST] = "RAM BLOCKS REQUEST", ++ [RDMA_CONTROL_RAM_BLOCKS_RESULT] = "RAM BLOCKS RESULT", ++ [RDMA_CONTROL_COMPRESS] = "COMPRESS", ++ [RDMA_CONTROL_REGISTER_REQUEST] = "REGISTER REQUEST", ++ [RDMA_CONTROL_REGISTER_RESULT] = "REGISTER RESULT", ++ [RDMA_CONTROL_REGISTER_FINISHED] = "REGISTER FINISHED", ++ [RDMA_CONTROL_UNREGISTER_REQUEST] = "UNREGISTER REQUEST", ++ [RDMA_CONTROL_UNREGISTER_FINISHED] = "UNREGISTER FINISHED", ++}; ++ ++/* ++ * Memory and MR structures used to represent an IB Send/Recv work request. ++ * This is *not* used for RDMA writes, only IB Send/Recv. ++ */ ++typedef struct { ++ uint8_t control[RDMA_CONTROL_MAX_BUFFER]; /* actual buffer to register */ ++ struct ibv_mr *control_mr; /* registration metadata */ ++ size_t control_len; /* length of the message */ ++ uint8_t *control_curr; /* start of unconsumed bytes */ ++} RDMAWorkRequestData; ++ ++/* ++ * Negotiate RDMA capabilities during connection-setup time. ++ */ ++typedef struct { ++ uint32_t version; ++ uint32_t flags; ++} RDMACapabilities; ++ ++static void caps_to_network(RDMACapabilities *cap) ++{ ++ cap->version = htonl(cap->version); ++ cap->flags = htonl(cap->flags); ++} ++ ++static void network_to_caps(RDMACapabilities *cap) ++{ ++ cap->version = ntohl(cap->version); ++ cap->flags = ntohl(cap->flags); ++} ++ ++/* ++ * Representation of a RAMBlock from an RDMA perspective. ++ * This is not transmitted, only local. ++ * This and subsequent structures cannot be linked lists ++ * because we're using a single IB message to transmit ++ * the information. It's small anyway, so a list is overkill. ++ */ ++typedef struct RDMALocalBlock { ++ uint8_t *local_host_addr; /* local virtual address */ ++ uint64_t remote_host_addr; /* remote virtual address */ ++ uint64_t offset; ++ uint64_t length; ++ struct ibv_mr **pmr; /* MRs for chunk-level registration */ ++ struct ibv_mr *mr; /* MR for non-chunk-level registration */ ++ uint32_t *remote_keys; /* rkeys for chunk-level registration */ ++ uint32_t remote_rkey; /* rkeys for non-chunk-level registration */ ++ int index; /* which block are we */ ++ bool is_ram_block; ++ int nb_chunks; ++ unsigned long *transit_bitmap; ++ unsigned long *unregister_bitmap; ++} RDMALocalBlock; ++ ++/* ++ * Also represents a RAMblock, but only on the dest. ++ * This gets transmitted by the dest during connection-time ++ * to the source VM and then is used to populate the ++ * corresponding RDMALocalBlock with ++ * the information needed to perform the actual RDMA. ++ */ ++typedef struct QEMU_PACKED RDMARemoteBlock { ++ uint64_t remote_host_addr; ++ uint64_t offset; ++ uint64_t length; ++ uint32_t remote_rkey; ++ uint32_t padding; ++} RDMARemoteBlock; ++ ++static uint64_t htonll(uint64_t v) ++{ ++ union { uint32_t lv[2]; uint64_t llv; } u; ++ u.lv[0] = htonl(v >> 32); ++ u.lv[1] = htonl(v & 0xFFFFFFFFULL); ++ return u.llv; ++} ++ ++static uint64_t ntohll(uint64_t v) { ++ union { uint32_t lv[2]; uint64_t llv; } u; ++ u.llv = v; ++ return ((uint64_t)ntohl(u.lv[0]) << 32) | (uint64_t) ntohl(u.lv[1]); ++} ++ ++static void remote_block_to_network(RDMARemoteBlock *rb) ++{ ++ rb->remote_host_addr = htonll(rb->remote_host_addr); ++ rb->offset = htonll(rb->offset); ++ rb->length = htonll(rb->length); ++ rb->remote_rkey = htonl(rb->remote_rkey); ++} ++ ++static void network_to_remote_block(RDMARemoteBlock *rb) ++{ ++ rb->remote_host_addr = ntohll(rb->remote_host_addr); ++ rb->offset = ntohll(rb->offset); ++ rb->length = ntohll(rb->length); ++ rb->remote_rkey = ntohl(rb->remote_rkey); ++} ++ ++/* ++ * Virtual address of the above structures used for transmitting ++ * the RAMBlock descriptions at connection-time. ++ * This structure is *not* transmitted. ++ */ ++typedef struct RDMALocalBlocks { ++ int nb_blocks; ++ bool init; /* main memory init complete */ ++ RDMALocalBlock *block; ++} RDMALocalBlocks; ++ ++/* ++ * Main data structure for RDMA state. ++ * While there is only one copy of this structure being allocated right now, ++ * this is the place where one would start if you wanted to consider ++ * having more than one RDMA connection open at the same time. ++ */ ++typedef struct RDMAContext { ++ char *host; ++ int port; ++ ++ RDMAWorkRequestData wr_data[RDMA_WRID_MAX + 1]; ++ ++ /* ++ * This is used by *_exchange_send() to figure out whether or not ++ * the initial "READY" message has already been received or not. ++ * This is because other functions may potentially poll() and detect ++ * the READY message before send() does, in which case we need to ++ * know if it completed. ++ */ ++ int control_ready_expected; ++ ++ /* number of outstanding writes */ ++ int nb_sent; ++ ++ /* store info about current buffer so that we can ++ merge it with future sends */ ++ uint64_t current_addr; ++ uint64_t current_length; ++ /* index of ram block the current buffer belongs to */ ++ int current_index; ++ /* index of the chunk in the current ram block */ ++ int current_chunk; ++ ++ bool pin_all; ++ ++ /* ++ * infiniband-specific variables for opening the device ++ * and maintaining connection state and so forth. ++ * ++ * cm_id also has ibv_context, rdma_event_channel, and ibv_qp in ++ * cm_id->verbs, cm_id->channel, and cm_id->qp. ++ */ ++ struct rdma_cm_id *cm_id; /* connection manager ID */ ++ struct rdma_cm_id *listen_id; ++ ++ struct ibv_context *verbs; ++ struct rdma_event_channel *channel; ++ struct ibv_qp *qp; /* queue pair */ ++ struct ibv_comp_channel *comp_channel; /* completion channel */ ++ struct ibv_pd *pd; /* protection domain */ ++ struct ibv_cq *cq; /* completion queue */ ++ ++ /* ++ * If a previous write failed (perhaps because of a failed ++ * memory registration, then do not attempt any future work ++ * and remember the error state. ++ */ ++ int error_state; ++ int error_reported; ++ ++ /* ++ * Description of ram blocks used throughout the code. ++ */ ++ RDMALocalBlocks local_ram_blocks; ++ RDMARemoteBlock *block; ++ ++ /* ++ * Migration on *destination* started. ++ * Then use coroutine yield function. ++ * Source runs in a thread, so we don't care. ++ */ ++ int migration_started_on_destination; ++ ++ int total_registrations; ++ int total_writes; ++ ++ int unregister_current, unregister_next; ++ uint64_t unregistrations[RDMA_SIGNALED_SEND_MAX]; ++ ++ GHashTable *blockmap; ++} RDMAContext; ++ ++/* ++ * Interface to the rest of the migration call stack. ++ */ ++typedef struct QEMUFileRDMA { ++ RDMAContext *rdma; ++ size_t len; ++ void *file; ++} QEMUFileRDMA; ++ ++/* ++ * Main structure for IB Send/Recv control messages. ++ * This gets prepended at the beginning of every Send/Recv. ++ */ ++typedef struct QEMU_PACKED { ++ uint32_t len; /* Total length of data portion */ ++ uint32_t type; /* which control command to perform */ ++ uint32_t repeat; /* number of commands in data portion of same type */ ++ uint32_t padding; ++} RDMAControlHeader; ++ ++static void control_to_network(RDMAControlHeader *control) ++{ ++ control->type = htonl(control->type); ++ control->len = htonl(control->len); ++ control->repeat = htonl(control->repeat); ++} ++ ++static void network_to_control(RDMAControlHeader *control) ++{ ++ control->type = ntohl(control->type); ++ control->len = ntohl(control->len); ++ control->repeat = ntohl(control->repeat); ++} ++ ++/* ++ * Register a single Chunk. ++ * Information sent by the source VM to inform the dest ++ * to register an single chunk of memory before we can perform ++ * the actual RDMA operation. ++ */ ++typedef struct QEMU_PACKED { ++ union QEMU_PACKED { ++ uint64_t current_addr; /* offset into the ramblock of the chunk */ ++ uint64_t chunk; /* chunk to lookup if unregistering */ ++ } key; ++ uint32_t current_index; /* which ramblock the chunk belongs to */ ++ uint32_t padding; ++ uint64_t chunks; /* how many sequential chunks to register */ ++} RDMARegister; ++ ++static void register_to_network(RDMARegister *reg) ++{ ++ reg->key.current_addr = htonll(reg->key.current_addr); ++ reg->current_index = htonl(reg->current_index); ++ reg->chunks = htonll(reg->chunks); ++} ++ ++static void network_to_register(RDMARegister *reg) ++{ ++ reg->key.current_addr = ntohll(reg->key.current_addr); ++ reg->current_index = ntohl(reg->current_index); ++ reg->chunks = ntohll(reg->chunks); ++} ++ ++typedef struct QEMU_PACKED { ++ uint32_t value; /* if zero, we will madvise() */ ++ uint32_t block_idx; /* which ram block index */ ++ uint64_t offset; /* where in the remote ramblock this chunk */ ++ uint64_t length; /* length of the chunk */ ++} RDMACompress; ++ ++static void compress_to_network(RDMACompress *comp) ++{ ++ comp->value = htonl(comp->value); ++ comp->block_idx = htonl(comp->block_idx); ++ comp->offset = htonll(comp->offset); ++ comp->length = htonll(comp->length); ++} ++ ++static void network_to_compress(RDMACompress *comp) ++{ ++ comp->value = ntohl(comp->value); ++ comp->block_idx = ntohl(comp->block_idx); ++ comp->offset = ntohll(comp->offset); ++ comp->length = ntohll(comp->length); ++} ++ ++/* ++ * The result of the dest's memory registration produces an "rkey" ++ * which the source VM must reference in order to perform ++ * the RDMA operation. ++ */ ++typedef struct QEMU_PACKED { ++ uint32_t rkey; ++ uint32_t padding; ++ uint64_t host_addr; ++} RDMARegisterResult; ++ ++static void result_to_network(RDMARegisterResult *result) ++{ ++ result->rkey = htonl(result->rkey); ++ result->host_addr = htonll(result->host_addr); ++}; ++ ++static void network_to_result(RDMARegisterResult *result) ++{ ++ result->rkey = ntohl(result->rkey); ++ result->host_addr = ntohll(result->host_addr); ++}; ++ ++const char *print_wrid(int wrid); ++static int qemu_rdma_exchange_send(RDMAContext *rdma, RDMAControlHeader *head, ++ uint8_t *data, RDMAControlHeader *resp, ++ int *resp_idx, ++ int (*callback)(RDMAContext *rdma)); ++ ++static inline uint64_t ram_chunk_index(uint8_t *start, uint8_t *host) ++{ ++ return ((uintptr_t) host - (uintptr_t) start) >> RDMA_REG_CHUNK_SHIFT; ++} ++ ++static inline uint8_t *ram_chunk_start(RDMALocalBlock *rdma_ram_block, ++ uint64_t i) ++{ ++ return (uint8_t *) (((uintptr_t) rdma_ram_block->local_host_addr) ++ + (i << RDMA_REG_CHUNK_SHIFT)); ++} ++ ++static inline uint8_t *ram_chunk_end(RDMALocalBlock *rdma_ram_block, uint64_t i) ++{ ++ uint8_t *result = ram_chunk_start(rdma_ram_block, i) + ++ (1UL << RDMA_REG_CHUNK_SHIFT); ++ ++ if (result > (rdma_ram_block->local_host_addr + rdma_ram_block->length)) { ++ result = rdma_ram_block->local_host_addr + rdma_ram_block->length; ++ } ++ ++ return result; ++} ++ ++static int __qemu_rdma_add_block(RDMAContext *rdma, void *host_addr, ++ ram_addr_t block_offset, uint64_t length) ++{ ++ RDMALocalBlocks *local = &rdma->local_ram_blocks; ++ RDMALocalBlock *block = g_hash_table_lookup(rdma->blockmap, ++ (void *) block_offset); ++ RDMALocalBlock *old = local->block; ++ ++ assert(block == NULL); ++ ++ local->block = g_malloc0(sizeof(RDMALocalBlock) * (local->nb_blocks + 1)); ++ ++ if (local->nb_blocks) { ++ int x; ++ ++ for (x = 0; x < local->nb_blocks; x++) { ++ g_hash_table_remove(rdma->blockmap, (void *)old[x].offset); ++ g_hash_table_insert(rdma->blockmap, (void *)old[x].offset, ++ &local->block[x]); ++ } ++ memcpy(local->block, old, sizeof(RDMALocalBlock) * local->nb_blocks); ++ g_free(old); ++ } ++ ++ block = &local->block[local->nb_blocks]; ++ ++ block->local_host_addr = host_addr; ++ block->offset = block_offset; ++ block->length = length; ++ block->index = local->nb_blocks; ++ block->nb_chunks = ram_chunk_index(host_addr, host_addr + length) + 1UL; ++ block->transit_bitmap = bitmap_new(block->nb_chunks); ++ bitmap_clear(block->transit_bitmap, 0, block->nb_chunks); ++ block->unregister_bitmap = bitmap_new(block->nb_chunks); ++ bitmap_clear(block->unregister_bitmap, 0, block->nb_chunks); ++ block->remote_keys = g_malloc0(block->nb_chunks * sizeof(uint32_t)); ++ ++ block->is_ram_block = local->init ? false : true; ++ ++ g_hash_table_insert(rdma->blockmap, (void *) block_offset, block); ++ ++ DDPRINTF("Added Block: %d, addr: %" PRIu64 ", offset: %" PRIu64 ++ " length: %" PRIu64 " end: %" PRIu64 " bits %" PRIu64 " chunks %d\n", ++ local->nb_blocks, (uint64_t) block->local_host_addr, block->offset, ++ block->length, (uint64_t) (block->local_host_addr + block->length), ++ BITS_TO_LONGS(block->nb_chunks) * ++ sizeof(unsigned long) * 8, block->nb_chunks); ++ ++ local->nb_blocks++; ++ ++ return 0; ++} ++ ++/* ++ * Memory regions need to be registered with the device and queue pairs setup ++ * in advanced before the migration starts. This tells us where the RAM blocks ++ * are so that we can register them individually. ++ */ ++static void qemu_rdma_init_one_block(void *host_addr, ++ ram_addr_t block_offset, ram_addr_t length, void *opaque) ++{ ++ __qemu_rdma_add_block(opaque, host_addr, block_offset, length); ++} ++ ++/* ++ * Identify the RAMBlocks and their quantity. They will be references to ++ * identify chunk boundaries inside each RAMBlock and also be referenced ++ * during dynamic page registration. ++ */ ++static int qemu_rdma_init_ram_blocks(RDMAContext *rdma) ++{ ++ RDMALocalBlocks *local = &rdma->local_ram_blocks; ++ ++ assert(rdma->blockmap == NULL); ++ rdma->blockmap = g_hash_table_new(g_direct_hash, g_direct_equal); ++ memset(local, 0, sizeof *local); ++ qemu_ram_foreach_block(qemu_rdma_init_one_block, rdma); ++ DPRINTF("Allocated %d local ram block structures\n", local->nb_blocks); ++ rdma->block = (RDMARemoteBlock *) g_malloc0(sizeof(RDMARemoteBlock) * ++ rdma->local_ram_blocks.nb_blocks); ++ local->init = true; ++ return 0; ++} ++ ++static int __qemu_rdma_delete_block(RDMAContext *rdma, ram_addr_t block_offset) ++{ ++ RDMALocalBlocks *local = &rdma->local_ram_blocks; ++ RDMALocalBlock *block = g_hash_table_lookup(rdma->blockmap, ++ (void *) block_offset); ++ RDMALocalBlock *old = local->block; ++ int x; ++ ++ assert(block); ++ ++ if (block->pmr) { ++ int j; ++ ++ for (j = 0; j < block->nb_chunks; j++) { ++ if (!block->pmr[j]) { ++ continue; ++ } ++ ibv_dereg_mr(block->pmr[j]); ++ rdma->total_registrations--; ++ } ++ g_free(block->pmr); ++ block->pmr = NULL; ++ } ++ ++ if (block->mr) { ++ ibv_dereg_mr(block->mr); ++ rdma->total_registrations--; ++ block->mr = NULL; ++ } ++ ++ g_free(block->transit_bitmap); ++ block->transit_bitmap = NULL; ++ ++ g_free(block->unregister_bitmap); ++ block->unregister_bitmap = NULL; ++ ++ g_free(block->remote_keys); ++ block->remote_keys = NULL; ++ ++ for (x = 0; x < local->nb_blocks; x++) { ++ g_hash_table_remove(rdma->blockmap, (void *)old[x].offset); ++ } ++ ++ if (local->nb_blocks > 1) { ++ ++ local->block = g_malloc0(sizeof(RDMALocalBlock) * ++ (local->nb_blocks - 1)); ++ ++ if (block->index) { ++ memcpy(local->block, old, sizeof(RDMALocalBlock) * block->index); ++ } ++ ++ if (block->index < (local->nb_blocks - 1)) { ++ memcpy(local->block + block->index, old + (block->index + 1), ++ sizeof(RDMALocalBlock) * ++ (local->nb_blocks - (block->index + 1))); ++ } ++ } else { ++ assert(block == local->block); ++ local->block = NULL; ++ } ++ ++ DDPRINTF("Deleted Block: %d, addr: %" PRIu64 ", offset: %" PRIu64 ++ " length: %" PRIu64 " end: %" PRIu64 " bits %" PRIu64 " chunks %d\n", ++ local->nb_blocks, (uint64_t) block->local_host_addr, block->offset, ++ block->length, (uint64_t) (block->local_host_addr + block->length), ++ BITS_TO_LONGS(block->nb_chunks) * ++ sizeof(unsigned long) * 8, block->nb_chunks); ++ ++ g_free(old); ++ ++ local->nb_blocks--; ++ ++ if (local->nb_blocks) { ++ for (x = 0; x < local->nb_blocks; x++) { ++ g_hash_table_insert(rdma->blockmap, (void *)local->block[x].offset, ++ &local->block[x]); ++ } ++ } ++ ++ return 0; ++} ++ ++/* ++ * Put in the log file which RDMA device was opened and the details ++ * associated with that device. ++ */ ++static void qemu_rdma_dump_id(const char *who, struct ibv_context *verbs) ++{ ++ printf("%s RDMA Device opened: kernel name %s " ++ "uverbs device name %s, " ++ "infiniband_verbs class device path %s," ++ " infiniband class device path %s\n", ++ who, ++ verbs->device->name, ++ verbs->device->dev_name, ++ verbs->device->dev_path, ++ verbs->device->ibdev_path); ++} ++ ++/* ++ * Put in the log file the RDMA gid addressing information, ++ * useful for folks who have trouble understanding the ++ * RDMA device hierarchy in the kernel. ++ */ ++static void qemu_rdma_dump_gid(const char *who, struct rdma_cm_id *id) ++{ ++ char sgid[33]; ++ char dgid[33]; ++ inet_ntop(AF_INET6, &id->route.addr.addr.ibaddr.sgid, sgid, sizeof sgid); ++ inet_ntop(AF_INET6, &id->route.addr.addr.ibaddr.dgid, dgid, sizeof dgid); ++ DPRINTF("%s Source GID: %s, Dest GID: %s\n", who, sgid, dgid); ++} ++ ++/* ++ * Figure out which RDMA device corresponds to the requested IP hostname ++ * Also create the initial connection manager identifiers for opening ++ * the connection. ++ */ ++static int qemu_rdma_resolve_host(RDMAContext *rdma, Error **errp) ++{ ++ int ret; ++ struct addrinfo *res; ++ char port_str[16]; ++ struct rdma_cm_event *cm_event; ++ char ip[40] = "unknown"; ++ ++ if (rdma->host == NULL || !strcmp(rdma->host, "")) { ++ ERROR(errp, "RDMA hostname has not been set\n"); ++ return -1; ++ } ++ ++ /* create CM channel */ ++ rdma->channel = rdma_create_event_channel(); ++ if (!rdma->channel) { ++ ERROR(errp, "could not create CM channel\n"); ++ return -1; ++ } ++ ++ /* create CM id */ ++ ret = rdma_create_id(rdma->channel, &rdma->cm_id, NULL, RDMA_PS_TCP); ++ if (ret) { ++ ERROR(errp, "could not create channel id\n"); ++ goto err_resolve_create_id; ++ } ++ ++ snprintf(port_str, 16, "%d", rdma->port); ++ port_str[15] = '\0'; ++ ++ ret = getaddrinfo(rdma->host, port_str, NULL, &res); ++ if (ret < 0) { ++ ERROR(errp, "could not getaddrinfo address %s\n", rdma->host); ++ goto err_resolve_get_addr; ++ } ++ ++ inet_ntop(AF_INET, &((struct sockaddr_in *) res->ai_addr)->sin_addr, ++ ip, sizeof ip); ++ DPRINTF("%s => %s\n", rdma->host, ip); ++ ++ /* resolve the first address */ ++ ret = rdma_resolve_addr(rdma->cm_id, NULL, res->ai_addr, ++ RDMA_RESOLVE_TIMEOUT_MS); ++ if (ret) { ++ ERROR(errp, "could not resolve address %s\n", rdma->host); ++ goto err_resolve_get_addr; ++ } ++ ++ qemu_rdma_dump_gid("source_resolve_addr", rdma->cm_id); ++ ++ ret = rdma_get_cm_event(rdma->channel, &cm_event); ++ if (ret) { ++ ERROR(errp, "could not perform event_addr_resolved\n"); ++ goto err_resolve_get_addr; ++ } ++ ++ if (cm_event->event != RDMA_CM_EVENT_ADDR_RESOLVED) { ++ ERROR(errp, "result not equal to event_addr_resolved %s\n", ++ rdma_event_str(cm_event->event)); ++ perror("rdma_resolve_addr"); ++ goto err_resolve_get_addr; ++ } ++ rdma_ack_cm_event(cm_event); ++ ++ /* resolve route */ ++ ret = rdma_resolve_route(rdma->cm_id, RDMA_RESOLVE_TIMEOUT_MS); ++ if (ret) { ++ ERROR(errp, "could not resolve rdma route\n"); ++ goto err_resolve_get_addr; ++ } ++ ++ ret = rdma_get_cm_event(rdma->channel, &cm_event); ++ if (ret) { ++ ERROR(errp, "could not perform event_route_resolved\n"); ++ goto err_resolve_get_addr; ++ } ++ if (cm_event->event != RDMA_CM_EVENT_ROUTE_RESOLVED) { ++ ERROR(errp, "result not equal to event_route_resolved: %s\n", ++ rdma_event_str(cm_event->event)); ++ rdma_ack_cm_event(cm_event); ++ goto err_resolve_get_addr; ++ } ++ rdma_ack_cm_event(cm_event); ++ rdma->verbs = rdma->cm_id->verbs; ++ qemu_rdma_dump_id("source_resolve_host", rdma->cm_id->verbs); ++ qemu_rdma_dump_gid("source_resolve_host", rdma->cm_id); ++ return 0; ++ ++err_resolve_get_addr: ++ rdma_destroy_id(rdma->cm_id); ++ rdma->cm_id = NULL; ++err_resolve_create_id: ++ rdma_destroy_event_channel(rdma->channel); ++ rdma->channel = NULL; ++ ++ return -1; ++} ++ ++/* ++ * Create protection domain and completion queues ++ */ ++static int qemu_rdma_alloc_pd_cq(RDMAContext *rdma) ++{ ++ /* allocate pd */ ++ rdma->pd = ibv_alloc_pd(rdma->verbs); ++ if (!rdma->pd) { ++ fprintf(stderr, "failed to allocate protection domain\n"); ++ return -1; ++ } ++ ++ /* create completion channel */ ++ rdma->comp_channel = ibv_create_comp_channel(rdma->verbs); ++ if (!rdma->comp_channel) { ++ fprintf(stderr, "failed to allocate completion channel\n"); ++ goto err_alloc_pd_cq; ++ } ++ ++ /* ++ * Completion queue can be filled by both read and write work requests, ++ * so must reflect the sum of both possible queue sizes. ++ */ ++ rdma->cq = ibv_create_cq(rdma->verbs, (RDMA_SIGNALED_SEND_MAX * 3), ++ NULL, rdma->comp_channel, 0); ++ if (!rdma->cq) { ++ fprintf(stderr, "failed to allocate completion queue\n"); ++ goto err_alloc_pd_cq; ++ } ++ ++ return 0; ++ ++err_alloc_pd_cq: ++ if (rdma->pd) { ++ ibv_dealloc_pd(rdma->pd); ++ } ++ if (rdma->comp_channel) { ++ ibv_destroy_comp_channel(rdma->comp_channel); ++ } ++ rdma->pd = NULL; ++ rdma->comp_channel = NULL; ++ return -1; ++ ++} ++ ++/* ++ * Create queue pairs. ++ */ ++static int qemu_rdma_alloc_qp(RDMAContext *rdma) ++{ ++ struct ibv_qp_init_attr attr = { 0 }; ++ int ret; ++ ++ attr.cap.max_send_wr = RDMA_SIGNALED_SEND_MAX; ++ attr.cap.max_recv_wr = 3; ++ attr.cap.max_send_sge = 1; ++ attr.cap.max_recv_sge = 1; ++ attr.send_cq = rdma->cq; ++ attr.recv_cq = rdma->cq; ++ attr.qp_type = IBV_QPT_RC; ++ ++ ret = rdma_create_qp(rdma->cm_id, rdma->pd, &attr); ++ if (ret) { ++ return -1; ++ } ++ ++ rdma->qp = rdma->cm_id->qp; ++ return 0; ++} ++ ++static int qemu_rdma_reg_whole_ram_blocks(RDMAContext *rdma) ++{ ++ int i; ++ RDMALocalBlocks *local = &rdma->local_ram_blocks; ++ ++ for (i = 0; i < local->nb_blocks; i++) { ++ local->block[i].mr = ++ ibv_reg_mr(rdma->pd, ++ local->block[i].local_host_addr, ++ local->block[i].length, ++ IBV_ACCESS_LOCAL_WRITE | ++ IBV_ACCESS_REMOTE_WRITE ++ ); ++ if (!local->block[i].mr) { ++ perror("Failed to register local dest ram block!\n"); ++ break; ++ } ++ rdma->total_registrations++; ++ } ++ ++ if (i >= local->nb_blocks) { ++ return 0; ++ } ++ ++ for (i--; i >= 0; i--) { ++ ibv_dereg_mr(local->block[i].mr); ++ rdma->total_registrations--; ++ } ++ ++ return -1; ++ ++} ++ ++/* ++ * Find the ram block that corresponds to the page requested to be ++ * transmitted by QEMU. ++ * ++ * Once the block is found, also identify which 'chunk' within that ++ * block that the page belongs to. ++ * ++ * This search cannot fail or the migration will fail. ++ */ ++static int qemu_rdma_search_ram_block(RDMAContext *rdma, ++ uint64_t block_offset, ++ uint64_t offset, ++ uint64_t length, ++ uint64_t *block_index, ++ uint64_t *chunk_index) ++{ ++ uint64_t current_addr = block_offset + offset; ++ RDMALocalBlock *block = g_hash_table_lookup(rdma->blockmap, ++ (void *) block_offset); ++ assert(block); ++ assert(current_addr >= block->offset); ++ assert((current_addr + length) <= (block->offset + block->length)); ++ ++ *block_index = block->index; ++ *chunk_index = ram_chunk_index(block->local_host_addr, ++ block->local_host_addr + (current_addr - block->offset)); ++ ++ return 0; ++} ++ ++/* ++ * Register a chunk with IB. If the chunk was already registered ++ * previously, then skip. ++ * ++ * Also return the keys associated with the registration needed ++ * to perform the actual RDMA operation. ++ */ ++static int qemu_rdma_register_and_get_keys(RDMAContext *rdma, ++ RDMALocalBlock *block, uint8_t *host_addr, ++ uint32_t *lkey, uint32_t *rkey, int chunk, ++ uint8_t *chunk_start, uint8_t *chunk_end) ++{ ++ if (block->mr) { ++ if (lkey) { ++ *lkey = block->mr->lkey; ++ } ++ if (rkey) { ++ *rkey = block->mr->rkey; ++ } ++ return 0; ++ } ++ ++ /* allocate memory to store chunk MRs */ ++ if (!block->pmr) { ++ block->pmr = g_malloc0(block->nb_chunks * sizeof(struct ibv_mr *)); ++ if (!block->pmr) { ++ return -1; ++ } ++ } ++ ++ /* ++ * If 'rkey', then we're the destination, so grant access to the source. ++ * ++ * If 'lkey', then we're the source VM, so grant access only to ourselves. ++ */ ++ if (!block->pmr[chunk]) { ++ uint64_t len = chunk_end - chunk_start; ++ ++ DDPRINTF("Registering %" PRIu64 " bytes @ %p\n", ++ len, chunk_start); ++ ++ block->pmr[chunk] = ibv_reg_mr(rdma->pd, ++ chunk_start, len, ++ (rkey ? (IBV_ACCESS_LOCAL_WRITE | ++ IBV_ACCESS_REMOTE_WRITE) : 0)); ++ ++ if (!block->pmr[chunk]) { ++ perror("Failed to register chunk!"); ++ fprintf(stderr, "Chunk details: block: %d chunk index %d" ++ " start %" PRIu64 " end %" PRIu64 " host %" PRIu64 ++ " local %" PRIu64 " registrations: %d\n", ++ block->index, chunk, (uint64_t) chunk_start, ++ (uint64_t) chunk_end, (uint64_t) host_addr, ++ (uint64_t) block->local_host_addr, ++ rdma->total_registrations); ++ return -1; ++ } ++ rdma->total_registrations++; ++ } ++ ++ if (lkey) { ++ *lkey = block->pmr[chunk]->lkey; ++ } ++ if (rkey) { ++ *rkey = block->pmr[chunk]->rkey; ++ } ++ return 0; ++} ++ ++/* ++ * Register (at connection time) the memory used for control ++ * channel messages. ++ */ ++static int qemu_rdma_reg_control(RDMAContext *rdma, int idx) ++{ ++ rdma->wr_data[idx].control_mr = ibv_reg_mr(rdma->pd, ++ rdma->wr_data[idx].control, RDMA_CONTROL_MAX_BUFFER, ++ IBV_ACCESS_LOCAL_WRITE | IBV_ACCESS_REMOTE_WRITE); ++ if (rdma->wr_data[idx].control_mr) { ++ rdma->total_registrations++; ++ return 0; ++ } ++ fprintf(stderr, "qemu_rdma_reg_control failed!\n"); ++ return -1; ++} ++ ++const char *print_wrid(int wrid) ++{ ++ if (wrid >= RDMA_WRID_RECV_CONTROL) { ++ return wrid_desc[RDMA_WRID_RECV_CONTROL]; ++ } ++ return wrid_desc[wrid]; ++} ++ ++/* ++ * RDMA requires memory registration (mlock/pinning), but this is not good for ++ * overcommitment. ++ * ++ * In preparation for the future where LRU information or workload-specific ++ * writable writable working set memory access behavior is available to QEMU ++ * it would be nice to have in place the ability to UN-register/UN-pin ++ * particular memory regions from the RDMA hardware when it is determine that ++ * those regions of memory will likely not be accessed again in the near future. ++ * ++ * While we do not yet have such information right now, the following ++ * compile-time option allows us to perform a non-optimized version of this ++ * behavior. ++ * ++ * By uncommenting this option, you will cause *all* RDMA transfers to be ++ * unregistered immediately after the transfer completes on both sides of the ++ * connection. This has no effect in 'rdma-pin-all' mode, only regular mode. ++ * ++ * This will have a terrible impact on migration performance, so until future ++ * workload information or LRU information is available, do not attempt to use ++ * this feature except for basic testing. ++ */ ++//#define RDMA_UNREGISTRATION_EXAMPLE ++ ++/* ++ * Perform a non-optimized memory unregistration after every transfer ++ * for demonsration purposes, only if pin-all is not requested. ++ * ++ * Potential optimizations: ++ * 1. Start a new thread to run this function continuously ++ - for bit clearing ++ - and for receipt of unregister messages ++ * 2. Use an LRU. ++ * 3. Use workload hints. ++ */ ++static int qemu_rdma_unregister_waiting(RDMAContext *rdma) ++{ ++ while (rdma->unregistrations[rdma->unregister_current]) { ++ int ret; ++ uint64_t wr_id = rdma->unregistrations[rdma->unregister_current]; ++ uint64_t chunk = ++ (wr_id & RDMA_WRID_CHUNK_MASK) >> RDMA_WRID_CHUNK_SHIFT; ++ uint64_t index = ++ (wr_id & RDMA_WRID_BLOCK_MASK) >> RDMA_WRID_BLOCK_SHIFT; ++ RDMALocalBlock *block = ++ &(rdma->local_ram_blocks.block[index]); ++ RDMARegister reg = { .current_index = index }; ++ RDMAControlHeader resp = { .type = RDMA_CONTROL_UNREGISTER_FINISHED, ++ }; ++ RDMAControlHeader head = { .len = sizeof(RDMARegister), ++ .type = RDMA_CONTROL_UNREGISTER_REQUEST, ++ .repeat = 1, ++ }; ++ ++ DDPRINTF("Processing unregister for chunk: %" PRIu64 ++ " at position %d\n", chunk, rdma->unregister_current); ++ ++ rdma->unregistrations[rdma->unregister_current] = 0; ++ rdma->unregister_current++; ++ ++ if (rdma->unregister_current == RDMA_SIGNALED_SEND_MAX) { ++ rdma->unregister_current = 0; ++ } ++ ++ ++ /* ++ * Unregistration is speculative (because migration is single-threaded ++ * and we cannot break the protocol's inifinband message ordering). ++ * Thus, if the memory is currently being used for transmission, ++ * then abort the attempt to unregister and try again ++ * later the next time a completion is received for this memory. ++ */ ++ clear_bit(chunk, block->unregister_bitmap); ++ ++ if (test_bit(chunk, block->transit_bitmap)) { ++ DDPRINTF("Cannot unregister inflight chunk: %" PRIu64 "\n", chunk); ++ continue; ++ } ++ ++ DDPRINTF("Sending unregister for chunk: %" PRIu64 "\n", chunk); ++ ++ ret = ibv_dereg_mr(block->pmr[chunk]); ++ block->pmr[chunk] = NULL; ++ block->remote_keys[chunk] = 0; ++ ++ if (ret != 0) { ++ perror("unregistration chunk failed"); ++ return -ret; ++ } ++ rdma->total_registrations--; ++ ++ reg.key.chunk = chunk; ++ register_to_network(®); ++ ret = qemu_rdma_exchange_send(rdma, &head, (uint8_t *) ®, ++ &resp, NULL, NULL); ++ if (ret < 0) { ++ return ret; ++ } ++ ++ DDPRINTF("Unregister for chunk: %" PRIu64 " complete.\n", chunk); ++ } ++ ++ return 0; ++} ++ ++static uint64_t qemu_rdma_make_wrid(uint64_t wr_id, uint64_t index, ++ uint64_t chunk) ++{ ++ uint64_t result = wr_id & RDMA_WRID_TYPE_MASK; ++ ++ result |= (index << RDMA_WRID_BLOCK_SHIFT); ++ result |= (chunk << RDMA_WRID_CHUNK_SHIFT); ++ ++ return result; ++} ++ ++/* ++ * Set bit for unregistration in the next iteration. ++ * We cannot transmit right here, but will unpin later. ++ */ ++static void qemu_rdma_signal_unregister(RDMAContext *rdma, uint64_t index, ++ uint64_t chunk, uint64_t wr_id) ++{ ++ if (rdma->unregistrations[rdma->unregister_next] != 0) { ++ fprintf(stderr, "rdma migration: queue is full!\n"); ++ } else { ++ RDMALocalBlock *block = &(rdma->local_ram_blocks.block[index]); ++ ++ if (!test_and_set_bit(chunk, block->unregister_bitmap)) { ++ DDPRINTF("Appending unregister chunk %" PRIu64 ++ " at position %d\n", chunk, rdma->unregister_next); ++ ++ rdma->unregistrations[rdma->unregister_next++] = ++ qemu_rdma_make_wrid(wr_id, index, chunk); ++ ++ if (rdma->unregister_next == RDMA_SIGNALED_SEND_MAX) { ++ rdma->unregister_next = 0; ++ } ++ } else { ++ DDPRINTF("Unregister chunk %" PRIu64 " already in queue.\n", ++ chunk); ++ } ++ } ++} ++ ++/* ++ * Consult the connection manager to see a work request ++ * (of any kind) has completed. ++ * Return the work request ID that completed. ++ */ ++static uint64_t qemu_rdma_poll(RDMAContext *rdma, uint64_t *wr_id_out) ++{ ++ int ret; ++ struct ibv_wc wc; ++ uint64_t wr_id; ++ ++ ret = ibv_poll_cq(rdma->cq, 1, &wc); ++ ++ if (!ret) { ++ *wr_id_out = RDMA_WRID_NONE; ++ return 0; ++ } ++ ++ if (ret < 0) { ++ fprintf(stderr, "ibv_poll_cq return %d!\n", ret); ++ return ret; ++ } ++ ++ wr_id = wc.wr_id & RDMA_WRID_TYPE_MASK; ++ ++ if (wc.status != IBV_WC_SUCCESS) { ++ fprintf(stderr, "ibv_poll_cq wc.status=%d %s!\n", ++ wc.status, ibv_wc_status_str(wc.status)); ++ fprintf(stderr, "ibv_poll_cq wrid=%s!\n", wrid_desc[wr_id]); ++ ++ return -1; ++ } ++ ++ if (rdma->control_ready_expected && ++ (wr_id >= RDMA_WRID_RECV_CONTROL)) { ++ DDDPRINTF("completion %s #%" PRId64 " received (%" PRId64 ")" ++ " left %d\n", wrid_desc[RDMA_WRID_RECV_CONTROL], ++ wr_id - RDMA_WRID_RECV_CONTROL, wr_id, rdma->nb_sent); ++ rdma->control_ready_expected = 0; ++ } ++ ++ if (wr_id == RDMA_WRID_RDMA_WRITE) { ++ uint64_t chunk = ++ (wc.wr_id & RDMA_WRID_CHUNK_MASK) >> RDMA_WRID_CHUNK_SHIFT; ++ uint64_t index = ++ (wc.wr_id & RDMA_WRID_BLOCK_MASK) >> RDMA_WRID_BLOCK_SHIFT; ++ RDMALocalBlock *block = &(rdma->local_ram_blocks.block[index]); ++ ++ DDDPRINTF("completions %s (%" PRId64 ") left %d, " ++ "block %" PRIu64 ", chunk: %" PRIu64 " %p %p\n", ++ print_wrid(wr_id), wr_id, rdma->nb_sent, index, chunk, ++ block->local_host_addr, (void *)block->remote_host_addr); ++ ++ clear_bit(chunk, block->transit_bitmap); ++ ++ if (rdma->nb_sent > 0) { ++ rdma->nb_sent--; ++ } ++ ++ if (!rdma->pin_all) { ++ /* ++ * FYI: If one wanted to signal a specific chunk to be unregistered ++ * using LRU or workload-specific information, this is the function ++ * you would call to do so. That chunk would then get asynchronously ++ * unregistered later. ++ */ ++#ifdef RDMA_UNREGISTRATION_EXAMPLE ++ qemu_rdma_signal_unregister(rdma, index, chunk, wc.wr_id); ++#endif ++ } ++ } else { ++ DDDPRINTF("other completion %s (%" PRId64 ") received left %d\n", ++ print_wrid(wr_id), wr_id, rdma->nb_sent); ++ } ++ ++ *wr_id_out = wc.wr_id; ++ ++ return 0; ++} ++ ++/* ++ * Block until the next work request has completed. ++ * ++ * First poll to see if a work request has already completed, ++ * otherwise block. ++ * ++ * If we encounter completed work requests for IDs other than ++ * the one we're interested in, then that's generally an error. ++ * ++ * The only exception is actual RDMA Write completions. These ++ * completions only need to be recorded, but do not actually ++ * need further processing. ++ */ ++static int qemu_rdma_block_for_wrid(RDMAContext *rdma, int wrid_requested) ++{ ++ int num_cq_events = 0, ret = 0; ++ struct ibv_cq *cq; ++ void *cq_ctx; ++ uint64_t wr_id = RDMA_WRID_NONE, wr_id_in; ++ ++ if (ibv_req_notify_cq(rdma->cq, 0)) { ++ return -1; ++ } ++ /* poll cq first */ ++ while (wr_id != wrid_requested) { ++ ret = qemu_rdma_poll(rdma, &wr_id_in); ++ if (ret < 0) { ++ return ret; ++ } ++ ++ wr_id = wr_id_in & RDMA_WRID_TYPE_MASK; ++ ++ if (wr_id == RDMA_WRID_NONE) { ++ break; ++ } ++ if (wr_id != wrid_requested) { ++ DDDPRINTF("A Wanted wrid %s (%d) but got %s (%" PRIu64 ")\n", ++ print_wrid(wrid_requested), ++ wrid_requested, print_wrid(wr_id), wr_id); ++ } ++ } ++ ++ if (wr_id == wrid_requested) { ++ return 0; ++ } ++ ++ while (1) { ++ /* ++ * Coroutine doesn't start until process_incoming_migration() ++ * so don't yield unless we know we're running inside of a coroutine. ++ */ ++ if (rdma->migration_started_on_destination) { ++ yield_until_fd_readable(rdma->comp_channel->fd); ++ } ++ ++ if (ibv_get_cq_event(rdma->comp_channel, &cq, &cq_ctx)) { ++ perror("ibv_get_cq_event"); ++ goto err_block_for_wrid; ++ } ++ ++ num_cq_events++; ++ ++ if (ibv_req_notify_cq(cq, 0)) { ++ goto err_block_for_wrid; ++ } ++ ++ while (wr_id != wrid_requested) { ++ ret = qemu_rdma_poll(rdma, &wr_id_in); ++ if (ret < 0) { ++ goto err_block_for_wrid; ++ } ++ ++ wr_id = wr_id_in & RDMA_WRID_TYPE_MASK; ++ ++ if (wr_id == RDMA_WRID_NONE) { ++ break; ++ } ++ if (wr_id != wrid_requested) { ++ DDDPRINTF("B Wanted wrid %s (%d) but got %s (%" PRIu64 ")\n", ++ print_wrid(wrid_requested), wrid_requested, ++ print_wrid(wr_id), wr_id); ++ } ++ } ++ ++ if (wr_id == wrid_requested) { ++ goto success_block_for_wrid; ++ } ++ } ++ ++success_block_for_wrid: ++ if (num_cq_events) { ++ ibv_ack_cq_events(cq, num_cq_events); ++ } ++ return 0; ++ ++err_block_for_wrid: ++ if (num_cq_events) { ++ ibv_ack_cq_events(cq, num_cq_events); ++ } ++ return ret; ++} ++ ++/* ++ * Post a SEND message work request for the control channel ++ * containing some data and block until the post completes. ++ */ ++static int qemu_rdma_post_send_control(RDMAContext *rdma, uint8_t *buf, ++ RDMAControlHeader *head) ++{ ++ int ret = 0; ++ RDMAWorkRequestData *wr = &rdma->wr_data[RDMA_WRID_MAX]; ++ struct ibv_send_wr *bad_wr; ++ struct ibv_sge sge = { ++ .addr = (uint64_t)(wr->control), ++ .length = head->len + sizeof(RDMAControlHeader), ++ .lkey = wr->control_mr->lkey, ++ }; ++ struct ibv_send_wr send_wr = { ++ .wr_id = RDMA_WRID_SEND_CONTROL, ++ .opcode = IBV_WR_SEND, ++ .send_flags = IBV_SEND_SIGNALED, ++ .sg_list = &sge, ++ .num_sge = 1, ++ }; ++ ++ DDDPRINTF("CONTROL: sending %s..\n", control_desc[head->type]); ++ ++ /* ++ * We don't actually need to do a memcpy() in here if we used ++ * the "sge" properly, but since we're only sending control messages ++ * (not RAM in a performance-critical path), then its OK for now. ++ * ++ * The copy makes the RDMAControlHeader simpler to manipulate ++ * for the time being. ++ */ ++ memcpy(wr->control, head, sizeof(RDMAControlHeader)); ++ control_to_network((void *) wr->control); ++ ++ if (buf) { ++ memcpy(wr->control + sizeof(RDMAControlHeader), buf, head->len); ++ } ++ ++ ++ if (ibv_post_send(rdma->qp, &send_wr, &bad_wr)) { ++ return -1; ++ } ++ ++ if (ret < 0) { ++ fprintf(stderr, "Failed to use post IB SEND for control!\n"); ++ return ret; ++ } ++ ++ ret = qemu_rdma_block_for_wrid(rdma, RDMA_WRID_SEND_CONTROL); ++ if (ret < 0) { ++ fprintf(stderr, "rdma migration: send polling control error!\n"); ++ } ++ ++ return ret; ++} ++ ++/* ++ * Post a RECV work request in anticipation of some future receipt ++ * of data on the control channel. ++ */ ++static int qemu_rdma_post_recv_control(RDMAContext *rdma, int idx) ++{ ++ struct ibv_recv_wr *bad_wr; ++ struct ibv_sge sge = { ++ .addr = (uint64_t)(rdma->wr_data[idx].control), ++ .length = RDMA_CONTROL_MAX_BUFFER, ++ .lkey = rdma->wr_data[idx].control_mr->lkey, ++ }; ++ ++ struct ibv_recv_wr recv_wr = { ++ .wr_id = RDMA_WRID_RECV_CONTROL + idx, ++ .sg_list = &sge, ++ .num_sge = 1, ++ }; ++ ++ ++ if (ibv_post_recv(rdma->qp, &recv_wr, &bad_wr)) { ++ return -1; ++ } ++ ++ return 0; ++} ++ ++/* ++ * Block and wait for a RECV control channel message to arrive. ++ */ ++static int qemu_rdma_exchange_get_response(RDMAContext *rdma, ++ RDMAControlHeader *head, int expecting, int idx) ++{ ++ int ret = qemu_rdma_block_for_wrid(rdma, RDMA_WRID_RECV_CONTROL + idx); ++ ++ if (ret < 0) { ++ fprintf(stderr, "rdma migration: recv polling control error!\n"); ++ return ret; ++ } ++ ++ network_to_control((void *) rdma->wr_data[idx].control); ++ memcpy(head, rdma->wr_data[idx].control, sizeof(RDMAControlHeader)); ++ ++ DDDPRINTF("CONTROL: %s receiving...\n", control_desc[expecting]); ++ ++ if (expecting == RDMA_CONTROL_NONE) { ++ DDDPRINTF("Surprise: got %s (%d)\n", ++ control_desc[head->type], head->type); ++ } else if (head->type != expecting || head->type == RDMA_CONTROL_ERROR) { ++ fprintf(stderr, "Was expecting a %s (%d) control message" ++ ", but got: %s (%d), length: %d\n", ++ control_desc[expecting], expecting, ++ control_desc[head->type], head->type, head->len); ++ return -EIO; ++ } ++ ++ return 0; ++} ++ ++/* ++ * When a RECV work request has completed, the work request's ++ * buffer is pointed at the header. ++ * ++ * This will advance the pointer to the data portion ++ * of the control message of the work request's buffer that ++ * was populated after the work request finished. ++ */ ++static void qemu_rdma_move_header(RDMAContext *rdma, int idx, ++ RDMAControlHeader *head) ++{ ++ rdma->wr_data[idx].control_len = head->len; ++ rdma->wr_data[idx].control_curr = ++ rdma->wr_data[idx].control + sizeof(RDMAControlHeader); ++} ++ ++/* ++ * This is an 'atomic' high-level operation to deliver a single, unified ++ * control-channel message. ++ * ++ * Additionally, if the user is expecting some kind of reply to this message, ++ * they can request a 'resp' response message be filled in by posting an ++ * additional work request on behalf of the user and waiting for an additional ++ * completion. ++ * ++ * The extra (optional) response is used during registration to us from having ++ * to perform an *additional* exchange of message just to provide a response by ++ * instead piggy-backing on the acknowledgement. ++ */ ++static int qemu_rdma_exchange_send(RDMAContext *rdma, RDMAControlHeader *head, ++ uint8_t *data, RDMAControlHeader *resp, ++ int *resp_idx, ++ int (*callback)(RDMAContext *rdma)) ++{ ++ int ret = 0; ++ ++ /* ++ * Wait until the dest is ready before attempting to deliver the message ++ * by waiting for a READY message. ++ */ ++ if (rdma->control_ready_expected) { ++ RDMAControlHeader resp; ++ ret = qemu_rdma_exchange_get_response(rdma, ++ &resp, RDMA_CONTROL_READY, RDMA_WRID_READY); ++ if (ret < 0) { ++ return ret; ++ } ++ } ++ ++ /* ++ * If the user is expecting a response, post a WR in anticipation of it. ++ */ ++ if (resp) { ++ ret = qemu_rdma_post_recv_control(rdma, RDMA_WRID_DATA); ++ if (ret) { ++ fprintf(stderr, "rdma migration: error posting" ++ " extra control recv for anticipated result!"); ++ return ret; ++ } ++ } ++ ++ /* ++ * Post a WR to replace the one we just consumed for the READY message. ++ */ ++ ret = qemu_rdma_post_recv_control(rdma, RDMA_WRID_READY); ++ if (ret) { ++ fprintf(stderr, "rdma migration: error posting first control recv!"); ++ return ret; ++ } ++ ++ /* ++ * Deliver the control message that was requested. ++ */ ++ ret = qemu_rdma_post_send_control(rdma, data, head); ++ ++ if (ret < 0) { ++ fprintf(stderr, "Failed to send control buffer!\n"); ++ return ret; ++ } ++ ++ /* ++ * If we're expecting a response, block and wait for it. ++ */ ++ if (resp) { ++ if (callback) { ++ DDPRINTF("Issuing callback before receiving response...\n"); ++ ret = callback(rdma); ++ if (ret < 0) { ++ return ret; ++ } ++ } ++ ++ DDPRINTF("Waiting for response %s\n", control_desc[resp->type]); ++ ret = qemu_rdma_exchange_get_response(rdma, resp, ++ resp->type, RDMA_WRID_DATA); ++ ++ if (ret < 0) { ++ return ret; ++ } ++ ++ qemu_rdma_move_header(rdma, RDMA_WRID_DATA, resp); ++ if (resp_idx) { ++ *resp_idx = RDMA_WRID_DATA; ++ } ++ DDPRINTF("Response %s received.\n", control_desc[resp->type]); ++ } ++ ++ rdma->control_ready_expected = 1; ++ ++ return 0; ++} ++ ++/* ++ * This is an 'atomic' high-level operation to receive a single, unified ++ * control-channel message. ++ */ ++static int qemu_rdma_exchange_recv(RDMAContext *rdma, RDMAControlHeader *head, ++ int expecting) ++{ ++ RDMAControlHeader ready = { ++ .len = 0, ++ .type = RDMA_CONTROL_READY, ++ .repeat = 1, ++ }; ++ int ret; ++ ++ /* ++ * Inform the source that we're ready to receive a message. ++ */ ++ ret = qemu_rdma_post_send_control(rdma, NULL, &ready); ++ ++ if (ret < 0) { ++ fprintf(stderr, "Failed to send control buffer!\n"); ++ return ret; ++ } ++ ++ /* ++ * Block and wait for the message. ++ */ ++ ret = qemu_rdma_exchange_get_response(rdma, head, ++ expecting, RDMA_WRID_READY); ++ ++ if (ret < 0) { ++ return ret; ++ } ++ ++ qemu_rdma_move_header(rdma, RDMA_WRID_READY, head); ++ ++ /* ++ * Post a new RECV work request to replace the one we just consumed. ++ */ ++ ret = qemu_rdma_post_recv_control(rdma, RDMA_WRID_READY); ++ if (ret) { ++ fprintf(stderr, "rdma migration: error posting second control recv!"); ++ return ret; ++ } ++ ++ return 0; ++} ++ ++/* ++ * Write an actual chunk of memory using RDMA. ++ * ++ * If we're using dynamic registration on the dest-side, we have to ++ * send a registration command first. ++ */ ++static int qemu_rdma_write_one(QEMUFile *f, RDMAContext *rdma, ++ int current_index, uint64_t current_addr, ++ uint64_t length) ++{ ++ struct ibv_sge sge; ++ struct ibv_send_wr send_wr = { 0 }; ++ struct ibv_send_wr *bad_wr; ++ int reg_result_idx, ret, count = 0; ++ uint64_t chunk, chunks; ++ uint8_t *chunk_start, *chunk_end; ++ RDMALocalBlock *block = &(rdma->local_ram_blocks.block[current_index]); ++ RDMARegister reg; ++ RDMARegisterResult *reg_result; ++ RDMAControlHeader resp = { .type = RDMA_CONTROL_REGISTER_RESULT }; ++ RDMAControlHeader head = { .len = sizeof(RDMARegister), ++ .type = RDMA_CONTROL_REGISTER_REQUEST, ++ .repeat = 1, ++ }; ++ ++retry: ++ sge.addr = (uint64_t)(block->local_host_addr + ++ (current_addr - block->offset)); ++ sge.length = length; ++ ++ chunk = ram_chunk_index(block->local_host_addr, (uint8_t *) sge.addr); ++ chunk_start = ram_chunk_start(block, chunk); ++ ++ if (block->is_ram_block) { ++ chunks = length / (1UL << RDMA_REG_CHUNK_SHIFT); ++ ++ if (chunks && ((length % (1UL << RDMA_REG_CHUNK_SHIFT)) == 0)) { ++ chunks--; ++ } ++ } else { ++ chunks = block->length / (1UL << RDMA_REG_CHUNK_SHIFT); ++ ++ if (chunks && ((block->length % (1UL << RDMA_REG_CHUNK_SHIFT)) == 0)) { ++ chunks--; ++ } ++ } ++ ++ DDPRINTF("Writing %" PRIu64 " chunks, (%" PRIu64 " MB)\n", ++ chunks + 1, (chunks + 1) * (1UL << RDMA_REG_CHUNK_SHIFT) / 1024 / 1024); ++ ++ chunk_end = ram_chunk_end(block, chunk + chunks); ++ ++ if (!rdma->pin_all) { ++#ifdef RDMA_UNREGISTRATION_EXAMPLE ++ qemu_rdma_unregister_waiting(rdma); ++#endif ++ } ++ ++ while (test_bit(chunk, block->transit_bitmap)) { ++ (void)count; ++ DDPRINTF("(%d) Not clobbering: block: %d chunk %" PRIu64 ++ " current %" PRIu64 " len %" PRIu64 " %d %d\n", ++ count++, current_index, chunk, ++ sge.addr, length, rdma->nb_sent, block->nb_chunks); ++ ++ ret = qemu_rdma_block_for_wrid(rdma, RDMA_WRID_RDMA_WRITE); ++ ++ if (ret < 0) { ++ fprintf(stderr, "Failed to Wait for previous write to complete " ++ "block %d chunk %" PRIu64 ++ " current %" PRIu64 " len %" PRIu64 " %d\n", ++ current_index, chunk, sge.addr, length, rdma->nb_sent); ++ return ret; ++ } ++ } ++ ++ if (!rdma->pin_all || !block->is_ram_block) { ++ if (!block->remote_keys[chunk]) { ++ /* ++ * This chunk has not yet been registered, so first check to see ++ * if the entire chunk is zero. If so, tell the other size to ++ * memset() + madvise() the entire chunk without RDMA. ++ */ ++ ++ if (can_use_buffer_find_nonzero_offset((void *)sge.addr, length) ++ && buffer_find_nonzero_offset((void *)sge.addr, ++ length) == length) { ++ RDMACompress comp = { ++ .offset = current_addr, ++ .value = 0, ++ .block_idx = current_index, ++ .length = length, ++ }; ++ ++ head.len = sizeof(comp); ++ head.type = RDMA_CONTROL_COMPRESS; ++ ++ DDPRINTF("Entire chunk is zero, sending compress: %" ++ PRIu64 " for %d " ++ "bytes, index: %d, offset: %" PRId64 "...\n", ++ chunk, sge.length, current_index, current_addr); ++ ++ compress_to_network(&comp); ++ ret = qemu_rdma_exchange_send(rdma, &head, ++ (uint8_t *) &comp, NULL, NULL, NULL); ++ ++ if (ret < 0) { ++ return -EIO; ++ } ++ ++ acct_update_position(f, sge.length, true); ++ ++ return 1; ++ } ++ ++ /* ++ * Otherwise, tell other side to register. ++ */ ++ reg.current_index = current_index; ++ if (block->is_ram_block) { ++ reg.key.current_addr = current_addr; ++ } else { ++ reg.key.chunk = chunk; ++ } ++ reg.chunks = chunks; ++ ++ DDPRINTF("Sending registration request chunk %" PRIu64 " for %d " ++ "bytes, index: %d, offset: %" PRId64 "...\n", ++ chunk, sge.length, current_index, current_addr); ++ ++ register_to_network(®); ++ ret = qemu_rdma_exchange_send(rdma, &head, (uint8_t *) ®, ++ &resp, ®_result_idx, NULL); ++ if (ret < 0) { ++ return ret; ++ } ++ ++ /* try to overlap this single registration with the one we sent. */ ++ if (qemu_rdma_register_and_get_keys(rdma, block, ++ (uint8_t *) sge.addr, ++ &sge.lkey, NULL, chunk, ++ chunk_start, chunk_end)) { ++ fprintf(stderr, "cannot get lkey!\n"); ++ return -EINVAL; ++ } ++ ++ reg_result = (RDMARegisterResult *) ++ rdma->wr_data[reg_result_idx].control_curr; ++ ++ network_to_result(reg_result); ++ ++ DDPRINTF("Received registration result:" ++ " my key: %x their key %x, chunk %" PRIu64 "\n", ++ block->remote_keys[chunk], reg_result->rkey, chunk); ++ ++ block->remote_keys[chunk] = reg_result->rkey; ++ block->remote_host_addr = reg_result->host_addr; ++ } else { ++ /* already registered before */ ++ if (qemu_rdma_register_and_get_keys(rdma, block, ++ (uint8_t *)sge.addr, ++ &sge.lkey, NULL, chunk, ++ chunk_start, chunk_end)) { ++ fprintf(stderr, "cannot get lkey!\n"); ++ return -EINVAL; ++ } ++ } ++ ++ send_wr.wr.rdma.rkey = block->remote_keys[chunk]; ++ } else { ++ send_wr.wr.rdma.rkey = block->remote_rkey; ++ ++ if (qemu_rdma_register_and_get_keys(rdma, block, (uint8_t *)sge.addr, ++ &sge.lkey, NULL, chunk, ++ chunk_start, chunk_end)) { ++ fprintf(stderr, "cannot get lkey!\n"); ++ return -EINVAL; ++ } ++ } ++ ++ /* ++ * Encode the ram block index and chunk within this wrid. ++ * We will use this information at the time of completion ++ * to figure out which bitmap to check against and then which ++ * chunk in the bitmap to look for. ++ */ ++ send_wr.wr_id = qemu_rdma_make_wrid(RDMA_WRID_RDMA_WRITE, ++ current_index, chunk); ++ ++ send_wr.opcode = IBV_WR_RDMA_WRITE; ++ send_wr.send_flags = IBV_SEND_SIGNALED; ++ send_wr.sg_list = &sge; ++ send_wr.num_sge = 1; ++ send_wr.wr.rdma.remote_addr = block->remote_host_addr + ++ (current_addr - block->offset); ++ ++ DDDPRINTF("Posting chunk: %" PRIu64 ", addr: %lx" ++ " remote: %lx, bytes %" PRIu32 "\n", ++ chunk, sge.addr, send_wr.wr.rdma.remote_addr, ++ sge.length); ++ ++ /* ++ * ibv_post_send() does not return negative error numbers, ++ * per the specification they are positive - no idea why. ++ */ ++ ret = ibv_post_send(rdma->qp, &send_wr, &bad_wr); ++ ++ if (ret == ENOMEM) { ++ DDPRINTF("send queue is full. wait a little....\n"); ++ ret = qemu_rdma_block_for_wrid(rdma, RDMA_WRID_RDMA_WRITE); ++ if (ret < 0) { ++ fprintf(stderr, "rdma migration: failed to make " ++ "room in full send queue! %d\n", ret); ++ return ret; ++ } ++ ++ goto retry; ++ ++ } else if (ret > 0) { ++ perror("rdma migration: post rdma write failed"); ++ return -ret; ++ } ++ ++ set_bit(chunk, block->transit_bitmap); ++ acct_update_position(f, sge.length, false); ++ rdma->total_writes++; ++ ++ return 0; ++} ++ ++/* ++ * Push out any unwritten RDMA operations. ++ * ++ * We support sending out multiple chunks at the same time. ++ * Not all of them need to get signaled in the completion queue. ++ */ ++static int qemu_rdma_write_flush(QEMUFile *f, RDMAContext *rdma) ++{ ++ int ret; ++ ++ if (!rdma->current_length) { ++ return 0; ++ } ++ ++ ret = qemu_rdma_write_one(f, rdma, ++ rdma->current_index, rdma->current_addr, rdma->current_length); ++ ++ if (ret < 0) { ++ return ret; ++ } ++ ++ if (ret == 0) { ++ rdma->nb_sent++; ++ DDDPRINTF("sent total: %d\n", rdma->nb_sent); ++ } ++ ++ rdma->current_length = 0; ++ rdma->current_addr = 0; ++ ++ return 0; ++} ++ ++static inline int qemu_rdma_buffer_mergable(RDMAContext *rdma, ++ uint64_t offset, uint64_t len) ++{ ++ RDMALocalBlock *block = ++ &(rdma->local_ram_blocks.block[rdma->current_index]); ++ uint8_t *host_addr = block->local_host_addr + (offset - block->offset); ++ uint8_t *chunk_end = ram_chunk_end(block, rdma->current_chunk); ++ ++ if (rdma->current_length == 0) { ++ return 0; ++ } ++ ++ /* ++ * Only merge into chunk sequentially. ++ */ ++ if (offset != (rdma->current_addr + rdma->current_length)) { ++ return 0; ++ } ++ ++ if (rdma->current_index < 0) { ++ return 0; ++ } ++ ++ if (offset < block->offset) { ++ return 0; ++ } ++ ++ if ((offset + len) > (block->offset + block->length)) { ++ return 0; ++ } ++ ++ if (rdma->current_chunk < 0) { ++ return 0; ++ } ++ ++ if ((host_addr + len) > chunk_end) { ++ return 0; ++ } ++ ++ return 1; ++} ++ ++/* ++ * We're not actually writing here, but doing three things: ++ * ++ * 1. Identify the chunk the buffer belongs to. ++ * 2. If the chunk is full or the buffer doesn't belong to the current ++ * chunk, then start a new chunk and flush() the old chunk. ++ * 3. To keep the hardware busy, we also group chunks into batches ++ * and only require that a batch gets acknowledged in the completion ++ * qeueue instead of each individual chunk. ++ */ ++static int qemu_rdma_write(QEMUFile *f, RDMAContext *rdma, ++ uint64_t block_offset, uint64_t offset, ++ uint64_t len) ++{ ++ uint64_t current_addr = block_offset + offset; ++ uint64_t index = rdma->current_index; ++ uint64_t chunk = rdma->current_chunk; ++ int ret; ++ ++ /* If we cannot merge it, we flush the current buffer first. */ ++ if (!qemu_rdma_buffer_mergable(rdma, current_addr, len)) { ++ ret = qemu_rdma_write_flush(f, rdma); ++ if (ret) { ++ return ret; ++ } ++ rdma->current_length = 0; ++ rdma->current_addr = current_addr; ++ ++ ret = qemu_rdma_search_ram_block(rdma, block_offset, ++ offset, len, &index, &chunk); ++ if (ret) { ++ fprintf(stderr, "ram block search failed\n"); ++ return ret; ++ } ++ rdma->current_index = index; ++ rdma->current_chunk = chunk; ++ } ++ ++ /* merge it */ ++ rdma->current_length += len; ++ ++ /* flush it if buffer is too large */ ++ if (rdma->current_length >= RDMA_MERGE_MAX) { ++ return qemu_rdma_write_flush(f, rdma); ++ } ++ ++ return 0; ++} ++ ++static void qemu_rdma_cleanup(RDMAContext *rdma) ++{ ++ struct rdma_cm_event *cm_event; ++ int ret, idx; ++ ++ if (rdma->cm_id) { ++ if (rdma->error_state) { ++ RDMAControlHeader head = { .len = 0, ++ .type = RDMA_CONTROL_ERROR, ++ .repeat = 1, ++ }; ++ fprintf(stderr, "Early error. Sending error.\n"); ++ qemu_rdma_post_send_control(rdma, NULL, &head); ++ } ++ ++ ret = rdma_disconnect(rdma->cm_id); ++ if (!ret) { ++ DDPRINTF("waiting for disconnect\n"); ++ ret = rdma_get_cm_event(rdma->channel, &cm_event); ++ if (!ret) { ++ rdma_ack_cm_event(cm_event); ++ } ++ } ++ DDPRINTF("Disconnected.\n"); ++ rdma->cm_id = NULL; ++ } ++ ++ g_free(rdma->block); ++ rdma->block = NULL; ++ ++ for (idx = 0; idx <= RDMA_WRID_MAX; idx++) { ++ if (rdma->wr_data[idx].control_mr) { ++ rdma->total_registrations--; ++ ibv_dereg_mr(rdma->wr_data[idx].control_mr); ++ } ++ rdma->wr_data[idx].control_mr = NULL; ++ } ++ ++ if (rdma->local_ram_blocks.block) { ++ while (rdma->local_ram_blocks.nb_blocks) { ++ __qemu_rdma_delete_block(rdma, ++ rdma->local_ram_blocks.block->offset); ++ } ++ } ++ ++ if (rdma->qp) { ++ ibv_destroy_qp(rdma->qp); ++ rdma->qp = NULL; ++ } ++ if (rdma->cq) { ++ ibv_destroy_cq(rdma->cq); ++ rdma->cq = NULL; ++ } ++ if (rdma->comp_channel) { ++ ibv_destroy_comp_channel(rdma->comp_channel); ++ rdma->comp_channel = NULL; ++ } ++ if (rdma->pd) { ++ ibv_dealloc_pd(rdma->pd); ++ rdma->pd = NULL; ++ } ++ if (rdma->listen_id) { ++ rdma_destroy_id(rdma->listen_id); ++ rdma->listen_id = NULL; ++ } ++ if (rdma->cm_id) { ++ rdma_destroy_id(rdma->cm_id); ++ rdma->cm_id = NULL; ++ } ++ if (rdma->channel) { ++ rdma_destroy_event_channel(rdma->channel); ++ rdma->channel = NULL; ++ } ++} ++ ++ ++static int qemu_rdma_source_init(RDMAContext *rdma, Error **errp, bool pin_all) ++{ ++ int ret, idx; ++ Error *local_err = NULL, **temp = &local_err; ++ ++ /* ++ * Will be validated against destination's actual capabilities ++ * after the connect() completes. ++ */ ++ rdma->pin_all = pin_all; ++ ++ ret = qemu_rdma_resolve_host(rdma, temp); ++ if (ret) { ++ goto err_rdma_source_init; ++ } ++ ++ ret = qemu_rdma_alloc_pd_cq(rdma); ++ if (ret) { ++ ERROR(temp, "rdma migration: error allocating pd and cq! Your mlock()" ++ " limits may be too low. Please check $ ulimit -a # and " ++ "search for 'ulimit -l' in the output\n"); ++ goto err_rdma_source_init; ++ } ++ ++ ret = qemu_rdma_alloc_qp(rdma); ++ if (ret) { ++ ERROR(temp, "rdma migration: error allocating qp!\n"); ++ goto err_rdma_source_init; ++ } ++ ++ ret = qemu_rdma_init_ram_blocks(rdma); ++ if (ret) { ++ ERROR(temp, "rdma migration: error initializing ram blocks!\n"); ++ goto err_rdma_source_init; ++ } ++ ++ for (idx = 0; idx <= RDMA_WRID_MAX; idx++) { ++ ret = qemu_rdma_reg_control(rdma, idx); ++ if (ret) { ++ ERROR(temp, "rdma migration: error registering %d control!\n", ++ idx); ++ goto err_rdma_source_init; ++ } ++ } ++ ++ return 0; ++ ++err_rdma_source_init: ++ error_propagate(errp, local_err); ++ qemu_rdma_cleanup(rdma); ++ return -1; ++} ++ ++static int qemu_rdma_connect(RDMAContext *rdma, Error **errp) ++{ ++ RDMACapabilities cap = { ++ .version = RDMA_CONTROL_VERSION_CURRENT, ++ .flags = 0, ++ }; ++ struct rdma_conn_param conn_param = { .initiator_depth = 2, ++ .retry_count = 5, ++ .private_data = &cap, ++ .private_data_len = sizeof(cap), ++ }; ++ struct rdma_cm_event *cm_event; ++ int ret; ++ ++ /* ++ * Only negotiate the capability with destination if the user ++ * on the source first requested the capability. ++ */ ++ if (rdma->pin_all) { ++ DPRINTF("Server pin-all memory requested.\n"); ++ cap.flags |= RDMA_CAPABILITY_PIN_ALL; ++ } ++ ++ caps_to_network(&cap); ++ ++ ret = rdma_connect(rdma->cm_id, &conn_param); ++ if (ret) { ++ perror("rdma_connect"); ++ ERROR(errp, "connecting to destination!\n"); ++ rdma_destroy_id(rdma->cm_id); ++ rdma->cm_id = NULL; ++ goto err_rdma_source_connect; ++ } ++ ++ ret = rdma_get_cm_event(rdma->channel, &cm_event); ++ if (ret) { ++ perror("rdma_get_cm_event after rdma_connect"); ++ ERROR(errp, "connecting to destination!\n"); ++ rdma_ack_cm_event(cm_event); ++ rdma_destroy_id(rdma->cm_id); ++ rdma->cm_id = NULL; ++ goto err_rdma_source_connect; ++ } ++ ++ if (cm_event->event != RDMA_CM_EVENT_ESTABLISHED) { ++ perror("rdma_get_cm_event != EVENT_ESTABLISHED after rdma_connect"); ++ ERROR(errp, "connecting to destination!\n"); ++ rdma_ack_cm_event(cm_event); ++ rdma_destroy_id(rdma->cm_id); ++ rdma->cm_id = NULL; ++ goto err_rdma_source_connect; ++ } ++ ++ memcpy(&cap, cm_event->param.conn.private_data, sizeof(cap)); ++ network_to_caps(&cap); ++ ++ /* ++ * Verify that the *requested* capabilities are supported by the destination ++ * and disable them otherwise. ++ */ ++ if (rdma->pin_all && !(cap.flags & RDMA_CAPABILITY_PIN_ALL)) { ++ ERROR(errp, "Server cannot support pinning all memory. " ++ "Will register memory dynamically.\n"); ++ rdma->pin_all = false; ++ } ++ ++ DPRINTF("Pin all memory: %s\n", rdma->pin_all ? "enabled" : "disabled"); ++ ++ rdma_ack_cm_event(cm_event); ++ ++ ret = qemu_rdma_post_recv_control(rdma, 0); ++ if (ret) { ++ ERROR(errp, "posting second control recv!\n"); ++ goto err_rdma_source_connect; ++ } ++ ++ rdma->control_ready_expected = 1; ++ rdma->nb_sent = 0; ++ return 0; ++ ++err_rdma_source_connect: ++ qemu_rdma_cleanup(rdma); ++ return -1; ++} ++ ++static int qemu_rdma_dest_init(RDMAContext *rdma, Error **errp) ++{ ++ int ret = -EINVAL, idx; ++ struct sockaddr_in sin; ++ struct rdma_cm_id *listen_id; ++ char ip[40] = "unknown"; ++ ++ for (idx = 0; idx <= RDMA_WRID_MAX; idx++) { ++ rdma->wr_data[idx].control_len = 0; ++ rdma->wr_data[idx].control_curr = NULL; ++ } ++ ++ if (rdma->host == NULL) { ++ ERROR(errp, "RDMA host is not set!\n"); ++ rdma->error_state = -EINVAL; ++ return -1; ++ } ++ /* create CM channel */ ++ rdma->channel = rdma_create_event_channel(); ++ if (!rdma->channel) { ++ ERROR(errp, "could not create rdma event channel\n"); ++ rdma->error_state = -EINVAL; ++ return -1; ++ } ++ ++ /* create CM id */ ++ ret = rdma_create_id(rdma->channel, &listen_id, NULL, RDMA_PS_TCP); ++ if (ret) { ++ ERROR(errp, "could not create cm_id!\n"); ++ goto err_dest_init_create_listen_id; ++ } ++ ++ memset(&sin, 0, sizeof(sin)); ++ sin.sin_family = AF_INET; ++ sin.sin_port = htons(rdma->port); ++ ++ if (rdma->host && strcmp("", rdma->host)) { ++ struct hostent *dest_addr; ++ dest_addr = gethostbyname(rdma->host); ++ if (!dest_addr) { ++ ERROR(errp, "migration could not gethostbyname!\n"); ++ ret = -EINVAL; ++ goto err_dest_init_bind_addr; ++ } ++ memcpy(&sin.sin_addr.s_addr, dest_addr->h_addr, ++ dest_addr->h_length); ++ inet_ntop(AF_INET, dest_addr->h_addr, ip, sizeof ip); ++ } else { ++ sin.sin_addr.s_addr = INADDR_ANY; ++ } ++ ++ DPRINTF("%s => %s\n", rdma->host, ip); ++ ++ ret = rdma_bind_addr(listen_id, (struct sockaddr *)&sin); ++ if (ret) { ++ ERROR(errp, "Error: could not rdma_bind_addr!\n"); ++ goto err_dest_init_bind_addr; ++ } ++ ++ rdma->listen_id = listen_id; ++ qemu_rdma_dump_gid("dest_init", listen_id); ++ return 0; ++ ++err_dest_init_bind_addr: ++ rdma_destroy_id(listen_id); ++err_dest_init_create_listen_id: ++ rdma_destroy_event_channel(rdma->channel); ++ rdma->channel = NULL; ++ rdma->error_state = ret; ++ return ret; ++ ++} ++ ++static void *qemu_rdma_data_init(const char *host_port, Error **errp) ++{ ++ RDMAContext *rdma = NULL; ++ InetSocketAddress *addr; ++ ++ if (host_port) { ++ rdma = g_malloc0(sizeof(RDMAContext)); ++ memset(rdma, 0, sizeof(RDMAContext)); ++ rdma->current_index = -1; ++ rdma->current_chunk = -1; ++ ++ addr = inet_parse(host_port, NULL); ++ if (addr != NULL) { ++ rdma->port = atoi(addr->port); ++ rdma->host = g_strdup(addr->host); ++ } else { ++ ERROR(errp, "bad RDMA migration address '%s'", host_port); ++ g_free(rdma); ++ return NULL; ++ } ++ } ++ ++ return rdma; ++} ++ ++/* ++ * QEMUFile interface to the control channel. ++ * SEND messages for control only. ++ * pc.ram is handled with regular RDMA messages. ++ */ ++static int qemu_rdma_put_buffer(void *opaque, const uint8_t *buf, ++ int64_t pos, int size) ++{ ++ QEMUFileRDMA *r = opaque; ++ QEMUFile *f = r->file; ++ RDMAContext *rdma = r->rdma; ++ size_t remaining = size; ++ uint8_t * data = (void *) buf; ++ int ret; ++ ++ CHECK_ERROR_STATE(); ++ ++ /* ++ * Push out any writes that ++ * we're queued up for pc.ram. ++ */ ++ ret = qemu_rdma_write_flush(f, rdma); ++ if (ret < 0) { ++ rdma->error_state = ret; ++ return ret; ++ } ++ ++ while (remaining) { ++ RDMAControlHeader head; ++ ++ r->len = MIN(remaining, RDMA_SEND_INCREMENT); ++ remaining -= r->len; ++ ++ head.len = r->len; ++ head.type = RDMA_CONTROL_QEMU_FILE; ++ ++ ret = qemu_rdma_exchange_send(rdma, &head, data, NULL, NULL, NULL); ++ ++ if (ret < 0) { ++ rdma->error_state = ret; ++ return ret; ++ } ++ ++ data += r->len; ++ } ++ ++ return size; ++} ++ ++static size_t qemu_rdma_fill(RDMAContext *rdma, uint8_t *buf, ++ int size, int idx) ++{ ++ size_t len = 0; ++ ++ if (rdma->wr_data[idx].control_len) { ++ DDDPRINTF("RDMA %" PRId64 " of %d bytes already in buffer\n", ++ rdma->wr_data[idx].control_len, size); ++ ++ len = MIN(size, rdma->wr_data[idx].control_len); ++ memcpy(buf, rdma->wr_data[idx].control_curr, len); ++ rdma->wr_data[idx].control_curr += len; ++ rdma->wr_data[idx].control_len -= len; ++ } ++ ++ return len; ++} ++ ++/* ++ * QEMUFile interface to the control channel. ++ * RDMA links don't use bytestreams, so we have to ++ * return bytes to QEMUFile opportunistically. ++ */ ++static int qemu_rdma_get_buffer(void *opaque, uint8_t *buf, ++ int64_t pos, int size) ++{ ++ QEMUFileRDMA *r = opaque; ++ RDMAContext *rdma = r->rdma; ++ RDMAControlHeader head; ++ int ret = 0; ++ ++ CHECK_ERROR_STATE(); ++ ++ /* ++ * First, we hold on to the last SEND message we ++ * were given and dish out the bytes until we run ++ * out of bytes. ++ */ ++ r->len = qemu_rdma_fill(r->rdma, buf, size, 0); ++ if (r->len) { ++ return r->len; ++ } ++ ++ /* ++ * Once we run out, we block and wait for another ++ * SEND message to arrive. ++ */ ++ ret = qemu_rdma_exchange_recv(rdma, &head, RDMA_CONTROL_QEMU_FILE); ++ ++ if (ret < 0) { ++ rdma->error_state = ret; ++ return ret; ++ } ++ ++ /* ++ * SEND was received with new bytes, now try again. ++ */ ++ return qemu_rdma_fill(r->rdma, buf, size, 0); ++} ++ ++/* ++ * Block until all the outstanding chunks have been delivered by the hardware. ++ */ ++static int qemu_rdma_drain_cq(QEMUFile *f, RDMAContext *rdma) ++{ ++ int ret; ++ ++ if (qemu_rdma_write_flush(f, rdma) < 0) { ++ return -EIO; ++ } ++ ++ while (rdma->nb_sent) { ++ ret = qemu_rdma_block_for_wrid(rdma, RDMA_WRID_RDMA_WRITE); ++ if (ret < 0) { ++ fprintf(stderr, "rdma migration: complete polling error!\n"); ++ return -EIO; ++ } ++ } ++ ++ qemu_rdma_unregister_waiting(rdma); ++ ++ return 0; ++} ++ ++static int qemu_rdma_close(void *opaque) ++{ ++ DPRINTF("Shutting down connection.\n"); ++ QEMUFileRDMA *r = opaque; ++ if (r->rdma) { ++ qemu_rdma_cleanup(r->rdma); ++ g_free(r->rdma); ++ } ++ g_free(r); ++ return 0; ++} ++ ++/* ++ * Parameters: ++ * @offset == 0 : ++ * This means that 'block_offset' is a full virtual address that does not ++ * belong to a RAMBlock of the virtual machine and instead ++ * represents a private malloc'd memory area that the caller wishes to ++ * transfer. ++ * ++ * @offset != 0 : ++ * Offset is an offset to be added to block_offset and used ++ * to also lookup the corresponding RAMBlock. ++ * ++ * @size > 0 : ++ * Initiate an transfer this size. ++ * ++ * @size == 0 : ++ * A 'hint' or 'advice' that means that we wish to speculatively ++ * and asynchronously unregister this memory. In this case, there is no ++ * gaurantee that the unregister will actually happen, for example, ++ * if the memory is being actively transmitted. Additionally, the memory ++ * may be re-registered at any future time if a write within the same ++ * chunk was requested again, even if you attempted to unregister it ++ * here. ++ * ++ * @size < 0 : TODO, not yet supported ++ * Unregister the memory NOW. This means that the caller does not ++ * expect there to be any future RDMA transfers and we just want to clean ++ * things up. This is used in case the upper layer owns the memory and ++ * cannot wait for qemu_fclose() to occur. ++ * ++ * @bytes_sent : User-specificed pointer to indicate how many bytes were ++ * sent. Usually, this will not be more than a few bytes of ++ * the protocol because most transfers are sent asynchronously. ++ */ ++static size_t qemu_rdma_save_page(QEMUFile *f, void *opaque, ++ ram_addr_t block_offset, ram_addr_t offset, ++ size_t size, int *bytes_sent) ++{ ++ QEMUFileRDMA *rfile = opaque; ++ RDMAContext *rdma = rfile->rdma; ++ int ret; ++ ++ CHECK_ERROR_STATE(); ++ ++ qemu_fflush(f); ++ ++ if (size > 0) { ++ /* ++ * Add this page to the current 'chunk'. If the chunk ++ * is full, or the page doen't belong to the current chunk, ++ * an actual RDMA write will occur and a new chunk will be formed. ++ */ ++ ret = qemu_rdma_write(f, rdma, block_offset, offset, size); ++ if (ret < 0) { ++ fprintf(stderr, "rdma migration: write error! %d\n", ret); ++ goto err; ++ } ++ ++ /* ++ * We always return 1 bytes because the RDMA ++ * protocol is completely asynchronous. We do not yet know ++ * whether an identified chunk is zero or not because we're ++ * waiting for other pages to potentially be merged with ++ * the current chunk. So, we have to call qemu_update_position() ++ * later on when the actual write occurs. ++ */ ++ if (bytes_sent) { ++ *bytes_sent = 1; ++ } ++ } else { ++ uint64_t index, chunk; ++ ++ /* TODO: Change QEMUFileOps prototype to be signed: size_t => long ++ if (size < 0) { ++ ret = qemu_rdma_drain_cq(f, rdma); ++ if (ret < 0) { ++ fprintf(stderr, "rdma: failed to synchronously drain" ++ " completion queue before unregistration.\n"); ++ goto err; ++ } ++ } ++ */ ++ ++ ret = qemu_rdma_search_ram_block(rdma, block_offset, ++ offset, size, &index, &chunk); ++ ++ if (ret) { ++ fprintf(stderr, "ram block search failed\n"); ++ goto err; ++ } ++ ++ qemu_rdma_signal_unregister(rdma, index, chunk, 0); ++ ++ /* ++ * TODO: Synchronous, gauranteed unregistration (should not occur during ++ * fast-path). Otherwise, unregisters will process on the next call to ++ * qemu_rdma_drain_cq() ++ if (size < 0) { ++ qemu_rdma_unregister_waiting(rdma); ++ } ++ */ ++ } ++ ++ /* ++ * Drain the Completion Queue if possible, but do not block, ++ * just poll. ++ * ++ * If nothing to poll, the end of the iteration will do this ++ * again to make sure we don't overflow the request queue. ++ */ ++ while (1) { ++ uint64_t wr_id, wr_id_in; ++ int ret = qemu_rdma_poll(rdma, &wr_id_in); ++ if (ret < 0) { ++ fprintf(stderr, "rdma migration: polling error! %d\n", ret); ++ goto err; ++ } ++ ++ wr_id = wr_id_in & RDMA_WRID_TYPE_MASK; ++ ++ if (wr_id == RDMA_WRID_NONE) { ++ break; ++ } ++ } ++ ++ return RAM_SAVE_CONTROL_DELAYED; ++err: ++ rdma->error_state = ret; ++ return ret; ++} ++ ++static int qemu_rdma_accept(RDMAContext *rdma) ++{ ++ RDMACapabilities cap; ++ struct rdma_conn_param conn_param = { ++ .responder_resources = 2, ++ .private_data = &cap, ++ .private_data_len = sizeof(cap), ++ }; ++ struct rdma_cm_event *cm_event; ++ struct ibv_context *verbs; ++ int ret = -EINVAL; ++ int idx; ++ ++ ret = rdma_get_cm_event(rdma->channel, &cm_event); ++ if (ret) { ++ goto err_rdma_dest_wait; ++ } ++ ++ if (cm_event->event != RDMA_CM_EVENT_CONNECT_REQUEST) { ++ rdma_ack_cm_event(cm_event); ++ goto err_rdma_dest_wait; ++ } ++ ++ memcpy(&cap, cm_event->param.conn.private_data, sizeof(cap)); ++ ++ network_to_caps(&cap); ++ ++ if (cap.version < 1 || cap.version > RDMA_CONTROL_VERSION_CURRENT) { ++ fprintf(stderr, "Unknown source RDMA version: %d, bailing...\n", ++ cap.version); ++ rdma_ack_cm_event(cm_event); ++ goto err_rdma_dest_wait; ++ } ++ ++ /* ++ * Respond with only the capabilities this version of QEMU knows about. ++ */ ++ cap.flags &= known_capabilities; ++ ++ /* ++ * Enable the ones that we do know about. ++ * Add other checks here as new ones are introduced. ++ */ ++ if (cap.flags & RDMA_CAPABILITY_PIN_ALL) { ++ rdma->pin_all = true; ++ } ++ ++ rdma->cm_id = cm_event->id; ++ verbs = cm_event->id->verbs; ++ ++ rdma_ack_cm_event(cm_event); ++ ++ DPRINTF("Memory pin all: %s\n", rdma->pin_all ? "enabled" : "disabled"); ++ ++ caps_to_network(&cap); ++ ++ DPRINTF("verbs context after listen: %p\n", verbs); ++ ++ if (!rdma->verbs) { ++ rdma->verbs = verbs; ++ } else if (rdma->verbs != verbs) { ++ fprintf(stderr, "ibv context not matching %p, %p!\n", ++ rdma->verbs, verbs); ++ goto err_rdma_dest_wait; ++ } ++ ++ qemu_rdma_dump_id("dest_init", verbs); ++ ++ ret = qemu_rdma_alloc_pd_cq(rdma); ++ if (ret) { ++ fprintf(stderr, "rdma migration: error allocating pd and cq!\n"); ++ goto err_rdma_dest_wait; ++ } ++ ++ ret = qemu_rdma_alloc_qp(rdma); ++ if (ret) { ++ fprintf(stderr, "rdma migration: error allocating qp!\n"); ++ goto err_rdma_dest_wait; ++ } ++ ++ ret = qemu_rdma_init_ram_blocks(rdma); ++ if (ret) { ++ fprintf(stderr, "rdma migration: error initializing ram blocks!\n"); ++ goto err_rdma_dest_wait; ++ } ++ ++ for (idx = 0; idx <= RDMA_WRID_MAX; idx++) { ++ ret = qemu_rdma_reg_control(rdma, idx); ++ if (ret) { ++ fprintf(stderr, "rdma: error registering %d control!\n", idx); ++ goto err_rdma_dest_wait; ++ } ++ } ++ ++ qemu_set_fd_handler2(rdma->channel->fd, NULL, NULL, NULL, NULL); ++ ++ ret = rdma_accept(rdma->cm_id, &conn_param); ++ if (ret) { ++ fprintf(stderr, "rdma_accept returns %d!\n", ret); ++ goto err_rdma_dest_wait; ++ } ++ ++ ret = rdma_get_cm_event(rdma->channel, &cm_event); ++ if (ret) { ++ fprintf(stderr, "rdma_accept get_cm_event failed %d!\n", ret); ++ goto err_rdma_dest_wait; ++ } ++ ++ if (cm_event->event != RDMA_CM_EVENT_ESTABLISHED) { ++ fprintf(stderr, "rdma_accept not event established!\n"); ++ rdma_ack_cm_event(cm_event); ++ goto err_rdma_dest_wait; ++ } ++ ++ rdma_ack_cm_event(cm_event); ++ ++ ret = qemu_rdma_post_recv_control(rdma, 0); ++ if (ret) { ++ fprintf(stderr, "rdma migration: error posting second control recv!\n"); ++ goto err_rdma_dest_wait; ++ } ++ ++ qemu_rdma_dump_gid("dest_connect", rdma->cm_id); ++ ++ return 0; ++ ++err_rdma_dest_wait: ++ rdma->error_state = ret; ++ qemu_rdma_cleanup(rdma); ++ return ret; ++} ++ ++/* ++ * During each iteration of the migration, we listen for instructions ++ * by the source VM to perform dynamic page registrations before they ++ * can perform RDMA operations. ++ * ++ * We respond with the 'rkey'. ++ * ++ * Keep doing this until the source tells us to stop. ++ */ ++static int qemu_rdma_registration_handle(QEMUFile *f, void *opaque, ++ uint64_t flags) ++{ ++ RDMAControlHeader reg_resp = { .len = sizeof(RDMARegisterResult), ++ .type = RDMA_CONTROL_REGISTER_RESULT, ++ .repeat = 0, ++ }; ++ RDMAControlHeader unreg_resp = { .len = 0, ++ .type = RDMA_CONTROL_UNREGISTER_FINISHED, ++ .repeat = 0, ++ }; ++ RDMAControlHeader blocks = { .type = RDMA_CONTROL_RAM_BLOCKS_RESULT, ++ .repeat = 1 }; ++ QEMUFileRDMA *rfile = opaque; ++ RDMAContext *rdma = rfile->rdma; ++ RDMALocalBlocks *local = &rdma->local_ram_blocks; ++ RDMAControlHeader head; ++ RDMARegister *reg, *registers; ++ RDMACompress *comp; ++ RDMARegisterResult *reg_result; ++ static RDMARegisterResult results[RDMA_CONTROL_MAX_COMMANDS_PER_MESSAGE]; ++ RDMALocalBlock *block; ++ void *host_addr; ++ int ret = 0; ++ int idx = 0; ++ int count = 0; ++ int i = 0; ++ ++ CHECK_ERROR_STATE(); ++ ++ do { ++ DDDPRINTF("Waiting for next request %" PRIu64 "...\n", flags); ++ ++ ret = qemu_rdma_exchange_recv(rdma, &head, RDMA_CONTROL_NONE); ++ ++ if (ret < 0) { ++ break; ++ } ++ ++ if (head.repeat > RDMA_CONTROL_MAX_COMMANDS_PER_MESSAGE) { ++ fprintf(stderr, "rdma: Too many requests in this message (%d)." ++ "Bailing.\n", head.repeat); ++ ret = -EIO; ++ break; ++ } ++ ++ switch (head.type) { ++ case RDMA_CONTROL_COMPRESS: ++ comp = (RDMACompress *) rdma->wr_data[idx].control_curr; ++ network_to_compress(comp); ++ ++ DDPRINTF("Zapping zero chunk: %" PRId64 ++ " bytes, index %d, offset %" PRId64 "\n", ++ comp->length, comp->block_idx, comp->offset); ++ block = &(rdma->local_ram_blocks.block[comp->block_idx]); ++ ++ host_addr = block->local_host_addr + ++ (comp->offset - block->offset); ++ ++ ram_handle_compressed(host_addr, comp->value, comp->length); ++ break; ++ ++ case RDMA_CONTROL_REGISTER_FINISHED: ++ DDDPRINTF("Current registrations complete.\n"); ++ goto out; ++ ++ case RDMA_CONTROL_RAM_BLOCKS_REQUEST: ++ DPRINTF("Initial setup info requested.\n"); ++ ++ if (rdma->pin_all) { ++ ret = qemu_rdma_reg_whole_ram_blocks(rdma); ++ if (ret) { ++ fprintf(stderr, "rdma migration: error dest " ++ "registering ram blocks!\n"); ++ goto out; ++ } ++ } ++ ++ /* ++ * Dest uses this to prepare to transmit the RAMBlock descriptions ++ * to the source VM after connection setup. ++ * Both sides use the "remote" structure to communicate and update ++ * their "local" descriptions with what was sent. ++ */ ++ for (i = 0; i < local->nb_blocks; i++) { ++ rdma->block[i].remote_host_addr = ++ (uint64_t)(local->block[i].local_host_addr); ++ ++ if (rdma->pin_all) { ++ rdma->block[i].remote_rkey = local->block[i].mr->rkey; ++ } ++ ++ rdma->block[i].offset = local->block[i].offset; ++ rdma->block[i].length = local->block[i].length; ++ ++ remote_block_to_network(&rdma->block[i]); ++ } ++ ++ blocks.len = rdma->local_ram_blocks.nb_blocks ++ * sizeof(RDMARemoteBlock); ++ ++ ++ ret = qemu_rdma_post_send_control(rdma, ++ (uint8_t *) rdma->block, &blocks); ++ ++ if (ret < 0) { ++ fprintf(stderr, "rdma migration: error sending remote info!\n"); ++ goto out; ++ } ++ ++ break; ++ case RDMA_CONTROL_REGISTER_REQUEST: ++ DDPRINTF("There are %d registration requests\n", head.repeat); ++ ++ reg_resp.repeat = head.repeat; ++ registers = (RDMARegister *) rdma->wr_data[idx].control_curr; ++ ++ for (count = 0; count < head.repeat; count++) { ++ uint64_t chunk; ++ uint8_t *chunk_start, *chunk_end; ++ ++ reg = ®isters[count]; ++ network_to_register(reg); ++ ++ reg_result = &results[count]; ++ ++ DDPRINTF("Registration request (%d): index %d, current_addr %" ++ PRIu64 " chunks: %" PRIu64 "\n", count, ++ reg->current_index, reg->key.current_addr, reg->chunks); ++ ++ block = &(rdma->local_ram_blocks.block[reg->current_index]); ++ if (block->is_ram_block) { ++ host_addr = (block->local_host_addr + ++ (reg->key.current_addr - block->offset)); ++ chunk = ram_chunk_index(block->local_host_addr, ++ (uint8_t *) host_addr); ++ } else { ++ chunk = reg->key.chunk; ++ host_addr = block->local_host_addr + ++ (reg->key.chunk * (1UL << RDMA_REG_CHUNK_SHIFT)); ++ } ++ chunk_start = ram_chunk_start(block, chunk); ++ chunk_end = ram_chunk_end(block, chunk + reg->chunks); ++ if (qemu_rdma_register_and_get_keys(rdma, block, ++ (uint8_t *)host_addr, NULL, ®_result->rkey, ++ chunk, chunk_start, chunk_end)) { ++ fprintf(stderr, "cannot get rkey!\n"); ++ ret = -EINVAL; ++ goto out; ++ } ++ ++ reg_result->host_addr = (uint64_t) block->local_host_addr; ++ ++ DDPRINTF("Registered rkey for this request: %x\n", ++ reg_result->rkey); ++ ++ result_to_network(reg_result); ++ } ++ ++ ret = qemu_rdma_post_send_control(rdma, ++ (uint8_t *) results, ®_resp); ++ ++ if (ret < 0) { ++ fprintf(stderr, "Failed to send control buffer!\n"); ++ goto out; ++ } ++ break; ++ case RDMA_CONTROL_UNREGISTER_REQUEST: ++ DDPRINTF("There are %d unregistration requests\n", head.repeat); ++ unreg_resp.repeat = head.repeat; ++ registers = (RDMARegister *) rdma->wr_data[idx].control_curr; ++ ++ for (count = 0; count < head.repeat; count++) { ++ reg = ®isters[count]; ++ network_to_register(reg); ++ ++ DDPRINTF("Unregistration request (%d): " ++ " index %d, chunk %" PRIu64 "\n", ++ count, reg->current_index, reg->key.chunk); ++ ++ block = &(rdma->local_ram_blocks.block[reg->current_index]); ++ ++ ret = ibv_dereg_mr(block->pmr[reg->key.chunk]); ++ block->pmr[reg->key.chunk] = NULL; ++ ++ if (ret != 0) { ++ perror("rdma unregistration chunk failed"); ++ ret = -ret; ++ goto out; ++ } ++ ++ rdma->total_registrations--; ++ ++ DDPRINTF("Unregistered chunk %" PRIu64 " successfully.\n", ++ reg->key.chunk); ++ } ++ ++ ret = qemu_rdma_post_send_control(rdma, NULL, &unreg_resp); ++ ++ if (ret < 0) { ++ fprintf(stderr, "Failed to send control buffer!\n"); ++ goto out; ++ } ++ break; ++ case RDMA_CONTROL_REGISTER_RESULT: ++ fprintf(stderr, "Invalid RESULT message at dest.\n"); ++ ret = -EIO; ++ goto out; ++ default: ++ fprintf(stderr, "Unknown control message %s\n", ++ control_desc[head.type]); ++ ret = -EIO; ++ goto out; ++ } ++ } while (1); ++out: ++ if (ret < 0) { ++ rdma->error_state = ret; ++ } ++ return ret; ++} ++ ++static int qemu_rdma_registration_start(QEMUFile *f, void *opaque, ++ uint64_t flags) ++{ ++ QEMUFileRDMA *rfile = opaque; ++ RDMAContext *rdma = rfile->rdma; ++ ++ CHECK_ERROR_STATE(); ++ ++ DDDPRINTF("start section: %" PRIu64 "\n", flags); ++ qemu_put_be64(f, RAM_SAVE_FLAG_HOOK); ++ qemu_fflush(f); ++ ++ return 0; ++} ++ ++/* ++ * Inform dest that dynamic registrations are done for now. ++ * First, flush writes, if any. ++ */ ++static int qemu_rdma_registration_stop(QEMUFile *f, void *opaque, ++ uint64_t flags) ++{ ++ Error *local_err = NULL, **errp = &local_err; ++ QEMUFileRDMA *rfile = opaque; ++ RDMAContext *rdma = rfile->rdma; ++ RDMAControlHeader head = { .len = 0, .repeat = 1 }; ++ int ret = 0; ++ ++ CHECK_ERROR_STATE(); ++ ++ qemu_fflush(f); ++ ret = qemu_rdma_drain_cq(f, rdma); ++ ++ if (ret < 0) { ++ goto err; ++ } ++ ++ if (flags == RAM_CONTROL_SETUP) { ++ RDMAControlHeader resp = {.type = RDMA_CONTROL_RAM_BLOCKS_RESULT }; ++ RDMALocalBlocks *local = &rdma->local_ram_blocks; ++ int reg_result_idx, i, j, nb_remote_blocks; ++ ++ head.type = RDMA_CONTROL_RAM_BLOCKS_REQUEST; ++ DPRINTF("Sending registration setup for ram blocks...\n"); ++ ++ /* ++ * Make sure that we parallelize the pinning on both sides. ++ * For very large guests, doing this serially takes a really ++ * long time, so we have to 'interleave' the pinning locally ++ * with the control messages by performing the pinning on this ++ * side before we receive the control response from the other ++ * side that the pinning has completed. ++ */ ++ ret = qemu_rdma_exchange_send(rdma, &head, NULL, &resp, ++ ®_result_idx, rdma->pin_all ? ++ qemu_rdma_reg_whole_ram_blocks : NULL); ++ if (ret < 0) { ++ ERROR(errp, "receiving remote info!\n"); ++ return ret; ++ } ++ ++ qemu_rdma_move_header(rdma, reg_result_idx, &resp); ++ memcpy(rdma->block, ++ rdma->wr_data[reg_result_idx].control_curr, resp.len); ++ ++ nb_remote_blocks = resp.len / sizeof(RDMARemoteBlock); ++ ++ /* ++ * The protocol uses two different sets of rkeys (mutually exclusive): ++ * 1. One key to represent the virtual address of the entire ram block. ++ * (dynamic chunk registration disabled - pin everything with one rkey.) ++ * 2. One to represent individual chunks within a ram block. ++ * (dynamic chunk registration enabled - pin individual chunks.) ++ * ++ * Once the capability is successfully negotiated, the destination transmits ++ * the keys to use (or sends them later) including the virtual addresses ++ * and then propagates the remote ram block descriptions to his local copy. ++ */ ++ ++ if (local->nb_blocks != nb_remote_blocks) { ++ ERROR(errp, "ram blocks mismatch #1! " ++ "Your QEMU command line parameters are probably " ++ "not identical on both the source and destination.\n"); ++ return -EINVAL; ++ } ++ ++ for (i = 0; i < nb_remote_blocks; i++) { ++ network_to_remote_block(&rdma->block[i]); ++ ++ /* search local ram blocks */ ++ for (j = 0; j < local->nb_blocks; j++) { ++ if (rdma->block[i].offset != local->block[j].offset) { ++ continue; ++ } ++ ++ if (rdma->block[i].length != local->block[j].length) { ++ ERROR(errp, "ram blocks mismatch #2! " ++ "Your QEMU command line parameters are probably " ++ "not identical on both the source and destination.\n"); ++ return -EINVAL; ++ } ++ local->block[j].remote_host_addr = ++ rdma->block[i].remote_host_addr; ++ local->block[j].remote_rkey = rdma->block[i].remote_rkey; ++ break; ++ } ++ ++ if (j >= local->nb_blocks) { ++ ERROR(errp, "ram blocks mismatch #3! " ++ "Your QEMU command line parameters are probably " ++ "not identical on both the source and destination.\n"); ++ return -EINVAL; ++ } ++ } ++ } ++ ++ DDDPRINTF("Sending registration finish %" PRIu64 "...\n", flags); ++ ++ head.type = RDMA_CONTROL_REGISTER_FINISHED; ++ ret = qemu_rdma_exchange_send(rdma, &head, NULL, NULL, NULL, NULL); ++ ++ if (ret < 0) { ++ goto err; ++ } ++ ++ return 0; ++err: ++ rdma->error_state = ret; ++ return ret; ++} ++ ++static int qemu_rdma_get_fd(void *opaque) ++{ ++ QEMUFileRDMA *rfile = opaque; ++ RDMAContext *rdma = rfile->rdma; ++ ++ return rdma->comp_channel->fd; ++} ++ ++const QEMUFileOps rdma_read_ops = { ++ .get_buffer = qemu_rdma_get_buffer, ++ .get_fd = qemu_rdma_get_fd, ++ .close = qemu_rdma_close, ++ .hook_ram_load = qemu_rdma_registration_handle, ++}; ++ ++const QEMUFileOps rdma_write_ops = { ++ .put_buffer = qemu_rdma_put_buffer, ++ .close = qemu_rdma_close, ++ .before_ram_iterate = qemu_rdma_registration_start, ++ .after_ram_iterate = qemu_rdma_registration_stop, ++ .save_page = qemu_rdma_save_page, ++}; ++ ++static void *qemu_fopen_rdma(RDMAContext *rdma, const char *mode) ++{ ++ QEMUFileRDMA *r = g_malloc0(sizeof(QEMUFileRDMA)); ++ ++ if (qemu_file_mode_is_not_valid(mode)) { ++ return NULL; ++ } ++ ++ r->rdma = rdma; ++ ++ if (mode[0] == 'w') { ++ r->file = qemu_fopen_ops(r, &rdma_write_ops); ++ } else { ++ r->file = qemu_fopen_ops(r, &rdma_read_ops); ++ } ++ ++ return r->file; ++} ++ ++static void rdma_accept_incoming_migration(void *opaque) ++{ ++ RDMAContext *rdma = opaque; ++ int ret; ++ QEMUFile *f; ++ Error *local_err = NULL, **errp = &local_err; ++ ++ DPRINTF("Accepting rdma connection...\n"); ++ ret = qemu_rdma_accept(rdma); ++ ++ if (ret) { ++ ERROR(errp, "RDMA Migration initialization failed!\n"); ++ return; ++ } ++ ++ DPRINTF("Accepted migration\n"); ++ ++ f = qemu_fopen_rdma(rdma, "rb"); ++ if (f == NULL) { ++ ERROR(errp, "could not qemu_fopen_rdma!\n"); ++ qemu_rdma_cleanup(rdma); ++ return; ++ } ++ ++ rdma->migration_started_on_destination = 1; ++ process_incoming_migration(f); ++} ++ ++void rdma_start_incoming_migration(const char *host_port, Error **errp) ++{ ++ int ret; ++ RDMAContext *rdma; ++ Error *local_err = NULL; ++ ++ DPRINTF("Starting RDMA-based incoming migration\n"); ++ rdma = qemu_rdma_data_init(host_port, &local_err); ++ ++ if (rdma == NULL) { ++ goto err; ++ } ++ ++ ret = qemu_rdma_dest_init(rdma, &local_err); ++ ++ if (ret) { ++ goto err; ++ } ++ ++ DPRINTF("qemu_rdma_dest_init success\n"); ++ ++ ret = rdma_listen(rdma->listen_id, 5); ++ ++ if (ret) { ++ ERROR(errp, "listening on socket!\n"); ++ goto err; ++ } ++ ++ DPRINTF("rdma_listen success\n"); ++ ++ qemu_set_fd_handler2(rdma->channel->fd, NULL, ++ rdma_accept_incoming_migration, NULL, ++ (void *)(intptr_t) rdma); ++ return; ++err: ++ error_propagate(errp, local_err); ++ g_free(rdma); ++} ++ ++void rdma_start_outgoing_migration(void *opaque, ++ const char *host_port, Error **errp) ++{ ++ MigrationState *s = opaque; ++ Error *local_err = NULL, **temp = &local_err; ++ RDMAContext *rdma = qemu_rdma_data_init(host_port, &local_err); ++ int ret = 0; ++ ++ if (rdma == NULL) { ++ ERROR(temp, "Failed to initialize RDMA data structures! %d\n", ret); ++ goto err; ++ } ++ ++ ret = qemu_rdma_source_init(rdma, &local_err, ++ s->enabled_capabilities[MIGRATION_CAPABILITY_X_RDMA_PIN_ALL]); ++ ++ if (ret) { ++ goto err; ++ } ++ ++ DPRINTF("qemu_rdma_source_init success\n"); ++ ret = qemu_rdma_connect(rdma, &local_err); ++ ++ if (ret) { ++ goto err; ++ } ++ ++ DPRINTF("qemu_rdma_source_connect success\n"); ++ ++ s->file = qemu_fopen_rdma(rdma, "wb"); ++ migrate_fd_connect(s); ++ return; ++err: ++ error_propagate(errp, local_err); ++ g_free(rdma); ++ migrate_fd_error(s); ++} +diff --git a/migration.c b/migration.c +index 73a348f..2fa0237 100644 +--- a/migration.c ++++ b/migration.c +@@ -78,6 +78,10 @@ void qemu_start_incoming_migration(const char *uri, Error **errp) + + if (strstart(uri, "tcp:", &p)) + tcp_start_incoming_migration(p, errp); ++#ifdef CONFIG_RDMA ++ else if (strstart(uri, "x-rdma:", &p)) ++ rdma_start_incoming_migration(p, errp); ++#endif + #if !defined(WIN32) + else if (strstart(uri, "exec:", &p)) + exec_start_incoming_migration(p, errp); +@@ -415,6 +419,10 @@ void qmp_migrate(const char *uri, bool has_blk, bool blk, + + if (strstart(uri, "tcp:", &p)) { + tcp_start_outgoing_migration(s, p, &local_err); ++#ifdef CONFIG_RDMA ++ } else if (strstart(uri, "x-rdma:", &p)) { ++ rdma_start_outgoing_migration(s, p, &local_err); ++#endif + #if !defined(WIN32) + } else if (strstart(uri, "exec:", &p)) { + exec_start_outgoing_migration(s, p, &local_err); +-- +1.7.11.7 + diff --git a/SOURCES/kvm-rdma-correct-newlines-in-error-statements.patch b/SOURCES/kvm-rdma-correct-newlines-in-error-statements.patch new file mode 100644 index 0000000..ec2b476 --- /dev/null +++ b/SOURCES/kvm-rdma-correct-newlines-in-error-statements.patch @@ -0,0 +1,338 @@ +From 5ff68375e65250c295b6ed5ba946dc792df3cd55 Mon Sep 17 00:00:00 2001 +Message-Id: <5ff68375e65250c295b6ed5ba946dc792df3cd55.1387382496.git.minovotn@redhat.com> +In-Reply-To: +References: +From: Nigel Croxon +Date: Thu, 14 Nov 2013 22:52:58 +0100 +Subject: [PATCH 22/46] rdma: correct newlines in error statements + +RH-Author: Nigel Croxon +Message-id: <1384469598-13137-23-git-send-email-ncroxon@redhat.com> +Patchwork-id: 55712 +O-Subject: [RHEL7.0 PATCH 22/42] rdma: correct newlines in error statements +Bugzilla: 1011720 +RH-Acked-by: Orit Wasserman +RH-Acked-by: Amit Shah +RH-Acked-by: Paolo Bonzini + +Bugzilla: 1011720 +https://bugzilla.redhat.com/show_bug.cgi?id=1011720 + +>From commit ID: +commit 66988941251ef64044aa3b951ebd84162e5a4e3a +Author: Michael R. Hines +Date: Sat Aug 3 22:54:50 2013 -0400 + + rdma: correct newlines in error statements + + Don't print newlines on the error_setg() function, + but still allow newlines on fprintf(). + + Signed-off-by: Michael R. Hines + Message-id: 1375584894-9917-4-git-send-email-mrhines@linux.vnet.ibm.com + Signed-off-by: Anthony Liguori +--- + migration-rdma.c | 68 +++++++++++++++++++++++++++--------------------------- + 1 files changed, 34 insertions(+), 34 deletions(-) + +Signed-off-by: Michal Novotny +--- + migration-rdma.c | 68 ++++++++++++++++++++++++++++---------------------------- + 1 file changed, 34 insertions(+), 34 deletions(-) + +diff --git a/migration-rdma.c b/migration-rdma.c +index fe6118d..c958e5f 100644 +--- a/migration-rdma.c ++++ b/migration-rdma.c +@@ -60,7 +60,7 @@ + */ + #define ERROR(errp, fmt, ...) \ + do { \ +- fprintf(stderr, "RDMA ERROR: " fmt, ## __VA_ARGS__); \ ++ fprintf(stderr, "RDMA ERROR: " fmt "\n", ## __VA_ARGS__); \ + if (errp && (*(errp) == NULL)) { \ + error_setg(errp, "RDMA ERROR: " fmt, ## __VA_ARGS__); \ + } \ +@@ -748,21 +748,21 @@ static int qemu_rdma_resolve_host(RDMAContext *rdma, Error **errp) + int af = rdma->ipv6 ? PF_INET6 : PF_INET; + + if (rdma->host == NULL || !strcmp(rdma->host, "")) { +- ERROR(errp, "RDMA hostname has not been set\n"); ++ ERROR(errp, "RDMA hostname has not been set"); + return -1; + } + + /* create CM channel */ + rdma->channel = rdma_create_event_channel(); + if (!rdma->channel) { +- ERROR(errp, "could not create CM channel\n"); ++ ERROR(errp, "could not create CM channel"); + return -1; + } + + /* create CM id */ + ret = rdma_create_id(rdma->channel, &rdma->cm_id, NULL, RDMA_PS_TCP); + if (ret) { +- ERROR(errp, "could not create channel id\n"); ++ ERROR(errp, "could not create channel id"); + goto err_resolve_create_id; + } + +@@ -771,7 +771,7 @@ static int qemu_rdma_resolve_host(RDMAContext *rdma, Error **errp) + + ret = getaddrinfo(rdma->host, port_str, NULL, &res); + if (ret < 0) { +- ERROR(errp, "could not getaddrinfo address %s\n", rdma->host); ++ ERROR(errp, "could not getaddrinfo address %s", rdma->host); + goto err_resolve_get_addr; + } + +@@ -783,7 +783,7 @@ static int qemu_rdma_resolve_host(RDMAContext *rdma, Error **errp) + ret = rdma_resolve_addr(rdma->cm_id, NULL, res->ai_addr, + RDMA_RESOLVE_TIMEOUT_MS); + if (ret) { +- ERROR(errp, "could not resolve address %s\n", rdma->host); ++ ERROR(errp, "could not resolve address %s", rdma->host); + goto err_resolve_get_addr; + } + +@@ -791,12 +791,12 @@ static int qemu_rdma_resolve_host(RDMAContext *rdma, Error **errp) + + ret = rdma_get_cm_event(rdma->channel, &cm_event); + if (ret) { +- ERROR(errp, "could not perform event_addr_resolved\n"); ++ ERROR(errp, "could not perform event_addr_resolved"); + goto err_resolve_get_addr; + } + + if (cm_event->event != RDMA_CM_EVENT_ADDR_RESOLVED) { +- ERROR(errp, "result not equal to event_addr_resolved %s\n", ++ ERROR(errp, "result not equal to event_addr_resolved %s", + rdma_event_str(cm_event->event)); + perror("rdma_resolve_addr"); + goto err_resolve_get_addr; +@@ -806,17 +806,17 @@ static int qemu_rdma_resolve_host(RDMAContext *rdma, Error **errp) + /* resolve route */ + ret = rdma_resolve_route(rdma->cm_id, RDMA_RESOLVE_TIMEOUT_MS); + if (ret) { +- ERROR(errp, "could not resolve rdma route\n"); ++ ERROR(errp, "could not resolve rdma route"); + goto err_resolve_get_addr; + } + + ret = rdma_get_cm_event(rdma->channel, &cm_event); + if (ret) { +- ERROR(errp, "could not perform event_route_resolved\n"); ++ ERROR(errp, "could not perform event_route_resolved"); + goto err_resolve_get_addr; + } + if (cm_event->event != RDMA_CM_EVENT_ROUTE_RESOLVED) { +- ERROR(errp, "result not equal to event_route_resolved: %s\n", ++ ERROR(errp, "result not equal to event_route_resolved: %s", + rdma_event_str(cm_event->event)); + rdma_ack_cm_event(cm_event); + goto err_resolve_get_addr; +@@ -2117,26 +2117,26 @@ static int qemu_rdma_source_init(RDMAContext *rdma, Error **errp, bool pin_all) + if (ret) { + ERROR(temp, "rdma migration: error allocating pd and cq! Your mlock()" + " limits may be too low. Please check $ ulimit -a # and " +- "search for 'ulimit -l' in the output\n"); ++ "search for 'ulimit -l' in the output"); + goto err_rdma_source_init; + } + + ret = qemu_rdma_alloc_qp(rdma); + if (ret) { +- ERROR(temp, "rdma migration: error allocating qp!\n"); ++ ERROR(temp, "rdma migration: error allocating qp!"); + goto err_rdma_source_init; + } + + ret = qemu_rdma_init_ram_blocks(rdma); + if (ret) { +- ERROR(temp, "rdma migration: error initializing ram blocks!\n"); ++ ERROR(temp, "rdma migration: error initializing ram blocks!"); + goto err_rdma_source_init; + } + + for (idx = 0; idx <= RDMA_WRID_MAX; idx++) { + ret = qemu_rdma_reg_control(rdma, idx); + if (ret) { +- ERROR(temp, "rdma migration: error registering %d control!\n", ++ ERROR(temp, "rdma migration: error registering %d control!", + idx); + goto err_rdma_source_init; + } +@@ -2178,7 +2178,7 @@ static int qemu_rdma_connect(RDMAContext *rdma, Error **errp) + ret = rdma_connect(rdma->cm_id, &conn_param); + if (ret) { + perror("rdma_connect"); +- ERROR(errp, "connecting to destination!\n"); ++ ERROR(errp, "connecting to destination!"); + rdma_destroy_id(rdma->cm_id); + rdma->cm_id = NULL; + goto err_rdma_source_connect; +@@ -2187,7 +2187,7 @@ static int qemu_rdma_connect(RDMAContext *rdma, Error **errp) + ret = rdma_get_cm_event(rdma->channel, &cm_event); + if (ret) { + perror("rdma_get_cm_event after rdma_connect"); +- ERROR(errp, "connecting to destination!\n"); ++ ERROR(errp, "connecting to destination!"); + rdma_ack_cm_event(cm_event); + rdma_destroy_id(rdma->cm_id); + rdma->cm_id = NULL; +@@ -2196,7 +2196,7 @@ static int qemu_rdma_connect(RDMAContext *rdma, Error **errp) + + if (cm_event->event != RDMA_CM_EVENT_ESTABLISHED) { + perror("rdma_get_cm_event != EVENT_ESTABLISHED after rdma_connect"); +- ERROR(errp, "connecting to destination!\n"); ++ ERROR(errp, "connecting to destination!"); + rdma_ack_cm_event(cm_event); + rdma_destroy_id(rdma->cm_id); + rdma->cm_id = NULL; +@@ -2212,7 +2212,7 @@ static int qemu_rdma_connect(RDMAContext *rdma, Error **errp) + */ + if (rdma->pin_all && !(cap.flags & RDMA_CAPABILITY_PIN_ALL)) { + ERROR(errp, "Server cannot support pinning all memory. " +- "Will register memory dynamically.\n"); ++ "Will register memory dynamically."); + rdma->pin_all = false; + } + +@@ -2222,7 +2222,7 @@ static int qemu_rdma_connect(RDMAContext *rdma, Error **errp) + + ret = qemu_rdma_post_recv_control(rdma, 0); + if (ret) { +- ERROR(errp, "posting second control recv!\n"); ++ ERROR(errp, "posting second control recv!"); + goto err_rdma_source_connect; + } + +@@ -2251,14 +2251,14 @@ static int qemu_rdma_dest_init(RDMAContext *rdma, Error **errp) + } + + if (rdma->host == NULL) { +- ERROR(errp, "RDMA host is not set!\n"); ++ ERROR(errp, "RDMA host is not set!"); + rdma->error_state = -EINVAL; + return -1; + } + /* create CM channel */ + rdma->channel = rdma_create_event_channel(); + if (!rdma->channel) { +- ERROR(errp, "could not create rdma event channel\n"); ++ ERROR(errp, "could not create rdma event channel"); + rdma->error_state = -EINVAL; + return -1; + } +@@ -2266,7 +2266,7 @@ static int qemu_rdma_dest_init(RDMAContext *rdma, Error **errp) + /* create CM id */ + ret = rdma_create_id(rdma->channel, &listen_id, NULL, RDMA_PS_TCP); + if (ret) { +- ERROR(errp, "could not create cm_id!\n"); ++ ERROR(errp, "could not create cm_id!"); + goto err_dest_init_create_listen_id; + } + +@@ -2279,7 +2279,7 @@ static int qemu_rdma_dest_init(RDMAContext *rdma, Error **errp) + if (rdma->host && strcmp("", rdma->host)) { + ret = getaddrinfo(rdma->host, port_str, NULL, &res); + if (ret < 0) { +- ERROR(errp, "could not getaddrinfo address %s\n", rdma->host); ++ ERROR(errp, "could not getaddrinfo address %s", rdma->host); + goto err_dest_init_bind_addr; + } + +@@ -2287,7 +2287,7 @@ static int qemu_rdma_dest_init(RDMAContext *rdma, Error **errp) + inet_ntop(af, &((struct sockaddr_in *) res->ai_addr)->sin_addr, + ip, sizeof ip); + } else { +- ERROR(errp, "migration host and port not specified!\n"); ++ ERROR(errp, "migration host and port not specified!"); + ret = -EINVAL; + goto err_dest_init_bind_addr; + } +@@ -2296,7 +2296,7 @@ static int qemu_rdma_dest_init(RDMAContext *rdma, Error **errp) + + ret = rdma_bind_addr(listen_id, res->ai_addr); + if (ret) { +- ERROR(errp, "Error: could not rdma_bind_addr!\n"); ++ ERROR(errp, "Error: could not rdma_bind_addr!"); + goto err_dest_init_bind_addr; + } + +@@ -3036,7 +3036,7 @@ static int qemu_rdma_registration_stop(QEMUFile *f, void *opaque, + ®_result_idx, rdma->pin_all ? + qemu_rdma_reg_whole_ram_blocks : NULL); + if (ret < 0) { +- ERROR(errp, "receiving remote info!\n"); ++ ERROR(errp, "receiving remote info!"); + return ret; + } + +@@ -3061,7 +3061,7 @@ static int qemu_rdma_registration_stop(QEMUFile *f, void *opaque, + if (local->nb_blocks != nb_remote_blocks) { + ERROR(errp, "ram blocks mismatch #1! " + "Your QEMU command line parameters are probably " +- "not identical on both the source and destination.\n"); ++ "not identical on both the source and destination."); + return -EINVAL; + } + +@@ -3077,7 +3077,7 @@ static int qemu_rdma_registration_stop(QEMUFile *f, void *opaque, + if (rdma->block[i].length != local->block[j].length) { + ERROR(errp, "ram blocks mismatch #2! " + "Your QEMU command line parameters are probably " +- "not identical on both the source and destination.\n"); ++ "not identical on both the source and destination."); + return -EINVAL; + } + local->block[j].remote_host_addr = +@@ -3089,7 +3089,7 @@ static int qemu_rdma_registration_stop(QEMUFile *f, void *opaque, + if (j >= local->nb_blocks) { + ERROR(errp, "ram blocks mismatch #3! " + "Your QEMU command line parameters are probably " +- "not identical on both the source and destination.\n"); ++ "not identical on both the source and destination."); + return -EINVAL; + } + } +@@ -3163,7 +3163,7 @@ static void rdma_accept_incoming_migration(void *opaque) + ret = qemu_rdma_accept(rdma); + + if (ret) { +- ERROR(errp, "RDMA Migration initialization failed!\n"); ++ ERROR(errp, "RDMA Migration initialization failed!"); + return; + } + +@@ -3171,7 +3171,7 @@ static void rdma_accept_incoming_migration(void *opaque) + + f = qemu_fopen_rdma(rdma, "rb"); + if (f == NULL) { +- ERROR(errp, "could not qemu_fopen_rdma!\n"); ++ ERROR(errp, "could not qemu_fopen_rdma!"); + qemu_rdma_cleanup(rdma); + return; + } +@@ -3204,7 +3204,7 @@ void rdma_start_incoming_migration(const char *host_port, Error **errp) + ret = rdma_listen(rdma->listen_id, 5); + + if (ret) { +- ERROR(errp, "listening on socket!\n"); ++ ERROR(errp, "listening on socket!"); + goto err; + } + +@@ -3228,7 +3228,7 @@ void rdma_start_outgoing_migration(void *opaque, + int ret = 0; + + if (rdma == NULL) { +- ERROR(temp, "Failed to initialize RDMA data structures! %d\n", ret); ++ ERROR(temp, "Failed to initialize RDMA data structures! %d", ret); + goto err; + } + +-- +1.7.11.7 + diff --git a/SOURCES/kvm-rdma-don-t-use-negative-index-to-array.patch b/SOURCES/kvm-rdma-don-t-use-negative-index-to-array.patch new file mode 100644 index 0000000..3750a78 --- /dev/null +++ b/SOURCES/kvm-rdma-don-t-use-negative-index-to-array.patch @@ -0,0 +1,96 @@ +From 64b612d6551f21f7c3e34fa522b5b9c13f2b4ed8 Mon Sep 17 00:00:00 2001 +Message-Id: <64b612d6551f21f7c3e34fa522b5b9c13f2b4ed8.1387382496.git.minovotn@redhat.com> +In-Reply-To: +References: +From: Nigel Croxon +Date: Thu, 14 Nov 2013 22:52:59 +0100 +Subject: [PATCH 23/46] rdma: don't use negative index to array + +RH-Author: Nigel Croxon +Message-id: <1384469598-13137-24-git-send-email-ncroxon@redhat.com> +Patchwork-id: 55707 +O-Subject: [RHEL7.0 PATCH 23/42] rdma: don't use negative index to array +Bugzilla: 1011720 +RH-Acked-by: Orit Wasserman +RH-Acked-by: Amit Shah +RH-Acked-by: Paolo Bonzini + +Bugzilla: 1011720 +https://bugzilla.redhat.com/show_bug.cgi?id=1011720 + +>From commit ID: +commit 44b5949491a47043c4f7c4ff09f0191f82919a82 +Author: Isaku Yamahata +Date: Sat Aug 3 22:54:51 2013 -0400 + + rdma: don't use negative index to array + + Reviewed-by: Michael R. Hines + Signed-off-by: Isaku Yamahata + Signed-off-by: Michael R. Hines + Message-id: 1375584894-9917-5-git-send-email-mrhines@linux.vnet.ibm.com + Signed-off-by: Anthony Liguori +--- + migration-rdma.c | 27 +++++++++++++++------------ + 1 files changed, 15 insertions(+), 12 deletions(-) + +Signed-off-by: Michal Novotny +--- + migration-rdma.c | 27 +++++++++++++++------------ + 1 file changed, 15 insertions(+), 12 deletions(-) + +diff --git a/migration-rdma.c b/migration-rdma.c +index c958e5f..7266803 100644 +--- a/migration-rdma.c ++++ b/migration-rdma.c +@@ -1933,10 +1933,21 @@ static int qemu_rdma_write_flush(QEMUFile *f, RDMAContext *rdma) + static inline int qemu_rdma_buffer_mergable(RDMAContext *rdma, + uint64_t offset, uint64_t len) + { +- RDMALocalBlock *block = +- &(rdma->local_ram_blocks.block[rdma->current_index]); +- uint8_t *host_addr = block->local_host_addr + (offset - block->offset); +- uint8_t *chunk_end = ram_chunk_end(block, rdma->current_chunk); ++ RDMALocalBlock *block; ++ uint8_t *host_addr; ++ uint8_t *chunk_end; ++ ++ if (rdma->current_index < 0) { ++ return 0; ++ } ++ ++ if (rdma->current_chunk < 0) { ++ return 0; ++ } ++ ++ block = &(rdma->local_ram_blocks.block[rdma->current_index]); ++ host_addr = block->local_host_addr + (offset - block->offset); ++ chunk_end = ram_chunk_end(block, rdma->current_chunk); + + if (rdma->current_length == 0) { + return 0; +@@ -1949,10 +1960,6 @@ static inline int qemu_rdma_buffer_mergable(RDMAContext *rdma, + return 0; + } + +- if (rdma->current_index < 0) { +- return 0; +- } +- + if (offset < block->offset) { + return 0; + } +@@ -1961,10 +1968,6 @@ static inline int qemu_rdma_buffer_mergable(RDMAContext *rdma, + return 0; + } + +- if (rdma->current_chunk < 0) { +- return 0; +- } +- + if ((host_addr + len) > chunk_end) { + return 0; + } +-- +1.7.11.7 + diff --git a/SOURCES/kvm-rdma-export-throughput-w-MigrationStats-QMP.patch b/SOURCES/kvm-rdma-export-throughput-w-MigrationStats-QMP.patch new file mode 100644 index 0000000..0bf22fd --- /dev/null +++ b/SOURCES/kvm-rdma-export-throughput-w-MigrationStats-QMP.patch @@ -0,0 +1,138 @@ +From a181c782ef252d49815ce3628716f91e51c765c2 Mon Sep 17 00:00:00 2001 +Message-Id: +In-Reply-To: +References: +From: Nigel Croxon +Date: Thu, 14 Nov 2013 22:52:43 +0100 +Subject: [PATCH 07/46] rdma: export throughput w/ MigrationStats QMP + +RH-Author: Nigel Croxon +Message-id: <1384469598-13137-8-git-send-email-ncroxon@redhat.com> +Patchwork-id: 55698 +O-Subject: [RHEL7.0 PATCH 07/42] rdma: export throughput w/ MigrationStats QMP +Bugzilla: 1011720 +RH-Acked-by: Orit Wasserman +RH-Acked-by: Amit Shah +RH-Acked-by: Paolo Bonzini + +Bugzilla: 1011720 +https://bugzilla.redhat.com/show_bug.cgi?id=1011720 + +>From commit ID: +commit 7e114f8cf24a01893226e3a4d22a288125515cfd +Author: Michael R. Hines +Date: Tue Jun 25 21:35:30 2013 -0400 + + rdma: export throughput w/ MigrationStats QMP + + This exposes throughput (in megabits/sec) through QMP. + + Reviewed-by: Juan Quintela + Reviewed-by: Paolo Bonzini + Reviewed-by: Chegu Vinod + Tested-by: Chegu Vinod + Tested-by: Michael R. Hines + Signed-off-by: Michael R. Hines + Signed-off-by: Juan Quintela +--- + hmp.c | 2 ++ + include/migration/migration.h | 1 + + migration.c | 6 ++++++ + qapi-schema.json | 5 ++++- + 4 files changed, 13 insertions(+), 1 deletions(-) + +Signed-off-by: Michal Novotny +--- + hmp.c | 2 ++ + include/migration/migration.h | 1 + + migration.c | 6 ++++++ + qapi-schema.json | 5 ++++- + 4 files changed, 13 insertions(+), 1 deletion(-) + +diff --git a/hmp.c b/hmp.c +index 29990d2..316e6a1 100644 +--- a/hmp.c ++++ b/hmp.c +@@ -167,6 +167,8 @@ void hmp_info_migrate(Monitor *mon, const QDict *qdict) + if (info->has_ram) { + monitor_printf(mon, "transferred ram: %" PRIu64 " kbytes\n", + info->ram->transferred >> 10); ++ monitor_printf(mon, "throughput: %0.2f mbps\n", ++ info->ram->mbps); + monitor_printf(mon, "remaining ram: %" PRIu64 " kbytes\n", + info->ram->remaining >> 10); + monitor_printf(mon, "total ram: %" PRIu64 " kbytes\n", +diff --git a/include/migration/migration.h b/include/migration/migration.h +index 2f3a3d9..201be18 100644 +--- a/include/migration/migration.h ++++ b/include/migration/migration.h +@@ -40,6 +40,7 @@ struct MigrationState + + int state; + MigrationParams params; ++ double mbps; + int64_t total_time; + int64_t downtime; + int64_t expected_downtime; +diff --git a/migration.c b/migration.c +index 3520776..f4d1e34 100644 +--- a/migration.c ++++ b/migration.c +@@ -66,6 +66,7 @@ MigrationState *migrate_get_current(void) + .state = MIG_STATE_SETUP, + .bandwidth_limit = MAX_THROTTLE, + .xbzrle_cache_size = DEFAULT_MIGRATE_CACHE_SIZE, ++ .mbps = -1, + }; + + return ¤t_migration; +@@ -201,6 +202,7 @@ MigrationInfo *qmp_query_migrate(Error **errp) + info->ram->normal = norm_mig_pages_transferred(); + info->ram->normal_bytes = norm_mig_bytes_transferred(); + info->ram->dirty_pages_rate = s->dirty_pages_rate; ++ info->ram->mbps = s->mbps; + + if (blk_mig_active()) { + info->has_disk = true; +@@ -231,6 +233,7 @@ MigrationInfo *qmp_query_migrate(Error **errp) + info->ram->skipped = skipped_mig_pages_transferred(); + info->ram->normal = norm_mig_pages_transferred(); + info->ram->normal_bytes = norm_mig_bytes_transferred(); ++ info->ram->mbps = s->mbps; + break; + case MIG_STATE_ERROR: + info->has_status = true; +@@ -580,6 +583,9 @@ static void *migration_thread(void *opaque) + double bandwidth = transferred_bytes / time_spent; + max_size = bandwidth * migrate_max_downtime() / 1000000; + ++ s->mbps = time_spent ? (((double) transferred_bytes * 8.0) / ++ ((double) time_spent / 1000.0)) / 1000.0 / 1000.0 : -1; ++ + DPRINTF("transferred %" PRIu64 " time_spent %" PRIu64 + " bandwidth %g max_size %" PRId64 "\n", + transferred_bytes, time_spent, bandwidth, max_size); +diff --git a/qapi-schema.json b/qapi-schema.json +index 92fcd54..17df327 100644 +--- a/qapi-schema.json ++++ b/qapi-schema.json +@@ -569,12 +569,15 @@ + # @dirty-pages-rate: number of pages dirtied by second by the + # guest (since 1.3) + # ++# @mbps: throughput in megabits/sec. (since 1.6) ++# + # Since: 0.14.0 + ## + { 'type': 'MigrationStats', + 'data': {'transferred': 'int', 'remaining': 'int', 'total': 'int' , + 'duplicate': 'int', 'skipped': 'int', 'normal': 'int', +- 'normal-bytes': 'int', 'dirty-pages-rate' : 'int' } } ++ 'normal-bytes': 'int', 'dirty-pages-rate' : 'int', ++ 'mbps' : 'number' } } + + ## + # @XBZRLECacheStats +-- +1.7.11.7 + diff --git a/SOURCES/kvm-rdma-export-yield_until_fd_readable.patch b/SOURCES/kvm-rdma-export-yield_until_fd_readable.patch new file mode 100644 index 0000000..dbca42a --- /dev/null +++ b/SOURCES/kvm-rdma-export-yield_until_fd_readable.patch @@ -0,0 +1,139 @@ +From 5134b54a7e8941d6e6c112e03b7e85b578606fc0 Mon Sep 17 00:00:00 2001 +Message-Id: <5134b54a7e8941d6e6c112e03b7e85b578606fc0.1387382496.git.minovotn@redhat.com> +In-Reply-To: +References: +From: Nigel Croxon +Date: Thu, 14 Nov 2013 22:52:42 +0100 +Subject: [PATCH 06/46] rdma: export yield_until_fd_readable() + +RH-Author: Nigel Croxon +Message-id: <1384469598-13137-7-git-send-email-ncroxon@redhat.com> +Patchwork-id: 55691 +O-Subject: [RHEL7.0 PATCH 06/42] rdma: export yield_until_fd_readable() +Bugzilla: 1011720 +RH-Acked-by: Orit Wasserman +RH-Acked-by: Amit Shah +RH-Acked-by: Paolo Bonzini + +Bugzilla: 1011720 +https://bugzilla.redhat.com/show_bug.cgi?id=1011720 + +>From commit ID: +commit 9f05d0c3a4f9e8fcb13ed09cc350af45a627809a +Author: Michael R. Hines +Date: Tue Jun 25 21:35:29 2013 -0400 + + rdma: export yield_until_fd_readable() + + The RDMA event channel can be made non-blocking just like a TCP + socket. Exporting this function allows us to yield so that the + QEMU monitor remains available. + + Reviewed-by: Juan Quintela + Reviewed-by: Paolo Bonzini + Reviewed-by: Chegu Vinod + Tested-by: Chegu Vinod + Tested-by: Michael R. Hines + Signed-off-by: Michael R. Hines + Signed-off-by: Juan Quintela +--- + include/block/coroutine.h | 6 ++++++ + qemu-coroutine-io.c | 23 +++++++++++++++++++++++ + savevm.c | 28 ---------------------------- + 3 files changed, 29 insertions(+), 28 deletions(-) + +Signed-off-by: Michal Novotny +--- + include/block/coroutine.h | 6 ++++++ + qemu-coroutine-io.c | 23 +++++++++++++++++++++++ + savevm.c | 28 ---------------------------- + 3 files changed, 29 insertions(+), 28 deletions(-) + +diff --git a/include/block/coroutine.h b/include/block/coroutine.h +index a978162..377805a 100644 +--- a/include/block/coroutine.h ++++ b/include/block/coroutine.h +@@ -209,4 +209,10 @@ void qemu_co_rwlock_unlock(CoRwlock *lock); + */ + void coroutine_fn co_sleep_ns(QEMUClock *clock, int64_t ns); + ++/** ++ * Yield until a file descriptor becomes readable ++ * ++ * Note that this function clobbers the handlers for the file descriptor. ++ */ ++void coroutine_fn yield_until_fd_readable(int fd); + #endif /* QEMU_COROUTINE_H */ +diff --git a/qemu-coroutine-io.c b/qemu-coroutine-io.c +index e8ad1a4..c4df35a 100644 +--- a/qemu-coroutine-io.c ++++ b/qemu-coroutine-io.c +@@ -63,3 +63,26 @@ qemu_co_send_recv(int sockfd, void *buf, size_t bytes, bool do_send) + struct iovec iov = { .iov_base = buf, .iov_len = bytes }; + return qemu_co_sendv_recvv(sockfd, &iov, 1, 0, bytes, do_send); + } ++ ++typedef struct { ++ Coroutine *co; ++ int fd; ++} FDYieldUntilData; ++ ++static void fd_coroutine_enter(void *opaque) ++{ ++ FDYieldUntilData *data = opaque; ++ qemu_set_fd_handler(data->fd, NULL, NULL, NULL); ++ qemu_coroutine_enter(data->co, NULL); ++} ++ ++void coroutine_fn yield_until_fd_readable(int fd) ++{ ++ FDYieldUntilData data; ++ ++ assert(qemu_in_coroutine()); ++ data.co = qemu_coroutine_self(); ++ data.fd = fd; ++ qemu_set_fd_handler(fd, fd_coroutine_enter, NULL, &data); ++ qemu_coroutine_yield(); ++} +diff --git a/savevm.c b/savevm.c +index f68f7f2..9304788 100644 +--- a/savevm.c ++++ b/savevm.c +@@ -149,34 +149,6 @@ typedef struct QEMUFileSocket + QEMUFile *file; + } QEMUFileSocket; + +-typedef struct { +- Coroutine *co; +- int fd; +-} FDYieldUntilData; +- +-static void fd_coroutine_enter(void *opaque) +-{ +- FDYieldUntilData *data = opaque; +- qemu_set_fd_handler(data->fd, NULL, NULL, NULL); +- qemu_coroutine_enter(data->co, NULL); +-} +- +-/** +- * Yield until a file descriptor becomes readable +- * +- * Note that this function clobbers the handlers for the file descriptor. +- */ +-static void coroutine_fn yield_until_fd_readable(int fd) +-{ +- FDYieldUntilData data; +- +- assert(qemu_in_coroutine()); +- data.co = qemu_coroutine_self(); +- data.fd = fd; +- qemu_set_fd_handler(fd, fd_coroutine_enter, NULL, &data); +- qemu_coroutine_yield(); +-} +- + static ssize_t socket_writev_buffer(void *opaque, struct iovec *iov, int iovcnt, + int64_t pos) + { +-- +1.7.11.7 + diff --git a/SOURCES/kvm-rdma-forgot-to-turn-off-the-debugging-flag.patch b/SOURCES/kvm-rdma-forgot-to-turn-off-the-debugging-flag.patch new file mode 100644 index 0000000..1b29e0e --- /dev/null +++ b/SOURCES/kvm-rdma-forgot-to-turn-off-the-debugging-flag.patch @@ -0,0 +1,57 @@ +From 78b9f22700ec26bf8bc9bb1fb8c2ba69296955cf Mon Sep 17 00:00:00 2001 +Message-Id: <78b9f22700ec26bf8bc9bb1fb8c2ba69296955cf.1387382496.git.minovotn@redhat.com> +In-Reply-To: +References: +From: Nigel Croxon +Date: Thu, 14 Nov 2013 22:52:57 +0100 +Subject: [PATCH 21/46] rdma: forgot to turn off the debugging flag + +RH-Author: Nigel Croxon +Message-id: <1384469598-13137-22-git-send-email-ncroxon@redhat.com> +Patchwork-id: 55703 +O-Subject: [RHEL7.0 PATCH 21/42] rdma: forgot to turn off the debugging flag +Bugzilla: 1011720 +RH-Acked-by: Orit Wasserman +RH-Acked-by: Amit Shah +RH-Acked-by: Paolo Bonzini + +Bugzilla: 1011720 +https://bugzilla.redhat.com/show_bug.cgi?id=1011720 + +>From commit ID: +commit 8cd31adc7cc0602ba0a66b7d9b50fd016ab5530a +Author: Michael R. Hines +Date: Sat Aug 3 22:54:49 2013 -0400 + + rdma: forgot to turn off the debugging flag + + Ooops. We forgot to turn off the flag. + + Signed-off-by: Michael R. Hines + Message-id: 1375584894-9917-3-git-send-email-mrhines@linux.vnet.ibm.com + Signed-off-by: Anthony Liguori +--- + migration-rdma.c | 2 +- + 1 files changed, 1 insertions(+), 1 deletions(-) + +Signed-off-by: Michal Novotny +--- + migration-rdma.c | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/migration-rdma.c b/migration-rdma.c +index 9cf73e3..fe6118d 100644 +--- a/migration-rdma.c ++++ b/migration-rdma.c +@@ -27,7 +27,7 @@ + #include + #include + +-#define DEBUG_RDMA ++//#define DEBUG_RDMA + //#define DEBUG_RDMA_VERBOSE + //#define DEBUG_RDMA_REALLY_VERBOSE + +-- +1.7.11.7 + diff --git a/SOURCES/kvm-rdma-introduce-MIG_STATE_NONE-and-change-MIG_STATE_S.patch b/SOURCES/kvm-rdma-introduce-MIG_STATE_NONE-and-change-MIG_STATE_S.patch new file mode 100644 index 0000000..148a183 --- /dev/null +++ b/SOURCES/kvm-rdma-introduce-MIG_STATE_NONE-and-change-MIG_STATE_S.patch @@ -0,0 +1,140 @@ +From 8495376b2f1376da64faa0a62a8ec06a4499d735 Mon Sep 17 00:00:00 2001 +Message-Id: <8495376b2f1376da64faa0a62a8ec06a4499d735.1387382496.git.minovotn@redhat.com> +In-Reply-To: +References: +From: Nigel Croxon +Date: Thu, 14 Nov 2013 22:52:54 +0100 +Subject: [PATCH 18/46] rdma: introduce MIG_STATE_NONE and change + MIG_STATE_SETUP state transition + +RH-Author: Nigel Croxon +Message-id: <1384469598-13137-19-git-send-email-ncroxon@redhat.com> +Patchwork-id: 55699 +O-Subject: [RHEL7.0 PATCH 18/42] rdma: introduce MIG_STATE_NONE and change MIG_STATE_SETUP state transition +Bugzilla: 1011720 +RH-Acked-by: Orit Wasserman +RH-Acked-by: Amit Shah +RH-Acked-by: Paolo Bonzini + +Bugzilla: 1011720 +https://bugzilla.redhat.com/show_bug.cgi?id=1011720 + +>From commit ID: +commit 29ae8a4133082e16970c9d4be09f4b6a15034617 +Author: Michael R. Hines +Date: Mon Jul 22 10:01:57 2013 -0400 + + rdma: introduce MIG_STATE_NONE and change MIG_STATE_SETUP state transition + + As described in the previous patch, until now, the MIG_STATE_SETUP + state was not really a 'formal' state. It has been used as a 'zero' state + (what we're calling 'NONE' here) and QEMU has been unconditionally transitioning + into this state when the QMP migration command was called. Instead we want to + introduce MIG_STATE_NONE, which is our starting state in the state machine, and + then immediately transition into the MIG_STATE_SETUP state when the QMP migrate + command is issued. + + In order to do this, we must delay the transition into MIG_STATE_ACTIVE until + later in the migration_thread(). This is done to be able to timestamp the amount of + time spent in the SETUP state for proper accounting to the user during + an RDMA migration. + + Furthermore, the management software, until now, has never been aware of the + existence of the SETUP state whatsoever. This must change, because, timing of this + state implies that the state actually exists. + + These two patches cannot be separated because the 'query_migrate' QMP + switch statement needs to know how to handle this new state transition. + + Reviewed-by: Juan Quintela + Tested-by: Michael R. Hines + Signed-off-by: Michael R. Hines + Signed-off-by: Juan Quintela +--- + migration.c | 21 ++++++++++++++------- + 1 files changed, 14 insertions(+), 7 deletions(-) + +Signed-off-by: Michal Novotny +--- + migration.c | 21 ++++++++++++++------- + 1 file changed, 14 insertions(+), 7 deletions(-) + +diff --git a/migration.c b/migration.c +index e885bb7..ddbfd45 100644 +--- a/migration.c ++++ b/migration.c +@@ -36,7 +36,8 @@ + #endif + + enum { +- MIG_STATE_ERROR, ++ MIG_STATE_ERROR = -1, ++ MIG_STATE_NONE, + MIG_STATE_SETUP, + MIG_STATE_CANCELLED, + MIG_STATE_ACTIVE, +@@ -63,7 +64,7 @@ static NotifierList migration_state_notifiers = + MigrationState *migrate_get_current(void) + { + static MigrationState current_migration = { +- .state = MIG_STATE_SETUP, ++ .state = MIG_STATE_NONE, + .bandwidth_limit = MAX_THROTTLE, + .xbzrle_cache_size = DEFAULT_MIGRATE_CACHE_SIZE, + .mbps = -1, +@@ -184,9 +185,13 @@ MigrationInfo *qmp_query_migrate(Error **errp) + MigrationState *s = migrate_get_current(); + + switch (s->state) { +- case MIG_STATE_SETUP: ++ case MIG_STATE_NONE: + /* no migration has happened ever */ + break; ++ case MIG_STATE_SETUP: ++ info->has_status = true; ++ info->status = g_strdup("setup"); ++ break; + case MIG_STATE_ACTIVE: + info->has_status = true; + info->status = g_strdup("active"); +@@ -258,7 +263,7 @@ void qmp_migrate_set_capabilities(MigrationCapabilityStatusList *params, + MigrationState *s = migrate_get_current(); + MigrationCapabilityStatusList *cap; + +- if (s->state == MIG_STATE_ACTIVE) { ++ if (s->state == MIG_STATE_ACTIVE || s->state == MIG_STATE_SETUP) { + error_set(errp, QERR_MIGRATION_ACTIVE); + return; + } +@@ -401,7 +406,7 @@ void qmp_migrate(const char *uri, bool has_blk, bool blk, + } + #endif + +- if (s->state == MIG_STATE_ACTIVE) { ++ if (s->state == MIG_STATE_ACTIVE || s->state == MIG_STATE_SETUP) { + error_set(errp, QERR_MIGRATION_ACTIVE); + return; + } +@@ -551,6 +556,8 @@ static void *migration_thread(void *opaque) + DPRINTF("beginning savevm\n"); + qemu_savevm_state_begin(s->file, &s->params); + ++ migrate_set_state(s, MIG_STATE_SETUP, MIG_STATE_ACTIVE); ++ + while (s->state == MIG_STATE_ACTIVE) { + int64_t current_time; + uint64_t pending_size; +@@ -641,8 +648,8 @@ static void *migration_thread(void *opaque) + + void migrate_fd_connect(MigrationState *s) + { +- s->state = MIG_STATE_ACTIVE; +- trace_migrate_set_state(MIG_STATE_ACTIVE); ++ s->state = MIG_STATE_SETUP; ++ trace_migrate_set_state(MIG_STATE_SETUP); + + /* This is a best 1st approximation. ns to ms */ + s->expected_downtime = max_downtime/1000000; +-- +1.7.11.7 + diff --git a/SOURCES/kvm-rdma-introduce-capability-x-rdma-pin-all.patch b/SOURCES/kvm-rdma-introduce-capability-x-rdma-pin-all.patch new file mode 100644 index 0000000..2b713e1 --- /dev/null +++ b/SOURCES/kvm-rdma-introduce-capability-x-rdma-pin-all.patch @@ -0,0 +1,126 @@ +From e3995aaa436e2ec92e720ff17855c6460dbc3761 Mon Sep 17 00:00:00 2001 +Message-Id: +In-Reply-To: +References: +From: Nigel Croxon +Date: Thu, 14 Nov 2013 22:52:47 +0100 +Subject: [PATCH 11/46] rdma: introduce capability x-rdma-pin-all + +RH-Author: Nigel Croxon +Message-id: <1384469598-13137-12-git-send-email-ncroxon@redhat.com> +Patchwork-id: 55696 +O-Subject: [RHEL7.0 PATCH 11/42] rdma: introduce capability x-rdma-pin-all +Bugzilla: 1011720 +RH-Acked-by: Orit Wasserman +RH-Acked-by: Amit Shah +RH-Acked-by: Paolo Bonzini + +Bugzilla: 1011720 +https://bugzilla.redhat.com/show_bug.cgi?id=1011720 + +>From commit ID: +commit 60d9222c8f50c3e5dd3df9ee84ddd1d1c4b35389 +Author: Michael R. Hines +Date: Tue Jun 25 21:35:36 2013 -0400 + + rdma: introduce capability x-rdma-pin-all + + This capability allows you to disable dynamic chunk registration + for better throughput on high-performance links. + + For example, using an 8GB RAM virtual machine with all 8GB of memory in + active use and the VM itself is completely idle using a 40 gbps infiniband link: + + 1. x-rdma-pin-all disabled total time: approximately 7.5 seconds @ 9.5 Gbps + 2. x-rdma-pin-all enabled total time: approximately 4 seconds @ 26 Gbps + + These numbers would of course scale up to whatever size virtual machine + you have to migrate using RDMA. + + Enabling this feature does *not* have any measurable affect on + migration *downtime*. This is because, without this feature, all of the + memory will have already been registered already in advance during + the bulk round and does not need to be re-registered during the successive + iteration rounds. + + Reviewed-by: Juan Quintela + Reviewed-by: Paolo Bonzini + Reviewed-by: Chegu Vinod + Reviewed-by: Eric Blake + Tested-by: Chegu Vinod + Tested-by: Michael R. Hines + Signed-off-by: Michael R. Hines + Signed-off-by: Juan Quintela +--- + include/migration/migration.h | 1 + + migration.c | 9 +++++++++ + qapi-schema.json | 7 ++++++- + 3 files changed, 16 insertions(+), 1 deletions(-) + +Signed-off-by: Michal Novotny +--- + include/migration/migration.h | 1 + + migration.c | 9 +++++++++ + qapi-schema.json | 7 ++++++- + 3 files changed, 16 insertions(+), 1 deletion(-) + +diff --git a/include/migration/migration.h b/include/migration/migration.h +index 6455e36..701709a 100644 +--- a/include/migration/migration.h ++++ b/include/migration/migration.h +@@ -123,6 +123,7 @@ void migrate_add_blocker(Error *reason); + */ + void migrate_del_blocker(Error *reason); + ++bool migrate_rdma_pin_all(void); + bool migrate_zero_blocks(void); + + bool migrate_auto_converge(void); +diff --git a/migration.c b/migration.c +index f4d1e34..73a348f 100644 +--- a/migration.c ++++ b/migration.c +@@ -484,6 +484,15 @@ void qmp_migrate_set_downtime(double value, Error **errp) + max_downtime = (uint64_t)value; + } + ++bool migrate_rdma_pin_all(void) ++{ ++ MigrationState *s; ++ ++ s = migrate_get_current(); ++ ++ return s->enabled_capabilities[MIGRATION_CAPABILITY_X_RDMA_PIN_ALL]; ++} ++ + bool migrate_auto_converge(void) + { + MigrationState *s; +diff --git a/qapi-schema.json b/qapi-schema.json +index 17df327..bf1fe68 100644 +--- a/qapi-schema.json ++++ b/qapi-schema.json +@@ -664,6 +664,11 @@ + # This feature allows us to minimize migration traffic for certain work + # loads, by sending compressed difference of the pages + # ++# @x-rdma-pin-all: Controls whether or not the entire VM memory footprint is ++# mlock()'d on demand or all at once. Refer to docs/rdma.txt for usage. ++# Disabled by default. Experimental: may (or may not) be renamed after ++# further testing is complete. (since 1.6) ++# + # @auto-converge: If enabled, QEMU will automatically throttle down the guest + # to speed up convergence of RAM migration. (since 1.6) + # +@@ -679,7 +684,7 @@ + # Since: 1.2 + ## + { 'enum': 'MigrationCapability', +- 'data': ['xbzrle', 'auto-converge', 'zero-blocks'] } ++ 'data': ['xbzrle', 'x-rdma-pin-all', 'auto-converge', 'zero-blocks'] } + + ## + # @MigrationCapabilityStatus +-- +1.7.11.7 + diff --git a/SOURCES/kvm-rdma-introduce-qemu_file_mode_is_not_valid.patch b/SOURCES/kvm-rdma-introduce-qemu_file_mode_is_not_valid.patch new file mode 100644 index 0000000..8762934 --- /dev/null +++ b/SOURCES/kvm-rdma-introduce-qemu_file_mode_is_not_valid.patch @@ -0,0 +1,106 @@ +From e7b184d50f2723ae82e35251ad8f05ec1cddb034 Mon Sep 17 00:00:00 2001 +Message-Id: +In-Reply-To: +References: +From: Nigel Croxon +Date: Thu, 14 Nov 2013 22:52:44 +0100 +Subject: [PATCH 08/46] rdma: introduce qemu_file_mode_is_not_valid() + +RH-Author: Nigel Croxon +Message-id: <1384469598-13137-9-git-send-email-ncroxon@redhat.com> +Patchwork-id: 55692 +O-Subject: [RHEL7.0 PATCH 08/42] rdma: introduce qemu_file_mode_is_not_valid() +Bugzilla: 1011720 +RH-Acked-by: Orit Wasserman +RH-Acked-by: Amit Shah +RH-Acked-by: Paolo Bonzini + +Bugzilla: 1011720 +https://bugzilla.redhat.com/show_bug.cgi?id=1011720 + +>From commit ID: +commit bc1256f7f187cc7d491bfe3861249a60873adbbc +Author: Michael R. Hines +Date: Tue Jun 25 21:35:31 2013 -0400 + + rdma: introduce qemu_file_mode_is_not_valid() + + QEMUFileRDMA also has read and write modes. This function is now + shared to reduce code duplication. + + Reviewed-by: Juan Quintela + Reviewed-by: Paolo Bonzini + Reviewed-by: Chegu Vinod + Tested-by: Chegu Vinod + Tested-by: Michael R. Hines + Signed-off-by: Michael R. Hines + Signed-off-by: Juan Quintela +--- + include/migration/qemu-file.h | 1 + + savevm.c | 20 +++++++++++++------- + 2 files changed, 14 insertions(+), 7 deletions(-) + +Signed-off-by: Michal Novotny +--- + include/migration/qemu-file.h | 1 + + savevm.c | 20 +++++++++++++------- + 2 files changed, 14 insertions(+), 7 deletions(-) + +diff --git a/include/migration/qemu-file.h b/include/migration/qemu-file.h +index fb1cf40..37d1604 100644 +--- a/include/migration/qemu-file.h ++++ b/include/migration/qemu-file.h +@@ -80,6 +80,7 @@ void qemu_put_byte(QEMUFile *f, int v); + * The buffer should be available till it is sent asynchronously. + */ + void qemu_put_buffer_async(QEMUFile *f, const uint8_t *buf, int size); ++bool qemu_file_mode_is_not_valid(const char *mode); + + static inline void qemu_put_ubyte(QEMUFile *f, unsigned int v) + { +diff --git a/savevm.c b/savevm.c +index 9304788..26d5607 100644 +--- a/savevm.c ++++ b/savevm.c +@@ -449,14 +449,23 @@ static const QEMUFileOps socket_write_ops = { + .close = socket_close + }; + +-QEMUFile *qemu_fopen_socket(int fd, const char *mode) ++bool qemu_file_mode_is_not_valid(const char *mode) + { +- QEMUFileSocket *s; +- + if (mode == NULL || + (mode[0] != 'r' && mode[0] != 'w') || + mode[1] != 'b' || mode[2] != 0) { + fprintf(stderr, "qemu_fopen: Argument validity check failed\n"); ++ return true; ++ } ++ ++ return false; ++} ++ ++QEMUFile *qemu_fopen_socket(int fd, const char *mode) ++{ ++ QEMUFileSocket *s; ++ ++ if (qemu_file_mode_is_not_valid(mode)) { + return NULL; + } + +@@ -475,10 +484,7 @@ QEMUFile *qemu_fopen(const char *filename, const char *mode) + { + QEMUFileStdio *s; + +- if (mode == NULL || +- (mode[0] != 'r' && mode[0] != 'w') || +- mode[1] != 'b' || mode[2] != 0) { +- fprintf(stderr, "qemu_fopen: Argument validity check failed\n"); ++ if (qemu_file_mode_is_not_valid(mode)) { + return NULL; + } + +-- +1.7.11.7 + diff --git a/SOURCES/kvm-rdma-introduce-qemu_ram_foreach_block.patch b/SOURCES/kvm-rdma-introduce-qemu_ram_foreach_block.patch new file mode 100644 index 0000000..2f60c16 --- /dev/null +++ b/SOURCES/kvm-rdma-introduce-qemu_ram_foreach_block.patch @@ -0,0 +1,85 @@ +From 34bab268a046ceb03e4f925eb8f45a80314c6c34 Mon Sep 17 00:00:00 2001 +Message-Id: <34bab268a046ceb03e4f925eb8f45a80314c6c34.1387382496.git.minovotn@redhat.com> +In-Reply-To: +References: +From: Nigel Croxon +Date: Thu, 14 Nov 2013 22:52:45 +0100 +Subject: [PATCH 09/46] rdma: introduce qemu_ram_foreach_block() + +RH-Author: Nigel Croxon +Message-id: <1384469598-13137-10-git-send-email-ncroxon@redhat.com> +Patchwork-id: 55693 +O-Subject: [RHEL7.0 PATCH 09/42] rdma: introduce qemu_ram_foreach_block() +Bugzilla: 1011720 +RH-Acked-by: Orit Wasserman +RH-Acked-by: Amit Shah +RH-Acked-by: Paolo Bonzini + +Bugzilla: 1011720 +https://bugzilla.redhat.com/show_bug.cgi?id=1011720 + +>From commit ID: +commit bd2fa51fcdba3408f308df1b08fae04053ecdee5 +Author: Michael R. Hines +Date: Tue Jun 25 21:35:34 2013 -0400 + + rdma: introduce qemu_ram_foreach_block() + + This is used during RDMA initialization in order to + transmit a description of all the RAM blocks to the + peer for later dynamic chunk registration purposes. + + Reviewed-by: Juan Quintela + Reviewed-by: Paolo Bonzini + Reviewed-by: Chegu Vinod + Tested-by: Chegu Vinod + Tested-by: Michael R. Hines + Signed-off-by: Michael R. Hines + Signed-off-by: Juan Quintela +--- + exec.c | 9 +++++++++ + include/exec/cpu-common.h | 5 +++++ + 2 files changed, 14 insertions(+), 0 deletions(-) + +Signed-off-by: Michal Novotny +--- + exec.c | 9 +++++++++ + include/exec/cpu-common.h | 5 +++++ + 2 files changed, 14 insertions(+) + +diff --git a/exec.c b/exec.c +index cb11571..64af205 100644 +--- a/exec.c ++++ b/exec.c +@@ -2644,3 +2644,12 @@ bool cpu_physical_memory_is_io(hwaddr phys_addr) + memory_region_is_romd(section->mr)); + } + #endif ++ ++void qemu_ram_foreach_block(RAMBlockIterFunc func, void *opaque) ++{ ++ RAMBlock *block; ++ ++ QTAILQ_FOREACH(block, &ram_list.blocks, next) { ++ func(block->host, block->offset, block->length, opaque); ++ } ++} +diff --git a/include/exec/cpu-common.h b/include/exec/cpu-common.h +index 2e5f11f..2900fd6 100644 +--- a/include/exec/cpu-common.h ++++ b/include/exec/cpu-common.h +@@ -119,6 +119,11 @@ extern struct MemoryRegion io_mem_rom; + extern struct MemoryRegion io_mem_unassigned; + extern struct MemoryRegion io_mem_notdirty; + ++typedef void (RAMBlockIterFunc)(void *host_addr, ++ ram_addr_t offset, ram_addr_t length, void *opaque); ++ ++void qemu_ram_foreach_block(RAMBlockIterFunc func, void *opaque); ++ + #endif + + #endif /* !CPU_COMMON_H */ +-- +1.7.11.7 + diff --git a/SOURCES/kvm-rdma-introduce-qemu_update_position.patch b/SOURCES/kvm-rdma-introduce-qemu_update_position.patch new file mode 100644 index 0000000..dbf2f1d --- /dev/null +++ b/SOURCES/kvm-rdma-introduce-qemu_update_position.patch @@ -0,0 +1,120 @@ +From 2d15ce1f7898287ef50a658bb08aeb4bb22b8a0a Mon Sep 17 00:00:00 2001 +Message-Id: <2d15ce1f7898287ef50a658bb08aeb4bb22b8a0a.1387382496.git.minovotn@redhat.com> +In-Reply-To: +References: +From: Nigel Croxon +Date: Thu, 14 Nov 2013 22:52:41 +0100 +Subject: [PATCH 05/46] rdma: introduce qemu_update_position() + +RH-Author: Nigel Croxon +Message-id: <1384469598-13137-6-git-send-email-ncroxon@redhat.com> +Patchwork-id: 55689 +O-Subject: [RHEL7.0 PATCH 05/42] rdma: introduce qemu_update_position() +Bugzilla: 1011720 +RH-Acked-by: Orit Wasserman +RH-Acked-by: Amit Shah +RH-Acked-by: Paolo Bonzini + +Bugzilla: 1011720 +https://bugzilla.redhat.com/show_bug.cgi?id=1011720 + +>From commit ID: +commit 2b0ce0797d6bfb13ebefe010da86abced0b7a9b3 +Author: Michael R. Hines +Date: Tue Jun 25 21:35:28 2013 -0400 + + rdma: introduce qemu_update_position() + + RDMA writes happen asynchronously, and thus the performance accounting + also needs to be able to occur asynchronously. This allows anybody + to call into savevm.c to update both f->pos as well as into arch_init.c + to update the acct_info structure with up-to-date values when + the RDMA transfer actually completes. + + Reviewed-by: Juan Quintela + Tested-by: Chegu Vinod + Tested-by: Michael R. Hines + Signed-off-by: Michael R. Hines + Signed-off-by: Juan Quintela +--- + arch_init.c | 12 ++++++++++++ + include/migration/migration.h | 2 ++ + include/migration/qemu-file.h | 1 + + savevm.c | 5 +++++ + 4 files changed, 20 insertions(+), 0 deletions(-) + +Signed-off-by: Michal Novotny +--- + arch_init.c | 12 ++++++++++++ + include/migration/migration.h | 2 ++ + include/migration/qemu-file.h | 1 + + savevm.c | 5 +++++ + 4 files changed, 20 insertions(+) + +diff --git a/arch_init.c b/arch_init.c +index 2c0ea1b..e940ede 100644 +--- a/arch_init.c ++++ b/arch_init.c +@@ -522,6 +522,18 @@ static int ram_save_block(QEMUFile *f, bool last_stage) + + static uint64_t bytes_transferred; + ++void acct_update_position(QEMUFile *f, size_t size, bool zero) ++{ ++ uint64_t pages = size / TARGET_PAGE_SIZE; ++ if (zero) { ++ acct_info.dup_pages += pages; ++ } else { ++ acct_info.norm_pages += pages; ++ bytes_transferred += size; ++ qemu_update_position(f, size); ++ } ++} ++ + static ram_addr_t ram_save_remaining(void) + { + return migration_dirty_pages; +diff --git a/include/migration/migration.h b/include/migration/migration.h +index f1519dd..2f3a3d9 100644 +--- a/include/migration/migration.h ++++ b/include/migration/migration.h +@@ -92,6 +92,8 @@ uint64_t ram_bytes_remaining(void); + uint64_t ram_bytes_transferred(void); + uint64_t ram_bytes_total(void); + ++void acct_update_position(QEMUFile *f, size_t size, bool zero); ++ + extern SaveVMHandlers savevm_ram_handlers; + + uint64_t dup_mig_bytes_transferred(void); +diff --git a/include/migration/qemu-file.h b/include/migration/qemu-file.h +index 8931e16..fb1cf40 100644 +--- a/include/migration/qemu-file.h ++++ b/include/migration/qemu-file.h +@@ -93,6 +93,7 @@ void qemu_put_be32(QEMUFile *f, unsigned int v); + void qemu_put_be64(QEMUFile *f, uint64_t v); + int qemu_get_buffer(QEMUFile *f, uint8_t *buf, int size); + int qemu_get_byte(QEMUFile *f); ++void qemu_update_position(QEMUFile *f, size_t size); + + static inline unsigned int qemu_get_ubyte(QEMUFile *f) + { +diff --git a/savevm.c b/savevm.c +index 4d898af..f68f7f2 100644 +--- a/savevm.c ++++ b/savevm.c +@@ -671,6 +671,11 @@ int qemu_get_fd(QEMUFile *f) + return -1; + } + ++void qemu_update_position(QEMUFile *f, size_t size) ++{ ++ f->pos += size; ++} ++ + /** Closes the file + * + * Returns negative error value if any error happened on previous operations or +-- +1.7.11.7 + diff --git a/SOURCES/kvm-rdma-introduce-ram_handle_compressed.patch b/SOURCES/kvm-rdma-introduce-ram_handle_compressed.patch new file mode 100644 index 0000000..f8023b6 --- /dev/null +++ b/SOURCES/kvm-rdma-introduce-ram_handle_compressed.patch @@ -0,0 +1,111 @@ +From 6499b6033f8aff6482cfa7942b0c16b386a519f5 Mon Sep 17 00:00:00 2001 +Message-Id: <6499b6033f8aff6482cfa7942b0c16b386a519f5.1387382496.git.minovotn@redhat.com> +In-Reply-To: +References: +From: Nigel Croxon +Date: Thu, 14 Nov 2013 22:52:50 +0100 +Subject: [PATCH 14/46] rdma: introduce ram_handle_compressed() + +RH-Author: Nigel Croxon +Message-id: <1384469598-13137-15-git-send-email-ncroxon@redhat.com> +Patchwork-id: 55706 +O-Subject: [RHEL7.0 PATCH 14/42] rdma: introduce ram_handle_compressed() +Bugzilla: 1011720 +RH-Acked-by: Orit Wasserman +RH-Acked-by: Amit Shah +RH-Acked-by: Paolo Bonzini + +Bugzilla: 1011720 +https://bugzilla.redhat.com/show_bug.cgi?id=1011720 + +>From commit ID: +commit 44c3b58cf9b2c91a38363f0b45d20f3f40b8f2b3 +Author: Michael R. Hines +Date: Mon Jul 22 10:01:53 2013 -0400 + + rdma: introduce ram_handle_compressed() + + This gives RDMA shared access to madvise() on the destination side + when an entire chunk is found to be zero. + + Reviewed-by: Juan Quintela + Reviewed-by: Paolo Bonzini + Reviewed-by: Chegu Vinod + Tested-by: Chegu Vinod + Tested-by: Michael R. Hines + Signed-off-by: Michael R. Hines + Signed-off-by: Juan Quintela +--- + arch_init.c | 29 +++++++++++++++++++---------- + include/migration/migration.h | 2 ++ + 2 files changed, 21 insertions(+), 10 deletions(-) + +Signed-off-by: Michal Novotny +--- + arch_init.c | 29 +++++++++++++++++++---------- + include/migration/migration.h | 2 ++ + 2 files changed, 21 insertions(+), 10 deletions(-) + +diff --git a/arch_init.c b/arch_init.c +index e940ede..e7da520 100644 +--- a/arch_init.c ++++ b/arch_init.c +@@ -809,6 +809,24 @@ static inline void *host_from_stream_offset(QEMUFile *f, + return NULL; + } + ++/* ++ * If a page (or a whole RDMA chunk) has been ++ * determined to be zero, then zap it. ++ */ ++void ram_handle_compressed(void *host, uint8_t ch, uint64_t size) ++{ ++ if (ch != 0 || !is_zero_page(host)) { ++ memset(host, ch, size); ++#ifndef _WIN32 ++ if (ch == 0 && ++ (!kvm_enabled() || kvm_has_sync_mmu()) && ++ getpagesize() <= TARGET_PAGE_SIZE) { ++ qemu_madvise(host, TARGET_PAGE_SIZE, QEMU_MADV_DONTNEED); ++ } ++#endif ++ } ++} ++ + static int ram_load(QEMUFile *f, void *opaque, int version_id) + { + ram_addr_t addr; +@@ -876,16 +894,7 @@ static int ram_load(QEMUFile *f, void *opaque, int version_id) + } + + ch = qemu_get_byte(f); +- if (ch != 0 || !is_zero_page(host)) { +- memset(host, ch, TARGET_PAGE_SIZE); +-#ifndef _WIN32 +- if (ch == 0 && +- (!kvm_enabled() || kvm_has_sync_mmu()) && +- getpagesize() <= TARGET_PAGE_SIZE) { +- qemu_madvise(host, TARGET_PAGE_SIZE, QEMU_MADV_DONTNEED); +- } +-#endif +- } ++ ram_handle_compressed(host, ch, TARGET_PAGE_SIZE); + } else if (flags & RAM_SAVE_FLAG_PAGE) { + void *host; + +diff --git a/include/migration/migration.h b/include/migration/migration.h +index 701709a..90b5021 100644 +--- a/include/migration/migration.h ++++ b/include/migration/migration.h +@@ -109,6 +109,8 @@ uint64_t xbzrle_mig_pages_transferred(void); + uint64_t xbzrle_mig_pages_overflow(void); + uint64_t xbzrle_mig_pages_cache_miss(void); + ++void ram_handle_compressed(void *host, uint8_t ch, uint64_t size); ++ + /** + * @migrate_add_blocker - prevent migration from proceeding + * +-- +1.7.11.7 + diff --git a/SOURCES/kvm-rdma-memory-leak-RDMAContext-host.patch b/SOURCES/kvm-rdma-memory-leak-RDMAContext-host.patch new file mode 100644 index 0000000..d4bd4bb --- /dev/null +++ b/SOURCES/kvm-rdma-memory-leak-RDMAContext-host.patch @@ -0,0 +1,59 @@ +From ca20b922adfc76c1aff60e86ae731295cf82f884 Mon Sep 17 00:00:00 2001 +Message-Id: +In-Reply-To: +References: +From: Nigel Croxon +Date: Thu, 14 Nov 2013 22:53:02 +0100 +Subject: [PATCH 26/46] rdma: memory leak RDMAContext::host + +RH-Author: Nigel Croxon +Message-id: <1384469598-13137-27-git-send-email-ncroxon@redhat.com> +Patchwork-id: 55704 +O-Subject: [RHEL7.0 PATCH 26/42] rdma: memory leak RDMAContext::host +Bugzilla: 1011720 +RH-Acked-by: Orit Wasserman +RH-Acked-by: Amit Shah +RH-Acked-by: Paolo Bonzini + +Bugzilla: 1011720 +https://bugzilla.redhat.com/show_bug.cgi?id=1011720 + +>From commit ID: +commit e1d0fb378ae3bb4272124a12e3fe1a02c4745eb1 +Author: Isaku Yamahata +Date: Sat Aug 3 22:54:54 2013 -0400 + + rdma: memory leak RDMAContext::host + + It is allocated by g_strdup(), so needs to be freed. + + Reviewed-by: Michael R. Hines + Signed-off-by: Isaku Yamahata + Signed-off-by: Michael R. Hines + Message-id: 1375584894-9917-8-git-send-email-mrhines@linux.vnet.ibm.com + Signed-off-by: Anthony Liguori +--- + migration-rdma.c | 2 ++ + 1 files changed, 2 insertions(+), 0 deletions(-) + +Signed-off-by: Michal Novotny +--- + migration-rdma.c | 2 ++ + 1 file changed, 2 insertions(+) + +diff --git a/migration-rdma.c b/migration-rdma.c +index 6afe98c..ff0a823 100644 +--- a/migration-rdma.c ++++ b/migration-rdma.c +@@ -2097,6 +2097,8 @@ static void qemu_rdma_cleanup(RDMAContext *rdma) + rdma_destroy_event_channel(rdma->channel); + rdma->channel = NULL; + } ++ g_free(rdma->host); ++ rdma->host = NULL; + } + + +-- +1.7.11.7 + diff --git a/SOURCES/kvm-rdma-new-QEMUFileOps-hooks.patch b/SOURCES/kvm-rdma-new-QEMUFileOps-hooks.patch new file mode 100644 index 0000000..e809999 --- /dev/null +++ b/SOURCES/kvm-rdma-new-QEMUFileOps-hooks.patch @@ -0,0 +1,220 @@ +From 01eb364d7e367e66572363b4c974b7f3428ea4ca Mon Sep 17 00:00:00 2001 +Message-Id: <01eb364d7e367e66572363b4c974b7f3428ea4ca.1387382496.git.minovotn@redhat.com> +In-Reply-To: +References: +From: Nigel Croxon +Date: Thu, 14 Nov 2013 22:52:46 +0100 +Subject: [PATCH 10/46] rdma: new QEMUFileOps hooks + +RH-Author: Nigel Croxon +Message-id: <1384469598-13137-11-git-send-email-ncroxon@redhat.com> +Patchwork-id: 55694 +O-Subject: [RHEL7.0 PATCH 10/42] rdma: new QEMUFileOps hooks +Bugzilla: 1011720 +RH-Acked-by: Orit Wasserman +RH-Acked-by: Amit Shah +RH-Acked-by: Paolo Bonzini + +Bugzilla: 1011720 +https://bugzilla.redhat.com/show_bug.cgi?id=1011720 + +>From commit ID: +commit 43487c678d6e4e7182bfa70d2bc75422578782aa +Author: Michael R. Hines +Date: Tue Jun 25 21:35:35 2013 -0400 + + rdma: new QEMUFileOps hooks + + These are the prototypes and implementation of new hooks that + RDMA takes advantage of to perform dynamic page registration. + + An optional hook is also introduced for a custom function + to be able to override the default save_page function. + + Also included are the prototypes and accessor methods used by + arch_init.c which invoke funtions inside savevm.c to call out + to the hooks that may or may not have been overridden + inside of QEMUFileOps. + + Reviewed-by: Juan Quintela + Reviewed-by: Paolo Bonzini + Reviewed-by: Chegu Vinod + Tested-by: Chegu Vinod + Tested-by: Michael R. Hines + Signed-off-by: Michael R. Hines + Signed-off-by: Juan Quintela +--- + include/migration/migration.h | 20 ++++++++++++++ + include/migration/qemu-file.h | 29 ++++++++++++++++++++ + savevm.c | 59 +++++++++++++++++++++++++++++++++++++++++ + 3 files changed, 108 insertions(+), 0 deletions(-) + +Signed-off-by: Michal Novotny +--- + include/migration/migration.h | 20 +++++++++++++++ + include/migration/qemu-file.h | 29 +++++++++++++++++++++ + savevm.c | 59 +++++++++++++++++++++++++++++++++++++++++++ + 3 files changed, 108 insertions(+) + +diff --git a/include/migration/migration.h b/include/migration/migration.h +index 201be18..6455e36 100644 +--- a/include/migration/migration.h ++++ b/include/migration/migration.h +@@ -21,6 +21,7 @@ + #include "qapi/error.h" + #include "migration/vmstate.h" + #include "qapi-types.h" ++#include "exec/cpu-common.h" + + struct MigrationParams { + bool blk; +@@ -134,4 +135,23 @@ int migrate_use_xbzrle(void); + int64_t migrate_xbzrle_cache_size(void); + + int64_t xbzrle_cache_resize(int64_t new_size); ++ ++void ram_control_before_iterate(QEMUFile *f, uint64_t flags); ++void ram_control_after_iterate(QEMUFile *f, uint64_t flags); ++void ram_control_load_hook(QEMUFile *f, uint64_t flags); ++ ++/* Whenever this is found in the data stream, the flags ++ * will be passed to ram_control_load_hook in the incoming-migration ++ * side. This lets before_ram_iterate/after_ram_iterate add ++ * transport-specific sections to the RAM migration data. ++ */ ++#define RAM_SAVE_FLAG_HOOK 0x80 ++ ++#define RAM_SAVE_CONTROL_NOT_SUPP -1000 ++#define RAM_SAVE_CONTROL_DELAYED -2000 ++ ++size_t ram_control_save_page(QEMUFile *f, ram_addr_t block_offset, ++ ram_addr_t offset, size_t size, ++ int *bytes_sent); ++ + #endif +diff --git a/include/migration/qemu-file.h b/include/migration/qemu-file.h +index 37d1604..0f757fb 100644 +--- a/include/migration/qemu-file.h ++++ b/include/migration/qemu-file.h +@@ -23,6 +23,7 @@ + */ + #ifndef QEMU_FILE_H + #define QEMU_FILE_H 1 ++#include "exec/cpu-common.h" + + /* This function writes a chunk of data to a file at the given position. + * The pos argument can be ignored if the file is only being used for +@@ -57,12 +58,40 @@ typedef int (QEMUFileGetFD)(void *opaque); + typedef ssize_t (QEMUFileWritevBufferFunc)(void *opaque, struct iovec *iov, + int iovcnt, int64_t pos); + ++/* ++ * This function provides hooks around different ++ * stages of RAM migration. ++ */ ++typedef int (QEMURamHookFunc)(QEMUFile *f, void *opaque, uint64_t flags); ++ ++/* ++ * Constants used by ram_control_* hooks ++ */ ++#define RAM_CONTROL_SETUP 0 ++#define RAM_CONTROL_ROUND 1 ++#define RAM_CONTROL_HOOK 2 ++#define RAM_CONTROL_FINISH 3 ++ ++/* ++ * This function allows override of where the RAM page ++ * is saved (such as RDMA, for example.) ++ */ ++typedef size_t (QEMURamSaveFunc)(QEMUFile *f, void *opaque, ++ ram_addr_t block_offset, ++ ram_addr_t offset, ++ size_t size, ++ int *bytes_sent); ++ + typedef struct QEMUFileOps { + QEMUFilePutBufferFunc *put_buffer; + QEMUFileGetBufferFunc *get_buffer; + QEMUFileCloseFunc *close; + QEMUFileGetFD *get_fd; + QEMUFileWritevBufferFunc *writev_buffer; ++ QEMURamHookFunc *before_ram_iterate; ++ QEMURamHookFunc *after_ram_iterate; ++ QEMURamHookFunc *hook_ram_load; ++ QEMURamSaveFunc *save_page; + } QEMUFileOps; + + QEMUFile *qemu_fopen_ops(void *opaque, const QEMUFileOps *ops); +diff --git a/savevm.c b/savevm.c +index 26d5607..e0491e7 100644 +--- a/savevm.c ++++ b/savevm.c +@@ -616,6 +616,65 @@ void qemu_fflush(QEMUFile *f) + } + } + ++void ram_control_before_iterate(QEMUFile *f, uint64_t flags) ++{ ++ int ret = 0; ++ ++ if (f->ops->before_ram_iterate) { ++ ret = f->ops->before_ram_iterate(f, f->opaque, flags); ++ if (ret < 0) { ++ qemu_file_set_error(f, ret); ++ } ++ } ++} ++ ++void ram_control_after_iterate(QEMUFile *f, uint64_t flags) ++{ ++ int ret = 0; ++ ++ if (f->ops->after_ram_iterate) { ++ ret = f->ops->after_ram_iterate(f, f->opaque, flags); ++ if (ret < 0) { ++ qemu_file_set_error(f, ret); ++ } ++ } ++} ++ ++void ram_control_load_hook(QEMUFile *f, uint64_t flags) ++{ ++ int ret = 0; ++ ++ if (f->ops->hook_ram_load) { ++ ret = f->ops->hook_ram_load(f, f->opaque, flags); ++ if (ret < 0) { ++ qemu_file_set_error(f, ret); ++ } ++ } else { ++ qemu_file_set_error(f, ret); ++ } ++} ++ ++size_t ram_control_save_page(QEMUFile *f, ram_addr_t block_offset, ++ ram_addr_t offset, size_t size, int *bytes_sent) ++{ ++ if (f->ops->save_page) { ++ int ret = f->ops->save_page(f, f->opaque, block_offset, ++ offset, size, bytes_sent); ++ ++ if (ret != RAM_SAVE_CONTROL_DELAYED) { ++ if (*bytes_sent > 0) { ++ qemu_update_position(f, *bytes_sent); ++ } else if (ret < 0) { ++ qemu_file_set_error(f, ret); ++ } ++ } ++ ++ return ret; ++ } ++ ++ return RAM_SAVE_CONTROL_NOT_SUPP; ++} ++ + static void qemu_fill_buffer(QEMUFile *f) + { + int len; +-- +1.7.11.7 + diff --git a/SOURCES/kvm-rdma-proper-getaddrinfo-handling.patch b/SOURCES/kvm-rdma-proper-getaddrinfo-handling.patch new file mode 100644 index 0000000..f2cc4f4 --- /dev/null +++ b/SOURCES/kvm-rdma-proper-getaddrinfo-handling.patch @@ -0,0 +1,168 @@ +From b60d6390ff9415bc5960ba20ff5cc56e50078f85 Mon Sep 17 00:00:00 2001 +Message-Id: +In-Reply-To: +References: +From: Nigel Croxon +Date: Thu, 14 Nov 2013 22:53:06 +0100 +Subject: [PATCH 30/46] rdma: proper getaddrinfo() handling + +RH-Author: Nigel Croxon +Message-id: <1384469598-13137-31-git-send-email-ncroxon@redhat.com> +Patchwork-id: 55714 +O-Subject: [RHEL7.0 PATCH 30/42] rdma: proper getaddrinfo() handling +Bugzilla: 1011720 +RH-Acked-by: Orit Wasserman +RH-Acked-by: Amit Shah +RH-Acked-by: Paolo Bonzini + +Bugzilla: 1011720 +https://bugzilla.redhat.com/show_bug.cgi?id=1011720 + +>From commit ID: +commit 6470215b794d6d9f9ffbd82f669645715eb014f8 +Author: Michael R. Hines +Date: Fri Aug 9 16:05:43 2013 -0400 + + rdma: proper getaddrinfo() handling + + getaddrinfo() already knows what it's doing, + but it can potentially return multiple addresses. + We need to handle that... + + Reviewed-by: Orit Wasserman + Signed-off-by: Michael R. Hines + Message-id: 1376078746-24948-5-git-send-email-mrhines@linux.vnet.ibm.com + Signed-off-by: Anthony Liguori +--- + migration-rdma.c | 56 +++++++++++++++++++++++++++-------------------------- + 1 files changed, 29 insertions(+), 27 deletions(-) + +Signed-off-by: Michal Novotny +--- + migration-rdma.c | 56 +++++++++++++++++++++++++++++--------------------------- + 1 file changed, 29 insertions(+), 27 deletions(-) + +diff --git a/migration-rdma.c b/migration-rdma.c +index 9c02ad3..e6fd77a 100644 +--- a/migration-rdma.c ++++ b/migration-rdma.c +@@ -392,7 +392,6 @@ typedef struct RDMAContext { + uint64_t unregistrations[RDMA_SIGNALED_SEND_MAX]; + + GHashTable *blockmap; +- bool ipv6; + } RDMAContext; + + /* +@@ -745,7 +744,7 @@ static int qemu_rdma_resolve_host(RDMAContext *rdma, Error **errp) + char port_str[16]; + struct rdma_cm_event *cm_event; + char ip[40] = "unknown"; +- int af = rdma->ipv6 ? PF_INET6 : PF_INET; ++ struct addrinfo *e; + + if (rdma->host == NULL || !strcmp(rdma->host, "")) { + ERROR(errp, "RDMA hostname has not been set"); +@@ -775,18 +774,23 @@ static int qemu_rdma_resolve_host(RDMAContext *rdma, Error **errp) + goto err_resolve_get_addr; + } + +- inet_ntop(af, &((struct sockaddr_in *) res->ai_addr)->sin_addr, +- ip, sizeof ip); +- DPRINTF("%s => %s\n", rdma->host, ip); ++ for (e = res; e != NULL; e = e->ai_next) { ++ inet_ntop(e->ai_family, ++ &((struct sockaddr_in *) e->ai_addr)->sin_addr, ip, sizeof ip); ++ DPRINTF("Trying %s => %s\n", rdma->host, ip); + +- /* resolve the first address */ +- ret = rdma_resolve_addr(rdma->cm_id, NULL, res->ai_addr, +- RDMA_RESOLVE_TIMEOUT_MS); +- if (ret) { +- ERROR(errp, "could not resolve address %s", rdma->host); +- goto err_resolve_get_addr; ++ /* resolve the first address */ ++ ret = rdma_resolve_addr(rdma->cm_id, NULL, e->ai_addr, ++ RDMA_RESOLVE_TIMEOUT_MS); ++ if (!ret) { ++ goto route; ++ } + } + ++ ERROR(errp, "could not resolve address %s", rdma->host); ++ goto err_resolve_get_addr; ++ ++route: + qemu_rdma_dump_gid("source_resolve_addr", rdma->cm_id); + + ret = rdma_get_cm_event(rdma->channel, &cm_event); +@@ -2260,8 +2264,6 @@ err_rdma_source_connect: + static int qemu_rdma_dest_init(RDMAContext *rdma, Error **errp) + { + int ret = -EINVAL, idx; +- int af = rdma->ipv6 ? PF_INET6 : PF_INET; +- struct sockaddr_in sin; + struct rdma_cm_id *listen_id; + char ip[40] = "unknown"; + struct addrinfo *res; +@@ -2292,35 +2294,36 @@ static int qemu_rdma_dest_init(RDMAContext *rdma, Error **errp) + goto err_dest_init_create_listen_id; + } + +- memset(&sin, 0, sizeof(sin)); +- sin.sin_family = af; +- sin.sin_port = htons(rdma->port); + snprintf(port_str, 16, "%d", rdma->port); + port_str[15] = '\0'; + + if (rdma->host && strcmp("", rdma->host)) { ++ struct addrinfo *e; ++ + ret = getaddrinfo(rdma->host, port_str, NULL, &res); + if (ret < 0) { + ERROR(errp, "could not getaddrinfo address %s", rdma->host); + goto err_dest_init_bind_addr; + } + ++ for (e = res; e != NULL; e = e->ai_next) { ++ inet_ntop(e->ai_family, ++ &((struct sockaddr_in *) e->ai_addr)->sin_addr, ip, sizeof ip); ++ DPRINTF("Trying %s => %s\n", rdma->host, ip); ++ ret = rdma_bind_addr(listen_id, e->ai_addr); ++ if (!ret) { ++ goto listen; ++ } ++ } + +- inet_ntop(af, &((struct sockaddr_in *) res->ai_addr)->sin_addr, +- ip, sizeof ip); ++ ERROR(errp, "Error: could not rdma_bind_addr!"); ++ goto err_dest_init_bind_addr; + } else { + ERROR(errp, "migration host and port not specified!"); + ret = -EINVAL; + goto err_dest_init_bind_addr; + } +- +- DPRINTF("%s => %s\n", rdma->host, ip); +- +- ret = rdma_bind_addr(listen_id, res->ai_addr); +- if (ret) { +- ERROR(errp, "Error: could not rdma_bind_addr!"); +- goto err_dest_init_bind_addr; +- } ++listen: + + rdma->listen_id = listen_id; + qemu_rdma_dump_gid("dest_init", listen_id); +@@ -2351,7 +2354,6 @@ static void *qemu_rdma_data_init(const char *host_port, Error **errp) + if (addr != NULL) { + rdma->port = atoi(addr->port); + rdma->host = g_strdup(addr->host); +- rdma->ipv6 = addr->ipv6; + } else { + ERROR(errp, "bad RDMA migration address '%s'", host_port); + g_free(rdma); +-- +1.7.11.7 + diff --git a/SOURCES/kvm-rdma-qemu_rdma_post_send_control-uses-wrongly-RDMA_W.patch b/SOURCES/kvm-rdma-qemu_rdma_post_send_control-uses-wrongly-RDMA_W.patch new file mode 100644 index 0000000..901f488 --- /dev/null +++ b/SOURCES/kvm-rdma-qemu_rdma_post_send_control-uses-wrongly-RDMA_W.patch @@ -0,0 +1,105 @@ +From 4d2bc4b2e4d04efa0fd2f3cd10f6bc22b9c0af9f Mon Sep 17 00:00:00 2001 +Message-Id: <4d2bc4b2e4d04efa0fd2f3cd10f6bc22b9c0af9f.1387382496.git.minovotn@redhat.com> +In-Reply-To: +References: +From: Nigel Croxon +Date: Thu, 14 Nov 2013 22:53:00 +0100 +Subject: [PATCH 24/46] rdma: qemu_rdma_post_send_control uses wrongly + RDMA_WRID_MAX + +RH-Author: Nigel Croxon +Message-id: <1384469598-13137-25-git-send-email-ncroxon@redhat.com> +Patchwork-id: 55708 +O-Subject: [RHEL7.0 PATCH 24/42] rdma: qemu_rdma_post_send_control uses wrongly RDMA_WRID_MAX +Bugzilla: 1011720 +RH-Acked-by: Orit Wasserman +RH-Acked-by: Amit Shah +RH-Acked-by: Paolo Bonzini + +Bugzilla: 1011720 +https://bugzilla.redhat.com/show_bug.cgi?id=1011720 + +>From commit ID: +commit 1f22364bb5a756dfcbd15c2ae2bac18bbcef6190 +Author: Isaku Yamahata +Date: Sat Aug 3 22:54:52 2013 -0400 + + rdma: qemu_rdma_post_send_control uses wrongly RDMA_WRID_MAX + + RDMA_WRID_CONTROL should be used. And remove related work around. + + Reviewed-by: Michael R. Hines + Signed-off-by: Isaku Yamahata + Signed-off-by: Michael R. Hines + Message-id: 1375584894-9917-6-git-send-email-mrhines@linux.vnet.ibm.com + Signed-off-by: Anthony Liguori +--- + migration-rdma.c | 12 ++++++------ + 1 files changed, 6 insertions(+), 6 deletions(-) + +Signed-off-by: Michal Novotny +--- + migration-rdma.c | 12 ++++++------ + 1 file changed, 6 insertions(+), 6 deletions(-) + +diff --git a/migration-rdma.c b/migration-rdma.c +index 7266803..ea16f0e 100644 +--- a/migration-rdma.c ++++ b/migration-rdma.c +@@ -322,7 +322,7 @@ typedef struct RDMAContext { + char *host; + int port; + +- RDMAWorkRequestData wr_data[RDMA_WRID_MAX + 1]; ++ RDMAWorkRequestData wr_data[RDMA_WRID_MAX]; + + /* + * This is used by *_exchange_send() to figure out whether or not +@@ -1399,7 +1399,7 @@ static int qemu_rdma_post_send_control(RDMAContext *rdma, uint8_t *buf, + RDMAControlHeader *head) + { + int ret = 0; +- RDMAWorkRequestData *wr = &rdma->wr_data[RDMA_WRID_MAX]; ++ RDMAWorkRequestData *wr = &rdma->wr_data[RDMA_WRID_CONTROL]; + struct ibv_send_wr *bad_wr; + struct ibv_sge sge = { + .addr = (uint64_t)(wr->control), +@@ -2054,7 +2054,7 @@ static void qemu_rdma_cleanup(RDMAContext *rdma) + g_free(rdma->block); + rdma->block = NULL; + +- for (idx = 0; idx <= RDMA_WRID_MAX; idx++) { ++ for (idx = 0; idx < RDMA_WRID_MAX; idx++) { + if (rdma->wr_data[idx].control_mr) { + rdma->total_registrations--; + ibv_dereg_mr(rdma->wr_data[idx].control_mr); +@@ -2136,7 +2136,7 @@ static int qemu_rdma_source_init(RDMAContext *rdma, Error **errp, bool pin_all) + goto err_rdma_source_init; + } + +- for (idx = 0; idx <= RDMA_WRID_MAX; idx++) { ++ for (idx = 0; idx < RDMA_WRID_MAX; idx++) { + ret = qemu_rdma_reg_control(rdma, idx); + if (ret) { + ERROR(temp, "rdma migration: error registering %d control!", +@@ -2248,7 +2248,7 @@ static int qemu_rdma_dest_init(RDMAContext *rdma, Error **errp) + struct addrinfo *res; + char port_str[16]; + +- for (idx = 0; idx <= RDMA_WRID_MAX; idx++) { ++ for (idx = 0; idx < RDMA_WRID_MAX; idx++) { + rdma->wr_data[idx].control_len = 0; + rdma->wr_data[idx].control_curr = NULL; + } +@@ -2705,7 +2705,7 @@ static int qemu_rdma_accept(RDMAContext *rdma) + goto err_rdma_dest_wait; + } + +- for (idx = 0; idx <= RDMA_WRID_MAX; idx++) { ++ for (idx = 0; idx < RDMA_WRID_MAX; idx++) { + ret = qemu_rdma_reg_control(rdma, idx); + if (ret) { + fprintf(stderr, "rdma: error registering %d control!\n", idx); +-- +1.7.11.7 + diff --git a/SOURCES/kvm-rdma-remaining-documentation-fixes.patch b/SOURCES/kvm-rdma-remaining-documentation-fixes.patch new file mode 100644 index 0000000..f65c426 --- /dev/null +++ b/SOURCES/kvm-rdma-remaining-documentation-fixes.patch @@ -0,0 +1,94 @@ +From 0488e742dcf68d044910b51beddc712ae1baa767 Mon Sep 17 00:00:00 2001 +Message-Id: <0488e742dcf68d044910b51beddc712ae1baa767.1387382496.git.minovotn@redhat.com> +In-Reply-To: +References: +From: Nigel Croxon +Date: Thu, 14 Nov 2013 22:53:08 +0100 +Subject: [PATCH 32/46] rdma: remaining documentation fixes + +RH-Author: Nigel Croxon +Message-id: <1384469598-13137-33-git-send-email-ncroxon@redhat.com> +Patchwork-id: 55710 +O-Subject: [RHEL7.0 PATCH 32/42] rdma: remaining documentation fixes +Bugzilla: 1011720 +RH-Acked-by: Orit Wasserman +RH-Acked-by: Amit Shah +RH-Acked-by: Paolo Bonzini + +Bugzilla: 1011720 +https://bugzilla.redhat.com/show_bug.cgi?id=1011720 + +>From commit ID: +commit 8f3067bd86485f8cd03abc940ddb2b8467ef3627 +Author: Michael R. Hines +Date: Fri Aug 9 16:05:45 2013 -0400 + + rdma: remaining documentation fixes + + Was missing 'setup-time' in some of the QMP documentation... + + Signed-off-by: Michael R. Hines + Reviewed-by: Eric Blake + Message-id: 1376078746-24948-7-git-send-email-mrhines@linux.vnet.ibm.com + Signed-off-by: Anthony Liguori +--- + qmp-commands.hx | 10 ++++++++++ + 1 files changed, 10 insertions(+), 0 deletions(-) + +Signed-off-by: Michal Novotny +--- + qmp-commands.hx | 10 ++++++++++ + 1 file changed, 10 insertions(+) + +diff --git a/qmp-commands.hx b/qmp-commands.hx +index 4942590..cedcd17 100644 +--- a/qmp-commands.hx ++++ b/qmp-commands.hx +@@ -2576,6 +2576,12 @@ The main json-object contains the following: + - "total-time": total amount of ms since migration started. If + migration has ended, it returns the total migration + time (json-int) ++- "setup-time" amount of setup time in milliseconds _before_ the ++ iterations begin but _after_ the QMP command is issued. ++ This is designed to provide an accounting of any activities ++ (such as RDMA pinning) which may be expensive, but do not ++ actually occur during the iterative migration rounds ++ themselves. (json-int) + - "downtime": only present when migration has finished correctly + total amount in ms for downtime that happened (json-int) + - "expected-downtime": only present while migration is active +@@ -2629,6 +2635,7 @@ Examples: + "remaining":123, + "total":246, + "total-time":12345, ++ "setup-time":12345, + "downtime":12345, + "duplicate":123, + "normal":123, +@@ -2653,6 +2660,7 @@ Examples: + "remaining":123, + "total":246, + "total-time":12345, ++ "setup-time":12345, + "expected-downtime":12345, + "duplicate":123, + "normal":123, +@@ -2672,6 +2680,7 @@ Examples: + "remaining":1053304, + "transferred":3720, + "total-time":12345, ++ "setup-time":12345, + "expected-downtime":12345, + "duplicate":123, + "normal":123, +@@ -2697,6 +2706,7 @@ Examples: + "remaining":1053304, + "transferred":3720, + "total-time":12345, ++ "setup-time":12345, + "expected-downtime":12345, + "duplicate":10, + "normal":3333, +-- +1.7.11.7 + diff --git a/SOURCES/kvm-rdma-send-pc.ram.patch b/SOURCES/kvm-rdma-send-pc.ram.patch new file mode 100644 index 0000000..cac694a --- /dev/null +++ b/SOURCES/kvm-rdma-send-pc.ram.patch @@ -0,0 +1,152 @@ +From ab8cff98f973031b20d7f1971b4fe42d8bf6488c Mon Sep 17 00:00:00 2001 +Message-Id: +In-Reply-To: +References: +From: Nigel Croxon +Date: Thu, 14 Nov 2013 22:52:52 +0100 +Subject: [PATCH 16/46] rdma: send pc.ram + +RH-Author: Nigel Croxon +Message-id: <1384469598-13137-17-git-send-email-ncroxon@redhat.com> +Patchwork-id: 55700 +O-Subject: [RHEL7.0 PATCH 16/42] rdma: send pc.ram +Bugzilla: 1011720 +RH-Acked-by: Orit Wasserman +RH-Acked-by: Amit Shah +RH-Acked-by: Paolo Bonzini + +Bugzilla: 1011720 +https://bugzilla.redhat.com/show_bug.cgi?id=1011720 + +>From commit ID: +commit 0033b8b42a1cc2a9350619ea19e11954b12fb819 +Author: Michael R. Hines +Date: Mon Jul 22 10:01:55 2013 -0400 + + rdma: send pc.ram + + This takes advantages of the previous patches: + + 1. use the new QEMUFileOps hook 'save_page' + + 2. call out to the right accessor methods to invoke + the iteration hooks defined in QEMUFileOps + + Reviewed-by: Paolo Bonzini + Reviewed-by: Chegu Vinod + Tested-by: Chegu Vinod + Tested-by: Michael R. Hines + Signed-off-by: Michael R. Hines + Signed-off-by: Juan Quintela +--- + arch_init.c | 33 ++++++++++++++++++++++++++++++++- + 1 files changed, 32 insertions(+), 1 deletions(-) + +Signed-off-by: Michal Novotny +--- + arch_init.c | 33 ++++++++++++++++++++++++++++++++- + 1 file changed, 32 insertions(+), 1 deletion(-) + +diff --git a/arch_init.c b/arch_init.c +index e7da520..034341c 100644 +--- a/arch_init.c ++++ b/arch_init.c +@@ -118,6 +118,7 @@ static void check_guest_throttling(void); + #define RAM_SAVE_FLAG_EOS 0x10 + #define RAM_SAVE_FLAG_CONTINUE 0x20 + #define RAM_SAVE_FLAG_XBZRLE 0x40 ++/* 0x80 is reserved in migration.h start with 0x100 next */ + + + static struct defconfig_file { +@@ -476,6 +477,7 @@ static int ram_save_block(QEMUFile *f, bool last_stage) + ram_bulk_stage = false; + } + } else { ++ int ret; + uint8_t *p; + int cont = (block == last_sent_block) ? + RAM_SAVE_FLAG_CONTINUE : 0; +@@ -484,7 +486,18 @@ static int ram_save_block(QEMUFile *f, bool last_stage) + + /* In doubt sent page as normal */ + bytes_sent = -1; +- if (is_zero_page(p)) { ++ ret = ram_control_save_page(f, block->offset, ++ offset, TARGET_PAGE_SIZE, &bytes_sent); ++ ++ if (ret != RAM_SAVE_CONTROL_NOT_SUPP) { ++ if (ret != RAM_SAVE_CONTROL_DELAYED) { ++ if (bytes_sent > 0) { ++ acct_info.norm_pages++; ++ } else if (bytes_sent == 0) { ++ acct_info.dup_pages++; ++ } ++ } ++ } else if (is_zero_page(p)) { + acct_info.dup_pages++; + bytes_sent = save_block_hdr(f, block, offset, cont, + RAM_SAVE_FLAG_COMPRESS); +@@ -636,6 +649,10 @@ static int ram_save_setup(QEMUFile *f, void *opaque) + } + + qemu_mutex_unlock_ramlist(); ++ ++ ram_control_before_iterate(f, RAM_CONTROL_SETUP); ++ ram_control_after_iterate(f, RAM_CONTROL_SETUP); ++ + qemu_put_be64(f, RAM_SAVE_FLAG_EOS); + + return 0; +@@ -654,6 +671,8 @@ static int ram_save_iterate(QEMUFile *f, void *opaque) + reset_ram_globals(); + } + ++ ram_control_before_iterate(f, RAM_CONTROL_ROUND); ++ + t0 = qemu_get_clock_ns(rt_clock); + i = 0; + while ((ret = qemu_file_rate_limit(f)) == 0) { +@@ -685,6 +704,12 @@ static int ram_save_iterate(QEMUFile *f, void *opaque) + + qemu_mutex_unlock_ramlist(); + ++ /* ++ * Must occur before EOS (or any QEMUFile operation) ++ * because of RDMA protocol. ++ */ ++ ram_control_after_iterate(f, RAM_CONTROL_ROUND); ++ + if (ret < 0) { + bytes_transferred += total_sent; + return ret; +@@ -702,6 +727,8 @@ static int ram_save_complete(QEMUFile *f, void *opaque) + qemu_mutex_lock_ramlist(); + migration_bitmap_sync(); + ++ ram_control_before_iterate(f, RAM_CONTROL_FINISH); ++ + /* try transferring iterative blocks of memory */ + + /* flush all remaining blocks regardless of rate limiting */ +@@ -715,6 +742,8 @@ static int ram_save_complete(QEMUFile *f, void *opaque) + } + bytes_transferred += bytes_sent; + } ++ ++ ram_control_after_iterate(f, RAM_CONTROL_FINISH); + migration_end(); + + qemu_mutex_unlock_ramlist(); +@@ -914,6 +943,8 @@ static int ram_load(QEMUFile *f, void *opaque, int version_id) + ret = -EINVAL; + goto done; + } ++ } else if (flags & RAM_SAVE_FLAG_HOOK) { ++ ram_control_load_hook(f, flags); + } + error = qemu_file_get_error(f); + if (error) { +-- +1.7.11.7 + diff --git a/SOURCES/kvm-rdma-silly-ipv6-bugfix.patch b/SOURCES/kvm-rdma-silly-ipv6-bugfix.patch new file mode 100644 index 0000000..99b6c36 --- /dev/null +++ b/SOURCES/kvm-rdma-silly-ipv6-bugfix.patch @@ -0,0 +1,64 @@ +From b00c5116a41f106737f011b4c803b7451941a732 Mon Sep 17 00:00:00 2001 +Message-Id: +In-Reply-To: +References: +From: Nigel Croxon +Date: Thu, 14 Nov 2013 22:53:09 +0100 +Subject: [PATCH 33/46] rdma: silly ipv6 bugfix + +RH-Author: Nigel Croxon +Message-id: <1384469598-13137-34-git-send-email-ncroxon@redhat.com> +Patchwork-id: 55715 +O-Subject: [RHEL7.0 PATCH 33/42] rdma: silly ipv6 bugfix +Bugzilla: 1011720 +RH-Acked-by: Orit Wasserman +RH-Acked-by: Amit Shah +RH-Acked-by: Paolo Bonzini + +Bugzilla: 1011720 +https://bugzilla.redhat.com/show_bug.cgi?id=1011720 + +>From commit ID: +commit c89aa2f1851b08c3efa8a1070c0a6b9a36e1227f +Author: Michael R. Hines +Date: Sun Aug 18 22:27:08 2013 -0400 + + rdma: silly ipv6 bugfix + + My bad - but it's very important for us to warn the user that + IPv6 is broken on RoCE in linux right now, until linux releases + a fixed version. + + Signed-off-by: Michael R. Hines + Signed-off-by: Michael Tokarev +--- + migration-rdma.c | 8 +++++--- + 1 files changed, 5 insertions(+), 3 deletions(-) + +Signed-off-by: Michal Novotny +--- + migration-rdma.c | 8 +++++--- + 1 file changed, 5 insertions(+), 3 deletions(-) + +diff --git a/migration-rdma.c b/migration-rdma.c +index ada488e..943496f 100644 +--- a/migration-rdma.c ++++ b/migration-rdma.c +@@ -920,9 +920,11 @@ static int qemu_rdma_resolve_host(RDMAContext *rdma, Error **errp) + ret = rdma_resolve_addr(rdma->cm_id, NULL, e->ai_dst_addr, + RDMA_RESOLVE_TIMEOUT_MS); + if (!ret) { +- ret = qemu_rdma_broken_ipv6_kernel(errp, rdma->cm_id->verbs); +- if (ret) { +- continue; ++ if (e->ai_family == AF_INET6) { ++ ret = qemu_rdma_broken_ipv6_kernel(errp, rdma->cm_id->verbs); ++ if (ret) { ++ continue; ++ } + } + goto route; + } +-- +1.7.11.7 + diff --git a/SOURCES/kvm-rdma-update-documentation-to-reflect-new-unpin-suppo.patch b/SOURCES/kvm-rdma-update-documentation-to-reflect-new-unpin-suppo.patch new file mode 100644 index 0000000..740f6b9 --- /dev/null +++ b/SOURCES/kvm-rdma-update-documentation-to-reflect-new-unpin-suppo.patch @@ -0,0 +1,160 @@ +From bd86e4e5fd283179e97ef07354d822afbf21b7dd Mon Sep 17 00:00:00 2001 +Message-Id: +In-Reply-To: +References: +From: Nigel Croxon +Date: Thu, 14 Nov 2013 22:52:48 +0100 +Subject: [PATCH 12/46] rdma: update documentation to reflect new unpin + support + +RH-Author: Nigel Croxon +Message-id: <1384469598-13137-13-git-send-email-ncroxon@redhat.com> +Patchwork-id: 55702 +O-Subject: [RHEL7.0 PATCH 12/42] rdma: update documentation to reflect new unpin support +Bugzilla: 1011720 +RH-Acked-by: Orit Wasserman +RH-Acked-by: Amit Shah +RH-Acked-by: Paolo Bonzini + +Bugzilla: 1011720 +https://bugzilla.redhat.com/show_bug.cgi?id=1011720 + +>From commit ID: +commit a5f56b906e0d7975b87dc3d3c5bfe5a75a4028d2 +Author: Michael R. Hines +Date: Mon Jul 22 10:01:51 2013 -0400 + + rdma: update documentation to reflect new unpin support + + As requested, the protocol now includes memory unpinning support. + This has been implemented in a non-optimized manner, in such a way + that one could devise an LRU or other workload-specific information + on top of the basic mechanism to influence the way unpinning happens + during runtime. + + The feature is not yet user-facing, and is thus can only be enabled + at compile-time. + + Reviewed-by: Eric Blake + Signed-off-by: Michael R. Hines + Signed-off-by: Juan Quintela +--- + docs/rdma.txt | 51 ++++++++++++++++++++++++++++++--------------------- + 1 files changed, 30 insertions(+), 21 deletions(-) + +Signed-off-by: Michal Novotny +--- + docs/rdma.txt | 51 ++++++++++++++++++++++++++++++--------------------- + 1 file changed, 30 insertions(+), 21 deletions(-) + +diff --git a/docs/rdma.txt b/docs/rdma.txt +index 45a4b1d..45d1c8a 100644 +--- a/docs/rdma.txt ++++ b/docs/rdma.txt +@@ -35,7 +35,7 @@ memory tracked during each live migration iteration round cannot keep pace + with the rate of dirty memory produced by the workload. + + RDMA currently comes in two flavors: both Ethernet based (RoCE, or RDMA +-over Convered Ethernet) as well as Infiniband-based. This implementation of ++over Converged Ethernet) as well as Infiniband-based. This implementation of + migration using RDMA is capable of using both technologies because of + the use of the OpenFabrics OFED software stack that abstracts out the + programming model irrespective of the underlying hardware. +@@ -188,9 +188,9 @@ header portion and a data portion (but together are transmitted + as a single SEND message). + + Header: +- * Length (of the data portion, uint32, network byte order) +- * Type (what command to perform, uint32, network byte order) +- * Repeat (Number of commands in data portion, same type only) ++ * Length (of the data portion, uint32, network byte order) ++ * Type (what command to perform, uint32, network byte order) ++ * Repeat (Number of commands in data portion, same type only) + + The 'Repeat' field is here to support future multiple page registrations + in a single message without any need to change the protocol itself +@@ -202,17 +202,19 @@ The maximum number of repeats is hard-coded to 4096. This is a conservative + limit based on the maximum size of a SEND message along with emperical + observations on the maximum future benefit of simultaneous page registrations. + +-The 'type' field has 10 different command values: +- 1. Unused +- 2. Error (sent to the source during bad things) +- 3. Ready (control-channel is available) +- 4. QEMU File (for sending non-live device state) +- 5. RAM Blocks request (used right after connection setup) +- 6. RAM Blocks result (used right after connection setup) +- 7. Compress page (zap zero page and skip registration) +- 8. Register request (dynamic chunk registration) +- 9. Register result ('rkey' to be used by sender) +- 10. Register finished (registration for current iteration finished) ++The 'type' field has 12 different command values: ++ 1. Unused ++ 2. Error (sent to the source during bad things) ++ 3. Ready (control-channel is available) ++ 4. QEMU File (for sending non-live device state) ++ 5. RAM Blocks request (used right after connection setup) ++ 6. RAM Blocks result (used right after connection setup) ++ 7. Compress page (zap zero page and skip registration) ++ 8. Register request (dynamic chunk registration) ++ 9. Register result ('rkey' to be used by sender) ++ 10. Register finished (registration for current iteration finished) ++ 11. Unregister request (unpin previously registered memory) ++ 12. Unregister finished (confirmation that unpin completed) + + A single control message, as hinted above, can contain within the data + portion an array of many commands of the same type. If there is more than +@@ -243,7 +245,7 @@ qemu_rdma_exchange_send(header, data, optional response header & data): + from the receiver to tell us that the receiver + is *ready* for us to transmit some new bytes. + 2. Optionally: if we are expecting a response from the command +- (that we have no yet transmitted), let's post an RQ ++ (that we have not yet transmitted), let's post an RQ + work request to receive that data a few moments later. + 3. When the READY arrives, librdmacm will + unblock us and we immediately post a RQ work request +@@ -293,8 +295,10 @@ librdmacm provides the user with a 'private data' area to be exchanged + at connection-setup time before any infiniband traffic is generated. + + Header: +- * Version (protocol version validated before send/recv occurs), uint32, network byte order +- * Flags (bitwise OR of each capability), uint32, network byte order ++ * Version (protocol version validated before send/recv occurs), ++ uint32, network byte order ++ * Flags (bitwise OR of each capability), ++ uint32, network byte order + + There is no data portion of this header right now, so there is + no length field. The maximum size of the 'private data' section +@@ -313,7 +317,7 @@ If the version is invalid, we throw an error. + If the version is new, we only negotiate the capabilities that the + requested version is able to perform and ignore the rest. + +-Currently there is only *one* capability in Version #1: dynamic page registration ++Currently there is only one capability in Version #1: dynamic page registration + + Finally: Negotiation happens with the Flags field: If the primary-VM + sets a flag, but the destination does not support this capability, it +@@ -326,8 +330,8 @@ QEMUFileRDMA Interface: + + QEMUFileRDMA introduces a couple of new functions: + +-1. qemu_rdma_get_buffer() (QEMUFileOps rdma_read_ops) +-2. qemu_rdma_put_buffer() (QEMUFileOps rdma_write_ops) ++1. qemu_rdma_get_buffer() (QEMUFileOps rdma_read_ops) ++2. qemu_rdma_put_buffer() (QEMUFileOps rdma_write_ops) + + These two functions are very short and simply use the protocol + describe above to deliver bytes without changing the upper-level +@@ -413,3 +417,8 @@ TODO: + the use of KSM and ballooning while using RDMA. + 4. Also, some form of balloon-device usage tracking would also + help alleviate some issues. ++5. Move UNREGISTER requests to a separate thread. ++6. Use LRU to provide more fine-grained direction of UNREGISTER ++ requests for unpinning memory in an overcommitted environment. ++7. Expose UNREGISTER support to the user by way of workload-specific ++ hints about application behavior. +-- +1.7.11.7 + diff --git a/SOURCES/kvm-rdma-use-DRMA_WRID_READY.patch b/SOURCES/kvm-rdma-use-DRMA_WRID_READY.patch new file mode 100644 index 0000000..0157dfd --- /dev/null +++ b/SOURCES/kvm-rdma-use-DRMA_WRID_READY.patch @@ -0,0 +1,66 @@ +From 4eebbdd32a06ffc62947151257883db34294b598 Mon Sep 17 00:00:00 2001 +Message-Id: <4eebbdd32a06ffc62947151257883db34294b598.1387382496.git.minovotn@redhat.com> +In-Reply-To: +References: +From: Nigel Croxon +Date: Thu, 14 Nov 2013 22:53:01 +0100 +Subject: [PATCH 25/46] rdma: use DRMA_WRID_READY + +RH-Author: Nigel Croxon +Message-id: <1384469598-13137-26-git-send-email-ncroxon@redhat.com> +Patchwork-id: 55711 +O-Subject: [RHEL7.0 PATCH 25/42] rdma: use DRMA_WRID_READY +Bugzilla: 1011720 +RH-Acked-by: Orit Wasserman +RH-Acked-by: Amit Shah +RH-Acked-by: Paolo Bonzini + +Bugzilla: 1011720 +https://bugzilla.redhat.com/show_bug.cgi?id=1011720 + +>From commit ID: +commit 877726397f7e24d0c8a2b303a852769b5edd155c +Author: Isaku Yamahata +Date: Sat Aug 3 22:54:53 2013 -0400 + + rdma: use RDMA_WRID_READY + + Reviewed-by: Michael R. Hines + Signed-off-by: Isaku Yamahata + Signed-off-by: Michael R. Hines + Message-id: 1375584894-9917-7-git-send-email-mrhines@linux.vnet.ibm.com + Signed-off-by: Anthony Liguori +--- + migration-rdma.c | 4 ++-- + 1 files changed, 2 insertions(+), 2 deletions(-) + +Signed-off-by: Michal Novotny +--- + migration-rdma.c | 4 ++-- + 1 file changed, 2 insertions(+), 2 deletions(-) + +diff --git a/migration-rdma.c b/migration-rdma.c +index ea16f0e..6afe98c 100644 +--- a/migration-rdma.c ++++ b/migration-rdma.c +@@ -2223,7 +2223,7 @@ static int qemu_rdma_connect(RDMAContext *rdma, Error **errp) + + rdma_ack_cm_event(cm_event); + +- ret = qemu_rdma_post_recv_control(rdma, 0); ++ ret = qemu_rdma_post_recv_control(rdma, RDMA_WRID_READY); + if (ret) { + ERROR(errp, "posting second control recv!"); + goto err_rdma_source_connect; +@@ -2735,7 +2735,7 @@ static int qemu_rdma_accept(RDMAContext *rdma) + + rdma_ack_cm_event(cm_event); + +- ret = qemu_rdma_post_recv_control(rdma, 0); ++ ret = qemu_rdma_post_recv_control(rdma, RDMA_WRID_READY); + if (ret) { + fprintf(stderr, "rdma migration: error posting second control recv!\n"); + goto err_rdma_dest_wait; +-- +1.7.11.7 + diff --git a/SOURCES/kvm-rdma-use-resp.len-after-validation-in-qemu_rdma_regi.patch b/SOURCES/kvm-rdma-use-resp.len-after-validation-in-qemu_rdma_regi.patch new file mode 100644 index 0000000..3161a6b --- /dev/null +++ b/SOURCES/kvm-rdma-use-resp.len-after-validation-in-qemu_rdma_regi.patch @@ -0,0 +1,75 @@ +From a2aad899158f118fd8ab16531385b9fc2b48ba14 Mon Sep 17 00:00:00 2001 +Message-Id: +In-Reply-To: +References: +From: Nigel Croxon +Date: Thu, 14 Nov 2013 22:53:03 +0100 +Subject: [PATCH 27/46] rdma: use resp.len after validation in + qemu_rdma_registration_stop + +RH-Author: Nigel Croxon +Message-id: <1384469598-13137-28-git-send-email-ncroxon@redhat.com> +Patchwork-id: 55716 +O-Subject: [RHEL7.0 PATCH 27/42] rdma: use resp.len after validation in qemu_rdma_registration_stop +Bugzilla: 1011720 +RH-Acked-by: Orit Wasserman +RH-Acked-by: Amit Shah +RH-Acked-by: Paolo Bonzini + +Bugzilla: 1011720 +https://bugzilla.redhat.com/show_bug.cgi?id=1011720 + +>From commit ID: +commit 885e8f984ea846e79a39ddc4f066f4dd3d04b264 +Author: Isaku Yamahata +Date: Fri Aug 9 16:05:40 2013 -0400 + + rdma: use resp.len after validation in qemu_rdma_registration_stop + + resp.len is given from remote host. So should be validated before use. + Otherwise memcpy can access beyond the buffer. + + Cc: Michael R. Hines + Reviewed-by: Orit Wasserman + Reviewed-by: Michael R. Hines + Signed-off-by: Isaku Yamahata + Signed-off-by: Michael R. Hines + Message-id: 1376078746-24948-2-git-send-email-mrhines@linux.vnet.ibm.com + Signed-off-by: Anthony Liguori +--- + migration-rdma.c | 7 +++---- + 1 files changed, 3 insertions(+), 4 deletions(-) + +Signed-off-by: Michal Novotny +--- + migration-rdma.c | 7 +++---- + 1 file changed, 3 insertions(+), 4 deletions(-) + +diff --git a/migration-rdma.c b/migration-rdma.c +index ff0a823..1412cde 100644 +--- a/migration-rdma.c ++++ b/migration-rdma.c +@@ -3045,10 +3045,6 @@ static int qemu_rdma_registration_stop(QEMUFile *f, void *opaque, + return ret; + } + +- qemu_rdma_move_header(rdma, reg_result_idx, &resp); +- memcpy(rdma->block, +- rdma->wr_data[reg_result_idx].control_curr, resp.len); +- + nb_remote_blocks = resp.len / sizeof(RDMARemoteBlock); + + /* +@@ -3070,6 +3066,9 @@ static int qemu_rdma_registration_stop(QEMUFile *f, void *opaque, + return -EINVAL; + } + ++ qemu_rdma_move_header(rdma, reg_result_idx, &resp); ++ memcpy(rdma->block, ++ rdma->wr_data[reg_result_idx].control_curr, resp.len); + for (i = 0; i < nb_remote_blocks; i++) { + network_to_remote_block(&rdma->block[i]); + +-- +1.7.11.7 + diff --git a/SOURCES/kvm-rdma-validate-RDMAControlHeader-len.patch b/SOURCES/kvm-rdma-validate-RDMAControlHeader-len.patch new file mode 100644 index 0000000..0e14bd7 --- /dev/null +++ b/SOURCES/kvm-rdma-validate-RDMAControlHeader-len.patch @@ -0,0 +1,70 @@ +From 036dba4d4b9a82507dafba8a365bf6e6bbf5b6e8 Mon Sep 17 00:00:00 2001 +Message-Id: <036dba4d4b9a82507dafba8a365bf6e6bbf5b6e8.1387382496.git.minovotn@redhat.com> +In-Reply-To: +References: +From: Nigel Croxon +Date: Thu, 14 Nov 2013 22:53:04 +0100 +Subject: [PATCH 28/46] rdma: validate RDMAControlHeader::len + +RH-Author: Nigel Croxon +Message-id: <1384469598-13137-29-git-send-email-ncroxon@redhat.com> +Patchwork-id: 55709 +O-Subject: [RHEL7.0 PATCH 28/42] rdma: validate RDMAControlHeader::len +Bugzilla: 1011720 +RH-Acked-by: Orit Wasserman +RH-Acked-by: Amit Shah +RH-Acked-by: Paolo Bonzini + +Bugzilla: 1011720 +https://bugzilla.redhat.com/show_bug.cgi?id=1011720 + +>From commit ID: +commit 6f1484edadba57f2800dc04ae3527ee4b6dac7ef +Author: Isaku Yamahata +Date: Fri Aug 9 16:05:41 2013 -0400 + + rdma: validate RDMAControlHeader::len + + RMDAControlHeader::len is provided from remote, so validate it. + + Reviewed-by: Orit Wasserman + Reviewed-by: Michael R. Hines + Signed-off-by: Isaku Yamahata + Signed-off-by: Michael R. Hines + Message-id: 1376078746-24948-3-git-send-email-mrhines@linux.vnet.ibm.com + Signed-off-by: Anthony Liguori +--- + migration-rdma.c | 5 +++++ + 1 files changed, 5 insertions(+), 0 deletions(-) + +Signed-off-by: Michal Novotny +--- + migration-rdma.c | 5 +++++ + 1 file changed, 5 insertions(+) + +diff --git a/migration-rdma.c b/migration-rdma.c +index 1412cde..140d930 100644 +--- a/migration-rdma.c ++++ b/migration-rdma.c +@@ -1424,6 +1424,7 @@ static int qemu_rdma_post_send_control(RDMAContext *rdma, uint8_t *buf, + * The copy makes the RDMAControlHeader simpler to manipulate + * for the time being. + */ ++ assert(head->len <= RDMA_CONTROL_MAX_BUFFER - sizeof(*head)); + memcpy(wr->control, head, sizeof(RDMAControlHeader)); + control_to_network((void *) wr->control); + +@@ -1504,6 +1505,10 @@ static int qemu_rdma_exchange_get_response(RDMAContext *rdma, + control_desc[head->type], head->type, head->len); + return -EIO; + } ++ if (head->len > RDMA_CONTROL_MAX_BUFFER - sizeof(*head)) { ++ fprintf(stderr, "too long length: %d\n", head->len); ++ return -EINVAL; ++ } + + return 0; + } +-- +1.7.11.7 + diff --git a/SOURCES/kvm-refactor-start-address-calculation.patch b/SOURCES/kvm-refactor-start-address-calculation.patch new file mode 100644 index 0000000..6b3b57a --- /dev/null +++ b/SOURCES/kvm-refactor-start-address-calculation.patch @@ -0,0 +1,56 @@ +From f792ee6d096426909f440421758e908460c18f77 Mon Sep 17 00:00:00 2001 +From: Juan Quintela +Date: Tue, 14 Jan 2014 15:07:47 +0100 +Subject: [PATCH 36/40] kvm: refactor start address calculation + +RH-Author: Juan Quintela +Message-id: <1389712071-23303-37-git-send-email-quintela@redhat.com> +Patchwork-id: 56691 +O-Subject: [RHEL7 qemu-kvm PATCH 36/40] kvm: refactor start address calculation +Bugzilla: 997559 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Orit Wasserman +RH-Acked-by: Dr. David Alan Gilbert (git) + +Signed-off-by: Juan Quintela +Reviewed-by: Orit Wasserman +(cherry picked from commit c9dd46fc0d64d9f314aa3c220d4aff9d01ab778e) +Signed-off-by: Juan Quintela +--- + kvm-all.c | 8 ++++---- + 1 file changed, 4 insertions(+), 4 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + kvm-all.c | 8 ++++---- + 1 files changed, 4 insertions(+), 4 deletions(-) + +diff --git a/kvm-all.c b/kvm-all.c +index 8e2bd34..d3aa869 100644 +--- a/kvm-all.c ++++ b/kvm-all.c +@@ -367,7 +367,8 @@ static int kvm_get_dirty_pages_log_range(MemoryRegionSection *section, + { + unsigned int i, j; + unsigned long page_number, c; +- hwaddr addr, addr1; ++ hwaddr addr; ++ ram_addr_t start = section->offset_within_region + section->mr->ram_addr; + ram_addr_t ram_addr; + unsigned int len = ((section->size / getpagesize()) + HOST_LONG_BITS - 1) / HOST_LONG_BITS; + unsigned long hpratio = getpagesize() / TARGET_PAGE_SIZE; +@@ -383,9 +384,8 @@ static int kvm_get_dirty_pages_log_range(MemoryRegionSection *section, + j = ffsl(c) - 1; + c &= ~(1ul << j); + page_number = (i * HOST_LONG_BITS + j) * hpratio; +- addr1 = page_number * TARGET_PAGE_SIZE; +- addr = section->offset_within_region + addr1; +- ram_addr = section->mr->ram_addr + addr; ++ addr = page_number * TARGET_PAGE_SIZE; ++ ram_addr = start + addr; + cpu_physical_memory_set_dirty_range(ram_addr, + TARGET_PAGE_SIZE * hpratio); + } while (c != 0); +-- +1.7.1 + diff --git a/SOURCES/kvm-refer-to-FWCfgState-explicitly.patch b/SOURCES/kvm-refer-to-FWCfgState-explicitly.patch new file mode 100644 index 0000000..c1f491c --- /dev/null +++ b/SOURCES/kvm-refer-to-FWCfgState-explicitly.patch @@ -0,0 +1,268 @@ +From 9698fead0e127336b0483ec2289affb308d7f505 Mon Sep 17 00:00:00 2001 +Message-Id: <9698fead0e127336b0483ec2289affb308d7f505.1387298827.git.minovotn@redhat.com> +In-Reply-To: <3ed0fb61a3dc912ef036d7ef450bed192090709e.1387298827.git.minovotn@redhat.com> +References: <3ed0fb61a3dc912ef036d7ef450bed192090709e.1387298827.git.minovotn@redhat.com> +From: "Michael S. Tsirkin" +Date: Tue, 17 Dec 2013 15:17:11 +0100 +Subject: [PATCH 09/56] refer to FWCfgState explicitly + +RH-Author: Michael S. Tsirkin +Message-id: <1387293161-4085-10-git-send-email-mst@redhat.com> +Patchwork-id: 56314 +O-Subject: [PATCH qemu-kvm RHEL7.0 v2 09/57] refer to FWCfgState explicitly +Bugzilla: 1034876 +RH-Acked-by: Igor Mammedov +RH-Acked-by: Marcel Apfelbaum +RH-Acked-by: Laszlo Ersek + +From: Laszlo Ersek + +Currently some places use pointer-to-void even though they mean +pointer-to-FWCfgState. Clean them up. + +Signed-off-by: Laszlo Ersek +Reviewed-by: Anthony Liguori +Signed-off-by: Michael S. Tsirkin +(cherry picked from commit a88b362c6ffbb7a802bf0ed5ef0e2447164dc989) +--- + hw/i386/multiboot.h | 4 +++- + include/hw/i386/pc.h | 19 ++++++++++--------- + include/hw/loader.h | 3 ++- + hw/acpi/piix4.c | 2 +- + hw/core/loader.c | 2 +- + hw/i386/multiboot.c | 2 +- + hw/i386/pc.c | 24 ++++++++++++------------ + hw/i386/pc_piix.c | 2 +- + hw/sparc/sun4m.c | 2 +- + hw/sparc64/sun4u.c | 2 +- + 10 files changed, 33 insertions(+), 29 deletions(-) + +Signed-off-by: Michal Novotny +--- + hw/acpi/piix4.c | 2 +- + hw/core/loader.c | 2 +- + hw/i386/multiboot.c | 2 +- + hw/i386/multiboot.h | 4 +++- + hw/i386/pc.c | 24 ++++++++++++------------ + hw/i386/pc_piix.c | 2 +- + hw/sparc/sun4m.c | 2 +- + hw/sparc64/sun4u.c | 2 +- + include/hw/i386/pc.h | 19 ++++++++++--------- + include/hw/loader.h | 3 ++- + 10 files changed, 33 insertions(+), 29 deletions(-) + +diff --git a/hw/acpi/piix4.c b/hw/acpi/piix4.c +index 8af97cf..6882937 100644 +--- a/hw/acpi/piix4.c ++++ b/hw/acpi/piix4.c +@@ -447,7 +447,7 @@ static int piix4_pm_initfn(PCIDevice *dev) + + i2c_bus *piix4_pm_init(PCIBus *bus, int devfn, uint32_t smb_io_base, + qemu_irq sci_irq, qemu_irq smi_irq, +- int kvm_enabled, void *fw_cfg) ++ int kvm_enabled, FWCfgState *fw_cfg) + { + PCIDevice *dev; + PIIX4PMState *s; +diff --git a/hw/core/loader.c b/hw/core/loader.c +index 8514eaf..7d61537 100644 +--- a/hw/core/loader.c ++++ b/hw/core/loader.c +@@ -733,7 +733,7 @@ int rom_load_all(void) + return 0; + } + +-void rom_set_fw(void *f) ++void rom_set_fw(FWCfgState *f) + { + fw_cfg = f; + } +diff --git a/hw/i386/multiboot.c b/hw/i386/multiboot.c +index d696507..09211e0 100644 +--- a/hw/i386/multiboot.c ++++ b/hw/i386/multiboot.c +@@ -124,7 +124,7 @@ static void mb_add_mod(MultibootState *s, + s->mb_mods_count++; + } + +-int load_multiboot(void *fw_cfg, ++int load_multiboot(FWCfgState *fw_cfg, + FILE *f, + const char *kernel_filename, + const char *initrd_filename, +diff --git a/hw/i386/multiboot.h b/hw/i386/multiboot.h +index 98fb1b7..60de309 100644 +--- a/hw/i386/multiboot.h ++++ b/hw/i386/multiboot.h +@@ -1,7 +1,9 @@ + #ifndef QEMU_MULTIBOOT_H + #define QEMU_MULTIBOOT_H + +-int load_multiboot(void *fw_cfg, ++#include "hw/nvram/fw_cfg.h" ++ ++int load_multiboot(FWCfgState *fw_cfg, + FILE *f, + const char *kernel_filename, + const char *initrd_filename, +diff --git a/hw/i386/pc.c b/hw/i386/pc.c +index 333e83f..2948781 100644 +--- a/hw/i386/pc.c ++++ b/hw/i386/pc.c +@@ -598,9 +598,9 @@ static unsigned int pc_apic_id_limit(unsigned int max_cpus) + return x86_cpu_apic_id_from_index(max_cpus - 1) + 1; + } + +-static void *bochs_bios_init(void) ++static FWCfgState *bochs_bios_init(void) + { +- void *fw_cfg; ++ FWCfgState *fw_cfg; + uint8_t *smbios_table; + size_t smbios_len; + uint64_t *numa_fw_cfg; +@@ -677,7 +677,7 @@ static long get_file_size(FILE *f) + return size; + } + +-static void load_linux(void *fw_cfg, ++static void load_linux(FWCfgState *fw_cfg, + const char *kernel_filename, + const char *initrd_filename, + const char *kernel_cmdline, +@@ -1019,19 +1019,19 @@ void pc_acpi_init(const char *default_dsdt) + } + } + +-void *pc_memory_init(MemoryRegion *system_memory, +- const char *kernel_filename, +- const char *kernel_cmdline, +- const char *initrd_filename, +- ram_addr_t below_4g_mem_size, +- ram_addr_t above_4g_mem_size, +- MemoryRegion *rom_memory, +- MemoryRegion **ram_memory) ++FWCfgState *pc_memory_init(MemoryRegion *system_memory, ++ const char *kernel_filename, ++ const char *kernel_cmdline, ++ const char *initrd_filename, ++ ram_addr_t below_4g_mem_size, ++ ram_addr_t above_4g_mem_size, ++ MemoryRegion *rom_memory, ++ MemoryRegion **ram_memory) + { + int linux_boot, i; + MemoryRegion *ram, *option_rom_mr; + MemoryRegion *ram_below_4g, *ram_above_4g; +- void *fw_cfg; ++ FWCfgState *fw_cfg; + + linux_boot = (kernel_filename != NULL); + +diff --git a/hw/i386/pc_piix.c b/hw/i386/pc_piix.c +index 8c3f2d6..b6f9288 100644 +--- a/hw/i386/pc_piix.c ++++ b/hw/i386/pc_piix.c +@@ -85,7 +85,7 @@ static void pc_init1(QEMUMachineInitArgs *args, + MemoryRegion *pci_memory; + MemoryRegion *rom_memory; + DeviceState *icc_bridge; +- void *fw_cfg = NULL; ++ FWCfgState *fw_cfg = NULL; + + icc_bridge = qdev_create(NULL, TYPE_ICC_BRIDGE); + object_property_add_child(qdev_get_machine(), "icc-bridge", +diff --git a/hw/sparc/sun4m.c b/hw/sparc/sun4m.c +index 635115f..7c5b8e7 100644 +--- a/hw/sparc/sun4m.c ++++ b/hw/sparc/sun4m.c +@@ -873,7 +873,7 @@ static void sun4m_hw_init(const struct sun4m_hwdef *hwdef, ram_addr_t RAM_size, + qemu_irq *cpu_halt; + unsigned long kernel_size; + DriveInfo *fd[MAX_FD]; +- void *fw_cfg; ++ FWCfgState *fw_cfg; + unsigned int num_vsimms; + + /* init CPUs */ +diff --git a/hw/sparc64/sun4u.c b/hw/sparc64/sun4u.c +index 5c2bbd4..5ce5ed6 100644 +--- a/hw/sparc64/sun4u.c ++++ b/hw/sparc64/sun4u.c +@@ -818,7 +818,7 @@ static void sun4uv_init(MemoryRegion *address_space_mem, + qemu_irq *ivec_irqs, *pbm_irqs; + DriveInfo *hd[MAX_IDE_BUS * MAX_IDE_DEVS]; + DriveInfo *fd[MAX_FD]; +- void *fw_cfg; ++ FWCfgState *fw_cfg; + + /* init CPUs */ + cpu = cpu_devinit(cpu_model, hwdef); +diff --git a/include/hw/i386/pc.h b/include/hw/i386/pc.h +index 72f6882..4175c1b 100644 +--- a/include/hw/i386/pc.h ++++ b/include/hw/i386/pc.h +@@ -9,6 +9,7 @@ + #include "net/net.h" + #include "exec/memory.h" + #include "hw/i386/ioapic.h" ++#include "hw/nvram/fw_cfg.h" + + /* PC-style peripherals (also used by other machines). */ + +@@ -84,14 +85,14 @@ void pc_acpi_smi_interrupt(void *opaque, int irq, int level); + void pc_cpus_init(const char *cpu_model, DeviceState *icc_bridge); + void pc_hot_add_cpu(const int64_t id, Error **errp); + void pc_acpi_init(const char *default_dsdt); +-void *pc_memory_init(MemoryRegion *system_memory, +- const char *kernel_filename, +- const char *kernel_cmdline, +- const char *initrd_filename, +- ram_addr_t below_4g_mem_size, +- ram_addr_t above_4g_mem_size, +- MemoryRegion *rom_memory, +- MemoryRegion **ram_memory); ++FWCfgState *pc_memory_init(MemoryRegion *system_memory, ++ const char *kernel_filename, ++ const char *kernel_cmdline, ++ const char *initrd_filename, ++ ram_addr_t below_4g_mem_size, ++ ram_addr_t above_4g_mem_size, ++ MemoryRegion *rom_memory, ++ MemoryRegion **ram_memory); + qemu_irq *pc_allocate_cpu_irq(void); + DeviceState *pc_vga_init(ISABus *isa_bus, PCIBus *pci_bus); + void pc_basic_device_init(ISABus *isa_bus, qemu_irq *gsi, +@@ -115,7 +116,7 @@ void ioapic_init_gsi(GSIState *gsi_state, const char *parent_name); + + i2c_bus *piix4_pm_init(PCIBus *bus, int devfn, uint32_t smb_io_base, + qemu_irq sci_irq, qemu_irq smi_irq, +- int kvm_enabled, void *fw_cfg); ++ int kvm_enabled, FWCfgState *fw_cfg); + void piix4_smbus_register_device(SMBusDevice *dev, uint8_t addr); + + /* hpet.c */ +diff --git a/include/hw/loader.h b/include/hw/loader.h +index 0958f06..15d4cc9 100644 +--- a/include/hw/loader.h ++++ b/include/hw/loader.h +@@ -1,6 +1,7 @@ + #ifndef LOADER_H + #define LOADER_H + #include "qapi/qmp/qdict.h" ++#include "hw/nvram/fw_cfg.h" + + /* loader.c */ + int get_image_size(const char *filename); +@@ -30,7 +31,7 @@ int rom_add_blob(const char *name, const void *blob, size_t len, + int rom_add_elf_program(const char *name, void *data, size_t datasize, + size_t romsize, hwaddr addr); + int rom_load_all(void); +-void rom_set_fw(void *f); ++void rom_set_fw(FWCfgState *f); + int rom_copy(uint8_t *dest, hwaddr addr, size_t size); + void *rom_ptr(hwaddr addr); + void do_info_roms(Monitor *mon, const QDict *qdict); +-- +1.7.11.7 + diff --git a/SOURCES/kvm-rng-egd-offset-the-point-when-repeatedly-read-from-t.patch b/SOURCES/kvm-rng-egd-offset-the-point-when-repeatedly-read-from-t.patch new file mode 100644 index 0000000..5145d23 --- /dev/null +++ b/SOURCES/kvm-rng-egd-offset-the-point-when-repeatedly-read-from-t.patch @@ -0,0 +1,60 @@ +From 5b3829247a3edf89ebc63e8c2be2554fd66dfd41 Mon Sep 17 00:00:00 2001 +From: Amos Kong +Date: Sat, 23 Nov 2013 03:48:48 +0100 +Subject: [PATCH 13/14] rng-egd: offset the point when repeatedly read from the buffer + +RH-Author: Amos Kong +Message-id: <1385178528-7953-1-git-send-email-akong@redhat.com> +Patchwork-id: 55868 +O-Subject: [RHEL-7.0 qemu-kvm PATCH] rng-egd: offset the point when repeatedly read from the buffer +Bugzilla: 1032862 +RH-Acked-by: Fam Zheng +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Vlad Yasevich +RH-Acked-by: Amit Shah +RH-Acked-by: Xiao Wang + +Bugzilla: 1032862 +Brew: http://brewweb.devel.redhat.com/brew/taskinfo?taskID=6634396 + +The buffer content might be read out more than once, currently +we just repeatedly read the first data block, buffer offset is +missing. + +Cc: qemu-stable@nongnu.org +Signed-off-by: Amos Kong +Message-id: 1385023371-8198-3-git-send-email-akong@redhat.com +Signed-off-by: Anthony Liguori +(cherry picked from commit 1eb1bd9eafa890f1f4d16ef5cb8b9239a86874d9) +--- + backends/rng-egd.c | 4 +++- + 1 files changed, 3 insertions(+), 1 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + backends/rng-egd.c | 4 +++- + 1 files changed, 3 insertions(+), 1 deletions(-) + +diff --git a/backends/rng-egd.c b/backends/rng-egd.c +index 9e5a536..2962795 100644 +--- a/backends/rng-egd.c ++++ b/backends/rng-egd.c +@@ -91,12 +91,14 @@ static int rng_egd_chr_can_read(void *opaque) + static void rng_egd_chr_read(void *opaque, const uint8_t *buf, int size) + { + RngEgd *s = RNG_EGD(opaque); ++ size_t buf_offset = 0; + + while (size > 0 && s->requests) { + RngRequest *req = s->requests->data; + int len = MIN(size, req->size - req->offset); + +- memcpy(req->data + req->offset, buf, len); ++ memcpy(req->data + req->offset, buf + buf_offset, len); ++ buf_offset += len; + req->offset += len; + size -= len; + +-- +1.7.1 + diff --git a/SOURCES/kvm-savevm-Fix-potential-memory-leak.patch b/SOURCES/kvm-savevm-Fix-potential-memory-leak.patch new file mode 100644 index 0000000..68773f6 --- /dev/null +++ b/SOURCES/kvm-savevm-Fix-potential-memory-leak.patch @@ -0,0 +1,65 @@ +From 59e3d6e0995b2db39e4d87436c600e2475a9b502 Mon Sep 17 00:00:00 2001 +Message-Id: <59e3d6e0995b2db39e4d87436c600e2475a9b502.1387382496.git.minovotn@redhat.com> +In-Reply-To: +References: +From: Nigel Croxon +Date: Thu, 14 Nov 2013 22:52:38 +0100 +Subject: [PATCH 02/46] savevm: Fix potential memory leak + +RH-Author: Nigel Croxon +Message-id: <1384469598-13137-3-git-send-email-ncroxon@redhat.com> +Patchwork-id: 55690 +O-Subject: [RHEL7.0 PATCH 02/42] savevm: Fix potential memory leak +Bugzilla: 1011720 +RH-Acked-by: Orit Wasserman +RH-Acked-by: Amit Shah +RH-Acked-by: Paolo Bonzini + +Bugzilla: 1011720 +https://bugzilla.redhat.com/show_bug.cgi?id=1011720 + +>From commit ID: +commit 4f080057767a684aab60998659e18f98c5fbefc7 +Author: Stefan Weil +Date: Sun Jun 16 13:33:05 2013 +0200 + + savevm: Fix potential memory leak + + The leak was reported by cppcheck. Fix it by moving the g_malloc0 after + the argument validity check. + + Signed-off-by: Stefan Weil + Signed-off-by: Michael Tokarev +--- + savevm.c | 3 ++- + 1 files changed, 2 insertions(+), 1 deletions(-) + +Signed-off-by: Michal Novotny +--- + savevm.c | 3 ++- + 1 file changed, 2 insertions(+), 1 deletion(-) + +diff --git a/savevm.c b/savevm.c +index 4d12d92..4d898af 100644 +--- a/savevm.c ++++ b/savevm.c +@@ -479,7 +479,7 @@ static const QEMUFileOps socket_write_ops = { + + QEMUFile *qemu_fopen_socket(int fd, const char *mode) + { +- QEMUFileSocket *s = g_malloc0(sizeof(QEMUFileSocket)); ++ QEMUFileSocket *s; + + if (mode == NULL || + (mode[0] != 'r' && mode[0] != 'w') || +@@ -488,6 +488,7 @@ QEMUFile *qemu_fopen_socket(int fd, const char *mode) + return NULL; + } + ++ s = g_malloc0(sizeof(QEMUFileSocket)); + s->fd = fd; + if (mode[0] == 'w') { + qemu_set_block(s->fd); +-- +1.7.11.7 + diff --git a/SOURCES/kvm-savevm-fix-wrong-initialization-by-ram_control_load_.patch b/SOURCES/kvm-savevm-fix-wrong-initialization-by-ram_control_load_.patch new file mode 100644 index 0000000..d019c6f --- /dev/null +++ b/SOURCES/kvm-savevm-fix-wrong-initialization-by-ram_control_load_.patch @@ -0,0 +1,59 @@ +From 9933c07995dc978f8ea636cead7c66d78428484b Mon Sep 17 00:00:00 2001 +Message-Id: <9933c07995dc978f8ea636cead7c66d78428484b.1387382496.git.minovotn@redhat.com> +In-Reply-To: +References: +From: Nigel Croxon +Date: Thu, 14 Nov 2013 22:53:10 +0100 +Subject: [PATCH 34/46] savevm: fix wrong initialization by + ram_control_load_hook + +RH-Author: Nigel Croxon +Message-id: <1384469598-13137-35-git-send-email-ncroxon@redhat.com> +Patchwork-id: 55720 +O-Subject: [RHEL7.0 PATCH 34/42] savevm: fix wrong initialization by ram_control_load_hook +Bugzilla: 1011720 +RH-Acked-by: Orit Wasserman +RH-Acked-by: Amit Shah +RH-Acked-by: Paolo Bonzini + +Bugzilla: 1011720 +https://bugzilla.redhat.com/show_bug.cgi?id=1011720 + +>From commit ID: +commit c77a5f2daa1ccbd825d59b95c70207c0a196bb94 +Author: Lei Li +Date: Wed Sep 4 17:02:35 2013 +0800 + + savevm: fix wrong initialization by ram_control_load_hook + + It should set negative error value rather than 0 in QEMUFile + if there has been an error. + + Reviewed-by: Michael R. Hines + Signed-off-by: Lei Li + Signed-off-by: Juan Quintela +--- + savevm.c | 2 +- + 1 files changed, 1 insertions(+), 1 deletions(-) + +Signed-off-by: Michal Novotny +--- + savevm.c | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/savevm.c b/savevm.c +index 03fc4d9..a0d4e09 100644 +--- a/savevm.c ++++ b/savevm.c +@@ -642,7 +642,7 @@ void ram_control_after_iterate(QEMUFile *f, uint64_t flags) + + void ram_control_load_hook(QEMUFile *f, uint64_t flags) + { +- int ret = 0; ++ int ret = -EINVAL; + + if (f->ops->hook_ram_load) { + ret = f->ops->hook_ram_load(f, f->opaque, flags); +-- +1.7.11.7 + diff --git a/SOURCES/kvm-scripts-qapi.py-Avoid-syntax-not-supported-by-Python.patch b/SOURCES/kvm-scripts-qapi.py-Avoid-syntax-not-supported-by-Python.patch new file mode 100644 index 0000000..9c0f0ab --- /dev/null +++ b/SOURCES/kvm-scripts-qapi.py-Avoid-syntax-not-supported-by-Python.patch @@ -0,0 +1,54 @@ +From e41361867982017cdfed92f1874395da2596cb51 Mon Sep 17 00:00:00 2001 +Message-Id: +In-Reply-To: <091eecc4fa42754760dfff393dabcc2b444e9693.1387369730.git.minovotn@redhat.com> +References: <091eecc4fa42754760dfff393dabcc2b444e9693.1387369730.git.minovotn@redhat.com> +From: Markus Armbruster +Date: Tue, 10 Dec 2013 15:29:20 +0100 +Subject: [PATCH 20/21] scripts/qapi.py: Avoid syntax not supported by Python + 2.4 + +RH-Author: Markus Armbruster +Message-id: <1386689361-30281-18-git-send-email-armbru@redhat.com> +Patchwork-id: 56138 +O-Subject: [PATCH 7.0 qemu-kvm 17/18] scripts/qapi.py: Avoid syntax not supported by Python 2.4 +Bugzilla: 997915 +RH-Acked-by: Laszlo Ersek +RH-Acked-by: Kevin Wolf +RH-Acked-by: Luiz Capitulino + +From: Peter Maydell + +The Python "except Foo as x" syntax was only introduced in +Python 2.6, but we aim to support Python 2.4 and later. +Use the old-style "except Foo, x" syntax instead, thus +fixing configure/compile on systems with older Python. + +Signed-off-by: Peter Maydell +Signed-off-by: Luiz Capitulino +(cherry picked from commit 21e0043bada1a24ae2ba6cd0051e104c0cbf9634) +Signed-off-by: Markus Armbruster +--- + scripts/qapi.py | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +Signed-off-by: Michal Novotny +--- + scripts/qapi.py | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/scripts/qapi.py b/scripts/qapi.py +index 0ebea94..1069310 100644 +--- a/scripts/qapi.py ++++ b/scripts/qapi.py +@@ -161,7 +161,7 @@ class QAPISchema: + def parse_schema(fp): + try: + schema = QAPISchema(fp) +- except QAPISchemaError as e: ++ except QAPISchemaError, e: + print >>sys.stderr, e + exit(1) + +-- +1.7.11.7 + diff --git a/SOURCES/kvm-scsi-Allocate-SCSITargetReq-r-buf-dynamically-CVE-20.patch b/SOURCES/kvm-scsi-Allocate-SCSITargetReq-r-buf-dynamically-CVE-20.patch new file mode 100644 index 0000000..987f3de --- /dev/null +++ b/SOURCES/kvm-scsi-Allocate-SCSITargetReq-r-buf-dynamically-CVE-20.patch @@ -0,0 +1,166 @@ +From 3f4a2e18f357a82186ce02018e42a24b5db4154d Mon Sep 17 00:00:00 2001 +From: Asias He +Date: Fri, 11 Oct 2013 10:36:39 +0800 +Subject: [PATCH] scsi: Allocate SCSITargetReq r->buf dynamically [CVE-2013-4344] + +BZ: https://bugzilla.redhat.com/show_bug.cgi?id=1007334 +Brew: https://brewweb.devel.redhat.com/taskinfo?taskID=6402920 +RH-Author: Asias He +Message-id: <1381458999-8048-1-git-send-email-asias@redhat.com> +O-Subject: [RHEL7.0 qemu-kvm EMBARGOED PATCH v2] scsi: Allocate SCSITargetReq r->buf dynamically [CVE-2013-4344] +Bugzilla: 1007334 +RH-Acked-by: Kevin Wolf +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Stefan Hajnoczi + +r->buf is hardcoded to 2056 which is (256 + 1) * 8, allowing 256 luns at +most. If more than 256 luns are specified by user, we have buffer +overflow in scsi_target_emulate_report_luns. + +To fix, we allocate the buffer dynamically. + +Signed-off-by: Asias He +Tested-by: Michael Roth +Signed-off-by: Paolo Bonzini +(cherry picked from commit 846424350b292f16b732b573273a5c1f195cd7a3) +--- + hw/scsi/scsi-bus.c | 45 ++++++++++++++++++++++++++++++++++----------- + include/hw/scsi/scsi.h | 2 ++ + 2 files changed, 36 insertions(+), 11 deletions(-) + +diff --git a/hw/scsi/scsi-bus.c b/hw/scsi/scsi-bus.c +index 18a0399..9082ea7 100644 +--- a/hw/scsi/scsi-bus.c ++++ b/hw/scsi/scsi-bus.c +@@ -11,6 +11,8 @@ static char *scsibus_get_dev_path(DeviceState *dev); + static char *scsibus_get_fw_dev_path(DeviceState *dev); + static int scsi_req_parse(SCSICommand *cmd, SCSIDevice *dev, uint8_t *buf); + static void scsi_req_dequeue(SCSIRequest *req); ++static uint8_t *scsi_target_alloc_buf(SCSIRequest *req, size_t len); ++static void scsi_target_free_buf(SCSIRequest *req); + + static Property scsi_props[] = { + DEFINE_PROP_UINT32("channel", SCSIDevice, channel, 0), +@@ -309,7 +311,8 @@ typedef struct SCSITargetReq SCSITargetReq; + struct SCSITargetReq { + SCSIRequest req; + int len; +- uint8_t buf[2056]; ++ uint8_t *buf; ++ int buf_len; + }; + + static void store_lun(uint8_t *outbuf, int lun) +@@ -353,14 +356,12 @@ static bool scsi_target_emulate_report_luns(SCSITargetReq *r) + if (!found_lun0) { + n += 8; + } +- len = MIN(n + 8, r->req.cmd.xfer & ~7); +- if (len > sizeof(r->buf)) { +- /* TODO: > 256 LUNs? */ +- return false; +- } + ++ scsi_target_alloc_buf(&r->req, n + 8); ++ ++ len = MIN(n + 8, r->req.cmd.xfer & ~7); + memset(r->buf, 0, len); +- stl_be_p(&r->buf, n); ++ stl_be_p(&r->buf[0], n); + i = found_lun0 ? 8 : 16; + QTAILQ_FOREACH(kid, &r->req.bus->qbus.children, sibling) { + DeviceState *qdev = kid->child; +@@ -379,6 +380,9 @@ static bool scsi_target_emulate_report_luns(SCSITargetReq *r) + static bool scsi_target_emulate_inquiry(SCSITargetReq *r) + { + assert(r->req.dev->lun != r->req.lun); ++ ++ scsi_target_alloc_buf(&r->req, SCSI_INQUIRY_LEN); ++ + if (r->req.cmd.buf[1] & 0x2) { + /* Command support data - optional, not implemented */ + return false; +@@ -403,7 +407,7 @@ static bool scsi_target_emulate_inquiry(SCSITargetReq *r) + return false; + } + /* done with EVPD */ +- assert(r->len < sizeof(r->buf)); ++ assert(r->len < r->buf_len); + r->len = MIN(r->req.cmd.xfer, r->len); + return true; + } +@@ -414,7 +418,7 @@ static bool scsi_target_emulate_inquiry(SCSITargetReq *r) + } + + /* PAGE CODE == 0 */ +- r->len = MIN(r->req.cmd.xfer, 36); ++ r->len = MIN(r->req.cmd.xfer, SCSI_INQUIRY_LEN); + memset(r->buf, 0, r->len); + if (r->req.lun != 0) { + r->buf[0] = TYPE_NO_LUN; +@@ -447,8 +451,9 @@ static int32_t scsi_target_send_command(SCSIRequest *req, uint8_t *buf) + } + break; + case REQUEST_SENSE: ++ scsi_target_alloc_buf(&r->req, SCSI_SENSE_LEN); + r->len = scsi_device_get_sense(r->req.dev, r->buf, +- MIN(req->cmd.xfer, sizeof r->buf), ++ MIN(req->cmd.xfer, r->buf_len), + (req->cmd.buf[1] & 1) == 0); + if (r->req.dev->sense_is_ua) { + scsi_device_unit_attention_reported(req->dev); +@@ -493,11 +498,29 @@ static uint8_t *scsi_target_get_buf(SCSIRequest *req) + return r->buf; + } + ++static uint8_t *scsi_target_alloc_buf(SCSIRequest *req, size_t len) ++{ ++ SCSITargetReq *r = DO_UPCAST(SCSITargetReq, req, req); ++ ++ r->buf = g_malloc(len); ++ r->buf_len = len; ++ ++ return r->buf; ++} ++ ++static void scsi_target_free_buf(SCSIRequest *req) ++{ ++ SCSITargetReq *r = DO_UPCAST(SCSITargetReq, req, req); ++ ++ g_free(r->buf); ++} ++ + static const struct SCSIReqOps reqops_target_command = { + .size = sizeof(SCSITargetReq), + .send_command = scsi_target_send_command, + .read_data = scsi_target_read_data, + .get_buf = scsi_target_get_buf, ++ .free_req = scsi_target_free_buf, + }; + + +@@ -1353,7 +1376,7 @@ int scsi_build_sense(uint8_t *in_buf, int in_len, + buf[7] = 10; + buf[12] = sense.asc; + buf[13] = sense.ascq; +- return MIN(len, 18); ++ return MIN(len, SCSI_SENSE_LEN); + } else { + /* Return descriptor format sense buffer */ + buf[0] = 0x72; +diff --git a/include/hw/scsi/scsi.h b/include/hw/scsi/scsi.h +index 9786e00..2eccb72 100644 +--- a/include/hw/scsi/scsi.h ++++ b/include/hw/scsi/scsi.h +@@ -9,6 +9,8 @@ + #define MAX_SCSI_DEVS 255 + + #define SCSI_CMD_BUF_SIZE 16 ++#define SCSI_SENSE_LEN 18 ++#define SCSI_INQUIRY_LEN 36 + + typedef struct SCSIBus SCSIBus; + typedef struct SCSIBusInfo SCSIBusInfo; +-- +1.7.1 + diff --git a/SOURCES/kvm-scsi-Change-scsi-sense-buf-size-to-252.patch b/SOURCES/kvm-scsi-Change-scsi-sense-buf-size-to-252.patch new file mode 100644 index 0000000..d3ee4a5 --- /dev/null +++ b/SOURCES/kvm-scsi-Change-scsi-sense-buf-size-to-252.patch @@ -0,0 +1,101 @@ +From 79d13d1e7d0934198a2774235b70f688aa5f433f Mon Sep 17 00:00:00 2001 +From: Fam Zheng +Date: Wed, 19 Mar 2014 05:33:13 +0100 +Subject: [PATCH 1/2] scsi: Change scsi sense buf size to 252 + +RH-Author: Fam Zheng +Message-id: <1395207194-25330-2-git-send-email-famz@redhat.com> +Patchwork-id: 58139 +O-Subject: [RHEL-7 qemu-kvm PATCH v2 1/2] scsi: Change scsi sense buf size to 252 +Bugzilla: 1058173 +RH-Acked-by: Markus Armbruster +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Paolo Bonzini + +Bugzilla: https://bugzilla.redhat.com/show_bug.cgi?id=1058173 +Brew: http://brewweb.devel.redhat.com/brew/taskinfo?taskID=7141744 + +Current buffer size fails the assersion check in like + + hw/scsi/scsi-bus.c:1655: assert(req->sense_len <= sizeof(req->sense)); + +when backend (block/iscsi.c) returns more data then 96. + +Exercise the core dump path by booting an Gentoo ISO with scsi-generic +device backed with iscsi (built with libiscsi 1.7.0): + + x86_64-softmmu/qemu-system-x86_64 \ + -drive file=iscsi://localhost:3260/iqn.foobar/0,if=none,id=drive-disk \ + -device virtio-scsi-pci,id=scsi1,bus=pci.0,addr=0x6 \ + -device scsi-generic,drive=drive-disk,bus=scsi1.0,id=iscsi-disk \ + -boot d \ + -cdrom gentoo.iso + + qemu-system-x86_64: hw/scsi/scsi-bus.c:1655: scsi_req_complete: + Assertion `req->sense_len <= sizeof(req->sense)' failed. + +According to SPC-4, section 4.5.2.1, 252 is the limit of sense data. So +increase the value to fix it. + +Also remove duplicated define for the macro. + +Signed-off-by: Fam Zheng +Reviewed-by: Benoit Canet +Cc: qemu-stable@nongnu.org +Signed-off-by: Paolo Bonzini +(cherry picked from commit c5f52875b980e54e6bebad6121c76863356e1d7f) +Signed-off-by: Fam Zheng +--- + hw/scsi/scsi-generic.c | 2 -- + hw/scsi/spapr_vscsi.c | 1 - + include/hw/scsi/scsi.h | 2 +- + 3 files changed, 1 insertion(+), 4 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + hw/scsi/scsi-generic.c | 2 -- + hw/scsi/spapr_vscsi.c | 1 - + include/hw/scsi/scsi.h | 2 +- + 3 files changed, 1 insertions(+), 4 deletions(-) + +diff --git a/hw/scsi/scsi-generic.c b/hw/scsi/scsi-generic.c +index f08b64e..8d92e0d 100644 +--- a/hw/scsi/scsi-generic.c ++++ b/hw/scsi/scsi-generic.c +@@ -37,8 +37,6 @@ do { fprintf(stderr, "scsi-generic: " fmt , ## __VA_ARGS__); } while (0) + #include + #include "block/scsi.h" + +-#define SCSI_SENSE_BUF_SIZE 96 +- + #define SG_ERR_DRIVER_TIMEOUT 0x06 + #define SG_ERR_DRIVER_SENSE 0x08 + +diff --git a/hw/scsi/spapr_vscsi.c b/hw/scsi/spapr_vscsi.c +index e8978bf..514ab88 100644 +--- a/hw/scsi/spapr_vscsi.c ++++ b/hw/scsi/spapr_vscsi.c +@@ -60,7 +60,6 @@ + #define VSCSI_MAX_SECTORS 4096 + #define VSCSI_REQ_LIMIT 24 + +-#define SCSI_SENSE_BUF_SIZE 96 + #define SRP_RSP_SENSE_DATA_LEN 18 + + typedef union vscsi_crq { +diff --git a/include/hw/scsi/scsi.h b/include/hw/scsi/scsi.h +index 2eccb72..4a1de1b 100644 +--- a/include/hw/scsi/scsi.h ++++ b/include/hw/scsi/scsi.h +@@ -31,7 +31,7 @@ typedef struct SCSISense { + uint8_t ascq; + } SCSISense; + +-#define SCSI_SENSE_BUF_SIZE 96 ++#define SCSI_SENSE_BUF_SIZE 252 + + struct SCSICommand { + uint8_t buf[SCSI_CMD_BUF_SIZE]; +-- +1.7.1 + diff --git a/SOURCES/kvm-scsi-Fix-migration-of-scsi-sense-data.patch b/SOURCES/kvm-scsi-Fix-migration-of-scsi-sense-data.patch new file mode 100644 index 0000000..8baa340 --- /dev/null +++ b/SOURCES/kvm-scsi-Fix-migration-of-scsi-sense-data.patch @@ -0,0 +1,119 @@ +From 5cd8edcba7977ebc8973af8a894716f3915e1dc7 Mon Sep 17 00:00:00 2001 +From: Fam Zheng +Date: Wed, 19 Mar 2014 05:33:14 +0100 +Subject: [PATCH 2/2] scsi: Fix migration of scsi sense data + +RH-Author: Fam Zheng +Message-id: <1395207194-25330-3-git-send-email-famz@redhat.com> +Patchwork-id: 58140 +O-Subject: [RHEL-7 qemu-kvm PATCH v2 2/2] scsi: Fix migration of scsi sense data +Bugzilla: 1058173 +RH-Acked-by: Markus Armbruster +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Paolo Bonzini + +c5f52875 changed the size of sense array in vmstate_scsi_device by +mistake. This patch restores the old size, and add a subsection for the +remaining part of the buffer size. So that migration is not broken. + +Signed-off-by: Fam Zheng +Signed-off-by: Paolo Bonzini +(cherry picked from commit 2e323f03bfa323636552b386c982412944ff86ae) +Signed-off-by: Fam Zheng +--- + hw/scsi/scsi-bus.c | 30 +++++++++++++++++++++++++++++- + include/hw/scsi/scsi.h | 1 + + include/migration/vmstate.h | 3 +++ + 3 files changed, 33 insertions(+), 1 deletion(-) + +Signed-off-by: Miroslav Rezanina +--- + hw/scsi/scsi-bus.c | 30 +++++++++++++++++++++++++++++- + include/hw/scsi/scsi.h | 1 + + include/migration/vmstate.h | 3 +++ + 3 files changed, 33 insertions(+), 1 deletions(-) + +diff --git a/hw/scsi/scsi-bus.c b/hw/scsi/scsi-bus.c +index a0fbf06..77e0c10 100644 +--- a/hw/scsi/scsi-bus.c ++++ b/hw/scsi/scsi-bus.c +@@ -1874,6 +1874,26 @@ static const VMStateInfo vmstate_info_scsi_requests = { + .put = put_scsi_requests, + }; + ++static bool scsi_sense_state_needed(void *opaque) ++{ ++ SCSIDevice *s = opaque; ++ ++ return s->sense_len > SCSI_SENSE_BUF_SIZE_OLD; ++} ++ ++static const VMStateDescription vmstate_scsi_sense_state = { ++ .name = "SCSIDevice/sense", ++ .version_id = 1, ++ .minimum_version_id = 1, ++ .minimum_version_id_old = 1, ++ .fields = (VMStateField []) { ++ VMSTATE_UINT8_SUB_ARRAY(sense, SCSIDevice, ++ SCSI_SENSE_BUF_SIZE_OLD, ++ SCSI_SENSE_BUF_SIZE - SCSI_SENSE_BUF_SIZE_OLD), ++ VMSTATE_END_OF_LIST() ++ } ++}; ++ + const VMStateDescription vmstate_scsi_device = { + .name = "SCSIDevice", + .version_id = 1, +@@ -1884,7 +1904,7 @@ const VMStateDescription vmstate_scsi_device = { + VMSTATE_UINT8(unit_attention.asc, SCSIDevice), + VMSTATE_UINT8(unit_attention.ascq, SCSIDevice), + VMSTATE_BOOL(sense_is_ua, SCSIDevice), +- VMSTATE_UINT8_ARRAY(sense, SCSIDevice, SCSI_SENSE_BUF_SIZE), ++ VMSTATE_UINT8_SUB_ARRAY(sense, SCSIDevice, 0, SCSI_SENSE_BUF_SIZE_OLD), + VMSTATE_UINT32(sense_len, SCSIDevice), + { + .name = "requests", +@@ -1896,6 +1916,14 @@ const VMStateDescription vmstate_scsi_device = { + .offset = 0, + }, + VMSTATE_END_OF_LIST() ++ }, ++ .subsections = (VMStateSubsection []) { ++ { ++ .vmsd = &vmstate_scsi_sense_state, ++ .needed = scsi_sense_state_needed, ++ }, { ++ /* empty */ ++ } + } + }; + +diff --git a/include/hw/scsi/scsi.h b/include/hw/scsi/scsi.h +index 4a1de1b..b0d6e8f 100644 +--- a/include/hw/scsi/scsi.h ++++ b/include/hw/scsi/scsi.h +@@ -31,6 +31,7 @@ typedef struct SCSISense { + uint8_t ascq; + } SCSISense; + ++#define SCSI_SENSE_BUF_SIZE_OLD 96 + #define SCSI_SENSE_BUF_SIZE 252 + + struct SCSICommand { +diff --git a/include/migration/vmstate.h b/include/migration/vmstate.h +index ebc4d09..11d93e1 100644 +--- a/include/migration/vmstate.h ++++ b/include/migration/vmstate.h +@@ -625,6 +625,9 @@ extern const VMStateInfo vmstate_info_bitmap; + #define VMSTATE_UINT8_ARRAY(_f, _s, _n) \ + VMSTATE_UINT8_ARRAY_V(_f, _s, _n, 0) + ++#define VMSTATE_UINT8_SUB_ARRAY(_f, _s, _start, _num) \ ++ VMSTATE_SUB_ARRAY(_f, _s, _start, _num, 0, vmstate_info_uint8, uint8_t) ++ + #define VMSTATE_UINT8_2DARRAY(_f, _s, _n1, _n2) \ + VMSTATE_UINT8_2DARRAY_V(_f, _s, _n1, _n2, 0) + +-- +1.7.1 + diff --git a/SOURCES/kvm-scsi-Support-TEST-UNIT-READY-in-the-dummy-LUN0.patch b/SOURCES/kvm-scsi-Support-TEST-UNIT-READY-in-the-dummy-LUN0.patch new file mode 100644 index 0000000..11bfb63 --- /dev/null +++ b/SOURCES/kvm-scsi-Support-TEST-UNIT-READY-in-the-dummy-LUN0.patch @@ -0,0 +1,55 @@ +From 4dfa4b8a0adf2ff3b5f48426e5f293d4ccaa86ce Mon Sep 17 00:00:00 2001 +From: Fam Zheng +Date: Wed, 29 Jan 2014 05:09:21 +0100 +Subject: [PATCH 03/28] scsi: Support TEST UNIT READY in the dummy LUN0 + +RH-Author: Fam Zheng +Message-id: <1390972161-27425-1-git-send-email-famz@redhat.com> +Patchwork-id: 57014 +O-Subject: [RHEL-7 qemu-kvm PATCH] scsi: Support TEST UNIT READY in the dummy LUN0 +Bugzilla: 1004143 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Markus Armbruster + +From: Paolo Bonzini + +Bugzilla: https://bugzilla.redhat.com/show_bug.cgi?id=1004143 +Brew: http://brewweb.devel.redhat.com/brew/taskinfo?taskID=6965573 + +SeaBIOS waits for LUN0 to respond to the TEST UNIT READY command +in order to decide whether it should part of the boot sequence. +If LUN0 does not respond to the command, boot is delayed by up +to 5 seconds. This currently happens when there is no LUN0 on +a target. Fix that by adding a trivial implementation of the +command. + +Cc: qemu-stable@nongnu.org +Signed-off-by: Paolo Bonzini +(cherry picked from commit 1cb27d9233d572826b45bd8498d2fab1b6f01df9) +Signed-off-by: Fam Zheng +--- + hw/scsi/scsi-bus.c | 2 ++ + 1 file changed, 2 insertions(+) + +Signed-off-by: Miroslav Rezanina +--- + hw/scsi/scsi-bus.c | 2 ++ + 1 files changed, 2 insertions(+), 0 deletions(-) + +diff --git a/hw/scsi/scsi-bus.c b/hw/scsi/scsi-bus.c +index 0f02208..a0fbf06 100644 +--- a/hw/scsi/scsi-bus.c ++++ b/hw/scsi/scsi-bus.c +@@ -461,6 +461,8 @@ static int32_t scsi_target_send_command(SCSIRequest *req, uint8_t *buf) + r->req.dev->sense_is_ua = false; + } + break; ++ case TEST_UNIT_READY: ++ break; + default: + scsi_req_build_sense(req, SENSE_CODE(LUN_NOT_SUPPORTED)); + scsi_req_complete(req, CHECK_CONDITION); +-- +1.7.1 + diff --git a/SOURCES/kvm-scsi-bus-fix-transfer-length-and-direction-for-VERIF.patch b/SOURCES/kvm-scsi-bus-fix-transfer-length-and-direction-for-VERIF.patch new file mode 100644 index 0000000..008e1b0 --- /dev/null +++ b/SOURCES/kvm-scsi-bus-fix-transfer-length-and-direction-for-VERIF.patch @@ -0,0 +1,75 @@ +From 496cf1296786c104f08a04263d59abf701759374 Mon Sep 17 00:00:00 2001 +From: Paolo Bonzini +Date: Mon, 20 Jan 2014 12:49:44 +0100 +Subject: [PATCH 28/34] scsi-bus: fix transfer length and direction for VERIFY command +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +RH-Author: Paolo Bonzini +Message-id: <1390222185-24969-2-git-send-email-pbonzini@redhat.com> +Patchwork-id: 56833 +O-Subject: [RHEL 7.0 qemu-kvm PATCH 1/2] scsi-bus: fix transfer length and direction for VERIFY command +Bugzilla: 1035644 +RH-Acked-by: Fam Zheng +RH-Acked-by: Laszlo Ersek +RH-Acked-by: Orit Wasserman + +The amount of bytes to transfer depends on the BYTCHK field. +If any data is transferred, it is sent to the device. + +Cc: qemu-stable@nongnu.org +Tested-by: Hervé Poussineau +Signed-off-by: Paolo Bonzini +(cherry picked from commit d12ad44cc4cc9142179e64295608611f118b8ad8) +--- + hw/scsi/scsi-bus.c | 14 +++++++++++++- + 1 file changed, 13 insertions(+), 1 deletion(-) + +Signed-off-by: Miroslav Rezanina +--- + hw/scsi/scsi-bus.c | 14 +++++++++++++- + 1 files changed, 13 insertions(+), 1 deletions(-) + +diff --git a/hw/scsi/scsi-bus.c b/hw/scsi/scsi-bus.c +index 6733c1a..0f02208 100644 +--- a/hw/scsi/scsi-bus.c ++++ b/hw/scsi/scsi-bus.c +@@ -874,7 +874,6 @@ static int scsi_req_length(SCSICommand *cmd, SCSIDevice *dev, uint8_t *buf) + case RELEASE: + case ERASE: + case ALLOW_MEDIUM_REMOVAL: +- case VERIFY_10: + case SEEK_10: + case SYNCHRONIZE_CACHE: + case SYNCHRONIZE_CACHE_16: +@@ -891,6 +890,16 @@ static int scsi_req_length(SCSICommand *cmd, SCSIDevice *dev, uint8_t *buf) + case ALLOW_OVERWRITE: + cmd->xfer = 0; + break; ++ case VERIFY_10: ++ case VERIFY_12: ++ case VERIFY_16: ++ if ((buf[1] & 2) == 0) { ++ cmd->xfer = 0; ++ } else if ((buf[1] & 4) == 1) { ++ cmd->xfer = 1; ++ } ++ cmd->xfer *= dev->blocksize; ++ break; + case MODE_SENSE: + break; + case WRITE_SAME_10: +@@ -1088,6 +1097,9 @@ static void scsi_cmd_xfer_mode(SCSICommand *cmd) + case WRITE_VERIFY_12: + case WRITE_16: + case WRITE_VERIFY_16: ++ case VERIFY_10: ++ case VERIFY_12: ++ case VERIFY_16: + case COPY: + case COPY_VERIFY: + case COMPARE: +-- +1.7.1 + diff --git a/SOURCES/kvm-scsi-disk-add-UNMAP-limits-to-block-limits-VPD-page.patch b/SOURCES/kvm-scsi-disk-add-UNMAP-limits-to-block-limits-VPD-page.patch new file mode 100644 index 0000000..607b422 --- /dev/null +++ b/SOURCES/kvm-scsi-disk-add-UNMAP-limits-to-block-limits-VPD-page.patch @@ -0,0 +1,113 @@ +From de979b1f256be8488f49a78646dee1ded06251ef Mon Sep 17 00:00:00 2001 +From: Paolo Bonzini +Date: Mon, 20 Jan 2014 12:49:40 +0100 +Subject: [PATCH 2/4] scsi-disk: add UNMAP limits to block limits VPD page + +RH-Author: Paolo Bonzini +Message-id: <1390222180-24891-1-git-send-email-pbonzini@redhat.com> +Patchwork-id: 56831 +O-Subject: [RHEL 7.0 qemu-kvm PATCH] scsi-disk: add UNMAP limits to block limits VPD page +Bugzilla: 1037503 +RH-Acked-by: Orit Wasserman +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Fam Zheng + +Bugzilla: 1037503 + +Brew build: 6896455 + +Linux prefers WRITE SAME to UNMAP if the limits are zero, and WRITE +SAME does not discard anything unless the device can guarantee that +the resulting block is zero. + +Setting the maximum unmap block and descriptor counts to non-zero +makes Linux choose UNMAP and fixes thin provisioning on glusterfs. + +While the maximum unmap block count can have some effect on performance, +the (suggested) maximum number of descriptors is not particularly +important so I didn't add a customization option. SCSI drivers are +used to online firmware updates so I'm not yet adding versioning support +for SCSI, but we're probably getting close to the point when it's worth +thinking about it. + +Reported-by: Bharata B Rao +Signed-off-by: Paolo Bonzini +(cherry picked from commit 8a1bd2973ed5f99a3c37c9afdff823c4a22152b1) +--- + hw/scsi/scsi-disk.c | 20 ++++++++++++++++++++ + 1 file changed, 20 insertions(+) + +Signed-off-by: Miroslav Rezanina +--- + hw/scsi/scsi-disk.c | 20 ++++++++++++++++++++ + 1 files changed, 20 insertions(+), 0 deletions(-) + +diff --git a/hw/scsi/scsi-disk.c b/hw/scsi/scsi-disk.c +index 7653411..bce617c 100644 +--- a/hw/scsi/scsi-disk.c ++++ b/hw/scsi/scsi-disk.c +@@ -47,6 +47,7 @@ do { printf("scsi-disk: " fmt , ## __VA_ARGS__); } while (0) + #define SCSI_MAX_MODE_LEN 256 + + #define DEFAULT_DISCARD_GRANULARITY 4096 ++#define DEFAULT_MAX_UNMAP_SIZE (1 << 30) /* 1 GB */ + + typedef struct SCSIDiskState SCSIDiskState; + +@@ -74,6 +75,7 @@ struct SCSIDiskState + bool media_event; + bool eject_request; + uint64_t wwn; ++ uint64_t max_unmap_size; + QEMUBH *bh; + char *version; + char *serial; +@@ -625,6 +627,8 @@ static int scsi_disk_emulate_inquiry(SCSIRequest *req, uint8_t *outbuf) + s->qdev.conf.min_io_size / s->qdev.blocksize; + unsigned int opt_io_size = + s->qdev.conf.opt_io_size / s->qdev.blocksize; ++ unsigned int max_unmap_sectors = ++ s->max_unmap_size / s->qdev.blocksize; + + if (s->qdev.type == TYPE_ROM) { + DPRINTF("Inquiry (EVPD[%02X] not supported for CDROM\n", +@@ -647,6 +651,18 @@ static int scsi_disk_emulate_inquiry(SCSIRequest *req, uint8_t *outbuf) + outbuf[14] = (opt_io_size >> 8) & 0xff; + outbuf[15] = opt_io_size & 0xff; + ++ /* max unmap LBA count, default is 1GB */ ++ outbuf[20] = (max_unmap_sectors >> 24) & 0xff; ++ outbuf[21] = (max_unmap_sectors >> 16) & 0xff; ++ outbuf[22] = (max_unmap_sectors >> 8) & 0xff; ++ outbuf[23] = max_unmap_sectors & 0xff; ++ ++ /* max unmap descriptors, 255 fit in 4 kb with an 8-byte header. */ ++ outbuf[24] = 0; ++ outbuf[25] = 0; ++ outbuf[26] = 0; ++ outbuf[27] = 255; ++ + /* optimal unmap granularity */ + outbuf[28] = (unmap_sectors >> 24) & 0xff; + outbuf[29] = (unmap_sectors >> 16) & 0xff; +@@ -2519,6 +2535,8 @@ static Property scsi_hd_properties[] = { + DEFINE_PROP_BIT("dpofua", SCSIDiskState, features, + SCSI_DISK_F_DPOFUA, false), + DEFINE_PROP_HEX64("wwn", SCSIDiskState, wwn, 0), ++ DEFINE_PROP_UINT64("max_unmap_size", SCSIDiskState, max_unmap_size, ++ DEFAULT_MAX_UNMAP_SIZE), + DEFINE_BLOCK_CHS_PROPERTIES(SCSIDiskState, qdev.conf), + DEFINE_PROP_END_OF_LIST(), + }; +@@ -2628,6 +2646,8 @@ static Property scsi_disk_properties[] = { + DEFINE_PROP_BIT("dpofua", SCSIDiskState, features, + SCSI_DISK_F_DPOFUA, false), + DEFINE_PROP_HEX64("wwn", SCSIDiskState, wwn, 0), ++ DEFINE_PROP_UINT64("max_unmap_size", SCSIDiskState, max_unmap_size, ++ DEFAULT_MAX_UNMAP_SIZE), + DEFINE_PROP_END_OF_LIST(), + }; + +-- +1.7.1 + diff --git a/SOURCES/kvm-scsi-disk-catch-write-protection-errors-in-UNMAP.patch.patch.patch b/SOURCES/kvm-scsi-disk-catch-write-protection-errors-in-UNMAP.patch.patch.patch new file mode 100644 index 0000000..f83c383 --- /dev/null +++ b/SOURCES/kvm-scsi-disk-catch-write-protection-errors-in-UNMAP.patch.patch.patch @@ -0,0 +1,58 @@ +From 25760de201dc5c29d171fc4ae4f34d6eaabbdad6 Mon Sep 17 00:00:00 2001 +Message-Id: <25760de201dc5c29d171fc4ae4f34d6eaabbdad6.1389014116.git.minovotn@redhat.com> +In-Reply-To: +References: +From: Paolo Bonzini +Date: Mon, 9 Dec 2013 14:09:23 +0100 +Subject: [PATCH 35/50] scsi-disk: catch write protection errors in UNMAP + +RH-Author: Paolo Bonzini +Message-id: <1386598178-11845-38-git-send-email-pbonzini@redhat.com> +Patchwork-id: 56074 +O-Subject: [RHEL 7.0 qemu-kvm PATCH 37/52] scsi-disk: catch write protection errors in UNMAP +Bugzilla: 1007815 +RH-Acked-by: Jeffrey Cody +RH-Acked-by: Fam Zheng +RH-Acked-by: Stefan Hajnoczi + +This is the same that is already done for WRITE SAME. + +Signed-off-by: Paolo Bonzini +Signed-off-by: Stefan Hajnoczi +(cherry picked from commit c5fd1fb038405ed13496761970b3b531f747a892) +--- + hw/scsi/scsi-disk.c | 6 ++++++ + 1 file changed, 6 insertions(+) + +Signed-off-by: Michal Novotny +--- + hw/scsi/scsi-disk.c | 6 ++++++ + 1 file changed, 6 insertions(+) + +diff --git a/hw/scsi/scsi-disk.c b/hw/scsi/scsi-disk.c +index 74e6a14..4138268 100644 +--- a/hw/scsi/scsi-disk.c ++++ b/hw/scsi/scsi-disk.c +@@ -1543,6 +1543,7 @@ done: + + static void scsi_disk_emulate_unmap(SCSIDiskReq *r, uint8_t *inbuf) + { ++ SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, r->req.dev); + uint8_t *p = inbuf; + int len = r->req.cmd.xfer; + UnmapCBData *data; +@@ -1560,6 +1561,11 @@ static void scsi_disk_emulate_unmap(SCSIDiskReq *r, uint8_t *inbuf) + goto invalid_param_len; + } + ++ if (bdrv_is_read_only(s->qdev.conf.bs)) { ++ scsi_check_condition(r, SENSE_CODE(WRITE_PROTECTED)); ++ return; ++ } ++ + data = g_new0(UnmapCBData, 1); + data->r = r; + data->inbuf = &p[8]; +-- +1.7.11.7 + diff --git a/SOURCES/kvm-scsi-disk-correctly-implement-WRITE-SAME.patch.patch.patch b/SOURCES/kvm-scsi-disk-correctly-implement-WRITE-SAME.patch.patch.patch new file mode 100644 index 0000000..0001b6a --- /dev/null +++ b/SOURCES/kvm-scsi-disk-correctly-implement-WRITE-SAME.patch.patch.patch @@ -0,0 +1,219 @@ +From 36d03c829bbf59e9346784b1e582803c482c4320 Mon Sep 17 00:00:00 2001 +Message-Id: <36d03c829bbf59e9346784b1e582803c482c4320.1389014116.git.minovotn@redhat.com> +In-Reply-To: +References: +From: Paolo Bonzini +Date: Mon, 9 Dec 2013 14:09:25 +0100 +Subject: [PATCH 37/50] scsi-disk: correctly implement WRITE SAME + +RH-Author: Paolo Bonzini +Message-id: <1386598178-11845-40-git-send-email-pbonzini@redhat.com> +Patchwork-id: 56076 +O-Subject: [RHEL 7.0 qemu-kvm PATCH 39/52] scsi-disk: correctly implement WRITE SAME +Bugzilla: 1007815 +RH-Acked-by: Jeffrey Cody +RH-Acked-by: Fam Zheng +RH-Acked-by: Stefan Hajnoczi + +Fetch the data to be written from the input buffer. If it is all zeroes, +we can use the write_zeroes call (possibly with the new MAY_UNMAP flag). +Otherwise, do as many write cycles as needed, writing 512k at a time. + +Strictly speaking, this is still incorrect because a zero cluster should +only be written if the MAY_UNMAP flag is set. But this is a bug in qcow2 +and the other formats, not in the SCSI code. + +Signed-off-by: Paolo Bonzini +Signed-off-by: Stefan Hajnoczi +(cherry picked from commit 84f94a9a82487639bc87d5f09f938c9f6a61f79a) +--- + hw/scsi/scsi-disk.c | 140 +++++++++++++++++++++++++++++++++++++++++++--------- + 1 file changed, 116 insertions(+), 24 deletions(-) + +Signed-off-by: Michal Novotny +--- + hw/scsi/scsi-disk.c | 140 +++++++++++++++++++++++++++++++++++++++++++--------- + 1 file changed, 116 insertions(+), 24 deletions(-) + +diff --git a/hw/scsi/scsi-disk.c b/hw/scsi/scsi-disk.c +index 0640bb0..efadfc0 100644 +--- a/hw/scsi/scsi-disk.c ++++ b/hw/scsi/scsi-disk.c +@@ -41,6 +41,7 @@ do { printf("scsi-disk: " fmt , ## __VA_ARGS__); } while (0) + #include + #endif + ++#define SCSI_WRITE_SAME_MAX 524288 + #define SCSI_DMA_BUF_SIZE 131072 + #define SCSI_MAX_INQUIRY_LEN 256 + #define SCSI_MAX_MODE_LEN 256 +@@ -634,6 +635,8 @@ static int scsi_disk_emulate_inquiry(SCSIRequest *req, uint8_t *outbuf) + buflen = 0x40; + memset(outbuf + 4, 0, buflen - 4); + ++ outbuf[4] = 0x1; /* wsnz */ ++ + /* optimal transfer length granularity */ + outbuf[6] = (min_io_size >> 8) & 0xff; + outbuf[7] = min_io_size & 0xff; +@@ -1589,6 +1592,111 @@ invalid_field: + scsi_check_condition(r, SENSE_CODE(INVALID_FIELD)); + } + ++typedef struct WriteSameCBData { ++ SCSIDiskReq *r; ++ int64_t sector; ++ int nb_sectors; ++ QEMUIOVector qiov; ++ struct iovec iov; ++} WriteSameCBData; ++ ++static void scsi_write_same_complete(void *opaque, int ret) ++{ ++ WriteSameCBData *data = opaque; ++ SCSIDiskReq *r = data->r; ++ SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, r->req.dev); ++ ++ assert(r->req.aiocb != NULL); ++ r->req.aiocb = NULL; ++ bdrv_acct_done(s->qdev.conf.bs, &r->acct); ++ if (r->req.io_canceled) { ++ goto done; ++ } ++ ++ if (ret < 0) { ++ if (scsi_handle_rw_error(r, -ret)) { ++ goto done; ++ } ++ } ++ ++ data->nb_sectors -= data->iov.iov_len / 512; ++ data->sector += data->iov.iov_len / 512; ++ data->iov.iov_len = MIN(data->nb_sectors * 512, data->iov.iov_len); ++ if (data->iov.iov_len) { ++ bdrv_acct_start(s->qdev.conf.bs, &r->acct, data->iov.iov_len, BDRV_ACCT_WRITE); ++ r->req.aiocb = bdrv_aio_writev(s->qdev.conf.bs, data->sector, ++ &data->qiov, data->iov.iov_len / 512, ++ scsi_write_same_complete, r); ++ return; ++ } ++ ++ scsi_req_complete(&r->req, GOOD); ++ ++done: ++ if (!r->req.io_canceled) { ++ scsi_req_unref(&r->req); ++ } ++ qemu_vfree(data->iov.iov_base); ++ g_free(data); ++} ++ ++static void scsi_disk_emulate_write_same(SCSIDiskReq *r, uint8_t *inbuf) ++{ ++ SCSIRequest *req = &r->req; ++ SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, req->dev); ++ uint32_t nb_sectors = scsi_data_cdb_length(r->req.cmd.buf); ++ WriteSameCBData *data; ++ uint8_t *buf; ++ int i; ++ ++ /* Fail if PBDATA=1 or LBDATA=1 or ANCHOR=1. */ ++ if (nb_sectors == 0 || (req->cmd.buf[1] & 0x16)) { ++ scsi_check_condition(r, SENSE_CODE(INVALID_FIELD)); ++ return; ++ } ++ ++ if (bdrv_is_read_only(s->qdev.conf.bs)) { ++ scsi_check_condition(r, SENSE_CODE(WRITE_PROTECTED)); ++ return; ++ } ++ if (!check_lba_range(s, r->req.cmd.lba, nb_sectors)) { ++ scsi_check_condition(r, SENSE_CODE(LBA_OUT_OF_RANGE)); ++ return; ++ } ++ ++ if (buffer_is_zero(inbuf, s->qdev.blocksize)) { ++ int flags = (req->cmd.buf[1] & 0x8) ? BDRV_REQ_MAY_UNMAP : 0; ++ ++ /* The request is used as the AIO opaque value, so add a ref. */ ++ scsi_req_ref(&r->req); ++ bdrv_acct_start(s->qdev.conf.bs, &r->acct, nb_sectors * s->qdev.blocksize, ++ BDRV_ACCT_WRITE); ++ r->req.aiocb = bdrv_aio_write_zeroes(s->qdev.conf.bs, ++ r->req.cmd.lba * (s->qdev.blocksize / 512), ++ nb_sectors * (s->qdev.blocksize / 512), ++ flags, scsi_aio_complete, r); ++ return; ++ } ++ ++ data = g_new0(WriteSameCBData, 1); ++ data->r = r; ++ data->sector = r->req.cmd.lba * (s->qdev.blocksize / 512); ++ data->nb_sectors = nb_sectors * (s->qdev.blocksize / 512); ++ data->iov.iov_len = MIN(data->nb_sectors * 512, SCSI_WRITE_SAME_MAX); ++ data->iov.iov_base = buf = qemu_blockalign(s->qdev.conf.bs, data->iov.iov_len); ++ qemu_iovec_init_external(&data->qiov, &data->iov, 1); ++ ++ for (i = 0; i < data->iov.iov_len; i += s->qdev.blocksize) { ++ memcpy(&buf[i], inbuf, s->qdev.blocksize); ++ } ++ ++ scsi_req_ref(&r->req); ++ bdrv_acct_start(s->qdev.conf.bs, &r->acct, data->iov.iov_len, BDRV_ACCT_WRITE); ++ r->req.aiocb = bdrv_aio_writev(s->qdev.conf.bs, data->sector, ++ &data->qiov, data->iov.iov_len / 512, ++ scsi_write_same_complete, data); ++} ++ + static void scsi_disk_emulate_write_data(SCSIRequest *req) + { + SCSIDiskReq *r = DO_UPCAST(SCSIDiskReq, req, req); +@@ -1612,6 +1720,10 @@ static void scsi_disk_emulate_write_data(SCSIRequest *req) + scsi_disk_emulate_unmap(r, r->iov.iov_base); + break; + ++ case WRITE_SAME_10: ++ case WRITE_SAME_16: ++ scsi_disk_emulate_write_same(r, r->iov.iov_base); ++ break; + default: + abort(); + } +@@ -1854,30 +1966,10 @@ static int32_t scsi_disk_emulate_command(SCSIRequest *req, uint8_t *buf) + break; + case WRITE_SAME_10: + case WRITE_SAME_16: +- nb_sectors = scsi_data_cdb_length(r->req.cmd.buf); +- if (bdrv_is_read_only(s->qdev.conf.bs)) { +- scsi_check_condition(r, SENSE_CODE(WRITE_PROTECTED)); +- return 0; +- } +- if (!check_lba_range(s, r->req.cmd.lba, nb_sectors)) { +- goto illegal_lba; +- } +- +- /* +- * We only support WRITE SAME with the unmap bit set for now. +- * Reject UNMAP=0 or ANCHOR=1. +- */ +- if (!(req->cmd.buf[1] & 0x8) || (req->cmd.buf[1] & 0x10)) { +- goto illegal_request; +- } +- +- /* The request is used as the AIO opaque value, so add a ref. */ +- scsi_req_ref(&r->req); +- r->req.aiocb = bdrv_aio_discard(s->qdev.conf.bs, +- r->req.cmd.lba * (s->qdev.blocksize / 512), +- nb_sectors * (s->qdev.blocksize / 512), +- scsi_aio_complete, r); +- return 0; ++ DPRINTF("WRITE SAME %d (len %lu)\n", ++ req->cmd.buf[0] == WRITE_SAME_10 ? 10 : 16, ++ (long)r->req.cmd.xfer); ++ break; + default: + DPRINTF("Unknown SCSI command (%2.2x)\n", buf[0]); + scsi_check_condition(r, SENSE_CODE(INVALID_OPCODE)); +-- +1.7.11.7 + diff --git a/SOURCES/kvm-scsi-disk-fix-VERIFY-emulation.patch b/SOURCES/kvm-scsi-disk-fix-VERIFY-emulation.patch new file mode 100644 index 0000000..37f0853 --- /dev/null +++ b/SOURCES/kvm-scsi-disk-fix-VERIFY-emulation.patch @@ -0,0 +1,109 @@ +From e110f0eee587fbfc75409e0980f25275dd8551de Mon Sep 17 00:00:00 2001 +From: Paolo Bonzini +Date: Mon, 20 Jan 2014 12:49:45 +0100 +Subject: [PATCH 29/34] scsi-disk: fix VERIFY emulation +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +RH-Author: Paolo Bonzini +Message-id: <1390222185-24969-3-git-send-email-pbonzini@redhat.com> +Patchwork-id: 56834 +O-Subject: [RHEL 7.0 qemu-kvm PATCH 2/2] scsi-disk: fix VERIFY emulation +Bugzilla: 1035644 +RH-Acked-by: Fam Zheng +RH-Acked-by: Laszlo Ersek +RH-Acked-by: Orit Wasserman + +VERIFY emulation was completely botched (and remained botched through +all the refactorings). The command must be emulated both in check-medium +mode (BYTCHK=00, which we implement by doing nothing) and in check-bytes +mode (which we do not implement yet). Unlike WRITE AND VERIFY (which we +treat simply as WRITE with FUA bit set), VERIFY cannot be handled like +READ. In fact the device is _receiving_ data for VERIFY, not _sending_ +it like READ. + +Cc: qemu-stable@nongnu.org +Tested-by: Hervé Poussineau +Signed-off-by: Paolo Bonzini +(cherry picked from commit d97e7730816094a71cd1f19a56d7a73f77cdbf96) +--- + hw/scsi/scsi-disk.c | 27 ++++++++++++++++++++------- + 1 file changed, 20 insertions(+), 7 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + hw/scsi/scsi-disk.c | 27 ++++++++++++++++++++------- + 1 files changed, 20 insertions(+), 7 deletions(-) + +diff --git a/hw/scsi/scsi-disk.c b/hw/scsi/scsi-disk.c +index c44f159..7653411 100644 +--- a/hw/scsi/scsi-disk.c ++++ b/hw/scsi/scsi-disk.c +@@ -1720,10 +1720,19 @@ static void scsi_disk_emulate_write_data(SCSIRequest *req) + scsi_disk_emulate_unmap(r, r->iov.iov_base); + break; + ++ case VERIFY_10: ++ case VERIFY_12: ++ case VERIFY_16: ++ if (r->req.status == -1) { ++ scsi_check_condition(r, SENSE_CODE(INVALID_FIELD)); ++ } ++ break; ++ + case WRITE_SAME_10: + case WRITE_SAME_16: + scsi_disk_emulate_write_same(r, r->iov.iov_base); + break; ++ + default: + abort(); + } +@@ -1964,6 +1973,14 @@ static int32_t scsi_disk_emulate_command(SCSIRequest *req, uint8_t *buf) + case UNMAP: + DPRINTF("Unmap (len %lu)\n", (long)r->req.cmd.xfer); + break; ++ case VERIFY_10: ++ case VERIFY_12: ++ case VERIFY_16: ++ DPRINTF("Verify (bytchk %lu)\n", (r->req.buf[1] >> 1) & 3); ++ if (req->cmd.buf[1] & 6) { ++ goto illegal_request; ++ } ++ break; + case WRITE_SAME_10: + case WRITE_SAME_16: + DPRINTF("WRITE SAME %d (len %lu)\n", +@@ -2044,10 +2061,6 @@ static int32_t scsi_disk_dma_command(SCSIRequest *req, uint8_t *buf) + scsi_check_condition(r, SENSE_CODE(WRITE_PROTECTED)); + return 0; + } +- /* fallthrough */ +- case VERIFY_10: +- case VERIFY_12: +- case VERIFY_16: + DPRINTF("Write %s(sector %" PRId64 ", count %u)\n", + (command & 0xe) == 0xe ? "And Verify " : "", + r->req.cmd.lba, len); +@@ -2315,14 +2328,14 @@ static const SCSIReqOps *const scsi_disk_reqops_dispatch[256] = { + [UNMAP] = &scsi_disk_emulate_reqops, + [WRITE_SAME_10] = &scsi_disk_emulate_reqops, + [WRITE_SAME_16] = &scsi_disk_emulate_reqops, ++ [VERIFY_10] = &scsi_disk_emulate_reqops, ++ [VERIFY_12] = &scsi_disk_emulate_reqops, ++ [VERIFY_16] = &scsi_disk_emulate_reqops, + + [READ_6] = &scsi_disk_dma_reqops, + [READ_10] = &scsi_disk_dma_reqops, + [READ_12] = &scsi_disk_dma_reqops, + [READ_16] = &scsi_disk_dma_reqops, +- [VERIFY_10] = &scsi_disk_dma_reqops, +- [VERIFY_12] = &scsi_disk_dma_reqops, +- [VERIFY_16] = &scsi_disk_dma_reqops, + [WRITE_6] = &scsi_disk_dma_reqops, + [WRITE_10] = &scsi_disk_dma_reqops, + [WRITE_12] = &scsi_disk_dma_reqops, +-- +1.7.1 + diff --git a/SOURCES/kvm-scsi-disk-fix-WRITE-SAME-with-large-non-zero-payload.patch.patch.patch b/SOURCES/kvm-scsi-disk-fix-WRITE-SAME-with-large-non-zero-payload.patch.patch.patch new file mode 100644 index 0000000..3fb0993 --- /dev/null +++ b/SOURCES/kvm-scsi-disk-fix-WRITE-SAME-with-large-non-zero-payload.patch.patch.patch @@ -0,0 +1,46 @@ +From 7239bc0ab3b7be4dabb0e65a19c0618ce0a6a171 Mon Sep 17 00:00:00 2001 +Message-Id: <7239bc0ab3b7be4dabb0e65a19c0618ce0a6a171.1389014116.git.minovotn@redhat.com> +In-Reply-To: +References: +From: Paolo Bonzini +Date: Mon, 9 Dec 2013 14:09:26 +0100 +Subject: [PATCH 38/50] scsi-disk: fix WRITE SAME with large non-zero payload + +RH-Author: Paolo Bonzini +Message-id: <1386598178-11845-41-git-send-email-pbonzini@redhat.com> +Patchwork-id: 56077 +O-Subject: [RHEL 7.0 qemu-kvm PATCH 40/52] scsi-disk: fix WRITE SAME with large non-zero payload +Bugzilla: 1007815 +RH-Acked-by: Jeffrey Cody +RH-Acked-by: Fam Zheng +RH-Acked-by: Stefan Hajnoczi + +Due to a thinko in the patch that implemented WRITE SAME. + +Signed-off-by: Paolo Bonzini +(cherry picked from commit 98e33f1b0eff84d9538cf957dde48c3f67f6f9d8) +--- + hw/scsi/scsi-disk.c | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +Signed-off-by: Michal Novotny +--- + hw/scsi/scsi-disk.c | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/hw/scsi/scsi-disk.c b/hw/scsi/scsi-disk.c +index efadfc0..c44f159 100644 +--- a/hw/scsi/scsi-disk.c ++++ b/hw/scsi/scsi-disk.c +@@ -1626,7 +1626,7 @@ static void scsi_write_same_complete(void *opaque, int ret) + bdrv_acct_start(s->qdev.conf.bs, &r->acct, data->iov.iov_len, BDRV_ACCT_WRITE); + r->req.aiocb = bdrv_aio_writev(s->qdev.conf.bs, data->sector, + &data->qiov, data->iov.iov_len / 512, +- scsi_write_same_complete, r); ++ scsi_write_same_complete, data); + return; + } + +-- +1.7.11.7 + diff --git a/SOURCES/kvm-scsi-disk-reject-ANCHOR-1-for-UNMAP-and-WRITE-SAME-c.patch.patch.patch b/SOURCES/kvm-scsi-disk-reject-ANCHOR-1-for-UNMAP-and-WRITE-SAME-c.patch.patch.patch new file mode 100644 index 0000000..f57486c --- /dev/null +++ b/SOURCES/kvm-scsi-disk-reject-ANCHOR-1-for-UNMAP-and-WRITE-SAME-c.patch.patch.patch @@ -0,0 +1,77 @@ +From bcf0f4b1f226bcb27e154cc14850f67229b22d90 Mon Sep 17 00:00:00 2001 +Message-Id: +In-Reply-To: +References: +From: Paolo Bonzini +Date: Mon, 9 Dec 2013 14:09:24 +0100 +Subject: [PATCH 36/50] scsi-disk: reject ANCHOR=1 for UNMAP and WRITE SAME + commands + +RH-Author: Paolo Bonzini +Message-id: <1386598178-11845-39-git-send-email-pbonzini@redhat.com> +Patchwork-id: 56075 +O-Subject: [RHEL 7.0 qemu-kvm PATCH 38/52] scsi-disk: reject ANCHOR=1 for UNMAP and WRITE SAME commands +Bugzilla: 1007815 +RH-Acked-by: Jeffrey Cody +RH-Acked-by: Fam Zheng +RH-Acked-by: Stefan Hajnoczi + +Since we report ANC_SUP==0 in VPD page B2h, we need to return +an error (ILLEGAL REQUEST/INVALID FIELD IN CDB) for all WRITE SAME +requests with ANCHOR==1. + +Inspired by a similar patch to the LIO in-kernel target. + +Signed-off-by: Paolo Bonzini +Signed-off-by: Stefan Hajnoczi +(cherry picked from commit 823bd7391c96ba675f20fd6d952d1cb6e1ffb851) +--- + hw/scsi/scsi-disk.c | 12 +++++++++++- + 1 file changed, 11 insertions(+), 1 deletion(-) + +Signed-off-by: Michal Novotny +--- + hw/scsi/scsi-disk.c | 12 +++++++++++- + 1 file changed, 11 insertions(+), 1 deletion(-) + +diff --git a/hw/scsi/scsi-disk.c b/hw/scsi/scsi-disk.c +index 4138268..0640bb0 100644 +--- a/hw/scsi/scsi-disk.c ++++ b/hw/scsi/scsi-disk.c +@@ -1548,6 +1548,11 @@ static void scsi_disk_emulate_unmap(SCSIDiskReq *r, uint8_t *inbuf) + int len = r->req.cmd.xfer; + UnmapCBData *data; + ++ /* Reject ANCHOR=1. */ ++ if (r->req.cmd.buf[1] & 0x1) { ++ goto invalid_field; ++ } ++ + if (len < 8) { + goto invalid_param_len; + } +@@ -1578,6 +1583,10 @@ static void scsi_disk_emulate_unmap(SCSIDiskReq *r, uint8_t *inbuf) + + invalid_param_len: + scsi_check_condition(r, SENSE_CODE(INVALID_PARAM_LEN)); ++ return; ++ ++invalid_field: ++ scsi_check_condition(r, SENSE_CODE(INVALID_FIELD)); + } + + static void scsi_disk_emulate_write_data(SCSIRequest *req) +@@ -1856,8 +1865,9 @@ static int32_t scsi_disk_emulate_command(SCSIRequest *req, uint8_t *buf) + + /* + * We only support WRITE SAME with the unmap bit set for now. ++ * Reject UNMAP=0 or ANCHOR=1. + */ +- if (!(req->cmd.buf[1] & 0x8)) { ++ if (!(req->cmd.buf[1] & 0x8) || (req->cmd.buf[1] & 0x10)) { + goto illegal_request; + } + +-- +1.7.11.7 + diff --git a/SOURCES/kvm-seccomp-add-kill-to-the-syscall-whitelist.patch b/SOURCES/kvm-seccomp-add-kill-to-the-syscall-whitelist.patch new file mode 100644 index 0000000..79e8d69 --- /dev/null +++ b/SOURCES/kvm-seccomp-add-kill-to-the-syscall-whitelist.patch @@ -0,0 +1,73 @@ +From 2735c1f0c0ae68933112a98bf5a5c6d22486c74f Mon Sep 17 00:00:00 2001 +Message-Id: <2735c1f0c0ae68933112a98bf5a5c6d22486c74f.1387369730.git.minovotn@redhat.com> +In-Reply-To: <091eecc4fa42754760dfff393dabcc2b444e9693.1387369730.git.minovotn@redhat.com> +References: <091eecc4fa42754760dfff393dabcc2b444e9693.1387369730.git.minovotn@redhat.com> +From: Paul Moore +Date: Tue, 3 Dec 2013 16:04:48 +0100 +Subject: [PATCH 03/21] seccomp: add kill() to the syscall whitelist + +RH-Author: Paul Moore +Message-id: <20131203160448.1445.78917.stgit@localhost> +Patchwork-id: 55976 +O-Subject: [RHEL7 qemu-kvm PATCH] seccomp: add kill() to the syscall whitelist +Bugzilla: 1026314 +RH-Acked-by: Bandan Das +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: knoel@redhat.com + +Bugzilla: https://bugzilla.redhat.com/show_bug.cgi?id=1026314 +Brew: https://brewweb.devel.redhat.com/taskinfo?taskID=6672333 +Upstream: In QEMU/seccomp maintainer's tree + git://github.com/otubo/qemu.git#seccomp +Tested: Tested by myself, IBM, and original BZ reporter, see BZ + + commit: e9eecb5bf82a71564bf018fcbbfc6cda19cab6c2 + From: Paul Moore + Date: 2013-11-20 11:12:17 -0500 + + seccomp: add kill() to the syscall whitelist + + The kill() syscall is triggered with the following command: + + # qemu -sandbox on -monitor stdio \ + -device intel-hda -device hda-duplex -vnc :0 + + The resulting syslog/audit message: + + # ausearch -m SECCOMP + ---- + time->Wed Nov 20 09:52:08 2013 + type=SECCOMP msg=audit(1384912328.482:6656): auid=0 uid=0 gid=0 ses=854 + subj=unconfined_u:unconfined_r:unconfined_t:s0-s0:c0.c1023 pid=12087 + comm="qemu-kvm" sig=31 syscall=62 compat=0 ip=0x7f7a1d2abc67 code=0x0 + # scmp_sys_resolver 62 + kill + + Reported-by: CongLi + Tested-by: CongLi + Signed-off-by: Paul Moore + Acked-by: Eduardo Otubo +--- + qemu-seccomp.c | 1 + + 1 file changed, 1 insertion(+) + +Signed-off-by: Michal Novotny +--- + qemu-seccomp.c | 1 + + 1 file changed, 1 insertion(+) + +diff --git a/qemu-seccomp.c b/qemu-seccomp.c +index ca15f21..906101f 100644 +--- a/qemu-seccomp.c ++++ b/qemu-seccomp.c +@@ -123,6 +123,7 @@ static const struct QemuSeccompSyscall seccomp_whitelist[] = { + { SCMP_SYS(write), 244 }, + { SCMP_SYS(fcntl), 243 }, + { SCMP_SYS(tgkill), 242 }, ++ { SCMP_SYS(kill), 242 }, + { SCMP_SYS(rt_sigaction), 242 }, + { SCMP_SYS(pipe2), 242 }, + { SCMP_SYS(munmap), 242 }, +-- +1.7.11.7 + diff --git a/SOURCES/kvm-seccomp-add-mkdir-and-fchmod-to-the-whitelist.patch b/SOURCES/kvm-seccomp-add-mkdir-and-fchmod-to-the-whitelist.patch new file mode 100644 index 0000000..0d7cec0 --- /dev/null +++ b/SOURCES/kvm-seccomp-add-mkdir-and-fchmod-to-the-whitelist.patch @@ -0,0 +1,62 @@ +From 45031cfb033d0c3941f48acb8c46861f756ab700 Mon Sep 17 00:00:00 2001 +From: Paul Moore +Date: Mon, 27 Jan 2014 21:43:11 +0100 +Subject: [PATCH 01/28] seccomp: add mkdir() and fchmod() to the whitelist + +RH-Author: Paul Moore +Message-id: <20140127214311.24608.57759.stgit@localhost> +Patchwork-id: 56966 +O-Subject: [RHEL7 qemu-kvm PATCH 1/2] seccomp: add mkdir() and fchmod() to the whitelist +Bugzilla: 1026314 +RH-Acked-by: Laszlo Ersek +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Juan Quintela + +Bugzilla: https://bugzilla.redhat.com/show_bug.cgi?id=1026314 +Brew: https://brewweb.devel.redhat.com/taskinfo?taskID=6956172 +Upstream: upstream, see commit IDs +Testing: tested, see BZ + + seccomp: add mkdir() and fchmod() to the whitelist + + The PulseAudio library attempts to do a mkdir(2) and fchmod(2) on + "/run/user//pulse" which is currently blocked by the syscall + filter; this patch adds the two missing syscalls to the whitelist. + You can reproduce this problem with the following command: + + # qemu -monitor stdio -device intel-hda -device hda-duplex + + If watched under strace the following syscalls are shown: + + mkdir("/run/user/0/pulse", 0700) + fchmod(11, 0700) [NOTE: 11 is the fd for /run/user/0/pulse] + + Reported-by: xuhan@redhat.com + Signed-off-by: Paul Moore +--- + qemu-seccomp.c | 4 +++- + 1 file changed, 3 insertions(+), 1 deletion(-) + +Signed-off-by: Miroslav Rezanina +--- + qemu-seccomp.c | 4 +++- + 1 files changed, 3 insertions(+), 1 deletions(-) + +diff --git a/qemu-seccomp.c b/qemu-seccomp.c +index fc48bdd..34a54e4 100644 +--- a/qemu-seccomp.c ++++ b/qemu-seccomp.c +@@ -237,7 +237,9 @@ static const struct QemuSeccompSyscall seccomp_whitelist[] = { + { SCMP_SYS(io_cancel), 241 }, + { SCMP_SYS(io_setup), 241 }, + { SCMP_SYS(io_destroy), 241 }, +- { SCMP_SYS(arch_prctl), 240 } ++ { SCMP_SYS(arch_prctl), 240 }, ++ { SCMP_SYS(mkdir), 240 }, ++ { SCMP_SYS(fchmod), 240 } + }; + + int seccomp_start(void) +-- +1.7.1 + diff --git a/SOURCES/kvm-seccomp-add-some-basic-shared-memory-syscalls-to-the.patch b/SOURCES/kvm-seccomp-add-some-basic-shared-memory-syscalls-to-the.patch new file mode 100644 index 0000000..164ad5b --- /dev/null +++ b/SOURCES/kvm-seccomp-add-some-basic-shared-memory-syscalls-to-the.patch @@ -0,0 +1,54 @@ +From 38a4a6fb83fc002980bda2b47662997181607579 Mon Sep 17 00:00:00 2001 +From: Paul Moore +Date: Mon, 27 Jan 2014 21:43:17 +0100 +Subject: [PATCH 02/28] seccomp: add some basic shared memory syscalls to the whitelist + +RH-Author: Paul Moore +Message-id: <20140127214317.24608.67441.stgit@localhost> +Patchwork-id: 56967 +O-Subject: [RHEL7 qemu-kvm PATCH 2/2] seccomp: add some basic shared memory syscalls to the whitelist +Bugzilla: 1026314 +RH-Acked-by: Laszlo Ersek +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Juan Quintela + +Bugzilla: https://bugzilla.redhat.com/show_bug.cgi?id=1026314 +Brew: https://brewweb.devel.redhat.com/taskinfo?taskID=6956172 +Upstream: upstream, see commit IDs +Testing: tested, see BZ + + seccomp: add some basic shared memory syscalls to the whitelist + + PulseAudio requires the use of shared memory so add shmget(), shmat(), + and shmdt() to the syscall whitelist. + + Reported-by: xuhan@redhat.com + Signed-off-by: Paul Moore +--- + qemu-seccomp.c | 5 ++++- + 1 file changed, 4 insertions(+), 1 deletion(-) + +Signed-off-by: Miroslav Rezanina +--- + qemu-seccomp.c | 5 ++++- + 1 files changed, 4 insertions(+), 1 deletions(-) + +diff --git a/qemu-seccomp.c b/qemu-seccomp.c +index 34a54e4..3a2fbed 100644 +--- a/qemu-seccomp.c ++++ b/qemu-seccomp.c +@@ -239,7 +239,10 @@ static const struct QemuSeccompSyscall seccomp_whitelist[] = { + { SCMP_SYS(io_destroy), 241 }, + { SCMP_SYS(arch_prctl), 240 }, + { SCMP_SYS(mkdir), 240 }, +- { SCMP_SYS(fchmod), 240 } ++ { SCMP_SYS(fchmod), 240 }, ++ { SCMP_SYS(shmget), 240 }, ++ { SCMP_SYS(shmat), 240 }, ++ { SCMP_SYS(shmdt), 240 } + }; + + int seccomp_start(void) +-- +1.7.1 + diff --git a/SOURCES/kvm-seccomp-exit-if-seccomp_init-fails.patch b/SOURCES/kvm-seccomp-exit-if-seccomp_init-fails.patch new file mode 100644 index 0000000..03cdea7 --- /dev/null +++ b/SOURCES/kvm-seccomp-exit-if-seccomp_init-fails.patch @@ -0,0 +1,55 @@ +From 77b56ef5c4488f32151018c06443c701d6173ce7 Mon Sep 17 00:00:00 2001 +From: Paul Moore +Date: Fri, 20 Dec 2013 21:43:16 +0100 +Subject: [PATCH 04/16] seccomp: exit if seccomp_init() fails + +RH-Author: Paul Moore +Message-id: <20131220214316.2542.64440.stgit@localhost> +Patchwork-id: 56418 +O-Subject: [RHEL7 qemu-kvm PATCH] seccomp: exit if seccomp_init() fails +Bugzilla: 1044845 +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Markus Armbruster +RH-Acked-by: Laszlo Ersek + +From: Corey Bryant + +Bugzilla: https://bugzilla.redhat.com/show_bug.cgi?id=1044845 +Brew: https://brewweb.devel.redhat.com/taskinfo?taskID=6770015 +Upstream: merged into the QEMU seccomp tree + git://github.com/otubo/qemu.git seccomp +Testing: Tested by IBM, see BZ + + seccomp: exit if seccomp_init() fails + + This fixes a bug where we weren't exiting if seccomp_init() failed. + + Signed-off-by: Corey Bryant + Acked-by: Eduardo Otubo + Acked-by: Paul Moore + (cherry picked from commit 2a13f991123fa16841e6d94b02a9cc2c76d91725) + Signed-off-by: Paul Moore +--- + qemu-seccomp.c | 1 + + 1 file changed, 1 insertion(+) + +Signed-off-by: Miroslav Rezanina +--- + qemu-seccomp.c | 1 + + 1 files changed, 1 insertions(+), 0 deletions(-) + +diff --git a/qemu-seccomp.c b/qemu-seccomp.c +index 906101f..fc48bdd 100644 +--- a/qemu-seccomp.c ++++ b/qemu-seccomp.c +@@ -248,6 +248,7 @@ int seccomp_start(void) + + ctx = seccomp_init(SCMP_ACT_KILL); + if (ctx == NULL) { ++ rc = -1; + goto seccomp_return; + } + +-- +1.7.1 + diff --git a/SOURCES/kvm-size-off-by-one.patch b/SOURCES/kvm-size-off-by-one.patch new file mode 100644 index 0000000..3d30ba8 --- /dev/null +++ b/SOURCES/kvm-size-off-by-one.patch @@ -0,0 +1,118 @@ +From cac9ac8f0173f95893fbc62fa67fcf04e4c76f5f Mon Sep 17 00:00:00 2001 +From: Stefan Hajnoczi +Date: Tue, 25 Mar 2014 14:23:15 +0100 +Subject: [PATCH 08/49] size off-by-one + +RH-Author: Kevin Wolf +Message-id: <1395753835-7591-9-git-send-email-kwolf@redhat.com> +Patchwork-id: n/a +O-Subject: [virt-devel] [EMBARGOED RHEL-7.0 qemu-kvm PATCH 08/48] block/cloop: fix offsets[] size off-by-one +Bugzilla: 1066691 +RH-Acked-by: Jeff Cody +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Paolo Bonzini + +From: Stefan Hajnoczi + +Bugzilla: https://bugzilla.redhat.com/show_bug.cgi?id=1066691 +Upstream status: Series embargoed + +cloop stores the number of compressed blocks in the n_blocks header +field. The file actually contains n_blocks + 1 offsets, where the extra +offset is the end-of-file offset. + +The following line in cloop_read_block() results in an out-of-bounds +offsets[] access: + +uint32_t bytes = s->offsets[block_num + 1] - s->offsets[block_num]; + +This patch allocates and loads the extra offset so that +cloop_read_block() works correctly when the last block is accessed. + +Notice that we must free s->offsets[] unconditionally now since there is +always an end-of-file offset. + +Signed-off-by: Stefan Hajnoczi +Signed-off-by: Kevin Wolf +--- + block/cloop.c | 12 +++++------- + tests/qemu-iotests/075 | 5 +++++ + tests/qemu-iotests/075.out | 4 ++++ + 3 files changed, 14 insertions(+), 7 deletions(-) + +diff --git a/block/cloop.c b/block/cloop.c +index 55a804f..b6ad50f 100644 +--- a/block/cloop.c ++++ b/block/cloop.c +@@ -99,14 +99,14 @@ static int cloop_open(BlockDriverState *bs, QDict *options, int flags, + s->n_blocks = be32_to_cpu(s->n_blocks); + + /* read offsets */ +- if (s->n_blocks > UINT32_MAX / sizeof(uint64_t)) { ++ if (s->n_blocks > (UINT32_MAX - 1) / sizeof(uint64_t)) { + /* Prevent integer overflow */ + error_setg(errp, "n_blocks %u must be %zu or less", + s->n_blocks, +- UINT32_MAX / sizeof(uint64_t)); ++ (UINT32_MAX - 1) / sizeof(uint64_t)); + return -EINVAL; + } +- offsets_size = s->n_blocks * sizeof(uint64_t); ++ offsets_size = (s->n_blocks + 1) * sizeof(uint64_t); + if (offsets_size > 512 * 1024 * 1024) { + /* Prevent ridiculous offsets_size which causes memory allocation to + * fail or overflows bdrv_pread() size. In practice the 512 MB +@@ -123,7 +123,7 @@ static int cloop_open(BlockDriverState *bs, QDict *options, int flags, + goto fail; + } + +- for(i=0;in_blocks;i++) { ++ for (i = 0; i < s->n_blocks + 1; i++) { + uint64_t size; + + s->offsets[i] = be64_to_cpu(s->offsets[i]); +@@ -243,9 +243,7 @@ static coroutine_fn int cloop_co_read(BlockDriverState *bs, int64_t sector_num, + static void cloop_close(BlockDriverState *bs) + { + BDRVCloopState *s = bs->opaque; +- if (s->n_blocks > 0) { +- g_free(s->offsets); +- } ++ g_free(s->offsets); + g_free(s->compressed_block); + g_free(s->uncompressed_block); + inflateEnd(&s->zstream); +diff --git a/tests/qemu-iotests/075 b/tests/qemu-iotests/075 +index d74fb33..40032c5 100755 +--- a/tests/qemu-iotests/075 ++++ b/tests/qemu-iotests/075 +@@ -52,6 +52,11 @@ _use_sample_img simple-pattern.cloop.bz2 + $QEMU_IO -c "read 0 512" $TEST_IMG 2>&1 | _filter_qemu_io | _filter_testdir + + echo ++echo "== check that the last sector can be read ==" ++_use_sample_img simple-pattern.cloop.bz2 ++$QEMU_IO -c "read $((1024 * 1024 - 512)) 512" $TEST_IMG 2>&1 | _filter_qemu_io | _filter_testdir ++ ++echo + echo "== block_size must be a multiple of 512 ==" + _use_sample_img simple-pattern.cloop.bz2 + poke_file "$TEST_IMG" "$block_size_offset" "\x00\x00\x02\x01" +diff --git a/tests/qemu-iotests/075.out b/tests/qemu-iotests/075.out +index 911cd3b..5f1d6c1 100644 +--- a/tests/qemu-iotests/075.out ++++ b/tests/qemu-iotests/075.out +@@ -4,6 +4,10 @@ QA output created by 075 + read 512/512 bytes at offset 0 + 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) + ++== check that the last sector can be read == ++read 512/512 bytes at offset 1048064 ++512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) ++ + == block_size must be a multiple of 512 == + qemu-io: can't open device TEST_DIR/simple-pattern.cloop: block_size 513 must be a multiple of 512 + no file open, try 'help open' +-- +1.7.1 + diff --git a/SOURCES/kvm-slavio_misc-Fix-slavio_led_mem_readw-_writew-tracepo.patch b/SOURCES/kvm-slavio_misc-Fix-slavio_led_mem_readw-_writew-tracepo.patch new file mode 100644 index 0000000..1c1a1b8 --- /dev/null +++ b/SOURCES/kvm-slavio_misc-Fix-slavio_led_mem_readw-_writew-tracepo.patch @@ -0,0 +1,50 @@ +From bd6746591d0d325933ef99cf67eff755974136d7 Mon Sep 17 00:00:00 2001 +Message-Id: +In-Reply-To: +References: +From: Markus Armbruster +Date: Tue, 10 Dec 2013 15:12:51 +0100 +Subject: [PATCH 10/16] slavio_misc: Fix slavio_led_mem_readw/_writew + tracepoints + +RH-Author: Markus Armbruster +Message-id: <1386688376-29521-3-git-send-email-armbru@redhat.com> +Patchwork-id: 56113 +O-Subject: [PATCH 7.0 qemu-kvm 2/7] slavio_misc: Fix slavio_led_mem_readw/_writew tracepoints +Bugzilla: 997832 +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Eduardo Habkost +RH-Acked-by: Laszlo Ersek + +From: Markus Armbruster + +Broken since they got added in commit 97bf485. + +Signed-off-by: Markus Armbruster +Signed-off-by: Stefan Hajnoczi +(cherry picked from commit f3a64b8c89ac9b5111f97e2653d249e4668764b3) +--- + hw/misc/slavio_misc.c | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +Signed-off-by: Michal Novotny +--- + hw/misc/slavio_misc.c | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/hw/misc/slavio_misc.c b/hw/misc/slavio_misc.c +index a7a9368..3571850 100644 +--- a/hw/misc/slavio_misc.c ++++ b/hw/misc/slavio_misc.c +@@ -368,7 +368,7 @@ static void slavio_led_mem_writew(void *opaque, hwaddr addr, + { + MiscState *s = opaque; + +- trace_slavio_led_mem_readw(val & 0xffff); ++ trace_slavio_led_mem_writew(val & 0xffff); + switch (addr) { + case 0: + s->leds = val; +-- +1.7.11.7 + diff --git a/SOURCES/kvm-ssdt-fix-PBLK-length.patch b/SOURCES/kvm-ssdt-fix-PBLK-length.patch new file mode 100644 index 0000000..d0263a1 --- /dev/null +++ b/SOURCES/kvm-ssdt-fix-PBLK-length.patch @@ -0,0 +1,50 @@ +From 58ee433311cbd3f767efba8d062a84dead7ce44e Mon Sep 17 00:00:00 2001 +Message-Id: <58ee433311cbd3f767efba8d062a84dead7ce44e.1387298827.git.minovotn@redhat.com> +In-Reply-To: <3ed0fb61a3dc912ef036d7ef450bed192090709e.1387298827.git.minovotn@redhat.com> +References: <3ed0fb61a3dc912ef036d7ef450bed192090709e.1387298827.git.minovotn@redhat.com> +From: "Michael S. Tsirkin" +Date: Tue, 17 Dec 2013 15:19:11 +0100 +Subject: [PATCH 49/56] ssdt: fix PBLK length + +RH-Author: Michael S. Tsirkin +Message-id: <1387293161-4085-50-git-send-email-mst@redhat.com> +Patchwork-id: 56355 +O-Subject: [PATCH qemu-kvm RHEL7.0 v2 49/57] ssdt: fix PBLK length +Bugzilla: 1034876 +RH-Acked-by: Igor Mammedov +RH-Acked-by: Marcel Apfelbaum +RH-Acked-by: Laszlo Ersek + +We don't really support CPU throttling, so supply 0 PBLK length. + +Reviewed-by: Gerd Hoffmann +Tested-by: Gerd Hoffmann +Reviewed-by: Igor Mammedov +Tested-by: Igor Mammedov +Signed-off-by: Michael S. Tsirkin +(cherry picked from commit 6ec80ef1502e90d19b90f021514debe32c8689a8) +--- + hw/i386/ssdt-proc.dsl | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +Signed-off-by: Michal Novotny +--- + hw/i386/ssdt-proc.dsl | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/hw/i386/ssdt-proc.dsl b/hw/i386/ssdt-proc.dsl +index 58333c7..8229bfd 100644 +--- a/hw/i386/ssdt-proc.dsl ++++ b/hw/i386/ssdt-proc.dsl +@@ -37,7 +37,7 @@ DefinitionBlock ("ssdt-proc.aml", "SSDT", 0x01, "BXPC", "BXSSDT", 0x1) + ACPI_EXTRACT_PROCESSOR_START ssdt_proc_start + ACPI_EXTRACT_PROCESSOR_END ssdt_proc_end + ACPI_EXTRACT_PROCESSOR_STRING ssdt_proc_name +- Processor(CPAA, 0xAA, 0x0000b010, 0x06) { ++ Processor(CPAA, 0xAA, 0x00000000, 0x0) { + ACPI_EXTRACT_NAME_BYTE_CONST ssdt_proc_id + Name(ID, 0xAA) + /* +-- +1.7.11.7 + diff --git a/SOURCES/kvm-ssdt-proc-update-generated-file.patch b/SOURCES/kvm-ssdt-proc-update-generated-file.patch new file mode 100644 index 0000000..900f2e8 --- /dev/null +++ b/SOURCES/kvm-ssdt-proc-update-generated-file.patch @@ -0,0 +1,73 @@ +From 7677a5cbf45e70853de5e5af2de447ff585aee39 Mon Sep 17 00:00:00 2001 +Message-Id: <7677a5cbf45e70853de5e5af2de447ff585aee39.1387298827.git.minovotn@redhat.com> +In-Reply-To: <3ed0fb61a3dc912ef036d7ef450bed192090709e.1387298827.git.minovotn@redhat.com> +References: <3ed0fb61a3dc912ef036d7ef450bed192090709e.1387298827.git.minovotn@redhat.com> +From: "Michael S. Tsirkin" +Date: Tue, 17 Dec 2013 15:19:13 +0100 +Subject: [PATCH 50/56] ssdt-proc: update generated file + +RH-Author: Michael S. Tsirkin +Message-id: <1387293161-4085-51-git-send-email-mst@redhat.com> +Patchwork-id: 56356 +O-Subject: [PATCH qemu-kvm RHEL7.0 v2 50/57] ssdt-proc: update generated file +Bugzilla: 1034876 +RH-Acked-by: Igor Mammedov +RH-Acked-by: Marcel Apfelbaum +RH-Acked-by: Laszlo Ersek + +Update generated ssdt proc hex file (used for systems +lacking IASL) after P_BLK length change. + +Reviewed-by: Gerd Hoffmann +Tested-by: Gerd Hoffmann +Reviewed-by: Igor Mammedov +Tested-by: Igor Mammedov +Signed-off-by: Michael S. Tsirkin +(cherry picked from commit 742f5d2ed578bb53b2130b6da2c66de9929f4821) +--- + hw/i386/ssdt-proc.hex.generated | 10 +++++----- + 1 file changed, 5 insertions(+), 5 deletions(-) + +Signed-off-by: Michal Novotny +--- + hw/i386/ssdt-proc.hex.generated | 10 +++++----- + 1 file changed, 5 insertions(+), 5 deletions(-) + +diff --git a/hw/i386/ssdt-proc.hex.generated b/hw/i386/ssdt-proc.hex.generated +index a28172e..bb9920d 100644 +--- a/hw/i386/ssdt-proc.hex.generated ++++ b/hw/i386/ssdt-proc.hex.generated +@@ -11,7 +11,7 @@ static unsigned char ssdp_proc_aml[] = { + 0x0, + 0x0, + 0x1, +-0xb3, ++0xb8, + 0x42, + 0x58, + 0x50, +@@ -34,9 +34,9 @@ static unsigned char ssdp_proc_aml[] = { + 0x4e, + 0x54, + 0x4c, +-0x28, +-0x5, +-0x10, ++0x23, ++0x8, ++0x13, + 0x20, + 0x5b, + 0x83, +@@ -51,7 +51,7 @@ static unsigned char ssdp_proc_aml[] = { + 0xb0, + 0x0, + 0x0, +-0x6, ++0x0, + 0x8, + 0x49, + 0x44, +-- +1.7.11.7 + diff --git a/SOURCES/kvm-support-using-KVM_MEM_READONLY-flag-for-regions.patch b/SOURCES/kvm-support-using-KVM_MEM_READONLY-flag-for-regions.patch new file mode 100644 index 0000000..d6b4b42 --- /dev/null +++ b/SOURCES/kvm-support-using-KVM_MEM_READONLY-flag-for-regions.patch @@ -0,0 +1,158 @@ +From 8140691df300c06f99981832cf2f19a2e5e5d0b9 Mon Sep 17 00:00:00 2001 +From: Laszlo Ersek +Date: Sat, 11 Jan 2014 17:59:57 +0100 +Subject: [PATCH 07/22] kvm: support using KVM_MEM_READONLY flag for regions + +RH-Author: Laszlo Ersek +Message-id: <1389463208-6278-8-git-send-email-lersek@redhat.com> +Patchwork-id: 56619 +O-Subject: [RHEL-7.0 qemu-kvm PATCH 07/18] kvm: support using KVM_MEM_READONLY flag for regions +Bugzilla: 1032346 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Amos Kong +RH-Acked-by: Andrew Jones + +From: Jordan Justen + +For readonly memory regions and rom devices in romd_mode, +we make use of the KVM_MEM_READONLY. A slot that uses +KVM_MEM_READONLY can be read from and code can execute from the +region, but writes will exit to qemu. + +For rom devices with !romd_mode, we force the slot to be +removed so reads or writes to the region will exit to qemu. +(Note that a memory region in this state is not executable +within kvm.) + +v7: + * Update for readable => romd_mode rename (5f9a5ea1) + +Signed-off-by: Jordan Justen +Reviewed-by: Xiao Guangrong (v4) +Reviewed-by: Paolo Bonzini (v5) +Message-id: 1369816047-16384-4-git-send-email-jordan.l.justen@intel.com +Signed-off-by: Anthony Liguori +(cherry picked from commit 235e8982ad393e5611cb892df54881c872eea9e1) +Signed-off-by: Laszlo Ersek +--- + kvm-all.c | 37 ++++++++++++++++++++++++++++--------- + 1 file changed, 28 insertions(+), 9 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + kvm-all.c | 37 ++++++++++++++++++++++++++++--------- + 1 files changed, 28 insertions(+), 9 deletions(-) + +diff --git a/kvm-all.c b/kvm-all.c +index 0a70ca1..42c71b9 100644 +--- a/kvm-all.c ++++ b/kvm-all.c +@@ -203,12 +203,18 @@ static int kvm_set_user_memory_region(KVMState *s, KVMSlot *slot) + + mem.slot = slot->slot; + mem.guest_phys_addr = slot->start_addr; +- mem.memory_size = slot->memory_size; + mem.userspace_addr = (unsigned long)slot->ram; + mem.flags = slot->flags; + if (s->migration_log) { + mem.flags |= KVM_MEM_LOG_DIRTY_PAGES; + } ++ if (mem.flags & KVM_MEM_READONLY) { ++ /* Set the slot size to 0 before setting the slot to the desired ++ * value. This is needed based on KVM commit 75d61fbc. */ ++ mem.memory_size = 0; ++ kvm_vm_ioctl(s, KVM_SET_USER_MEMORY_REGION, &mem); ++ } ++ mem.memory_size = slot->memory_size; + return kvm_vm_ioctl(s, KVM_SET_USER_MEMORY_REGION, &mem); + } + +@@ -270,9 +276,14 @@ err: + * dirty pages logging control + */ + +-static int kvm_mem_flags(KVMState *s, bool log_dirty) ++static int kvm_mem_flags(KVMState *s, bool log_dirty, bool readonly) + { +- return log_dirty ? KVM_MEM_LOG_DIRTY_PAGES : 0; ++ int flags = 0; ++ flags = log_dirty ? KVM_MEM_LOG_DIRTY_PAGES : 0; ++ if (readonly && kvm_readonly_mem_allowed) { ++ flags |= KVM_MEM_READONLY; ++ } ++ return flags; + } + + static int kvm_slot_dirty_pages_log_change(KVMSlot *mem, bool log_dirty) +@@ -283,7 +294,7 @@ static int kvm_slot_dirty_pages_log_change(KVMSlot *mem, bool log_dirty) + + old_flags = mem->flags; + +- flags = (mem->flags & ~mask) | kvm_mem_flags(s, log_dirty); ++ flags = (mem->flags & ~mask) | kvm_mem_flags(s, log_dirty, false); + mem->flags = flags; + + /* If nothing changed effectively, no need to issue ioctl */ +@@ -601,6 +612,8 @@ static void kvm_set_phys_mem(MemoryRegionSection *section, bool add) + int err; + MemoryRegion *mr = section->mr; + bool log_dirty = memory_region_is_logging(mr); ++ bool writeable = !mr->readonly && !mr->rom_device; ++ bool readonly_flag = mr->readonly || memory_region_is_romd(mr); + hwaddr start_addr = section->offset_within_address_space; + ram_addr_t size = section->size; + void *ram = NULL; +@@ -620,7 +633,13 @@ static void kvm_set_phys_mem(MemoryRegionSection *section, bool add) + } + + if (!memory_region_is_ram(mr)) { +- return; ++ if (writeable || !kvm_readonly_mem_allowed) { ++ return; ++ } else if (!mr->romd_mode) { ++ /* If the memory device is not in romd_mode, then we actually want ++ * to remove the kvm memory slot so all accesses will trap. */ ++ add = false; ++ } + } + + ram = memory_region_get_ram_ptr(mr) + section->offset_within_region + delta; +@@ -669,7 +688,7 @@ static void kvm_set_phys_mem(MemoryRegionSection *section, bool add) + mem->memory_size = old.memory_size; + mem->start_addr = old.start_addr; + mem->ram = old.ram; +- mem->flags = kvm_mem_flags(s, log_dirty); ++ mem->flags = kvm_mem_flags(s, log_dirty, readonly_flag); + + err = kvm_set_user_memory_region(s, mem); + if (err) { +@@ -690,7 +709,7 @@ static void kvm_set_phys_mem(MemoryRegionSection *section, bool add) + mem->memory_size = start_addr - old.start_addr; + mem->start_addr = old.start_addr; + mem->ram = old.ram; +- mem->flags = kvm_mem_flags(s, log_dirty); ++ mem->flags = kvm_mem_flags(s, log_dirty, readonly_flag); + + err = kvm_set_user_memory_region(s, mem); + if (err) { +@@ -714,7 +733,7 @@ static void kvm_set_phys_mem(MemoryRegionSection *section, bool add) + size_delta = mem->start_addr - old.start_addr; + mem->memory_size = old.memory_size - size_delta; + mem->ram = old.ram + size_delta; +- mem->flags = kvm_mem_flags(s, log_dirty); ++ mem->flags = kvm_mem_flags(s, log_dirty, readonly_flag); + + err = kvm_set_user_memory_region(s, mem); + if (err) { +@@ -736,7 +755,7 @@ static void kvm_set_phys_mem(MemoryRegionSection *section, bool add) + mem->memory_size = size; + mem->start_addr = start_addr; + mem->ram = ram; +- mem->flags = kvm_mem_flags(s, log_dirty); ++ mem->flags = kvm_mem_flags(s, log_dirty, readonly_flag); + + err = kvm_set_user_memory_region(s, mem); + if (err) { +-- +1.7.1 + diff --git a/SOURCES/kvm-switch-rhel7-machine-types-to-big-bios.patch b/SOURCES/kvm-switch-rhel7-machine-types-to-big-bios.patch new file mode 100644 index 0000000..59c487b --- /dev/null +++ b/SOURCES/kvm-switch-rhel7-machine-types-to-big-bios.patch @@ -0,0 +1,53 @@ +From a1a0f3cf9b80f1d13f7dc10cf540c1ca19570b70 Mon Sep 17 00:00:00 2001 +From: Gerd Hoffmann +Date: Thu, 16 Jan 2014 09:31:59 -0500 +Subject: [PATCH 09/14] switch rhel7 machine types to big bios. + +Message-id: <1389864720-14128-3-git-send-email-kraxel@redhat.com> +Patchwork-id: 56737 +O-Subject: [RHEL-7 qemu-kvm PATCH 2/3] switch rhel7 machine types to big bios. +Bugzilla: 1038603 +RH-Acked-by: Orit Wasserman +RH-Acked-by: Miroslav Rezanina +RH-Acked-by: Laszlo Ersek + +related upstream commit: bcf2b7d2af7c54bb42be1229df9e78ba7d08d2a7 + +Signed-off-by: Gerd Hoffmann +--- + hw/i386/pc_piix.c | 1 + + hw/i386/pc_q35.c | 1 + + redhat/qemu-kvm.spec.template | 6 ++++-- + 3 files changed, 6 insertions(+), 2 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + hw/i386/pc_piix.c | 1 + + hw/i386/pc_q35.c | 1 + + redhat/qemu-kvm.spec.template | 6 ++++-- + 3 files changed, 6 insertions(+), 2 deletions(-) + +diff --git a/hw/i386/pc_piix.c b/hw/i386/pc_piix.c +index 29c013a..e061877 100644 +--- a/hw/i386/pc_piix.c ++++ b/hw/i386/pc_piix.c +@@ -756,6 +756,7 @@ static QEMUMachine pc_machine_rhel700 = { + .hot_add_cpu = pc_hot_add_cpu, + .max_cpus = 255, + .is_default = 1, ++ .default_machine_opts = "firmware=bios-256k.bin", + DEFAULT_MACHINE_OPTIONS, + }; + +diff --git a/hw/i386/pc_q35.c b/hw/i386/pc_q35.c +index 86c0c90..8d1a714 100644 +--- a/hw/i386/pc_q35.c ++++ b/hw/i386/pc_q35.c +@@ -280,6 +280,7 @@ static QEMUMachine pc_q35_machine_rhel700 = { + .init = pc_q35_init_rhel700, + .hot_add_cpu = pc_hot_add_cpu, + .max_cpus = 255, ++ .default_machine_opts = "firmware=bios-256k.bin", + DEFAULT_MACHINE_OPTIONS, + }; + diff --git a/SOURCES/kvm-sysfw-remove-read-only-pc_sysfw_flash_vs_rom_bug_com.patch b/SOURCES/kvm-sysfw-remove-read-only-pc_sysfw_flash_vs_rom_bug_com.patch new file mode 100644 index 0000000..6adb0d0 --- /dev/null +++ b/SOURCES/kvm-sysfw-remove-read-only-pc_sysfw_flash_vs_rom_bug_com.patch @@ -0,0 +1,84 @@ +From 6c03a5a402c6438f8873f81f4a24514eddf475e7 Mon Sep 17 00:00:00 2001 +From: Laszlo Ersek +Date: Sat, 11 Jan 2014 18:00:00 +0100 +Subject: [PATCH 10/22] sysfw: remove read-only pc_sysfw_flash_vs_rom_bug_compatible + +RH-Author: Laszlo Ersek +Message-id: <1389463208-6278-11-git-send-email-lersek@redhat.com> +Patchwork-id: 56624 +O-Subject: [RHEL-7.0 qemu-kvm PATCH 10/18] sysfw: remove read-only pc_sysfw_flash_vs_rom_bug_compatible +Bugzilla: 1032346 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Amos Kong +RH-Acked-by: Andrew Jones + +From: Paolo Bonzini + +The variable is not written anymore. + +This cleans up after 9e1c2ec (which accidentally left variable +pc_sysfw_flash_vs_rom_bug_compatible behind, value always zero), and +buries dead code from commit dafb82e (which resurrected the pc_sysfw +code for pc_sysfw_flash_vs_rom_bug_compatible by mistake). + +Signed-off-by: Paolo Bonzini +Message-id: 1376069702-22330-2-git-send-email-aliguori@us.ibm.com +Signed-off-by: Anthony Liguori +(cherry picked from commit 133bb095acf536f85e7e57821596c8c844aaa583) +Signed-off-by: Laszlo Ersek +--- + hw/block/pc_sysfw.c | 26 +------------------------- + 1 file changed, 1 insertion(+), 25 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + hw/block/pc_sysfw.c | 26 +------------------------- + 1 files changed, 1 insertions(+), 25 deletions(-) + +diff --git a/hw/block/pc_sysfw.c b/hw/block/pc_sysfw.c +index 76932fc..38261b1 100644 +--- a/hw/block/pc_sysfw.c ++++ b/hw/block/pc_sysfw.c +@@ -196,12 +196,6 @@ static void old_pc_system_rom_init(MemoryRegion *rom_memory, bool isapc_ram_fw) + bios); + } + +-/* +- * Bug-compatible flash vs. ROM selection enabled? +- * A few older machines enable this. +- */ +-bool pc_sysfw_flash_vs_rom_bug_compatible; +- + void pc_system_firmware_init(MemoryRegion *rom_memory) + { + DriveInfo *pflash_drv; +@@ -219,25 +213,7 @@ void pc_system_firmware_init(MemoryRegion *rom_memory) + + pflash_drv = drive_get(IF_PFLASH, 0, 0); + +- if (pc_sysfw_flash_vs_rom_bug_compatible) { +- /* +- * This is a Bad Idea, because it makes enabling/disabling KVM +- * guest-visible. Do it only in bug-compatibility mode. +- */ +- if (kvm_enabled()) { +- if (pflash_drv != NULL) { +- fprintf(stderr, "qemu: pflash cannot be used with kvm enabled\n"); +- exit(1); +- } else { +- /* In old pc_sysfw_flash_vs_rom_bug_compatible mode, we assume +- * that KVM cannot execute from device memory. In this case, we +- * use old rom based firmware initialization for KVM. But, since +- * this is different from non-kvm mode, this behavior is +- * undesirable */ +- sysfw_dev->rom_only = 1; +- } +- } +- } else if (pflash_drv == NULL) { ++ if (pflash_drv == NULL) { + /* When a pflash drive is not found, use rom-mode */ + sysfw_dev->rom_only = 1; + } else if (kvm_enabled() && !kvm_readonly_mem_enabled()) { +-- +1.7.1 + diff --git a/SOURCES/kvm-target-i386-Cleanup-foo-feature-handling.patch b/SOURCES/kvm-target-i386-Cleanup-foo-feature-handling.patch new file mode 100644 index 0000000..4d09b27 --- /dev/null +++ b/SOURCES/kvm-target-i386-Cleanup-foo-feature-handling.patch @@ -0,0 +1,70 @@ +From d451bbe0826ead2944fcea51e70cab1a40c0c478 Mon Sep 17 00:00:00 2001 +From: Vadim Rozenfeld +Date: Mon, 3 Mar 2014 12:09:23 +0100 +Subject: [PATCH 11/12] target-i386: Cleanup 'foo' feature handling +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +RH-Author: Vadim Rozenfeld +Message-id: <1393848564-10511-12-git-send-email-vrozenfe@redhat.com> +Patchwork-id: 57967 +O-Subject: [RHEL-7.0 qemu-kvm v4 PATCH 11/12] target-i386: Cleanup 'foo' feature handling +Bugzilla: 1057173 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Igor Mammedov +RH-Acked-by: Eduardo Habkost +RH-Acked-by: Juan Quintela + +From: Igor Mammedov + +Features check, enforce, hv_relaxed and hv_vapic are treated as boolean +set to 'on' when passed from command line, so it's not necessary to +handle each of them separately. Collapse them to one catch-all branch +which will treat any feature in format 'foo' as boolean set to 'on'. + +Any unknown feature will be rejected by CPU property setter so there is no +need to check for unknown feature in cpu_x86_parse_featurestr(), therefore +it's replaced by above mentioned catch-all handler. + +Signed-off-by: Igor Mammedov +Reviewed-by: Eduardo Habkost +Signed-off-by: Andreas Färber +(cherry picked from commit 258f5abe9a8786c410f98367e9e042ee16c249f2) +--- + target-i386/cpu.c | 13 ++----------- + 1 file changed, 2 insertions(+), 11 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + target-i386/cpu.c | 13 ++----------- + 1 files changed, 2 insertions(+), 11 deletions(-) + +diff --git a/target-i386/cpu.c b/target-i386/cpu.c +index 9f2a04e..8421dfc 100644 +--- a/target-i386/cpu.c ++++ b/target-i386/cpu.c +@@ -1683,18 +1683,9 @@ static void cpu_x86_parse_featurestr(X86CPU *cpu, char *features, Error **errp) + error_setg(errp, "unrecognized feature %s", featurestr); + goto out; + } +- } else if (!strcmp(featurestr, "check")) { +- object_property_parse(OBJECT(cpu), "on", featurestr, errp); +- } else if (!strcmp(featurestr, "enforce")) { +- object_property_parse(OBJECT(cpu), "on", featurestr, errp); +- } else if (!strcmp(featurestr, "hv_relaxed")) { +- object_property_parse(OBJECT(cpu), "on", "hv-relaxed", errp); +- } else if (!strcmp(featurestr, "hv_vapic")) { +- object_property_parse(OBJECT(cpu), "on", "hv-vapic", errp); + } else { +- error_setg(errp, "feature string `%s' not in format (+feature|" +- "-feature|feature=xyz)", featurestr); +- goto out; ++ feat2prop(featurestr); ++ object_property_parse(OBJECT(cpu), "on", featurestr, errp); + } + if (error_is_set(errp)) { + goto out; +-- +1.7.1 + diff --git a/SOURCES/kvm-target-i386-Convert-check-and-enforce-to-static-prop.patch b/SOURCES/kvm-target-i386-Convert-check-and-enforce-to-static-prop.patch new file mode 100644 index 0000000..260c879 --- /dev/null +++ b/SOURCES/kvm-target-i386-Convert-check-and-enforce-to-static-prop.patch @@ -0,0 +1,100 @@ +From f60e83f9ba3436243c247fe81a53b0158f982b2a Mon Sep 17 00:00:00 2001 +From: Vadim Rozenfeld +Date: Mon, 3 Mar 2014 12:09:22 +0100 +Subject: [PATCH 10/12] target-i386: Convert 'check' and 'enforce' to static properties +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +RH-Author: Vadim Rozenfeld +Message-id: <1393848564-10511-11-git-send-email-vrozenfe@redhat.com> +Patchwork-id: 57966 +O-Subject: [RHEL-7.0 qemu-kvm v4 PATCH 10/12] target-i386: Convert 'check' and 'enforce' to static properties +Bugzilla: 1004773 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Igor Mammedov +RH-Acked-by: Eduardo Habkost +RH-Acked-by: Juan Quintela + +From: Igor Mammedov + +* Additionally convert check_cpuid & enforce_cpuid to bool and make them + members of X86CPU +* Make 'enforce' feature independent from 'check' + +Signed-off-by: Igor Mammedov +Signed-off-by: Andreas Färber +(cherry picked from commit 912ffc479c0008bd983f5733daa52438b359be6f) +--- + target-i386/cpu-qom.h | 2 ++ + target-i386/cpu.c | 13 ++++++------- + 2 files changed, 8 insertions(+), 7 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + target-i386/cpu-qom.h | 2 ++ + target-i386/cpu.c | 13 ++++++------- + 2 files changed, 8 insertions(+), 7 deletions(-) + +diff --git a/target-i386/cpu-qom.h b/target-i386/cpu-qom.h +index ac56fec..99ba65f 100644 +--- a/target-i386/cpu-qom.h ++++ b/target-i386/cpu-qom.h +@@ -69,6 +69,8 @@ typedef struct X86CPU { + bool hyperv_vapic; + bool hyperv_relaxed_timing; + int hyperv_spinlock_attempts; ++ bool check_cpuid; ++ bool enforce_cpuid; + + /* Features that were filtered out because of missing host capabilities */ + uint32_t filtered_features[FEATURE_WORDS]; +diff --git a/target-i386/cpu.c b/target-i386/cpu.c +index db51f72..9f2a04e 100644 +--- a/target-i386/cpu.c ++++ b/target-i386/cpu.c +@@ -242,9 +242,6 @@ typedef struct model_features_t { + FeatureWord feat_word; + } model_features_t; + +-int check_cpuid = 0; +-int enforce_cpuid = 0; +- + static uint32_t kvm_default_features = (1 << KVM_FEATURE_CLOCKSOURCE) | + (1 << KVM_FEATURE_NOP_IO_DELAY) | + (1 << KVM_FEATURE_CLOCKSOURCE2) | +@@ -1687,9 +1684,9 @@ static void cpu_x86_parse_featurestr(X86CPU *cpu, char *features, Error **errp) + goto out; + } + } else if (!strcmp(featurestr, "check")) { +- check_cpuid = 1; ++ object_property_parse(OBJECT(cpu), "on", featurestr, errp); + } else if (!strcmp(featurestr, "enforce")) { +- check_cpuid = enforce_cpuid = 1; ++ object_property_parse(OBJECT(cpu), "on", featurestr, errp); + } else if (!strcmp(featurestr, "hv_relaxed")) { + object_property_parse(OBJECT(cpu), "on", "hv-relaxed", errp); + } else if (!strcmp(featurestr, "hv_vapic")) { +@@ -2490,8 +2487,8 @@ static void x86_cpu_realizefn(DeviceState *dev, Error **errp) + env->features[FEAT_8000_0001_ECX] &= TCG_EXT3_FEATURES; + env->features[FEAT_SVM] &= TCG_SVM_FEATURES; + } else { +- if (check_cpuid && kvm_check_features_against_host(cpu) +- && enforce_cpuid) { ++ if ((cpu->check_cpuid || cpu->enforce_cpuid) ++ && kvm_check_features_against_host(cpu) && cpu->enforce_cpuid) { + error_setg(&local_err, + "Host's CPU doesn't support requested features"); + goto out; +@@ -2633,6 +2630,8 @@ static Property x86_cpu_properties[] = { + { .name = "hv-spinlocks", .info = &qdev_prop_spinlocks }, + DEFINE_PROP_BOOL("hv-relaxed", X86CPU, hyperv_relaxed_timing, false), + DEFINE_PROP_BOOL("hv-vapic", X86CPU, hyperv_vapic, false), ++ DEFINE_PROP_BOOL("check", X86CPU, check_cpuid, false), ++ DEFINE_PROP_BOOL("enforce", X86CPU, enforce_cpuid, false), + DEFINE_PROP_END_OF_LIST() + }; + +-- +1.7.1 + diff --git a/SOURCES/kvm-target-i386-Convert-hv_relaxed-to-static-property.patch b/SOURCES/kvm-target-i386-Convert-hv_relaxed-to-static-property.patch new file mode 100644 index 0000000..0464a33 --- /dev/null +++ b/SOURCES/kvm-target-i386-Convert-hv_relaxed-to-static-property.patch @@ -0,0 +1,59 @@ +From 69161658b1c504064ce50f7f89662b44c39d8839 Mon Sep 17 00:00:00 2001 +From: Vadim Rozenfeld +Date: Mon, 3 Mar 2014 12:09:19 +0100 +Subject: [PATCH 07/12] target-i386: Convert 'hv_relaxed' to static property +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +RH-Author: Vadim Rozenfeld +Message-id: <1393848564-10511-8-git-send-email-vrozenfe@redhat.com> +Patchwork-id: 57963 +O-Subject: [RHEL-7.0 qemu-kvm v4 PATCH 07/12] target-i386: Convert 'hv_relaxed' to static property +Bugzilla: 1057173 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Igor Mammedov +RH-Acked-by: Eduardo Habkost +RH-Acked-by: Juan Quintela + +From: Igor Mammedov + +Signed-off-by: Igor Mammedov +Signed-off-by: Andreas Färber +(cherry picked from commit 89314504197b305173e3f2d23ce541898ef2691c) + +Conflicts: + target-i386/cpu.c +--- + target-i386/cpu.c | 3 ++- + 1 file changed, 2 insertions(+), 1 deletion(-) + +Signed-off-by: Miroslav Rezanina +--- + target-i386/cpu.c | 3 ++- + 1 files changed, 2 insertions(+), 1 deletions(-) + +diff --git a/target-i386/cpu.c b/target-i386/cpu.c +index 826d8d6..7c8efaf 100644 +--- a/target-i386/cpu.c ++++ b/target-i386/cpu.c +@@ -1649,7 +1649,7 @@ static void cpu_x86_parse_featurestr(X86CPU *cpu, char *features, Error **errp) + } else if (!strcmp(featurestr, "enforce")) { + check_cpuid = enforce_cpuid = 1; + } else if (!strcmp(featurestr, "hv_relaxed")) { +- cpu->hyperv_relaxed_timing = true; ++ object_property_parse(OBJECT(cpu), "on", "hv-relaxed", errp); + } else if (!strcmp(featurestr, "hv_vapic")) { + cpu->hyperv_vapic = true; + } else { +@@ -2588,6 +2588,7 @@ static int64_t x86_cpu_get_arch_id(CPUState *cs) + + static Property x86_cpu_properties[] = { + DEFINE_PROP_BOOL("pmu", X86CPU, enable_pmu, false), ++ DEFINE_PROP_BOOL("hv-relaxed", X86CPU, hyperv_relaxed_timing, false), + DEFINE_PROP_END_OF_LIST() + }; + +-- +1.7.1 + diff --git a/SOURCES/kvm-target-i386-Convert-hv_spinlocks-to-static-property.patch b/SOURCES/kvm-target-i386-Convert-hv_spinlocks-to-static-property.patch new file mode 100644 index 0000000..6dc9e85 --- /dev/null +++ b/SOURCES/kvm-target-i386-Convert-hv_spinlocks-to-static-property.patch @@ -0,0 +1,112 @@ +From 8b2c0bd8595d7e175c04f80fbc3035cd538aab2b Mon Sep 17 00:00:00 2001 +From: Vadim Rozenfeld +Date: Mon, 3 Mar 2014 12:09:21 +0100 +Subject: [PATCH 09/12] target-i386: Convert 'hv_spinlocks' to static property +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +RH-Author: Vadim Rozenfeld +Message-id: <1393848564-10511-10-git-send-email-vrozenfe@redhat.com> +Patchwork-id: 57965 +O-Subject: [RHEL-7.0 qemu-kvm v4 PATCH 09/12] target-i386: Convert 'hv_spinlocks' to static property +Bugzilla: 1057173 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Igor Mammedov +RH-Acked-by: Eduardo Habkost +RH-Acked-by: Juan Quintela + +From: Igor Mammedov + +Signed-off-by: Igor Mammedov +Signed-off-by: Andreas Färber +(cherry picked from commit c8f0f88e2a4cf27bde27a31a98badd61fe212652) +--- + target-i386/cpu.c | 45 ++++++++++++++++++++++++++++++++++++++++++++- + 1 file changed, 44 insertions(+), 1 deletion(-) + +Signed-off-by: Miroslav Rezanina +--- + target-i386/cpu.c | 45 ++++++++++++++++++++++++++++++++++++++++++++- + 1 files changed, 44 insertions(+), 1 deletions(-) + +diff --git a/target-i386/cpu.c b/target-i386/cpu.c +index 7a8cb01..db51f72 100644 +--- a/target-i386/cpu.c ++++ b/target-i386/cpu.c +@@ -1511,6 +1511,46 @@ static void x86_cpu_get_feature_words(Object *obj, Visitor *v, void *opaque, + error_propagate(errp, err); + } + ++static void x86_get_hv_spinlocks(Object *obj, Visitor *v, void *opaque, ++ const char *name, Error **errp) ++{ ++ X86CPU *cpu = X86_CPU(obj); ++ int64_t value = cpu->hyperv_spinlock_attempts; ++ ++ visit_type_int(v, &value, name, errp); ++} ++ ++static void x86_set_hv_spinlocks(Object *obj, Visitor *v, void *opaque, ++ const char *name, Error **errp) ++{ ++ const int64_t min = 0xFFF; ++ const int64_t max = UINT_MAX; ++ X86CPU *cpu = X86_CPU(obj); ++ Error *err = NULL; ++ int64_t value; ++ ++ visit_type_int(v, &value, name, &err); ++ if (err) { ++ error_propagate(errp, err); ++ return; ++ } ++ ++ if (value < min || value > max) { ++ error_setg(errp, "Property %s.%s doesn't take value %" PRId64 ++ " (minimum: %" PRId64 ", maximum: %" PRId64 ")", ++ object_get_typename(obj), name ? name : "null", ++ value, min, max); ++ return; ++ } ++ cpu->hyperv_spinlock_attempts = value; ++} ++ ++static PropertyInfo qdev_prop_spinlocks = { ++ .name = "int", ++ .get = x86_get_hv_spinlocks, ++ .set = x86_set_hv_spinlocks, ++}; ++ + static int cpu_x86_find_by_name(X86CPU *cpu, x86_def_t *x86_cpu_def, + const char *name) + { +@@ -1628,6 +1668,7 @@ static void cpu_x86_parse_featurestr(X86CPU *cpu, char *features, Error **errp) + } else if (!strcmp(featurestr, "hv-spinlocks")) { + char *err; + const int min = 0xFFF; ++ char num[32]; + numvalue = strtoul(val, &err, 0); + if (!*val || *err) { + error_setg(errp, "bad numerical value %s", val); +@@ -1639,7 +1680,8 @@ static void cpu_x86_parse_featurestr(X86CPU *cpu, char *features, Error **errp) + min); + numvalue = min; + } +- cpu->hyperv_spinlock_attempts = numvalue; ++ snprintf(num, sizeof(num), "%" PRId32, numvalue); ++ object_property_parse(OBJECT(cpu), num, featurestr, errp); + } else { + error_setg(errp, "unrecognized feature %s", featurestr); + goto out; +@@ -2588,6 +2630,7 @@ static int64_t x86_cpu_get_arch_id(CPUState *cs) + + static Property x86_cpu_properties[] = { + DEFINE_PROP_BOOL("pmu", X86CPU, enable_pmu, false), ++ { .name = "hv-spinlocks", .info = &qdev_prop_spinlocks }, + DEFINE_PROP_BOOL("hv-relaxed", X86CPU, hyperv_relaxed_timing, false), + DEFINE_PROP_BOOL("hv-vapic", X86CPU, hyperv_vapic, false), + DEFINE_PROP_END_OF_LIST() +-- +1.7.1 + diff --git a/SOURCES/kvm-target-i386-Convert-hv_vapic-to-static-property.patch b/SOURCES/kvm-target-i386-Convert-hv_vapic-to-static-property.patch new file mode 100644 index 0000000..8eb46c1 --- /dev/null +++ b/SOURCES/kvm-target-i386-Convert-hv_vapic-to-static-property.patch @@ -0,0 +1,56 @@ +From 7c8a13c9c4e443bb7bd1cc5492ce8d0eb728f8fe Mon Sep 17 00:00:00 2001 +From: Vadim Rozenfeld +Date: Mon, 3 Mar 2014 12:09:20 +0100 +Subject: [PATCH 08/12] target-i386: Convert 'hv_vapic' to static property +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +RH-Author: Vadim Rozenfeld +Message-id: <1393848564-10511-9-git-send-email-vrozenfe@redhat.com> +Patchwork-id: 57964 +O-Subject: [RHEL-7.0 qemu-kvm v4 PATCH 08/12] target-i386: Convert 'hv_vapic' to static property +Bugzilla: 1057173 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Igor Mammedov +RH-Acked-by: Eduardo Habkost +RH-Acked-by: Juan Quintela + +From: Igor Mammedov + +Signed-off-by: Igor Mammedov +Signed-off-by: Andreas Färber +(cherry picked from commit 0f46685d1b03efaaf5189f0e9af8754cb8f8979c) +--- + target-i386/cpu.c | 3 ++- + 1 file changed, 2 insertions(+), 1 deletion(-) + +Signed-off-by: Miroslav Rezanina +--- + target-i386/cpu.c | 3 ++- + 1 files changed, 2 insertions(+), 1 deletions(-) + +diff --git a/target-i386/cpu.c b/target-i386/cpu.c +index 7c8efaf..7a8cb01 100644 +--- a/target-i386/cpu.c ++++ b/target-i386/cpu.c +@@ -1651,7 +1651,7 @@ static void cpu_x86_parse_featurestr(X86CPU *cpu, char *features, Error **errp) + } else if (!strcmp(featurestr, "hv_relaxed")) { + object_property_parse(OBJECT(cpu), "on", "hv-relaxed", errp); + } else if (!strcmp(featurestr, "hv_vapic")) { +- cpu->hyperv_vapic = true; ++ object_property_parse(OBJECT(cpu), "on", "hv-vapic", errp); + } else { + error_setg(errp, "feature string `%s' not in format (+feature|" + "-feature|feature=xyz)", featurestr); +@@ -2589,6 +2589,7 @@ static int64_t x86_cpu_get_arch_id(CPUState *cs) + static Property x86_cpu_properties[] = { + DEFINE_PROP_BOOL("pmu", X86CPU, enable_pmu, false), + DEFINE_PROP_BOOL("hv-relaxed", X86CPU, hyperv_relaxed_timing, false), ++ DEFINE_PROP_BOOL("hv-vapic", X86CPU, hyperv_vapic, false), + DEFINE_PROP_END_OF_LIST() + }; + +-- +1.7.1 + diff --git a/SOURCES/kvm-target-i386-Copy-cpu64-rhel6-definition-into-qemu64.patch b/SOURCES/kvm-target-i386-Copy-cpu64-rhel6-definition-into-qemu64.patch new file mode 100644 index 0000000..7ffa123 --- /dev/null +++ b/SOURCES/kvm-target-i386-Copy-cpu64-rhel6-definition-into-qemu64.patch @@ -0,0 +1,83 @@ +From 4941c3e5c2366f008c90f1f58a49c0ed203fce11 Mon Sep 17 00:00:00 2001 +From: Eduardo Habkost +Date: Tue, 25 Mar 2014 16:03:47 +0100 +Subject: [PATCH 2/2] target-i386: Copy cpu64-rhel6 definition into qemu64 + +RH-Author: Eduardo Habkost +Message-id: <1395763427-31684-3-git-send-email-ehabkost@redhat.com> +Patchwork-id: 58248 +O-Subject: [RHEL7 qemu-kvm PATCH 2/2] target-i386: Copy cpu64-rhel6 definition into qemu64 +Bugzilla: 1080170 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Alex Williamson +RH-Acked-by: Bandan Das + +Bugzilla: 1078607 +Brew scratch build: http://brewweb.devel.redhat.com/brew/taskinfo?taskID=7250917 +Upstream status: not applicable + +The CPUID data from cpu64-rhel6 is a better default than qemu64. Among +other things, this fixes MSI problems on 32-bit Windows guests. + +Signed-off-by: Eduardo Habkost +--- + target-i386/cpu.c | 33 ++++++++++++++++++++------------- + 1 file changed, 20 insertions(+), 13 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + target-i386/cpu.c | 33 ++++++++++++++++++++------------- + 1 files changed, 20 insertions(+), 13 deletions(-) + +diff --git a/target-i386/cpu.c b/target-i386/cpu.c +index 005e190..e65318e 100644 +--- a/target-i386/cpu.c ++++ b/target-i386/cpu.c +@@ -440,24 +440,31 @@ typedef struct x86_def_t { + */ + static x86_def_t builtin_x86_defs[] = { + { ++ /* qemu64 is the default CPU model for all *-rhel7.* machine-types. ++ * The default on RHEL-6 was cpu64-rhel6. ++ * libvirt assumes that qemu64 is the default for _all_ machine-types, ++ * so we should try to keep qemu64 and cpu64-rhel6 as similar as ++ * possible. ++ */ + .name = "qemu64", + .level = 4, + .vendor = CPUID_VENDOR_AMD, + .family = 6, +- .model = 6, ++ .model = 13, + .stepping = 3, +- .features[FEAT_1_EDX] = +- PPRO_FEATURES | +- CPUID_MTRR | CPUID_CLFLUSH | CPUID_MCA | +- CPUID_PSE36, +- .features[FEAT_1_ECX] = +- CPUID_EXT_SSE3 | CPUID_EXT_CX16 | CPUID_EXT_POPCNT, +- .features[FEAT_8000_0001_EDX] = +- (PPRO_FEATURES & CPUID_EXT2_AMD_ALIASES) | +- CPUID_EXT2_LM | CPUID_EXT2_SYSCALL | CPUID_EXT2_NX, +- .features[FEAT_8000_0001_ECX] = +- CPUID_EXT3_LAHF_LM | CPUID_EXT3_SVM | +- CPUID_EXT3_ABM | CPUID_EXT3_SSE4A, ++ .features[FEAT_1_EDX] = CPUID_SSE2 | CPUID_SSE | CPUID_FXSR | ++ CPUID_MMX | CPUID_CLFLUSH | CPUID_PSE36 | CPUID_PAT | CPUID_CMOV | ++ CPUID_MCA | CPUID_PGE | CPUID_MTRR | CPUID_SEP | CPUID_APIC | ++ CPUID_CX8 | CPUID_MCE | CPUID_PAE | CPUID_MSR | CPUID_TSC | ++ CPUID_PSE | CPUID_DE | CPUID_FP87, ++ .features[FEAT_1_ECX] = CPUID_EXT_CX16 | CPUID_EXT_SSE3, ++ .features[FEAT_8000_0001_EDX] = CPUID_EXT2_LM | CPUID_EXT2_FXSR | ++ CPUID_EXT2_MMX | CPUID_EXT2_NX | CPUID_EXT2_PAT | CPUID_EXT2_CMOV | ++ CPUID_EXT2_PGE | CPUID_EXT2_SYSCALL | CPUID_EXT2_APIC | ++ CPUID_EXT2_CX8 | CPUID_EXT2_MCE | CPUID_EXT2_PAE | CPUID_EXT2_MSR | CPUID_EXT2_TSC | ++ CPUID_EXT2_PSE | CPUID_EXT2_DE | CPUID_EXT2_FPU, ++ .features[FEAT_8000_0001_ECX] = CPUID_EXT3_SSE4A | CPUID_EXT3_ABM | ++ CPUID_EXT3_SVM | CPUID_EXT3_LAHF_LM, + .xlevel = 0x8000000A, + }, + { +-- +1.7.1 + diff --git a/SOURCES/kvm-target-i386-Move-hyperv_-static-globals-to-X86CPU.patch b/SOURCES/kvm-target-i386-Move-hyperv_-static-globals-to-X86CPU.patch new file mode 100644 index 0000000..5608caa --- /dev/null +++ b/SOURCES/kvm-target-i386-Move-hyperv_-static-globals-to-X86CPU.patch @@ -0,0 +1,375 @@ +From 6d78a7906b69054a4798b1b68548f59fec9e5da8 Mon Sep 17 00:00:00 2001 +From: Vadim Rozenfeld +Date: Mon, 3 Mar 2014 12:09:13 +0100 +Subject: [PATCH 01/12] target-i386: Move hyperv_* static globals to X86CPU +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +RH-Author: Vadim Rozenfeld +Message-id: <1393848564-10511-2-git-send-email-vrozenfe@redhat.com> +Patchwork-id: 57957 +O-Subject: [RHEL-7.0 qemu-kvm v4 PATCH 01/12] target-i386: Move hyperv_* static globals to X86CPU +Bugzilla: 1004773 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Igor Mammedov +RH-Acked-by: Juan Quintela +RH-Acked-by: Eduardo Habkost + +From: Igor Mammedov + + since hyperv_* helper functions are used only in target-i386/kvm.c + move them there as static helpers + +Requested-by: Eduardo Habkost +Signed-off-by: Igor Mammedov +Signed-off-by: Andreas Färber +(cherry picked from commit 92067bf4bfa144ea3967a9951808f5e587bdab18) + +Conflicts: + target-i386/cpu.h + target-i386/kvm.c +--- + target-i386/Makefile.objs | 2 +- + target-i386/cpu-qom.h | 4 +++ + target-i386/cpu.c | 16 ++++++++---- + target-i386/cpu.h | 4 +++ + target-i386/hyperv.c | 64 ----------------------------------------------- + target-i386/hyperv.h | 45 --------------------------------- + target-i386/kvm.c | 36 ++++++++++++++++++-------- + 7 files changed, 46 insertions(+), 125 deletions(-) + delete mode 100644 target-i386/hyperv.c + delete mode 100644 target-i386/hyperv.h + +Signed-off-by: Miroslav Rezanina +--- + target-i386/Makefile.objs | 2 +- + target-i386/cpu-qom.h | 4 +++ + target-i386/cpu.c | 16 +++++++--- + target-i386/cpu.h | 4 +++ + target-i386/hyperv.c | 64 --------------------------------------------- + target-i386/hyperv.h | 45 ------------------------------- + target-i386/kvm.c | 36 ++++++++++++++++++------- + 7 files changed, 46 insertions(+), 125 deletions(-) + delete mode 100644 target-i386/hyperv.c + delete mode 100644 target-i386/hyperv.h + +diff --git a/target-i386/Makefile.objs b/target-i386/Makefile.objs +index c1d4f05..887dca7 100644 +--- a/target-i386/Makefile.objs ++++ b/target-i386/Makefile.objs +@@ -2,7 +2,7 @@ obj-y += translate.o helper.o cpu.o + obj-y += excp_helper.o fpu_helper.o cc_helper.o int_helper.o svm_helper.o + obj-y += smm_helper.o misc_helper.o mem_helper.o seg_helper.o + obj-$(CONFIG_SOFTMMU) += machine.o arch_memory_mapping.o arch_dump.o +-obj-$(CONFIG_KVM) += kvm.o hyperv.o ++obj-$(CONFIG_KVM) += kvm.o + obj-$(CONFIG_NO_KVM) += kvm-stub.o + obj-$(CONFIG_LINUX_USER) += ioport-user.o + obj-$(CONFIG_BSD_USER) += ioport-user.o +diff --git a/target-i386/cpu-qom.h b/target-i386/cpu-qom.h +index 12c7bea..ac56fec 100644 +--- a/target-i386/cpu-qom.h ++++ b/target-i386/cpu-qom.h +@@ -66,6 +66,10 @@ typedef struct X86CPU { + + CPUX86State env; + ++ bool hyperv_vapic; ++ bool hyperv_relaxed_timing; ++ int hyperv_spinlock_attempts; ++ + /* Features that were filtered out because of missing host capabilities */ + uint32_t filtered_features[FEATURE_WORDS]; + +diff --git a/target-i386/cpu.c b/target-i386/cpu.c +index 31ff568..826d8d6 100644 +--- a/target-i386/cpu.c ++++ b/target-i386/cpu.c +@@ -35,8 +35,6 @@ + #include "qapi/visitor.h" + #include "sysemu/arch_init.h" + +-#include "hyperv.h" +- + #include "hw/hw.h" + #if defined(CONFIG_KVM) + #include +@@ -1629,12 +1627,19 @@ static void cpu_x86_parse_featurestr(X86CPU *cpu, char *features, Error **errp) + object_property_parse(OBJECT(cpu), num, "tsc-frequency", errp); + } else if (!strcmp(featurestr, "hv-spinlocks")) { + char *err; ++ const int min = 0xFFF; + numvalue = strtoul(val, &err, 0); + if (!*val || *err) { + error_setg(errp, "bad numerical value %s", val); + goto out; + } +- hyperv_set_spinlock_retries(numvalue); ++ if (numvalue < min) { ++ fprintf(stderr, "hv-spinlocks value shall always be >= 0x%x" ++ ", fixup will be removed in future versions\n", ++ min); ++ numvalue = min; ++ } ++ cpu->hyperv_spinlock_attempts = numvalue; + } else { + error_setg(errp, "unrecognized feature %s", featurestr); + goto out; +@@ -1644,9 +1649,9 @@ static void cpu_x86_parse_featurestr(X86CPU *cpu, char *features, Error **errp) + } else if (!strcmp(featurestr, "enforce")) { + check_cpuid = enforce_cpuid = 1; + } else if (!strcmp(featurestr, "hv_relaxed")) { +- hyperv_enable_relaxed_timing(true); ++ cpu->hyperv_relaxed_timing = true; + } else if (!strcmp(featurestr, "hv_vapic")) { +- hyperv_enable_vapic_recommended(true); ++ cpu->hyperv_vapic = true; + } else { + error_setg(errp, "feature string `%s' not in format (+feature|" + "-feature|feature=xyz)", featurestr); +@@ -2559,6 +2564,7 @@ static void x86_cpu_initfn(Object *obj) + x86_cpu_get_feature_words, + NULL, NULL, (void *)cpu->filtered_features, NULL); + ++ cpu->hyperv_spinlock_attempts = HYPERV_SPINLOCK_NEVER_RETRY; + env->cpuid_apic_id = x86_cpu_apic_id_from_index(cs->cpu_index); + + /* init various static tables used in TCG mode */ +diff --git a/target-i386/cpu.h b/target-i386/cpu.h +index 37ff264..4c4c9ff 100644 +--- a/target-i386/cpu.h ++++ b/target-i386/cpu.h +@@ -565,6 +565,10 @@ typedef uint32_t FeatureWordArray[FEATURE_WORDS]; + #define CPUID_MWAIT_IBE (1 << 1) /* Interrupts can exit capability */ + #define CPUID_MWAIT_EMX (1 << 0) /* enumeration supported */ + ++#ifndef HYPERV_SPINLOCK_NEVER_RETRY ++#define HYPERV_SPINLOCK_NEVER_RETRY 0xFFFFFFFF ++#endif ++ + #define EXCP00_DIVZ 0 + #define EXCP01_DB 1 + #define EXCP02_NMI 2 +diff --git a/target-i386/hyperv.c b/target-i386/hyperv.c +deleted file mode 100644 +index f284e99..0000000 +--- a/target-i386/hyperv.c ++++ /dev/null +@@ -1,64 +0,0 @@ +-/* +- * QEMU Hyper-V support +- * +- * Copyright Red Hat, Inc. 2011 +- * +- * Author: Vadim Rozenfeld +- * +- * This work is licensed under the terms of the GNU GPL, version 2 or later. +- * See the COPYING file in the top-level directory. +- * +- */ +- +-#include "hyperv.h" +- +-static bool hyperv_vapic; +-static bool hyperv_relaxed_timing; +-static int hyperv_spinlock_attempts = HYPERV_SPINLOCK_NEVER_RETRY; +- +-void hyperv_enable_vapic_recommended(bool val) +-{ +- hyperv_vapic = val; +-} +- +-void hyperv_enable_relaxed_timing(bool val) +-{ +- hyperv_relaxed_timing = val; +-} +- +-void hyperv_set_spinlock_retries(int val) +-{ +- hyperv_spinlock_attempts = val; +- if (hyperv_spinlock_attempts < 0xFFF) { +- hyperv_spinlock_attempts = 0xFFF; +- } +-} +- +-bool hyperv_enabled(void) +-{ +- return hyperv_hypercall_available() || hyperv_relaxed_timing_enabled(); +-} +- +-bool hyperv_hypercall_available(void) +-{ +- if (hyperv_vapic || +- (hyperv_spinlock_attempts != HYPERV_SPINLOCK_NEVER_RETRY)) { +- return true; +- } +- return false; +-} +- +-bool hyperv_vapic_recommended(void) +-{ +- return hyperv_vapic; +-} +- +-bool hyperv_relaxed_timing_enabled(void) +-{ +- return hyperv_relaxed_timing; +-} +- +-int hyperv_get_spinlock_retries(void) +-{ +- return hyperv_spinlock_attempts; +-} +diff --git a/target-i386/hyperv.h b/target-i386/hyperv.h +deleted file mode 100644 +index bacb1d4..0000000 +--- a/target-i386/hyperv.h ++++ /dev/null +@@ -1,45 +0,0 @@ +-/* +- * QEMU Hyper-V support +- * +- * Copyright Red Hat, Inc. 2011 +- * +- * Author: Vadim Rozenfeld +- * +- * This work is licensed under the terms of the GNU GPL, version 2 or later. +- * See the COPYING file in the top-level directory. +- * +- */ +- +-#ifndef QEMU_HW_HYPERV_H +-#define QEMU_HW_HYPERV_H 1 +- +-#include "qemu-common.h" +-#ifdef CONFIG_KVM +-#include +-#endif +- +-#ifndef HYPERV_SPINLOCK_NEVER_RETRY +-#define HYPERV_SPINLOCK_NEVER_RETRY 0xFFFFFFFF +-#endif +- +-#ifndef KVM_CPUID_SIGNATURE_NEXT +-#define KVM_CPUID_SIGNATURE_NEXT 0x40000100 +-#endif +- +-#if !defined(CONFIG_USER_ONLY) && defined(CONFIG_KVM) +-void hyperv_enable_vapic_recommended(bool val); +-void hyperv_enable_relaxed_timing(bool val); +-void hyperv_set_spinlock_retries(int val); +-#else +-static inline void hyperv_enable_vapic_recommended(bool val) { } +-static inline void hyperv_enable_relaxed_timing(bool val) { } +-static inline void hyperv_set_spinlock_retries(int val) { } +-#endif +- +-bool hyperv_enabled(void); +-bool hyperv_hypercall_available(void); +-bool hyperv_vapic_recommended(void); +-bool hyperv_relaxed_timing_enabled(void); +-int hyperv_get_spinlock_retries(void); +- +-#endif /* QEMU_HW_HYPERV_H */ +diff --git a/target-i386/kvm.c b/target-i386/kvm.c +index 4b470e4..c7fabd7 100644 +--- a/target-i386/kvm.c ++++ b/target-i386/kvm.c +@@ -31,7 +31,7 @@ + #include "hw/i386/pc.h" + #include "hw/i386/apic.h" + #include "exec/ioport.h" +-#include "hyperv.h" ++#include + #include "hw/pci/pci.h" + + //#define DEBUG_KVM +@@ -421,6 +421,22 @@ unsigned long kvm_arch_vcpu_id(CPUState *cs) + return cpu->env.cpuid_apic_id; + } + ++#ifndef KVM_CPUID_SIGNATURE_NEXT ++#define KVM_CPUID_SIGNATURE_NEXT 0x40000100 ++#endif ++ ++static bool hyperv_hypercall_available(X86CPU *cpu) ++{ ++ return cpu->hyperv_vapic || ++ (cpu->hyperv_spinlock_attempts != HYPERV_SPINLOCK_NEVER_RETRY); ++} ++ ++static bool hyperv_enabled(X86CPU *cpu) ++{ ++ return hyperv_hypercall_available(cpu) || ++ cpu->hyperv_relaxed_timing; ++} ++ + #define KVM_MAX_CPUID_ENTRIES 100 + + int kvm_arch_init_vcpu(CPUState *cs) +@@ -443,7 +459,7 @@ int kvm_arch_init_vcpu(CPUState *cs) + c = &cpuid_data.entries[cpuid_i++]; + memset(c, 0, sizeof(*c)); + c->function = KVM_CPUID_SIGNATURE; +- if (!hyperv_enabled()) { ++ if (!hyperv_enabled(cpu)) { + memcpy(signature, "KVMKVMKVM\0\0\0", 12); + c->eax = 0; + } else { +@@ -459,7 +475,7 @@ int kvm_arch_init_vcpu(CPUState *cs) + c->function = KVM_CPUID_FEATURES; + c->eax = env->features[FEAT_KVM]; + +- if (hyperv_enabled()) { ++ if (hyperv_enabled(cpu)) { + memcpy(signature, "Hv#1\0\0\0\0\0\0\0\0", 12); + c->eax = signature[0]; + +@@ -472,10 +488,10 @@ int kvm_arch_init_vcpu(CPUState *cs) + c = &cpuid_data.entries[cpuid_i++]; + memset(c, 0, sizeof(*c)); + c->function = HYPERV_CPUID_FEATURES; +- if (hyperv_relaxed_timing_enabled()) { ++ if (cpu->hyperv_relaxed_timing) { + c->eax |= HV_X64_MSR_HYPERCALL_AVAILABLE; + } +- if (hyperv_vapic_recommended()) { ++ if (cpu->hyperv_vapic) { + c->eax |= HV_X64_MSR_HYPERCALL_AVAILABLE; + c->eax |= HV_X64_MSR_APIC_ACCESS_AVAILABLE; + } +@@ -483,13 +499,13 @@ int kvm_arch_init_vcpu(CPUState *cs) + c = &cpuid_data.entries[cpuid_i++]; + memset(c, 0, sizeof(*c)); + c->function = HYPERV_CPUID_ENLIGHTMENT_INFO; +- if (hyperv_relaxed_timing_enabled()) { ++ if (cpu->hyperv_relaxed_timing) { + c->eax |= HV_X64_RELAXED_TIMING_RECOMMENDED; + } +- if (hyperv_vapic_recommended()) { ++ if (cpu->hyperv_vapic) { + c->eax |= HV_X64_APIC_ACCESS_RECOMMENDED; + } +- c->ebx = hyperv_get_spinlock_retries(); ++ c->ebx = cpu->hyperv_spinlock_attempts; + + c = &cpuid_data.entries[cpuid_i++]; + memset(c, 0, sizeof(*c)); +@@ -1177,11 +1193,11 @@ static int kvm_put_msrs(X86CPU *cpu, int level) + kvm_msr_entry_set(&msrs[n++], MSR_CORE_PERF_GLOBAL_CTRL, + env->msr_global_ctrl); + } +- if (hyperv_hypercall_available()) { ++ if (hyperv_hypercall_available(cpu)) { + kvm_msr_entry_set(&msrs[n++], HV_X64_MSR_GUEST_OS_ID, 0); + kvm_msr_entry_set(&msrs[n++], HV_X64_MSR_HYPERCALL, 0); + } +- if (hyperv_vapic_recommended()) { ++ if (cpu->hyperv_vapic) { + kvm_msr_entry_set(&msrs[n++], HV_X64_MSR_APIC_ASSIST_PAGE, 0); + } + } +-- +1.7.1 + diff --git a/SOURCES/kvm-tests-Fix-schema-parser-test-for-in-tree-build.patch b/SOURCES/kvm-tests-Fix-schema-parser-test-for-in-tree-build.patch new file mode 100644 index 0000000..8ad31b8 --- /dev/null +++ b/SOURCES/kvm-tests-Fix-schema-parser-test-for-in-tree-build.patch @@ -0,0 +1,75 @@ +From ba8738a0a615a51984a60be2f987b98789968fb6 Mon Sep 17 00:00:00 2001 +Message-Id: +In-Reply-To: <091eecc4fa42754760dfff393dabcc2b444e9693.1387369730.git.minovotn@redhat.com> +References: <091eecc4fa42754760dfff393dabcc2b444e9693.1387369730.git.minovotn@redhat.com> +From: Markus Armbruster +Date: Tue, 10 Dec 2013 15:29:21 +0100 +Subject: [PATCH 21/21] tests: Fix schema parser test for in-tree build +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +RH-Author: Markus Armbruster +Message-id: <1386689361-30281-19-git-send-email-armbru@redhat.com> +Patchwork-id: 56133 +O-Subject: [PATCH 7.0 qemu-kvm 18/18] tests: Fix schema parser test for in-tree build +Bugzilla: 997915 +RH-Acked-by: Laszlo Ersek +RH-Acked-by: Kevin Wolf +RH-Acked-by: Luiz Capitulino + +From: Markus Armbruster + +Commit 4f193e3 added the test, but screwed up in-tree builds +(SRCDIR=.): the tests's output overwrites the expected output, and is +thus compared to itself. + +Cc: qemu-stable@nongnu.org +Reported-by: Laszlo Ersek +Reviewed-by: Andreas Färber +Reviewed-by: Laszlo Ersek +Signed-off-by: Markus Armbruster +Signed-off-by: Michael Tokarev +(cherry picked from commit d8039e58b1ecfdc9af171502c83e3949f6dafb95) +--- + tests/.gitignore | 1 + + tests/Makefile | 8 ++++---- + 2 files changed, 5 insertions(+), 4 deletions(-) + +Signed-off-by: Michal Novotny +--- + tests/.gitignore | 1 + + tests/Makefile | 8 ++++---- + 2 files changed, 5 insertions(+), 4 deletions(-) + +diff --git a/tests/.gitignore b/tests/.gitignore +index fb05c2a..d9c2ef4 100644 +--- a/tests/.gitignore ++++ b/tests/.gitignore +@@ -19,3 +19,4 @@ test-thread-pool + test-x86-cpuid + test-xbzrle + *-test ++qapi-schema/*.test.* +diff --git a/tests/Makefile b/tests/Makefile +index a38f360..3d196aa 100644 +--- a/tests/Makefile ++++ b/tests/Makefile +@@ -233,10 +233,10 @@ check-tests/test-qapi.py: tests/test-qapi.py + + .PHONY: $(patsubst %, check-%, $(check-qapi-schema-y)) + $(patsubst %, check-%, $(check-qapi-schema-y)): check-%.json: $(SRC_PATH)/%.json +- $(call quiet-command, PYTHONPATH=$(SRC_PATH)/scripts $(PYTHON) $(SRC_PATH)/tests/qapi-schema/test-qapi.py <$^ >$*.out 2>$*.err; echo $$? >$*.exit, " TEST $*.out") +- @diff -q $(SRC_PATH)/$*.out $*.out +- @diff -q $(SRC_PATH)/$*.err $*.err +- @diff -q $(SRC_PATH)/$*.exit $*.exit ++ $(call quiet-command, PYTHONPATH=$(SRC_PATH)/scripts $(PYTHON) $(SRC_PATH)/tests/qapi-schema/test-qapi.py <$^ >$*.test.out 2>$*.test.err; echo $$? >$*.test.exit, " TEST $*.out") ++ @diff -q $(SRC_PATH)/$*.out $*.test.out ++ @diff -q $(SRC_PATH)/$*.err $*.test.err ++ @diff -q $(SRC_PATH)/$*.exit $*.test.exit + + # Consolidated targets + +-- +1.7.11.7 + diff --git a/SOURCES/kvm-tests-QAPI-schema-parser-tests.patch b/SOURCES/kvm-tests-QAPI-schema-parser-tests.patch new file mode 100644 index 0000000..033c8d6 --- /dev/null +++ b/SOURCES/kvm-tests-QAPI-schema-parser-tests.patch @@ -0,0 +1,713 @@ +From 6a72b8101fdaa33464d6f82e7a7963e4aa135f41 Mon Sep 17 00:00:00 2001 +Message-Id: <6a72b8101fdaa33464d6f82e7a7963e4aa135f41.1387369730.git.minovotn@redhat.com> +In-Reply-To: <091eecc4fa42754760dfff393dabcc2b444e9693.1387369730.git.minovotn@redhat.com> +References: <091eecc4fa42754760dfff393dabcc2b444e9693.1387369730.git.minovotn@redhat.com> +From: Markus Armbruster +Date: Tue, 10 Dec 2013 15:29:11 +0100 +Subject: [PATCH 11/21] tests: QAPI schema parser tests + +RH-Author: Markus Armbruster +Message-id: <1386689361-30281-9-git-send-email-armbru@redhat.com> +Patchwork-id: 56130 +O-Subject: [PATCH 7.0 qemu-kvm 08/18] tests: QAPI schema parser tests +Bugzilla: 997915 +RH-Acked-by: Laszlo Ersek +RH-Acked-by: Kevin Wolf +RH-Acked-by: Luiz Capitulino + +From: Markus Armbruster + +The parser handles erroneous input badly. To be improved shortly. + +Signed-off-by: Markus Armbruster +Message-id: 1374939721-7876-2-git-send-email-armbru@redhat.com +Signed-off-by: Anthony Liguori +(cherry picked from commit 98626572f18ddc61c08588c32a1773bc91f8624e) +--- + configure | 2 +- + tests/Makefile | 24 ++++++++++++++++++++++-- + tests/qapi-schema/comments.err | 0 + tests/qapi-schema/comments.exit | 1 + + tests/qapi-schema/comments.json | 4 ++++ + tests/qapi-schema/comments.out | 3 +++ + tests/qapi-schema/empty.err | 0 + tests/qapi-schema/empty.exit | 1 + + tests/qapi-schema/empty.json | 0 + tests/qapi-schema/empty.out | 3 +++ + tests/qapi-schema/funny-char.err | 0 + tests/qapi-schema/funny-char.exit | 1 + + tests/qapi-schema/funny-char.json | 2 ++ + tests/qapi-schema/funny-char.out | 3 +++ + tests/qapi-schema/indented-expr.err | 0 + tests/qapi-schema/indented-expr.exit | 1 + + tests/qapi-schema/indented-expr.json | 2 ++ + tests/qapi-schema/indented-expr.out | 3 +++ + tests/qapi-schema/missing-colon.err | 0 + tests/qapi-schema/missing-colon.exit | 1 + + tests/qapi-schema/missing-colon.json | 2 ++ + tests/qapi-schema/missing-colon.out | 3 +++ + tests/qapi-schema/missing-comma-list.err | 0 + tests/qapi-schema/missing-comma-list.exit | 1 + + tests/qapi-schema/missing-comma-list.json | 2 ++ + tests/qapi-schema/missing-comma-list.out | 3 +++ + tests/qapi-schema/missing-comma-object.err | 0 + tests/qapi-schema/missing-comma-object.exit | 1 + + tests/qapi-schema/missing-comma-object.json | 2 ++ + tests/qapi-schema/missing-comma-object.out | 3 +++ + tests/qapi-schema/non-objects.err | 1 + + tests/qapi-schema/non-objects.exit | 1 + + tests/qapi-schema/non-objects.json | 2 ++ + tests/qapi-schema/non-objects.out | 0 + tests/qapi-schema/quoted-structural-chars.err | 0 + tests/qapi-schema/quoted-structural-chars.exit | 1 + + tests/qapi-schema/quoted-structural-chars.json | 1 + + tests/qapi-schema/quoted-structural-chars.out | 3 +++ + tests/qapi-schema/test-qapi.py | 25 +++++++++++++++++++++++++ + tests/qapi-schema/trailing-comma-list.err | 0 + tests/qapi-schema/trailing-comma-list.exit | 1 + + tests/qapi-schema/trailing-comma-list.json | 2 ++ + tests/qapi-schema/trailing-comma-list.out | 3 +++ + tests/qapi-schema/trailing-comma-object.err | 0 + tests/qapi-schema/trailing-comma-object.exit | 1 + + tests/qapi-schema/trailing-comma-object.json | 2 ++ + tests/qapi-schema/trailing-comma-object.out | 3 +++ + tests/qapi-schema/unclosed-list.err | 1 + + tests/qapi-schema/unclosed-list.exit | 1 + + tests/qapi-schema/unclosed-list.json | 1 + + tests/qapi-schema/unclosed-list.out | 0 + tests/qapi-schema/unclosed-object.err | 1 + + tests/qapi-schema/unclosed-object.exit | 1 + + tests/qapi-schema/unclosed-object.json | 1 + + tests/qapi-schema/unclosed-object.out | 0 + tests/qapi-schema/unclosed-string.err | 1 + + tests/qapi-schema/unclosed-string.exit | 1 + + tests/qapi-schema/unclosed-string.json | 2 ++ + tests/qapi-schema/unclosed-string.out | 0 + 59 files changed, 121 insertions(+), 3 deletions(-) + create mode 100644 tests/qapi-schema/comments.err + create mode 100644 tests/qapi-schema/comments.exit + create mode 100644 tests/qapi-schema/comments.json + create mode 100644 tests/qapi-schema/comments.out + create mode 100644 tests/qapi-schema/empty.err + create mode 100644 tests/qapi-schema/empty.exit + create mode 100644 tests/qapi-schema/empty.json + create mode 100644 tests/qapi-schema/empty.out + create mode 100644 tests/qapi-schema/funny-char.err + create mode 100644 tests/qapi-schema/funny-char.exit + create mode 100644 tests/qapi-schema/funny-char.json + create mode 100644 tests/qapi-schema/funny-char.out + create mode 100644 tests/qapi-schema/indented-expr.err + create mode 100644 tests/qapi-schema/indented-expr.exit + create mode 100644 tests/qapi-schema/indented-expr.json + create mode 100644 tests/qapi-schema/indented-expr.out + create mode 100644 tests/qapi-schema/missing-colon.err + create mode 100644 tests/qapi-schema/missing-colon.exit + create mode 100644 tests/qapi-schema/missing-colon.json + create mode 100644 tests/qapi-schema/missing-colon.out + create mode 100644 tests/qapi-schema/missing-comma-list.err + create mode 100644 tests/qapi-schema/missing-comma-list.exit + create mode 100644 tests/qapi-schema/missing-comma-list.json + create mode 100644 tests/qapi-schema/missing-comma-list.out + create mode 100644 tests/qapi-schema/missing-comma-object.err + create mode 100644 tests/qapi-schema/missing-comma-object.exit + create mode 100644 tests/qapi-schema/missing-comma-object.json + create mode 100644 tests/qapi-schema/missing-comma-object.out + create mode 100644 tests/qapi-schema/non-objects.err + create mode 100644 tests/qapi-schema/non-objects.exit + create mode 100644 tests/qapi-schema/non-objects.json + create mode 100644 tests/qapi-schema/non-objects.out + create mode 100644 tests/qapi-schema/quoted-structural-chars.err + create mode 100644 tests/qapi-schema/quoted-structural-chars.exit + create mode 100644 tests/qapi-schema/quoted-structural-chars.json + create mode 100644 tests/qapi-schema/quoted-structural-chars.out + create mode 100644 tests/qapi-schema/test-qapi.py + create mode 100644 tests/qapi-schema/trailing-comma-list.err + create mode 100644 tests/qapi-schema/trailing-comma-list.exit + create mode 100644 tests/qapi-schema/trailing-comma-list.json + create mode 100644 tests/qapi-schema/trailing-comma-list.out + create mode 100644 tests/qapi-schema/trailing-comma-object.err + create mode 100644 tests/qapi-schema/trailing-comma-object.exit + create mode 100644 tests/qapi-schema/trailing-comma-object.json + create mode 100644 tests/qapi-schema/trailing-comma-object.out + create mode 100644 tests/qapi-schema/unclosed-list.err + create mode 100644 tests/qapi-schema/unclosed-list.exit + create mode 100644 tests/qapi-schema/unclosed-list.json + create mode 100644 tests/qapi-schema/unclosed-list.out + create mode 100644 tests/qapi-schema/unclosed-object.err + create mode 100644 tests/qapi-schema/unclosed-object.exit + create mode 100644 tests/qapi-schema/unclosed-object.json + create mode 100644 tests/qapi-schema/unclosed-object.out + create mode 100644 tests/qapi-schema/unclosed-string.err + create mode 100644 tests/qapi-schema/unclosed-string.exit + create mode 100644 tests/qapi-schema/unclosed-string.json + create mode 100644 tests/qapi-schema/unclosed-string.out + +diff --git a/tests/qapi-schema/unclosed-string.out b/tests/qapi-schema/unclosed-string.out +new file mode 100644 +index 0000000..e69de29 + +Signed-off-by: Michal Novotny +--- + configure | 2 +- + tests/Makefile | 24 ++++++++++++++++++++++-- + tests/qapi-schema/comments.exit | 1 + + tests/qapi-schema/comments.json | 4 ++++ + tests/qapi-schema/comments.out | 3 +++ + tests/qapi-schema/empty.exit | 1 + + tests/qapi-schema/empty.out | 3 +++ + tests/qapi-schema/funny-char.exit | 1 + + tests/qapi-schema/funny-char.json | 2 ++ + tests/qapi-schema/funny-char.out | 3 +++ + tests/qapi-schema/indented-expr.exit | 1 + + tests/qapi-schema/indented-expr.json | 2 ++ + tests/qapi-schema/indented-expr.out | 3 +++ + tests/qapi-schema/missing-colon.exit | 1 + + tests/qapi-schema/missing-colon.json | 2 ++ + tests/qapi-schema/missing-colon.out | 3 +++ + tests/qapi-schema/missing-comma-list.exit | 1 + + tests/qapi-schema/missing-comma-list.json | 2 ++ + tests/qapi-schema/missing-comma-list.out | 3 +++ + tests/qapi-schema/missing-comma-object.exit | 1 + + tests/qapi-schema/missing-comma-object.json | 2 ++ + tests/qapi-schema/missing-comma-object.out | 3 +++ + tests/qapi-schema/non-objects.err | 1 + + tests/qapi-schema/non-objects.exit | 1 + + tests/qapi-schema/non-objects.json | 2 ++ + tests/qapi-schema/quoted-structural-chars.exit | 1 + + tests/qapi-schema/quoted-structural-chars.json | 1 + + tests/qapi-schema/quoted-structural-chars.out | 3 +++ + tests/qapi-schema/test-qapi.py | 25 +++++++++++++++++++++++++ + tests/qapi-schema/trailing-comma-list.exit | 1 + + tests/qapi-schema/trailing-comma-list.json | 2 ++ + tests/qapi-schema/trailing-comma-list.out | 3 +++ + tests/qapi-schema/trailing-comma-object.exit | 1 + + tests/qapi-schema/trailing-comma-object.json | 2 ++ + tests/qapi-schema/trailing-comma-object.out | 3 +++ + tests/qapi-schema/unclosed-list.err | 1 + + tests/qapi-schema/unclosed-list.exit | 1 + + tests/qapi-schema/unclosed-list.json | 1 + + tests/qapi-schema/unclosed-object.err | 1 + + tests/qapi-schema/unclosed-object.exit | 1 + + tests/qapi-schema/unclosed-object.json | 1 + + tests/qapi-schema/unclosed-string.err | 1 + + tests/qapi-schema/unclosed-string.exit | 1 + + tests/qapi-schema/unclosed-string.json | 2 ++ + 44 files changed, 121 insertions(+), 3 deletions(-) + create mode 100644 tests/qapi-schema/comments.err + create mode 100644 tests/qapi-schema/comments.exit + create mode 100644 tests/qapi-schema/comments.json + create mode 100644 tests/qapi-schema/comments.out + create mode 100644 tests/qapi-schema/empty.err + create mode 100644 tests/qapi-schema/empty.exit + create mode 100644 tests/qapi-schema/empty.json + create mode 100644 tests/qapi-schema/empty.out + create mode 100644 tests/qapi-schema/funny-char.err + create mode 100644 tests/qapi-schema/funny-char.exit + create mode 100644 tests/qapi-schema/funny-char.json + create mode 100644 tests/qapi-schema/funny-char.out + create mode 100644 tests/qapi-schema/indented-expr.err + create mode 100644 tests/qapi-schema/indented-expr.exit + create mode 100644 tests/qapi-schema/indented-expr.json + create mode 100644 tests/qapi-schema/indented-expr.out + create mode 100644 tests/qapi-schema/missing-colon.err + create mode 100644 tests/qapi-schema/missing-colon.exit + create mode 100644 tests/qapi-schema/missing-colon.json + create mode 100644 tests/qapi-schema/missing-colon.out + create mode 100644 tests/qapi-schema/missing-comma-list.err + create mode 100644 tests/qapi-schema/missing-comma-list.exit + create mode 100644 tests/qapi-schema/missing-comma-list.json + create mode 100644 tests/qapi-schema/missing-comma-list.out + create mode 100644 tests/qapi-schema/missing-comma-object.err + create mode 100644 tests/qapi-schema/missing-comma-object.exit + create mode 100644 tests/qapi-schema/missing-comma-object.json + create mode 100644 tests/qapi-schema/missing-comma-object.out + create mode 100644 tests/qapi-schema/non-objects.err + create mode 100644 tests/qapi-schema/non-objects.exit + create mode 100644 tests/qapi-schema/non-objects.json + create mode 100644 tests/qapi-schema/non-objects.out + create mode 100644 tests/qapi-schema/quoted-structural-chars.err + create mode 100644 tests/qapi-schema/quoted-structural-chars.exit + create mode 100644 tests/qapi-schema/quoted-structural-chars.json + create mode 100644 tests/qapi-schema/quoted-structural-chars.out + create mode 100644 tests/qapi-schema/test-qapi.py + create mode 100644 tests/qapi-schema/trailing-comma-list.err + create mode 100644 tests/qapi-schema/trailing-comma-list.exit + create mode 100644 tests/qapi-schema/trailing-comma-list.json + create mode 100644 tests/qapi-schema/trailing-comma-list.out + create mode 100644 tests/qapi-schema/trailing-comma-object.err + create mode 100644 tests/qapi-schema/trailing-comma-object.exit + create mode 100644 tests/qapi-schema/trailing-comma-object.json + create mode 100644 tests/qapi-schema/trailing-comma-object.out + create mode 100644 tests/qapi-schema/unclosed-list.err + create mode 100644 tests/qapi-schema/unclosed-list.exit + create mode 100644 tests/qapi-schema/unclosed-list.json + create mode 100644 tests/qapi-schema/unclosed-list.out + create mode 100644 tests/qapi-schema/unclosed-object.err + create mode 100644 tests/qapi-schema/unclosed-object.exit + create mode 100644 tests/qapi-schema/unclosed-object.json + create mode 100644 tests/qapi-schema/unclosed-object.out + create mode 100644 tests/qapi-schema/unclosed-string.err + create mode 100644 tests/qapi-schema/unclosed-string.exit + create mode 100644 tests/qapi-schema/unclosed-string.json + +diff --git a/configure b/configure +index f86793d..0a729ac 100755 +--- a/configure ++++ b/configure +@@ -4511,7 +4511,7 @@ if [ "$dtc_internal" = "yes" ]; then + fi + + # build tree in object directory in case the source is not in the current directory +-DIRS="tests tests/tcg tests/tcg/cris tests/tcg/lm32 tests/libqos" ++DIRS="tests tests/tcg tests/tcg/cris tests/tcg/lm32 tests/libqos tests/qapi-schema" + DIRS="$DIRS pc-bios/optionrom pc-bios/spapr-rtas pc-bios/s390-ccw" + DIRS="$DIRS roms/seabios roms/vgabios" + DIRS="$DIRS qapi-generated" +diff --git a/tests/Makefile b/tests/Makefile +index 2e9093e..e96982b 100644 +--- a/tests/Makefile ++++ b/tests/Makefile +@@ -70,6 +70,14 @@ gcov-files-sparc64-y += hw/m48t59.c + check-qtest-arm-y = tests/tmp105-test$(EXESUF) + gcov-files-arm-y += hw/tmp105.c + ++check-qapi-schema-y := $(addprefix tests/qapi-schema/, \ ++ comments.json empty.json funny-char.json indented-expr.json \ ++ missing-colon.json missing-comma-list.json \ ++ missing-comma-object.json non-objects.json \ ++ quoted-structural-chars.json \ ++ trailing-comma-list.json trailing-comma-object.json \ ++ unclosed-list.json unclosed-object.json unclosed-string.json) ++ + GENERATED_HEADERS += tests/test-qapi-types.h tests/test-qapi-visit.h tests/test-qmp-commands.h + + test-obj-y = tests/check-qint.o tests/check-qstring.o tests/check-qdict.o \ +@@ -157,6 +165,7 @@ check-help: + @echo " make check-qtest-TARGET Run qtest tests for given target" + @echo " make check-qtest Run qtest tests" + @echo " make check-unit Run qobject tests" ++ @echo " make check-qapi-schema Run QAPI schema tests" + @echo " make check-block Run block tests" + @echo " make check-report.html Generates an HTML test report" + @echo +@@ -219,12 +228,23 @@ check-report.html: check-report.xml + check-tests/qemu-iotests-quick.sh: tests/qemu-iotests-quick.sh qemu-img$(EXESUF) qemu-io$(EXESUF) + $< + ++.PHONY: check-tests/test-qapi.py ++check-tests/test-qapi.py: tests/test-qapi.py ++ ++.PHONY: $(patsubst %, check-%, $(check-qapi-schema-y)) ++$(patsubst %, check-%, $(check-qapi-schema-y)): check-%.json: $(SRC_PATH)/%.json ++ $(call quiet-command, PYTHONPATH=$(SRC_PATH)/scripts $(PYTHON) $(SRC_PATH)/tests/qapi-schema/test-qapi.py <$^ >$*.out 2>$*.err; echo $$? >$*.exit, " TEST $*.out") ++ @diff -q $(SRC_PATH)/$*.out $*.out ++ @diff -q $(SRC_PATH)/$*.err $*.err ++ @diff -q $(SRC_PATH)/$*.exit $*.exit ++ + # Consolidated targets + +-.PHONY: check-qtest check-unit check ++.PHONY: check-qapi-schema check-qtest check-unit check ++check-qapi-schema: $(patsubst %,check-%, $(check-qapi-schema-y)) + check-qtest: $(patsubst %,check-qtest-%, $(QTEST_TARGETS)) + check-unit: $(patsubst %,check-%, $(check-unit-y)) + check-block: $(patsubst %,check-%, $(check-block-y)) +-check: check-unit check-qtest ++check: check-qapi-schema check-unit check-qtest + + -include $(wildcard tests/*.d) +diff --git a/tests/qapi-schema/comments.err b/tests/qapi-schema/comments.err +new file mode 100644 +index 0000000..e69de29 +diff --git a/tests/qapi-schema/comments.exit b/tests/qapi-schema/comments.exit +new file mode 100644 +index 0000000..573541a +--- /dev/null ++++ b/tests/qapi-schema/comments.exit +@@ -0,0 +1 @@ ++0 +diff --git a/tests/qapi-schema/comments.json b/tests/qapi-schema/comments.json +new file mode 100644 +index 0000000..e643f3a +--- /dev/null ++++ b/tests/qapi-schema/comments.json +@@ -0,0 +1,4 @@ ++# Unindented comment ++{ 'enum': 'Status', # Comment to the right of code ++ # Indented comment ++ 'data': [ 'good', 'bad', 'ugly' ] } +diff --git a/tests/qapi-schema/comments.out b/tests/qapi-schema/comments.out +new file mode 100644 +index 0000000..e3bd904 +--- /dev/null ++++ b/tests/qapi-schema/comments.out +@@ -0,0 +1,3 @@ ++[OrderedDict([('enum', 'Status'), ('data', ['good', 'bad', 'ugly'])])] ++['Status'] ++[] +diff --git a/tests/qapi-schema/empty.err b/tests/qapi-schema/empty.err +new file mode 100644 +index 0000000..e69de29 +diff --git a/tests/qapi-schema/empty.exit b/tests/qapi-schema/empty.exit +new file mode 100644 +index 0000000..573541a +--- /dev/null ++++ b/tests/qapi-schema/empty.exit +@@ -0,0 +1 @@ ++0 +diff --git a/tests/qapi-schema/empty.json b/tests/qapi-schema/empty.json +new file mode 100644 +index 0000000..e69de29 +diff --git a/tests/qapi-schema/empty.out b/tests/qapi-schema/empty.out +new file mode 100644 +index 0000000..b7f89a4 +--- /dev/null ++++ b/tests/qapi-schema/empty.out +@@ -0,0 +1,3 @@ ++[] ++[] ++[] +diff --git a/tests/qapi-schema/funny-char.err b/tests/qapi-schema/funny-char.err +new file mode 100644 +index 0000000..e69de29 +diff --git a/tests/qapi-schema/funny-char.exit b/tests/qapi-schema/funny-char.exit +new file mode 100644 +index 0000000..573541a +--- /dev/null ++++ b/tests/qapi-schema/funny-char.exit +@@ -0,0 +1 @@ ++0 +diff --git a/tests/qapi-schema/funny-char.json b/tests/qapi-schema/funny-char.json +new file mode 100644 +index 0000000..d4973a2 +--- /dev/null ++++ b/tests/qapi-schema/funny-char.json +@@ -0,0 +1,2 @@ ++{ 'enum': 'Status', ++ 'data': [ 'good', 'bad', 'ugly' ]; } +diff --git a/tests/qapi-schema/funny-char.out b/tests/qapi-schema/funny-char.out +new file mode 100644 +index 0000000..e3bd904 +--- /dev/null ++++ b/tests/qapi-schema/funny-char.out +@@ -0,0 +1,3 @@ ++[OrderedDict([('enum', 'Status'), ('data', ['good', 'bad', 'ugly'])])] ++['Status'] ++[] +diff --git a/tests/qapi-schema/indented-expr.err b/tests/qapi-schema/indented-expr.err +new file mode 100644 +index 0000000..e69de29 +diff --git a/tests/qapi-schema/indented-expr.exit b/tests/qapi-schema/indented-expr.exit +new file mode 100644 +index 0000000..573541a +--- /dev/null ++++ b/tests/qapi-schema/indented-expr.exit +@@ -0,0 +1 @@ ++0 +diff --git a/tests/qapi-schema/indented-expr.json b/tests/qapi-schema/indented-expr.json +new file mode 100644 +index 0000000..d80af60 +--- /dev/null ++++ b/tests/qapi-schema/indented-expr.json +@@ -0,0 +1,2 @@ ++{ 'id' : 'eins' } ++ { 'id' : 'zwei' } +diff --git a/tests/qapi-schema/indented-expr.out b/tests/qapi-schema/indented-expr.out +new file mode 100644 +index 0000000..98ae692 +--- /dev/null ++++ b/tests/qapi-schema/indented-expr.out +@@ -0,0 +1,3 @@ ++[OrderedDict([('id', 'eins')])] ++[] ++[] +diff --git a/tests/qapi-schema/missing-colon.err b/tests/qapi-schema/missing-colon.err +new file mode 100644 +index 0000000..e69de29 +diff --git a/tests/qapi-schema/missing-colon.exit b/tests/qapi-schema/missing-colon.exit +new file mode 100644 +index 0000000..573541a +--- /dev/null ++++ b/tests/qapi-schema/missing-colon.exit +@@ -0,0 +1 @@ ++0 +diff --git a/tests/qapi-schema/missing-colon.json b/tests/qapi-schema/missing-colon.json +new file mode 100644 +index 0000000..6fc27ce +--- /dev/null ++++ b/tests/qapi-schema/missing-colon.json +@@ -0,0 +1,2 @@ ++{ 'enum' 'Status', ++ 'data': [ 'good', 'bad', 'ugly' ] } +diff --git a/tests/qapi-schema/missing-colon.out b/tests/qapi-schema/missing-colon.out +new file mode 100644 +index 0000000..50f827e +--- /dev/null ++++ b/tests/qapi-schema/missing-colon.out +@@ -0,0 +1,3 @@ ++[OrderedDict([('enum', ','), ('data', ['good', 'bad', 'ugly'])])] ++[','] ++[] +diff --git a/tests/qapi-schema/missing-comma-list.err b/tests/qapi-schema/missing-comma-list.err +new file mode 100644 +index 0000000..e69de29 +diff --git a/tests/qapi-schema/missing-comma-list.exit b/tests/qapi-schema/missing-comma-list.exit +new file mode 100644 +index 0000000..573541a +--- /dev/null ++++ b/tests/qapi-schema/missing-comma-list.exit +@@ -0,0 +1 @@ ++0 +diff --git a/tests/qapi-schema/missing-comma-list.json b/tests/qapi-schema/missing-comma-list.json +new file mode 100644 +index 0000000..1af39b2 +--- /dev/null ++++ b/tests/qapi-schema/missing-comma-list.json +@@ -0,0 +1,2 @@ ++{ 'enum': 'Status', ++ 'data': [ 'good' 'bad', 'ugly' ] } +diff --git a/tests/qapi-schema/missing-comma-list.out b/tests/qapi-schema/missing-comma-list.out +new file mode 100644 +index 0000000..e3bd904 +--- /dev/null ++++ b/tests/qapi-schema/missing-comma-list.out +@@ -0,0 +1,3 @@ ++[OrderedDict([('enum', 'Status'), ('data', ['good', 'bad', 'ugly'])])] ++['Status'] ++[] +diff --git a/tests/qapi-schema/missing-comma-object.err b/tests/qapi-schema/missing-comma-object.err +new file mode 100644 +index 0000000..e69de29 +diff --git a/tests/qapi-schema/missing-comma-object.exit b/tests/qapi-schema/missing-comma-object.exit +new file mode 100644 +index 0000000..573541a +--- /dev/null ++++ b/tests/qapi-schema/missing-comma-object.exit +@@ -0,0 +1 @@ ++0 +diff --git a/tests/qapi-schema/missing-comma-object.json b/tests/qapi-schema/missing-comma-object.json +new file mode 100644 +index 0000000..50f5178 +--- /dev/null ++++ b/tests/qapi-schema/missing-comma-object.json +@@ -0,0 +1,2 @@ ++{ 'enum': 'Status' ++ 'data': [ 'good', 'bad', 'ugly' ] } +diff --git a/tests/qapi-schema/missing-comma-object.out b/tests/qapi-schema/missing-comma-object.out +new file mode 100644 +index 0000000..e3bd904 +--- /dev/null ++++ b/tests/qapi-schema/missing-comma-object.out +@@ -0,0 +1,3 @@ ++[OrderedDict([('enum', 'Status'), ('data', ['good', 'bad', 'ugly'])])] ++['Status'] ++[] +diff --git a/tests/qapi-schema/non-objects.err b/tests/qapi-schema/non-objects.err +new file mode 100644 +index 0000000..48c849d +--- /dev/null ++++ b/tests/qapi-schema/non-objects.err +@@ -0,0 +1 @@ ++Crashed: +diff --git a/tests/qapi-schema/non-objects.exit b/tests/qapi-schema/non-objects.exit +new file mode 100644 +index 0000000..d00491f +--- /dev/null ++++ b/tests/qapi-schema/non-objects.exit +@@ -0,0 +1 @@ ++1 +diff --git a/tests/qapi-schema/non-objects.json b/tests/qapi-schema/non-objects.json +new file mode 100644 +index 0000000..f3fa851 +--- /dev/null ++++ b/tests/qapi-schema/non-objects.json +@@ -0,0 +1,2 @@ ++'string' ++[ ] +diff --git a/tests/qapi-schema/non-objects.out b/tests/qapi-schema/non-objects.out +new file mode 100644 +index 0000000..e69de29 +diff --git a/tests/qapi-schema/quoted-structural-chars.err b/tests/qapi-schema/quoted-structural-chars.err +new file mode 100644 +index 0000000..e69de29 +diff --git a/tests/qapi-schema/quoted-structural-chars.exit b/tests/qapi-schema/quoted-structural-chars.exit +new file mode 100644 +index 0000000..573541a +--- /dev/null ++++ b/tests/qapi-schema/quoted-structural-chars.exit +@@ -0,0 +1 @@ ++0 +diff --git a/tests/qapi-schema/quoted-structural-chars.json b/tests/qapi-schema/quoted-structural-chars.json +new file mode 100644 +index 0000000..9fe657a +--- /dev/null ++++ b/tests/qapi-schema/quoted-structural-chars.json +@@ -0,0 +1 @@ ++'{' 'key1' ':' 'value1' ',' 'key2' ':' '[' ']' '}' +diff --git a/tests/qapi-schema/quoted-structural-chars.out b/tests/qapi-schema/quoted-structural-chars.out +new file mode 100644 +index 0000000..85405be +--- /dev/null ++++ b/tests/qapi-schema/quoted-structural-chars.out +@@ -0,0 +1,3 @@ ++[OrderedDict([('key1', 'value1'), ('key2', [])])] ++[] ++[] +diff --git a/tests/qapi-schema/test-qapi.py b/tests/qapi-schema/test-qapi.py +new file mode 100644 +index 0000000..3280eff +--- /dev/null ++++ b/tests/qapi-schema/test-qapi.py +@@ -0,0 +1,25 @@ ++# ++# QAPI parser test harness ++# ++# Copyright (c) 2013 Red Hat Inc. ++# ++# Authors: ++# Markus Armbruster ++# ++# This work is licensed under the terms of the GNU GPL, version 2 or later. ++# See the COPYING file in the top-level directory. ++# ++ ++from qapi import * ++from pprint import pprint ++import sys ++ ++try: ++ exprs = parse_schema(sys.stdin) ++except: ++ print >>sys.stderr, "Crashed:", sys.exc_info()[0] ++ exit(1) ++ ++pprint(exprs) ++pprint(enum_types) ++pprint(struct_types) +diff --git a/tests/qapi-schema/trailing-comma-list.err b/tests/qapi-schema/trailing-comma-list.err +new file mode 100644 +index 0000000..e69de29 +diff --git a/tests/qapi-schema/trailing-comma-list.exit b/tests/qapi-schema/trailing-comma-list.exit +new file mode 100644 +index 0000000..573541a +--- /dev/null ++++ b/tests/qapi-schema/trailing-comma-list.exit +@@ -0,0 +1 @@ ++0 +diff --git a/tests/qapi-schema/trailing-comma-list.json b/tests/qapi-schema/trailing-comma-list.json +new file mode 100644 +index 0000000..9b0c8bd +--- /dev/null ++++ b/tests/qapi-schema/trailing-comma-list.json +@@ -0,0 +1,2 @@ ++{ 'enum': 'Status', ++ 'data': [ 'good', 'bad', 'ugly', ] } +diff --git a/tests/qapi-schema/trailing-comma-list.out b/tests/qapi-schema/trailing-comma-list.out +new file mode 100644 +index 0000000..e3bd904 +--- /dev/null ++++ b/tests/qapi-schema/trailing-comma-list.out +@@ -0,0 +1,3 @@ ++[OrderedDict([('enum', 'Status'), ('data', ['good', 'bad', 'ugly'])])] ++['Status'] ++[] +diff --git a/tests/qapi-schema/trailing-comma-object.err b/tests/qapi-schema/trailing-comma-object.err +new file mode 100644 +index 0000000..e69de29 +diff --git a/tests/qapi-schema/trailing-comma-object.exit b/tests/qapi-schema/trailing-comma-object.exit +new file mode 100644 +index 0000000..573541a +--- /dev/null ++++ b/tests/qapi-schema/trailing-comma-object.exit +@@ -0,0 +1 @@ ++0 +diff --git a/tests/qapi-schema/trailing-comma-object.json b/tests/qapi-schema/trailing-comma-object.json +new file mode 100644 +index 0000000..bbaea55 +--- /dev/null ++++ b/tests/qapi-schema/trailing-comma-object.json +@@ -0,0 +1,2 @@ ++{ 'enum': 'Status', ++ 'data': [ 'good', 'bad', 'ugly' ], } +diff --git a/tests/qapi-schema/trailing-comma-object.out b/tests/qapi-schema/trailing-comma-object.out +new file mode 100644 +index 0000000..e3bd904 +--- /dev/null ++++ b/tests/qapi-schema/trailing-comma-object.out +@@ -0,0 +1,3 @@ ++[OrderedDict([('enum', 'Status'), ('data', ['good', 'bad', 'ugly'])])] ++['Status'] ++[] +diff --git a/tests/qapi-schema/unclosed-list.err b/tests/qapi-schema/unclosed-list.err +new file mode 100644 +index 0000000..f9a9c2a +--- /dev/null ++++ b/tests/qapi-schema/unclosed-list.err +@@ -0,0 +1 @@ ++Crashed: +diff --git a/tests/qapi-schema/unclosed-list.exit b/tests/qapi-schema/unclosed-list.exit +new file mode 100644 +index 0000000..d00491f +--- /dev/null ++++ b/tests/qapi-schema/unclosed-list.exit +@@ -0,0 +1 @@ ++1 +diff --git a/tests/qapi-schema/unclosed-list.json b/tests/qapi-schema/unclosed-list.json +new file mode 100644 +index 0000000..e3e9566 +--- /dev/null ++++ b/tests/qapi-schema/unclosed-list.json +@@ -0,0 +1 @@ ++{ 'key': [ 'value' } +diff --git a/tests/qapi-schema/unclosed-list.out b/tests/qapi-schema/unclosed-list.out +new file mode 100644 +index 0000000..e69de29 +diff --git a/tests/qapi-schema/unclosed-object.err b/tests/qapi-schema/unclosed-object.err +new file mode 100644 +index 0000000..f9a9c2a +--- /dev/null ++++ b/tests/qapi-schema/unclosed-object.err +@@ -0,0 +1 @@ ++Crashed: +diff --git a/tests/qapi-schema/unclosed-object.exit b/tests/qapi-schema/unclosed-object.exit +new file mode 100644 +index 0000000..d00491f +--- /dev/null ++++ b/tests/qapi-schema/unclosed-object.exit +@@ -0,0 +1 @@ ++1 +diff --git a/tests/qapi-schema/unclosed-object.json b/tests/qapi-schema/unclosed-object.json +new file mode 100644 +index 0000000..8ac069d +--- /dev/null ++++ b/tests/qapi-schema/unclosed-object.json +@@ -0,0 +1 @@ ++{ 'key': [ 'value' ] +diff --git a/tests/qapi-schema/unclosed-object.out b/tests/qapi-schema/unclosed-object.out +new file mode 100644 +index 0000000..e69de29 +diff --git a/tests/qapi-schema/unclosed-string.err b/tests/qapi-schema/unclosed-string.err +new file mode 100644 +index 0000000..5af46c2 +--- /dev/null ++++ b/tests/qapi-schema/unclosed-string.err +@@ -0,0 +1 @@ ++Crashed: +diff --git a/tests/qapi-schema/unclosed-string.exit b/tests/qapi-schema/unclosed-string.exit +new file mode 100644 +index 0000000..d00491f +--- /dev/null ++++ b/tests/qapi-schema/unclosed-string.exit +@@ -0,0 +1 @@ ++1 +diff --git a/tests/qapi-schema/unclosed-string.json b/tests/qapi-schema/unclosed-string.json +new file mode 100644 +index 0000000..8c16b6b +--- /dev/null ++++ b/tests/qapi-schema/unclosed-string.json +@@ -0,0 +1,2 @@ ++{ 'text': 'lorem ips ++} +-- +1.7.11.7 + diff --git a/SOURCES/kvm-tests-Use-qapi-schema-test.json-as-schema-parser-tes.patch b/SOURCES/kvm-tests-Use-qapi-schema-test.json-as-schema-parser-tes.patch new file mode 100644 index 0000000..8e38077 --- /dev/null +++ b/SOURCES/kvm-tests-Use-qapi-schema-test.json-as-schema-parser-tes.patch @@ -0,0 +1,119 @@ +From 1c4e0e685b539c2ee15d88922a88c9b9998ba8c1 Mon Sep 17 00:00:00 2001 +Message-Id: <1c4e0e685b539c2ee15d88922a88c9b9998ba8c1.1387369730.git.minovotn@redhat.com> +In-Reply-To: <091eecc4fa42754760dfff393dabcc2b444e9693.1387369730.git.minovotn@redhat.com> +References: <091eecc4fa42754760dfff393dabcc2b444e9693.1387369730.git.minovotn@redhat.com> +From: Markus Armbruster +Date: Tue, 10 Dec 2013 15:29:12 +0100 +Subject: [PATCH 12/21] tests: Use qapi-schema-test.json as schema parser test + +RH-Author: Markus Armbruster +Message-id: <1386689361-30281-10-git-send-email-armbru@redhat.com> +Patchwork-id: 56137 +O-Subject: [PATCH 7.0 qemu-kvm 09/18] tests: Use qapi-schema-test.json as schema parser test +Bugzilla: 997915 +RH-Acked-by: Laszlo Ersek +RH-Acked-by: Kevin Wolf +RH-Acked-by: Luiz Capitulino + +From: Markus Armbruster + +Signed-off-by: Markus Armbruster +Reviewed-by: Eric Blake +Message-id: 1374939721-7876-3-git-send-email-armbru@redhat.com +Signed-off-by: Anthony Liguori +(cherry picked from commit 4f193e34c6c41abdd06c134e584312077def2bda) +--- + tests/Makefile | 8 ++++---- + tests/qapi-schema/qapi-schema-test.err | 0 + tests/qapi-schema/qapi-schema-test.exit | 1 + + .../qapi-schema/qapi-schema-test.json | 0 + tests/qapi-schema/qapi-schema-test.out | 19 +++++++++++++++++++ + 5 files changed, 24 insertions(+), 4 deletions(-) + create mode 100644 tests/qapi-schema/qapi-schema-test.err + create mode 100644 tests/qapi-schema/qapi-schema-test.exit + rename qapi-schema-test.json => tests/qapi-schema/qapi-schema-test.json (100%) + create mode 100644 tests/qapi-schema/qapi-schema-test.out + +diff --git a/qapi-schema-test.json b/tests/qapi-schema/qapi-schema-test.json +similarity index 100% +rename from qapi-schema-test.json +rename to tests/qapi-schema/qapi-schema-test.json + +Signed-off-by: Michal Novotny +--- + tests/Makefile | 8 ++++---- + tests/qapi-schema/qapi-schema-test.exit | 1 + + tests/qapi-schema/qapi-schema-test.out | 19 +++++++++++++++++++ + 3 files changed, 24 insertions(+), 4 deletions(-) + create mode 100644 tests/qapi-schema/qapi-schema-test.err + create mode 100644 tests/qapi-schema/qapi-schema-test.exit + create mode 100644 tests/qapi-schema/qapi-schema-test.out + +diff --git a/tests/Makefile b/tests/Makefile +index e96982b..a38f360 100644 +--- a/tests/Makefile ++++ b/tests/Makefile +@@ -74,7 +74,7 @@ check-qapi-schema-y := $(addprefix tests/qapi-schema/, \ + comments.json empty.json funny-char.json indented-expr.json \ + missing-colon.json missing-comma-list.json \ + missing-comma-object.json non-objects.json \ +- quoted-structural-chars.json \ ++ qapi-schema-test.json quoted-structural-chars.json \ + trailing-comma-list.json trailing-comma-object.json \ + unclosed-list.json unclosed-object.json unclosed-string.json) + +@@ -111,13 +111,13 @@ tests/test-xbzrle$(EXESUF): tests/test-xbzrle.o xbzrle.o page_cache.o libqemuuti + tests/test-cutils$(EXESUF): tests/test-cutils.o util/cutils.o + + tests/test-qapi-types.c tests/test-qapi-types.h :\ +-$(SRC_PATH)/qapi-schema-test.json $(SRC_PATH)/scripts/qapi-types.py ++$(SRC_PATH)/tests/qapi-schema/qapi-schema-test.json $(SRC_PATH)/scripts/qapi-types.py + $(call quiet-command,$(PYTHON) $(SRC_PATH)/scripts/qapi-types.py $(gen-out-type) -o tests -p "test-" < $<, " GEN $@") + tests/test-qapi-visit.c tests/test-qapi-visit.h :\ +-$(SRC_PATH)/qapi-schema-test.json $(SRC_PATH)/scripts/qapi-visit.py ++$(SRC_PATH)/tests/qapi-schema/qapi-schema-test.json $(SRC_PATH)/scripts/qapi-visit.py + $(call quiet-command,$(PYTHON) $(SRC_PATH)/scripts/qapi-visit.py $(gen-out-type) -o tests -p "test-" < $<, " GEN $@") + tests/test-qmp-commands.h tests/test-qmp-marshal.c :\ +-$(SRC_PATH)/qapi-schema-test.json $(SRC_PATH)/scripts/qapi-commands.py ++$(SRC_PATH)/tests/qapi-schema/qapi-schema-test.json $(SRC_PATH)/scripts/qapi-commands.py + $(call quiet-command,$(PYTHON) $(SRC_PATH)/scripts/qapi-commands.py $(gen-out-type) -o tests -p "test-" < $<, " GEN $@") + + tests/test-string-output-visitor$(EXESUF): tests/test-string-output-visitor.o $(test-qapi-obj-y) libqemuutil.a libqemustub.a +diff --git a/tests/qapi-schema/qapi-schema-test.err b/tests/qapi-schema/qapi-schema-test.err +new file mode 100644 +index 0000000..e69de29 +diff --git a/tests/qapi-schema/qapi-schema-test.exit b/tests/qapi-schema/qapi-schema-test.exit +new file mode 100644 +index 0000000..573541a +--- /dev/null ++++ b/tests/qapi-schema/qapi-schema-test.exit +@@ -0,0 +1 @@ ++0 +diff --git a/tests/qapi-schema/qapi-schema-test.out b/tests/qapi-schema/qapi-schema-test.out +new file mode 100644 +index 0000000..fb00344 +--- /dev/null ++++ b/tests/qapi-schema/qapi-schema-test.out +@@ -0,0 +1,19 @@ ++[OrderedDict([('enum', 'EnumOne'), ('data', ['value1', 'value2', 'value3'])]), ++ OrderedDict([('type', 'NestedEnumsOne'), ('data', OrderedDict([('enum1', 'EnumOne'), ('*enum2', 'EnumOne'), ('enum3', 'EnumOne'), ('*enum4', 'EnumOne')]))]), ++ OrderedDict([('type', 'UserDefOne'), ('data', OrderedDict([('integer', 'int'), ('string', 'str'), ('*enum1', 'EnumOne')]))]), ++ OrderedDict([('type', 'UserDefTwo'), ('data', OrderedDict([('string', 'str'), ('dict', OrderedDict([('string', 'str'), ('dict', OrderedDict([('userdef', 'UserDefOne'), ('string', 'str')])), ('*dict2', OrderedDict([('userdef', 'UserDefOne'), ('string', 'str')]))]))]))]), ++ OrderedDict([('type', 'UserDefNested'), ('data', OrderedDict([('string0', 'str'), ('dict1', OrderedDict([('string1', 'str'), ('dict2', OrderedDict([('userdef1', 'UserDefOne'), ('string2', 'str')])), ('*dict3', OrderedDict([('userdef2', 'UserDefOne'), ('string3', 'str')]))]))]))]), ++ OrderedDict([('type', 'UserDefA'), ('data', OrderedDict([('boolean', 'bool')]))]), ++ OrderedDict([('type', 'UserDefB'), ('data', OrderedDict([('integer', 'int')]))]), ++ OrderedDict([('union', 'UserDefUnion'), ('data', OrderedDict([('a', 'UserDefA'), ('b', 'UserDefB')]))]), ++ OrderedDict([('union', 'UserDefNativeListUnion'), ('data', OrderedDict([('integer', ['int']), ('s8', ['int8']), ('s16', ['int16']), ('s32', ['int32']), ('s64', ['int64']), ('u8', ['uint8']), ('u16', ['uint16']), ('u32', ['uint32']), ('u64', ['uint64']), ('number', ['number']), ('boolean', ['bool']), ('string', ['str'])]))]), ++ OrderedDict([('command', 'user_def_cmd'), ('data', OrderedDict())]), ++ OrderedDict([('command', 'user_def_cmd1'), ('data', OrderedDict([('ud1a', 'UserDefOne')]))]), ++ OrderedDict([('command', 'user_def_cmd2'), ('data', OrderedDict([('ud1a', 'UserDefOne'), ('ud1b', 'UserDefOne')])), ('returns', 'UserDefTwo')])] ++['EnumOne', 'UserDefUnionKind', 'UserDefNativeListUnionKind'] ++[OrderedDict([('type', 'NestedEnumsOne'), ('data', OrderedDict([('enum1', 'EnumOne'), ('*enum2', 'EnumOne'), ('enum3', 'EnumOne'), ('*enum4', 'EnumOne')]))]), ++ OrderedDict([('type', 'UserDefOne'), ('data', OrderedDict([('integer', 'int'), ('string', 'str'), ('*enum1', 'EnumOne')]))]), ++ OrderedDict([('type', 'UserDefTwo'), ('data', OrderedDict([('string', 'str'), ('dict', OrderedDict([('string', 'str'), ('dict', OrderedDict([('userdef', 'UserDefOne'), ('string', 'str')])), ('*dict2', OrderedDict([('userdef', 'UserDefOne'), ('string', 'str')]))]))]))]), ++ OrderedDict([('type', 'UserDefNested'), ('data', OrderedDict([('string0', 'str'), ('dict1', OrderedDict([('string1', 'str'), ('dict2', OrderedDict([('userdef1', 'UserDefOne'), ('string2', 'str')])), ('*dict3', OrderedDict([('userdef2', 'UserDefOne'), ('string3', 'str')]))]))]))]), ++ OrderedDict([('type', 'UserDefA'), ('data', OrderedDict([('boolean', 'bool')]))]), ++ OrderedDict([('type', 'UserDefB'), ('data', OrderedDict([('integer', 'int')]))])] +-- +1.7.11.7 + diff --git a/SOURCES/kvm-trace-events-Clean-up-after-removal-of-old-usb-host-.patch b/SOURCES/kvm-trace-events-Clean-up-after-removal-of-old-usb-host-.patch new file mode 100644 index 0000000..f1e8db3 --- /dev/null +++ b/SOURCES/kvm-trace-events-Clean-up-after-removal-of-old-usb-host-.patch @@ -0,0 +1,87 @@ +From 2122cd12101fcf8d3289ae516ec4612d986a00d8 Mon Sep 17 00:00:00 2001 +Message-Id: <2122cd12101fcf8d3289ae516ec4612d986a00d8.1387276076.git.minovotn@redhat.com> +In-Reply-To: +References: +From: Markus Armbruster +Date: Tue, 10 Dec 2013 15:12:56 +0100 +Subject: [PATCH 15/16] trace-events: Clean up after removal of old usb-host + code + +RH-Author: Markus Armbruster +Message-id: <1386688376-29521-8-git-send-email-armbru@redhat.com> +Patchwork-id: 56117 +O-Subject: [PATCH 7.0 qemu-kvm 7/7] trace-events: Clean up after removal of old usb-host code +Bugzilla: 997832 +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Eduardo Habkost +RH-Acked-by: Laszlo Ersek + +From: Markus Armbruster + +Commit b5613fd neglected to drop the trace events along with the code. + +Signed-off-by: Markus Armbruster +Signed-off-by: Gerd Hoffmann +(cherry picked from commit 904c063039f5923a07ce35fc40ed78ec6f7dee1a) +--- + trace-events | 13 ------------- + 1 file changed, 13 deletions(-) + +Signed-off-by: Michal Novotny +--- + trace-events | 13 ------------- + 1 file changed, 13 deletions(-) + +diff --git a/trace-events b/trace-events +index 2336943..b72a72f 100644 +--- a/trace-events ++++ b/trace-events +@@ -417,45 +417,32 @@ usb_uas_tmf_abort_task(int addr, uint16_t tag, uint16_t task_tag) "dev %d, tag 0 + usb_uas_tmf_logical_unit_reset(int addr, uint16_t tag, int lun) "dev %d, tag 0x%x, lun %d" + usb_uas_tmf_unsupported(int addr, uint16_t tag, uint32_t function) "dev %d, tag 0x%x, function 0x%x" + +-# hw/usb/host-linux.c + # hw/usb/host-libusb.c + usb_host_open_started(int bus, int addr) "dev %d:%d" + usb_host_open_success(int bus, int addr) "dev %d:%d" + usb_host_open_failure(int bus, int addr) "dev %d:%d" +-usb_host_disconnect(int bus, int addr) "dev %d:%d" + usb_host_close(int bus, int addr) "dev %d:%d" + usb_host_attach_kernel(int bus, int addr, int interface) "dev %d:%d, if %d" + usb_host_detach_kernel(int bus, int addr, int interface) "dev %d:%d, if %d" + usb_host_set_address(int bus, int addr, int config) "dev %d:%d, address %d" + usb_host_set_config(int bus, int addr, int config) "dev %d:%d, config %d" + usb_host_set_interface(int bus, int addr, int interface, int alt) "dev %d:%d, interface %d, alt %d" +-usb_host_claim_interfaces(int bus, int addr, int config, int nif) "dev %d:%d, config %d, nif %d" + usb_host_claim_interface(int bus, int addr, int config, int interface) "dev %d:%d, config %d, if %d" +-usb_host_release_interfaces(int bus, int addr) "dev %d:%d" + usb_host_release_interface(int bus, int addr, int interface) "dev %d:%d, if %d" + usb_host_req_control(int bus, int addr, void *p, int req, int value, int index) "dev %d:%d, packet %p, req 0x%x, value %d, index %d" + usb_host_req_data(int bus, int addr, void *p, int in, int ep, int size) "dev %d:%d, packet %p, in %d, ep %d, size %d" + usb_host_req_complete(int bus, int addr, void *p, int status, int length) "dev %d:%d, packet %p, status %d, length %d" + usb_host_req_emulated(int bus, int addr, void *p, int status) "dev %d:%d, packet %p, status %d" + usb_host_req_canceled(int bus, int addr, void *p) "dev %d:%d, packet %p" +-usb_host_urb_submit(int bus, int addr, void *aurb, int length, int more) "dev %d:%d, aurb %p, length %d, more %d" +-usb_host_urb_complete(int bus, int addr, void *aurb, int status, int length, int more) "dev %d:%d, aurb %p, status %d, length %d, more %d" +-usb_host_urb_canceled(int bus, int addr, void *aurb) "dev %d:%d, aurb %p" +-usb_host_ep_set_halt(int bus, int addr, int ep) "dev %d:%d, ep %d" +-usb_host_ep_clear_halt(int bus, int addr, int ep) "dev %d:%d, ep %d" + usb_host_iso_start(int bus, int addr, int ep) "dev %d:%d, ep %d" + usb_host_iso_stop(int bus, int addr, int ep) "dev %d:%d, ep %d" + usb_host_iso_out_of_bufs(int bus, int addr, int ep) "dev %d:%d, ep %d" +-usb_host_iso_many_urbs(int bus, int addr, int count) "dev %d:%d, count %d" + usb_host_reset(int bus, int addr) "dev %d:%d" + usb_host_auto_scan_enabled(void) + usb_host_auto_scan_disabled(void) +-usb_host_claim_port(int bus, int hub, int port) "bus %d, hub addr %d, port %d" +-usb_host_parse_device(int bus, int addr, int vendor, int product) "dev %d:%d, id %04x:%04x" + usb_host_parse_config(int bus, int addr, int value, int active) "dev %d:%d, value %d, active %d" + usb_host_parse_interface(int bus, int addr, int num, int alt, int active) "dev %d:%d, num %d, alt %d, active %d" + usb_host_parse_endpoint(int bus, int addr, int ep, const char *dir, const char *type, int active) "dev %d:%d, ep %d, %s, %s, active %d" +-usb_host_parse_unknown(int bus, int addr, int len, int type) "dev %d:%d, len %d, type %d" + usb_host_parse_error(int bus, int addr, const char *errmsg) "dev %d:%d, msg %s" + + # hw/scsi/scsi-bus.c +-- +1.7.11.7 + diff --git a/SOURCES/kvm-trace-events-Clean-up-with-scripts-cleanup-trace-eve.patch b/SOURCES/kvm-trace-events-Clean-up-with-scripts-cleanup-trace-eve.patch new file mode 100644 index 0000000..7d47d28 --- /dev/null +++ b/SOURCES/kvm-trace-events-Clean-up-with-scripts-cleanup-trace-eve.patch @@ -0,0 +1,58 @@ +From e0a3caa2206a851a3311bf42ddfb1558314868b1 Mon Sep 17 00:00:00 2001 +Message-Id: +In-Reply-To: +References: +From: Markus Armbruster +Date: Tue, 10 Dec 2013 15:12:55 +0100 +Subject: [PATCH 14/16] trace-events: Clean up with + scripts/cleanup-trace-events.pl again + +RH-Author: Markus Armbruster +Message-id: <1386688376-29521-7-git-send-email-armbru@redhat.com> +Patchwork-id: 56116 +O-Subject: [PATCH 7.0 qemu-kvm 6/7] trace-events: Clean up with scripts/cleanup-trace-events.pl again +Bugzilla: 997832 +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Eduardo Habkost +RH-Acked-by: Laszlo Ersek + +From: Markus Armbruster + +Event qxl_render_blit_guest_primary_initialized is unused since commit +c58c7b9, drop it. + +Commit 42e5b4c moved hw/ppc/xics.c to hw/intc/xics.c without updating +the comment in trace-events. + +"scripts/cleanup-trace-events.pl trace-events | diff trace-events" is +now clean again. + +Signed-off-by: Markus Armbruster +Signed-off-by: Michael Tokarev +(cherry picked from commit ddd0bd480fc07cc45f9cc7e3d113f23cb58b6082) + +Second hunk dropped, because we don't have commit 42e5b4c. +--- + trace-events | 1 - + 1 file changed, 1 deletion(-) + +Signed-off-by: Michal Novotny +--- + trace-events | 1 - + 1 file changed, 1 deletion(-) + +diff --git a/trace-events b/trace-events +index 2a034cb..2336943 100644 +--- a/trace-events ++++ b/trace-events +@@ -1102,7 +1102,6 @@ qemu_spice_wakeup(uint32_t qid) "%d" + qemu_spice_create_update(uint32_t left, uint32_t right, uint32_t top, uint32_t bottom) "lr %d -> %d, tb -> %d -> %d" + + # hw/display/qxl-render.c +-qxl_render_blit_guest_primary_initialized(void) "" + qxl_render_blit(int32_t stride, int32_t left, int32_t right, int32_t top, int32_t bottom) "stride=%d [%d, %d, %d, %d]" + qxl_render_guest_primary_resized(int32_t width, int32_t height, int32_t stride, int32_t bytes_pp, int32_t bits_pp) "%dx%d, stride %d, bpp %d, depth %d" + qxl_render_update_area_done(void *cookie) "%p" +-- +1.7.11.7 + diff --git a/SOURCES/kvm-trace-events-Drop-unused-events.patch b/SOURCES/kvm-trace-events-Drop-unused-events.patch new file mode 100644 index 0000000..7195694 --- /dev/null +++ b/SOURCES/kvm-trace-events-Drop-unused-events.patch @@ -0,0 +1,134 @@ +From 9a52cf8f79e980ccc07e18ad1ad2f410a2546799 Mon Sep 17 00:00:00 2001 +Message-Id: <9a52cf8f79e980ccc07e18ad1ad2f410a2546799.1387276076.git.minovotn@redhat.com> +In-Reply-To: +References: +From: Markus Armbruster +Date: Tue, 10 Dec 2013 15:12:53 +0100 +Subject: [PATCH 12/16] trace-events: Drop unused events + +RH-Author: Markus Armbruster +Message-id: <1386688376-29521-5-git-send-email-armbru@redhat.com> +Patchwork-id: 56115 +O-Subject: [PATCH 7.0 qemu-kvm 4/7] trace-events: Drop unused events +Bugzilla: 997832 +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Eduardo Habkost +RH-Acked-by: Laszlo Ersek + +From: Markus Armbruster + +Dropped event Unused since +mirror_cow 884fea4 +paio_complete 47e6b25 +paio_cancel 47e6b25 +usb_ehci_data 0ce668b +megasas_qf_dequeue never used +megasas_handle_frame never used +megasas_io_continue never used +megasas_iovec_map_failed never used +megasas_dcmd_map_failed never used +milkymist_softusb_mouse_event 4c15ba9 +xen_map_block 6506e4f +xen_unmap_block 6506e4f +qemu_spice_start 67be672 +qemu_spice_stop 67be672 + +Signed-off-by: Markus Armbruster +Signed-off-by: Stefan Hajnoczi +(cherry picked from commit 3ae76d23d21a1f47390c6abe3497c33b708aec1f) +--- + trace-events | 14 -------------- + 1 file changed, 14 deletions(-) + +Signed-off-by: Michal Novotny +--- + trace-events | 14 -------------- + 1 file changed, 14 deletions(-) + +diff --git a/trace-events b/trace-events +index 7cd335d..ef8b5e1 100644 +--- a/trace-events ++++ b/trace-events +@@ -85,7 +85,6 @@ mirror_before_flush(void *s) "s %p" + mirror_before_drain(void *s, int64_t cnt) "s %p dirty count %"PRId64 + mirror_before_sleep(void *s, int64_t cnt, int synced) "s %p dirty count %"PRId64" synced %d" + mirror_one_iteration(void *s, int64_t sector_num, int nb_sectors) "s %p sector_num %"PRId64" nb_sectors %d" +-mirror_cow(void *s, int64_t sector_num) "s %p sector_num %"PRId64 + mirror_iteration_done(void *s, int64_t sector_num, int nb_sectors, int ret) "s %p sector_num %"PRId64" nb_sectors %d ret %d" + mirror_yield(void *s, int64_t cnt, int buf_free_count, int in_flight) "s %p dirty count %"PRId64" free buffers %d in_flight %d" + mirror_yield_in_flight(void *s, int64_t sector_num, int in_flight) "s %p sector_num %"PRId64" in_flight %d" +@@ -122,8 +121,6 @@ thread_pool_cancel(void *req, void *opaque) "req %p opaque %p" + + # posix-aio-compat.c + paio_submit(void *acb, void *opaque, int64_t sector_num, int nb_sectors, int type) "acb %p opaque %p sector_num %"PRId64" nb_sectors %d type %d" +-paio_complete(void *acb, void *opaque, int ret) "acb %p opaque %p ret %d" +-paio_cancel(void *acb, void *opaque) "acb %p opaque %p" + + # ioport.c + cpu_in(unsigned int addr, unsigned int val) "addr %#x value %u" +@@ -303,7 +300,6 @@ usb_ehci_sitd(uint32_t addr, uint32_t nxt, uint32_t active) "ITD @ %08x: next %0 + usb_ehci_port_attach(uint32_t port, const char *owner, const char *device) "attach port #%d, owner %s, device %s" + usb_ehci_port_detach(uint32_t port, const char *owner) "detach port #%d, owner %s" + usb_ehci_port_reset(uint32_t port, int enable) "reset port #%d - %d" +-usb_ehci_data(int rw, uint32_t cpage, uint32_t offset, uint32_t addr, uint32_t len, uint32_t bufpos) "write %d, cpage %d, offset 0x%03x, addr 0x%08x, len %d, bufpos %d" + usb_ehci_queue_action(void *q, const char *action) "q %p: %s" + usb_ehci_packet_action(void *q, void *p, const char *action) "q %p p %p: %s" + usb_ehci_irq(uint32_t level, uint32_t frindex, uint32_t sts, uint32_t mask) "level %d, frindex 0x%04x, sts 0x%x, mask 0x%x" +@@ -609,11 +605,9 @@ megasas_qf_new(unsigned int index, void *cmd) "return new frame %x cmd %p" + megasas_qf_failed(unsigned long pa) "all frames busy for frame %lx" + megasas_qf_enqueue(unsigned int index, unsigned int count, uint64_t context, unsigned int tail, int busy) "enqueue frame %x count %d context %" PRIx64 " tail %x busy %d" + megasas_qf_update(unsigned int head, unsigned int busy) "update reply queue head %x busy %d" +-megasas_qf_dequeue(unsigned int index) "dequeue frame %x" + megasas_qf_map_failed(int cmd, unsigned long frame) "scmd %d: frame %lu" + megasas_qf_complete_noirq(uint64_t context) "context %" PRIx64 " " + megasas_qf_complete(uint64_t context, unsigned int tail, unsigned int offset, int busy, unsigned int doorbell) "context %" PRIx64 " tail %x offset %d busy %d doorbell %x" +-megasas_handle_frame(const char *cmd, uint64_t addr, uint64_t context, uint32_t count) "MFI cmd %s addr %" PRIx64 " context %" PRIx64 " count %d" + megasas_frame_busy(uint64_t addr) "frame %" PRIx64 " busy" + megasas_unhandled_frame_cmd(int cmd, uint8_t frame_cmd) "scmd %d: Unhandled MFI cmd %x" + megasas_handle_scsi(const char *frame, int bus, int dev, int lun, void *sdev, unsigned long size) "%s dev %x/%x/%x sdev %p xfer %lu" +@@ -636,8 +630,6 @@ megasas_io_write_start(int cmd, unsigned long lba, unsigned long count, unsigned + megasas_io_complete(int cmd, uint32_t len) "scmd %d: %d bytes completed" + megasas_io_read(int cmd, int bytes, int len, unsigned long offset) "scmd %d: %d/%d bytes, iov offset %lu" + megasas_io_write(int cmd, int bytes, int len, unsigned long offset) "scmd %d: %d/%d bytes, iov offset %lu" +-megasas_io_continue(int cmd, int bytes) "scmd %d: %d bytes left" +-megasas_iovec_map_failed(int cmd, int index, unsigned long iov_size) "scmd %d: iovec %d size %lu" + megasas_iovec_sgl_overflow(int cmd, int index, int limit) "scmd %d: iovec count %d limit %d" + megasas_iovec_sgl_underflow(int cmd, int index) "scmd %d: iovec count %d" + megasas_iovec_sgl_invalid(int cmd, int index, uint64_t pa, uint32_t len) "scmd %d: element %d pa %" PRIx64 " len %u" +@@ -652,7 +644,6 @@ megasas_dcmd_internal_invalid(int cmd, int opcode) "scmd %d: Invalid internal DC + megasas_dcmd_unhandled(int cmd, int opcode, int len) "scmd %d: opcode %x, len %d" + megasas_dcmd_zero_sge(int cmd) "scmd %d: zero DCMD sge count" + megasas_dcmd_invalid_sge(int cmd, int count) "scmd %d: invalid DCMD sge count %d" +-megasas_dcmd_map_failed(int cmd) "scmd %d: Failed to map DCMD buffer" + megasas_dcmd_invalid_xfer_len(int cmd, unsigned long size, unsigned long max) "scmd %d: invalid xfer len %ld, max %ld" + megasas_dcmd_enter(int cmd, const char *dcmd, int len) "scmd %d: DCMD %s len %d" + megasas_dcmd_dummy(int cmd, unsigned long size) "scmd %d: DCMD dummy xfer len %ld" +@@ -722,7 +713,6 @@ milkymist_softusb_memory_read(uint32_t addr, uint32_t value) "addr %08x value %0 + milkymist_softusb_memory_write(uint32_t addr, uint32_t value) "addr %08x value %08x" + milkymist_softusb_mevt(uint8_t m) "m %d" + milkymist_softusb_kevt(uint8_t m) "m %d" +-milkymist_softusb_mouse_event(int dx, int dy, int dz, int bs) "dx %d dy %d dz %d bs %02x" + milkymist_softusb_pulse_irq(void) "Pulse IRQ" + + # hw/milkymist-sysctl.c +@@ -810,8 +800,6 @@ xen_client_set_memory(uint64_t start_addr, unsigned long size, bool log_dirty) " + xen_map_cache(uint64_t phys_addr) "want %#"PRIx64 + xen_remap_bucket(uint64_t index) "index %#"PRIx64 + xen_map_cache_return(void* ptr) "%p" +-xen_map_block(uint64_t phys_addr, uint64_t size) "%#"PRIx64", size %#"PRIx64 +-xen_unmap_block(void* addr, unsigned long size) "%p, size %#lx" + + # exec.c + qemu_put_ram_ptr(void* addr) "%p" +@@ -1076,8 +1064,6 @@ qemu_spice_del_memslot(int qid, uint32_t gid, uint32_t slot_id) "%d gid=%u sid=% + qemu_spice_create_primary_surface(int qid, uint32_t sid, void *surface, int async) "%d sid=%u surface=%p async=%d" + qemu_spice_destroy_primary_surface(int qid, uint32_t sid, int async) "%d sid=%u async=%d" + qemu_spice_wakeup(uint32_t qid) "%d" +-qemu_spice_start(uint32_t qid) "%d" +-qemu_spice_stop(uint32_t qid) "%d" + qemu_spice_create_update(uint32_t left, uint32_t right, uint32_t top, uint32_t bottom) "lr %d -> %d, tb -> %d -> %d" + qxl_spice_destroy_surfaces_complete(int qid) "%d" + qxl_spice_destroy_surfaces(int qid, int async) "%d async=%d" +-- +1.7.11.7 + diff --git a/SOURCES/kvm-trace-events-Fix-up-source-file-comments.patch b/SOURCES/kvm-trace-events-Fix-up-source-file-comments.patch new file mode 100644 index 0000000..9e495b2 --- /dev/null +++ b/SOURCES/kvm-trace-events-Fix-up-source-file-comments.patch @@ -0,0 +1,605 @@ +From a4bbc54648f6865edee446d1d066c84a43e83695 Mon Sep 17 00:00:00 2001 +Message-Id: +In-Reply-To: +References: +From: Markus Armbruster +Date: Tue, 10 Dec 2013 15:12:54 +0100 +Subject: [PATCH 13/16] trace-events: Fix up source file comments + +RH-Author: Markus Armbruster +Message-id: <1386688376-29521-6-git-send-email-armbru@redhat.com> +Patchwork-id: 56118 +O-Subject: [PATCH 7.0 qemu-kvm 5/7] trace-events: Fix up source file comments +Bugzilla: 997832 +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Eduardo Habkost +RH-Acked-by: Laszlo Ersek + +From: Markus Armbruster + +They're all wrong since (at least) Paolo's big source tree +reorganization. Need to shuffle some event declarations around to +keep them under the correct source file comment. + +Signed-off-by: Markus Armbruster +Signed-off-by: Stefan Hajnoczi +(cherry picked from commit 3ba00637d024b9d43b26106060a23a85411d0757) + +Conflicts: + trace-events + +Trivially conflicts because we still have qemu_put_ram_ptr(), removed +upstream in commit 4f39178. +--- + trace-events | 162 ++++++++++++++++++++++++++++++++--------------------------- + 1 file changed, 87 insertions(+), 75 deletions(-) + +Signed-off-by: Michal Novotny +--- + trace-events | 162 ++++++++++++++++++++++++++++++++--------------------------- + 1 file changed, 87 insertions(+), 75 deletions(-) + +diff --git a/trace-events b/trace-events +index ef8b5e1..2a034cb 100644 +--- a/trace-events ++++ b/trace-events +@@ -25,18 +25,14 @@ + # + # The should be a sprintf()-compatible format string. + +-# qemu-malloc.c +-g_malloc(size_t size, void *ptr) "size %zu ptr %p" +-g_realloc(void *ptr, size_t size, void *newptr) "ptr %p size %zu newptr %p" +-g_free(void *ptr) "ptr %p" +- +-# osdep.c ++# util/oslib-win32.c ++# util/oslib-posix.c + qemu_memalign(size_t alignment, size_t size, void *ptr) "alignment %zu size %zu ptr %p" + qemu_anon_ram_alloc(size_t size, void *ptr) "size %zu ptr %p" + qemu_vfree(void *ptr) "ptr %p" + qemu_anon_ram_free(void *ptr, size_t size) "ptr %p size %zu" + +-# hw/virtio.c ++# hw/virtio/virtio.c + virtqueue_fill(void *vq, const void *elem, unsigned int len, unsigned int idx) "vq %p elem %p len %u idx %u" + virtqueue_flush(void *vq, unsigned int count) "vq %p count %u" + virtqueue_pop(void *vq, void *elem, unsigned int in_num, unsigned int out_num) "vq %p elem %p in_num %u out_num %u" +@@ -45,13 +41,13 @@ virtio_irq(void *vq) "vq %p" + virtio_notify(void *vdev, void *vq) "vdev %p vq %p" + virtio_set_status(void *vdev, uint8_t val) "vdev %p val %u" + +-# hw/virtio-serial-bus.c ++# hw/char/virtio-serial-bus.c + virtio_serial_send_control_event(unsigned int port, uint16_t event, uint16_t value) "port %u, event %u, value %u" + virtio_serial_throttle_port(unsigned int port, bool throttle) "port %u, throttle %d" + virtio_serial_handle_control_message(uint16_t event, uint16_t value) "event %u, value %u" + virtio_serial_handle_control_message_port(unsigned int port) "port %u" + +-# hw/virtio-console.c ++# hw/char/virtio-console.c + virtio_console_flush_buf(unsigned int port, size_t len, ssize_t ret) "port %u, in_len %zu, out_len %zd" + virtio_console_chr_read(unsigned int port, int size) "port %u, size %d" + virtio_console_chr_event(unsigned int port, int event) "port %u, event %d" +@@ -75,6 +71,8 @@ bdrv_co_do_copy_on_readv(void *bs, int64_t sector_num, int nb_sectors, int64_t c + # block/stream.c + stream_one_iteration(void *s, int64_t sector_num, int nb_sectors, int is_allocated) "s %p sector_num %"PRId64" nb_sectors %d is_allocated %d" + stream_start(void *bs, void *base, void *s, void *co, void *opaque) "bs %p base %p s %p co %p opaque %p" ++ ++# block/commit.c + commit_one_iteration(void *s, int64_t sector_num, int nb_sectors, int is_allocated) "s %p sector_num %"PRId64" nb_sectors %d is_allocated %d" + commit_start(void *bs, void *base, void *top, void *s, void *co, void *opaque) "bs %p base %p top %p s %p co %p opaque %p" + +@@ -99,19 +97,19 @@ qmp_block_job_complete(void *job) "job %p" + block_job_cb(void *bs, void *job, int ret) "bs %p job %p ret %d" + qmp_block_stream(void *bs, void *job) "bs %p job %p" + +-# hw/virtio-blk.c ++# hw/block/virtio-blk.c + virtio_blk_req_complete(void *req, int status) "req %p status %d" + virtio_blk_rw_complete(void *req, int ret) "req %p ret %d" + virtio_blk_handle_write(void *req, uint64_t sector, size_t nsectors) "req %p sector %"PRIu64" nsectors %zu" + virtio_blk_handle_read(void *req, uint64_t sector, size_t nsectors) "req %p sector %"PRIu64" nsectors %zu" + +-# hw/dataplane/virtio-blk.c ++# hw/block/dataplane/virtio-blk.c + virtio_blk_data_plane_start(void *s) "dataplane %p" + virtio_blk_data_plane_stop(void *s) "dataplane %p" + virtio_blk_data_plane_process_request(void *s, unsigned int out_num, unsigned int in_num, unsigned int head) "dataplane %p out_num %u in_num %u head %u" + virtio_blk_data_plane_complete_request(void *s, unsigned int head, int ret) "dataplane %p head %u ret %d" + +-# hw/dataplane/vring.c ++# hw/virtio/dataplane/vring.c + vring_setup(uint64_t physical, void *desc, void *avail, void *used) "vring physical %#"PRIx64" desc %p avail %p used %p" + + # thread-pool.c +@@ -119,7 +117,8 @@ thread_pool_submit(void *pool, void *req, void *opaque) "pool %p req %p opaque % + thread_pool_complete(void *pool, void *req, void *opaque, int ret) "pool %p req %p opaque %p ret %d" + thread_pool_cancel(void *req, void *opaque) "req %p opaque %p" + +-# posix-aio-compat.c ++# block/raw-win32.c ++# block/raw-posix.c + paio_submit(void *acb, void *opaque, int64_t sector_num, int nb_sectors, int type) "acb %p opaque %p sector_num %"PRId64" nb_sectors %d type %d" + + # ioport.c +@@ -130,29 +129,31 @@ cpu_out(unsigned int addr, unsigned int val) "addr %#x value %u" + # Since requests are raised via monitor, not many tracepoints are needed. + balloon_event(void *opaque, unsigned long addr) "opaque %p addr %lu" + +-# hw/apic.c +-apic_local_deliver(int vector, uint32_t lvt) "vector %d delivery mode %d" +-apic_deliver_irq(uint8_t dest, uint8_t dest_mode, uint8_t delivery_mode, uint8_t vector_num, uint8_t trigger_mode) "dest %d dest_mode %d delivery_mode %d vector %d trigger_mode %d" ++# hw/intc/apic_common.c + cpu_set_apic_base(uint64_t val) "%016"PRIx64 + cpu_get_apic_base(uint64_t val) "%016"PRIx64 +-apic_mem_readl(uint64_t addr, uint32_t val) "%"PRIx64" = %08x" +-apic_mem_writel(uint64_t addr, uint32_t val) "%"PRIx64" = %08x" + # coalescing + apic_report_irq_delivered(int apic_irq_delivered) "coalescing %d" + apic_reset_irq_delivered(int apic_irq_delivered) "old coalescing %d" + apic_get_irq_delivered(int apic_irq_delivered) "returning coalescing %d" + +-# hw/cs4231.c ++# hw/intc/apic.c ++apic_local_deliver(int vector, uint32_t lvt) "vector %d delivery mode %d" ++apic_deliver_irq(uint8_t dest, uint8_t dest_mode, uint8_t delivery_mode, uint8_t vector_num, uint8_t trigger_mode) "dest %d dest_mode %d delivery_mode %d vector %d trigger_mode %d" ++apic_mem_readl(uint64_t addr, uint32_t val) "%"PRIx64" = %08x" ++apic_mem_writel(uint64_t addr, uint32_t val) "%"PRIx64" = %08x" ++ ++# hw/audio/cs4231.c + cs4231_mem_readl_dreg(uint32_t reg, uint32_t ret) "read dreg %d: 0x%02x" + cs4231_mem_readl_reg(uint32_t reg, uint32_t ret) "read reg %d: 0x%08x" + cs4231_mem_writel_reg(uint32_t reg, uint32_t old, uint32_t val) "write reg %d: 0x%08x -> 0x%08x" + cs4231_mem_writel_dreg(uint32_t reg, uint32_t old, uint32_t val) "write dreg %d: 0x%02x -> 0x%02x" + +-# hw/ds1225y.c ++# hw/nvram/ds1225y.c + nvram_read(uint32_t addr, uint32_t ret) "read addr %d: 0x%02x" + nvram_write(uint32_t addr, uint32_t old, uint32_t val) "write addr %d: 0x%02x -> 0x%02x" + +-# hw/eccmemctl.c ++# hw/misc/eccmemctl.c + ecc_mem_writel_mer(uint32_t val) "Write memory enable %08x" + ecc_mem_writel_mdr(uint32_t val) "Write memory delay %08x" + ecc_mem_writel_mfsr(uint32_t val) "Write memory fault status %08x" +@@ -172,26 +173,26 @@ ecc_mem_readl_ecr1(uint32_t ret) "Read event count 2 %08x" + ecc_diag_mem_writeb(uint64_t addr, uint32_t val) "Write diagnostic %"PRId64" = %02x" + ecc_diag_mem_readb(uint64_t addr, uint32_t ret) "Read diagnostic %"PRId64"= %02x" + +-# hw/fw_cfg.c ++# hw/nvram/fw_cfg.c + fw_cfg_write(void *s, uint8_t value) "%p %d" + fw_cfg_select(void *s, uint16_t key, int ret) "%p key %d = %d" + fw_cfg_read(void *s, uint8_t ret) "%p = %d" + fw_cfg_add_file_dupe(void *s, char *name) "%p %s" + fw_cfg_add_file(void *s, int index, char *name, size_t len) "%p #%d: %s (%zd bytes)" + +-# hw/hd-geometry.c ++# hw/block/hd-geometry.c + hd_geometry_lchs_guess(void *bs, int cyls, int heads, int secs) "bs %p LCHS %d %d %d" + hd_geometry_guess(void *bs, uint32_t cyls, uint32_t heads, uint32_t secs, int trans) "bs %p CHS %u %u %u trans %d" + +-# hw/jazz-led.c ++# hw/display/jazz_led.c + jazz_led_read(uint64_t addr, uint8_t val) "read addr=0x%"PRIx64": 0x%x" + jazz_led_write(uint64_t addr, uint8_t new) "write addr=0x%"PRIx64": 0x%x" + +-# hw/lance.c ++# hw/net/lance.c + lance_mem_readw(uint64_t addr, uint32_t ret) "addr=%"PRIx64"val=0x%04x" + lance_mem_writew(uint64_t addr, uint32_t val) "addr=%"PRIx64"val=0x%04x" + +-# hw/slavio_intctl.c ++# hw/intc/slavio_intctl.c + slavio_intctl_mem_readl(uint32_t cpu, uint64_t addr, uint32_t ret) "read cpu %d reg 0x%"PRIx64" = %x" + slavio_intctl_mem_writel(uint32_t cpu, uint64_t addr, uint32_t val) "write cpu %d reg 0x%"PRIx64" = %x" + slavio_intctl_mem_writel_clear(uint32_t cpu, uint32_t val, uint32_t intreg_pending) "Cleared cpu %d irq mask %x, curmask %x" +@@ -205,7 +206,7 @@ slavio_check_interrupts(uint32_t pending, uint32_t intregm_disabled) "pending %x + slavio_set_irq(uint32_t target_cpu, int irq, uint32_t pil, int level) "Set cpu %d irq %d -> pil %d level %d" + slavio_set_timer_irq_cpu(int cpu, int level) "Set cpu %d local timer level %d" + +-# hw/slavio_misc.c ++# hw/misc/slavio_misc.c + slavio_misc_update_irq_raise(void) "Raise IRQ" + slavio_misc_update_irq_lower(void) "Lower IRQ" + slavio_set_power_fail(int power_failing, uint8_t config) "Power fail: %d, config: %d" +@@ -226,7 +227,7 @@ slavio_sysctrl_mem_readl(uint32_t ret) "Read system control %08x" + slavio_led_mem_writew(uint32_t val) "Write diagnostic LED %04x" + slavio_led_mem_readw(uint32_t ret) "Read diagnostic LED %04x" + +-# hw/slavio_timer.c ++# hw/timer/slavio_timer.c + slavio_timer_get_out(uint64_t limit, uint32_t counthigh, uint32_t count) "limit %"PRIx64" count %x%08x" + slavio_timer_irq(uint32_t counthigh, uint32_t count) "callback: count %x%08x" + slavio_timer_mem_readl_invalid(uint64_t addr) "invalid read address %"PRIx64 +@@ -241,7 +242,7 @@ slavio_timer_mem_writel_mode_counter(unsigned int timer_index) "processor %d cha + slavio_timer_mem_writel_mode_invalid(void) "not system timer" + slavio_timer_mem_writel_invalid(uint64_t addr) "invalid write address %"PRIx64 + +-# hw/sparc32_dma.c ++# hw/dma/sparc32_dma.c + ledma_memory_read(uint64_t addr) "DMA read addr 0x%"PRIx64 + ledma_memory_write(uint64_t addr) "DMA write addr 0x%"PRIx64 + sparc32_dma_set_irq_raise(void) "Raise IRQ" +@@ -253,13 +254,13 @@ sparc32_dma_mem_writel(uint64_t addr, uint32_t old, uint32_t val) "write dmareg + sparc32_dma_enable_raise(void) "Raise DMA enable" + sparc32_dma_enable_lower(void) "Lower DMA enable" + +-# hw/sun4m.c ++# hw/sparc/sun4m.c + sun4m_cpu_interrupt(unsigned int level) "Set CPU IRQ %d" + sun4m_cpu_reset_interrupt(unsigned int level) "Reset CPU IRQ %d" + sun4m_cpu_set_irq_raise(int level) "Raise CPU IRQ %d" + sun4m_cpu_set_irq_lower(int level) "Lower CPU IRQ %d" + +-# hw/sun4m_iommu.c ++# hw/dma/sun4m_iommu.c + sun4m_iommu_mem_readl(uint64_t addr, uint32_t ret) "read reg[%"PRIx64"] = %x" + sun4m_iommu_mem_writel(uint64_t addr, uint32_t val) "write reg[%"PRIx64"] = %x" + sun4m_iommu_mem_writel_ctrl(uint64_t iostart) "iostart = %"PRIx64 +@@ -417,6 +418,7 @@ usb_uas_tmf_logical_unit_reset(int addr, uint16_t tag, int lun) "dev %d, tag 0x% + usb_uas_tmf_unsupported(int addr, uint16_t tag, uint32_t function) "dev %d, tag 0x%x, function 0x%x" + + # hw/usb/host-linux.c ++# hw/usb/host-libusb.c + usb_host_open_started(int bus, int addr) "dev %d:%d" + usb_host_open_success(int bus, int addr) "dev %d:%d" + usb_host_open_failure(int bus, int addr) "dev %d:%d" +@@ -456,7 +458,7 @@ usb_host_parse_endpoint(int bus, int addr, int ep, const char *dir, const char * + usb_host_parse_unknown(int bus, int addr, int len, int type) "dev %d:%d, len %d, type %d" + usb_host_parse_error(int bus, int addr, const char *errmsg) "dev %d:%d, msg %s" + +-# hw/scsi-bus.c ++# hw/scsi/scsi-bus.c + scsi_req_alloc(int target, int lun, int tag) "target %d lun %d tag %d" + scsi_req_cancel(int target, int lun, int tag) "target %d lun %d tag %d" + scsi_req_data(int target, int lun, int tag, int len) "target %d lun %d tag %d len %d" +@@ -478,6 +480,9 @@ scsi_request_sense(int target, int lun, int tag) "target %d lun %d tag %d" + vm_state_notify(int running, int reason) "running %d reason %d" + load_file(const char *name, const char *path) "name %s location %s" + runstate_set(int new_state) "new state %d" ++g_malloc(size_t size, void *ptr) "size %zu ptr %p" ++g_realloc(void *ptr, size_t size, void *newptr) "ptr %p size %zu newptr %p" ++g_free(void *ptr) "ptr %p" + + # block/qcow2.c + qcow2_writev_start_req(void *co, int64_t sector, int nb_sectors) "co %p sector %" PRIx64 " nb_sectors %d" +@@ -486,6 +491,7 @@ qcow2_writev_start_part(void *co) "co %p" + qcow2_writev_done_part(void *co, int cur_nr_sectors) "co %p cur_nr_sectors %d" + qcow2_writev_data(void *co, uint64_t offset) "co %p offset %" PRIx64 + ++# block/qcow2-cluster.c + qcow2_alloc_clusters_offset(void *co, uint64_t offset, int n_start, int n_end) "co %p offet %" PRIx64 " n_start %d n_end %d" + qcow2_handle_copied(void *co, uint64_t guest_offset, uint64_t host_offset, uint64_t bytes) "co %p guest_offet %" PRIx64 " host_offset %" PRIx64 " bytes %" PRIx64 + qcow2_handle_alloc(void *co, uint64_t guest_offset, uint64_t host_offset, uint64_t bytes) "co %p guest_offet %" PRIx64 " host_offset %" PRIx64 " bytes %" PRIx64 +@@ -499,6 +505,7 @@ qcow2_l2_allocate_write_l2(void *bs, int l1_index) "bs %p l1_index %d" + qcow2_l2_allocate_write_l1(void *bs, int l1_index) "bs %p l1_index %d" + qcow2_l2_allocate_done(void *bs, int l1_index, int ret) "bs %p l1_index %d ret %d" + ++# block/qcow2-cache.c + qcow2_cache_get(void *co, int c, uint64_t offset, bool read_from_disk) "co %p is_l2_cache %d offset %" PRIx64 " read_from_disk %d" + qcow2_cache_get_replace_entry(void *co, int c, int i) "co %p is_l2_cache %d index %d" + qcow2_cache_get_read(void *co, int c, int i) "co %p is_l2_cache %d index %d" +@@ -530,11 +537,11 @@ qed_aio_write_prefill(void *s, void *acb, uint64_t start, size_t len, uint64_t o + qed_aio_write_postfill(void *s, void *acb, uint64_t start, size_t len, uint64_t offset) "s %p acb %p start %"PRIu64" len %zu offset %"PRIu64 + qed_aio_write_main(void *s, void *acb, int ret, uint64_t offset, size_t len) "s %p acb %p ret %d offset %"PRIu64" len %zu" + +-# hw/g364fb.c ++# hw/display/g364fb.c + g364fb_read(uint64_t addr, uint32_t val) "read addr=0x%"PRIx64": 0x%x" + g364fb_write(uint64_t addr, uint32_t new) "write addr=0x%"PRIx64": 0x%x" + +-# hw/grlib_gptimer.c ++# hw/timer/grlib_gptimer.c + grlib_gptimer_enable(int id, uint32_t count) "timer:%d set count 0x%x and run" + grlib_gptimer_disabled(int id, uint32_t config) "timer:%d Timer disable config 0x%x" + grlib_gptimer_restart(int id, uint32_t reload) "timer:%d reload val: 0x%x" +@@ -543,19 +550,19 @@ grlib_gptimer_hit(int id) "timer:%d HIT" + grlib_gptimer_readl(int id, uint64_t addr, uint32_t val) "timer:%d addr 0x%"PRIx64" 0x%x" + grlib_gptimer_writel(int id, uint64_t addr, uint32_t val) "timer:%d addr 0x%"PRIx64" 0x%x" + +-# hw/grlib_irqmp.c ++# hw/intc/grlib_irqmp.c + grlib_irqmp_check_irqs(uint32_t pend, uint32_t force, uint32_t mask, uint32_t lvl1, uint32_t lvl2) "pend:0x%04x force:0x%04x mask:0x%04x lvl1:0x%04x lvl0:0x%04x" + grlib_irqmp_ack(int intno) "interrupt:%d" + grlib_irqmp_set_irq(int irq) "Raise CPU IRQ %d" + grlib_irqmp_readl_unknown(uint64_t addr) "addr 0x%"PRIx64 + grlib_irqmp_writel_unknown(uint64_t addr, uint32_t value) "addr 0x%"PRIx64" value 0x%x" + +-# hw/grlib_apbuart.c ++# hw/char/grlib_apbuart.c + grlib_apbuart_event(int event) "event:%d" + grlib_apbuart_writel_unknown(uint64_t addr, uint32_t value) "addr 0x%"PRIx64" value 0x%x" + grlib_apbuart_readl_unknown(uint64_t addr) "addr 0x%"PRIx64"" + +-# hw/leon3.c ++# hw/sparc/leon3.c + leon3_set_irq(int intno) "Set CPU IRQ %d" + leon3_reset_irq(int intno) "Reset CPU IRQ %d" + +@@ -566,7 +573,7 @@ spice_vmc_register_interface(void *scd) "spice vmc registered interface %p" + spice_vmc_unregister_interface(void *scd) "spice vmc unregistered interface %p" + spice_vmc_event(int event) "spice vmc event %d" + +-# hw/lm32_pic.c ++# hw/intc/lm32_pic.c + lm32_pic_raise_irq(void) "Raise CPU interrupt" + lm32_pic_lower_irq(void) "Lower CPU interrupt" + lm32_pic_interrupt(int irq, int level) "Set IRQ%d %d" +@@ -575,27 +582,27 @@ lm32_pic_set_ip(uint32_t ip) "ip 0x%08x" + lm32_pic_get_im(uint32_t im) "im 0x%08x" + lm32_pic_get_ip(uint32_t ip) "ip 0x%08x" + +-# hw/lm32_juart.c ++# hw/char/lm32_juart.c + lm32_juart_get_jtx(uint32_t value) "jtx 0x%08x" + lm32_juart_set_jtx(uint32_t value) "jtx 0x%08x" + lm32_juart_get_jrx(uint32_t value) "jrx 0x%08x" + lm32_juart_set_jrx(uint32_t value) "jrx 0x%08x" + +-# hw/lm32_timer.c ++# hw/timer/lm32_timer.c + lm32_timer_memory_write(uint32_t addr, uint32_t value) "addr 0x%08x value 0x%08x" + lm32_timer_memory_read(uint32_t addr, uint32_t value) "addr 0x%08x value 0x%08x" + lm32_timer_hit(void) "timer hit" + lm32_timer_irq_state(int level) "irq state %d" + +-# hw/lm32_uart.c ++# hw/char/lm32_uart.c + lm32_uart_memory_write(uint32_t addr, uint32_t value) "addr 0x%08x value 0x%08x" + lm32_uart_memory_read(uint32_t addr, uint32_t value) "addr 0x%08x value 0x%08x" + lm32_uart_irq_state(int level) "irq state %d" + +-# hw/lm32_sys.c ++# hw/misc/lm32_sys.c + lm32_sys_memory_write(uint32_t addr, uint32_t value) "addr 0x%08x value 0x%08x" + +-# hw/megasas.c ++# hw/scsi/megasas.c + megasas_init_firmware(uint64_t pa) "pa %" PRIx64 " " + megasas_init_queue(uint64_t queue_pa, int queue_len, uint64_t head, uint64_t tail, uint32_t flags) "queue at %" PRIx64 " len %d head %" PRIx64 " tail %" PRIx64 " flags %x" + megasas_initq_map_failed(int frame) "scmd %d: failed to map queue" +@@ -669,7 +676,7 @@ megasas_mmio_invalid_readl(unsigned long addr) "addr 0x%lx" + megasas_mmio_writel(uint32_t addr, uint32_t val) "addr 0x%x: 0x%x" + megasas_mmio_invalid_writel(uint32_t addr, uint32_t val) "addr 0x%x: 0x%x" + +-# hw/milkymist-ac97.c ++# hw/audio/milkymist-ac97.c + milkymist_ac97_memory_read(uint32_t addr, uint32_t value) "addr %08x value %08x" + milkymist_ac97_memory_write(uint32_t addr, uint32_t value) "addr %08x value %08x" + milkymist_ac97_pulse_irq_crrequest(void) "Pulse IRQ CR request" +@@ -681,15 +688,15 @@ milkymist_ac97_in_cb_transferred(int transferred) "transferred %d" + milkymist_ac97_out_cb(int free, uint32_t remaining) "free %d remaining %u" + milkymist_ac97_out_cb_transferred(int transferred) "transferred %d" + +-# hw/milkymist-hpdmc.c ++# hw/misc/milkymist-hpdmc.c + milkymist_hpdmc_memory_read(uint32_t addr, uint32_t value) "addr=%08x value=%08x" + milkymist_hpdmc_memory_write(uint32_t addr, uint32_t value) "addr=%08x value=%08x" + +-# hw/milkymist-memcard.c ++# hw/sd/milkymist-memcard.c + milkymist_memcard_memory_read(uint32_t addr, uint32_t value) "addr %08x value %08x" + milkymist_memcard_memory_write(uint32_t addr, uint32_t value) "addr %08x value %08x" + +-# hw/milkymist-minimac2.c ++# hw/net/milkymist-minimac2.c + milkymist_minimac2_memory_read(uint32_t addr, uint32_t value) "addr %08x value %08x" + milkymist_minimac2_memory_write(uint32_t addr, uint32_t value) "addr %08x value %08x" + milkymist_minimac2_mdio_write(uint8_t phy_addr, uint8_t addr, uint16_t value) "phy_addr %02x addr %02x value %04x" +@@ -702,20 +709,20 @@ milkymist_minimac2_raise_irq_rx(void) "Raise IRQ RX" + milkymist_minimac2_lower_irq_rx(void) "Lower IRQ RX" + milkymist_minimac2_pulse_irq_tx(void) "Pulse IRQ TX" + +-# hw/milkymist-pfpu.c ++# hw/misc/milkymist-pfpu.c + milkymist_pfpu_memory_read(uint32_t addr, uint32_t value) "addr %08x value %08x" + milkymist_pfpu_memory_write(uint32_t addr, uint32_t value) "addr %08x value %08x" + milkymist_pfpu_vectout(uint32_t a, uint32_t b, uint32_t dma_ptr) "a %08x b %08x dma_ptr %08x" + milkymist_pfpu_pulse_irq(void) "Pulse IRQ" + +-# hw/milkymist-softusb.c ++# hw/input/milkymist-softusb.c + milkymist_softusb_memory_read(uint32_t addr, uint32_t value) "addr %08x value %08x" + milkymist_softusb_memory_write(uint32_t addr, uint32_t value) "addr %08x value %08x" + milkymist_softusb_mevt(uint8_t m) "m %d" + milkymist_softusb_kevt(uint8_t m) "m %d" + milkymist_softusb_pulse_irq(void) "Pulse IRQ" + +-# hw/milkymist-sysctl.c ++# hw/timer/milkymist-sysctl.c + milkymist_sysctl_memory_read(uint32_t addr, uint32_t value) "addr %08x value %08x" + milkymist_sysctl_memory_write(uint32_t addr, uint32_t value) "addr %08x value %08x" + milkymist_sysctl_icap_write(uint32_t value) "value %08x" +@@ -726,30 +733,30 @@ milkymist_sysctl_stop_timer1(void) "Stop timer1" + milkymist_sysctl_pulse_irq_timer0(void) "Pulse IRQ Timer0" + milkymist_sysctl_pulse_irq_timer1(void) "Pulse IRQ Timer1" + +-# hw/milkymist-tmu2.c ++# hw/display/milkymist-tmu2.c + milkymist_tmu2_memory_read(uint32_t addr, uint32_t value) "addr %08x value %08x" + milkymist_tmu2_memory_write(uint32_t addr, uint32_t value) "addr %08x value %08x" + milkymist_tmu2_start(void) "Start TMU" + milkymist_tmu2_pulse_irq(void) "Pulse IRQ" + +-# hw/milkymist-uart.c ++# hw/char/milkymist-uart.c + milkymist_uart_memory_read(uint32_t addr, uint32_t value) "addr %08x value %08x" + milkymist_uart_memory_write(uint32_t addr, uint32_t value) "addr %08x value %08x" + milkymist_uart_raise_irq(void) "Raise IRQ" + milkymist_uart_lower_irq(void) "Lower IRQ" + +-# hw/milkymist-vgafb.c ++# hw/display/milkymist-vgafb.c + milkymist_vgafb_memory_read(uint32_t addr, uint32_t value) "addr %08x value %08x" + milkymist_vgafb_memory_write(uint32_t addr, uint32_t value) "addr %08x value %08x" + +-# hw/mipsnet.c ++# hw/net/mipsnet.c + mipsnet_send(uint32_t size) "sending len=%u" + mipsnet_receive(uint32_t size) "receiving len=%u" + mipsnet_read(uint64_t addr, uint32_t val) "read addr=0x%" PRIx64 " val=0x%x" + mipsnet_write(uint64_t addr, uint64_t val) "write addr=0x%" PRIx64 " val=0x%" PRIx64 "" + mipsnet_irq(uint32_t isr, uint32_t intctl) "set irq to %d (%02x)" + +-# hw/pc87312.c ++# hw/isa/pc87312.c + pc87312_io_read(uint32_t addr, uint32_t val) "read addr=%x val=%x" + pc87312_io_write(uint32_t addr, uint32_t val) "write addr=%x val=%x" + pc87312_info_floppy(uint32_t base) "base 0x%x" +@@ -804,7 +811,7 @@ xen_map_cache_return(void* ptr) "%p" + # exec.c + qemu_put_ram_ptr(void* addr) "%p" + +-# hw/xen_platform.c ++# hw/xen/xen_platform.c + xen_platform_log(char *s) "xen platform: %s" + + # qemu-coroutine.c +@@ -820,7 +827,7 @@ qemu_co_mutex_lock_return(void *mutex, void *self) "mutex %p self %p" + qemu_co_mutex_unlock_entry(void *mutex, void *self) "mutex %p self %p" + qemu_co_mutex_unlock_return(void *mutex, void *self) "mutex %p self %p" + +-# hw/escc.c ++# hw/char/escc.c + escc_put_queue(char channel, int b) "channel %c put: 0x%02x" + escc_get_queue(char channel, int val) "channel %c get 0x%02x" + escc_update_irq(int irq) "IRQ = %d" +@@ -841,7 +848,7 @@ iscsi_aio_writev(void *iscsi, int64_t sector_num, int nb_sectors, void *opaque, + iscsi_aio_read16_cb(void *iscsi, int status, void *acb, int canceled) "iscsi %p status %d acb %p canceled %d" + iscsi_aio_readv(void *iscsi, int64_t sector_num, int nb_sectors, void *opaque, void *acb) "iscsi %p sector_num %"PRId64" nb_sectors %d opaque %p acb %p" + +-# hw/esp.c ++# hw/scsi/esp.c + esp_error_fifo_overrun(void) "FIFO overrun" + esp_error_unhandled_command(uint32_t val) "unhandled command (%2.2x)" + esp_error_invalid_write(uint32_t val, uint32_t addr) "invalid write of 0x%02x at [0x%x]" +@@ -876,6 +883,8 @@ esp_mem_writeb_cmd_selatn(uint32_t val) "Select with ATN (%2.2x)" + esp_mem_writeb_cmd_selatns(uint32_t val) "Select with ATN & stop (%2.2x)" + esp_mem_writeb_cmd_ensel(uint32_t val) "Enable selection (%2.2x)" + esp_mem_writeb_cmd_dissel(uint32_t val) "Disable selection (%2.2x)" ++ ++# hw/scsi/esp-pci.c + esp_pci_error_invalid_dma_direction(void) "invalid DMA transfer direction" + esp_pci_error_invalid_read(uint32_t reg) "read access outside bounds (reg 0x%x)" + esp_pci_error_invalid_write(uint32_t reg) "write access outside bounds (reg 0x%x)" +@@ -898,7 +907,7 @@ monitor_protocol_event_emit(uint32_t event, void *data) "event=%d data=%p" + monitor_protocol_event_queue(uint32_t event, void *data, uint64_t rate, uint64_t last, uint64_t now) "event=%d data=%p rate=%" PRId64 " last=%" PRId64 " now=%" PRId64 + monitor_protocol_event_throttle(uint32_t event, uint64_t rate) "event=%d rate=%" PRId64 + +-# hw/opencores_eth.c ++# hw/net/opencores_eth.c + open_eth_mii_write(unsigned idx, uint16_t v) "MII[%02x] <- %04x" + open_eth_mii_read(unsigned idx, uint16_t v) "MII[%02x] -> %04x" + open_eth_update_irq(uint32_t v) "IRQ <- %x" +@@ -968,10 +977,12 @@ mmu_helper_get_phys_addr_code(uint32_t tl, int mmu_idx, uint64_t prim_context, u + mmu_helper_get_phys_addr_data(uint32_t tl, int mmu_idx, uint64_t prim_context, uint64_t sec_context, uint64_t address) "tl=%d mmu_idx=%d primary context=%"PRIx64" secondary context=%"PRIx64" address=%"PRIx64"" + mmu_helper_mmu_fault(uint64_t address, uint64_t paddr, int mmu_idx, uint32_t tl, uint64_t prim_context, uint64_t sec_context) "Translate at %"PRIx64" -> %"PRIx64", mmu_idx=%d tl=%d primary context=%"PRIx64" secondary context=%"PRIx64"" + +-# target-sparc/int_helper.c ++# target-sparc/int64_helper.c + int_helper_set_softint(uint32_t softint) "new %08x" + int_helper_clear_softint(uint32_t softint) "new %08x" + int_helper_write_softint(uint32_t softint) "new %08x" ++ ++# target-sparc/int32_helper.c + int_helper_icache_freeze(void) "Instruction cache: freeze" + int_helper_dcache_freeze(void) "Data cache: freeze" + +@@ -990,7 +1001,7 @@ dma_complete(void *dbs, int ret, void *cb) "dbs=%p ret=%d cb=%p" + dma_bdrv_cb(void *dbs, int ret) "dbs=%p ret=%d" + dma_map_wait(void *dbs) "dbs=%p" + +-# console.h ++# ui/console.c + console_gfx_new(void) "" + console_txt_new(int w, int h) "%dx%d" + console_select(int nr) "%d" +@@ -1000,9 +1011,9 @@ displaysurface_create_from(void *display_surface, int w, int h, int bpp, int swa + displaysurface_free(void *display_surface) "surface=%p" + displaychangelistener_register(void *dcl, const char *name) "%p [ %s ]" + displaychangelistener_unregister(void *dcl, const char *name) "%p [ %s ]" +- +-# vga.c + ppm_save(const char *filename, void *display_surface) "%s surface=%p" ++ ++# hw/display/vmware_vga.c + vmware_value_read(uint32_t index, uint32_t value) "index %d, value 0x%x" + vmware_value_write(uint32_t index, uint32_t value) "index %d, value 0x%x" + vmware_palette_read(uint32_t index, uint32_t value) "index %d, value 0x%x" +@@ -1012,7 +1023,6 @@ vmware_scratch_write(uint32_t index, uint32_t value) "index %d, value 0x%x" + vmware_setmode(uint32_t w, uint32_t h, uint32_t bpp) "%dx%d @ %d bpp" + + # savevm.c +- + savevm_section_start(void) "" + savevm_section_end(unsigned int section_id) "section_id %u" + +@@ -1021,7 +1031,7 @@ migration_bitmap_sync_start(void) "" + migration_bitmap_sync_end(uint64_t dirty_pages) "dirty_pages %" PRIu64"" + migration_throttle(void) "" + +-# hw/qxl.c ++# hw/display/qxl.c + disable qxl_interface_set_mm_time(int qid, uint32_t mm_time) "%d %d" + disable qxl_io_write_vga(int qid, const char *mode, uint32_t addr, uint32_t val) "%d %s addr=%u val=%u" + qxl_create_guest_primary(int qid, uint32_t width, uint32_t height, uint64_t mem, uint32_t format, uint32_t position) "%d %ux%u mem=%" PRIx64 " %u,%u" +@@ -1059,12 +1069,6 @@ qxl_ring_res_push_rest(int qid, uint32_t ring_has, uint32_t ring_size, uint32_t + qxl_ring_res_put(int qid, uint32_t free_res) "%d #res=%d" + qxl_set_mode(int qid, int modenr, uint32_t x_res, uint32_t y_res, uint32_t bits, uint64_t devmem) "%d mode=%d [ x=%d y=%d @ bpp=%d devmem=0x%" PRIx64 " ]" + qxl_soft_reset(int qid) "%d" +-qemu_spice_add_memslot(int qid, uint32_t slot_id, unsigned long virt_start, unsigned long virt_end, int async) "%d %u: host virt 0x%lx - 0x%lx async=%d" +-qemu_spice_del_memslot(int qid, uint32_t gid, uint32_t slot_id) "%d gid=%u sid=%u" +-qemu_spice_create_primary_surface(int qid, uint32_t sid, void *surface, int async) "%d sid=%u surface=%p async=%d" +-qemu_spice_destroy_primary_surface(int qid, uint32_t sid, int async) "%d sid=%u async=%d" +-qemu_spice_wakeup(uint32_t qid) "%d" +-qemu_spice_create_update(uint32_t left, uint32_t right, uint32_t top, uint32_t bottom) "lr %d -> %d, tb -> %d -> %d" + qxl_spice_destroy_surfaces_complete(int qid) "%d" + qxl_spice_destroy_surfaces(int qid, int async) "%d async=%d" + qxl_spice_destroy_surface_wait_complete(int qid, uint32_t id) "%d sid=%d" +@@ -1089,13 +1093,21 @@ qxl_client_monitors_config_capped(int qid, int requested, int limit) "%d %d %d" + qxl_client_monitors_config_crc(int qid, unsigned size, uint32_t crc32) "%d %u %u" + qxl_set_client_capabilities_unsupported_by_revision(int qid, int revision) "%d revision=%d" + +-# hw/qxl-render.c ++# ui/spice-display.c ++qemu_spice_add_memslot(int qid, uint32_t slot_id, unsigned long virt_start, unsigned long virt_end, int async) "%d %u: host virt 0x%lx - 0x%lx async=%d" ++qemu_spice_del_memslot(int qid, uint32_t gid, uint32_t slot_id) "%d gid=%u sid=%u" ++qemu_spice_create_primary_surface(int qid, uint32_t sid, void *surface, int async) "%d sid=%u surface=%p async=%d" ++qemu_spice_destroy_primary_surface(int qid, uint32_t sid, int async) "%d sid=%u async=%d" ++qemu_spice_wakeup(uint32_t qid) "%d" ++qemu_spice_create_update(uint32_t left, uint32_t right, uint32_t top, uint32_t bottom) "lr %d -> %d, tb -> %d -> %d" ++ ++# hw/display/qxl-render.c + qxl_render_blit_guest_primary_initialized(void) "" + qxl_render_blit(int32_t stride, int32_t left, int32_t right, int32_t top, int32_t bottom) "stride=%d [%d, %d, %d, %d]" + qxl_render_guest_primary_resized(int32_t width, int32_t height, int32_t stride, int32_t bytes_pp, int32_t bits_pp) "%dx%d, stride %d, bpp %d, depth %d" + qxl_render_update_area_done(void *cookie) "%p" + +-# hw/spapr_pci.c ++# hw/ppc/spapr_pci.c + spapr_pci_msi(const char *msg, uint32_t n, uint32_t ca) "%s (device#%d, cfg=%x)" + spapr_pci_msi_setup(const char *name, unsigned vector, uint64_t addr) "dev\"%s\" vector %u, addr=%"PRIx64 + spapr_pci_rtas_ibm_change_msi(unsigned func, unsigned req) "func %u, requested %u" +@@ -1103,7 +1115,7 @@ spapr_pci_rtas_ibm_query_interrupt_source_number(unsigned ioa, unsigned intr) "q + spapr_pci_msi_write(uint64_t addr, uint64_t data, uint32_t dt_irq) "@%"PRIx64"<=%"PRIx64" IRQ %u" + spapr_pci_lsi_set(const char *busname, int pin, uint32_t irq) "%s PIN%d IRQ %u" + +-# hw/xics.c ++# hw/ppc/xics.c + xics_icp_check_ipi(int server, uint8_t mfrr) "CPU %d can take IPI mfrr=%#x" + xics_icp_accept(uint32_t old_xirr, uint32_t new_xirr) "icp_accept: XIRR %#"PRIx32"->%#"PRIx32 + xics_icp_eoi(int server, uint32_t xirr, uint32_t new_xirr) "icp_eoi: server %d given XIRR %#"PRIx32" new XIRR %#"PRIx32 +@@ -1116,7 +1128,7 @@ xics_ics_write_xive(int nr, int srcno, int server, uint8_t priority) "ics_write_ + xics_ics_reject(int nr, int srcno) "reject irq %#x [src %d]" + xics_ics_eoi(int nr) "ics_eoi: irq %#x" + +-# hbitmap.c ++# util/hbitmap.c + hbitmap_iter_skip_words(const void *hb, void *hbi, uint64_t pos, unsigned long cur) "hb %p hbi %p pos %"PRId64" cur 0x%lx" + hbitmap_reset(void *hb, uint64_t start, uint64_t count, uint64_t sbit, uint64_t ebit) "hb %p items %"PRIu64",%"PRIu64" bits %"PRIu64"..%"PRIu64 + hbitmap_set(void *hb, uint64_t start, uint64_t count, uint64_t sbit, uint64_t ebit) "hb %p items %"PRIu64",%"PRIu64" bits %"PRIu64"..%"PRIu64 +-- +1.7.11.7 + diff --git a/SOURCES/kvm-usb-add-microsoft-os-descriptors-compat-property.patch b/SOURCES/kvm-usb-add-microsoft-os-descriptors-compat-property.patch new file mode 100644 index 0000000..918235a --- /dev/null +++ b/SOURCES/kvm-usb-add-microsoft-os-descriptors-compat-property.patch @@ -0,0 +1,44 @@ +From 081943079e969c7f5edb5d52182b09da3230fb3b Mon Sep 17 00:00:00 2001 +From: Gerd Hoffmann +Date: Mon, 3 Feb 2014 16:30:31 +0100 +Subject: [PATCH 07/28] usb: add microsoft os descriptors compat property + +RH-Author: Gerd Hoffmann +Message-id: <1391445032-5540-5-git-send-email-kraxel@redhat.com> +Patchwork-id: 57074 +O-Subject: [RHEL-7 qemu-kvm PATCH 4/5] usb: add microsoft os descriptors compat property +Bugzilla: 1039530 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Juan Quintela +RH-Acked-by: Miroslav Rezanina + +Turn off for rhel6 machine types. RHEL only patch. + +Signed-off-by: Gerd Hoffmann +--- + hw/i386/pc_piix.c | 4 ++++ + 1 file changed, 4 insertions(+) + +Signed-off-by: Miroslav Rezanina +--- + hw/i386/pc_piix.c | 4 ++++ + 1 files changed, 4 insertions(+), 0 deletions(-) + +diff --git a/hw/i386/pc_piix.c b/hw/i386/pc_piix.c +index aac920a..697f12f 100644 +--- a/hw/i386/pc_piix.c ++++ b/hw/i386/pc_piix.c +@@ -900,6 +900,10 @@ static QEMUMachine pc_machine_rhel700 = { + .driver = "virtio-net-pci",\ + .property = "romfile",\ + .value = "rhel6-virtio.rom",\ ++ },{\ ++ .driver = TYPE_USB_DEVICE,\ ++ .property = "msos-desc",\ ++ .value = "no",\ + } + + static void pc_compat_rhel650(QEMUMachineInitArgs *args) +-- +1.7.1 + diff --git a/SOURCES/kvm-usb-add-support-for-microsoft-os-descriptors.patch b/SOURCES/kvm-usb-add-support-for-microsoft-os-descriptors.patch new file mode 100644 index 0000000..540116e --- /dev/null +++ b/SOURCES/kvm-usb-add-support-for-microsoft-os-descriptors.patch @@ -0,0 +1,490 @@ +From b907cc56cbbb6b979d97aa0c64eb08c1fe7b6f1e Mon Sep 17 00:00:00 2001 +From: Gerd Hoffmann +Date: Mon, 3 Feb 2014 16:30:30 +0100 +Subject: [PATCH 06/28] usb: add support for microsoft os descriptors + +RH-Author: Gerd Hoffmann +Message-id: <1391445032-5540-4-git-send-email-kraxel@redhat.com> +Patchwork-id: 57075 +O-Subject: [RHEL-7 qemu-kvm PATCH 3/5] usb: add support for microsoft os descriptors +Bugzilla: 1039530 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Juan Quintela +RH-Acked-by: Miroslav Rezanina + +This patch adds support for special usb descriptors used by microsoft +windows. They allow more fine-grained control over driver binding and +adding entries to the registry for configuration. + +As this is a guest-visible change the "msos-desc" compat property +has been added to turn this off for 1.7 + older + +Signed-off-by: Gerd Hoffmann +(cherry picked from commit 5319dc7b42610575cbd3a33f4340c1fb4f19b939) + +Conflicts: + hw/i386/pc_piix.c [ 1.7 compat properties ] + include/hw/i386/pc.h [ likewise ] +--- + hw/usb/Makefile.objs | 2 +- + hw/usb/bus.c | 2 + + hw/usb/desc-msos.c | 234 +++++++++++++++++++++++++++++++++++++++++++++++++++ + hw/usb/desc.c | 37 +++++++- + hw/usb/desc.h | 11 ++- + include/hw/usb.h | 3 + + trace-events | 1 + + 7 files changed, 284 insertions(+), 6 deletions(-) + create mode 100644 hw/usb/desc-msos.c + +Signed-off-by: Miroslav Rezanina +--- + hw/usb/Makefile.objs | 2 +- + hw/usb/bus.c | 2 + + hw/usb/desc-msos.c | 234 ++++++++++++++++++++++++++++++++++++++++++++++++++ + hw/usb/desc.c | 37 +++++++- + hw/usb/desc.h | 11 ++- + include/hw/usb.h | 3 + + trace-events | 1 + + 7 files changed, 284 insertions(+), 6 deletions(-) + create mode 100644 hw/usb/desc-msos.c + +diff --git a/hw/usb/Makefile.objs b/hw/usb/Makefile.objs +index a3eac3e..97b4575 100644 +--- a/hw/usb/Makefile.objs ++++ b/hw/usb/Makefile.objs +@@ -1,5 +1,5 @@ + # usb subsystem core +-common-obj-y += core.o combined-packet.o bus.o desc.o ++common-obj-y += core.o combined-packet.o bus.o desc.o desc-msos.o + common-obj-y += libhw.o + + # usb host adapters +diff --git a/hw/usb/bus.c b/hw/usb/bus.c +index ade9abc..fe6bd13 100644 +--- a/hw/usb/bus.c ++++ b/hw/usb/bus.c +@@ -16,6 +16,8 @@ static Property usb_props[] = { + DEFINE_PROP_STRING("serial", USBDevice, serial), + DEFINE_PROP_BIT("full-path", USBDevice, flags, + USB_DEV_FLAG_FULL_PATH, true), ++ DEFINE_PROP_BIT("msos-desc", USBDevice, flags, ++ USB_DEV_FLAG_MSOS_DESC_ENABLE, true), + DEFINE_PROP_END_OF_LIST() + }; + +diff --git a/hw/usb/desc-msos.c b/hw/usb/desc-msos.c +new file mode 100644 +index 0000000..ed8d62c +--- /dev/null ++++ b/hw/usb/desc-msos.c +@@ -0,0 +1,234 @@ ++#include "hw/usb.h" ++#include "hw/usb/desc.h" ++ ++/* ++ * Microsoft OS Descriptors ++ * ++ * Windows tries to fetch some special descriptors with informations ++ * specifically for windows. Presence is indicated using a special ++ * string @ index 0xee. There are two kinds of descriptors: ++ * ++ * compatid descriptor ++ * Used to bind drivers, if usb class isn't specific enougth. ++ * Used for PTP/MTP for example (both share the same usb class). ++ * ++ * properties descriptor ++ * Does carry registry entries. They show up in ++ * HLM\SYSTEM\CurrentControlSet\Enum\USB\\\Device Parameters ++ * ++ * Note that Windows caches the stuff it got in the registry, so when ++ * playing with this you have to delete registry subtrees to make ++ * windows query the device again: ++ * HLM\SYSTEM\CurrentControlSet\Control\usbflags ++ * HLM\SYSTEM\CurrentControlSet\Enum\USB ++ * Windows will complain it can't delete entries on the second one. ++ * It has deleted everything it had permissions too, which is enouth ++ * as this includes "Device Parameters". ++ * ++ * http://msdn.microsoft.com/en-us/library/windows/hardware/ff537430.aspx ++ * ++ */ ++ ++/* ------------------------------------------------------------------ */ ++ ++typedef struct msos_compat_hdr { ++ uint32_t dwLength; ++ uint8_t bcdVersion_lo; ++ uint8_t bcdVersion_hi; ++ uint8_t wIndex_lo; ++ uint8_t wIndex_hi; ++ uint8_t bCount; ++ uint8_t reserved[7]; ++} QEMU_PACKED msos_compat_hdr; ++ ++typedef struct msos_compat_func { ++ uint8_t bFirstInterfaceNumber; ++ uint8_t reserved_1; ++ uint8_t compatibleId[8]; ++ uint8_t subCompatibleId[8]; ++ uint8_t reserved_2[6]; ++} QEMU_PACKED msos_compat_func; ++ ++static int usb_desc_msos_compat(const USBDesc *desc, uint8_t *dest) ++{ ++ msos_compat_hdr *hdr = (void *)dest; ++ msos_compat_func *func; ++ int length = sizeof(*hdr); ++ int count = 0; ++ ++ func = (void *)(dest + length); ++ func->bFirstInterfaceNumber = 0; ++ func->reserved_1 = 0x01; ++ length += sizeof(*func); ++ count++; ++ ++ hdr->dwLength = cpu_to_le32(length); ++ hdr->bcdVersion_lo = 0x00; ++ hdr->bcdVersion_hi = 0x01; ++ hdr->wIndex_lo = 0x04; ++ hdr->wIndex_hi = 0x00; ++ hdr->bCount = count; ++ return length; ++} ++ ++/* ------------------------------------------------------------------ */ ++ ++typedef struct msos_prop_hdr { ++ uint32_t dwLength; ++ uint8_t bcdVersion_lo; ++ uint8_t bcdVersion_hi; ++ uint8_t wIndex_lo; ++ uint8_t wIndex_hi; ++ uint8_t wCount_lo; ++ uint8_t wCount_hi; ++} QEMU_PACKED msos_prop_hdr; ++ ++typedef struct msos_prop { ++ uint32_t dwLength; ++ uint32_t dwPropertyDataType; ++ uint8_t dwPropertyNameLength_lo; ++ uint8_t dwPropertyNameLength_hi; ++ uint8_t bPropertyName[]; ++} QEMU_PACKED msos_prop; ++ ++typedef struct msos_prop_data { ++ uint32_t dwPropertyDataLength; ++ uint8_t bPropertyData[]; ++} QEMU_PACKED msos_prop_data; ++ ++typedef enum msos_prop_type { ++ MSOS_REG_SZ = 1, ++ MSOS_REG_EXPAND_SZ = 2, ++ MSOS_REG_BINARY = 3, ++ MSOS_REG_DWORD_LE = 4, ++ MSOS_REG_DWORD_BE = 5, ++ MSOS_REG_LINK = 6, ++ MSOS_REG_MULTI_SZ = 7, ++} msos_prop_type; ++ ++static int usb_desc_msos_prop_name(struct msos_prop *prop, ++ const wchar_t *name) ++{ ++ int length = wcslen(name) + 1; ++ int i; ++ ++ prop->dwPropertyNameLength_lo = usb_lo(length*2); ++ prop->dwPropertyNameLength_hi = usb_hi(length*2); ++ for (i = 0; i < length; i++) { ++ prop->bPropertyName[i*2] = usb_lo(name[i]); ++ prop->bPropertyName[i*2+1] = usb_hi(name[i]); ++ } ++ return length*2; ++} ++ ++static int usb_desc_msos_prop_str(uint8_t *dest, msos_prop_type type, ++ const wchar_t *name, const wchar_t *value) ++{ ++ struct msos_prop *prop = (void *)dest; ++ struct msos_prop_data *data; ++ int length = sizeof(*prop); ++ int i, vlen = wcslen(value) + 1; ++ ++ prop->dwPropertyDataType = cpu_to_le32(type); ++ length += usb_desc_msos_prop_name(prop, name); ++ data = (void *)(dest + length); ++ ++ data->dwPropertyDataLength = cpu_to_le32(vlen*2); ++ length += sizeof(*prop); ++ ++ for (i = 0; i < vlen; i++) { ++ data->bPropertyData[i*2] = usb_lo(value[i]); ++ data->bPropertyData[i*2+1] = usb_hi(value[i]); ++ } ++ length += vlen*2; ++ ++ prop->dwLength = cpu_to_le32(length); ++ return length; ++} ++ ++static int usb_desc_msos_prop_dword(uint8_t *dest, const wchar_t *name, ++ uint32_t value) ++{ ++ struct msos_prop *prop = (void *)dest; ++ struct msos_prop_data *data; ++ int length = sizeof(*prop); ++ ++ prop->dwPropertyDataType = cpu_to_le32(MSOS_REG_DWORD_LE); ++ length += usb_desc_msos_prop_name(prop, name); ++ data = (void *)(dest + length); ++ ++ data->dwPropertyDataLength = cpu_to_le32(4); ++ data->bPropertyData[0] = (value) & 0xff; ++ data->bPropertyData[1] = (value >> 8) & 0xff; ++ data->bPropertyData[2] = (value >> 16) & 0xff; ++ data->bPropertyData[3] = (value >> 24) & 0xff; ++ length += sizeof(*prop) + 4; ++ ++ prop->dwLength = cpu_to_le32(length); ++ return length; ++} ++ ++static int usb_desc_msos_prop(const USBDesc *desc, uint8_t *dest) ++{ ++ msos_prop_hdr *hdr = (void *)dest; ++ int length = sizeof(*hdr); ++ int count = 0; ++ ++ if (desc->msos->Label) { ++ /* ++ * Given as example in the specs. Havn't figured yet where ++ * this label shows up in the windows gui. ++ */ ++ length += usb_desc_msos_prop_str(dest+length, MSOS_REG_SZ, ++ L"Label", desc->msos->Label); ++ count++; ++ } ++ ++ if (desc->msos->SelectiveSuspendEnabled) { ++ /* ++ * Signaling remote wakeup capability in the standard usb ++ * descriptors isn't enouth to make windows actually use it. ++ * This is the "Yes, we really mean it" registy entry to flip ++ * the switch in the windows drivers. ++ */ ++ length += usb_desc_msos_prop_dword(dest+length, ++ L"SelectiveSuspendEnabled", 1); ++ count++; ++ } ++ ++ hdr->dwLength = cpu_to_le32(length); ++ hdr->bcdVersion_lo = 0x00; ++ hdr->bcdVersion_hi = 0x01; ++ hdr->wIndex_lo = 0x05; ++ hdr->wIndex_hi = 0x00; ++ hdr->wCount_lo = usb_lo(count); ++ hdr->wCount_hi = usb_hi(count); ++ return length; ++} ++ ++/* ------------------------------------------------------------------ */ ++ ++int usb_desc_msos(const USBDesc *desc, USBPacket *p, ++ int index, uint8_t *dest, size_t len) ++{ ++ void *buf = g_malloc0(4096); ++ int length = 0; ++ ++ switch (index) { ++ case 0x0004: ++ length = usb_desc_msos_compat(desc, buf); ++ break; ++ case 0x0005: ++ length = usb_desc_msos_prop(desc, buf); ++ break; ++ } ++ ++ if (length > len) { ++ length = len; ++ } ++ memcpy(dest, buf, length); ++ free(buf); ++ ++ p->actual_length = length; ++ return 0; ++} +diff --git a/hw/usb/desc.c b/hw/usb/desc.c +index 3e560cd..5a954c6 100644 +--- a/hw/usb/desc.c ++++ b/hw/usb/desc.c +@@ -7,7 +7,7 @@ + /* ------------------------------------------------------------------ */ + + int usb_desc_device(const USBDescID *id, const USBDescDevice *dev, +- uint8_t *dest, size_t len) ++ bool msos, uint8_t *dest, size_t len) + { + uint8_t bLength = 0x12; + USBDescriptor *d = (void *)dest; +@@ -19,8 +19,18 @@ int usb_desc_device(const USBDescID *id, const USBDescDevice *dev, + d->bLength = bLength; + d->bDescriptorType = USB_DT_DEVICE; + +- d->u.device.bcdUSB_lo = usb_lo(dev->bcdUSB); +- d->u.device.bcdUSB_hi = usb_hi(dev->bcdUSB); ++ if (msos && dev->bcdUSB < 0x0200) { ++ /* ++ * Version 2.0+ required for microsoft os descriptors to work. ++ * Done this way so msos-desc compat property will handle both ++ * the version and the new descriptors being present. ++ */ ++ d->u.device.bcdUSB_lo = usb_lo(0x0200); ++ d->u.device.bcdUSB_hi = usb_hi(0x0200); ++ } else { ++ d->u.device.bcdUSB_lo = usb_lo(dev->bcdUSB); ++ d->u.device.bcdUSB_hi = usb_hi(dev->bcdUSB); ++ } + d->u.device.bDeviceClass = dev->bDeviceClass; + d->u.device.bDeviceSubClass = dev->bDeviceSubClass; + d->u.device.bDeviceProtocol = dev->bDeviceProtocol; +@@ -497,6 +507,10 @@ void usb_desc_init(USBDevice *dev) + if (desc->super) { + dev->speedmask |= USB_SPEED_MASK_SUPER; + } ++ if (desc->msos && (dev->flags & (1 << USB_DEV_FLAG_MSOS_DESC_ENABLE))) { ++ dev->flags |= (1 << USB_DEV_FLAG_MSOS_DESC_IN_USE); ++ usb_desc_set_string(dev, 0xee, "MSFT100Q"); ++ } + usb_desc_setdefaults(dev); + } + +@@ -624,6 +638,7 @@ int usb_desc_string(USBDevice *dev, int index, uint8_t *dest, size_t len) + int usb_desc_get_descriptor(USBDevice *dev, USBPacket *p, + int value, uint8_t *dest, size_t len) + { ++ bool msos = (dev->flags & (1 << USB_DEV_FLAG_MSOS_DESC_IN_USE)); + const USBDesc *desc = usb_device_get_usb_desc(dev); + const USBDescDevice *other_dev; + uint8_t buf[256]; +@@ -644,7 +659,7 @@ int usb_desc_get_descriptor(USBDevice *dev, USBPacket *p, + + switch(type) { + case USB_DT_DEVICE: +- ret = usb_desc_device(&desc->id, dev->device, buf, sizeof(buf)); ++ ret = usb_desc_device(&desc->id, dev->device, msos, buf, sizeof(buf)); + trace_usb_desc_device(dev->addr, len, ret); + break; + case USB_DT_CONFIG: +@@ -701,6 +716,7 @@ int usb_desc_get_descriptor(USBDevice *dev, USBPacket *p, + int usb_desc_handle_control(USBDevice *dev, USBPacket *p, + int request, int value, int index, int length, uint8_t *data) + { ++ bool msos = (dev->flags & (1 << USB_DEV_FLAG_MSOS_DESC_IN_USE)); + const USBDesc *desc = usb_device_get_usb_desc(dev); + int ret = -1; + +@@ -780,6 +796,19 @@ int usb_desc_handle_control(USBDevice *dev, USBPacket *p, + trace_usb_set_interface(dev->addr, index, value, ret); + break; + ++ case VendorDeviceRequest | 'Q': ++ if (msos) { ++ ret = usb_desc_msos(desc, p, index, data, length); ++ trace_usb_desc_msos(dev->addr, index, length, ret); ++ } ++ break; ++ case VendorInterfaceRequest | 'Q': ++ if (msos) { ++ ret = usb_desc_msos(desc, p, index, data, length); ++ trace_usb_desc_msos(dev->addr, index, length, ret); ++ } ++ break; ++ + } + return ret; + } +diff --git a/hw/usb/desc.h b/hw/usb/desc.h +index 81327b0..2b4fcda 100644 +--- a/hw/usb/desc.h ++++ b/hw/usb/desc.h +@@ -2,6 +2,7 @@ + #define QEMU_HW_USB_DESC_H + + #include ++#include + + /* binary representation */ + typedef struct USBDescriptor { +@@ -182,6 +183,11 @@ struct USBDescOther { + const uint8_t *data; + }; + ++struct USBDescMSOS { ++ const wchar_t *Label; ++ bool SelectiveSuspendEnabled; ++}; ++ + typedef const char *USBDescStrings[256]; + + struct USBDesc { +@@ -190,6 +196,7 @@ struct USBDesc { + const USBDescDevice *high; + const USBDescDevice *super; + const char* const *str; ++ const USBDescMSOS *msos; + }; + + #define USB_DESC_FLAG_SUPER (1 << 1) +@@ -207,7 +214,7 @@ static inline uint8_t usb_hi(uint16_t val) + + /* generate usb packages from structs */ + int usb_desc_device(const USBDescID *id, const USBDescDevice *dev, +- uint8_t *dest, size_t len); ++ bool msos, uint8_t *dest, size_t len); + int usb_desc_device_qualifier(const USBDescDevice *dev, + uint8_t *dest, size_t len); + int usb_desc_config(const USBDescConfig *conf, int flags, +@@ -219,6 +226,8 @@ int usb_desc_iface(const USBDescIface *iface, int flags, + int usb_desc_endpoint(const USBDescEndpoint *ep, int flags, + uint8_t *dest, size_t len); + int usb_desc_other(const USBDescOther *desc, uint8_t *dest, size_t len); ++int usb_desc_msos(const USBDesc *desc, USBPacket *p, ++ int index, uint8_t *dest, size_t len); + + /* control message emulation helpers */ + void usb_desc_init(USBDevice *dev); +diff --git a/include/hw/usb.h b/include/hw/usb.h +index a910456..b111be0 100644 +--- a/include/hw/usb.h ++++ b/include/hw/usb.h +@@ -182,6 +182,7 @@ typedef struct USBDescIface USBDescIface; + typedef struct USBDescEndpoint USBDescEndpoint; + typedef struct USBDescOther USBDescOther; + typedef struct USBDescString USBDescString; ++typedef struct USBDescMSOS USBDescMSOS; + + struct USBDescString { + uint8_t index; +@@ -207,6 +208,8 @@ struct USBEndpoint { + enum USBDeviceFlags { + USB_DEV_FLAG_FULL_PATH, + USB_DEV_FLAG_IS_HOST, ++ USB_DEV_FLAG_MSOS_DESC_ENABLE, ++ USB_DEV_FLAG_MSOS_DESC_IN_USE, + }; + + /* definition of a USB device */ +diff --git a/trace-events b/trace-events +index dbbd25d..5d86cf3 100644 +--- a/trace-events ++++ b/trace-events +@@ -393,6 +393,7 @@ usb_desc_config(int addr, int index, int len, int ret) "dev %d query config %d, + usb_desc_other_speed_config(int addr, int index, int len, int ret) "dev %d query config %d, len %d, ret %d" + usb_desc_string(int addr, int index, int len, int ret) "dev %d query string %d, len %d, ret %d" + usb_desc_bos(int addr, int len, int ret) "dev %d bos, len %d, ret %d" ++usb_desc_msos(int addr, int index, int len, int ret) "dev %d msos, index 0x%x, len %d, ret %d" + usb_set_addr(int addr) "dev %d" + usb_set_config(int addr, int config, int ret) "dev %d, config %d, ret %d" + usb_set_interface(int addr, int iface, int alt, int ret) "dev %d, interface %d, altsetting %d, ret %d" +-- +1.7.1 + diff --git a/SOURCES/kvm-usb-add-vendor-request-defines.patch b/SOURCES/kvm-usb-add-vendor-request-defines.patch new file mode 100644 index 0000000..d07a690 --- /dev/null +++ b/SOURCES/kvm-usb-add-vendor-request-defines.patch @@ -0,0 +1,67 @@ +From d76e3e1722f8895eaa4f34596169decde859fa86 Mon Sep 17 00:00:00 2001 +From: Gerd Hoffmann +Date: Mon, 3 Feb 2014 16:30:28 +0100 +Subject: [PATCH 04/28] usb: add vendor request defines + +RH-Author: Gerd Hoffmann +Message-id: <1391445032-5540-2-git-send-email-kraxel@redhat.com> +Patchwork-id: 57078 +O-Subject: [RHEL-7 qemu-kvm PATCH 1/5] usb: add vendor request defines +Bugzilla: 1039530 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Juan Quintela +RH-Acked-by: Miroslav Rezanina + +Add defines for vendor specific usb control requests. +Group defines by Device / Interface / Endpoint while +being at it. + +Signed-off-by: Gerd Hoffmann +(cherry picked from commit 2b81ba53887e6f3b5a79ecd2f446f849ed89561f) +--- + include/hw/usb.h | 17 +++++++++++++---- + 1 file changed, 13 insertions(+), 4 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + include/hw/usb.h | 17 +++++++++++++---- + 1 files changed, 13 insertions(+), 4 deletions(-) + +diff --git a/include/hw/usb.h b/include/hw/usb.h +index 695d853..a910456 100644 +--- a/include/hw/usb.h ++++ b/include/hw/usb.h +@@ -102,17 +102,26 @@ + + #define DeviceRequest ((USB_DIR_IN|USB_TYPE_STANDARD|USB_RECIP_DEVICE)<<8) + #define DeviceOutRequest ((USB_DIR_OUT|USB_TYPE_STANDARD|USB_RECIP_DEVICE)<<8) +-#define InterfaceRequest \ ++#define VendorDeviceRequest ((USB_DIR_IN|USB_TYPE_VENDOR|USB_RECIP_DEVICE)<<8) ++#define VendorDeviceOutRequest \ ++ ((USB_DIR_OUT|USB_TYPE_VENDOR|USB_RECIP_DEVICE)<<8) ++ ++#define InterfaceRequest \ + ((USB_DIR_IN|USB_TYPE_STANDARD|USB_RECIP_INTERFACE)<<8) + #define InterfaceOutRequest \ + ((USB_DIR_OUT|USB_TYPE_STANDARD|USB_RECIP_INTERFACE)<<8) +-#define EndpointRequest ((USB_DIR_IN|USB_TYPE_STANDARD|USB_RECIP_ENDPOINT)<<8) +-#define EndpointOutRequest \ +- ((USB_DIR_OUT|USB_TYPE_STANDARD|USB_RECIP_ENDPOINT)<<8) + #define ClassInterfaceRequest \ + ((USB_DIR_IN|USB_TYPE_CLASS|USB_RECIP_INTERFACE)<<8) + #define ClassInterfaceOutRequest \ + ((USB_DIR_OUT|USB_TYPE_CLASS|USB_RECIP_INTERFACE)<<8) ++#define VendorInterfaceRequest \ ++ ((USB_DIR_IN|USB_TYPE_VENDOR|USB_RECIP_INTERFACE)<<8) ++#define VendorInterfaceOutRequest \ ++ ((USB_DIR_OUT|USB_TYPE_VENDOR|USB_RECIP_INTERFACE)<<8) ++ ++#define EndpointRequest ((USB_DIR_IN|USB_TYPE_STANDARD|USB_RECIP_ENDPOINT)<<8) ++#define EndpointOutRequest \ ++ ((USB_DIR_OUT|USB_TYPE_STANDARD|USB_RECIP_ENDPOINT)<<8) + + #define USB_REQ_GET_STATUS 0x00 + #define USB_REQ_CLEAR_FEATURE 0x01 +-- +1.7.1 + diff --git a/SOURCES/kvm-usb-hid-add-microsoft-os-descriptor-support.patch b/SOURCES/kvm-usb-hid-add-microsoft-os-descriptor-support.patch new file mode 100644 index 0000000..7b9ffd6 --- /dev/null +++ b/SOURCES/kvm-usb-hid-add-microsoft-os-descriptor-support.patch @@ -0,0 +1,79 @@ +From 2dbe97005502fe2e1dcbebf177bafe443a62e96d Mon Sep 17 00:00:00 2001 +From: Gerd Hoffmann +Date: Mon, 3 Feb 2014 16:30:32 +0100 +Subject: [PATCH 08/28] usb-hid: add microsoft os descriptor support + +RH-Author: Gerd Hoffmann +Message-id: <1391445032-5540-6-git-send-email-kraxel@redhat.com> +Patchwork-id: 57079 +O-Subject: [RHEL-7 qemu-kvm PATCH 5/5] usb-hid: add microsoft os descriptor support +Bugzilla: 1039530 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Juan Quintela +RH-Acked-by: Miroslav Rezanina + +Set SelectiveSuspendEnabled registy entry to one. +This makes Windows use remote suspend by default, +without manual registry fiddeling. + +Signed-off-by: Gerd Hoffmann +(cherry picked from commit 88678fbd9dbf01fd0988bcb651508378d85e868a) +--- + hw/usb/dev-hid.c | 8 ++++++++ + 1 file changed, 8 insertions(+) + +Signed-off-by: Miroslav Rezanina +--- + hw/usb/dev-hid.c | 8 ++++++++ + 1 files changed, 8 insertions(+), 0 deletions(-) + +diff --git a/hw/usb/dev-hid.c b/hw/usb/dev-hid.c +index 6aadaa0..7dc75f7 100644 +--- a/hw/usb/dev-hid.c ++++ b/hw/usb/dev-hid.c +@@ -261,6 +261,10 @@ static const USBDescDevice desc_device_keyboard = { + }, + }; + ++static const USBDescMSOS desc_msos_suspend = { ++ .SelectiveSuspendEnabled = true, ++}; ++ + static const USBDesc desc_mouse = { + .id = { + .idVendor = 0x0627, +@@ -272,6 +276,7 @@ static const USBDesc desc_mouse = { + }, + .full = &desc_device_mouse, + .str = desc_strings, ++ .msos = &desc_msos_suspend, + }; + + static const USBDesc desc_tablet = { +@@ -285,6 +290,7 @@ static const USBDesc desc_tablet = { + }, + .full = &desc_device_tablet, + .str = desc_strings, ++ .msos = &desc_msos_suspend, + }; + + static const USBDesc desc_tablet2 = { +@@ -299,6 +305,7 @@ static const USBDesc desc_tablet2 = { + .full = &desc_device_tablet, + .high = &desc_device_tablet2, + .str = desc_strings, ++ .msos = &desc_msos_suspend, + }; + + static const USBDesc desc_keyboard = { +@@ -312,6 +319,7 @@ static const USBDesc desc_keyboard = { + }, + .full = &desc_device_keyboard, + .str = desc_strings, ++ .msos = &desc_msos_suspend, + }; + + static const uint8_t qemu_mouse_hid_report_descriptor[] = { +-- +1.7.1 + diff --git a/SOURCES/kvm-usb-move-usb_-hi-lo-helpers-to-header-file.patch b/SOURCES/kvm-usb-move-usb_-hi-lo-helpers-to-header-file.patch new file mode 100644 index 0000000..5266719 --- /dev/null +++ b/SOURCES/kvm-usb-move-usb_-hi-lo-helpers-to-header-file.patch @@ -0,0 +1,73 @@ +From f37a2871c57468d317739e21cc747066d9ed284f Mon Sep 17 00:00:00 2001 +From: Gerd Hoffmann +Date: Mon, 3 Feb 2014 16:30:29 +0100 +Subject: [PATCH 05/28] usb: move usb_{hi, lo} helpers to header file. + +RH-Author: Gerd Hoffmann +Message-id: <1391445032-5540-3-git-send-email-kraxel@redhat.com> +Patchwork-id: 57076 +O-Subject: [RHEL-7 qemu-kvm PATCH 2/5] usb: move usb_{hi, lo} helpers to header file. +Bugzilla: 1039530 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Juan Quintela +RH-Acked-by: Miroslav Rezanina + +Signed-off-by: Gerd Hoffmann +(cherry picked from commit 0b1fa34e1dd2764ee7ae2be849e1c5ba5e8724ca) +--- + hw/usb/desc.c | 10 ---------- + hw/usb/desc.h | 11 +++++++++++ + 2 files changed, 11 insertions(+), 10 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + hw/usb/desc.c | 10 ---------- + hw/usb/desc.h | 11 +++++++++++ + 2 files changed, 11 insertions(+), 10 deletions(-) + +diff --git a/hw/usb/desc.c b/hw/usb/desc.c +index bf6c522..3e560cd 100644 +--- a/hw/usb/desc.c ++++ b/hw/usb/desc.c +@@ -6,16 +6,6 @@ + + /* ------------------------------------------------------------------ */ + +-static uint8_t usb_lo(uint16_t val) +-{ +- return val & 0xff; +-} +- +-static uint8_t usb_hi(uint16_t val) +-{ +- return (val >> 8) & 0xff; +-} +- + int usb_desc_device(const USBDescID *id, const USBDescDevice *dev, + uint8_t *dest, size_t len) + { +diff --git a/hw/usb/desc.h b/hw/usb/desc.h +index ddd3e74..81327b0 100644 +--- a/hw/usb/desc.h ++++ b/hw/usb/desc.h +@@ -194,6 +194,17 @@ struct USBDesc { + + #define USB_DESC_FLAG_SUPER (1 << 1) + ++/* little helpers */ ++static inline uint8_t usb_lo(uint16_t val) ++{ ++ return val & 0xff; ++} ++ ++static inline uint8_t usb_hi(uint16_t val) ++{ ++ return (val >> 8) & 0xff; ++} ++ + /* generate usb packages from structs */ + int usb_desc_device(const USBDescID *id, const USBDescDevice *dev, + uint8_t *dest, size_t len); +-- +1.7.1 + diff --git a/SOURCES/kvm-use-directly-cpu_physical_memory_-api-for-tracki.patch b/SOURCES/kvm-use-directly-cpu_physical_memory_-api-for-tracki.patch new file mode 100644 index 0000000..04f2eb1 --- /dev/null +++ b/SOURCES/kvm-use-directly-cpu_physical_memory_-api-for-tracki.patch @@ -0,0 +1,79 @@ +From 85f240605d1a46de1fc8609f8e64b994f4716adb Mon Sep 17 00:00:00 2001 +From: Juan Quintela +Date: Tue, 14 Jan 2014 15:07:46 +0100 +Subject: [PATCH 35/40] kvm: use directly cpu_physical_memory_* api for tracking dirty pages +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +RH-Author: Juan Quintela +Message-id: <1389712071-23303-36-git-send-email-quintela@redhat.com> +Patchwork-id: 56690 +O-Subject: [RHEL7 qemu-kvm PATCH 35/40] kvm: use directly cpu_physical_memory_* api for tracking dirty pages +Bugzilla: 997559 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Orit Wasserman +RH-Acked-by: Dr. David Alan Gilbert (git) + +Performance is important in this function, and we want to optimize even further. + +Signed-off-by: Juan Quintela +Reviewed-by: Orit Wasserman +(cherry picked from commit 747afd5bcdc90f608c75d95f8a629a9cfc838c57) + +Conflicts: + kvm-all.c + +Due to upstream commits: + +commit dd1750d7981cf9e38985c9dfa474dcdbbe236270 +Author: Andreas Färber +Date: Wed May 1 13:45:44 2013 +0200 + + kvm: Change kvm_cpu_synchronize_state() argument to CPUState + +Signed-off-by: Juan Quintela +--- + kvm-all.c | 7 +++++-- + 1 file changed, 5 insertions(+), 2 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + kvm-all.c | 7 +++++-- + 1 files changed, 5 insertions(+), 2 deletions(-) + +diff --git a/kvm-all.c b/kvm-all.c +index 0e21494..8e2bd34 100644 +--- a/kvm-all.c ++++ b/kvm-all.c +@@ -31,6 +31,7 @@ + #include "sysemu/kvm.h" + #include "qemu/bswap.h" + #include "exec/memory.h" ++#include "exec/ram_addr.h" + #include "exec/address-spaces.h" + #include "qemu/event_notifier.h" + #include "trace.h" +@@ -367,6 +368,7 @@ static int kvm_get_dirty_pages_log_range(MemoryRegionSection *section, + unsigned int i, j; + unsigned long page_number, c; + hwaddr addr, addr1; ++ ram_addr_t ram_addr; + unsigned int len = ((section->size / getpagesize()) + HOST_LONG_BITS - 1) / HOST_LONG_BITS; + unsigned long hpratio = getpagesize() / TARGET_PAGE_SIZE; + +@@ -383,8 +385,9 @@ static int kvm_get_dirty_pages_log_range(MemoryRegionSection *section, + page_number = (i * HOST_LONG_BITS + j) * hpratio; + addr1 = page_number * TARGET_PAGE_SIZE; + addr = section->offset_within_region + addr1; +- memory_region_set_dirty(section->mr, addr, +- TARGET_PAGE_SIZE * hpratio); ++ ram_addr = section->mr->ram_addr + addr; ++ cpu_physical_memory_set_dirty_range(ram_addr, ++ TARGET_PAGE_SIZE * hpratio); + } while (c != 0); + } + } +-- +1.7.1 + diff --git a/SOURCES/kvm-use-recommended-max-vcpu-count.patch b/SOURCES/kvm-use-recommended-max-vcpu-count.patch new file mode 100644 index 0000000..bd9d7dc --- /dev/null +++ b/SOURCES/kvm-use-recommended-max-vcpu-count.patch @@ -0,0 +1,50 @@ +From 3513ae9049f3587572997f2728e219be11679da8 Mon Sep 17 00:00:00 2001 +From: Andrew Jones +Date: Tue, 21 Jan 2014 10:46:52 +0100 +Subject: [PATCH 31/34] use recommended max vcpu count + +RH-Author: Andrew Jones +Message-id: <1390301212-15344-1-git-send-email-drjones@redhat.com> +Patchwork-id: 56862 +O-Subject: [RHEL7.0 qemu-kvm PATCH v6] use recommended max vcpu count +Bugzilla: 998708 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Laszlo Ersek +RH-Acked-by: Marcelo Tosatti + +RHEL-only +Bugzilla: 998708 +Brew: 6905708 + +The recommended vcpu max limit (KVM_CAP_NR_VCPUS) should be used instead +of the actual max vcpu limit (KVM_CAP_MAX_VCPUS) to give an error. + +This matches the limit tested by QE on RHEL6: 160. + +Signed-off-by: Andrew Jones +--- + kvm-all.c | 3 +++ + 1 file changed, 3 insertions(+) + +Signed-off-by: Miroslav Rezanina +--- + kvm-all.c | 3 +++ + 1 files changed, 3 insertions(+), 0 deletions(-) + +diff --git a/kvm-all.c b/kvm-all.c +index 19acd58..603bd4b 100644 +--- a/kvm-all.c ++++ b/kvm-all.c +@@ -1350,6 +1350,9 @@ int kvm_init(void) + soft_vcpus_limit = kvm_recommended_vcpus(s); + hard_vcpus_limit = kvm_max_vcpus(s); + ++ /* RHEL doesn't support nr_vcpus > soft_vcpus_limit */ ++ hard_vcpus_limit = soft_vcpus_limit; ++ + while (nc->name) { + if (nc->num > soft_vcpus_limit) { + fprintf(stderr, +-- +1.7.1 + diff --git a/SOURCES/kvm-vdi-add-bounds-checks-for-blocks_in_image-and-disk_s.patch b/SOURCES/kvm-vdi-add-bounds-checks-for-blocks_in_image-and-disk_s.patch new file mode 100644 index 0000000..7f56604 --- /dev/null +++ b/SOURCES/kvm-vdi-add-bounds-checks-for-blocks_in_image-and-disk_s.patch @@ -0,0 +1,112 @@ +From 6ce116dda5d5a7708d660e32713ff40fc3f749ef Mon Sep 17 00:00:00 2001 +From: Jeff Cody +Date: Tue, 25 Mar 2014 14:23:24 +0100 +Subject: [PATCH 17/49] vdi: add bounds checks for blocks_in_image and disk_size header fields (CVE-2014-0144) + +RH-Author: Kevin Wolf +Message-id: <1395753835-7591-18-git-send-email-kwolf@redhat.com> +Patchwork-id: n/a +O-Subject: [virt-devel] [EMBARGOED RHEL-7.0 qemu-kvm PATCH 17/48] vdi: add bounds checks for blocks_in_image and disk_size header fields (CVE-2014-0144) +Bugzilla: 1079455 +RH-Acked-by: Jeff Cody +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Paolo Bonzini + +From: Jeff Cody + +Bugzilla: https://bugzilla.redhat.com/show_bug.cgi?id=1079455 +Upstream status: Embargoed + +The maximum blocks_in_image is 0xffffffff / 4, which also limits the +maximum disk_size for a VDI image. + +Signed-off-by: Jeff Cody +Signed-off-by: Kevin Wolf + +Conflicts: +block/vdi.c + +Signed-off-by: Kevin Wolf +--- + block/vdi.c | 26 ++++++++++++++++++++++++-- + 1 files changed, 24 insertions(+), 2 deletions(-) + +diff --git a/block/vdi.c b/block/vdi.c +index f973883..0457298 100644 +--- a/block/vdi.c ++++ b/block/vdi.c +@@ -120,6 +120,12 @@ typedef unsigned char uuid_t[16]; + + #define VDI_IS_ALLOCATED(X) ((X) < VDI_DISCARDED) + ++#define VDI_BLOCK_SIZE (1 * MiB) ++/* max blocks in image is (0xffffffff / 4) */ ++#define VDI_BLOCKS_IN_IMAGE_MAX 0x3fffffff ++#define VDI_DISK_SIZE_MAX ((uint64_t)VDI_BLOCKS_IN_IMAGE_MAX * \ ++ (uint64_t)VDI_BLOCK_SIZE) ++ + #if !defined(CONFIG_UUID) + static inline void uuid_generate(uuid_t out) + { +@@ -385,6 +391,11 @@ static int vdi_open(BlockDriverState *bs, QDict *options, int flags, + vdi_header_print(&header); + #endif + ++ if (header.disk_size > VDI_DISK_SIZE_MAX) { ++ ret = -EINVAL; ++ goto fail; ++ } ++ + if (header.disk_size % SECTOR_SIZE != 0) { + /* 'VBoxManage convertfromraw' can create images with odd disk sizes. + We accept them but round the disk size to the next multiple of +@@ -417,7 +428,7 @@ static int vdi_open(BlockDriverState *bs, QDict *options, int flags, + logout("unsupported sector size %u B\n", header.sector_size); + ret = -ENOTSUP; + goto fail; +- } else if (header.block_size != 1 * MiB) { ++ } else if (header.block_size != VDI_BLOCK_SIZE) { + logout("unsupported block size %u B\n", header.block_size); + ret = -ENOTSUP; + goto fail; +@@ -434,6 +445,10 @@ static int vdi_open(BlockDriverState *bs, QDict *options, int flags, + logout("parent uuid != 0, unsupported\n"); + ret = -ENOTSUP; + goto fail; ++ } else if (header.blocks_in_image > VDI_BLOCKS_IN_IMAGE_MAX) { ++ logout("unsupported number of blocks in image\n"); ++ ret = -ENOTSUP; ++ goto fail; + } + + bs->total_sectors = header.disk_size / SECTOR_SIZE; +@@ -682,11 +697,17 @@ static int vdi_create(const char *filename, QEMUOptionParameter *options, + options++; + } + ++ if (bytes > VDI_DISK_SIZE_MAX) { ++ result = -EINVAL; ++ goto exit; ++ } ++ + fd = qemu_open(filename, + O_WRONLY | O_CREAT | O_TRUNC | O_BINARY | O_LARGEFILE, + 0644); + if (fd < 0) { +- return -errno; ++ result = -errno; ++ goto exit; + } + + /* We need enough blocks to store the given disk size, +@@ -747,6 +768,7 @@ static int vdi_create(const char *filename, QEMUOptionParameter *options, + result = -errno; + } + ++exit: + return result; + } + +-- +1.7.1 + diff --git a/SOURCES/kvm-vfio-Destroy-memory-regions.patch b/SOURCES/kvm-vfio-Destroy-memory-regions.patch new file mode 100644 index 0000000..40f3eac --- /dev/null +++ b/SOURCES/kvm-vfio-Destroy-memory-regions.patch @@ -0,0 +1,68 @@ +From 6ca164c42aa26e2273871061aa509cc50bd0dc4c Mon Sep 17 00:00:00 2001 +From: Alex Williamson +Date: Wed, 22 Jan 2014 21:33:06 -0500 +Subject: [PATCH 2/6] vfio: Destroy memory regions + +Message-id: <20140122213238.6166.63139.stgit@bling.home> +Patchwork-id: 56902 +O-Subject: [RHEL-7 qemu-kvm PATCH 1/1] vfio: Destroy memory regions +Bugzilla: 1052030 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Bandan Das +RH-Acked-by: Laszlo Ersek + +Bugzilla: 1052030 +Upstream: 7c4228b4771acddcb8815079bc116007cec8a1ff (tag from pull request) + +Somehow this has been lurking for a while; we remove our subregions +from the base BAR and VGA region mappings, but we don't destroy them, +creating a leak and more serious problems when we try to migrate after +removing these devices. Add the trivial bit of final cleanup to +remove these entirely. + +Signed-off-by: Alex Williamson +--- + hw/misc/vfio.c | 4 ++++ + 1 file changed, 4 insertions(+) + +Signed-off-by: Miroslav Rezanina +--- + hw/misc/vfio.c | 4 ++++ + 1 file changed, 4 insertions(+) + +diff --git a/hw/misc/vfio.c b/hw/misc/vfio.c +index 83f2b6a..e1f30a2 100644 +--- a/hw/misc/vfio.c ++++ b/hw/misc/vfio.c +@@ -1928,6 +1928,7 @@ static void vfio_vga_quirk_teardown(VFIODevice *vdev) + while (!QLIST_EMPTY(&vdev->vga.region[i].quirks)) { + VFIOQuirk *quirk = QLIST_FIRST(&vdev->vga.region[i].quirks); + memory_region_del_subregion(&vdev->vga.region[i].mem, &quirk->mem); ++ memory_region_destroy(&quirk->mem); + QLIST_REMOVE(quirk, next); + g_free(quirk); + } +@@ -1950,6 +1951,7 @@ static void vfio_bar_quirk_teardown(VFIODevice *vdev, int nr) + while (!QLIST_EMPTY(&bar->quirks)) { + VFIOQuirk *quirk = QLIST_FIRST(&bar->quirks); + memory_region_del_subregion(&bar->mem, &quirk->mem); ++ memory_region_destroy(&quirk->mem); + QLIST_REMOVE(quirk, next); + g_free(quirk); + } +@@ -2379,10 +2381,12 @@ static void vfio_unmap_bar(VFIODevice *vdev, int nr) + + memory_region_del_subregion(&bar->mem, &bar->mmap_mem); + munmap(bar->mmap, memory_region_size(&bar->mmap_mem)); ++ memory_region_destroy(&bar->mmap_mem); + + if (vdev->msix && vdev->msix->table_bar == nr) { + memory_region_del_subregion(&bar->mem, &vdev->msix->mmap_mem); + munmap(vdev->msix->mmap, memory_region_size(&vdev->msix->mmap_mem)); ++ memory_region_destroy(&vdev->msix->mmap_mem); + } + + memory_region_destroy(&bar->mem); +-- +1.8.3.1 + diff --git a/SOURCES/kvm-vfio-blacklist-loading-of-unstable-roms.patch b/SOURCES/kvm-vfio-blacklist-loading-of-unstable-roms.patch new file mode 100644 index 0000000..03c0a67 --- /dev/null +++ b/SOURCES/kvm-vfio-blacklist-loading-of-unstable-roms.patch @@ -0,0 +1,141 @@ +From 8c54fd61fa0c98d6e543923badfd174160acedd0 Mon Sep 17 00:00:00 2001 +From: Bandan Das +Date: Thu, 27 Feb 2014 18:31:17 +0100 +Subject: [PATCH 5/6] vfio: blacklist loading of unstable roms + +RH-Author: Bandan Das +Message-id: <1393525877-32262-3-git-send-email-bsd@redhat.com> +Patchwork-id: 57933 +O-Subject: [PATCH RHEL-7.0 qemu-kvm v2 2/2] vfio: blacklist loading of unstable roms +Bugzilla: 1037956 +RH-Acked-by: Alex Williamson +RH-Acked-by: Michael S. Tsirkin +RH-Acked-by: Marcel Apfelbaum + +Certain cards such as the Broadcom BCM57810 have rom quirks +that exhibit unstable system behavior duing device assignment. In +the particular case of 57810, rom execution hangs and if a FLR +follows, the device becomes inoperable until a power cycle. This +change blacklists loading of rom for such cards unless the user +specifies a romfile or rombar=1 on the cmd line + +Signed-off-by: Bandan Das +Signed-off-by: Alex Williamson +(cherry picked from commit 4b9430294ed406a00f045d825ada146aecf32309) +--- + hw/misc/vfio.c | 73 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + 1 file changed, 73 insertions(+) + +Signed-off-by: Miroslav Rezanina +--- + hw/misc/vfio.c | 73 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + 1 files changed, 73 insertions(+), 0 deletions(-) + +diff --git a/hw/misc/vfio.c b/hw/misc/vfio.c +index e1f30a2..b04170e 100644 +--- a/hw/misc/vfio.c ++++ b/hw/misc/vfio.c +@@ -206,6 +206,29 @@ typedef struct VFIOGroup { + QLIST_ENTRY(VFIOGroup) container_next; + } VFIOGroup; + ++typedef struct VFIORomBlacklistEntry { ++ uint16_t vendor_id; ++ uint16_t device_id; ++} VFIORomBlacklistEntry; ++ ++/* ++ * List of device ids/vendor ids for which to disable ++ * option rom loading. This avoids the guest hangs during rom ++ * execution as noticed with the BCM 57810 card for lack of a ++ * more better way to handle such issues. ++ * The user can still override by specifying a romfile or ++ * rombar=1. ++ * Please see https://bugs.launchpad.net/qemu/+bug/1284874 ++ * for an analysis of the 57810 card hang. When adding ++ * a new vendor id/device id combination below, please also add ++ * your card/environment details and information that could ++ * help in debugging to the bug tracking this issue ++ */ ++static const VFIORomBlacklistEntry romblacklist[] = { ++ /* Broadcom BCM 57810 */ ++ { 0x14e4, 0x168e } ++}; ++ + #define MSIX_CAP_LENGTH 12 + #define MAX_DEV_ASSIGN_CMDLINE 32 + +@@ -1167,13 +1190,43 @@ static const MemoryRegionOps vfio_rom_ops = { + .endianness = DEVICE_LITTLE_ENDIAN, + }; + ++static bool vfio_blacklist_opt_rom(VFIODevice *vdev) ++{ ++ PCIDevice *pdev = &vdev->pdev; ++ uint16_t vendor_id, device_id; ++ int count = 0; ++ ++ vendor_id = pci_get_word(pdev->config + PCI_VENDOR_ID); ++ device_id = pci_get_word(pdev->config + PCI_DEVICE_ID); ++ ++ while (count < ARRAY_SIZE(romblacklist)) { ++ if (romblacklist[count].vendor_id == vendor_id && ++ romblacklist[count].device_id == device_id) { ++ return true; ++ } ++ count++; ++ } ++ ++ return false; ++} ++ + static void vfio_pci_size_rom(VFIODevice *vdev) + { + uint32_t orig, size = cpu_to_le32((uint32_t)PCI_ROM_ADDRESS_MASK); + off_t offset = vdev->config_offset + PCI_ROM_ADDRESS; ++ DeviceState *dev = DEVICE(vdev); + char name[32]; + + if (vdev->pdev.romfile || !vdev->pdev.rom_bar) { ++ /* Since pci handles romfile, just print a message and return */ ++ if (vfio_blacklist_opt_rom(vdev) && vdev->pdev.romfile) { ++ error_printf("Warning : Device at %04x:%02x:%02x.%x " ++ "is known to cause system instability issues during " ++ "option rom execution. " ++ "Proceeding anyway since user specified romfile\n", ++ vdev->host.domain, vdev->host.bus, vdev->host.slot, ++ vdev->host.function); ++ } + return; + } + +@@ -1197,6 +1250,26 @@ static void vfio_pci_size_rom(VFIODevice *vdev) + return; + } + ++ if (vfio_blacklist_opt_rom(vdev)) { ++ if (dev->opts && qemu_opt_get(dev->opts, "rombar")) { ++ error_printf("Warning : Device at %04x:%02x:%02x.%x " ++ "is known to cause system instability issues during " ++ "option rom execution. " ++ "Proceeding anyway since user specified non zero value for " ++ "rombar\n", ++ vdev->host.domain, vdev->host.bus, vdev->host.slot, ++ vdev->host.function); ++ } else { ++ error_printf("Warning : Rom loading for device at " ++ "%04x:%02x:%02x.%x has been disabled due to " ++ "system instability issues. " ++ "Specify rombar=1 or romfile to force\n", ++ vdev->host.domain, vdev->host.bus, vdev->host.slot, ++ vdev->host.function); ++ return; ++ } ++ } ++ + DPRINTF("%04x:%02x:%02x.%x ROM size 0x%x\n", vdev->host.domain, + vdev->host.bus, vdev->host.slot, vdev->host.function, size); + +-- +1.7.1 + diff --git a/SOURCES/kvm-vfio-cap-number-of-devices-that-can-be-assigned.patch b/SOURCES/kvm-vfio-cap-number-of-devices-that-can-be-assigned.patch new file mode 100644 index 0000000..7ce6fd3 --- /dev/null +++ b/SOURCES/kvm-vfio-cap-number-of-devices-that-can-be-assigned.patch @@ -0,0 +1,73 @@ +From 4110ee428550f672ee1a1a73a634d5392bf9c55f Mon Sep 17 00:00:00 2001 +Message-Id: <4110ee428550f672ee1a1a73a634d5392bf9c55f.1387382496.git.minovotn@redhat.com> +In-Reply-To: +References: +From: Bandan Das +Date: Tue, 3 Dec 2013 20:05:13 +0100 +Subject: [PATCH 44/46] vfio: cap number of devices that can be assigned + +RH-Author: Bandan Das +Message-id: <1386101113-31560-3-git-send-email-bsd@redhat.com> +Patchwork-id: 55984 +O-Subject: [PATCH RHEL7 qemu-kvm v2 2/2] vfio: cap number of devices that can be assigned +Bugzilla: 678368 +RH-Acked-by: Alex Williamson +RH-Acked-by: Marcelo Tosatti +RH-Acked-by: Michael S. Tsirkin + +Go through all groups to get count of total number of devices +active to enforce limit + +Reasoning from Alex for the limit(32) - Assuming 3 slots per +device, with 125 slots (number of memory slots for RHEL 7), +we can support almost 40 devices and still have few slots left +for other uses. Stepping down a bit, the number 32 arbitrarily +matches the number of slots on a PCI bus and is also a nice power +of two. + +Signed-off-by: Bandan Das +--- + hw/misc/vfio.c | 15 ++++++++++++++- + 1 file changed, 14 insertions(+), 1 deletion(-) + +Signed-off-by: Michal Novotny +--- + hw/misc/vfio.c | 15 ++++++++++++++- + 1 file changed, 14 insertions(+), 1 deletion(-) + +diff --git a/hw/misc/vfio.c b/hw/misc/vfio.c +index 250f96f..bd30130 100644 +--- a/hw/misc/vfio.c ++++ b/hw/misc/vfio.c +@@ -201,6 +201,7 @@ typedef struct VFIOGroup { + } VFIOGroup; + + #define MSIX_CAP_LENGTH 12 ++#define MAX_DEV_ASSIGN_CMDLINE 32 + + static QLIST_HEAD(, VFIOContainer) + container_list = QLIST_HEAD_INITIALIZER(container_list); +@@ -3557,7 +3558,19 @@ static int vfio_initfn(PCIDevice *pdev) + ssize_t len; + struct stat st; + int groupid; +- int ret; ++ int ret, i = 0; ++ ++ QLIST_FOREACH(group, &group_list, next) { ++ QLIST_FOREACH(pvdev, &group->device_list, next) { ++ i++; ++ } ++ } ++ ++ if (i >= MAX_DEV_ASSIGN_CMDLINE) { ++ error_report("vfio: Maximum supported vfio devices (%d) " ++ "already attached\n", MAX_DEV_ASSIGN_CMDLINE); ++ return -1; ++ } + + /* Check that the host device exists */ + snprintf(path, sizeof(path), +-- +1.7.11.7 + diff --git a/SOURCES/kvm-vfio-pci-Fail-initfn-on-DMA-mapping-errors.patch b/SOURCES/kvm-vfio-pci-Fail-initfn-on-DMA-mapping-errors.patch new file mode 100644 index 0000000..b049362 --- /dev/null +++ b/SOURCES/kvm-vfio-pci-Fail-initfn-on-DMA-mapping-errors.patch @@ -0,0 +1,139 @@ +From 00636d4945615f869926ec05df55680dfb452a01 Mon Sep 17 00:00:00 2001 +From: Alex Williamson +Date: Wed, 22 Jan 2014 20:52:52 -0500 +Subject: [PATCH 1/6] vfio-pci: Fail initfn on DMA mapping errors + +Message-id: <20140122205231.4223.40719.stgit@bling.home> +Patchwork-id: 56900 +O-Subject: [RHEL-7 qemu-kvm PATCH 1/1] vfio-pci: Fail initfn on DMA mapping errors +Bugzilla: 1044815 +RH-Acked-by: Bandan Das +RH-Acked-by: Laszlo Ersek +RH-Acked-by: Markus Armbruster + +Bugzilla: 1044815 +Upstream: 87ca1f77b1c406137fe36ab73b2dc91fb75f8d0a (tag from pull request) + +The vfio-pci initfn will currently succeed even if DMA mappings fail. +A typical reason for failure is if the user does not have sufficient +privilege to lock all the memory for the guest. In this case, the +device gets attached, but can only access a portion of guest memory +and is extremely unlikely to work. + +DMA mappings are done via a MemoryListener, which provides no direct +error return path. We therefore stuff the errno into our container +structure and check for error after registration completes. We can +also test for mapping errors during runtime, but our only option for +resolution at that point is to kill the guest with a hw_error. + +Signed-off-by: Alex Williamson +(cherry picked from commit 87ca1f77b1c406137fe36ab73b2dc91fb75f8d0a) +--- + hw/misc/vfio.c | 44 ++++++++++++++++++++++++++++++++++++++------ + 1 file changed, 38 insertions(+), 6 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + hw/misc/vfio.c | 44 ++++++++++++++++++++++++++++++++++++++------ + 1 file changed, 38 insertions(+), 6 deletions(-) + +diff --git a/hw/misc/vfio.c b/hw/misc/vfio.c +index bd30130..83f2b6a 100644 +--- a/hw/misc/vfio.c ++++ b/hw/misc/vfio.c +@@ -133,12 +133,18 @@ enum { + + struct VFIOGroup; + ++typedef struct VFIOType1 { ++ MemoryListener listener; ++ int error; ++ bool initialized; ++} VFIOType1; ++ + typedef struct VFIOContainer { + int fd; /* /dev/vfio/vfio, empowered by the attached groups */ + struct { + /* enable abstraction to support various iommu backends */ + union { +- MemoryListener listener; /* Used by type1 iommu */ ++ VFIOType1 type1; + }; + void (*release)(struct VFIOContainer *); + } iommu_data; +@@ -2102,7 +2108,7 @@ static void vfio_listener_region_add(MemoryListener *listener, + MemoryRegionSection *section) + { + VFIOContainer *container = container_of(listener, VFIOContainer, +- iommu_data.listener); ++ iommu_data.type1.listener); + hwaddr iova, end; + void *vaddr; + int ret; +@@ -2140,6 +2146,19 @@ static void vfio_listener_region_add(MemoryListener *listener, + error_report("vfio_dma_map(%p, 0x%"HWADDR_PRIx", " + "0x%"HWADDR_PRIx", %p) = %d (%m)", + container, iova, end - iova, vaddr, ret); ++ ++ /* ++ * On the initfn path, store the first error in the container so we ++ * can gracefully fail. Runtime, there's not much we can do other ++ * than throw a hardware error. ++ */ ++ if (!container->iommu_data.type1.initialized) { ++ if (!container->iommu_data.type1.error) { ++ container->iommu_data.type1.error = ret; ++ } ++ } else { ++ hw_error("vfio: DMA mapping failed, unable to continue\n"); ++ } + } + } + +@@ -2147,7 +2166,7 @@ static void vfio_listener_region_del(MemoryListener *listener, + MemoryRegionSection *section) + { + VFIOContainer *container = container_of(listener, VFIOContainer, +- iommu_data.listener); ++ iommu_data.type1.listener); + hwaddr iova, end; + int ret; + +@@ -2190,7 +2209,7 @@ static MemoryListener vfio_memory_listener = { + + static void vfio_listener_release(VFIOContainer *container) + { +- memory_listener_unregister(&container->iommu_data.listener); ++ memory_listener_unregister(&container->iommu_data.type1.listener); + } + + /* +@@ -3159,10 +3178,23 @@ static int vfio_connect_container(VFIOGroup *group) + return -errno; + } + +- container->iommu_data.listener = vfio_memory_listener; ++ container->iommu_data.type1.listener = vfio_memory_listener; + container->iommu_data.release = vfio_listener_release; + +- memory_listener_register(&container->iommu_data.listener, &address_space_memory); ++ memory_listener_register(&container->iommu_data.type1.listener, ++ &address_space_memory); ++ ++ if (container->iommu_data.type1.error) { ++ ret = container->iommu_data.type1.error; ++ vfio_listener_release(container); ++ g_free(container); ++ close(fd); ++ error_report("vfio: memory listener initialization failed for container\n"); ++ return ret; ++ } ++ ++ container->iommu_data.type1.initialized = true; ++ + } else { + error_report("vfio: No available IOMMU models"); + g_free(container); +-- +1.8.3.1 + diff --git a/SOURCES/kvm-vfio-pci-Fix-multifunction-on.patch b/SOURCES/kvm-vfio-pci-Fix-multifunction-on.patch new file mode 100644 index 0000000..e3d4171 --- /dev/null +++ b/SOURCES/kvm-vfio-pci-Fix-multifunction-on.patch @@ -0,0 +1,58 @@ +From 7197c8b9234f26922ce7c6f3d7784b2604bdaafd Mon Sep 17 00:00:00 2001 +From: Alex Williamson +Date: Thu, 21 Nov 2013 21:08:58 +0100 +Subject: [PATCH 10/14] vfio-pci: Fix multifunction=on + +RH-Author: Alex Williamson +Message-id: <20131121210817.12705.22782.stgit@bling.home> +Patchwork-id: 55844 +O-Subject: [RHEL7 qemu-kvm PATCH] vfio-pci: Fix multifunction=on +Bugzilla: 1029275 +RH-Acked-by: Amos Kong +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Bandan Das + +Bugzilla: https://bugzilla.redhat.com/show_bug.cgi?id=1029275 +Brew: https://brewweb.devel.redhat.com/taskinfo?taskID=6627360 +Upstream: 187d62327aca39afbb038d13d7cd6bf2d11640d3 + +When an assigned device is initialized it copies the device config +space into the emulated config space. Unfortunately multifunction is +setup prior to the device initfn and gets clobbered. We need to +restore it just like pci-assign does. + +Signed-off-by: Alex Williamson +Reviewed-by: Bandan Das +Message-id: 20131112185059.7262.33780.stgit@bling.home +Cc: qemu-stable@nongnu.org +Signed-off-by: Anthony Liguori +--- + hw/misc/vfio.c | 7 +++++++ + 1 file changed, 7 insertions(+) + +Signed-off-by: Miroslav Rezanina +--- + hw/misc/vfio.c | 7 +++++++ + 1 files changed, 7 insertions(+), 0 deletions(-) + +diff --git a/hw/misc/vfio.c b/hw/misc/vfio.c +index b7f213b..5a6925c 100644 +--- a/hw/misc/vfio.c ++++ b/hw/misc/vfio.c +@@ -3625,6 +3625,13 @@ static int vfio_initfn(PCIDevice *pdev) + vdev->emulated_config_bits[PCI_HEADER_TYPE] = + PCI_HEADER_TYPE_MULTI_FUNCTION; + ++ /* Restore or clear multifunction, this is always controlled by QEMU */ ++ if (vdev->pdev.cap_present & QEMU_PCI_CAP_MULTIFUNCTION) { ++ vdev->pdev.config[PCI_HEADER_TYPE] |= PCI_HEADER_TYPE_MULTI_FUNCTION; ++ } else { ++ vdev->pdev.config[PCI_HEADER_TYPE] &= ~PCI_HEADER_TYPE_MULTI_FUNCTION; ++ } ++ + /* + * Clear host resource mapping info. If we choose not to register a + * BAR, such as might be the case with the option ROM, we can get +-- +1.7.1 + diff --git a/SOURCES/kvm-vfio-pci-Release-all-MSI-X-vectors-when-disabled.patch b/SOURCES/kvm-vfio-pci-Release-all-MSI-X-vectors-when-disabled.patch new file mode 100644 index 0000000..8756cf4 --- /dev/null +++ b/SOURCES/kvm-vfio-pci-Release-all-MSI-X-vectors-when-disabled.patch @@ -0,0 +1,67 @@ +From 4e1c9f340ef7820e28c55ad286a631cb9e63967a Mon Sep 17 00:00:00 2001 +Message-Id: <4e1c9f340ef7820e28c55ad286a631cb9e63967a.1387276076.git.minovotn@redhat.com> +In-Reply-To: +References: +From: Alex Williamson +Date: Mon, 9 Dec 2013 17:48:46 +0100 +Subject: [PATCH 06/16] vfio-pci: Release all MSI-X vectors when disabled + +RH-Author: Alex Williamson +Message-id: <20131209174830.21963.40720.stgit@bling.home> +Patchwork-id: 56091 +O-Subject: [RHEL7 qemu-kvm PATCH] vfio-pci: Release all MSI-X vectors when disabled +Bugzilla: 1029743 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Bandan Das +RH-Acked-by: Amos Kong + +Bugzilla: https://bugzilla.redhat.com/show_bug.cgi?id=1029743 +Brew: https://brewweb.devel.redhat.com/taskinfo?taskID=6696250 +Upstream: 3e40ba0faf0822fa78336fe6cd9d677ea9b14f1b + +We were relying on msix_unset_vector_notifiers() to release all the +vectors when we disable MSI-X, but this only happens when MSI-X is +still enabled on the device. Perform further cleanup by releasing +any remaining vectors listed as in-use after this call. This caused +a leak of IRQ routes on hotplug depending on how the guest OS prepared +the device for removal. + +Signed-off-by: Alex Williamson +Cc: qemu-stable@nongnu.org +--- + hw/misc/vfio.c | 12 ++++++++++++ + 1 file changed, 12 insertions(+) + +Signed-off-by: Michal Novotny +--- + hw/misc/vfio.c | 12 ++++++++++++ + 1 file changed, 12 insertions(+) + +diff --git a/hw/misc/vfio.c b/hw/misc/vfio.c +index 5a6925c..250f96f 100644 +--- a/hw/misc/vfio.c ++++ b/hw/misc/vfio.c +@@ -886,8 +886,20 @@ static void vfio_disable_msi_common(VFIODevice *vdev) + + static void vfio_disable_msix(VFIODevice *vdev) + { ++ int i; ++ + msix_unset_vector_notifiers(&vdev->pdev); + ++ /* ++ * MSI-X will only release vectors if MSI-X is still enabled on the ++ * device, check through the rest and release it ourselves if necessary. ++ */ ++ for (i = 0; i < vdev->nr_vectors; i++) { ++ if (vdev->msi_vectors[i].use) { ++ vfio_msix_vector_release(&vdev->pdev, i); ++ } ++ } ++ + if (vdev->nr_vectors) { + vfio_disable_irqindex(vdev, VFIO_PCI_MSIX_IRQ_INDEX); + } +-- +1.7.11.7 + diff --git a/SOURCES/kvm-vhdx-Bounds-checking-for-block_size-and-logical_sect.patch b/SOURCES/kvm-vhdx-Bounds-checking-for-block_size-and-logical_sect.patch new file mode 100644 index 0000000..596cf45 --- /dev/null +++ b/SOURCES/kvm-vhdx-Bounds-checking-for-block_size-and-logical_sect.patch @@ -0,0 +1,64 @@ +From 95b523f48df55dfd60229d2573385828a884aa7c Mon Sep 17 00:00:00 2001 +From: Jeff Cody +Date: Tue, 25 Mar 2014 14:23:25 +0100 +Subject: [PATCH 18/49] vhdx: Bounds checking for block_size and logical_sector_size (CVE-2014-0148) + +RH-Author: Kevin Wolf +Message-id: <1395753835-7591-19-git-send-email-kwolf@redhat.com> +Patchwork-id: n/a +O-Subject: [virt-devel] [EMBARGOED RHEL-7.0 qemu-kvm PATCH 18/48] vhdx: Bounds checking for block_size and logical_sector_size (CVE-2014-0148) +Bugzilla: 1079346 +RH-Acked-by: Jeff Cody +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Paolo Bonzini + +From: Jeff Cody + +Bugzilla: https://bugzilla.redhat.com/show_bug.cgi?id=1079346 +Upstream status: Embargoed + +Other variables (e.g. sectors_per_block) are calculated using these +variables, and if not range-checked illegal values could be obtained +causing infinite loops and other potential issues when calculating +BAT entries. + +The 1.00 VHDX spec requires BlockSize to be min 1MB, max 256MB. +LogicalSectorSize is required to be either 512 or 4096 bytes. + +Reported-by: Kevin Wolf +Signed-off-by: Jeff Cody +Signed-off-by: Kevin Wolf +--- + block/vhdx.c | 12 ++++++++++-- + 1 files changed, 10 insertions(+), 2 deletions(-) + +diff --git a/block/vhdx.c b/block/vhdx.c +index 1995778..66a25c9 100644 +--- a/block/vhdx.c ++++ b/block/vhdx.c +@@ -785,12 +785,20 @@ static int vhdx_parse_metadata(BlockDriverState *bs, BDRVVHDXState *s) + le32_to_cpus(&s->logical_sector_size); + le32_to_cpus(&s->physical_sector_size); + +- if (s->logical_sector_size == 0 || s->params.block_size == 0) { ++ if (s->params.block_size < VHDX_BLOCK_SIZE_MIN || ++ s->params.block_size > VHDX_BLOCK_SIZE_MAX) { + ret = -EINVAL; + goto exit; + } + +- /* both block_size and sector_size are guaranteed powers of 2 */ ++ /* only 2 supported sector sizes */ ++ if (s->logical_sector_size != 512 && s->logical_sector_size != 4096) { ++ ret = -EINVAL; ++ goto exit; ++ } ++ ++ /* Both block_size and sector_size are guaranteed powers of 2, below. ++ Due to range checks above, s->sectors_per_block can never be < 256 */ + s->sectors_per_block = s->params.block_size / s->logical_sector_size; + s->chunk_ratio = (VHDX_MAX_SECTORS_PER_BLOCK) * + (uint64_t)s->logical_sector_size / +-- +1.7.1 + diff --git a/SOURCES/kvm-virtio-balloon-switch-exit-callback-to-VirtioDeviceC.patch b/SOURCES/kvm-virtio-balloon-switch-exit-callback-to-VirtioDeviceC.patch new file mode 100644 index 0000000..b21da97 --- /dev/null +++ b/SOURCES/kvm-virtio-balloon-switch-exit-callback-to-VirtioDeviceC.patch @@ -0,0 +1,72 @@ +From 9813363c031fd56a536dfafd64dcc9bc430f9bb1 Mon Sep 17 00:00:00 2001 +From: Markus Armbruster +Date: Thu, 23 Jan 2014 14:03:38 +0100 +Subject: [PATCH 11/14] virtio-balloon: switch exit callback to VirtioDeviceClass + +RH-Author: Markus Armbruster +Message-id: <1390485820-7585-9-git-send-email-armbru@redhat.com> +Patchwork-id: 56930 +O-Subject: [PATCH 7.0 qemu-kvm 08/10] virtio-balloon: switch exit callback to VirtioDeviceClass +Bugzilla: 983344 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Marcel Apfelbaum +RH-Acked-by: Michael S. Tsirkin + +From: Paolo Bonzini + +This ensures hot-unplug is handled properly by the proxy, and avoids +leaking bus_name which is freed by virtio_device_exit. + +Cc: qemu-stable@nongnu.org +Acked-by: Andreas Faerber +Signed-off-by: Paolo Bonzini +(cherry picked from commit baa61b9870dd7e0bb07e0ae61c6ec805db13f699) +Signed-off-by: Markus Armbruster +--- + hw/virtio/virtio-balloon.c | 10 ++++------ + 1 file changed, 4 insertions(+), 6 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + hw/virtio/virtio-balloon.c | 10 ++++------ + 1 files changed, 4 insertions(+), 6 deletions(-) + +diff --git a/hw/virtio/virtio-balloon.c b/hw/virtio/virtio-balloon.c +index 85661f6..76c607f 100644 +--- a/hw/virtio/virtio-balloon.c ++++ b/hw/virtio/virtio-balloon.c +@@ -369,16 +369,14 @@ static int virtio_balloon_device_init(VirtIODevice *vdev) + return 0; + } + +-static int virtio_balloon_device_exit(DeviceState *qdev) ++static void virtio_balloon_device_exit(VirtIODevice *vdev) + { +- VirtIOBalloon *s = VIRTIO_BALLOON(qdev); +- VirtIODevice *vdev = VIRTIO_DEVICE(qdev); ++ VirtIOBalloon *s = VIRTIO_BALLOON(vdev); + + balloon_stats_destroy_timer(s); + qemu_remove_balloon_handler(s); +- unregister_savevm(qdev, "virtio-balloon", s); ++ unregister_savevm(DEVICE(vdev), "virtio-balloon", s); + virtio_cleanup(vdev); +- return 0; + } + + static Property virtio_balloon_properties[] = { +@@ -389,10 +387,10 @@ static void virtio_balloon_class_init(ObjectClass *klass, void *data) + { + DeviceClass *dc = DEVICE_CLASS(klass); + VirtioDeviceClass *vdc = VIRTIO_DEVICE_CLASS(klass); +- dc->exit = virtio_balloon_device_exit; + dc->props = virtio_balloon_properties; + set_bit(DEVICE_CATEGORY_MISC, dc->categories); + vdc->init = virtio_balloon_device_init; ++ vdc->exit = virtio_balloon_device_exit; + vdc->get_config = virtio_balloon_get_config; + vdc->set_config = virtio_balloon_set_config; + vdc->get_features = virtio_balloon_get_features; +-- +1.7.1 + diff --git a/SOURCES/kvm-virtio-blk-switch-exit-callback-to-VirtioDeviceClass.patch b/SOURCES/kvm-virtio-blk-switch-exit-callback-to-VirtioDeviceClass.patch new file mode 100644 index 0000000..6e7963d --- /dev/null +++ b/SOURCES/kvm-virtio-blk-switch-exit-callback-to-VirtioDeviceClass.patch @@ -0,0 +1,76 @@ +From f9630bb1a1267c9d3f8b2d3e70bfa9a05bd0cf07 Mon Sep 17 00:00:00 2001 +From: Markus Armbruster +Date: Thu, 23 Jan 2014 14:03:34 +0100 +Subject: [PATCH 07/14] virtio-blk: switch exit callback to VirtioDeviceClass + +RH-Author: Markus Armbruster +Message-id: <1390485820-7585-5-git-send-email-armbru@redhat.com> +Patchwork-id: 56922 +O-Subject: [PATCH 7.0 qemu-kvm 04/10] virtio-blk: switch exit callback to VirtioDeviceClass +Bugzilla: 983344 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Marcel Apfelbaum +RH-Acked-by: Michael S. Tsirkin + +From: Paolo Bonzini + +This ensures hot-unplug is handled properly by the proxy, and avoids +leaking bus_name which is freed by virtio_device_exit. + +Cc: qemu-stable@nongnu.org +Acked-by: Andreas Faerber +Signed-off-by: Paolo Bonzini +(cherry picked from commit 40dfc16f5fe0afb66f9436718781264dfadb6c61) +Signed-off-by: Markus Armbruster +--- + hw/block/virtio-blk.c | 10 ++++------ + 1 file changed, 4 insertions(+), 6 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + hw/block/virtio-blk.c | 10 ++++------ + 1 files changed, 4 insertions(+), 6 deletions(-) + +diff --git a/hw/block/virtio-blk.c b/hw/block/virtio-blk.c +index 49a23c3..aa37cc9 100644 +--- a/hw/block/virtio-blk.c ++++ b/hw/block/virtio-blk.c +@@ -729,20 +729,18 @@ static int virtio_blk_device_init(VirtIODevice *vdev) + return 0; + } + +-static int virtio_blk_device_exit(DeviceState *dev) ++static void virtio_blk_device_exit(VirtIODevice *vdev) + { +- VirtIODevice *vdev = VIRTIO_DEVICE(dev); +- VirtIOBlock *s = VIRTIO_BLK(dev); ++ VirtIOBlock *s = VIRTIO_BLK(vdev); + #ifdef CONFIG_VIRTIO_BLK_DATA_PLANE + remove_migration_state_change_notifier(&s->migration_state_notifier); + virtio_blk_data_plane_destroy(s->dataplane); + s->dataplane = NULL; + #endif + qemu_del_vm_change_state_handler(s->change); +- unregister_savevm(dev, "virtio-blk", s); ++ unregister_savevm(DEVICE(vdev), "virtio-blk", s); + blockdev_mark_auto_del(s->bs); + virtio_cleanup(vdev); +- return 0; + } + + static Property virtio_blk_properties[] = { +@@ -754,10 +752,10 @@ static void virtio_blk_class_init(ObjectClass *klass, void *data) + { + DeviceClass *dc = DEVICE_CLASS(klass); + VirtioDeviceClass *vdc = VIRTIO_DEVICE_CLASS(klass); +- dc->exit = virtio_blk_device_exit; + dc->props = virtio_blk_properties; + set_bit(DEVICE_CATEGORY_STORAGE, dc->categories); + vdc->init = virtio_blk_device_init; ++ vdc->exit = virtio_blk_device_exit; + vdc->get_config = virtio_blk_update_config; + vdc->set_config = virtio_blk_set_config; + vdc->get_features = virtio_blk_get_features; +-- +1.7.1 + diff --git a/SOURCES/kvm-virtio-bus-cleanup-plug-unplug-interface.patch b/SOURCES/kvm-virtio-bus-cleanup-plug-unplug-interface.patch new file mode 100644 index 0000000..ad7bf81 --- /dev/null +++ b/SOURCES/kvm-virtio-bus-cleanup-plug-unplug-interface.patch @@ -0,0 +1,178 @@ +From 39ea2d15631b21f962924e88b62e3586e531ac66 Mon Sep 17 00:00:00 2001 +From: Markus Armbruster +Date: Thu, 23 Jan 2014 14:03:33 +0100 +Subject: [PATCH 06/14] virtio-bus: cleanup plug/unplug interface + +RH-Author: Markus Armbruster +Message-id: <1390485820-7585-4-git-send-email-armbru@redhat.com> +Patchwork-id: 56924 +O-Subject: [PATCH 7.0 qemu-kvm 03/10] virtio-bus: cleanup plug/unplug interface +Bugzilla: 983344 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Marcel Apfelbaum +RH-Acked-by: Michael S. Tsirkin + +From: Paolo Bonzini + +Right now we have these pairs: + +- virtio_bus_plug_device/virtio_bus_destroy_device. The first + takes a VirtIODevice, the second takes a VirtioBusState + +- device_plugged/device_unplug callbacks in the VirtioBusClass + (here it's just the naming that is inconsistent) + +- virtio_bus_destroy_device is not called by anyone (and since + it calls qdev_free, it would be called by the proxies---but + then the callback is useless since the proxies can do whatever + they want before calling virtio_bus_destroy_device) + +And there is a k->init but no k->exit, hence virtio_device_exit is +overwritten by subclasses (except virtio-9p). This cleans it up by: + +- renaming the device_unplug callback to device_unplugged + +- renaming virtio_bus_plug_device to virtio_bus_device_plugged, + matching the callback name + +- renaming virtio_bus_destroy_device to virtio_bus_device_unplugged, + removing the qdev_free, making it take a VirtIODevice and calling it + from virtio_device_exit + +- adding a k->exit callback + +virtio_device_exit is still overwritten, the next patches will fix that. + +Cc: qemu-stable@nongnu.org +Acked-by: Andreas Faerber +Signed-off-by: Paolo Bonzini +(cherry picked from commit 5e96f5d2f8d2696ef7d2d8d7282c18fa6023470b) + +Conflicts: + include/hw/virtio/virtio-bus.h + +Trivially conflicts because we lack commit 6ce69d1 "virtio: Support +transports which can specify the vring alignment". +Signed-off-by: Markus Armbruster +--- + hw/virtio/virtio-bus.c | 19 +++++++++---------- + hw/virtio/virtio.c | 7 ++++++- + include/hw/virtio/virtio-bus.h | 6 +++--- + include/hw/virtio/virtio.h | 1 + + 4 files changed, 19 insertions(+), 14 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + hw/virtio/virtio-bus.c | 19 +++++++++---------- + hw/virtio/virtio.c | 7 ++++++- + include/hw/virtio/virtio-bus.h | 6 +++--- + include/hw/virtio/virtio.h | 1 + + 4 files changed, 19 insertions(+), 14 deletions(-) + +diff --git a/hw/virtio/virtio-bus.c b/hw/virtio/virtio-bus.c +index 17dd06e..eb77019 100644 +--- a/hw/virtio/virtio-bus.c ++++ b/hw/virtio/virtio-bus.c +@@ -37,8 +37,8 @@ do { printf("virtio_bus: " fmt , ## __VA_ARGS__); } while (0) + #define DPRINTF(fmt, ...) do { } while (0) + #endif + +-/* Plug the VirtIODevice */ +-int virtio_bus_plug_device(VirtIODevice *vdev) ++/* A VirtIODevice is being plugged */ ++int virtio_bus_device_plugged(VirtIODevice *vdev) + { + DeviceState *qdev = DEVICE(vdev); + BusState *qbus = BUS(qdev_get_parent_bus(qdev)); +@@ -64,20 +64,19 @@ void virtio_bus_reset(VirtioBusState *bus) + } + } + +-/* Destroy the VirtIODevice */ +-void virtio_bus_destroy_device(VirtioBusState *bus) ++/* A VirtIODevice is being unplugged */ ++void virtio_bus_device_unplugged(VirtIODevice *vdev) + { +- BusState *qbus = BUS(bus); +- VirtioBusClass *klass = VIRTIO_BUS_GET_CLASS(bus); +- VirtIODevice *vdev = virtio_bus_get_device(bus); ++ DeviceState *qdev = DEVICE(vdev); ++ BusState *qbus = BUS(qdev_get_parent_bus(qdev)); ++ VirtioBusClass *klass = VIRTIO_BUS_GET_CLASS(qbus); + + DPRINTF("%s: remove device.\n", qbus->name); + + if (vdev != NULL) { +- if (klass->device_unplug != NULL) { +- klass->device_unplug(qbus->parent); ++ if (klass->device_unplugged != NULL) { ++ klass->device_unplugged(qbus->parent); + } +- object_unparent(OBJECT(vdev)); + } + } + +diff --git a/hw/virtio/virtio.c b/hw/virtio/virtio.c +index a5251cb..b5bb0b6 100644 +--- a/hw/virtio/virtio.c ++++ b/hw/virtio/virtio.c +@@ -1118,14 +1118,19 @@ static int virtio_device_init(DeviceState *qdev) + if (k->init(vdev) < 0) { + return -1; + } +- virtio_bus_plug_device(vdev); ++ virtio_bus_device_plugged(vdev); + return 0; + } + + static int virtio_device_exit(DeviceState *qdev) + { + VirtIODevice *vdev = VIRTIO_DEVICE(qdev); ++ VirtioDeviceClass *k = VIRTIO_DEVICE_GET_CLASS(qdev); + ++ virtio_bus_device_unplugged(vdev); ++ if (k->exit) { ++ k->exit(vdev); ++ } + if (vdev->bus_name) { + g_free(vdev->bus_name); + vdev->bus_name = NULL; +diff --git a/include/hw/virtio/virtio-bus.h b/include/hw/virtio/virtio-bus.h +index 105ca6d..228c9d7 100644 +--- a/include/hw/virtio/virtio-bus.h ++++ b/include/hw/virtio/virtio-bus.h +@@ -61,16 +61,16 @@ typedef struct VirtioBusClass { + * transport independent exit function. + * This is called by virtio-bus just before the device is unplugged. + */ +- void (*device_unplug)(DeviceState *d); ++ void (*device_unplugged)(DeviceState *d); + } VirtioBusClass; + + struct VirtioBusState { + BusState parent_obj; + }; + +-int virtio_bus_plug_device(VirtIODevice *vdev); ++int virtio_bus_device_plugged(VirtIODevice *vdev); + void virtio_bus_reset(VirtioBusState *bus); +-void virtio_bus_destroy_device(VirtioBusState *bus); ++void virtio_bus_device_unplugged(VirtIODevice *bus); + /* Get the device id of the plugged device. */ + uint16_t virtio_bus_get_vdev_id(VirtioBusState *bus); + /* Get the config_len field of the plugged device. */ +diff --git a/include/hw/virtio/virtio.h b/include/hw/virtio/virtio.h +index f2aa6a3..cd886c3 100644 +--- a/include/hw/virtio/virtio.h ++++ b/include/hw/virtio/virtio.h +@@ -125,6 +125,7 @@ typedef struct VirtioDeviceClass { + /* This is what a VirtioDevice must implement */ + DeviceClass parent; + int (*init)(VirtIODevice *vdev); ++ void (*exit)(VirtIODevice *vdev); + uint32_t (*get_features)(VirtIODevice *vdev, uint32_t requested_features); + uint32_t (*bad_features)(VirtIODevice *vdev); + void (*set_features)(VirtIODevice *vdev, uint32_t val); +-- +1.7.1 + diff --git a/SOURCES/kvm-virtio-bus-remove-vdev-field.patch b/SOURCES/kvm-virtio-bus-remove-vdev-field.patch new file mode 100644 index 0000000..a665c22 --- /dev/null +++ b/SOURCES/kvm-virtio-bus-remove-vdev-field.patch @@ -0,0 +1,256 @@ +From 9164d579671d6147799c92ee35b9efc1760155cb Mon Sep 17 00:00:00 2001 +From: Markus Armbruster +Date: Thu, 23 Jan 2014 14:03:31 +0100 +Subject: [PATCH 04/14] virtio-bus: remove vdev field + +RH-Author: Markus Armbruster +Message-id: <1390485820-7585-2-git-send-email-armbru@redhat.com> +Patchwork-id: 56927 +O-Subject: [PATCH 7.0 qemu-kvm 01/10] virtio-bus: remove vdev field +Bugzilla: 983344 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Marcel Apfelbaum +RH-Acked-by: Michael S. Tsirkin + +From: Paolo Bonzini + +The vdev field is complicated to synchronize. Just access the +BusState's list of children. + +Cc: qemu-stable@nongnu.org +Acked-by: Andreas Faerber +Signed-off-by: Paolo Bonzini +(cherry picked from commit 06d3dff0723c712a4b109ced4243edf49ef850af) + +Conflicts: + hw/virtio/virtio-mmio.c + +We don't have hw/virtio/virtio-mmio.c. + +Semantic conflict in hw/pci/pci-hotplug, because we got commit 1e3043a +via upstream 1.5.3, but upstream master has not. +Signed-off-by: Markus Armbruster +--- + hw/pci/pci-hotplug.c | 2 +- + hw/virtio/virtio-bus.c | 65 +++++++++++++++++++++++++----------------- + hw/virtio/virtio-pci.c | 2 +- + include/hw/virtio/virtio-bus.h | 16 ++++++++--- + 4 files changed, 53 insertions(+), 32 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + hw/pci/pci-hotplug.c | 2 +- + hw/virtio/virtio-bus.c | 65 ++++++++++++++++++++++++---------------- + hw/virtio/virtio-pci.c | 2 +- + include/hw/virtio/virtio-bus.h | 16 +++++++-- + 4 files changed, 53 insertions(+), 32 deletions(-) + +diff --git a/hw/pci/pci-hotplug.c b/hw/pci/pci-hotplug.c +index 667e40c..eae28d4 100644 +--- a/hw/pci/pci-hotplug.c ++++ b/hw/pci/pci-hotplug.c +@@ -96,7 +96,7 @@ static int scsi_hot_add(Monitor *mon, DeviceState *adapter, + return -1; + } + virtio_proxy = VIRTIO_PCI(adapter); +- adapter = DEVICE(virtio_proxy->bus.vdev); ++ adapter = DEVICE(virtio_bus_get_device(&virtio_proxy->bus)); + scsibus = (SCSIBus *) + object_dynamic_cast(OBJECT(QLIST_FIRST(&adapter->child_bus)), + TYPE_SCSI_BUS); +diff --git a/hw/virtio/virtio-bus.c b/hw/virtio/virtio-bus.c +index e6b103c..17dd06e 100644 +--- a/hw/virtio/virtio-bus.c ++++ b/hw/virtio/virtio-bus.c +@@ -46,8 +46,6 @@ int virtio_bus_plug_device(VirtIODevice *vdev) + VirtioBusClass *klass = VIRTIO_BUS_GET_CLASS(bus); + DPRINTF("%s: plug device.\n", qbus->name); + +- bus->vdev = vdev; +- + if (klass->device_plugged != NULL) { + klass->device_plugged(qbus->parent); + } +@@ -58,9 +56,11 @@ int virtio_bus_plug_device(VirtIODevice *vdev) + /* Reset the virtio_bus */ + void virtio_bus_reset(VirtioBusState *bus) + { ++ VirtIODevice *vdev = virtio_bus_get_device(bus); ++ + DPRINTF("%s: reset device.\n", qbus->name); +- if (bus->vdev != NULL) { +- virtio_reset(bus->vdev); ++ if (vdev != NULL) { ++ virtio_reset(vdev); + } + } + +@@ -69,62 +69,71 @@ void virtio_bus_destroy_device(VirtioBusState *bus) + { + BusState *qbus = BUS(bus); + VirtioBusClass *klass = VIRTIO_BUS_GET_CLASS(bus); ++ VirtIODevice *vdev = virtio_bus_get_device(bus); ++ + DPRINTF("%s: remove device.\n", qbus->name); + +- if (bus->vdev != NULL) { ++ if (vdev != NULL) { + if (klass->device_unplug != NULL) { + klass->device_unplug(qbus->parent); + } +- object_unparent(OBJECT(bus->vdev)); +- bus->vdev = NULL; ++ object_unparent(OBJECT(vdev)); + } + } + + /* Get the device id of the plugged device. */ + uint16_t virtio_bus_get_vdev_id(VirtioBusState *bus) + { +- assert(bus->vdev != NULL); +- return bus->vdev->device_id; ++ VirtIODevice *vdev = virtio_bus_get_device(bus); ++ assert(vdev != NULL); ++ return vdev->device_id; + } + + /* Get the config_len field of the plugged device. */ + size_t virtio_bus_get_vdev_config_len(VirtioBusState *bus) + { +- assert(bus->vdev != NULL); +- return bus->vdev->config_len; ++ VirtIODevice *vdev = virtio_bus_get_device(bus); ++ assert(vdev != NULL); ++ return vdev->config_len; + } + + /* Get the features of the plugged device. */ + uint32_t virtio_bus_get_vdev_features(VirtioBusState *bus, + uint32_t requested_features) + { ++ VirtIODevice *vdev = virtio_bus_get_device(bus); + VirtioDeviceClass *k; +- assert(bus->vdev != NULL); +- k = VIRTIO_DEVICE_GET_CLASS(bus->vdev); ++ ++ assert(vdev != NULL); ++ k = VIRTIO_DEVICE_GET_CLASS(vdev); + assert(k->get_features != NULL); +- return k->get_features(bus->vdev, requested_features); ++ return k->get_features(vdev, requested_features); + } + + /* Set the features of the plugged device. */ + void virtio_bus_set_vdev_features(VirtioBusState *bus, + uint32_t requested_features) + { ++ VirtIODevice *vdev = virtio_bus_get_device(bus); + VirtioDeviceClass *k; +- assert(bus->vdev != NULL); +- k = VIRTIO_DEVICE_GET_CLASS(bus->vdev); ++ ++ assert(vdev != NULL); ++ k = VIRTIO_DEVICE_GET_CLASS(vdev); + if (k->set_features != NULL) { +- k->set_features(bus->vdev, requested_features); ++ k->set_features(vdev, requested_features); + } + } + + /* Get bad features of the plugged device. */ + uint32_t virtio_bus_get_vdev_bad_features(VirtioBusState *bus) + { ++ VirtIODevice *vdev = virtio_bus_get_device(bus); + VirtioDeviceClass *k; +- assert(bus->vdev != NULL); +- k = VIRTIO_DEVICE_GET_CLASS(bus->vdev); ++ ++ assert(vdev != NULL); ++ k = VIRTIO_DEVICE_GET_CLASS(vdev); + if (k->bad_features != NULL) { +- return k->bad_features(bus->vdev); ++ return k->bad_features(vdev); + } else { + return 0; + } +@@ -133,22 +142,26 @@ uint32_t virtio_bus_get_vdev_bad_features(VirtioBusState *bus) + /* Get config of the plugged device. */ + void virtio_bus_get_vdev_config(VirtioBusState *bus, uint8_t *config) + { ++ VirtIODevice *vdev = virtio_bus_get_device(bus); + VirtioDeviceClass *k; +- assert(bus->vdev != NULL); +- k = VIRTIO_DEVICE_GET_CLASS(bus->vdev); ++ ++ assert(vdev != NULL); ++ k = VIRTIO_DEVICE_GET_CLASS(vdev); + if (k->get_config != NULL) { +- k->get_config(bus->vdev, config); ++ k->get_config(vdev, config); + } + } + + /* Set config of the plugged device. */ + void virtio_bus_set_vdev_config(VirtioBusState *bus, uint8_t *config) + { ++ VirtIODevice *vdev = virtio_bus_get_device(bus); + VirtioDeviceClass *k; +- assert(bus->vdev != NULL); +- k = VIRTIO_DEVICE_GET_CLASS(bus->vdev); ++ ++ assert(vdev != NULL); ++ k = VIRTIO_DEVICE_GET_CLASS(vdev); + if (k->set_config != NULL) { +- k->set_config(bus->vdev, config); ++ k->set_config(vdev, config); + } + } + +diff --git a/hw/virtio/virtio-pci.c b/hw/virtio/virtio-pci.c +index 6f5c434..1287e59 100644 +--- a/hw/virtio/virtio-pci.c ++++ b/hw/virtio/virtio-pci.c +@@ -948,7 +948,7 @@ static void virtio_pci_device_plugged(DeviceState *d) + uint8_t *config; + uint32_t size; + +- proxy->vdev = bus->vdev; ++ proxy->vdev = virtio_bus_get_device(bus); + + config = proxy->pci_dev.config; + if (proxy->class_code) { +diff --git a/include/hw/virtio/virtio-bus.h b/include/hw/virtio/virtio-bus.h +index 9ed60f9..105ca6d 100644 +--- a/include/hw/virtio/virtio-bus.h ++++ b/include/hw/virtio/virtio-bus.h +@@ -66,10 +66,6 @@ typedef struct VirtioBusClass { + + struct VirtioBusState { + BusState parent_obj; +- /* +- * Only one VirtIODevice can be plugged on the bus. +- */ +- VirtIODevice *vdev; + }; + + int virtio_bus_plug_device(VirtIODevice *vdev); +@@ -92,4 +88,16 @@ void virtio_bus_get_vdev_config(VirtioBusState *bus, uint8_t *config); + /* Set config of the plugged device. */ + void virtio_bus_set_vdev_config(VirtioBusState *bus, uint8_t *config); + ++static inline VirtIODevice *virtio_bus_get_device(VirtioBusState *bus) ++{ ++ BusState *qbus = &bus->parent_obj; ++ BusChild *kid = QTAILQ_FIRST(&qbus->children); ++ DeviceState *qdev = kid ? kid->child : NULL; ++ ++ /* This is used on the data path, the cast is guaranteed ++ * to succeed by the qdev machinery. ++ */ ++ return (VirtIODevice *)qdev; ++} ++ + #endif /* VIRTIO_BUS_H */ +-- +1.7.1 + diff --git a/SOURCES/kvm-virtio-net-add-feature-bit-for-any-header-s-g.patch b/SOURCES/kvm-virtio-net-add-feature-bit-for-any-header-s-g.patch new file mode 100644 index 0000000..ee97b67 --- /dev/null +++ b/SOURCES/kvm-virtio-net-add-feature-bit-for-any-header-s-g.patch @@ -0,0 +1,128 @@ +From 01ebac2f7d54e80a690c855680d35574d118b072 Mon Sep 17 00:00:00 2001 +From: Michael S. Tsirkin +Date: Wed, 12 Mar 2014 06:52:43 +0100 +Subject: [PATCH 06/16] virtio-net: add feature bit for any header s/g + +Message-id: <1394169006-8402-1-git-send-email-mst@redhat.com> +Patchwork-id: 58046 +O-Subject: [PATCH qemu-kvm RHEL7.0] virtio-net: add feature bit for any header s/g +Bugzilla: 990989 +RH-Acked-by: Xiao Wang +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Laszlo Ersek + +Old qemu versions required that 1st s/g entry is the header. + +Since QEMU 1.5, patchset titled "virtio-net: iovec handling cleanup" +removed this limitation but a feature bit is needed so guests know it's +safe to lay out header differently. + +This patch applies on top and adds such a feature bit to QEMU. +It is set by default for virtio-net. +virtio net header inline with the data is beneficial +for latency and small packet bandwidth - guest driver +code utilizing this feature has been acked but missed 3.11 +by a narrow margin, it's pending for 3.12. + +This feature bit is cleared by default when compatibility with old +machine types is requested. + +Other performance-sensitive devices (blk and scsi) +don't yet support arbitrary s/g layouts, so +we only set this bit for virtio-net for now. +There are plans to allow arbitrary layouts there, but +no code has been posted yet. + +Cc: Rusty Russell +Reviewed-by: Laszlo Ersek +Signed-off-by: Michael S. Tsirkin +(cherry picked from commit 488f069bd1f3aeb6ee748acb02b7581831bcb3f8) + +Brew build: http://brewweb.devel.redhat.com/brew/taskinfo?taskID=7155286 +Bugzilla: https://bugzilla.redhat.com/show_bug.cgi?id=990989 +Tested: on developer's box + +Conflicts: + include/hw/i386/pc.h +--- + +Oops, the patch got lost somehow. +I was sure our last rebase included it but no ... +Pls review ASAP and we'll discuss setting blocker for this one +separately. + +Impossible to fix in zstream since it would affect +migration. + + include/hw/i386/pc.h | 4 ++++ + include/hw/virtio/virtio-net.h | 1 + + include/hw/virtio/virtio.h | 2 ++ + hw/i386/pc_piix.c | 4 ++++ + 4 files changed, 11 insertions(+) + +Signed-off-by: Miroslav Rezanina +--- + hw/i386/pc_piix.c | 4 ++++ + include/hw/i386/pc.h | 4 ++++ + include/hw/virtio/virtio-net.h | 1 + + include/hw/virtio/virtio.h | 2 ++ + 4 files changed, 11 insertions(+), 0 deletions(-) + +diff --git a/hw/i386/pc_piix.c b/hw/i386/pc_piix.c +index 697f12f..98a5253 100644 +--- a/hw/i386/pc_piix.c ++++ b/hw/i386/pc_piix.c +@@ -904,6 +904,10 @@ static QEMUMachine pc_machine_rhel700 = { + .driver = TYPE_USB_DEVICE,\ + .property = "msos-desc",\ + .value = "no",\ ++ },{\ ++ .driver = "virtio-net-pci",\ ++ .property = "any_layout",\ ++ .value = "off",\ + } + + static void pc_compat_rhel650(QEMUMachineInitArgs *args) +diff --git a/include/hw/i386/pc.h b/include/hw/i386/pc.h +index f56e9ea..8a69347 100644 +--- a/include/hw/i386/pc.h ++++ b/include/hw/i386/pc.h +@@ -274,6 +274,10 @@ int e820_add_entry(uint64_t, uint64_t, uint32_t); + .driver = TYPE_X86_CPU,\ + .property = "pmu",\ + .value = "on",\ ++ },{\ ++ .driver = "virtio-net-pci",\ ++ .property = "any_layout",\ ++ .value = "off",\ + } + + #define PC_COMPAT_1_4 \ +diff --git a/include/hw/virtio/virtio-net.h b/include/hw/virtio/virtio-net.h +index beeead7..75723a8 100644 +--- a/include/hw/virtio/virtio-net.h ++++ b/include/hw/virtio/virtio-net.h +@@ -231,6 +231,7 @@ struct virtio_net_ctrl_mq { + + #define DEFINE_VIRTIO_NET_FEATURES(_state, _field) \ + DEFINE_VIRTIO_COMMON_FEATURES(_state, _field), \ ++ DEFINE_PROP_BIT("any_layout", _state, _field, VIRTIO_F_ANY_LAYOUT, true), \ + DEFINE_PROP_BIT("csum", _state, _field, VIRTIO_NET_F_CSUM, true), \ + DEFINE_PROP_BIT("guest_csum", _state, _field, VIRTIO_NET_F_GUEST_CSUM, true), \ + DEFINE_PROP_BIT("gso", _state, _field, VIRTIO_NET_F_GSO, true), \ +diff --git a/include/hw/virtio/virtio.h b/include/hw/virtio/virtio.h +index cd886c3..9e22865 100644 +--- a/include/hw/virtio/virtio.h ++++ b/include/hw/virtio/virtio.h +@@ -43,6 +43,8 @@ + /* We notify when the ring is completely used, even if the guest is suppressing + * callbacks */ + #define VIRTIO_F_NOTIFY_ON_EMPTY 24 ++/* Can the device handle any descriptor layout? */ ++#define VIRTIO_F_ANY_LAYOUT 27 + /* We support indirect buffer descriptors */ + #define VIRTIO_RING_F_INDIRECT_DESC 28 + /* The Guest publishes the used index for which it expects an interrupt +-- +1.7.1 + diff --git a/SOURCES/kvm-virtio-net-broken-RX-filtering-logic-fixed.patch b/SOURCES/kvm-virtio-net-broken-RX-filtering-logic-fixed.patch new file mode 100644 index 0000000..16ba2aa --- /dev/null +++ b/SOURCES/kvm-virtio-net-broken-RX-filtering-logic-fixed.patch @@ -0,0 +1,49 @@ +From d16828fb1034ceb05e3e690065aa1ddc2088d53c Mon Sep 17 00:00:00 2001 +From: Dmitry Fleytman +Date: Tue, 19 Nov 2013 13:18:27 +0100 +Subject: [PATCH 03/14] virtio-net: broken RX filtering logic fixed + +RH-Author: Dmitry Fleytman +Message-id: <1384867107-25295-1-git-send-email-dfleytma@redhat.com> +Patchwork-id: 55756 +O-Subject: [RHEL-7 qemu-kvm PATCH] virtio-net: broken RX filtering logic fixed +Bugzilla: 1029370 +RH-Acked-by: Yan Vugenfirer +RH-Acked-by: Vlad Yasevich +RH-Acked-by: Amos Kong + +BZ: https://bugzilla.redhat.com/show_bug.cgi?id=1029370 +Brew: https://brewweb.devel.redhat.com/taskinfo?taskID=6606668 +Upstream-status: cc386e96727442f5b67052d4e0a602f6f652ffe6 + +Upon processing of VIRTIO_NET_CTRL_MAC_TABLE_SET command +multicast list overwrites unicast list in mac_table. +This leads to broken logic for both unicast and multicast RX filtering. + +Signed-off-by: Dmitry Fleytman +--- + hw/net/virtio-net.c | 3 ++- + 1 file changed, 2 insertions(+), 1 deletion(-) + +Signed-off-by: Miroslav Rezanina +--- + hw/net/virtio-net.c | 3 ++- + 1 files changed, 2 insertions(+), 1 deletions(-) + +diff --git a/hw/net/virtio-net.c b/hw/net/virtio-net.c +index f889841..3bc1eed 100644 +--- a/hw/net/virtio-net.c ++++ b/hw/net/virtio-net.c +@@ -595,7 +595,8 @@ static int virtio_net_handle_mac(VirtIONet *n, uint8_t cmd, + } + + if (n->mac_table.in_use + mac_data.entries <= MAC_TABLE_ENTRIES) { +- s = iov_to_buf(iov, iov_cnt, 0, n->mac_table.macs, ++ s = iov_to_buf(iov, iov_cnt, 0, ++ &n->mac_table.macs[n->mac_table.in_use * ETH_ALEN], + mac_data.entries * ETH_ALEN); + if (s != mac_data.entries * ETH_ALEN) { + goto error; +-- +1.7.1 + diff --git a/SOURCES/kvm-virtio-net-don-t-update-mac_table-in-error-state.patch b/SOURCES/kvm-virtio-net-don-t-update-mac_table-in-error-state.patch new file mode 100644 index 0000000..ce94a81 --- /dev/null +++ b/SOURCES/kvm-virtio-net-don-t-update-mac_table-in-error-state.patch @@ -0,0 +1,130 @@ +From 4b542df026dfcc30802d300e56a99799f410ef50 Mon Sep 17 00:00:00 2001 +From: Amos Kong +Date: Mon, 6 Jan 2014 05:29:20 +0100 +Subject: [PATCH 7/8] virtio-net: don't update mac_table in error state + +RH-Author: Amos Kong +Message-id: <1388986160-19461-1-git-send-email-akong@redhat.com> +Patchwork-id: 56495 +O-Subject: [RHEL-7.0 qemu-kvm PATCH] virtio-net: don't update mac_table in error state +Bugzilla: 1048671 +RH-Acked-by: Xiao Wang +RH-Acked-by: Vlad Yasevich +RH-Acked-by: Stefan Hajnoczi + +Bugzilla: 1048671 +Brew: https://brewweb.devel.redhat.com/taskinfo?taskID=6805382 + +mac_table was always cleaned up first in handling +VIRTIO_NET_CTRL_MAC_TABLE_SET command, and we din't recover +mac_table content in error state, it's not correct. + +This patch makes all the changes in temporal variables, +only update the real mac_table if everything is ok. +We won't change mac_table in error state, so rxfilter +notification isn't needed. + +This patch also fixed same problame in + http://lists.nongnu.org/archive/html/qemu-devel/2013-11/msg01188.html + (not merge) + +I will send patch for virtio spec to clarifying this change. + +Signed-off-by: Amos Kong +Reviewed-by: Vlad Yasevich +Acked-by: Jason Wang +Signed-off-by: Stefan Hajnoczi +(cherry picked from commit cae2e5562cdaf3aafa1c4ec2d5f2b19af6c886dd) +--- + hw/net/virtio-net.c | 35 ++++++++++++++++++++--------------- + 1 files changed, 20 insertions(+), 15 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + hw/net/virtio-net.c | 35 ++++++++++++++++++++--------------- + 1 files changed, 20 insertions(+), 15 deletions(-) + +diff --git a/hw/net/virtio-net.c b/hw/net/virtio-net.c +index 915aa70..21b126f 100644 +--- a/hw/net/virtio-net.c ++++ b/hw/net/virtio-net.c +@@ -548,11 +548,11 @@ static int virtio_net_handle_mac(VirtIONet *n, uint8_t cmd, + return VIRTIO_NET_ERR; + } + +- n->mac_table.in_use = 0; +- n->mac_table.first_multi = 0; +- n->mac_table.uni_overflow = 0; +- n->mac_table.multi_overflow = 0; +- memset(n->mac_table.macs, 0, MAC_TABLE_ENTRIES * ETH_ALEN); ++ int in_use = 0; ++ int first_multi = 0; ++ uint8_t uni_overflow = 0; ++ uint8_t multi_overflow = 0; ++ uint8_t *macs = g_malloc0(MAC_TABLE_ENTRIES * ETH_ALEN); + + s = iov_to_buf(iov, iov_cnt, 0, &mac_data.entries, + sizeof(mac_data.entries)); +@@ -567,19 +567,19 @@ static int virtio_net_handle_mac(VirtIONet *n, uint8_t cmd, + } + + if (mac_data.entries <= MAC_TABLE_ENTRIES) { +- s = iov_to_buf(iov, iov_cnt, 0, n->mac_table.macs, ++ s = iov_to_buf(iov, iov_cnt, 0, macs, + mac_data.entries * ETH_ALEN); + if (s != mac_data.entries * ETH_ALEN) { + goto error; + } +- n->mac_table.in_use += mac_data.entries; ++ in_use += mac_data.entries; + } else { +- n->mac_table.uni_overflow = 1; ++ uni_overflow = 1; + } + + iov_discard_front(&iov, &iov_cnt, mac_data.entries * ETH_ALEN); + +- n->mac_table.first_multi = n->mac_table.in_use; ++ first_multi = in_use; + + s = iov_to_buf(iov, iov_cnt, 0, &mac_data.entries, + sizeof(mac_data.entries)); +@@ -594,24 +594,29 @@ static int virtio_net_handle_mac(VirtIONet *n, uint8_t cmd, + goto error; + } + +- if (n->mac_table.in_use + mac_data.entries <= MAC_TABLE_ENTRIES) { +- s = iov_to_buf(iov, iov_cnt, 0, +- &n->mac_table.macs[n->mac_table.in_use * ETH_ALEN], ++ if (in_use + mac_data.entries <= MAC_TABLE_ENTRIES) { ++ s = iov_to_buf(iov, iov_cnt, 0, &macs[in_use * ETH_ALEN], + mac_data.entries * ETH_ALEN); + if (s != mac_data.entries * ETH_ALEN) { + goto error; + } +- n->mac_table.in_use += mac_data.entries; ++ in_use += mac_data.entries; + } else { +- n->mac_table.multi_overflow = 1; ++ multi_overflow = 1; + } + ++ n->mac_table.in_use = in_use; ++ n->mac_table.first_multi = first_multi; ++ n->mac_table.uni_overflow = uni_overflow; ++ n->mac_table.multi_overflow = multi_overflow; ++ memcpy(n->mac_table.macs, macs, MAC_TABLE_ENTRIES * ETH_ALEN); ++ g_free(macs); + rxfilter_notify(nc); + + return VIRTIO_NET_OK; + + error: +- rxfilter_notify(nc); ++ g_free(macs); + return VIRTIO_NET_ERR; + } + +-- +1.7.1 + diff --git a/SOURCES/kvm-virtio-net-fix-guest-triggerable-buffer-overrun.patch b/SOURCES/kvm-virtio-net-fix-guest-triggerable-buffer-overrun.patch new file mode 100644 index 0000000..ddf2952 --- /dev/null +++ b/SOURCES/kvm-virtio-net-fix-guest-triggerable-buffer-overrun.patch @@ -0,0 +1,57 @@ +From 92504013c1489168e3514f3c7342c016156c6af3 Mon Sep 17 00:00:00 2001 +From: Michael S. Tsirkin +Date: Wed, 19 Mar 2014 17:21:02 +0200 +Subject: [PATCH] virtio-net: fix guest-triggerable buffer overrun + +RH-Author: Michael S. Tsirkin +Message-id: <1395242197-28749-1-git-send-email-mst@redhat.com> +O-Subject: [virt-devel][PATCH EMBARGOED qemu-kvm RHEL7.0] virtio-net: fix +Bugzilla: 1078308 +RH-Acked-by: Markus Armbruster +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Vlad Yasevich +RH-Acked-by: Dr. David Alan Gilbert + +When VM guest programs multicast addresses for +a virtio net card, it supplies a 32 bit +entries counter for the number of addresses. +These addresses are read into tail portion of +a fixed macs array which has size MAC_TABLE_ENTRIES, +at offset equal to in_use. + +To avoid overflow of this array by guest, qemu attempts +to test the size as follows: +- if (in_use + mac_data.entries <= MAC_TABLE_ENTRIES) { + +however, as mac_data.entries is uint32_t, this sum +can overflow, e.g. if in_use is 1 and mac_data.entries +is 0xffffffff then in_use + mac_data.entries will be 0. + +Qemu will then read guest supplied buffer into this +memory, overflowing buffer on heap. + +Signed-off-by: Michael S. Tsirkin + +Bugzilla: https://bugzilla.redhat.com/show_bug.cgi?id=1078308 +Upstream status: EMBARGOED RT 284849 +Brew build: http://brewweb.devel.redhat.com/brew/taskinfo?taskID=7225956 +--- + hw/net/virtio-net.c | 2 +- + 1 files changed, 1 insertions(+), 1 deletions(-) + +diff --git a/hw/net/virtio-net.c b/hw/net/virtio-net.c +index 06c53fe..2d559e0 100644 +--- a/hw/net/virtio-net.c ++++ b/hw/net/virtio-net.c +@@ -594,7 +594,7 @@ static int virtio_net_handle_mac(VirtIONet *n, uint8_t cmd, + goto error; + } + +- if (in_use + mac_data.entries <= MAC_TABLE_ENTRIES) { ++ if (mac_data.entries <= MAC_TABLE_ENTRIES - in_use) { + s = iov_to_buf(iov, iov_cnt, 0, &macs[in_use * ETH_ALEN], + mac_data.entries * ETH_ALEN); + if (s != mac_data.entries * ETH_ALEN) { +-- +1.7.1 + diff --git a/SOURCES/kvm-virtio-net-fix-the-memory-leak-in-rxfilter_notify.patch b/SOURCES/kvm-virtio-net-fix-the-memory-leak-in-rxfilter_notify.patch new file mode 100644 index 0000000..ddd6a40 --- /dev/null +++ b/SOURCES/kvm-virtio-net-fix-the-memory-leak-in-rxfilter_notify.patch @@ -0,0 +1,66 @@ +From 7bbc53ba5ca8c488498cc1f8a66de4e3bad5372c Mon Sep 17 00:00:00 2001 +Message-Id: <7bbc53ba5ca8c488498cc1f8a66de4e3bad5372c.1387276076.git.minovotn@redhat.com> +In-Reply-To: +References: +From: Amos Kong +Date: Sat, 23 Nov 2013 03:17:43 +0100 +Subject: [PATCH 03/16] virtio-net: fix the memory leak in rxfilter_notify() +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +RH-Author: Amos Kong +Message-id: <1385176664-3852-2-git-send-email-akong@redhat.com> +Patchwork-id: 55866 +O-Subject: [RHEL-7.0 qemu-kvm PATCH 1/2] virtio-net: fix the memory leak in rxfilter_notify() +Bugzilla: 1033810 +RH-Acked-by: Vlad Yasevich +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Igor Mammedov + +object_get_canonical_path() returns a gchar*, it should be freed by the +caller. + +Signed-off-by: Amos Kong +Reviewed-by: Michael S. Tsirkin +Reviewed-by: Vlad Yasevich +Reviewed-by: Andreas Färber +Signed-off-by: Stefan Hajnoczi +(cherry picked from commit 96e35046e4a97df5b4e1e24e217eb1e1701c7c71) +--- + hw/net/virtio-net.c | 8 ++++---- + 1 files changed, 4 insertions(+), 4 deletions(-) + +Signed-off-by: Michal Novotny +--- + hw/net/virtio-net.c | 8 ++++---- + 1 file changed, 4 insertions(+), 4 deletions(-) + +diff --git a/hw/net/virtio-net.c b/hw/net/virtio-net.c +index 3bc1eed..915aa70 100644 +--- a/hw/net/virtio-net.c ++++ b/hw/net/virtio-net.c +@@ -200,16 +200,16 @@ static void rxfilter_notify(NetClientState *nc) + VirtIONet *n = qemu_get_nic_opaque(nc); + + if (nc->rxfilter_notify_enabled) { ++ gchar *path = object_get_canonical_path(OBJECT(n->qdev)); + if (n->netclient_name) { + event_data = qobject_from_jsonf("{ 'name': %s, 'path': %s }", +- n->netclient_name, +- object_get_canonical_path(OBJECT(n->qdev))); ++ n->netclient_name, path); + } else { +- event_data = qobject_from_jsonf("{ 'path': %s }", +- object_get_canonical_path(OBJECT(n->qdev))); ++ event_data = qobject_from_jsonf("{ 'path': %s }", path); + } + monitor_protocol_event(QEVENT_NIC_RX_FILTER_CHANGED, event_data); + qobject_decref(event_data); ++ g_free(path); + + /* disable event notification to avoid events flooding */ + nc->rxfilter_notify_enabled = 0; +-- +1.7.11.7 + diff --git a/SOURCES/kvm-virtio-net-only-delete-bh-that-existed.patch b/SOURCES/kvm-virtio-net-only-delete-bh-that-existed.patch new file mode 100644 index 0000000..043e8c8 --- /dev/null +++ b/SOURCES/kvm-virtio-net-only-delete-bh-that-existed.patch @@ -0,0 +1,53 @@ +From 3c47b10c7a3a86d6fb5fb15a0c41fe512ed44f87 Mon Sep 17 00:00:00 2001 +From: Xiao Wang +Date: Thu, 14 Nov 2013 09:40:26 +0100 +Subject: [PATCH 02/14] virtio-net: only delete bh that existed + +RH-Author: Xiao Wang +Message-id: <1384422026-7632-1-git-send-email-jasowang@redhat.com> +Patchwork-id: 55681 +O-Subject: [RHEL7.0 qemu-kvm PATCH] virtio-net: only delete bh that existed +Bugzilla: 922463 +RH-Acked-by: Amos Kong +RH-Acked-by: Michael S. Tsirkin +RH-Acked-by: Markus Armbruster +RH-Acked-by: Vlad Yasevich + +bugzilla: https://bugzilla.redhat.com/show_bug.cgi?id=922463 +upstream: 6b9b8758c15f3bc2875dbd6e2d03c5362b8d6902 +brew build: https://brewweb.devel.redhat.com/taskinfo?taskID=6576713 +test status: tested by my self + +We delete without check whether it existed during exit. This will lead NULL +pointer deference since it was created conditionally depends on guest driver +status and features. So add a check of existence before trying to delete it. + +Cc: qemu-stable@nongnu.org +Signed-off-by: Jason Wang +Reviewed-by: Michael S. Tsirkin +Signed-off-by: Michael S. Tsirkin +--- + hw/net/virtio-net.c | 2 +- + 1 files changed, 1 insertions(+), 1 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + hw/net/virtio-net.c | 2 +- + 1 files changed, 1 insertions(+), 1 deletions(-) + +diff --git a/hw/net/virtio-net.c b/hw/net/virtio-net.c +index 19c5030..f889841 100644 +--- a/hw/net/virtio-net.c ++++ b/hw/net/virtio-net.c +@@ -1532,7 +1532,7 @@ static int virtio_net_device_exit(DeviceState *qdev) + if (q->tx_timer) { + qemu_del_timer(q->tx_timer); + qemu_free_timer(q->tx_timer); +- } else { ++ } else if (q->tx_bh) { + qemu_bh_delete(q->tx_bh); + } + } +-- +1.7.1 + diff --git a/SOURCES/kvm-virtio-net-switch-exit-callback-to-VirtioDeviceClass.patch b/SOURCES/kvm-virtio-net-switch-exit-callback-to-VirtioDeviceClass.patch new file mode 100644 index 0000000..5e6ddf9 --- /dev/null +++ b/SOURCES/kvm-virtio-net-switch-exit-callback-to-VirtioDeviceClass.patch @@ -0,0 +1,81 @@ +From fed60f16a54ee6689b6c03025bbe4704a8e4b251 Mon Sep 17 00:00:00 2001 +From: Markus Armbruster +Date: Thu, 23 Jan 2014 14:03:36 +0100 +Subject: [PATCH 09/14] virtio-net: switch exit callback to VirtioDeviceClass + +RH-Author: Markus Armbruster +Message-id: <1390485820-7585-7-git-send-email-armbru@redhat.com> +Patchwork-id: 56926 +O-Subject: [PATCH 7.0 qemu-kvm 06/10] virtio-net: switch exit callback to VirtioDeviceClass +Bugzilla: 983344 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Marcel Apfelbaum +RH-Acked-by: Michael S. Tsirkin + +From: Paolo Bonzini + +This ensures hot-unplug is handled properly by the proxy, and avoids +leaking bus_name which is freed by virtio_device_exit. + +Cc: qemu-stable@nongnu.org +Acked-by: Andreas Faerber +Signed-off-by: Paolo Bonzini +(cherry picked from commit 3786cff5eb384d058395a2729af627fa3253d056) +Signed-off-by: Markus Armbruster +--- + hw/net/virtio-net.c | 11 ++++------- + 1 file changed, 4 insertions(+), 7 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + hw/net/virtio-net.c | 11 ++++------- + 1 files changed, 4 insertions(+), 7 deletions(-) + +diff --git a/hw/net/virtio-net.c b/hw/net/virtio-net.c +index 21b126f..06c53fe 100644 +--- a/hw/net/virtio-net.c ++++ b/hw/net/virtio-net.c +@@ -1506,16 +1506,15 @@ static int virtio_net_device_init(VirtIODevice *vdev) + return 0; + } + +-static int virtio_net_device_exit(DeviceState *qdev) ++static void virtio_net_device_exit(VirtIODevice *vdev) + { +- VirtIONet *n = VIRTIO_NET(qdev); +- VirtIODevice *vdev = VIRTIO_DEVICE(qdev); ++ VirtIONet *n = VIRTIO_NET(vdev); + int i; + + /* This will stop vhost backend if appropriate. */ + virtio_net_set_status(vdev, 0); + +- unregister_savevm(qdev, "virtio-net", n); ++ unregister_savevm(DEVICE(vdev), "virtio-net", n); + + if (n->netclient_name) { + g_free(n->netclient_name); +@@ -1546,8 +1545,6 @@ static int virtio_net_device_exit(DeviceState *qdev) + g_free(n->vqs); + qemu_del_nic(n->nic); + virtio_cleanup(vdev); +- +- return 0; + } + + static void virtio_net_instance_init(Object *obj) +@@ -1574,10 +1571,10 @@ static void virtio_net_class_init(ObjectClass *klass, void *data) + { + DeviceClass *dc = DEVICE_CLASS(klass); + VirtioDeviceClass *vdc = VIRTIO_DEVICE_CLASS(klass); +- dc->exit = virtio_net_device_exit; + dc->props = virtio_net_properties; + set_bit(DEVICE_CATEGORY_NETWORK, dc->categories); + vdc->init = virtio_net_device_init; ++ vdc->exit = virtio_net_device_exit; + vdc->get_config = virtio_net_get_config; + vdc->set_config = virtio_net_set_config; + vdc->get_features = virtio_net_get_features; +-- +1.7.1 + diff --git a/SOURCES/kvm-virtio-pci-add-device_unplugged-callback.patch b/SOURCES/kvm-virtio-pci-add-device_unplugged-callback.patch new file mode 100644 index 0000000..5f9bfa1 --- /dev/null +++ b/SOURCES/kvm-virtio-pci-add-device_unplugged-callback.patch @@ -0,0 +1,81 @@ +From ad9077535a9a32543cd3e7a6d1cacbc37bc27125 Mon Sep 17 00:00:00 2001 +From: Markus Armbruster +Date: Thu, 23 Jan 2014 14:03:40 +0100 +Subject: [PATCH 13/14] virtio-pci: add device_unplugged callback + +RH-Author: Markus Armbruster +Message-id: <1390485820-7585-11-git-send-email-armbru@redhat.com> +Patchwork-id: 56929 +O-Subject: [PATCH 7.0 qemu-kvm 10/10] virtio-pci: add device_unplugged callback +Bugzilla: 983344 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Marcel Apfelbaum +RH-Acked-by: Michael S. Tsirkin + +From: Paolo Bonzini + +This fixes a crash in hot-unplug of virtio-pci devices behind a PCIe +switch. The crash happens because the ioeventfd is still set whent the +child is destroyed (destruction happens in postorder). Then the proxy +tries to unset to ioeventfd, but the virtqueue structure that holds the +EventNotifier has been trashed in the meanwhile. kvm_set_ioeventfd_pio +does not expect failure and aborts. + +The fix is simply to move parts of uninitialization to a new +device_unplugged callback, which is called before the child is destroyed. + +Cc: qemu-stable@nongnu.org +Acked-by: Andreas Faerber +Signed-off-by: Paolo Bonzini +(cherry picked from commit 06a1307379fcd6c551185ad87679cd7ed896b9ea) +Signed-off-by: Markus Armbruster +--- + hw/virtio/virtio-pci.c | 12 ++++++++++-- + 1 file changed, 10 insertions(+), 2 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + hw/virtio/virtio-pci.c | 12 ++++++++++-- + 1 files changed, 10 insertions(+), 2 deletions(-) + +diff --git a/hw/virtio/virtio-pci.c b/hw/virtio/virtio-pci.c +index 02ddbe9..00df4aa 100644 +--- a/hw/virtio/virtio-pci.c ++++ b/hw/virtio/virtio-pci.c +@@ -1007,6 +1007,15 @@ static void virtio_pci_device_plugged(DeviceState *d) + proxy->host_features); + } + ++static void virtio_pci_device_unplugged(DeviceState *d) ++{ ++ PCIDevice *pci_dev = PCI_DEVICE(d); ++ VirtIOPCIProxy *proxy = VIRTIO_PCI(d); ++ ++ virtio_pci_stop_ioeventfd(proxy); ++ msix_uninit_exclusive_bar(pci_dev); ++} ++ + static int virtio_pci_init(PCIDevice *pci_dev) + { + VirtIOPCIProxy *dev = VIRTIO_PCI(pci_dev); +@@ -1021,9 +1030,7 @@ static int virtio_pci_init(PCIDevice *pci_dev) + static void virtio_pci_exit(PCIDevice *pci_dev) + { + VirtIOPCIProxy *proxy = VIRTIO_PCI(pci_dev); +- virtio_pci_stop_ioeventfd(proxy); + memory_region_destroy(&proxy->bar); +- msix_uninit_exclusive_bar(pci_dev); + } + + static void virtio_pci_reset(DeviceState *qdev) +@@ -1557,6 +1564,7 @@ static void virtio_pci_bus_class_init(ObjectClass *klass, void *data) + k->set_guest_notifiers = virtio_pci_set_guest_notifiers; + k->vmstate_change = virtio_pci_vmstate_change; + k->device_plugged = virtio_pci_device_plugged; ++ k->device_unplugged = virtio_pci_device_unplugged; + } + + static const TypeInfo virtio_pci_bus_info = { +-- +1.7.1 + diff --git a/SOURCES/kvm-virtio-pci-remove-vdev-field.patch b/SOURCES/kvm-virtio-pci-remove-vdev-field.patch new file mode 100644 index 0000000..d31591d --- /dev/null +++ b/SOURCES/kvm-virtio-pci-remove-vdev-field.patch @@ -0,0 +1,465 @@ +From 20d6241976e9adff2ae4a52defb8d8074ccbeff6 Mon Sep 17 00:00:00 2001 +From: Markus Armbruster +Date: Thu, 23 Jan 2014 14:03:32 +0100 +Subject: [PATCH 05/14] virtio-pci: remove vdev field + +RH-Author: Markus Armbruster +Message-id: <1390485820-7585-3-git-send-email-armbru@redhat.com> +Patchwork-id: 56925 +O-Subject: [PATCH 7.0 qemu-kvm 02/10] virtio-pci: remove vdev field +Bugzilla: 983344 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Marcel Apfelbaum +RH-Acked-by: Michael S. Tsirkin + +From: Paolo Bonzini + +The vdev field is complicated to synchronize. Just access the +BusState's list of children. + +Cc: qemu-stable@nongnu.org +Acked-by: Andreas Faerber +Signed-off-by: Paolo Bonzini +(cherry picked from commit a3fc66d9fd37acbfcee013692246a8ae42bd93bb) + +Conflicts: + hw/virtio/virtio-pci.c + +Conflicts because we lack commit 9e64f8a "hw: set interrupts using pci +irq wrappers". +Signed-off-by: Markus Armbruster +--- + hw/virtio/virtio-pci.c | 110 +++++++++++++++++++++++++++++-------------------- + hw/virtio/virtio-pci.h | 1 - + 2 files changed, 65 insertions(+), 46 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + hw/virtio/virtio-pci.c | 110 ++++++++++++++++++++++++++++------------------- + hw/virtio/virtio-pci.h | 1 - + 2 files changed, 65 insertions(+), 46 deletions(-) + +diff --git a/hw/virtio/virtio-pci.c b/hw/virtio/virtio-pci.c +index 1287e59..02ddbe9 100644 +--- a/hw/virtio/virtio-pci.c ++++ b/hw/virtio/virtio-pci.c +@@ -118,31 +118,40 @@ static inline VirtIOPCIProxy *to_virtio_pci_proxy_fast(DeviceState *d) + static void virtio_pci_notify(DeviceState *d, uint16_t vector) + { + VirtIOPCIProxy *proxy = to_virtio_pci_proxy_fast(d); ++ + if (msix_enabled(&proxy->pci_dev)) + msix_notify(&proxy->pci_dev, vector); +- else +- qemu_set_irq(proxy->pci_dev.irq[0], proxy->vdev->isr & 1); ++ else { ++ VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus); ++ qemu_set_irq(proxy->pci_dev.irq[0], vdev->isr & 1); ++ } + } + + static void virtio_pci_save_config(DeviceState *d, QEMUFile *f) + { + VirtIOPCIProxy *proxy = to_virtio_pci_proxy(d); ++ VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus); ++ + pci_device_save(&proxy->pci_dev, f); + msix_save(&proxy->pci_dev, f); + if (msix_present(&proxy->pci_dev)) +- qemu_put_be16(f, proxy->vdev->config_vector); ++ qemu_put_be16(f, vdev->config_vector); + } + + static void virtio_pci_save_queue(DeviceState *d, int n, QEMUFile *f) + { + VirtIOPCIProxy *proxy = to_virtio_pci_proxy(d); ++ VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus); ++ + if (msix_present(&proxy->pci_dev)) +- qemu_put_be16(f, virtio_queue_vector(proxy->vdev, n)); ++ qemu_put_be16(f, virtio_queue_vector(vdev, n)); + } + + static int virtio_pci_load_config(DeviceState *d, QEMUFile *f) + { + VirtIOPCIProxy *proxy = to_virtio_pci_proxy(d); ++ VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus); ++ + int ret; + ret = pci_device_load(&proxy->pci_dev, f); + if (ret) { +@@ -151,12 +160,12 @@ static int virtio_pci_load_config(DeviceState *d, QEMUFile *f) + msix_unuse_all_vectors(&proxy->pci_dev); + msix_load(&proxy->pci_dev, f); + if (msix_present(&proxy->pci_dev)) { +- qemu_get_be16s(f, &proxy->vdev->config_vector); ++ qemu_get_be16s(f, &vdev->config_vector); + } else { +- proxy->vdev->config_vector = VIRTIO_NO_VECTOR; ++ vdev->config_vector = VIRTIO_NO_VECTOR; + } +- if (proxy->vdev->config_vector != VIRTIO_NO_VECTOR) { +- return msix_vector_use(&proxy->pci_dev, proxy->vdev->config_vector); ++ if (vdev->config_vector != VIRTIO_NO_VECTOR) { ++ return msix_vector_use(&proxy->pci_dev, vdev->config_vector); + } + return 0; + } +@@ -164,13 +173,15 @@ static int virtio_pci_load_config(DeviceState *d, QEMUFile *f) + static int virtio_pci_load_queue(DeviceState *d, int n, QEMUFile *f) + { + VirtIOPCIProxy *proxy = to_virtio_pci_proxy(d); ++ VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus); ++ + uint16_t vector; + if (msix_present(&proxy->pci_dev)) { + qemu_get_be16s(f, &vector); + } else { + vector = VIRTIO_NO_VECTOR; + } +- virtio_queue_set_vector(proxy->vdev, n, vector); ++ virtio_queue_set_vector(vdev, n, vector); + if (vector != VIRTIO_NO_VECTOR) { + return msix_vector_use(&proxy->pci_dev, vector); + } +@@ -180,7 +191,8 @@ static int virtio_pci_load_queue(DeviceState *d, int n, QEMUFile *f) + static int virtio_pci_set_host_notifier_internal(VirtIOPCIProxy *proxy, + int n, bool assign, bool set_handler) + { +- VirtQueue *vq = virtio_get_queue(proxy->vdev, n); ++ VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus); ++ VirtQueue *vq = virtio_get_queue(vdev, n); + EventNotifier *notifier = virtio_queue_get_host_notifier(vq); + int r = 0; + +@@ -205,6 +217,7 @@ static int virtio_pci_set_host_notifier_internal(VirtIOPCIProxy *proxy, + + static void virtio_pci_start_ioeventfd(VirtIOPCIProxy *proxy) + { ++ VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus); + int n, r; + + if (!(proxy->flags & VIRTIO_PCI_FLAG_USE_IOEVENTFD) || +@@ -214,7 +227,7 @@ static void virtio_pci_start_ioeventfd(VirtIOPCIProxy *proxy) + } + + for (n = 0; n < VIRTIO_PCI_QUEUE_MAX; n++) { +- if (!virtio_queue_get_num(proxy->vdev, n)) { ++ if (!virtio_queue_get_num(vdev, n)) { + continue; + } + +@@ -228,7 +241,7 @@ static void virtio_pci_start_ioeventfd(VirtIOPCIProxy *proxy) + + assign_error: + while (--n >= 0) { +- if (!virtio_queue_get_num(proxy->vdev, n)) { ++ if (!virtio_queue_get_num(vdev, n)) { + continue; + } + +@@ -241,6 +254,7 @@ assign_error: + + static void virtio_pci_stop_ioeventfd(VirtIOPCIProxy *proxy) + { ++ VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus); + int r; + int n; + +@@ -249,7 +263,7 @@ static void virtio_pci_stop_ioeventfd(VirtIOPCIProxy *proxy) + } + + for (n = 0; n < VIRTIO_PCI_QUEUE_MAX; n++) { +- if (!virtio_queue_get_num(proxy->vdev, n)) { ++ if (!virtio_queue_get_num(vdev, n)) { + continue; + } + +@@ -262,7 +276,7 @@ static void virtio_pci_stop_ioeventfd(VirtIOPCIProxy *proxy) + static void virtio_ioport_write(void *opaque, uint32_t addr, uint32_t val) + { + VirtIOPCIProxy *proxy = opaque; +- VirtIODevice *vdev = proxy->vdev; ++ VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus); + hwaddr pa; + + switch (addr) { +@@ -277,7 +291,7 @@ static void virtio_ioport_write(void *opaque, uint32_t addr, uint32_t val) + pa = (hwaddr)val << VIRTIO_PCI_QUEUE_ADDR_SHIFT; + if (pa == 0) { + virtio_pci_stop_ioeventfd(proxy); +- virtio_reset(proxy->vdev); ++ virtio_reset(vdev); + msix_unuse_all_vectors(&proxy->pci_dev); + } + else +@@ -304,7 +318,7 @@ static void virtio_ioport_write(void *opaque, uint32_t addr, uint32_t val) + } + + if (vdev->status == 0) { +- virtio_reset(proxy->vdev); ++ virtio_reset(vdev); + msix_unuse_all_vectors(&proxy->pci_dev); + } + +@@ -340,7 +354,7 @@ static void virtio_ioport_write(void *opaque, uint32_t addr, uint32_t val) + + static uint32_t virtio_ioport_read(VirtIOPCIProxy *proxy, uint32_t addr) + { +- VirtIODevice *vdev = proxy->vdev; ++ VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus); + uint32_t ret = 0xFFFFFFFF; + + switch (addr) { +@@ -386,6 +400,7 @@ static uint64_t virtio_pci_config_read(void *opaque, hwaddr addr, + unsigned size) + { + VirtIOPCIProxy *proxy = opaque; ++ VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus); + uint32_t config = VIRTIO_PCI_CONFIG(&proxy->pci_dev); + uint64_t val = 0; + if (addr < config) { +@@ -395,16 +410,16 @@ static uint64_t virtio_pci_config_read(void *opaque, hwaddr addr, + + switch (size) { + case 1: +- val = virtio_config_readb(proxy->vdev, addr); ++ val = virtio_config_readb(vdev, addr); + break; + case 2: +- val = virtio_config_readw(proxy->vdev, addr); ++ val = virtio_config_readw(vdev, addr); + if (virtio_is_big_endian()) { + val = bswap16(val); + } + break; + case 4: +- val = virtio_config_readl(proxy->vdev, addr); ++ val = virtio_config_readl(vdev, addr); + if (virtio_is_big_endian()) { + val = bswap32(val); + } +@@ -418,6 +433,7 @@ static void virtio_pci_config_write(void *opaque, hwaddr addr, + { + VirtIOPCIProxy *proxy = opaque; + uint32_t config = VIRTIO_PCI_CONFIG(&proxy->pci_dev); ++ VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus); + if (addr < config) { + virtio_ioport_write(proxy, addr, val); + return; +@@ -429,19 +445,19 @@ static void virtio_pci_config_write(void *opaque, hwaddr addr, + */ + switch (size) { + case 1: +- virtio_config_writeb(proxy->vdev, addr, val); ++ virtio_config_writeb(vdev, addr, val); + break; + case 2: + if (virtio_is_big_endian()) { + val = bswap16(val); + } +- virtio_config_writew(proxy->vdev, addr, val); ++ virtio_config_writew(vdev, addr, val); + break; + case 4: + if (virtio_is_big_endian()) { + val = bswap32(val); + } +- virtio_config_writel(proxy->vdev, addr, val); ++ virtio_config_writel(vdev, addr, val); + break; + } + } +@@ -460,6 +476,7 @@ static void virtio_write_config(PCIDevice *pci_dev, uint32_t address, + uint32_t val, int len) + { + VirtIOPCIProxy *proxy = DO_UPCAST(VirtIOPCIProxy, pci_dev, pci_dev); ++ VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus); + + pci_default_write_config(pci_dev, address, val, len); + +@@ -467,8 +484,7 @@ static void virtio_write_config(PCIDevice *pci_dev, uint32_t address, + !(pci_dev->config[PCI_COMMAND] & PCI_COMMAND_MASTER) && + !(proxy->flags & VIRTIO_PCI_FLAG_BUS_MASTER_BUG)) { + virtio_pci_stop_ioeventfd(proxy); +- virtio_set_status(proxy->vdev, +- proxy->vdev->status & ~VIRTIO_CONFIG_S_DRIVER_OK); ++ virtio_set_status(vdev, vdev->status & ~VIRTIO_CONFIG_S_DRIVER_OK); + } + } + +@@ -511,7 +527,8 @@ static int kvm_virtio_pci_irqfd_use(VirtIOPCIProxy *proxy, + unsigned int vector) + { + VirtIOIRQFD *irqfd = &proxy->vector_irqfd[vector]; +- VirtQueue *vq = virtio_get_queue(proxy->vdev, queue_no); ++ VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus); ++ VirtQueue *vq = virtio_get_queue(vdev, queue_no); + EventNotifier *n = virtio_queue_get_guest_notifier(vq); + int ret; + ret = kvm_irqchip_add_irqfd_notifier(kvm_state, n, irqfd->virq); +@@ -522,7 +539,8 @@ static void kvm_virtio_pci_irqfd_release(VirtIOPCIProxy *proxy, + unsigned int queue_no, + unsigned int vector) + { +- VirtQueue *vq = virtio_get_queue(proxy->vdev, queue_no); ++ VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus); ++ VirtQueue *vq = virtio_get_queue(vdev, queue_no); + EventNotifier *n = virtio_queue_get_guest_notifier(vq); + VirtIOIRQFD *irqfd = &proxy->vector_irqfd[vector]; + int ret; +@@ -534,7 +552,7 @@ static void kvm_virtio_pci_irqfd_release(VirtIOPCIProxy *proxy, + static int kvm_virtio_pci_vector_use(VirtIOPCIProxy *proxy, int nvqs) + { + PCIDevice *dev = &proxy->pci_dev; +- VirtIODevice *vdev = proxy->vdev; ++ VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus); + VirtioDeviceClass *k = VIRTIO_DEVICE_GET_CLASS(vdev); + unsigned int vector; + int ret, queue_no; +@@ -583,7 +601,7 @@ undo: + static void kvm_virtio_pci_vector_release(VirtIOPCIProxy *proxy, int nvqs) + { + PCIDevice *dev = &proxy->pci_dev; +- VirtIODevice *vdev = proxy->vdev; ++ VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus); + unsigned int vector; + int queue_no; + VirtioDeviceClass *k = VIRTIO_DEVICE_GET_CLASS(vdev); +@@ -611,8 +629,9 @@ static int virtio_pci_vq_vector_unmask(VirtIOPCIProxy *proxy, + unsigned int vector, + MSIMessage msg) + { +- VirtioDeviceClass *k = VIRTIO_DEVICE_GET_CLASS(proxy->vdev); +- VirtQueue *vq = virtio_get_queue(proxy->vdev, queue_no); ++ VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus); ++ VirtioDeviceClass *k = VIRTIO_DEVICE_GET_CLASS(vdev); ++ VirtQueue *vq = virtio_get_queue(vdev, queue_no); + EventNotifier *n = virtio_queue_get_guest_notifier(vq); + VirtIOIRQFD *irqfd; + int ret = 0; +@@ -631,10 +650,10 @@ static int virtio_pci_vq_vector_unmask(VirtIOPCIProxy *proxy, + * Otherwise, set it up now. + */ + if (k->guest_notifier_mask) { +- k->guest_notifier_mask(proxy->vdev, queue_no, false); ++ k->guest_notifier_mask(vdev, queue_no, false); + /* Test after unmasking to avoid losing events. */ + if (k->guest_notifier_pending && +- k->guest_notifier_pending(proxy->vdev, queue_no)) { ++ k->guest_notifier_pending(vdev, queue_no)) { + event_notifier_set(n); + } + } else { +@@ -647,13 +666,14 @@ static void virtio_pci_vq_vector_mask(VirtIOPCIProxy *proxy, + unsigned int queue_no, + unsigned int vector) + { +- VirtioDeviceClass *k = VIRTIO_DEVICE_GET_CLASS(proxy->vdev); ++ VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus); ++ VirtioDeviceClass *k = VIRTIO_DEVICE_GET_CLASS(vdev); + + /* If guest supports masking, keep irqfd but mask it. + * Otherwise, clean it up now. + */ + if (k->guest_notifier_mask) { +- k->guest_notifier_mask(proxy->vdev, queue_no, true); ++ k->guest_notifier_mask(vdev, queue_no, true); + } else { + kvm_virtio_pci_irqfd_release(proxy, queue_no, vector); + } +@@ -663,7 +683,7 @@ static int virtio_pci_vector_unmask(PCIDevice *dev, unsigned vector, + MSIMessage msg) + { + VirtIOPCIProxy *proxy = container_of(dev, VirtIOPCIProxy, pci_dev); +- VirtIODevice *vdev = proxy->vdev; ++ VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus); + int ret, queue_no; + + for (queue_no = 0; queue_no < proxy->nvqs_with_notifiers; queue_no++) { +@@ -693,7 +713,7 @@ undo: + static void virtio_pci_vector_mask(PCIDevice *dev, unsigned vector) + { + VirtIOPCIProxy *proxy = container_of(dev, VirtIOPCIProxy, pci_dev); +- VirtIODevice *vdev = proxy->vdev; ++ VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus); + int queue_no; + + for (queue_no = 0; queue_no < proxy->nvqs_with_notifiers; queue_no++) { +@@ -712,7 +732,7 @@ static void virtio_pci_vector_poll(PCIDevice *dev, + unsigned int vector_end) + { + VirtIOPCIProxy *proxy = container_of(dev, VirtIOPCIProxy, pci_dev); +- VirtIODevice *vdev = proxy->vdev; ++ VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus); + VirtioDeviceClass *k = VIRTIO_DEVICE_GET_CLASS(vdev); + int queue_no; + unsigned int vector; +@@ -744,8 +764,9 @@ static int virtio_pci_set_guest_notifier(DeviceState *d, int n, bool assign, + bool with_irqfd) + { + VirtIOPCIProxy *proxy = to_virtio_pci_proxy(d); +- VirtioDeviceClass *vdc = VIRTIO_DEVICE_GET_CLASS(proxy->vdev); +- VirtQueue *vq = virtio_get_queue(proxy->vdev, n); ++ VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus); ++ VirtioDeviceClass *vdc = VIRTIO_DEVICE_GET_CLASS(vdev); ++ VirtQueue *vq = virtio_get_queue(vdev, n); + EventNotifier *notifier = virtio_queue_get_guest_notifier(vq); + + if (assign) { +@@ -760,7 +781,7 @@ static int virtio_pci_set_guest_notifier(DeviceState *d, int n, bool assign, + } + + if (!msix_enabled(&proxy->pci_dev) && vdc->guest_notifier_mask) { +- vdc->guest_notifier_mask(proxy->vdev, n, !assign); ++ vdc->guest_notifier_mask(vdev, n, !assign); + } + + return 0; +@@ -775,7 +796,7 @@ static bool virtio_pci_query_guest_notifiers(DeviceState *d) + static int virtio_pci_set_guest_notifiers(DeviceState *d, int nvqs, bool assign) + { + VirtIOPCIProxy *proxy = to_virtio_pci_proxy(d); +- VirtIODevice *vdev = proxy->vdev; ++ VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus); + VirtioDeviceClass *k = VIRTIO_DEVICE_GET_CLASS(vdev); + int r, n; + bool with_irqfd = msix_enabled(&proxy->pci_dev) && +@@ -869,11 +890,12 @@ static int virtio_pci_set_host_notifier(DeviceState *d, int n, bool assign) + static void virtio_pci_vmstate_change(DeviceState *d, bool running) + { + VirtIOPCIProxy *proxy = to_virtio_pci_proxy(d); ++ VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus); + + if (running) { + /* Try to find out if the guest has bus master disabled, but is + in ready state. Then we have a buggy guest OS. */ +- if ((proxy->vdev->status & VIRTIO_CONFIG_S_DRIVER_OK) && ++ if ((vdev->status & VIRTIO_CONFIG_S_DRIVER_OK) && + !(proxy->pci_dev.config[PCI_COMMAND] & PCI_COMMAND_MASTER)) { + proxy->flags |= VIRTIO_PCI_FLAG_BUS_MASTER_BUG; + } +@@ -948,8 +970,6 @@ static void virtio_pci_device_plugged(DeviceState *d) + uint8_t *config; + uint32_t size; + +- proxy->vdev = virtio_bus_get_device(bus); +- + config = proxy->pci_dev.config; + if (proxy->class_code) { + pci_config_set_class(config, proxy->class_code); +diff --git a/hw/virtio/virtio-pci.h b/hw/virtio/virtio-pci.h +index 917bcc5..dc332ae 100644 +--- a/hw/virtio/virtio-pci.h ++++ b/hw/virtio/virtio-pci.h +@@ -82,7 +82,6 @@ typedef struct VirtioPCIClass { + + struct VirtIOPCIProxy { + PCIDevice pci_dev; +- VirtIODevice *vdev; + MemoryRegion bar; + uint32_t flags; + uint32_t class_code; +-- +1.7.1 + diff --git a/SOURCES/kvm-virtio-rng-switch-exit-callback-to-VirtioDeviceClass.patch b/SOURCES/kvm-virtio-rng-switch-exit-callback-to-VirtioDeviceClass.patch new file mode 100644 index 0000000..dd6c29d --- /dev/null +++ b/SOURCES/kvm-virtio-rng-switch-exit-callback-to-VirtioDeviceClass.patch @@ -0,0 +1,78 @@ +From 8c40efb1aad9861f12b958002c5cfae1d91aeae5 Mon Sep 17 00:00:00 2001 +From: Markus Armbruster +Date: Thu, 23 Jan 2014 14:03:39 +0100 +Subject: [PATCH 12/14] virtio-rng: switch exit callback to VirtioDeviceClass + +RH-Author: Markus Armbruster +Message-id: <1390485820-7585-10-git-send-email-armbru@redhat.com> +Patchwork-id: 56928 +O-Subject: [PATCH 7.0 qemu-kvm 09/10] virtio-rng: switch exit callback to VirtioDeviceClass +Bugzilla: 983344 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Marcel Apfelbaum +RH-Acked-by: Michael S. Tsirkin + +From: Paolo Bonzini + +This ensures hot-unplug is handled properly by the proxy, and avoids +leaking bus_name which is freed by virtio_device_exit. + +Cc: qemu-stable@nongnu.org +Acked-by: Andreas Faerber +Signed-off-by: Paolo Bonzini +(cherry picked from commit 7bb6edb0e3dd78d74e0ac980cf6c0a07307f61bf) + +Conflicts: + hw/virtio/virtio-rng.c + +Trivially conflicts because we lack commit bc72ad6 "aio / timers: +Switch entire codebase to the new timer API". +Signed-off-by: Markus Armbruster +--- + hw/virtio/virtio-rng.c | 10 ++++------ + 1 file changed, 4 insertions(+), 6 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + hw/virtio/virtio-rng.c | 10 ++++------ + 1 files changed, 4 insertions(+), 6 deletions(-) + +diff --git a/hw/virtio/virtio-rng.c b/hw/virtio/virtio-rng.c +index bac8421..6895146 100644 +--- a/hw/virtio/virtio-rng.c ++++ b/hw/virtio/virtio-rng.c +@@ -184,16 +184,14 @@ static int virtio_rng_device_init(VirtIODevice *vdev) + return 0; + } + +-static int virtio_rng_device_exit(DeviceState *qdev) ++static void virtio_rng_device_exit(VirtIODevice *vdev) + { +- VirtIORNG *vrng = VIRTIO_RNG(qdev); +- VirtIODevice *vdev = VIRTIO_DEVICE(qdev); ++ VirtIORNG *vrng = VIRTIO_RNG(vdev); + + qemu_del_timer(vrng->rate_limit_timer); + qemu_free_timer(vrng->rate_limit_timer); +- unregister_savevm(qdev, "virtio-rng", vrng); ++ unregister_savevm(DEVICE(vdev), "virtio-rng", vrng); + virtio_cleanup(vdev); +- return 0; + } + + static Property virtio_rng_properties[] = { +@@ -205,10 +203,10 @@ static void virtio_rng_class_init(ObjectClass *klass, void *data) + { + DeviceClass *dc = DEVICE_CLASS(klass); + VirtioDeviceClass *vdc = VIRTIO_DEVICE_CLASS(klass); +- dc->exit = virtio_rng_device_exit; + dc->props = virtio_rng_properties; + set_bit(DEVICE_CATEGORY_MISC, dc->categories); + vdc->init = virtio_rng_device_init; ++ vdc->exit = virtio_rng_device_exit; + vdc->get_features = get_features; + } + +-- +1.7.1 + diff --git a/SOURCES/kvm-virtio-scsi-switch-exit-callback-to-VirtioDeviceClas.patch b/SOURCES/kvm-virtio-scsi-switch-exit-callback-to-VirtioDeviceClas.patch new file mode 100644 index 0000000..fa160a2 --- /dev/null +++ b/SOURCES/kvm-virtio-scsi-switch-exit-callback-to-VirtioDeviceClas.patch @@ -0,0 +1,137 @@ +From 79d38d6ea2208ef31fe39eb7d5993e5eefd36eee Mon Sep 17 00:00:00 2001 +From: Markus Armbruster +Date: Thu, 23 Jan 2014 14:03:37 +0100 +Subject: [PATCH 10/14] virtio-scsi: switch exit callback to VirtioDeviceClass + +RH-Author: Markus Armbruster +Message-id: <1390485820-7585-8-git-send-email-armbru@redhat.com> +Patchwork-id: 56931 +O-Subject: [PATCH 7.0 qemu-kvm 07/10] virtio-scsi: switch exit callback to VirtioDeviceClass +Bugzilla: 983344 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Marcel Apfelbaum +RH-Acked-by: Michael S. Tsirkin + +From: Paolo Bonzini + +This ensures hot-unplug is handled properly by the proxy, and avoids +leaking bus_name which is freed by virtio_device_exit. + +Cc: qemu-stable@nongnu.org +Acked-by: Andreas Faerber +Signed-off-by: Paolo Bonzini +(cherry picked from commit e3c9d76acc984218264bbc6435b0c09f959ed9b8) +Signed-off-by: Markus Armbruster +--- + hw/scsi/vhost-scsi.c | 11 +++++------ + hw/scsi/virtio-scsi.c | 15 +++++++-------- + include/hw/virtio/virtio-scsi.h | 2 +- + 3 files changed, 13 insertions(+), 15 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + hw/scsi/vhost-scsi.c | 11 +++++------ + hw/scsi/virtio-scsi.c | 15 +++++++-------- + include/hw/virtio/virtio-scsi.h | 2 +- + 3 files changed, 13 insertions(+), 15 deletions(-) + +diff --git a/hw/scsi/vhost-scsi.c b/hw/scsi/vhost-scsi.c +index 9e770fb..5e3cc61 100644 +--- a/hw/scsi/vhost-scsi.c ++++ b/hw/scsi/vhost-scsi.c +@@ -240,11 +240,10 @@ static int vhost_scsi_init(VirtIODevice *vdev) + return 0; + } + +-static int vhost_scsi_exit(DeviceState *qdev) ++static void vhost_scsi_exit(VirtIODevice *vdev) + { +- VirtIODevice *vdev = VIRTIO_DEVICE(qdev); +- VHostSCSI *s = VHOST_SCSI(qdev); +- VirtIOSCSICommon *vs = VIRTIO_SCSI_COMMON(qdev); ++ VHostSCSI *s = VHOST_SCSI(vdev); ++ VirtIOSCSICommon *vs = VIRTIO_SCSI_COMMON(vdev); + + migrate_del_blocker(s->migration_blocker); + error_free(s->migration_blocker); +@@ -253,7 +252,7 @@ static int vhost_scsi_exit(DeviceState *qdev) + vhost_scsi_set_status(vdev, 0); + + g_free(s->dev.vqs); +- return virtio_scsi_common_exit(vs); ++ virtio_scsi_common_exit(vs); + } + + static Property vhost_scsi_properties[] = { +@@ -265,10 +264,10 @@ static void vhost_scsi_class_init(ObjectClass *klass, void *data) + { + DeviceClass *dc = DEVICE_CLASS(klass); + VirtioDeviceClass *vdc = VIRTIO_DEVICE_CLASS(klass); +- dc->exit = vhost_scsi_exit; + dc->props = vhost_scsi_properties; + set_bit(DEVICE_CATEGORY_STORAGE, dc->categories); + vdc->init = vhost_scsi_init; ++ vdc->exit = vhost_scsi_exit; + vdc->get_features = vhost_scsi_get_features; + vdc->set_config = vhost_scsi_set_config; + vdc->set_status = vhost_scsi_set_status; +diff --git a/hw/scsi/virtio-scsi.c b/hw/scsi/virtio-scsi.c +index 038cd83..57541b4 100644 +--- a/hw/scsi/virtio-scsi.c ++++ b/hw/scsi/virtio-scsi.c +@@ -636,22 +636,21 @@ static int virtio_scsi_device_init(VirtIODevice *vdev) + return 0; + } + +-int virtio_scsi_common_exit(VirtIOSCSICommon *vs) ++void virtio_scsi_common_exit(VirtIOSCSICommon *vs) + { + VirtIODevice *vdev = VIRTIO_DEVICE(vs); + + g_free(vs->cmd_vqs); + virtio_cleanup(vdev); +- return 0; + } + +-static int virtio_scsi_device_exit(DeviceState *qdev) ++static void virtio_scsi_device_exit(VirtIODevice *vdev) + { +- VirtIOSCSI *s = VIRTIO_SCSI(qdev); +- VirtIOSCSICommon *vs = VIRTIO_SCSI_COMMON(qdev); ++ VirtIOSCSI *s = VIRTIO_SCSI(vdev); ++ VirtIOSCSICommon *vs = VIRTIO_SCSI_COMMON(vdev); + +- unregister_savevm(qdev, "virtio-scsi", s); +- return virtio_scsi_common_exit(vs); ++ unregister_savevm(DEVICE(vdev), "virtio-scsi", s); ++ virtio_scsi_common_exit(vs); + } + + static Property virtio_scsi_properties[] = { +@@ -672,10 +671,10 @@ static void virtio_scsi_class_init(ObjectClass *klass, void *data) + { + DeviceClass *dc = DEVICE_CLASS(klass); + VirtioDeviceClass *vdc = VIRTIO_DEVICE_CLASS(klass); +- dc->exit = virtio_scsi_device_exit; + dc->props = virtio_scsi_properties; + set_bit(DEVICE_CATEGORY_STORAGE, dc->categories); + vdc->init = virtio_scsi_device_init; ++ vdc->exit = virtio_scsi_device_exit; + vdc->set_config = virtio_scsi_set_config; + vdc->get_features = virtio_scsi_get_features; + vdc->reset = virtio_scsi_reset; +diff --git a/include/hw/virtio/virtio-scsi.h b/include/hw/virtio/virtio-scsi.h +index 9a98540..206c61d 100644 +--- a/include/hw/virtio/virtio-scsi.h ++++ b/include/hw/virtio/virtio-scsi.h +@@ -187,6 +187,6 @@ typedef struct { + VIRTIO_SCSI_F_CHANGE, true) + + int virtio_scsi_common_init(VirtIOSCSICommon *vs); +-int virtio_scsi_common_exit(VirtIOSCSICommon *vs); ++void virtio_scsi_common_exit(VirtIOSCSICommon *vs); + + #endif /* _QEMU_VIRTIO_SCSI_H */ +-- +1.7.1 + diff --git a/SOURCES/kvm-virtio-serial-switch-exit-callback-to-VirtioDeviceCl.patch b/SOURCES/kvm-virtio-serial-switch-exit-callback-to-VirtioDeviceCl.patch new file mode 100644 index 0000000..1d6bf83 --- /dev/null +++ b/SOURCES/kvm-virtio-serial-switch-exit-callback-to-VirtioDeviceCl.patch @@ -0,0 +1,76 @@ +From faea056361cd9955f41a8d8c907af32625885b0d Mon Sep 17 00:00:00 2001 +From: Markus Armbruster +Date: Thu, 23 Jan 2014 14:03:35 +0100 +Subject: [PATCH 08/14] virtio-serial: switch exit callback to VirtioDeviceClass + +RH-Author: Markus Armbruster +Message-id: <1390485820-7585-6-git-send-email-armbru@redhat.com> +Patchwork-id: 56932 +O-Subject: [PATCH 7.0 qemu-kvm 05/10] virtio-serial: switch exit callback to VirtioDeviceClass +Bugzilla: 983344 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Marcel Apfelbaum +RH-Acked-by: Michael S. Tsirkin + +From: Paolo Bonzini + +This ensures hot-unplug is handled properly by the proxy, and avoids +leaking bus_name which is freed by virtio_device_exit. + +Cc: qemu-stable@nongnu.org +Acked-by: Andreas Faerber +Signed-off-by: Paolo Bonzini +(cherry picked from commit 0e86c13fe2058adb8c792ebb7c51a6a7ca9d3d55) +Signed-off-by: Markus Armbruster +--- + hw/char/virtio-serial-bus.c | 10 ++++------ + 1 file changed, 4 insertions(+), 6 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + hw/char/virtio-serial-bus.c | 10 ++++------ + 1 files changed, 4 insertions(+), 6 deletions(-) + +diff --git a/hw/char/virtio-serial-bus.c b/hw/char/virtio-serial-bus.c +index da417c7..57dd070 100644 +--- a/hw/char/virtio-serial-bus.c ++++ b/hw/char/virtio-serial-bus.c +@@ -987,12 +987,11 @@ static const TypeInfo virtio_serial_port_type_info = { + .class_init = virtio_serial_port_class_init, + }; + +-static int virtio_serial_device_exit(DeviceState *dev) ++static void virtio_serial_device_exit(VirtIODevice *vdev) + { +- VirtIOSerial *vser = VIRTIO_SERIAL(dev); +- VirtIODevice *vdev = VIRTIO_DEVICE(dev); ++ VirtIOSerial *vser = VIRTIO_SERIAL(vdev); + +- unregister_savevm(dev, "virtio-console", vser); ++ unregister_savevm(DEVICE(vdev), "virtio-console", vser); + + g_free(vser->ivqs); + g_free(vser->ovqs); +@@ -1004,7 +1003,6 @@ static int virtio_serial_device_exit(DeviceState *dev) + g_free(vser->post_load); + } + virtio_cleanup(vdev); +- return 0; + } + + static Property virtio_serial_properties[] = { +@@ -1016,10 +1014,10 @@ static void virtio_serial_class_init(ObjectClass *klass, void *data) + { + DeviceClass *dc = DEVICE_CLASS(klass); + VirtioDeviceClass *vdc = VIRTIO_DEVICE_CLASS(klass); +- dc->exit = virtio_serial_device_exit; + dc->props = virtio_serial_properties; + set_bit(DEVICE_CATEGORY_INPUT, dc->categories); + vdc->init = virtio_serial_device_init; ++ vdc->exit = virtio_serial_device_exit; + vdc->get_features = get_features; + vdc->get_config = get_config; + vdc->set_config = set_config; +-- +1.7.1 + diff --git a/SOURCES/kvm-virtio_pci-fix-level-interrupts-with-irqfd.patch b/SOURCES/kvm-virtio_pci-fix-level-interrupts-with-irqfd.patch new file mode 100644 index 0000000..fab9e05 --- /dev/null +++ b/SOURCES/kvm-virtio_pci-fix-level-interrupts-with-irqfd.patch @@ -0,0 +1,63 @@ +From d52f76a894c5a6663ffbee71e020069a86a52989 Mon Sep 17 00:00:00 2001 +Message-Id: +From: Stefan Hajnoczi +Date: Wed, 11 Dec 2013 09:55:07 +0100 +Subject: [PATCH] virtio_pci: fix level interrupts with irqfd + +RH-Author: Stefan Hajnoczi +Message-id: <1386755707-8033-1-git-send-email-stefanha@redhat.com> +Patchwork-id: 56157 +O-Subject: [RHEL7 qemu-kvm PATCH] virtio_pci: fix level interrupts with irqfd +Bugzilla: 1035132 +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Michael S. Tsirkin +RH-Acked-by: Alex Williamson + +From: "Michael S. Tsirkin" + +BZ: 1035132 +BZ: 1035150 +Brew: https://brewweb.devel.redhat.com/taskinfo?taskID=6700088 +Upstream: merged + +commit 62c96360ae7f2c7a8b029277fbb7cb082fdef7fd + virtio-pci: fix level interrupts +only helps systems without irqfd: on systems with irqfd support we +passed in flag requesting irqfd even when msix is disabled. + +As a result, for level interrupts we didn't install an fd handler so +unmasking an fd had no effect. + +Fix this up. + +Cc: qemu-stable@nongnu.org +Signed-off-by: Michael S. Tsirkin + +(cherry picked from commit 23fe2b3f9e7df8da53ac1bc32c6875254911d7f4) +Signed-off-by: Stefan Hajnoczi +--- + hw/virtio/virtio-pci.c | 3 +-- + 1 file changed, 1 insertion(+), 2 deletions(-) + +Signed-off-by: Michal Novotny +--- + hw/virtio/virtio-pci.c | 3 +-- + 1 file changed, 1 insertion(+), 2 deletions(-) + +diff --git a/hw/virtio/virtio-pci.c b/hw/virtio/virtio-pci.c +index ba8848f..6f5c434 100644 +--- a/hw/virtio/virtio-pci.c ++++ b/hw/virtio/virtio-pci.c +@@ -805,8 +805,7 @@ static int virtio_pci_set_guest_notifiers(DeviceState *d, int nvqs, bool assign) + break; + } + +- r = virtio_pci_set_guest_notifier(d, n, assign, +- kvm_msi_via_irqfd_enabled()); ++ r = virtio_pci_set_guest_notifier(d, n, assign, with_irqfd); + if (r < 0) { + goto assign_error; + } +-- +1.7.11.7 + diff --git a/SOURCES/kvm-vl-Round-memory-sizes-below-2MiB-up-to-2MiB.patch b/SOURCES/kvm-vl-Round-memory-sizes-below-2MiB-up-to-2MiB.patch new file mode 100644 index 0000000..19cb74e --- /dev/null +++ b/SOURCES/kvm-vl-Round-memory-sizes-below-2MiB-up-to-2MiB.patch @@ -0,0 +1,50 @@ +From 2b35241a510c17f731ba0142aa071d7ae24bf55b Mon Sep 17 00:00:00 2001 +From: Markus Armbruster +Date: Thu, 19 Dec 2013 13:32:45 +0100 +Subject: [PATCH 03/16] vl: Round memory sizes below 2MiB up to 2MiB + +RH-Author: Markus Armbruster +Message-id: <1387459965-19517-2-git-send-email-armbru@redhat.com> +Patchwork-id: 56389 +O-Subject: [PATCH 7.0 qemu-kvm 1/1] vl: Round memory sizes below 2MiB up to 2MiB +Bugzilla: 999836 +RH-Acked-by: Laszlo Ersek +RH-Acked-by: Luiz Capitulino +RH-Acked-by: Igor Mammedov + +From: Markus Armbruster + +SeaBIOS requires at least 1MiB of RAM, but doesn't doesn't check for +it. It simply assumes it's there, and crashes when it isn't, often +without any indication what's wrong. No upstream SeaBIOS fix +expected. + +In RHEL-6, we round memory sizes below 2MiB up to 2MiB to protect +SeaBIOS (commit 551c098 and commit b9d6c40). Do the same for RHEL-7. +Not wanted upstream. + +Signed-off-by: Markus Armbruster +--- + vl.c | 1 + + 1 file changed, 1 insertion(+) + +Signed-off-by: Miroslav Rezanina +--- + vl.c | 1 + + 1 files changed, 1 insertions(+), 0 deletions(-) + +diff --git a/vl.c b/vl.c +index b9074c5..781c352 100644 +--- a/vl.c ++++ b/vl.c +@@ -3165,6 +3165,7 @@ int main(int argc, char **argv, char **envp) + exit(1); + } + sz = QEMU_ALIGN_UP((uint64_t)value, 8192); ++ sz = MAX(sz, 2 * 1024 * 1024); + ram_size = sz; + if (ram_size != sz) { + fprintf(stderr, "qemu: ram size too large\n"); +-- +1.7.1 + diff --git a/SOURCES/kvm-vl-make-boot_strict-variable-static-not-used-outside.patch b/SOURCES/kvm-vl-make-boot_strict-variable-static-not-used-outside.patch new file mode 100644 index 0000000..199b809 --- /dev/null +++ b/SOURCES/kvm-vl-make-boot_strict-variable-static-not-used-outside.patch @@ -0,0 +1,44 @@ +From b3528ac97ab6b8f33179ed706f6fb09acf28d06a Mon Sep 17 00:00:00 2001 +From: Amos Kong +Date: Tue, 14 Jan 2014 09:56:40 +0100 +Subject: [PATCH 16/16] vl: make boot_strict variable static (not used outside vl.c) + +RH-Author: Amos Kong +Message-id: <1389693400-21546-3-git-send-email-akong@redhat.com> +Patchwork-id: 56653 +O-Subject: [RHEL-7.0 qemu-kvm PATCH 2/2] vl: make boot_strict variable static (not used outside vl.c) +Bugzilla: 997817 +RH-Acked-by: Laszlo Ersek +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Markus Armbruster + +From: Michael Tokarev + +Signed-off-by: Michael Tokarev +Reviewed-by: Amos Kong +(cherry picked from commit 6f2bfda35cf1c7b8a5913570b808396ab9299873) +--- + vl.c | 2 +- + 1 files changed, 1 insertions(+), 1 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + vl.c | 2 +- + 1 files changed, 1 insertions(+), 1 deletions(-) + +diff --git a/vl.c b/vl.c +index 11899dc..5aea00c 100644 +--- a/vl.c ++++ b/vl.c +@@ -232,7 +232,7 @@ int ctrl_grab = 0; + unsigned int nb_prom_envs = 0; + const char *prom_envs[MAX_PROM_ENVS]; + int boot_menu; +-bool boot_strict; ++static bool boot_strict; + uint8_t *boot_splash_filedata; + size_t boot_splash_filedata_size; + uint8_t qemu_extra_params_fw[2]; +-- +1.7.1 + diff --git a/SOURCES/kvm-vmdk-Allow-read-only-open-of-VMDK-version-3.patch b/SOURCES/kvm-vmdk-Allow-read-only-open-of-VMDK-version-3.patch new file mode 100644 index 0000000..62eef45 --- /dev/null +++ b/SOURCES/kvm-vmdk-Allow-read-only-open-of-VMDK-version-3.patch @@ -0,0 +1,71 @@ +From b42dc567a9071719d730393e717ade1db25c1994 Mon Sep 17 00:00:00 2001 +Message-Id: +In-Reply-To: <58a5fcf24b76c3cf80d671c215b59a0fef76a5c5.1387384437.git.minovotn@redhat.com> +References: <58a5fcf24b76c3cf80d671c215b59a0fef76a5c5.1387384437.git.minovotn@redhat.com> +From: Fam Zheng +Date: Tue, 10 Dec 2013 02:06:52 +0100 +Subject: [PATCH 2/2] vmdk: Allow read only open of VMDK version 3 + +RH-Author: Fam Zheng +Message-id: <1386641212-24945-1-git-send-email-famz@redhat.com> +Patchwork-id: 56099 +O-Subject: [RHEL-7 qemu-kvm PATCH] vmdk: Allow read only open of VMDK version 3 +Bugzilla: 1007710 +RH-Acked-by: Kevin Wolf +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Jeffrey Cody + +Bugzilla: https://bugzilla.redhat.com/show_bug.cgi?id=1029852 +Brew: https://brewweb.devel.redhat.com/taskinfo?taskID=6698629 + +Signed-off-by: Fam Zheng +Signed-off-by: Kevin Wolf +(cherry picked from commit 509d39aa22909c0ed1aabf896865f19c81fb38a1) + +Upstream commit doesn't have a verbose commit message, but as the +comment says, VMware KB 2064959 [1] advises that backup software can +read version=3 as version=1. This is important for virt-v2v and helps in +importing VMware VMs from vSphere, since most of the vSphere exported +OVF/OVA's come with version=3. + +[1]: http://kb.vmware.com/kb/2064959 + +Signed-off-by: Fam Zheng +--- + block/vmdk.c | 9 ++++++++- + 1 file changed, 8 insertions(+), 1 deletion(-) + +Signed-off-by: Michal Novotny +--- + block/vmdk.c | 9 ++++++++- + 1 file changed, 8 insertions(+), 1 deletion(-) + +diff --git a/block/vmdk.c b/block/vmdk.c +index 026b440..7ec6427 100644 +--- a/block/vmdk.c ++++ b/block/vmdk.c +@@ -605,13 +605,20 @@ static int vmdk_open_vmdk4(BlockDriverState *bs, + header = footer.header; + } + +- if (le32_to_cpu(header.version) >= 3) { ++ if (le32_to_cpu(header.version) > 3) { + char buf[64]; + snprintf(buf, sizeof(buf), "VMDK version %d", + le32_to_cpu(header.version)); + qerror_report(QERR_UNKNOWN_BLOCK_FORMAT_FEATURE, + bs->device_name, "vmdk", buf); + return -ENOTSUP; ++ } else if (le32_to_cpu(header.version) == 3 && (flags & BDRV_O_RDWR)) { ++ /* VMware KB 2064959 explains that version 3 added support for ++ * persistent changed block tracking (CBT), and backup software can ++ * read it as version=1 if it doesn't care about the changed area ++ * information. So we are safe to enable read only. */ ++ error_setg(errp, "VMDK version 3 must be read only"); ++ return -EINVAL; + } + + if (le32_to_cpu(header.num_gtes_per_gt) > 512) { +-- +1.7.11.7 + diff --git a/SOURCES/kvm-vpc-Validate-block-size-CVE-2014-0142.patch b/SOURCES/kvm-vpc-Validate-block-size-CVE-2014-0142.patch new file mode 100644 index 0000000..be7ca7f --- /dev/null +++ b/SOURCES/kvm-vpc-Validate-block-size-CVE-2014-0142.patch @@ -0,0 +1,155 @@ +From 94cdf32d7dfbfb12041eb58215e3074525a176b1 Mon Sep 17 00:00:00 2001 +From: Kevin Wolf +Date: Tue, 25 Mar 2014 14:23:23 +0100 +Subject: [PATCH 16/49] vpc: Validate block size (CVE-2014-0142) + +RH-Author: Kevin Wolf +Message-id: <1395753835-7591-17-git-send-email-kwolf@redhat.com> +Patchwork-id: n/a +O-Subject: [virt-devel] [EMBARGOED RHEL-7.0 qemu-kvm PATCH 16/48] vpc: Validate block size (CVE-2014-0142) +Bugzilla: 1079315 +RH-Acked-by: Jeff Cody +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Paolo Bonzini + +Bugzilla: https://bugzilla.redhat.com/show_bug.cgi?id=1079315 +Upstream status: Embargoed + +This fixes some cases of division by zero crashes. + +Signed-off-by: Kevin Wolf + +Conflicts: +tests/qemu-iotests/group + +Signed-off-by: Kevin Wolf +--- + block/vpc.c | 5 +++ + tests/qemu-iotests/088 | 64 ++++++++++++++++++++++++++++++++++++++++++++ + tests/qemu-iotests/088.out | 17 +++++++++++ + tests/qemu-iotests/group | 1 + + 4 files changed, 87 insertions(+), 0 deletions(-) + create mode 100755 tests/qemu-iotests/088 + create mode 100644 tests/qemu-iotests/088.out + +diff --git a/block/vpc.c b/block/vpc.c +index de5bc22..000d1c6 100644 +--- a/block/vpc.c ++++ b/block/vpc.c +@@ -235,6 +235,11 @@ static int vpc_open(BlockDriverState *bs, QDict *options, int flags, + } + + s->block_size = be32_to_cpu(dyndisk_header->block_size); ++ if (!is_power_of_2(s->block_size) || s->block_size < BDRV_SECTOR_SIZE) { ++ error_setg(errp, "Invalid block size %" PRIu32, s->block_size); ++ ret = -EINVAL; ++ goto fail; ++ } + s->bitmap_size = ((s->block_size / (8 * 512)) + 511) & ~511; + + s->max_table_entries = be32_to_cpu(dyndisk_header->max_table_entries); +diff --git a/tests/qemu-iotests/088 b/tests/qemu-iotests/088 +new file mode 100755 +index 0000000..c09adf8 +--- /dev/null ++++ b/tests/qemu-iotests/088 +@@ -0,0 +1,64 @@ ++#!/bin/bash ++# ++# vpc (VHD) format input validation tests ++# ++# Copyright (C) 2014 Red Hat, Inc. ++# ++# This program is free software; you can redistribute it and/or modify ++# it under the terms of the GNU General Public License as published by ++# the Free Software Foundation; either version 2 of the License, or ++# (at your option) any later version. ++# ++# This program is distributed in the hope that it will be useful, ++# but WITHOUT ANY WARRANTY; without even the implied warranty of ++# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++# GNU General Public License for more details. ++# ++# You should have received a copy of the GNU General Public License ++# along with this program. If not, see . ++# ++ ++# creator ++owner=kwolf@redhat.com ++ ++seq=`basename $0` ++echo "QA output created by $seq" ++ ++here=`pwd` ++tmp=/tmp/$$ ++status=1 # failure is the default! ++ ++_cleanup() ++{ ++ rm -f $TEST_IMG.snap ++ _cleanup_test_img ++} ++trap "_cleanup; exit \$status" 0 1 2 3 15 ++ ++# get standard environment, filters and checks ++. ./common.rc ++. ./common.filter ++ ++_supported_fmt vpc ++_supported_proto generic ++_supported_os Linux ++ ++offset_block_size=$((512 + 32)) ++ ++echo ++echo "== Invalid block size ==" ++_make_test_img 64M ++poke_file "$TEST_IMG" "$offset_block_size" "\x00\x00\x00\x00" ++{ $QEMU_IO -c "read 0 512" $TEST_IMG; } 2>&1 | _filter_qemu_io | _filter_testdir ++{ $QEMU_IO -c "write 0 512" $TEST_IMG; } 2>&1 | _filter_qemu_io | _filter_testdir ++poke_file "$TEST_IMG" "$offset_block_size" "\x00\x00\x00\x80" ++{ $QEMU_IO -c "read 0 512" $TEST_IMG; } 2>&1 | _filter_qemu_io | _filter_testdir ++{ $QEMU_IO -c "write 0 512" $TEST_IMG; } 2>&1 | _filter_qemu_io | _filter_testdir ++poke_file "$TEST_IMG" "$offset_block_size" "\x12\x34\x56\x78" ++{ $QEMU_IO -c "read 0 512" $TEST_IMG; } 2>&1 | _filter_qemu_io | _filter_testdir ++{ $QEMU_IO -c "write 0 512" $TEST_IMG; } 2>&1 | _filter_qemu_io | _filter_testdir ++ ++# success, all done ++echo "*** done" ++rm -f $seq.full ++status=0 +diff --git a/tests/qemu-iotests/088.out b/tests/qemu-iotests/088.out +new file mode 100644 +index 0000000..d961609 +--- /dev/null ++++ b/tests/qemu-iotests/088.out +@@ -0,0 +1,17 @@ ++QA output created by 088 ++ ++== Invalid block size == ++Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864 ++qemu-io: can't open device TEST_DIR/t.vpc: Invalid block size 0 ++no file open, try 'help open' ++qemu-io: can't open device TEST_DIR/t.vpc: Invalid block size 0 ++no file open, try 'help open' ++qemu-io: can't open device TEST_DIR/t.vpc: Invalid block size 128 ++no file open, try 'help open' ++qemu-io: can't open device TEST_DIR/t.vpc: Invalid block size 128 ++no file open, try 'help open' ++qemu-io: can't open device TEST_DIR/t.vpc: Invalid block size 305419896 ++no file open, try 'help open' ++qemu-io: can't open device TEST_DIR/t.vpc: Invalid block size 305419896 ++no file open, try 'help open' ++*** done +diff --git a/tests/qemu-iotests/group b/tests/qemu-iotests/group +index 30a0fd8..7d0d07e 100644 +--- a/tests/qemu-iotests/group ++++ b/tests/qemu-iotests/group +@@ -77,3 +77,4 @@ + 079 rw auto + 082 rw auto quick + 086 rw auto quick ++088 rw auto +-- +1.7.1 + diff --git a/SOURCES/kvm-vpc-vhd-add-bounds-check-for-max_table_entries-and-b.patch b/SOURCES/kvm-vpc-vhd-add-bounds-check-for-max_table_entries-and-b.patch new file mode 100644 index 0000000..9cae58b --- /dev/null +++ b/SOURCES/kvm-vpc-vhd-add-bounds-check-for-max_table_entries-and-b.patch @@ -0,0 +1,110 @@ +From 714a0140fd0061b44d63bd538a2d6a7de6f59be6 Mon Sep 17 00:00:00 2001 +From: Jeff Cody +Date: Tue, 25 Mar 2014 14:23:22 +0100 +Subject: [PATCH 15/49] vpc/vhd: add bounds check for max_table_entries and block_size (CVE-2014-0144) + +RH-Author: Kevin Wolf +Message-id: <1395753835-7591-16-git-send-email-kwolf@redhat.com> +Patchwork-id: n/a +O-Subject: [virt-devel] [EMBARGOED RHEL-7.0 qemu-kvm PATCH 15/48] vpc/vhd: add bounds check for max_table_entries and block_size (CVE-2014-0144) +Bugzilla: 1079455 +RH-Acked-by: Jeff Cody +RH-Acked-by: Stefan Hajnoczi +RH-Acked-by: Paolo Bonzini + +From: Jeff Cody + +Bugzilla: https://bugzilla.redhat.com/show_bug.cgi?id=1079455 +Upstream status: Embargoed + +This adds checks to make sure that max_table_entries and block_size +are in sane ranges. Memory is allocated based on max_table_entries, +and block_size is used to calculate indices into that allocated +memory, so if these values are incorrect that can lead to potential +unbounded memory allocation, or invalid memory accesses. + +Also, the allocation of the pagetable is changed from g_malloc0() +to qemu_blockalign(). + +Signed-off-by: Jeff Cody +Signed-off-by: Kevin Wolf +--- + block/vpc.c | 27 +++++++++++++++++++++++---- + 1 files changed, 23 insertions(+), 4 deletions(-) + +diff --git a/block/vpc.c b/block/vpc.c +index 059069f..de5bc22 100644 +--- a/block/vpc.c ++++ b/block/vpc.c +@@ -45,6 +45,8 @@ enum vhd_type { + // Seconds since Jan 1, 2000 0:00:00 (UTC) + #define VHD_TIMESTAMP_BASE 946684800 + ++#define VHD_MAX_SECTORS (65535LL * 255 * 255) ++ + // always big-endian + struct vhd_footer { + char creator[8]; // "conectix" +@@ -164,6 +166,7 @@ static int vpc_open(BlockDriverState *bs, QDict *options, int flags, + struct vhd_dyndisk_header* dyndisk_header; + uint8_t buf[HEADER_SIZE]; + uint32_t checksum; ++ uint64_t computed_size; + int disk_type = VHD_DYNAMIC; + int ret; + +@@ -212,7 +215,7 @@ static int vpc_open(BlockDriverState *bs, QDict *options, int flags, + be16_to_cpu(footer->cyls) * footer->heads * footer->secs_per_cyl; + + /* Allow a maximum disk size of approximately 2 TB */ +- if (bs->total_sectors >= 65535LL * 255 * 255) { ++ if (bs->total_sectors >= VHD_MAX_SECTORS) { + ret = -EFBIG; + goto fail; + } +@@ -235,7 +238,23 @@ static int vpc_open(BlockDriverState *bs, QDict *options, int flags, + s->bitmap_size = ((s->block_size / (8 * 512)) + 511) & ~511; + + s->max_table_entries = be32_to_cpu(dyndisk_header->max_table_entries); +- s->pagetable = g_malloc(s->max_table_entries * 4); ++ ++ if ((bs->total_sectors * 512) / s->block_size > 0xffffffffU) { ++ ret = -EINVAL; ++ goto fail; ++ } ++ if (s->max_table_entries > (VHD_MAX_SECTORS * 512) / s->block_size) { ++ ret = -EINVAL; ++ goto fail; ++ } ++ ++ computed_size = (uint64_t) s->max_table_entries * s->block_size; ++ if (computed_size < bs->total_sectors * 512) { ++ ret = -EINVAL; ++ goto fail; ++ } ++ ++ s->pagetable = qemu_blockalign(bs, s->max_table_entries * 4); + + s->bat_offset = be64_to_cpu(dyndisk_header->table_offset); + +@@ -281,7 +300,7 @@ static int vpc_open(BlockDriverState *bs, QDict *options, int flags, + return 0; + + fail: +- g_free(s->pagetable); ++ qemu_vfree(s->pagetable); + #ifdef CACHE + g_free(s->pageentry_u8); + #endif +@@ -804,7 +823,7 @@ static int vpc_create(const char *filename, QEMUOptionParameter *options, + static void vpc_close(BlockDriverState *bs) + { + BDRVVPCState *s = bs->opaque; +- g_free(s->pagetable); ++ qemu_vfree(s->pagetable); + #ifdef CACHE + g_free(s->pageentry_u8); + #endif +-- +1.7.1 + diff --git a/SOURCES/kvm-vpc-vhdx-add-get_info.patch.patch.patch b/SOURCES/kvm-vpc-vhdx-add-get_info.patch.patch.patch new file mode 100644 index 0000000..e0caf22 --- /dev/null +++ b/SOURCES/kvm-vpc-vhdx-add-get_info.patch.patch.patch @@ -0,0 +1,98 @@ +From ecaad218fdda71c1f64f557b3dff6a09a425b084 Mon Sep 17 00:00:00 2001 +Message-Id: +In-Reply-To: +References: +From: Paolo Bonzini +Date: Mon, 9 Dec 2013 14:09:17 +0100 +Subject: [PATCH 29/50] vpc, vhdx: add get_info + +RH-Author: Paolo Bonzini +Message-id: <1386598178-11845-32-git-send-email-pbonzini@redhat.com> +Patchwork-id: 56068 +O-Subject: [RHEL 7.0 qemu-kvm PATCH 31/52] vpc, vhdx: add get_info +Bugzilla: 1007815 +RH-Acked-by: Jeffrey Cody +RH-Acked-by: Fam Zheng +RH-Acked-by: Stefan Hajnoczi + +Signed-off-by: Paolo Bonzini +Reviewed-by: Peter Lieven +Signed-off-by: Stefan Hajnoczi +(cherry picked from commit 97b00e285119e611f500686f32f9bccffbb9126a) + +Conflicts: + block/vhdx.c [BlockDriver members] + block/vpc.c [VHDFooter vs. struct vhd_footer, BlockDriver members] +--- + block/vhdx.c | 10 ++++++++++ + block/vpc.c | 13 +++++++++++++ + 2 files changed, 23 insertions(+) + +Signed-off-by: Michal Novotny +--- + block/vhdx.c | 10 ++++++++++ + block/vpc.c | 13 +++++++++++++ + 2 files changed, 23 insertions(+) + +diff --git a/block/vhdx.c b/block/vhdx.c +index 6cb0412..7285b95 100644 +--- a/block/vhdx.c ++++ b/block/vhdx.c +@@ -878,6 +878,15 @@ static void vhdx_block_translate(BDRVVHDXState *s, int64_t sector_num, + } + + ++static int vhdx_get_info(BlockDriverState *bs, BlockDriverInfo *bdi) ++{ ++ BDRVVHDXState *s = bs->opaque; ++ ++ bdi->cluster_size = s->block_size; ++ ++ return 0; ++} ++ + + static coroutine_fn int vhdx_co_readv(BlockDriverState *bs, int64_t sector_num, + int nb_sectors, QEMUIOVector *qiov) +@@ -973,6 +982,7 @@ static BlockDriver bdrv_vhdx = { + .bdrv_reopen_prepare = vhdx_reopen_prepare, + .bdrv_co_readv = vhdx_co_readv, + .bdrv_co_writev = vhdx_co_writev, ++ .bdrv_get_info = vhdx_get_info, + }; + + static void bdrv_vhdx_init(void) +diff --git a/block/vpc.c b/block/vpc.c +index 5d65756..49520c1 100644 +--- a/block/vpc.c ++++ b/block/vpc.c +@@ -439,6 +439,18 @@ fail: + return -1; + } + ++static int vpc_get_info(BlockDriverState *bs, BlockDriverInfo *bdi) ++{ ++ BDRVVPCState *s = (BDRVVPCState *)bs->opaque; ++ struct vhd_footer *footer = (struct vhd_footer *) s->footer_buf; ++ ++ if (cpu_to_be32(footer->type) != VHD_FIXED) { ++ bdi->cluster_size = s->block_size; ++ } ++ ++ return 0; ++} ++ + static int vpc_read(BlockDriverState *bs, int64_t sector_num, + uint8_t *buf, int nb_sectors) + { +@@ -830,6 +842,7 @@ static BlockDriver bdrv_vpc = { + .bdrv_write = vpc_co_write, + + .create_options = vpc_create_options, ++ .bdrv_get_info = vpc_get_info, + }; + + static void bdrv_vpc_init(void) +-- +1.7.11.7 + diff --git a/SOURCES/kvm-vvfat-use-bdrv_new-to-allocate-BlockDriverState.patch b/SOURCES/kvm-vvfat-use-bdrv_new-to-allocate-BlockDriverState.patch new file mode 100644 index 0000000..50a8a9f --- /dev/null +++ b/SOURCES/kvm-vvfat-use-bdrv_new-to-allocate-BlockDriverState.patch @@ -0,0 +1,46 @@ +From e02cdc5fccb977bde5162af586a8cc4dcaf7c5f4 Mon Sep 17 00:00:00 2001 +From: Fam Zheng +Date: Fri, 17 Jan 2014 03:07:46 +0100 +Subject: [PATCH 03/34] vvfat: use bdrv_new() to allocate BlockDriverState + +RH-Author: Fam Zheng +Message-id: <1389928083-8921-2-git-send-email-famz@redhat.com> +Patchwork-id: 56763 +O-Subject: [RHEL-7 qemu-kvm PATCH 01/18] vvfat: use bdrv_new() to allocate BlockDriverState +Bugzilla: 1041301 +RH-Acked-by: Jeffrey Cody +RH-Acked-by: Kevin Wolf +RH-Acked-by: Stefan Hajnoczi + +we need bdrv_new() to properly initialize BDS, don't allocate memory +manually. + +Signed-off-by: Fam Zheng +Signed-off-by: Stefan Hajnoczi +(cherry picked from commit 3d34c6cd99f434126365150c2535bbf93b94f891) +Signed-off-by: Fam Zheng +--- + block/vvfat.c | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +Signed-off-by: Miroslav Rezanina +--- + block/vvfat.c | 2 +- + 1 files changed, 1 insertions(+), 1 deletions(-) + +diff --git a/block/vvfat.c b/block/vvfat.c +index cb45687..2c7970d 100644 +--- a/block/vvfat.c ++++ b/block/vvfat.c +@@ -2951,7 +2951,7 @@ static int enable_write_target(BDRVVVFATState *s) + unlink(s->qcow_filename); + #endif + +- s->bs->backing_hd = calloc(sizeof(BlockDriverState), 1); ++ s->bs->backing_hd = bdrv_new(""); + s->bs->backing_hd->drv = &vvfat_write_target; + s->bs->backing_hd->opaque = g_malloc(sizeof(void*)); + *(void**)s->bs->backing_hd->opaque = s; +-- +1.7.1 + diff --git a/SOURCES/kvm-xen_disk-simplify-blk_disconnect-with-refcnt.patch b/SOURCES/kvm-xen_disk-simplify-blk_disconnect-with-refcnt.patch new file mode 100644 index 0000000..debfbef --- /dev/null +++ b/SOURCES/kvm-xen_disk-simplify-blk_disconnect-with-refcnt.patch @@ -0,0 +1,70 @@ +From e81a83acac1f44ade1e28879203ca95466dad805 Mon Sep 17 00:00:00 2001 +From: Fam Zheng +Date: Fri, 17 Jan 2014 03:07:50 +0100 +Subject: [PATCH 07/34] xen_disk: simplify blk_disconnect with refcnt + +RH-Author: Fam Zheng +Message-id: <1389928083-8921-6-git-send-email-famz@redhat.com> +Patchwork-id: 56767 +O-Subject: [RHEL-7 qemu-kvm PATCH 05/18] xen_disk: simplify blk_disconnect with refcnt +Bugzilla: 1041301 +RH-Acked-by: Jeffrey Cody +RH-Acked-by: Kevin Wolf +RH-Acked-by: Stefan Hajnoczi + +We call bdrv_attach_dev when initializing whether or not bs is created +locally, so call bdrv_detach_dev and let the refcnt handle the +lifecycle. + +Signed-off-by: Fam Zheng +Signed-off-by: Stefan Hajnoczi +(cherry picked from commit c0777fe18b08c3a6de0c53325d6b9b75ebb9de9a) +Signed-off-by: Fam Zheng + +Conflicts: + hw/block/xen_disk.c + +Contextual conflict because of backport of 4f8a066b. + +Signed-off-by: Fam Zheng +--- + hw/block/xen_disk.c | 11 +++++------ + 1 file changed, 5 insertions(+), 6 deletions(-) + +Signed-off-by: Miroslav Rezanina +--- + hw/block/xen_disk.c | 11 +++++------ + 1 files changed, 5 insertions(+), 6 deletions(-) + +diff --git a/hw/block/xen_disk.c b/hw/block/xen_disk.c +index 138ab94..a2653b2 100644 +--- a/hw/block/xen_disk.c ++++ b/hw/block/xen_disk.c +@@ -822,6 +822,9 @@ static int blk_connect(struct XenDevice *xendev) + blkdev->bs = NULL; + return -1; + } ++ /* blkdev->bs is not create by us, we get a reference ++ * so we can bdrv_unref() unconditionally */ ++ bdrv_ref(blkdev->bs); + } + bdrv_attach_dev_nofail(blkdev->bs, blkdev); + blkdev->file_size = bdrv_getlength(blkdev->bs); +@@ -920,12 +923,8 @@ static void blk_disconnect(struct XenDevice *xendev) + struct XenBlkDev *blkdev = container_of(xendev, struct XenBlkDev, xendev); + + if (blkdev->bs) { +- if (!blkdev->dinfo) { +- /* close/delete only if we created it ourself */ +- bdrv_close(blkdev->bs); +- bdrv_detach_dev(blkdev->bs, blkdev); +- bdrv_unref(blkdev->bs); +- } ++ bdrv_detach_dev(blkdev->bs, blkdev); ++ bdrv_unref(blkdev->bs); + blkdev->bs = NULL; + } + xen_be_unbind_evtchn(&blkdev->xendev); +-- +1.7.1 + diff --git a/SOURCES/kvm-xhci-add-support-for-suspend-resume.patch b/SOURCES/kvm-xhci-add-support-for-suspend-resume.patch new file mode 100644 index 0000000..94a8408 --- /dev/null +++ b/SOURCES/kvm-xhci-add-support-for-suspend-resume.patch @@ -0,0 +1,62 @@ +From 1d59e428d7754c0fc331092d265254a0b3473546 Mon Sep 17 00:00:00 2001 +From: Gerd Hoffmann +Date: Wed, 11 Dec 2013 10:04:22 +0100 +Subject: [PATCH 1/5] xhci: add support for suspend/resume + +RH-Author: Gerd Hoffmann +Message-id: <1386756262-29763-2-git-send-email-kraxel@redhat.com> +Patchwork-id: 56161 +O-Subject: [RHEL-7 qemu-kvm PATCH 1/1] xhci: add support for suspend/resume +Bugzilla: 1012365 +RH-Acked-by: Laszlo Ersek +RH-Acked-by: Paolo Bonzini +RH-Acked-by: Miroslav Rezanina + +The OS can ask the xhci controller to save and restore its +internal state, which is used by the OS when the system is +suspended and resumed. + +This patch handles writes to the save + restore bits in the +command register. Only thing it does is updating the +restore error bit in the status register to signal an error +on restore. The guest OS should do a full reinitialization +after resume then. + +This is the minimal patch which gets S3 going with xhci. +Implementing full save/restore support is TBD. + +https://bugzilla.redhat.com/show_bug.cgi?id=1012365 + +Signed-off-by: Gerd Hoffmann +(cherry picked from commit f1f8bc218a422081f36f0b325b3de5e6a5078b74) +--- + hw/usb/hcd-xhci.c | 8 ++++++++ + 1 file changed, 8 insertions(+) + +Signed-off-by: Miroslav Rezanina +--- + hw/usb/hcd-xhci.c | 8 ++++++++ + 1 files changed, 8 insertions(+), 0 deletions(-) + +diff --git a/hw/usb/hcd-xhci.c b/hw/usb/hcd-xhci.c +index 9d7315f..87ba7af 100644 +--- a/hw/usb/hcd-xhci.c ++++ b/hw/usb/hcd-xhci.c +@@ -2976,6 +2976,14 @@ static void xhci_oper_write(void *ptr, hwaddr reg, + } else if (!(val & USBCMD_RS) && (xhci->usbcmd & USBCMD_RS)) { + xhci_stop(xhci); + } ++ if (val & USBCMD_CSS) { ++ /* save state */ ++ xhci->usbsts &= ~USBSTS_SRE; ++ } ++ if (val & USBCMD_CRS) { ++ /* restore state */ ++ xhci->usbsts |= USBSTS_SRE; ++ } + xhci->usbcmd = val & 0xc0f; + xhci_mfwrap_update(xhci); + if (val & USBCMD_HCRST) { +-- +1.7.1 + diff --git a/SPECS/qemu-kvm.spec b/SPECS/qemu-kvm.spec index dad5c30..1b063d7 100644 --- a/SPECS/qemu-kvm.spec +++ b/SPECS/qemu-kvm.spec @@ -18,6 +18,10 @@ %global have_usbredir 0 %endif +%ifnarch s390 s390x + %global have_librdma 1 +%endif + %ifnarch x86_64 %global build_only_sub 1 %global debug_package %{nil} @@ -70,7 +74,7 @@ Obsoletes: %1 < %{obsoletes_version} \ Summary: QEMU is a FAST! processor emulator Name: %{pkgname}%{?pkgsuffix} Version: 1.5.3 -Release: 19%{?dist} +Release: 60%{?dist} # Epoch because we pushed a qemu-1.0 package. AIUI this can't ever be dropped Epoch: 10 License: GPLv2+ and LGPLv2+ and BSD @@ -80,7 +84,7 @@ URL: http://www.qemu.org/ %if %{rhev} ExclusiveArch: x86_64 %endif -Requires: seabios-bin +Requires: seabios-bin >= 1.7.2.2-5 Requires: sgabios-bin Requires: seavgabios-bin Requires: ipxe-roms-qemu @@ -118,6 +122,9 @@ Source14: rhel6-virtio.rom Source15: rhel6-pcnet.rom Source16: rhel6-rtl8139.rom Source17: rhel6-ne2k_pci.rom +Source18: bios-256k.bin +Source19: README.rhel6-gpxe-source +Source20: rhel6-e1000.rom # libcacard build fixes (heading upstream) Patch1: 0000-libcacard-fix-missing-symbols-in-libcacard.so.patch @@ -1027,6 +1034,1176 @@ Patch485: kvm-qapi-qapi-visit.py-native-list-support.patch Patch486: kvm-qapi-enable-generation-of-native-list-code.patch # For bz#848203 - MAC Programming for virtio over macvtap - qemu-kvm support Patch487: kvm-net-add-support-of-mac-programming-over-macvtap-in-Q.patch +# For bz#1029539 - Machine type rhel6.1.0 and balloon device cause migration fail from RHEL6.5 host to RHEL7.0 host +Patch488: kvm-pc-drop-virtio-balloon-pci-event_idx-compat-property.patch +# For bz#922463 - qemu-kvm core dump when virtio-net multi queue guest hot-unpluging vNIC +Patch489: kvm-virtio-net-only-delete-bh-that-existed.patch +# For bz#1029370 - [whql][netkvm][wlk] Virtio-net device handles RX multicast filtering improperly +Patch490: kvm-virtio-net-broken-RX-filtering-logic-fixed.patch +# For bz#1025138 - Read/Randread/Randrw performance regression +Patch491: kvm-block-Avoid-unecessary-drv-bdrv_getlength-calls.patch +# For bz#1025138 - Read/Randread/Randrw performance regression +Patch492: kvm-block-Round-up-total_sectors.patch +# For bz#1016952 - qemu-kvm man page guide wrong path for qemu-bridge-helper +Patch493: kvm-doc-fix-hardcoded-helper-path.patch +# For bz#971933 - QMP: add RHEL's vendor extension prefix +Patch494: kvm-introduce-RFQDN_REDHAT-RHEL-6-7-fwd.patch +# For bz#971938 - QMP: Add error reason to BLOCK_IO_ERROR event +Patch495: kvm-error-reason-in-BLOCK_IO_ERROR-BLOCK_JOB_ERROR-event.patch +# For bz#895041 - QMP: forward port I/O error debug messages +Patch496: kvm-improve-debuggability-of-BLOCK_IO_ERROR-BLOCK_JOB_ER.patch +# For bz#1029275 - Guest only find one 82576 VF(function 0) while use multifunction +Patch497: kvm-vfio-pci-Fix-multifunction-on.patch +# For bz#1026739 - qcow2: Switch to compat=1.1 default for new images +Patch498: kvm-qcow2-Change-default-for-new-images-to-compat-1.1.patch +# For bz#1026739 - qcow2: Switch to compat=1.1 default for new images +Patch499: kvm-qcow2-change-default-for-new-images-to-compat-1.1-pa.patch +# For bz#1032862 - virtio-rng-egd: repeatedly read same random data-block w/o considering the buffer offset +Patch500: kvm-rng-egd-offset-the-point-when-repeatedly-read-from-t.patch +# For bz#1007334 - CVE-2013-4344 qemu-kvm: qemu: buffer overflow in scsi_target_emulate_report_luns [rhel-7.0] +Patch501: kvm-scsi-Allocate-SCSITargetReq-r-buf-dynamically-CVE-20.patch +# For bz#1033810 - memory leak in using object_get_canonical_path() +Patch502: kvm-virtio-net-fix-the-memory-leak-in-rxfilter_notify.patch +# For bz#1033810 - memory leak in using object_get_canonical_path() +Patch503: kvm-qom-Fix-memory-leak-in-object_property_set_link.patch +# For bz#1036537 - Cross version migration from RHEL6.5 host to RHEL7.0 host with sound device failed. +Patch504: kvm-fix-intel-hda-live-migration.patch +# For bz#1029743 - qemu-kvm core dump after hot plug/unplug 82576 PF about 100 times +Patch505: kvm-vfio-pci-Release-all-MSI-X-vectors-when-disabled.patch +# For bz#921490 - qemu-kvm core dumped after hot plugging more than 11 VF through vfio-pci +Patch506: kvm-Query-KVM-for-available-memory-slots.patch +# For bz#1039501 - [provisioning] discard=on broken +Patch507: kvm-block-Dont-ignore-previously-set-bdrv_flags.patch +# For bz#997832 - Backport trace fixes proactively to avoid confusion and silly conflicts +Patch508: kvm-cleanup-trace-events.pl-New.patch +# For bz#997832 - Backport trace fixes proactively to avoid confusion and silly conflicts +Patch509: kvm-slavio_misc-Fix-slavio_led_mem_readw-_writew-tracepo.patch +# For bz#997832 - Backport trace fixes proactively to avoid confusion and silly conflicts +Patch510: kvm-milkymist-minimac2-Fix-minimac2_read-_write-tracepoi.patch +# For bz#997832 - Backport trace fixes proactively to avoid confusion and silly conflicts +Patch511: kvm-trace-events-Drop-unused-events.patch +# For bz#997832 - Backport trace fixes proactively to avoid confusion and silly conflicts +Patch512: kvm-trace-events-Fix-up-source-file-comments.patch +# For bz#997832 - Backport trace fixes proactively to avoid confusion and silly conflicts +Patch513: kvm-trace-events-Clean-up-with-scripts-cleanup-trace-eve.patch +# For bz#997832 - Backport trace fixes proactively to avoid confusion and silly conflicts +Patch514: kvm-trace-events-Clean-up-after-removal-of-old-usb-host-.patch +# For bz#1027571 - [virtio-win]win8.1 guest network can not resume automatically after do "set_link tap1 on" +Patch515: kvm-net-Update-netdev-peer-on-link-change.patch +# For bz#1003773 - When virtio-blk-pci device with dataplane is failed to be added, the drive cannot be released. +Patch516: kvm-qdev-monitor-Unref-device-when-device_add-fails.patch +# For bz#1003773 - When virtio-blk-pci device with dataplane is failed to be added, the drive cannot be released. +Patch517: kvm-qdev-Drop-misleading-qdev_free-function.patch +# For bz#1003773 - When virtio-blk-pci device with dataplane is failed to be added, the drive cannot be released. +Patch518: kvm-blockdev-fix-drive_init-opts-and-bs_opts-leaks.patch +# For bz#1003773 - When virtio-blk-pci device with dataplane is failed to be added, the drive cannot be released. +Patch519: kvm-libqtest-rename-qmp-to-qmp_discard_response.patch +# For bz#1003773 - When virtio-blk-pci device with dataplane is failed to be added, the drive cannot be released. +Patch520: kvm-libqtest-add-qmp-fmt-.-QDict-function.patch +# For bz#1003773 - When virtio-blk-pci device with dataplane is failed to be added, the drive cannot be released. +Patch521: kvm-blockdev-test-add-test-case-for-drive_add-duplicate-.patch +# For bz#1003773 - When virtio-blk-pci device with dataplane is failed to be added, the drive cannot be released. +Patch522: kvm-qdev-monitor-test-add-device_add-leak-test-cases.patch +# For bz#1003773 - When virtio-blk-pci device with dataplane is failed to be added, the drive cannot be released. +Patch523: kvm-qtest-Use-display-none-by-default.patch +# For bz#1034876 - export acpi tables to guests +Patch524: kvm-range-add-Range-structure.patch +# For bz#1034876 - export acpi tables to guests +Patch525: kvm-range-add-Range-to-typedefs.patch +# For bz#1034876 - export acpi tables to guests +Patch526: kvm-range-add-min-max-operations-on-ranges.patch +# For bz#1034876 - export acpi tables to guests +Patch527: kvm-qdev-Add-SIZE-type-to-qdev-properties.patch +# For bz#1034876 - export acpi tables to guests +Patch528: kvm-qapi-make-visit_type_size-fallback-to-type_int.patch +# For bz#1034876 - export acpi tables to guests +Patch529: kvm-pc-move-IO_APIC_DEFAULT_ADDRESS-to-include-hw-i386-i.patch +# For bz#1034876 - export acpi tables to guests +Patch530: kvm-pci-add-helper-to-retrieve-the-64-bit-range.patch +# For bz#1034876 - export acpi tables to guests +Patch531: kvm-pci-fix-up-w64-size-calculation-helper.patch +# For bz#1034876 - export acpi tables to guests +Patch532: kvm-refer-to-FWCfgState-explicitly.patch +# For bz#1034876 - export acpi tables to guests +Patch533: kvm-fw_cfg-move-typedef-to-qemu-typedefs.h.patch +# For bz#1034876 - export acpi tables to guests +Patch534: kvm-arch_init-align-MR-size-to-target-page-size.patch +# For bz#1034876 - export acpi tables to guests +Patch535: kvm-loader-store-FW-CFG-ROM-files-in-RAM.patch +# For bz#1034876 - export acpi tables to guests +Patch536: kvm-pci-store-PCI-hole-ranges-in-guestinfo-structure.patch +# For bz#1034876 - export acpi tables to guests +Patch537: kvm-pc-pass-PCI-hole-ranges-to-Guests.patch +# For bz#1034876 - export acpi tables to guests +Patch538: kvm-pc-replace-i440fx_common_init-with-i440fx_init.patch +# For bz#1034876 - export acpi tables to guests +Patch539: kvm-pc-don-t-access-fw-cfg-if-NULL.patch +# For bz#1034876 - export acpi tables to guests +Patch540: kvm-pc-add-I440FX-QOM-cast-macro.patch +# For bz#1034876 - export acpi tables to guests +Patch541: kvm-pc-limit-64-bit-hole-to-2G-by-default.patch +# For bz#1034876 - export acpi tables to guests +Patch542: kvm-q35-make-pci-window-address-size-match-guest-cfg.patch +# For bz#1034876 - export acpi tables to guests +Patch543: kvm-q35-use-64-bit-window-programmed-by-guest.patch +# For bz#1034876 - export acpi tables to guests +Patch544: kvm-piix-use-64-bit-window-programmed-by-guest.patch +# For bz#1034876 - export acpi tables to guests +Patch545: kvm-pc-fix-regression-for-64-bit-PCI-memory.patch +# For bz#1034876 - export acpi tables to guests +Patch546: kvm-cleanup-object.h-include-error.h-directly.patch +# For bz#1034876 - export acpi tables to guests +Patch547: kvm-qom-cleanup-struct-Error-references.patch +# For bz#1034876 - export acpi tables to guests +Patch548: kvm-qom-add-pointer-to-int-property-helpers.patch +# For bz#1034876 - export acpi tables to guests +Patch549: kvm-fw_cfg-interface-to-trigger-callback-on-read.patch +# For bz#1034876 - export acpi tables to guests +Patch550: kvm-loader-support-for-unmapped-ROM-blobs.patch +# For bz#1034876 - export acpi tables to guests +Patch551: kvm-pcie_host-expose-UNMAPPED-macro.patch +# For bz#1034876 - export acpi tables to guests +Patch552: kvm-pcie_host-expose-address-format.patch +# For bz#1034876 - export acpi tables to guests +Patch553: kvm-q35-use-macro-for-MCFG-property-name.patch +# For bz#1034876 - export acpi tables to guests +Patch554: kvm-q35-expose-mmcfg-size-as-a-property.patch +# For bz#1034876 - export acpi tables to guests +Patch555: kvm-i386-add-ACPI-table-files-from-seabios.patch +# For bz#1034876 - export acpi tables to guests +Patch556: kvm-acpi-add-rules-to-compile-ASL-source.patch +# For bz#1034876 - export acpi tables to guests +Patch557: kvm-acpi-pre-compiled-ASL-files.patch +# For bz#1034876 - export acpi tables to guests +Patch558: kvm-acpi-ssdt-pcihp-updat-generated-file.patch +# For bz#1034876 - export acpi tables to guests +Patch559: kvm-loader-use-file-path-size-from-fw_cfg.h.patch +# For bz#1034876 - export acpi tables to guests +Patch560: kvm-i386-add-bios-linker-loader.patch +# For bz#1034876 - export acpi tables to guests +Patch561: kvm-loader-allow-adding-ROMs-in-done-callbacks.patch +# For bz#1034876 - export acpi tables to guests +Patch562: kvm-i386-define-pc-guest-info.patch +# For bz#1034876 - export acpi tables to guests +Patch563: kvm-acpi-piix-add-macros-for-acpi-property-names.patch +# For bz#1034876 - export acpi tables to guests +Patch564: kvm-piix-APIs-for-pc-guest-info.patch +# For bz#1034876 - export acpi tables to guests +Patch565: kvm-ich9-APIs-for-pc-guest-info.patch +# For bz#1034876 - export acpi tables to guests +Patch566: kvm-pvpanic-add-API-to-access-io-port.patch +# For bz#1034876 - export acpi tables to guests +Patch567: kvm-hpet-add-API-to-find-it.patch +# For bz#1034876 - export acpi tables to guests +Patch568: kvm-hpet-fix-build-with-CONFIG_HPET-off.patch +# For bz#1034876 - export acpi tables to guests +Patch569: kvm-acpi-add-interface-to-access-user-installed-tables.patch +# For bz#1034876 - export acpi tables to guests +Patch570: kvm-pc-use-new-api-to-add-builtin-tables.patch +# For bz#1034876 - export acpi tables to guests +Patch571: kvm-i386-ACPI-table-generation-code-from-seabios.patch +# For bz#1034876 - export acpi tables to guests +Patch572: kvm-ssdt-fix-PBLK-length.patch +# For bz#1034876 - export acpi tables to guests +Patch573: kvm-ssdt-proc-update-generated-file.patch +# For bz#1034876 - export acpi tables to guests +Patch574: kvm-pc-disable-pci-info.patch +# For bz#1034876 - export acpi tables to guests +Patch575: kvm-acpi-build-fix-build-on-glib-2.22.patch +# For bz#1034876 - export acpi tables to guests +Patch576: kvm-acpi-build-fix-build-on-glib-2.14.patch +# For bz#1034876 - export acpi tables to guests +Patch577: kvm-acpi-build-fix-support-for-glib-2.22.patch +# For bz#1034876 - export acpi tables to guests +Patch578: kvm-acpi-build-Fix-compiler-warning-missing-gnu_printf-f.patch +# For bz#1034876 - export acpi tables to guests +Patch579: kvm-exec-Fix-prototype-of-phys_mem_set_alloc-and-related.patch +# For bz#1034876 - export acpi tables to guests +Patch580: kvm-hw-i386-Makefile.obj-use-PYTHON-to-run-.py-scripts-c.patch +# For bz#1026314 +Patch581: kvm-seccomp-add-kill-to-the-syscall-whitelist.patch +Patch582: kvm-json-parser-fix-handling-of-large-whole-number-value.patch +Patch583: kvm-qapi-add-QMP-input-test-for-large-integers.patch +Patch584: kvm-qapi-fix-visitor-serialization-tests-for-numbers-dou.patch +Patch585: kvm-qapi-add-native-list-coverage-for-visitor-serializat.patch +Patch586: kvm-qapi-add-native-list-coverage-for-QMP-output-visitor.patch +Patch587: kvm-qapi-add-native-list-coverage-for-QMP-input-visitor-.patch +Patch588: kvm-qapi-lack-of-two-commas-in-dict.patch +Patch589: kvm-tests-QAPI-schema-parser-tests.patch +Patch590: kvm-tests-Use-qapi-schema-test.json-as-schema-parser-tes.patch +Patch591: kvm-qapi.py-Restructure-lexer-and-parser.patch +Patch592: kvm-qapi.py-Decent-syntax-error-reporting.patch +Patch593: kvm-qapi.py-Reject-invalid-characters-in-schema-file.patch +Patch594: kvm-qapi.py-Fix-schema-parser-to-check-syntax-systematic.patch +Patch595: kvm-qapi.py-Fix-diagnosing-non-objects-at-a-schema-s-top.patch +Patch596: kvm-qapi.py-Rename-expr_eval-to-expr-in-parse_schema.patch +Patch597: kvm-qapi.py-Permit-comments-starting-anywhere-on-the-lin.patch +Patch598: kvm-scripts-qapi.py-Avoid-syntax-not-supported-by-Python.patch +Patch599: kvm-tests-Fix-schema-parser-test-for-in-tree-build.patch +# For bz#1011720 - [HP 7.0 Feat]: Backport RDMA based live guest migration changes from upstream to RHEL7.0 KVM +Patch600: kvm-add-a-header-file-for-atomic-operations.patch +# For bz#1011720 - [HP 7.0 Feat]: Backport RDMA based live guest migration changes from upstream to RHEL7.0 KVM +Patch601: kvm-savevm-Fix-potential-memory-leak.patch +# For bz#1011720 - [HP 7.0 Feat]: Backport RDMA based live guest migration changes from upstream to RHEL7.0 KVM +Patch602: kvm-migration-Fail-migration-on-bdrv_flush_all-error.patch +# For bz#1011720 - [HP 7.0 Feat]: Backport RDMA based live guest migration changes from upstream to RHEL7.0 KVM +Patch603: kvm-rdma-add-documentation.patch +# For bz#1011720 - [HP 7.0 Feat]: Backport RDMA based live guest migration changes from upstream to RHEL7.0 KVM +Patch604: kvm-rdma-introduce-qemu_update_position.patch +# For bz#1011720 - [HP 7.0 Feat]: Backport RDMA based live guest migration changes from upstream to RHEL7.0 KVM +Patch605: kvm-rdma-export-yield_until_fd_readable.patch +# For bz#1011720 - [HP 7.0 Feat]: Backport RDMA based live guest migration changes from upstream to RHEL7.0 KVM +Patch606: kvm-rdma-export-throughput-w-MigrationStats-QMP.patch +# For bz#1011720 - [HP 7.0 Feat]: Backport RDMA based live guest migration changes from upstream to RHEL7.0 KVM +Patch607: kvm-rdma-introduce-qemu_file_mode_is_not_valid.patch +# For bz#1011720 - [HP 7.0 Feat]: Backport RDMA based live guest migration changes from upstream to RHEL7.0 KVM +Patch608: kvm-rdma-introduce-qemu_ram_foreach_block.patch +# For bz#1011720 - [HP 7.0 Feat]: Backport RDMA based live guest migration changes from upstream to RHEL7.0 KVM +Patch609: kvm-rdma-new-QEMUFileOps-hooks.patch +# For bz#1011720 - [HP 7.0 Feat]: Backport RDMA based live guest migration changes from upstream to RHEL7.0 KVM +Patch610: kvm-rdma-introduce-capability-x-rdma-pin-all.patch +# For bz#1011720 - [HP 7.0 Feat]: Backport RDMA based live guest migration changes from upstream to RHEL7.0 KVM +Patch611: kvm-rdma-update-documentation-to-reflect-new-unpin-suppo.patch +# For bz#1011720 - [HP 7.0 Feat]: Backport RDMA based live guest migration changes from upstream to RHEL7.0 KVM +Patch612: kvm-rdma-bugfix-ram_control_save_page.patch +# For bz#1011720 - [HP 7.0 Feat]: Backport RDMA based live guest migration changes from upstream to RHEL7.0 KVM +Patch613: kvm-rdma-introduce-ram_handle_compressed.patch +# For bz#1011720 - [HP 7.0 Feat]: Backport RDMA based live guest migration changes from upstream to RHEL7.0 KVM +Patch614: kvm-rdma-core-logic.patch +# For bz#1011720 - [HP 7.0 Feat]: Backport RDMA based live guest migration changes from upstream to RHEL7.0 KVM +Patch615: kvm-rdma-send-pc.ram.patch +# For bz#1011720 - [HP 7.0 Feat]: Backport RDMA based live guest migration changes from upstream to RHEL7.0 KVM +Patch616: kvm-rdma-allow-state-transitions-between-other-states-be.patch +# For bz#1011720 - [HP 7.0 Feat]: Backport RDMA based live guest migration changes from upstream to RHEL7.0 KVM +Patch617: kvm-rdma-introduce-MIG_STATE_NONE-and-change-MIG_STATE_S.patch +# For bz#1011720 - [HP 7.0 Feat]: Backport RDMA based live guest migration changes from upstream to RHEL7.0 KVM +Patch618: kvm-rdma-account-for-the-time-spent-in-MIG_STATE_SETUP-t.patch +# For bz#1011720 - [HP 7.0 Feat]: Backport RDMA based live guest migration changes from upstream to RHEL7.0 KVM +Patch619: kvm-rdma-bugfix-make-IPv6-support-work.patch +# For bz#1011720 - [HP 7.0 Feat]: Backport RDMA based live guest migration changes from upstream to RHEL7.0 KVM +Patch620: kvm-rdma-forgot-to-turn-off-the-debugging-flag.patch +# For bz#1011720 - [HP 7.0 Feat]: Backport RDMA based live guest migration changes from upstream to RHEL7.0 KVM +Patch621: kvm-rdma-correct-newlines-in-error-statements.patch +# For bz#1011720 - [HP 7.0 Feat]: Backport RDMA based live guest migration changes from upstream to RHEL7.0 KVM +Patch622: kvm-rdma-don-t-use-negative-index-to-array.patch +# For bz#1011720 - [HP 7.0 Feat]: Backport RDMA based live guest migration changes from upstream to RHEL7.0 KVM +Patch623: kvm-rdma-qemu_rdma_post_send_control-uses-wrongly-RDMA_W.patch +# For bz#1011720 - [HP 7.0 Feat]: Backport RDMA based live guest migration changes from upstream to RHEL7.0 KVM +Patch624: kvm-rdma-use-DRMA_WRID_READY.patch +# For bz#1011720 - [HP 7.0 Feat]: Backport RDMA based live guest migration changes from upstream to RHEL7.0 KVM +Patch625: kvm-rdma-memory-leak-RDMAContext-host.patch +# For bz#1011720 - [HP 7.0 Feat]: Backport RDMA based live guest migration changes from upstream to RHEL7.0 KVM +Patch626: kvm-rdma-use-resp.len-after-validation-in-qemu_rdma_regi.patch +# For bz#1011720 - [HP 7.0 Feat]: Backport RDMA based live guest migration changes from upstream to RHEL7.0 KVM +Patch627: kvm-rdma-validate-RDMAControlHeader-len.patch +# For bz#1011720 - [HP 7.0 Feat]: Backport RDMA based live guest migration changes from upstream to RHEL7.0 KVM +Patch628: kvm-rdma-check-if-RDMAControlHeader-len-match-transferre.patch +# For bz#1011720 - [HP 7.0 Feat]: Backport RDMA based live guest migration changes from upstream to RHEL7.0 KVM +Patch629: kvm-rdma-proper-getaddrinfo-handling.patch +# For bz#1011720 - [HP 7.0 Feat]: Backport RDMA based live guest migration changes from upstream to RHEL7.0 KVM +Patch630: kvm-rdma-IPv6-over-Ethernet-RoCE-is-broken-in-linux-work.patch +# For bz#1011720 - [HP 7.0 Feat]: Backport RDMA based live guest migration changes from upstream to RHEL7.0 KVM +Patch631: kvm-rdma-remaining-documentation-fixes.patch +# For bz#1011720 - [HP 7.0 Feat]: Backport RDMA based live guest migration changes from upstream to RHEL7.0 KVM +Patch632: kvm-rdma-silly-ipv6-bugfix.patch +# For bz#1011720 - [HP 7.0 Feat]: Backport RDMA based live guest migration changes from upstream to RHEL7.0 KVM +Patch633: kvm-savevm-fix-wrong-initialization-by-ram_control_load_.patch +# For bz#1011720 - [HP 7.0 Feat]: Backport RDMA based live guest migration changes from upstream to RHEL7.0 KVM +Patch634: kvm-arch_init-right-return-for-ram_save_iterate.patch +# For bz#1011720 - [HP 7.0 Feat]: Backport RDMA based live guest migration changes from upstream to RHEL7.0 KVM +Patch635: kvm-rdma-clean-up-of-qemu_rdma_cleanup.patch +# For bz#1011720 - [HP 7.0 Feat]: Backport RDMA based live guest migration changes from upstream to RHEL7.0 KVM +Patch636: kvm-rdma-constify-ram_chunk_-index-start-end.patch +# For bz#1011720 - [HP 7.0 Feat]: Backport RDMA based live guest migration changes from upstream to RHEL7.0 KVM +Patch637: kvm-migration-Fix-debug-print-type.patch +# For bz#1011720 - [HP 7.0 Feat]: Backport RDMA based live guest migration changes from upstream to RHEL7.0 KVM +Patch638: kvm-arch_init-make-is_zero_page-accept-size.patch +# For bz#1011720 - [HP 7.0 Feat]: Backport RDMA based live guest migration changes from upstream to RHEL7.0 KVM +Patch639: kvm-migration-ram_handle_compressed.patch +# For bz#1011720 - [HP 7.0 Feat]: Backport RDMA based live guest migration changes from upstream to RHEL7.0 KVM +Patch640: kvm-migration-fix-spice-migration.patch +# For bz#678368 - RFE: Support more than 8 assigned devices +Patch641: kvm-pci-assign-cap-number-of-devices-that-can-be-assigne.patch +# For bz#678368 - RFE: Support more than 8 assigned devices +Patch642: kvm-vfio-cap-number-of-devices-that-can-be-assigned.patch +# For bz#1039513 - backport remote wakeup for ehci +Patch643: kvm-Revert-usb-tablet-Don-t-claim-wakeup-capability-for-.patch +# For bz#1026554 - qemu: mempath: prefault pages manually +Patch644: kvm-mempath-prefault-pages-manually-v4.patch +# For bz#1007710 - [RFE] Enable qemu-img to support VMDK version 3 +# For bz#1029852 - qemu-img fails to convert vmdk image with "qemu-img: Could not open 'image.vmdk'" +Patch645: kvm-vmdk-Allow-read-only-open-of-VMDK-version-3.patch +# For bz#1035132 - fail to boot and call trace with x-data-plane=on specified for rhel6.5 guest +Patch646: kvm-virtio_pci-fix-level-interrupts-with-irqfd.patch +# For bz#889051 - Commands "__com.redhat_drive_add/del" don' t exist in RHEL7.0 +Patch647: kvm-QMP-Forward-port-__com.redhat_drive_del-from-RHEL-6.patch +# For bz#889051 - Commands "__com.redhat_drive_add/del" don' t exist in RHEL7.0 +Patch648: kvm-QMP-Forward-port-__com.redhat_drive_add-from-RHEL-6.patch +# For bz#889051 - Commands "__com.redhat_drive_add/del" don' t exist in RHEL7.0 +Patch649: kvm-HMP-Forward-port-__com.redhat_drive_add-from-RHEL-6.patch +# For bz#889051 - Commands "__com.redhat_drive_add/del" don' t exist in RHEL7.0 +Patch650: kvm-QMP-Document-throttling-parameters-of-__com.redhat_d.patch +# For bz#889051 - Commands "__com.redhat_drive_add/del" don' t exist in RHEL7.0 +Patch651: kvm-HMP-Disable-drive_add-for-Red-Hat-Enterprise-Linux.patch +Patch652: kvm-Revert-HMP-Disable-drive_add-for-Red-Hat-Enterprise-2.patch.patch +# For bz#1007815 - fix WRITE SAME support +Patch653: kvm-block-change-default-of-.has_zero_init-to-0.patch.patch +# For bz#1007815 - fix WRITE SAME support +Patch654: kvm-iscsi-factor-out-sector-conversions.patch.patch +# For bz#1007815 - fix WRITE SAME support +Patch655: kvm-iscsi-add-logical-block-provisioning-information-to-.patch.patch +# For bz#1007815 - fix WRITE SAME support +Patch656: kvm-iscsi-add-.bdrv_get_block_status.patch.patch.patch +# For bz#1007815 - fix WRITE SAME support +Patch657: kvm-iscsi-split-discard-requests-in-multiple-parts.patch.patch.patch +# For bz#1007815 - fix WRITE SAME support +Patch658: kvm-block-make-BdrvRequestFlags-public.patch.patch.patch +# For bz#1007815 - fix WRITE SAME support +Patch659: kvm-block-add-flags-to-bdrv_-_write_zeroes.patch.patch.patch +# For bz#1007815 - fix WRITE SAME support +Patch660: kvm-block-introduce-BDRV_REQ_MAY_UNMAP-request-flag.patch.patch.patch +# For bz#1007815 - fix WRITE SAME support +Patch661: kvm-block-add-logical-block-provisioning-info-to-BlockDr.patch.patch.patch +# For bz#1007815 - fix WRITE SAME support +Patch662: kvm-block-add-wrappers-for-logical-block-provisioning-in.patch.patch.patch +# For bz#1007815 - fix WRITE SAME support +Patch663: kvm-block-iscsi-add-.bdrv_get_info.patch.patch +# For bz#1007815 - fix WRITE SAME support +Patch664: kvm-block-add-BlockLimits-structure-to-BlockDriverState.patch.patch.patch +# For bz#1007815 - fix WRITE SAME support +Patch665: kvm-block-raw-copy-BlockLimits-on-raw_open.patch.patch.patch +# For bz#1007815 - fix WRITE SAME support +Patch666: kvm-block-honour-BlockLimits-in-bdrv_co_do_write_zeroes.patch.patch.patch +# For bz#1007815 - fix WRITE SAME support +Patch667: kvm-block-honour-BlockLimits-in-bdrv_co_discard.patch.patch.patch +# For bz#1007815 - fix WRITE SAME support +Patch668: kvm-iscsi-set-limits-in-BlockDriverState.patch.patch.patch +# For bz#1007815 - fix WRITE SAME support +Patch669: kvm-iscsi-simplify-iscsi_co_discard.patch.patch.patch +# For bz#1007815 - fix WRITE SAME support +Patch670: kvm-iscsi-add-bdrv_co_write_zeroes.patch.patch.patch +# For bz#1007815 - fix WRITE SAME support +Patch671: kvm-block-introduce-bdrv_make_zero.patch.patch.patch +# For bz#1007815 - fix WRITE SAME support +Patch672: kvm-block-get_block_status-fix-BDRV_BLOCK_ZERO-for-unall.patch.patch.patch +# For bz#1007815 - fix WRITE SAME support +Patch673: kvm-qemu-img-add-support-for-fully-allocated-images.patch.patch.patch +# For bz#1007815 - fix WRITE SAME support +Patch674: kvm-qemu-img-conditionally-zero-out-target-on-convert.patch.patch.patch +# For bz#1007815 - fix WRITE SAME support +Patch675: kvm-block-generalize-BlockLimits-handling-to-cover-bdrv_.patch.patch.patch +# For bz#1007815 - fix WRITE SAME support +Patch676: kvm-block-add-flags-to-BlockRequest.patch.patch.patch +# For bz#1007815 - fix WRITE SAME support +Patch677: kvm-block-add-flags-argument-to-bdrv_co_write_zeroes-tra.patch.patch.patch +# For bz#1007815 - fix WRITE SAME support +Patch678: kvm-block-add-bdrv_aio_write_zeroes.patch.patch.patch +# For bz#1007815 - fix WRITE SAME support +Patch679: kvm-block-handle-ENOTSUP-from-discard-in-generic-code.patch.patch.patch +# For bz#1007815 - fix WRITE SAME support +Patch680: kvm-block-make-bdrv_co_do_write_zeroes-stricter-in-produ.patch.patch.patch +# For bz#1007815 - fix WRITE SAME support +Patch681: kvm-vpc-vhdx-add-get_info.patch.patch.patch +# For bz#1007815 - fix WRITE SAME support +Patch682: kvm-block-drivers-add-discard-write_zeroes-properties-to.patch.patch.patch +# For bz#1007815 - fix WRITE SAME support +Patch683: kvm-block-drivers-expose-requirement-for-write-same-alig.patch.patch.patch +# For bz#1007815 - fix WRITE SAME support +Patch684: kvm-block-iscsi-remove-.bdrv_has_zero_init.patch.patch.patch +# For bz#1007815 - fix WRITE SAME support +Patch685: kvm-block-iscsi-updated-copyright.patch.patch.patch +# For bz#1007815 - fix WRITE SAME support +Patch686: kvm-block-iscsi-check-WRITE-SAME-support-differently-dep.patch.patch.patch +# For bz#1007815 - fix WRITE SAME support +Patch687: kvm-scsi-disk-catch-write-protection-errors-in-UNMAP.patch.patch.patch +# For bz#1007815 - fix WRITE SAME support +Patch688: kvm-scsi-disk-reject-ANCHOR-1-for-UNMAP-and-WRITE-SAME-c.patch.patch.patch +# For bz#1007815 - fix WRITE SAME support +Patch689: kvm-scsi-disk-correctly-implement-WRITE-SAME.patch.patch.patch +# For bz#1007815 - fix WRITE SAME support +Patch690: kvm-scsi-disk-fix-WRITE-SAME-with-large-non-zero-payload.patch.patch.patch +# For bz#1007815 - fix WRITE SAME support +Patch691: kvm-raw-posix-implement-write_zeroes-with-MAY_UNMAP-for-.patch.patch.patch.patch +# For bz#1007815 - fix WRITE SAME support +Patch692: kvm-raw-posix-implement-write_zeroes-with-MAY_UNMAP-for-.patch.patch.patch.patch.patch +# For bz#1007815 - fix WRITE SAME support +Patch693: kvm-raw-posix-add-support-for-write_zeroes-on-XFS-and-bl.patch.patch +# For bz#1007815 - fix WRITE SAME support +Patch694: kvm-qemu-iotests-033-is-fast.patch.patch +# For bz#1007815 - fix WRITE SAME support +Patch695: kvm-qemu-img-add-support-for-skipping-zeroes-in-input-du.patch.patch +# For bz#1007815 - fix WRITE SAME support +Patch696: kvm-qemu-img-fix-usage-instruction-for-qemu-img-convert.patch.patch +# For bz#1007815 - fix WRITE SAME support +Patch697: kvm-block-iscsi-set-bdi-cluster_size.patch.patch +# For bz#1039557 - optimize qemu-img for thin provisioned images +Patch698: kvm-block-add-opt_transfer_length-to-BlockLimits.patch.patch +# For bz#1039557 - optimize qemu-img for thin provisioned images +Patch699: kvm-block-iscsi-set-bs-bl.opt_transfer_length.patch.patch +# For bz#1039557 - optimize qemu-img for thin provisioned images +Patch700: kvm-qemu-img-dynamically-adjust-iobuffer-size-during-con.patch.patch +# For bz#1039557 - optimize qemu-img for thin provisioned images +Patch701: kvm-qemu-img-round-down-request-length-to-an-aligned-sec.patch.patch +# For bz#1039557 - optimize qemu-img for thin provisioned images +Patch702: kvm-qemu-img-decrease-progress-update-interval-on-conver.patch.patch +# For bz#879234 - [RFE] qemu-img: Add/improve support for VHDX format +Patch703: kvm-block-qemu-iotests-for-vhdx-read-sample-dynamic-imag.patch +# For bz#879234 - [RFE] qemu-img: Add/improve support for VHDX format +Patch704: kvm-block-qemu-iotests-add-quotes-to-TEST_IMG-usage-io-p.patch +# For bz#879234 - [RFE] qemu-img: Add/improve support for VHDX format +Patch705: kvm-block-qemu-iotests-fix-_make_test_img-to-work-with-s.patch +# For bz#879234 - [RFE] qemu-img: Add/improve support for VHDX format +Patch706: kvm-block-qemu-iotests-add-quotes-to-TEST_IMG.base-usage.patch +# For bz#879234 - [RFE] qemu-img: Add/improve support for VHDX format +Patch707: kvm-block-qemu-iotests-add-quotes-to-TEST_IMG-usage-in-0.patch +# For bz#879234 - [RFE] qemu-img: Add/improve support for VHDX format +Patch708: kvm-block-qemu-iotests-removes-duplicate-double-quotes-i.patch +# For bz#879234 - [RFE] qemu-img: Add/improve support for VHDX format +Patch709: kvm-block-vhdx-minor-comments-and-typo-correction.patch +# For bz#879234 - [RFE] qemu-img: Add/improve support for VHDX format +Patch710: kvm-block-vhdx-add-header-update-capability.patch +# For bz#879234 - [RFE] qemu-img: Add/improve support for VHDX format +Patch711: kvm-block-vhdx-code-movement-VHDXMetadataEntries-and-BDR.patch +# For bz#879234 - [RFE] qemu-img: Add/improve support for VHDX format +Patch712: kvm-block-vhdx-log-support-struct-and-defines.patch +# For bz#879234 - [RFE] qemu-img: Add/improve support for VHDX format +Patch713: kvm-block-vhdx-break-endian-translation-functions-out.patch +# For bz#879234 - [RFE] qemu-img: Add/improve support for VHDX format +Patch714: kvm-block-vhdx-update-log-guid-in-header-and-first-write.patch +# For bz#879234 - [RFE] qemu-img: Add/improve support for VHDX format +Patch715: kvm-block-vhdx-code-movement-move-vhdx_close-above-vhdx_.patch +# For bz#879234 - [RFE] qemu-img: Add/improve support for VHDX format +Patch716: kvm-block-vhdx-log-parsing-replay-and-flush-support.patch +# For bz#879234 - [RFE] qemu-img: Add/improve support for VHDX format +Patch717: kvm-block-vhdx-add-region-overlap-detection-for-image-fi.patch +# For bz#879234 - [RFE] qemu-img: Add/improve support for VHDX format +Patch718: kvm-block-vhdx-add-log-write-support.patch +# For bz#879234 - [RFE] qemu-img: Add/improve support for VHDX format +Patch719: kvm-block-vhdx-write-support.patch +# For bz#879234 - [RFE] qemu-img: Add/improve support for VHDX format +Patch720: kvm-block-vhdx-remove-BAT-file-offset-bit-shifting.patch +# For bz#879234 - [RFE] qemu-img: Add/improve support for VHDX format +Patch721: kvm-block-vhdx-move-more-endian-translations-to-vhdx-end.patch +# For bz#879234 - [RFE] qemu-img: Add/improve support for VHDX format +Patch722: kvm-block-vhdx-break-out-code-operations-to-functions.patch +# For bz#879234 - [RFE] qemu-img: Add/improve support for VHDX format +Patch723: kvm-block-vhdx-fix-comment-typos-in-header-fix-incorrect.patch +# For bz#879234 - [RFE] qemu-img: Add/improve support for VHDX format +Patch724: kvm-block-vhdx-add-.bdrv_create-support.patch +# For bz#879234 - [RFE] qemu-img: Add/improve support for VHDX format +Patch725: kvm-block-vhdx-update-_make_test_img-to-filter-out-vhdx-.patch +# For bz#879234 - [RFE] qemu-img: Add/improve support for VHDX format +Patch726: kvm-block-qemu-iotests-for-vhdx-add-write-test-support.patch +# For bz#879234 - [RFE] qemu-img: Add/improve support for VHDX format +Patch727: kvm-block-vhdx-qemu-iotest-log-replay-of-data-sector.patch +# For bz#965636 - streaming with no backing file should not do anything +Patch728: kvm-block-stream-Don-t-stream-unbacked-devices.patch +# For bz#1004347 - Backport qcow2 corruption prevention patches +Patch729: kvm-qemu-io-Let-open-pass-options-to-block-driver.patch +# For bz#1004347 - Backport qcow2 corruption prevention patches +Patch730: kvm-qcow2.py-Subcommand-for-changing-header-fields.patch +# For bz#1004347 - Backport qcow2 corruption prevention patches +Patch731: kvm-qemu-iotests-Remaining-error-propagation-adjustments.patch +# For bz#1004347 - Backport qcow2 corruption prevention patches +Patch732: kvm-qemu-iotests-Add-test-for-inactive-L2-overlap.patch +# For bz#1004347 - Backport qcow2 corruption prevention patches +Patch733: kvm-qemu-iotests-Adjust-test-result-039.patch +# For bz#1048671 - virtio-net: mac_table change isn't recovered in error state +Patch734: kvm-virtio-net-don-t-update-mac_table-in-error-state.patch +# For bz#1032904 - qemu-img can not create libiscsi qcow2_v3 image +Patch735: kvm-qcow2-Zero-initialise-first-cluster-for-new-images.patch +# For bz#1033490 - Cannot upgrade/downgrade qcow2 images +Patch736: kvm-option-Add-assigned-flag-to-QEMUOptionParameter.patch +# For bz#1033490 - Cannot upgrade/downgrade qcow2 images +Patch737: kvm-qcow2-refcount-Snapshot-update-for-zero-clusters.patch +# For bz#1033490 - Cannot upgrade/downgrade qcow2 images +Patch738: kvm-qemu-iotests-Snapshotting-zero-clusters.patch +# For bz#1033490 - Cannot upgrade/downgrade qcow2 images +Patch739: kvm-block-Image-file-option-amendment.patch +# For bz#1033490 - Cannot upgrade/downgrade qcow2 images +Patch740: kvm-qcow2-cache-Empty-cache.patch +# For bz#1033490 - Cannot upgrade/downgrade qcow2 images +Patch741: kvm-qcow2-cluster-Expand-zero-clusters.patch +# For bz#1033490 - Cannot upgrade/downgrade qcow2 images +Patch742: kvm-qcow2-Save-refcount-order-in-BDRVQcowState.patch +# For bz#1033490 - Cannot upgrade/downgrade qcow2 images +Patch743: kvm-qcow2-Implement-bdrv_amend_options.patch +# For bz#1033490 - Cannot upgrade/downgrade qcow2 images +Patch744: kvm-qcow2-Correct-bitmap-size-in-zero-expansion.patch +# For bz#1033490 - Cannot upgrade/downgrade qcow2 images +Patch745: kvm-qcow2-Free-only-newly-allocated-clusters-on-error.patch +# For bz#1033490 - Cannot upgrade/downgrade qcow2 images +Patch746: kvm-qcow2-Add-missing-space-in-error-message.patch +# For bz#1033490 - Cannot upgrade/downgrade qcow2 images +Patch747: kvm-qemu-iotest-qcow2-image-option-amendment.patch +# For bz#1033490 - Cannot upgrade/downgrade qcow2 images +Patch748: kvm-qemu-iotests-New-test-case-in-061.patch +# For bz#1033490 - Cannot upgrade/downgrade qcow2 images +Patch749: kvm-qemu-iotests-Preallocated-zero-clusters-in-061.patch +# For bz#972773 - RHEL7: Clarify support statement in KVM help +Patch750: kvm-Add-support-statement-to-help-output.patch +# For bz#903910 - RHEL7 does not have equivalent functionality for __com.redhat_qxl_screendump +Patch751: kvm-__com.redhat_qxl_screendump-add-docs.patch +# For bz#999836 - -m 1 crashes +Patch752: kvm-vl-Round-memory-sizes-below-2MiB-up-to-2MiB.patch +# For bz#1044845 - QEMU seccomp sandbox - exit if seccomp_init() fails +Patch753: kvm-seccomp-exit-if-seccomp_init-fails.patch +# For bz#1034876 - export acpi tables to guests +Patch754: kvm-configure-make-iasl-option-actually-work.patch +# For bz#1034876 - export acpi tables to guests +Patch755: kvm-acpi-build-disable-with-no-acpi.patch +# For bz#1039513 - backport remote wakeup for ehci +Patch756: kvm-ehci-implement-port-wakeup.patch +# For bz#1026712 - Qemu core dumpd when boot guest with driver name as "virtio-pci" +# For bz#1046007 - qemu-kvm aborted when hot plug PCI device to guest with romfile and rombar=0 +Patch757: kvm-qdev-monitor-Fix-crash-when-device_add-is-called-wit.patch +# For bz#1035001 - VHDX: journal log should not be replayed by default, but rather via qemu-img check -r all +Patch758: kvm-block-vhdx-improve-error-message-and-.bdrv_check-imp.patch +# For bz#1017650 - need to update qemu-img man pages on "VHDX" format +Patch759: kvm-docs-updated-qemu-img-man-page-and-qemu-doc-to-refle.patch +# For bz#1052340 - pvticketlocks: default on +Patch760: kvm-enable-pvticketlocks-by-default.patch +# For bz#997817 - -boot order and -boot once regressed since RHEL-6 +Patch761: kvm-fix-boot-strict-regressed-in-commit-6ef4716.patch +# For bz#997817 - -boot order and -boot once regressed since RHEL-6 +Patch762: kvm-vl-make-boot_strict-variable-static-not-used-outside.patch +# For bz#997559 - Improve live migration bitmap handling +Patch763: kvm-bitmap-use-long-as-index.patch +# For bz#997559 - Improve live migration bitmap handling +Patch764: kvm-memory-cpu_physical_memory_set_dirty_flags-result-is.patch +# For bz#997559 - Improve live migration bitmap handling +Patch765: kvm-memory-cpu_physical_memory_set_dirty_range-return-vo.patch +# For bz#997559 - Improve live migration bitmap handling +Patch766: kvm-exec-use-accessor-function-to-know-if-memory-is-dirt.patch +# For bz#997559 - Improve live migration bitmap handling +Patch767: kvm-memory-create-function-to-set-a-single-dirty-bit.patch +# For bz#997559 - Improve live migration bitmap handling +Patch768: kvm-exec-drop-useless-if.patch +# For bz#997559 - Improve live migration bitmap handling +Patch769: kvm-exec-create-function-to-get-a-single-dirty-bit.patch +# For bz#997559 - Improve live migration bitmap handling +Patch770: kvm-memory-make-cpu_physical_memory_is_dirty-return-bool.patch +# For bz#997559 - Improve live migration bitmap handling +Patch771: kvm-memory-all-users-of-cpu_physical_memory_get_dirty-us.patch +# For bz#997559 - Improve live migration bitmap handling +Patch772: kvm-memory-set-single-dirty-flags-when-possible.patch +# For bz#997559 - Improve live migration bitmap handling +Patch773: kvm-memory-cpu_physical_memory_set_dirty_range-always-di.patch +# For bz#997559 - Improve live migration bitmap handling +Patch774: kvm-memory-cpu_physical_memory_mask_dirty_range-always-c.patch +# For bz#997559 - Improve live migration bitmap handling +Patch775: kvm-memory-use-bit-2-for-migration.patch +# For bz#997559 - Improve live migration bitmap handling +Patch776: kvm-memory-make-sure-that-client-is-always-inside-range.patch +# For bz#997559 - Improve live migration bitmap handling +Patch777: kvm-memory-only-resize-dirty-bitmap-when-memory-size-inc.patch +# For bz#997559 - Improve live migration bitmap handling +Patch778: kvm-memory-cpu_physical_memory_clear_dirty_flag-result-i.patch +# For bz#997559 - Improve live migration bitmap handling +Patch779: kvm-bitmap-Add-bitmap_zero_extend-operation.patch +# For bz#997559 - Improve live migration bitmap handling +Patch780: kvm-memory-split-dirty-bitmap-into-three.patch +# For bz#997559 - Improve live migration bitmap handling +Patch781: kvm-memory-unfold-cpu_physical_memory_clear_dirty_flag-i.patch +# For bz#997559 - Improve live migration bitmap handling +Patch782: kvm-memory-unfold-cpu_physical_memory_set_dirty-in-its-o.patch +# For bz#997559 - Improve live migration bitmap handling +Patch783: kvm-memory-unfold-cpu_physical_memory_set_dirty_flag.patch +# For bz#997559 - Improve live migration bitmap handling +Patch784: kvm-memory-make-cpu_physical_memory_get_dirty-the-main-f.patch +# For bz#997559 - Improve live migration bitmap handling +Patch785: kvm-memory-cpu_physical_memory_get_dirty-is-used-as-retu.patch +# For bz#997559 - Improve live migration bitmap handling +Patch786: kvm-memory-s-mask-clear-cpu_physical_memory_mask_dirty_r.patch +# For bz#997559 - Improve live migration bitmap handling +Patch787: kvm-memory-use-find_next_bit-to-find-dirty-bits.patch +# For bz#997559 - Improve live migration bitmap handling +Patch788: kvm-memory-cpu_physical_memory_set_dirty_range-now-uses-.patch +# For bz#997559 - Improve live migration bitmap handling +Patch789: kvm-memory-cpu_physical_memory_clear_dirty_range-now-use.patch +# For bz#997559 - Improve live migration bitmap handling +Patch790: kvm-memory-s-dirty-clean-in-cpu_physical_memory_is_dirty.patch +# For bz#997559 - Improve live migration bitmap handling +Patch791: kvm-memory-make-cpu_physical_memory_reset_dirty-take-a-l.patch +# For bz#997559 - Improve live migration bitmap handling +Patch792: kvm-exec-Remove-unused-global-variable-phys_ram_fd.patch +# For bz#997559 - Improve live migration bitmap handling +Patch793: kvm-memory-cpu_physical_memory_set_dirty_tracking-should.patch +# For bz#997559 - Improve live migration bitmap handling +Patch794: kvm-memory-move-private-types-to-exec.c.patch +# For bz#997559 - Improve live migration bitmap handling +Patch795: kvm-memory-split-cpu_physical_memory_-functions-to-its-o.patch +# For bz#997559 - Improve live migration bitmap handling +Patch796: kvm-memory-unfold-memory_region_test_and_clear.patch +# For bz#997559 - Improve live migration bitmap handling +Patch797: kvm-use-directly-cpu_physical_memory_-api-for-tracki.patch +# For bz#997559 - Improve live migration bitmap handling +Patch798: kvm-refactor-start-address-calculation.patch +# For bz#997559 - Improve live migration bitmap handling +Patch799: kvm-memory-move-bitmap-synchronization-to-its-own-functi.patch +# For bz#997559 - Improve live migration bitmap handling +Patch800: kvm-memory-syncronize-kvm-bitmap-using-bitmaps-operation.patch +# For bz#997559 - Improve live migration bitmap handling +Patch801: kvm-ram-split-function-that-synchronizes-a-range.patch +# For bz#997559 - Improve live migration bitmap handling +Patch802: kvm-migration-synchronize-memory-bitmap-64bits-at-a-time.patch +# For bz#947785 - In rhel6.4 guest sound recorder doesn't work when playing audio +Patch803: kvm-intel-hda-fix-position-buffer.patch +# For bz#1003467 - Backport migration fixes from post qemu 1.6 +Patch804: kvm-The-calculation-of-bytes_xfer-in-qemu_put_buffer-is-.patch +# For bz#1003467 - Backport migration fixes from post qemu 1.6 +Patch805: kvm-migration-Fix-rate-limit.patch +# For bz#1017636 - PATCH: fix qemu using 50% host cpu when audio is playing +Patch806: kvm-audio-honor-QEMU_AUDIO_TIMER_PERIOD-instead-of-wakin.patch +# For bz#1017636 - PATCH: fix qemu using 50% host cpu when audio is playing +Patch807: kvm-audio-Lower-default-wakeup-rate-to-100-times-second.patch +# For bz#1017636 - PATCH: fix qemu using 50% host cpu when audio is playing +Patch808: kvm-audio-adjust-pulse-to-100Hz-wakeup-rate.patch +# For bz#918907 - provide backwards-compatible RHEL specific machine types in QEMU - CPU features +Patch809: kvm-pc-Fix-rhel6.-3dnow-3dnowext-compat-bits.patch +# For bz#1038603 - make seabios 256k for rhel7 machine types +Patch810: kvm-add-firmware-to-machine-options.patch +# For bz#1038603 - make seabios 256k for rhel7 machine types +Patch811: kvm-switch-rhel7-machine-types-to-big-bios.patch +# For bz#1034518 - boot order wrong with q35 +Patch812: kvm-pci-fix-pci-bridge-fw-path.patch +# For bz#1031098 - Disable device smbus-eeprom +Patch813: kvm-hw-cannot_instantiate_with_device_add_yet-due-to-poi.patch +# For bz#1031098 - Disable device smbus-eeprom +Patch814: kvm-qdev-Document-that-pointer-properties-kill-device_ad.patch +# For bz#1044742 - Cannot create guest on remote RHEL7 host using F20 virt-manager, libvirt's qemu -no-hpet detection is broken +Patch815: kvm-Add-back-no-hpet-but-ignore-it.patch +# For bz#669524 - Confusing error message from -device +Patch816: kvm-Revert-qdev-monitor-Fix-crash-when-device_add-is-cal.patch +# For bz#669524 - Confusing error message from -device +Patch817: kvm-Revert-qdev-Do-not-let-the-user-try-to-device_add-wh.patch +# For bz#669524 - Confusing error message from -device +Patch818: kvm-qdev-monitor-Clean-up-qdev_device_add-variable-namin.patch +# For bz#669524 - Confusing error message from -device +Patch819: kvm-qdev-monitor-Fix-crash-when-device_add-is-called.2.patch.patch +# For bz#669524 - Confusing error message from -device +Patch820: kvm-qdev-monitor-Avoid-qdev-as-variable-name.patch +# For bz#669524 - Confusing error message from -device +Patch821: kvm-qdev-monitor-Inline-qdev_init-for-device_add.patch +# For bz#669524 - Confusing error message from -device +Patch822: kvm-qdev-Do-not-let-the-user-try-to-device_add-when-it.2.patch.patch +# For bz#669524 - Confusing error message from -device +Patch823: kvm-qdev-monitor-Avoid-device_add-crashing-on-non-device.patch +# For bz#669524 - Confusing error message from -device +Patch824: kvm-qdev-monitor-Improve-error-message-for-device-nonexi.patch +# For bz#1003535 - qemu-kvm core dump when boot vm with more than 32 virtio disks/nics +Patch825: kvm-exec-change-well-known-physical-sections-to-macros.patch +# For bz#1003535 - qemu-kvm core dump when boot vm with more than 32 virtio disks/nics +Patch826: kvm-exec-separate-sections-and-nodes-per-address-space.patch +# For bz#1053699 - Backport Cancelled race condition fixes +Patch827: kvm-avoid-a-bogus-COMPLETED-CANCELLED-transition.patch +# For bz#1053699 - Backport Cancelled race condition fixes +Patch828: kvm-introduce-MIG_STATE_CANCELLING-state.patch +# For bz#1041301 - live snapshot merge (commit) of the active layer +Patch829: kvm-vvfat-use-bdrv_new-to-allocate-BlockDriverState.patch +# For bz#1041301 - live snapshot merge (commit) of the active layer +Patch830: kvm-block-implement-reference-count-for-BlockDriverState.patch +# For bz#1041301 - live snapshot merge (commit) of the active layer +Patch831: kvm-block-make-bdrv_delete-static.patch +# For bz#1041301 - live snapshot merge (commit) of the active layer +Patch832: kvm-migration-omit-drive-ref-as-we-have-bdrv_ref-now.patch +# For bz#1041301 - live snapshot merge (commit) of the active layer +Patch833: kvm-xen_disk-simplify-blk_disconnect-with-refcnt.patch +# For bz#1041301 - live snapshot merge (commit) of the active layer +Patch834: kvm-nbd-use-BlockDriverState-refcnt.patch +# For bz#1041301 - live snapshot merge (commit) of the active layer +Patch835: kvm-block-use-BDS-ref-for-block-jobs.patch +# For bz#1041301 - live snapshot merge (commit) of the active layer +Patch836: kvm-block-Make-BlockJobTypes-const.patch +# For bz#1041301 - live snapshot merge (commit) of the active layer +Patch837: kvm-blockjob-rename-BlockJobType-to-BlockJobDriver.patch +# For bz#1041301 - live snapshot merge (commit) of the active layer +Patch838: kvm-qapi-Introduce-enum-BlockJobType.patch +# For bz#1041301 - live snapshot merge (commit) of the active layer +Patch839: kvm-qapi-make-use-of-new-BlockJobType.patch +# For bz#1041301 - live snapshot merge (commit) of the active layer +Patch840: kvm-mirror-Don-t-close-target.patch +# For bz#1041301 - live snapshot merge (commit) of the active layer +Patch841: kvm-mirror-Move-base-to-MirrorBlockJob.patch +# For bz#1041301 - live snapshot merge (commit) of the active layer +Patch842: kvm-block-Add-commit_active_start.patch +# For bz#1041301 - live snapshot merge (commit) of the active layer +Patch843: kvm-commit-Support-commit-active-layer.patch +# For bz#1041301 - live snapshot merge (commit) of the active layer +Patch844: kvm-qemu-iotests-prefill-some-data-to-test-image.patch +# For bz#1041301 - live snapshot merge (commit) of the active layer +Patch845: kvm-qemu-iotests-Update-test-cases-for-commit-active.patch +# For bz#1041301 - live snapshot merge (commit) of the active layer +Patch846: kvm-commit-Remove-unused-check.patch +# For bz#921890 - Core dump when block mirror with "sync" is "none" and mode is "absolute-paths" +Patch847: kvm-blockdev-use-bdrv_getlength-in-qmp_drive_mirror.patch +# For bz#921890 - Core dump when block mirror with "sync" is "none" and mode is "absolute-paths" +Patch848: kvm-qemu-iotests-make-assert_no_active_block_jobs-common.patch +# For bz#921890 - Core dump when block mirror with "sync" is "none" and mode is "absolute-paths" +Patch849: kvm-block-drive-mirror-Check-for-NULL-backing_hd.patch +# For bz#921890 - Core dump when block mirror with "sync" is "none" and mode is "absolute-paths" +Patch850: kvm-qemu-iotests-Extend-041-for-unbacked-mirroring.patch +# For bz#921890 - Core dump when block mirror with "sync" is "none" and mode is "absolute-paths" +Patch851: kvm-qapi-schema-Update-description-for-NewImageMode.patch +# For bz#921890 - Core dump when block mirror with "sync" is "none" and mode is "absolute-paths" +Patch852: kvm-block-drive-mirror-Reuse-backing-HD-for-sync-none.patch +# For bz#921890 - Core dump when block mirror with "sync" is "none" and mode is "absolute-paths" +Patch853: kvm-qemu-iotests-Fix-test-041.patch +# For bz#1035644 - rhel7.0host + windows guest + virtio-win + 'chkdsk' in the guest gives qemu assertion in scsi_dma_complete +Patch854: kvm-scsi-bus-fix-transfer-length-and-direction-for-VERIF.patch +# For bz#1035644 - rhel7.0host + windows guest + virtio-win + 'chkdsk' in the guest gives qemu assertion in scsi_dma_complete +Patch855: kvm-scsi-disk-fix-VERIFY-emulation.patch +# For bz#1041301 - live snapshot merge (commit) of the active layer +Patch856: kvm-block-ensure-bdrv_drain_all-works-during-bdrv_delete.patch +# For bz#998708 - qemu-kvm: maximum vcpu should be recommended maximum +Patch857: kvm-use-recommended-max-vcpu-count.patch +# For bz#1049706 - MIss CPUID_EXT_X2APIC in Westmere cpu model +Patch858: kvm-pc-Create-pc_compat_rhel-functions.patch +# For bz#1049706 - MIss CPUID_EXT_X2APIC in Westmere cpu model +Patch859: kvm-pc-Enable-x2apic-by-default-on-more-recent-CPU-model.patch +# For bz#1019221 - Iscsi miss id sub-option in help output +Patch860: kvm-help-add-id-suboption-to-iscsi.patch +# For bz#1037503 - fix thin provisioning support for block device backends +Patch861: kvm-scsi-disk-add-UNMAP-limits-to-block-limits-VPD-page.patch +# For bz#1034876 - export acpi tables to guests +Patch862: kvm-qdev-Fix-32-bit-compilation-in-print_size.patch +# For bz#1034876 - export acpi tables to guests +Patch863: kvm-qdev-Use-clz-in-print_size.patch +# For bz#1026548 - i386: pc: align gpa<->hpa on 1GB boundary +Patch864: kvm-piix-gigabyte-alignment-for-ram.patch +# For bz#1026548 - i386: pc: align gpa<->hpa on 1GB boundary +Patch865: kvm-pc_piix-document-gigabyte_align.patch +# For bz#1026548 - i386: pc: align gpa<->hpa on 1GB boundary +Patch866: kvm-q35-gigabyle-alignment-for-ram.patch +# For bz#983344 - QEMU core dump and host will reboot when do hot-unplug a virtio-blk disk which use the switch behind switch +Patch867: kvm-virtio-bus-remove-vdev-field.patch +# For bz#983344 - QEMU core dump and host will reboot when do hot-unplug a virtio-blk disk which use the switch behind switch +Patch868: kvm-virtio-pci-remove-vdev-field.patch +# For bz#983344 - QEMU core dump and host will reboot when do hot-unplug a virtio-blk disk which use the switch behind switch +Patch869: kvm-virtio-bus-cleanup-plug-unplug-interface.patch +# For bz#983344 - QEMU core dump and host will reboot when do hot-unplug a virtio-blk disk which use the switch behind switch +Patch870: kvm-virtio-blk-switch-exit-callback-to-VirtioDeviceClass.patch +# For bz#983344 - QEMU core dump and host will reboot when do hot-unplug a virtio-blk disk which use the switch behind switch +Patch871: kvm-virtio-serial-switch-exit-callback-to-VirtioDeviceCl.patch +# For bz#983344 - QEMU core dump and host will reboot when do hot-unplug a virtio-blk disk which use the switch behind switch +Patch872: kvm-virtio-net-switch-exit-callback-to-VirtioDeviceClass.patch +# For bz#983344 - QEMU core dump and host will reboot when do hot-unplug a virtio-blk disk which use the switch behind switch +Patch873: kvm-virtio-scsi-switch-exit-callback-to-VirtioDeviceClas.patch +# For bz#983344 - QEMU core dump and host will reboot when do hot-unplug a virtio-blk disk which use the switch behind switch +Patch874: kvm-virtio-balloon-switch-exit-callback-to-VirtioDeviceC.patch +# For bz#983344 - QEMU core dump and host will reboot when do hot-unplug a virtio-blk disk which use the switch behind switch +Patch875: kvm-virtio-rng-switch-exit-callback-to-VirtioDeviceClass.patch +# For bz#983344 - QEMU core dump and host will reboot when do hot-unplug a virtio-blk disk which use the switch behind switch +Patch876: kvm-virtio-pci-add-device_unplugged-callback.patch +# For bz#1051438 - Error message contains garbled characters when unable to open image due to bad permissions (permission denied). +Patch877: kvm-block-use-correct-filename-for-error-report.patch +# For bz#1032346 - basic OVMF support (non-volatile UEFI variables in flash, and fixup for ACPI tables) +Patch878: kvm-Partially-revert-rhel-Drop-cfi.pflash01-and-isa-ide-.patch +# For bz#1032346 - basic OVMF support (non-volatile UEFI variables in flash, and fixup for ACPI tables) +Patch879: kvm-Revert-pc-Disable-the-use-flash-device-for-BIOS-unle.patch +# For bz#1032346 - basic OVMF support (non-volatile UEFI variables in flash, and fixup for ACPI tables) +Patch880: kvm-memory-Replace-open-coded-memory_region_is_romd.patch +# For bz#1032346 - basic OVMF support (non-volatile UEFI variables in flash, and fixup for ACPI tables) +Patch881: kvm-memory-Rename-readable-flag-to-romd_mode.patch +# For bz#1032346 - basic OVMF support (non-volatile UEFI variables in flash, and fixup for ACPI tables) +Patch882: kvm-isapc-Fix-non-KVM-qemu-boot-read-write-memory-for-is.patch +# For bz#1032346 - basic OVMF support (non-volatile UEFI variables in flash, and fixup for ACPI tables) +Patch883: kvm-add-kvm_readonly_mem_enabled.patch +# For bz#1032346 - basic OVMF support (non-volatile UEFI variables in flash, and fixup for ACPI tables) +Patch884: kvm-support-using-KVM_MEM_READONLY-flag-for-regions.patch +# For bz#1032346 - basic OVMF support (non-volatile UEFI variables in flash, and fixup for ACPI tables) +Patch885: kvm-pc_sysfw-allow-flash-pflash-memory-to-be-used-with-K.patch +# For bz#1032346 - basic OVMF support (non-volatile UEFI variables in flash, and fixup for ACPI tables) +Patch886: kvm-fix-double-free-the-memslot-in-kvm_set_phys_mem.patch +# For bz#1032346 - basic OVMF support (non-volatile UEFI variables in flash, and fixup for ACPI tables) +Patch887: kvm-sysfw-remove-read-only-pc_sysfw_flash_vs_rom_bug_com.patch +# For bz#1032346 - basic OVMF support (non-volatile UEFI variables in flash, and fixup for ACPI tables) +Patch888: kvm-pc_sysfw-remove-the-rom_only-property.patch +# For bz#1032346 - basic OVMF support (non-volatile UEFI variables in flash, and fixup for ACPI tables) +Patch889: kvm-pc_sysfw-do-not-make-it-a-device-anymore.patch +# For bz#1032346 - basic OVMF support (non-volatile UEFI variables in flash, and fixup for ACPI tables) +Patch890: kvm-hw-i386-pc_sysfw-support-two-flash-drives.patch +# For bz#1032346 - basic OVMF support (non-volatile UEFI variables in flash, and fixup for ACPI tables) +Patch891: kvm-i440fx-test-qtest_start-should-be-paired-with-qtest_.patch +# For bz#1032346 - basic OVMF support (non-volatile UEFI variables in flash, and fixup for ACPI tables) +Patch892: kvm-i440fx-test-give-each-GTest-case-its-own-qtest.patch +# For bz#1032346 - basic OVMF support (non-volatile UEFI variables in flash, and fixup for ACPI tables) +Patch893: kvm-i440fx-test-generate-temporary-firmware-blob.patch +# For bz#1032346 - basic OVMF support (non-volatile UEFI variables in flash, and fixup for ACPI tables) +Patch894: kvm-i440fx-test-verify-firmware-under-4G-and-1M-both-bio.patch +# For bz#1032346 - basic OVMF support (non-volatile UEFI variables in flash, and fixup for ACPI tables) +Patch895: kvm-piix-fix-32bit-pci-hole.patch +# For bz#1041564 - [NFR] qemu: Returning the watermark for all the images opened for writing +Patch896: kvm-qapi-Add-backing-to-BlockStats.patch +# For bz#918907 - provide backwards-compatible RHEL specific machine types in QEMU - CPU features +Patch897: kvm-pc-Disable-RDTSCP-unconditionally-on-rhel6.-machine-.patch +# For bz#1056428 - "rdtscp" flag defined on Opteron_G5 model and cann't be exposed to guest +# For bz#874400 - "rdtscp" flag defined on Opteron_G5 model and cann't be exposed to guest +Patch898: kvm-pc-Disable-RDTSCP-on-AMD-CPU-models.patch +# For bz#1030301 - qemu-img can not merge live snapshot to backing file(r/w backing file via libiscsi) +Patch899: kvm-block-add-.bdrv_reopen_prepare-stub-for-iscsi.patch +# For bz#1044815 - vfio initfn succeeds even if IOMMU mappings fail +Patch900: kvm-vfio-pci-Fail-initfn-on-DMA-mapping-errors.patch +# For bz#1052030 - src qemu-kvm core dump after hotplug/unhotplug GPU device and do local migration +Patch901: kvm-vfio-Destroy-memory-regions.patch +# For bz#1048092 - manpage of qemu-img contains error statement about compat option +Patch902: kvm-docs-qcow2-compat-1.1-is-now-the-default.patch +# For bz#947812 - There's a shot voice after 'system_reset' during playing music inside rhel6 guest w/ intel-hda device +Patch903: kvm-hda-codec-disable-streams-on-reset.patch +# For bz#1009297 - RHEL7.0 guest gui can not be used in dest host after migration +Patch904: kvm-QEMUBH-make-AioContext-s-bh-re-entrant.patch +# For bz#1009297 - RHEL7.0 guest gui can not be used in dest host after migration +Patch905: kvm-qxl-replace-pipe-signaling-with-bottom-half.patch +# For bz#748906 - qemu fails on disk with 4k sectors and cache=off +Patch906: kvm-block-fix-backing-file-segfault.patch +# For bz#748906 - qemu fails on disk with 4k sectors and cache=off +Patch907: kvm-block-Move-initialisation-of-BlockLimits-to-bdrv_ref.patch +# For bz#748906 - qemu fails on disk with 4k sectors and cache=off +Patch908: kvm-raw-Fix-BlockLimits-passthrough.patch +# For bz#748906 - qemu fails on disk with 4k sectors and cache=off +Patch909: kvm-block-Inherit-opt_transfer_length.patch +# For bz#748906 - qemu fails on disk with 4k sectors and cache=off +Patch910: kvm-block-Update-BlockLimits-when-they-might-have-change.patch +# For bz#748906 - qemu fails on disk with 4k sectors and cache=off +Patch911: kvm-qemu_memalign-Allow-small-alignments.patch +# For bz#748906 - qemu fails on disk with 4k sectors and cache=off +Patch912: kvm-block-Detect-unaligned-length-in-bdrv_qiov_is_aligne.patch +# For bz#748906 - qemu fails on disk with 4k sectors and cache=off +Patch913: kvm-block-Don-t-use-guest-sector-size-for-qemu_blockalig.patch +# For bz#748906 - qemu fails on disk with 4k sectors and cache=off +Patch914: kvm-block-rename-buffer_alignment-to-guest_block_size.patch +# For bz#748906 - qemu fails on disk with 4k sectors and cache=off +Patch915: kvm-raw-Probe-required-direct-I-O-alignment.patch +# For bz#748906 - qemu fails on disk with 4k sectors and cache=off +Patch916: kvm-block-Introduce-bdrv_aligned_preadv.patch +# For bz#748906 - qemu fails on disk with 4k sectors and cache=off +Patch917: kvm-block-Introduce-bdrv_co_do_preadv.patch +# For bz#748906 - qemu fails on disk with 4k sectors and cache=off +Patch918: kvm-block-Introduce-bdrv_aligned_pwritev.patch +# For bz#748906 - qemu fails on disk with 4k sectors and cache=off +Patch919: kvm-block-write-Handle-COR-dependency-after-I-O-throttli.patch +# For bz#748906 - qemu fails on disk with 4k sectors and cache=off +Patch920: kvm-block-Introduce-bdrv_co_do_pwritev.patch +# For bz#748906 - qemu fails on disk with 4k sectors and cache=off +Patch921: kvm-block-Switch-BdrvTrackedRequest-to-byte-granularity.patch +# For bz#748906 - qemu fails on disk with 4k sectors and cache=off +Patch922: kvm-block-Allow-waiting-for-overlapping-requests-between.patch +# For bz#748906 - qemu fails on disk with 4k sectors and cache=off +Patch923: kvm-block-use-DIV_ROUND_UP-in-bdrv_co_do_readv.patch +# For bz#748906 - qemu fails on disk with 4k sectors and cache=off +Patch924: kvm-block-Make-zero-after-EOF-work-with-larger-alignment.patch +# For bz#748906 - qemu fails on disk with 4k sectors and cache=off +Patch925: kvm-block-Generalise-and-optimise-COR-serialisation.patch +# For bz#748906 - qemu fails on disk with 4k sectors and cache=off +Patch926: kvm-block-Make-overlap-range-for-serialisation-dynamic.patch +# For bz#748906 - qemu fails on disk with 4k sectors and cache=off +Patch927: kvm-block-Fix-32-bit-truncation-in-mark_request_serialis.patch +# For bz#748906 - qemu fails on disk with 4k sectors and cache=off +Patch928: kvm-block-Allow-wait_serialising_requests-at-any-point.patch +# For bz#748906 - qemu fails on disk with 4k sectors and cache=off +Patch929: kvm-block-Align-requests-in-bdrv_co_do_pwritev.patch +# For bz#748906 - qemu fails on disk with 4k sectors and cache=off +Patch930: kvm-lock-Fix-memory-leaks-in-bdrv_co_do_pwritev.patch +# For bz#748906 - qemu fails on disk with 4k sectors and cache=off +Patch931: kvm-block-Assert-serialisation-assumptions-in-pwritev.patch +# For bz#748906 - qemu fails on disk with 4k sectors and cache=off +Patch932: kvm-block-Change-coroutine-wrapper-to-byte-granularity.patch +# For bz#748906 - qemu fails on disk with 4k sectors and cache=off +Patch933: kvm-block-Make-bdrv_pread-a-bdrv_prwv_co-wrapper.patch +# For bz#748906 - qemu fails on disk with 4k sectors and cache=off +Patch934: kvm-block-Make-bdrv_pwrite-a-bdrv_prwv_co-wrapper.patch +# For bz#748906 - qemu fails on disk with 4k sectors and cache=off +Patch935: kvm-iscsi-Set-bs-request_alignment.patch +# For bz#748906 - qemu fails on disk with 4k sectors and cache=off +Patch936: kvm-blkdebug-Make-required-alignment-configurable.patch +# For bz#748906 - qemu fails on disk with 4k sectors and cache=off +Patch937: kvm-blkdebug-Don-t-leak-bs-file-on-failure.patch +# For bz#748906 - qemu fails on disk with 4k sectors and cache=off +Patch938: kvm-qemu-io-New-command-sleep.patch +# For bz#748906 - qemu fails on disk with 4k sectors and cache=off +Patch939: kvm-qemu-iotests-Filter-out-qemu-io-prompt.patch +# For bz#748906 - qemu fails on disk with 4k sectors and cache=off +Patch940: kvm-qemu-iotests-Test-pwritev-RMW-logic.patch +# For bz#748906 - qemu fails on disk with 4k sectors and cache=off +Patch941: kvm-block-bdrv_aligned_pwritev-Assert-overlap-range.patch +# For bz#748906 - qemu fails on disk with 4k sectors and cache=off +Patch942: kvm-block-Don-t-call-ROUND_UP-with-negative-values.patch +# For bz#1026314 - qemu-kvm hang when use '-sandbox on'+'vnc'+'hda' +Patch943: kvm-seccomp-add-mkdir-and-fchmod-to-the-whitelist.patch +# For bz#1026314 - qemu-kvm hang when use '-sandbox on'+'vnc'+'hda' +Patch944: kvm-seccomp-add-some-basic-shared-memory-syscalls-to-the.patch +# For bz#1004143 - "test unit ready failed" on LUN 0 delays boot when a virtio-scsi target does not have any disk on LUN 0 +Patch945: kvm-scsi-Support-TEST-UNIT-READY-in-the-dummy-LUN0.patch +# For bz#1039530 - add support for microsoft os descriptors +Patch946: kvm-usb-add-vendor-request-defines.patch +# For bz#1039530 - add support for microsoft os descriptors +Patch947: kvm-usb-move-usb_-hi-lo-helpers-to-header-file.patch +# For bz#1039530 - add support for microsoft os descriptors +Patch948: kvm-usb-add-support-for-microsoft-os-descriptors.patch +# For bz#1039530 - add support for microsoft os descriptors +Patch949: kvm-usb-add-microsoft-os-descriptors-compat-property.patch +# For bz#1039530 - add support for microsoft os descriptors +Patch950: kvm-usb-hid-add-microsoft-os-descriptor-support.patch +# For bz#1044182 - Relax qemu-kvm stack protection to -fstack-protector-strong +Patch951: kvm-configure-add-option-to-disable-fstack-protect.patch +# For bz#1004197 - Cannot hot-plug nic in windows VM when the vmem is larger +Patch952: kvm-exec-always-use-MADV_DONTFORK.patch +# For bz#1048080 - Qemu-kvm NUMA emulation failed +Patch953: kvm-pc-Save-size-of-RAM-below-4GB.patch +# For bz#1048080 - Qemu-kvm NUMA emulation failed +Patch954: kvm-acpi-Fix-PCI-hole-handling-on-build_srat.patch +# For bz#1017096 - Fail to migrate while the size of migrate-compcache less then 4096 +Patch955: kvm-Add-check-for-cache-size-smaller-than-page-size.patch +# For bz#1047448 - qemu-kvm core dump in src host when do migration with "migrate_set_capability xbzrle on and migrate_set_cache_size 10000G" +Patch956: kvm-XBZRLE-cache-size-should-not-be-larger-than-guest-me.patch +# For bz#1047448 - qemu-kvm core dump in src host when do migration with "migrate_set_capability xbzrle on and migrate_set_cache_size 10000G" +Patch957: kvm-Don-t-abort-on-out-of-memory-when-creating-page-cach.patch +# For bz#1047448 - qemu-kvm core dump in src host when do migration with "migrate_set_capability xbzrle on and migrate_set_cache_size 10000G" +Patch958: kvm-Don-t-abort-on-memory-allocation-error.patch +# For bz#1038540 - qemu-kvm aborted while cancel migration then restart it (with page delta compression) +Patch959: kvm-Set-xbzrle-buffers-to-NULL-after-freeing-them-to-avo.patch +# For bz#1038540 - qemu-kvm aborted while cancel migration then restart it (with page delta compression) +Patch960: kvm-migration-fix-free-XBZRLE-decoded_buf-wrong.patch +# For bz#1047254 - qemu-img failed to commit image +Patch961: kvm-block-resize-backing-file-image-during-offline-commi.patch +# For bz#1047254 - qemu-img failed to commit image +Patch962: kvm-block-resize-backing-image-during-active-layer-commi.patch +# For bz#1047254 - qemu-img failed to commit image +Patch963: kvm-block-update-block-commit-documentation-regarding-im.patch +# For bz#1047254 - qemu-img failed to commit image +Patch964: kvm-block-Fix-bdrv_commit-return-value.patch +# For bz#1047254 - qemu-img failed to commit image +Patch965: kvm-block-remove-QED-.bdrv_make_empty-implementation.patch +# For bz#1047254 - qemu-img failed to commit image +Patch966: kvm-block-remove-qcow2-.bdrv_make_empty-implementation.patch +# For bz#997878 - Kill -SIGUSR1 `pidof qemu-img convert` can not get progress of qemu-img +Patch967: kvm-qemu-progress-Drop-unused-include.patch +# For bz#997878 - Kill -SIGUSR1 `pidof qemu-img convert` can not get progress of qemu-img +Patch968: kvm-qemu-progress-Fix-progress-printing-on-SIGUSR1.patch +# For bz#997878 - Kill -SIGUSR1 `pidof qemu-img convert` can not get progress of qemu-img +Patch969: kvm-Documentation-qemu-img-Mention-SIGUSR1-progress-repo.patch +# For bz#1063942 - configure qemu-kvm with --disable-qom-cast-debug +Patch970: kvm-fix-guest-physical-bits-to-match-host-to-go-beyond-1.patch +# For bz#1065225 - QMP socket breaks on unexpected close +Patch971: kvm-monitor-Cleanup-mon-outbuf-on-write-error.patch +# For bz#1012365 - xhci usb storage lost in guest after wakeup from S3 +Patch972: kvm-xhci-add-support-for-suspend-resume.patch +# For bz#1049176 - qemu-img core dump when using "-o preallocation=metadata,cluster_size=2048k" to create image of libiscsi lun +Patch973: kvm-qcow2-remove-n_start-and-n_end-of-qcow2_alloc_cluste.patch +# For bz#1049176 - qemu-img core dump when using "-o preallocation=metadata,cluster_size=2048k" to create image of libiscsi lun +Patch974: kvm-qcow2-fix-offset-overflow-in-qcow2_alloc_clusters_at.patch +# For bz#1055848 - qemu-img core dumped when cluster size is larger than the default value with opreallocation=metadata specified +Patch975: kvm-qcow2-check-for-NULL-l2meta.patch +# For bz#1055848 - qemu-img core dumped when cluster size is larger than the default value with opreallocation=metadata specified +Patch976: kvm-qemu-iotests-add-test-for-qcow2-preallocation-with-d.patch +# For bz#1069039 - -mem-prealloc option behaviour is opposite to expected +Patch977: kvm-mempath-prefault-fix-off-by-one-error.patch +# For bz#1065873 - qemu-img silently ignores options with multiple -o parameters +Patch978: kvm-qemu-option-has_help_option-and-is_valid_option_list.patch +# For bz#1065873 - qemu-img silently ignores options with multiple -o parameters +Patch979: kvm-qemu-img-create-Support-multiple-o-options.patch +# For bz#1065873 - qemu-img silently ignores options with multiple -o parameters +Patch980: kvm-qemu-img-convert-Support-multiple-o-options.patch +# For bz#1065873 - qemu-img silently ignores options with multiple -o parameters +Patch981: kvm-qemu-img-amend-Support-multiple-o-options.patch +# For bz#1065873 - qemu-img silently ignores options with multiple -o parameters +Patch982: kvm-qemu-img-Allow-o-help-with-incomplete-argument-list.patch +# For bz#1065873 - qemu-img silently ignores options with multiple -o parameters +Patch983: kvm-qemu-iotests-Check-qemu-img-command-line-parsing.patch +# For bz#1026184 - QMP: querying -drive option returns a NULL parameter list +Patch984: kvm-qmp-access-the-local-QemuOptsLists-for-drive-option.patch +# For bz#751937 - qxl triggers assert during iofuzz test +Patch985: kvm-qxl-add-sanity-check.patch +# For bz#1063417 - google stressapptest vs Migration +Patch986: kvm-Fix-two-XBZRLE-corruption-issues.patch +# For bz#1037956 - bnx2x: boot one guest to do vfio-pci with all PFs assigned in same group meet QEMU segmentation fault (Broadcom BCM57810 card) +Patch987: kvm-qdev-monitor-set-DeviceState-opts-before-calling-rea.patch +# For bz#1037956 - bnx2x: boot one guest to do vfio-pci with all PFs assigned in same group meet QEMU segmentation fault (Broadcom BCM57810 card) +Patch988: kvm-vfio-blacklist-loading-of-unstable-roms.patch +# For bz#1072339 - RHEV: Cannot start VMs that have more than 23 snapshots. +Patch989: kvm-block-Set-block-filename-sizes-to-PATH_MAX-instead-o.patch +# For bz#1004773 - Hyper-V guest OS id and hypercall MSRs not migrated +Patch990: kvm-target-i386-Move-hyperv_-static-globals-to-X86CPU.patch +# For bz#1057173 - KVM Hyper-V Enlightenment - New feature - hv-time (QEMU) +Patch991: kvm-Fix-uninitialized-cpuid_data.patch +# For bz#1004773 - Hyper-V guest OS id and hypercall MSRs not migrated +Patch992: kvm-fix-coexistence-of-KVM-and-Hyper-V-leaves.patch +# For bz#1004773 - Hyper-V guest OS id and hypercall MSRs not migrated +Patch993: kvm-make-availability-of-Hyper-V-enlightenments-depe.patch +# For bz#1004773 - Hyper-V guest OS id and hypercall MSRs not migrated +Patch994: kvm-make-hyperv-hypercall-and-guest-os-id-MSRs-migra.patch +# For bz#1004773 - Hyper-V guest OS id and hypercall MSRs not migrated +Patch995: kvm-make-hyperv-vapic-assist-page-migratable.patch +# For bz#1057173 - KVM Hyper-V Enlightenment - New feature - hv-time (QEMU) +Patch996: kvm-target-i386-Convert-hv_relaxed-to-static-property.patch +# For bz#1057173 - KVM Hyper-V Enlightenment - New feature - hv-time (QEMU) +Patch997: kvm-target-i386-Convert-hv_vapic-to-static-property.patch +# For bz#1057173 - KVM Hyper-V Enlightenment - New feature - hv-time (QEMU) +Patch998: kvm-target-i386-Convert-hv_spinlocks-to-static-property.patch +# For bz#1004773 - Hyper-V guest OS id and hypercall MSRs not migrated +Patch999: kvm-target-i386-Convert-check-and-enforce-to-static-prop.patch +# For bz#1057173 - KVM Hyper-V Enlightenment - New feature - hv-time (QEMU) +Patch1000: kvm-target-i386-Cleanup-foo-feature-handling.patch +# For bz#1057173 - KVM Hyper-V Enlightenment - New feature - hv-time (QEMU) +Patch1001: kvm-add-support-for-hyper-v-timers.patch +# For bz#1069541 - Segmentation fault when boot guest with dataplane=on +Patch1002: kvm-dataplane-Fix-startup-race.patch +# For bz#1057471 - fail to do hot-plug with "discard = on" with "Invalid parameter 'discard'" error +Patch1003: kvm-QMP-Relax-__com.redhat_drive_add-parameter-checking.patch +# For bz#993429 - kvm: test maximum number of vcpus supported (rhel7) +Patch1004: kvm-all-exit-in-case-max-vcpus-exceeded.patch +# For bz#1031526 - Can not commit snapshot when disk is using glusterfs:native backend +Patch1005: kvm-block-gluster-code-movements-state-storage-changes.patch +# For bz#1031526 - Can not commit snapshot when disk is using glusterfs:native backend +Patch1006: kvm-block-gluster-add-reopen-support.patch +# For bz#990989 - backport inline header virtio-net optimization +Patch1007: kvm-virtio-net-add-feature-bit-for-any-header-s-g.patch +# For bz#1073774 - e1000 ROM cause migrate fail from RHEL6.5 host to RHEL7.0 host +Patch1008: kvm-pc-Add-RHEL6-e1000-gPXE-image.patch +# For bz#1064018 - abort from conflicting genroms +# For bz#1064018#c6 - abort from conflicting genroms +Patch1009: kvm-loader-rename-in_ram-has_mr.patch +# For bz#1064018 - abort from conflicting genroms +# For bz#1064018#c6 - abort from conflicting genroms +Patch1010: kvm-pc-avoid-duplicate-names-for-ROM-MRs.patch +# For bz#1073728 - progress bar doesn't display when converting with -p +Patch1011: kvm-qemu-img-convert-Fix-progress-output.patch +# For bz#1073728 - progress bar doesn't display when converting with -p +Patch1012: kvm-qemu-iotests-Test-progress-output-for-conversion.patch +# For bz#1067784 - qemu-kvm: block.c:850: bdrv_open_common: Assertion `bs->request_alignment != 0' failed. Aborted (core dumped) +Patch1013: kvm-iscsi-Use-bs-sg-for-everything-else-than-disks.patch +# For bz#1067784 - qemu-kvm: block.c:850: bdrv_open_common: Assertion `bs->request_alignment != 0' failed. Aborted (core dumped) +Patch1014: kvm-block-Fix-bs-request_alignment-assertion-for-bs-sg-1.patch +# For bz#1005103 - Migration should fail when migrate guest offline to a file which is specified to a readonly directory. +Patch1015: kvm-qemu_file-use-fwrite-correctly.patch +# For bz#1005103 - Migration should fail when migrate guest offline to a file which is specified to a readonly directory. +Patch1016: kvm-qemu_file-Fix-mismerge-of-use-fwrite-correctly.patch +# For bz#1046248 - qemu-kvm crash when send "info qtree" after hot plug a device with invalid addr +Patch1017: kvm-qdev-monitor-Set-properties-after-parent-is-assigned.patch +# For bz#1048575 - Segmentation fault occurs after migrate guest(use scsi disk and add stress) to des machine +Patch1018: kvm-block-Update-image-size-in-bdrv_invalidate_cache.patch +# For bz#1048575 - Segmentation fault occurs after migrate guest(use scsi disk and add stress) to des machine +Patch1019: kvm-qcow2-Keep-option-in-qcow2_invalidate_cache.patch +# For bz#1048575 - Segmentation fault occurs after migrate guest(use scsi disk and add stress) to des machine +Patch1020: kvm-qcow2-Check-bs-drv-in-copy_sectors.patch +# For bz#1048575 - Segmentation fault occurs after migrate guest(use scsi disk and add stress) to des machine +Patch1021: kvm-block-bs-drv-may-be-NULL-in-bdrv_debug_resume.patch +# For bz#1048575 - Segmentation fault occurs after migrate guest(use scsi disk and add stress) to des machine +Patch1022: kvm-iotests-Test-corruption-during-COW-request.patch +# For bz#1058173 - qemu-kvm core dump booting guest with scsi-generic disk attached when using built-in iscsi driver +Patch1023: kvm-scsi-Change-scsi-sense-buf-size-to-252.patch +# For bz#1058173 - qemu-kvm core dump booting guest with scsi-generic disk attached when using built-in iscsi driver +Patch1024: kvm-scsi-Fix-migration-of-scsi-sense-data.patch +# For bz#1078809 - can not boot qemu-kvm-rhev with rbd image +Patch1025: kvm-configure-Fix-bugs-preventing-Ceph-inclusion.patch +# For bz#1078308 - EMBARGOED CVE-2014-0150 qemu: virtio-net: fix guest-triggerable buffer overrun [rhel-7.0] +Patch1026: kvm-virtio-net-fix-guest-triggerable-buffer-overrun.patch +# For bz#1080170 - Default CPU model for rhel6.* machine-types is different from RHEL-6 +Patch1027: kvm-pc-Use-cpu64-rhel6-CPU-model-by-default-on-rhel6-mac.patch +# For bz#1078607 - intel 82576 VF not work in windows 2008 x86 - Code 12 [TestOnly] +# For bz#1080170 - Default CPU model for rhel6.* machine-types is different from RHEL-6 +Patch1028: kvm-target-i386-Copy-cpu64-rhel6-definition-into-qemu64.patch +# For bz#1066691 - qemu-kvm: include leftover patches from block layer security audit +Patch1029: kvm-qemu-iotests-add-.-check-cloop-support.patch +# For bz#1066691 - qemu-kvm: include leftover patches from block layer security audit +Patch1030: kvm-qemu-iotests-add-cloop-input-validation-tests.patch +# For bz#1079455 - CVE-2014-0144 qemu-kvm: Qemu: block: missing input validation [rhel-7.0] +Patch1031: kvm-block-cloop-validate-block_size-header-field-CVE-201.patch +# For bz#1079320 - CVE-2014-0143 qemu-kvm: Qemu: block: multiple integer overflow flaws [rhel-7.0] +Patch1032: kvm-block-cloop-prevent-offsets_size-integer-overflow-CV.patch +# For bz#1079455 - CVE-2014-0144 qemu-kvm: Qemu: block: missing input validation [rhel-7.0] +Patch1033: kvm-block-cloop-refuse-images-with-huge-offsets-arrays-C.patch +# For bz#1079455 - CVE-2014-0144 qemu-kvm: Qemu: block: missing input validation [rhel-7.0] +Patch1034: kvm-block-cloop-refuse-images-with-bogus-offsets-CVE-201.patch +# For bz#1066691 - qemu-kvm: include leftover patches from block layer security audit +Patch1035: kvm-size-off-by-one.patch +# For bz#1066691 - qemu-kvm: include leftover patches from block layer security audit +Patch1036: kvm-qemu-iotests-Support-for-bochs-format.patch +# For bz#1066691 - qemu-kvm: include leftover patches from block layer security audit +Patch1037: kvm-bochs-Unify-header-structs-and-make-them-QEMU_PACKED.patch +# For bz#1079339 - CVE-2014-0147 qemu-kvm: Qemu: block: possible crash due signed types or logic error [rhel-7.0] +Patch1038: kvm-bochs-Use-unsigned-variables-for-offsets-and-sizes-C.patch +# For bz#1079320 - CVE-2014-0143 qemu-kvm: Qemu: block: multiple integer overflow flaws [rhel-7.0] +Patch1039: kvm-bochs-Check-catalog_size-header-field-CVE-2014-0143.patch +# For bz#1079315 - CVE-2014-0142 qemu-kvm: qemu: crash by possible division by zero [rhel-7.0] +Patch1040: kvm-bochs-Check-extent_size-header-field-CVE-2014-0142.patch +# For bz#1066691 - qemu-kvm: include leftover patches from block layer security audit +Patch1041: kvm-bochs-Fix-bitmap-offset-calculation.patch +# For bz#1079455 - CVE-2014-0144 qemu-kvm: Qemu: block: missing input validation [rhel-7.0] +Patch1042: kvm-vpc-vhd-add-bounds-check-for-max_table_entries-and-b.patch +# For bz#1079315 - CVE-2014-0142 qemu-kvm: qemu: crash by possible division by zero [rhel-7.0] +Patch1043: kvm-vpc-Validate-block-size-CVE-2014-0142.patch +# For bz#1079455 - CVE-2014-0144 qemu-kvm: Qemu: block: missing input validation [rhel-7.0] +Patch1044: kvm-vdi-add-bounds-checks-for-blocks_in_image-and-disk_s.patch +# For bz#1079346 - CVE-2014-0148 qemu-kvm: Qemu: vhdx: bounds checking for block_size and logical_sector_size [rhel-7.0] +Patch1045: kvm-vhdx-Bounds-checking-for-block_size-and-logical_sect.patch +# For bz#1079455 - CVE-2014-0144 qemu-kvm: Qemu: block: missing input validation [rhel-7.0] +Patch1046: kvm-curl-check-data-size-before-memcpy-to-local-buffer.-.patch +# For bz#1079455 - CVE-2014-0144 qemu-kvm: Qemu: block: missing input validation [rhel-7.0] +Patch1047: kvm-qcow2-Check-header_length-CVE-2014-0144.patch +# For bz#1079455 - CVE-2014-0144 qemu-kvm: Qemu: block: missing input validation [rhel-7.0] +Patch1048: kvm-qcow2-Check-backing_file_offset-CVE-2014-0144.patch +# For bz#1079455 - CVE-2014-0144 qemu-kvm: Qemu: block: missing input validation [rhel-7.0] +Patch1049: kvm-qcow2-Check-refcount-table-size-CVE-2014-0144.patch +# For bz#1066691 - qemu-kvm: include leftover patches from block layer security audit +Patch1050: kvm-qcow2-Validate-refcount-table-offset.patch +# For bz#1079455 - CVE-2014-0144 qemu-kvm: Qemu: block: missing input validation [rhel-7.0] +Patch1051: kvm-qcow2-Validate-snapshot-table-offset-size-CVE-2014-0.patch +# For bz#1079455 - CVE-2014-0144 qemu-kvm: Qemu: block: missing input validation [rhel-7.0] +Patch1052: kvm-qcow2-Validate-active-L1-table-offset-and-size-CVE-2.patch +# For bz#1066691 - qemu-kvm: include leftover patches from block layer security audit +Patch1053: kvm-qcow2-Fix-backing-file-name-length-check.patch +# For bz#1079339 - CVE-2014-0147 qemu-kvm: Qemu: block: possible crash due signed types or logic error [rhel-7.0] +Patch1054: kvm-qcow2-Don-t-rely-on-free_cluster_index-in-alloc_refc.patch +# For bz#1079320 - CVE-2014-0143 qemu-kvm: Qemu: block: multiple integer overflow flaws [rhel-7.0] +Patch1055: kvm-qcow2-Avoid-integer-overflow-in-get_refcount-CVE-201.patch +# For bz#1066691 - qemu-kvm: include leftover patches from block layer security audit +Patch1056: kvm-qcow2-Check-new-refcount-table-size-on-growth.patch +# For bz#1066691 - qemu-kvm: include leftover patches from block layer security audit +Patch1057: kvm-qcow2-Fix-types-in-qcow2_alloc_clusters-and-alloc_cl.patch +# For bz#1066691 - qemu-kvm: include leftover patches from block layer security audit +Patch1058: kvm-qcow2-Protect-against-some-integer-overflows-in-bdrv.patch +# For bz#1079320 - CVE-2014-0143 qemu-kvm: Qemu: block: multiple integer overflow flaws [rhel-7.0] +Patch1059: kvm-qcow2-Fix-new-L1-table-size-check-CVE-2014-0143.patch +# For bz#1066691 - qemu-kvm: include leftover patches from block layer security audit +Patch1060: kvm-dmg-coding-style-and-indentation-cleanup.patch +# For bz#1066691 - qemu-kvm: include leftover patches from block layer security audit +Patch1061: kvm-dmg-prevent-out-of-bounds-array-access-on-terminator.patch +# For bz#1066691 - qemu-kvm: include leftover patches from block layer security audit +Patch1062: kvm-dmg-drop-broken-bdrv_pread-loop.patch +# For bz#1066691 - qemu-kvm: include leftover patches from block layer security audit +Patch1063: kvm-dmg-use-appropriate-types-when-reading-chunks.patch +# For bz#1079325 - CVE-2014-0145 qemu-kvm: Qemu: prevent possible buffer overflows [rhel-7.0] +Patch1064: kvm-dmg-sanitize-chunk-length-and-sectorcount-CVE-2014-0.patch +# For bz#1066691 - qemu-kvm: include leftover patches from block layer security audit +Patch1065: kvm-dmg-use-uint64_t-consistently-for-sectors-and-length.patch +# For bz#1079325 - CVE-2014-0145 qemu-kvm: Qemu: prevent possible buffer overflows [rhel-7.0] +Patch1066: kvm-dmg-prevent-chunk-buffer-overflow-CVE-2014-0145.patch +# For bz#1066691 - qemu-kvm: include leftover patches from block layer security audit +Patch1067: kvm-block-vdi-bounds-check-qemu-io-tests.patch +# For bz#1079320 - CVE-2014-0143 qemu-kvm: Qemu: block: multiple integer overflow flaws [rhel-7.0] +Patch1068: kvm-block-Limit-request-size-CVE-2014-0143.patch +# For bz#1066691 - qemu-kvm: include leftover patches from block layer security audit +Patch1069: kvm-qcow2-Fix-copy_sectors-with-VM-state.patch +# For bz#1079333 - CVE-2014-0146 qemu-kvm: Qemu: qcow2: NULL dereference in qcow2_open() error path [rhel-7.0] +Patch1070: kvm-qcow2-Fix-NULL-dereference-in-qcow2_open-error-path-.patch +# For bz#1079325 - CVE-2014-0145 qemu-kvm: Qemu: prevent possible buffer overflows [rhel-7.0] +Patch1071: kvm-qcow2-Fix-L1-allocation-size-in-qcow2_snapshot_load_.patch +# For bz#1079320 - CVE-2014-0143 qemu-kvm: Qemu: block: multiple integer overflow flaws [rhel-7.0] +Patch1072: kvm-qcow2-Check-maximum-L1-size-in-qcow2_snapshot_load_t.patch +# For bz#1066691 - qemu-kvm: include leftover patches from block layer security audit +Patch1073: kvm-qcow2-Limit-snapshot-table-size.patch +# For bz#1079320 - CVE-2014-0143 qemu-kvm: Qemu: block: multiple integer overflow flaws [rhel-7.0] +Patch1074: kvm-parallels-Fix-catalog-size-integer-overflow-CVE-2014.patch +# For bz#1079315 - CVE-2014-0142 qemu-kvm: qemu: crash by possible division by zero [rhel-7.0] +Patch1075: kvm-parallels-Sanity-check-for-s-tracks-CVE-2014-0142.patch +# For bz#740107 - [Hitachi 7.0 FEAT] KVM: MCA Recovery for KVM guest OS memory +Patch1076: kvm-fix-machine-check-propagation.patch +# For bz#1081793 - qemu-img core dumped when creating a qcow2 image base on block device(iscsi or libiscsi) +Patch1077: kvm-qcow2-fix-dangling-refcount-table-entry.patch +# For bz#1081393 - qemu-img will prompt that 'leaked clusters were found' while creating images with '-o preallocation=metadata,cluster_size<=1024' +Patch1078: kvm-qcow2-link-all-L2-meta-updates-in-preallocate.patch + BuildRequires: zlib-devel BuildRequires: SDL-devel @@ -1037,6 +2214,7 @@ BuildRequires: cyrus-sasl-devel BuildRequires: libtool BuildRequires: libaio-devel BuildRequires: rsync +BuildRequires: python BuildRequires: pciutils-devel BuildRequires: pulseaudio-libs-devel BuildRequires: libiscsi-devel @@ -1088,6 +2266,16 @@ BuildRequires: pixman-devel # Documentation requirement BuildRequires: perl-podlators BuildRequires: texinfo +# For rdma +%if 0%{?have_librdma:1} +BuildRequires: librdmacm-devel +%endif +# iasl and cpp for acpi generation (not a hard requirement as we can use +# pre-compiled files, but it's better to use this) +%ifarch %{ix86} x86_64 +BuildRequires: iasl +BuildRequires: cpp +%endif %if 0%{!?build_only_sub:1} Requires: qemu-img = %{epoch}:%{version}-%{release} @@ -1103,25 +2291,21 @@ Requires: qemu-img = %{epoch}:%{version}-%{release} %define qemudocdir %{_docdir}/%{pkgname} %description -QEMU is a generic and open source processor emulator which achieves a good -emulation speed by using dynamic translation. QEMU has two operating modes: - - * Full system emulation. In this mode, QEMU emulates a full system (for - example a PC), including a processor and various peripherials. It can be - used to launch different Operating Systems without rebooting the PC or - to debug system code. - * User mode emulation. In this mode, QEMU can launch Linux processes compiled - for one CPU on another CPU. - -As QEMU requires no host kernel patches to run, it is safe and easy to use. -%if !%{rhev} -%package -n qemu-img +qemu-kvm is an open source virtualizer that provides hardware emulation for +the KVM hypervisor. qemu-kvm acts as a virtual machine monitor together with +the KVM kernel modules, and emulates the hardware for a full system such as +a PC and its assocated peripherals. + +As qemu-kvm requires no host kernel patches to run, it is safe and easy to use. + +%package -n qemu-img%{?pkgsuffix} Summary: QEMU command line tool for manipulating disk images Group: Development/Tools -%description -n qemu-img -This package provides a command line tool for manipulating disk images -%endif +%rhel_rhev_conflicts qemu-img + +%description -n qemu-img%{?pkgsuffix} +This package provides a command line tool for manipulating disk images. %if 0%{!?build_only_sub:1} %package -n qemu-kvm-common%{?pkgsuffix} @@ -1134,13 +2318,14 @@ Requires(post): systemd-units Requires(preun): systemd-units Requires(postun): systemd-units +%rhel_rhev_conflicts qemu-kvm-common + %description -n qemu-kvm-common%{?pkgsuffix} -QEMU is a generic and open source processor emulator which achieves a good -emulation speed by using dynamic translation. +qemu-kvm is an open source virtualizer that provides hardware emulation for +the KVM hypervisor. -This package provides the common files needed by all QEMU targets +This package provides documentation and auxiliary programs used with qemu-kvm. -%rhel_rhev_conflicts qemu-kvm-common %endif %if %{with guest_agent} @@ -1152,8 +2337,8 @@ Requires(preun): systemd-units Requires(postun): systemd-units %description -n qemu-guest-agent -QEMU is a generic and open source processor emulator which achieves a good -emulation speed by using dynamic translation. +qemu-kvm is an open source virtualizer that provides hardware emulation for +the KVM hypervisor. This package provides an agent to run inside guests, which communicates with the host over a virtio-serial channel named "org.qemu.guest_agent.0" @@ -1171,45 +2356,52 @@ This package does not need to be installed on the host OS. %endif -%if !%{rhev} - %if 0%{!?build_only_sub:1} -%package tools +%if 0%{!?build_only_sub:1} +%package -n qemu-kvm-tools%{?pkgsuffix} Summary: KVM debugging and diagnostics tools Group: Development/Tools -%description tools +%rhel_rhev_conflicts qemu-kvm-tools + +%description -n qemu-kvm-tools%{?pkgsuffix} This package contains some diagnostics and debugging tools for KVM, such as kvm_stat. - %endif +%endif -%package -n libcacard +%package -n libcacard%{?pkgsuffix} Summary: Common Access Card (CAC) Emulation Group: Development/Libraries -%description -n libcacard +%rhel_rhev_conflicts libcacard + +%description -n libcacard%{?pkgsuffix} Common Access Card (CAC) emulation library. -%package -n libcacard-tools +%package -n libcacard-tools%{?pkgsuffix} Summary: CAC Emulation tools Group: Development/Libraries Requires: libcacard = %{epoch}:%{version}-%{release} # older qemu-img has vscclient which is now in libcacard-tools Requires: qemu-img >= 3:1.3.0-5 -%description -n libcacard-tools +%rhel_rhev_conflicts libcacard-tools + +%description -n libcacard-tools%{?pkgsuffix} CAC emulation tools. -%package -n libcacard-devel +%package -n libcacard-devel%{?pkgsuffix} Summary: CAC Emulation devel Group: Development/Libraries Requires: libcacard = %{epoch}:%{version}-%{release} -%description -n libcacard-devel +%rhel_rhev_conflicts libcacard-devel + +%description -n libcacard-devel%{?pkgsuffix} CAC emulation development files. -%endif %prep %setup -q -n qemu-%{version} +cp %{SOURCE18} pc-bios # keep "make check" happy %patch1 -p1 #%%patch2 -p1 #%%patch3 -p1 @@ -1700,6 +2892,597 @@ CAC emulation development files. %patch485 -p1 %patch486 -p1 %patch487 -p1 +%patch488 -p1 +%patch489 -p1 +%patch490 -p1 +%patch491 -p1 +%patch492 -p1 +%patch493 -p1 +%patch494 -p1 +%patch495 -p1 +%patch496 -p1 +%patch497 -p1 +%patch498 -p1 +%patch499 -p1 +%patch500 -p1 +%patch501 -p1 +%patch502 -p1 +%patch503 -p1 +%patch504 -p1 +%patch505 -p1 +%patch506 -p1 +%patch507 -p1 +%patch508 -p1 +%patch509 -p1 +%patch510 -p1 +%patch511 -p1 +%patch512 -p1 +%patch513 -p1 +%patch514 -p1 +%patch515 -p1 +%patch516 -p1 +%patch517 -p1 +%patch518 -p1 +%patch519 -p1 +%patch520 -p1 +%patch521 -p1 +%patch522 -p1 +%patch523 -p1 +%patch524 -p1 +%patch525 -p1 +%patch526 -p1 +%patch527 -p1 +%patch528 -p1 +%patch529 -p1 +%patch530 -p1 +%patch531 -p1 +%patch532 -p1 +%patch533 -p1 +%patch534 -p1 +%patch535 -p1 +%patch536 -p1 +%patch537 -p1 +%patch538 -p1 +%patch539 -p1 +%patch540 -p1 +%patch541 -p1 +%patch542 -p1 +%patch543 -p1 +%patch544 -p1 +%patch545 -p1 +%patch546 -p1 +%patch547 -p1 +%patch548 -p1 +%patch549 -p1 +%patch550 -p1 +%patch551 -p1 +%patch552 -p1 +%patch553 -p1 +%patch554 -p1 +%patch555 -p1 +%patch556 -p1 +%patch557 -p1 +%patch558 -p1 +%patch559 -p1 +%patch560 -p1 +%patch561 -p1 +%patch562 -p1 +%patch563 -p1 +%patch564 -p1 +%patch565 -p1 +%patch566 -p1 +%patch567 -p1 +%patch568 -p1 +%patch569 -p1 +%patch570 -p1 +%patch571 -p1 +%patch572 -p1 +%patch573 -p1 +%patch574 -p1 +%patch575 -p1 +%patch576 -p1 +%patch577 -p1 +%patch578 -p1 +%patch579 -p1 +%patch580 -p1 +%patch581 -p1 +%patch582 -p1 +%patch583 -p1 +%patch584 -p1 +%patch585 -p1 +%patch586 -p1 +%patch587 -p1 +%patch588 -p1 +%patch589 -p1 +%patch590 -p1 +%patch591 -p1 +%patch592 -p1 +%patch593 -p1 +%patch594 -p1 +%patch595 -p1 +%patch596 -p1 +%patch597 -p1 +%patch598 -p1 +%patch599 -p1 +%patch600 -p1 +%patch601 -p1 +%patch602 -p1 +%patch603 -p1 +%patch604 -p1 +%patch605 -p1 +%patch606 -p1 +%patch607 -p1 +%patch608 -p1 +%patch609 -p1 +%patch610 -p1 +%patch611 -p1 +%patch612 -p1 +%patch613 -p1 +%patch614 -p1 +%patch615 -p1 +%patch616 -p1 +%patch617 -p1 +%patch618 -p1 +%patch619 -p1 +%patch620 -p1 +%patch621 -p1 +%patch622 -p1 +%patch623 -p1 +%patch624 -p1 +%patch625 -p1 +%patch626 -p1 +%patch627 -p1 +%patch628 -p1 +%patch629 -p1 +%patch630 -p1 +%patch631 -p1 +%patch632 -p1 +%patch633 -p1 +%patch634 -p1 +%patch635 -p1 +%patch636 -p1 +%patch637 -p1 +%patch638 -p1 +%patch639 -p1 +%patch640 -p1 +%patch641 -p1 +%patch642 -p1 +%patch643 -p1 +%patch644 -p1 +%patch645 -p1 +%patch646 -p1 +%patch647 -p1 +%patch648 -p1 +%patch649 -p1 +%patch650 -p1 +%patch651 -p1 +%patch652 -p1 +%patch653 -p1 +%patch654 -p1 +%patch655 -p1 +%patch656 -p1 +%patch657 -p1 +%patch658 -p1 +%patch659 -p1 +%patch660 -p1 +%patch661 -p1 +%patch662 -p1 +%patch663 -p1 +%patch664 -p1 +%patch665 -p1 +%patch666 -p1 +%patch667 -p1 +%patch668 -p1 +%patch669 -p1 +%patch670 -p1 +%patch671 -p1 +%patch672 -p1 +%patch673 -p1 +%patch674 -p1 +%patch675 -p1 +%patch676 -p1 +%patch677 -p1 +%patch678 -p1 +%patch679 -p1 +%patch680 -p1 +%patch681 -p1 +%patch682 -p1 +%patch683 -p1 +%patch684 -p1 +%patch685 -p1 +%patch686 -p1 +%patch687 -p1 +%patch688 -p1 +%patch689 -p1 +%patch690 -p1 +%patch691 -p1 +%patch692 -p1 +%patch693 -p1 +%patch694 -p1 +%patch695 -p1 +%patch696 -p1 +%patch697 -p1 +%patch698 -p1 +%patch699 -p1 +%patch700 -p1 +%patch701 -p1 +%patch702 -p1 +%patch703 -p1 +%patch704 -p1 +%patch705 -p1 +%patch706 -p1 +%patch707 -p1 +%patch708 -p1 +%patch709 -p1 +%patch710 -p1 +%patch711 -p1 +%patch712 -p1 +%patch713 -p1 +%patch714 -p1 +%patch715 -p1 +%patch716 -p1 +%patch717 -p1 +%patch718 -p1 +%patch719 -p1 +%patch720 -p1 +%patch721 -p1 +%patch722 -p1 +%patch723 -p1 +%patch724 -p1 +%patch725 -p1 +%patch726 -p1 +%patch727 -p1 +%patch728 -p1 +%patch729 -p1 +%patch730 -p1 +%patch731 -p1 +%patch732 -p1 +%patch733 -p1 +%patch734 -p1 +%patch735 -p1 +%patch736 -p1 +%patch737 -p1 +%patch738 -p1 +%patch739 -p1 +%patch740 -p1 +%patch741 -p1 +%patch742 -p1 +%patch743 -p1 +%patch744 -p1 +%patch745 -p1 +%patch746 -p1 +%patch747 -p1 +%patch748 -p1 +%patch749 -p1 +%patch750 -p1 +%patch751 -p1 +%patch752 -p1 +%patch753 -p1 +%patch754 -p1 +%patch755 -p1 +%patch756 -p1 +%patch757 -p1 +%patch758 -p1 +%patch759 -p1 +%patch760 -p1 +%patch761 -p1 +%patch762 -p1 +%patch763 -p1 +%patch764 -p1 +%patch765 -p1 +%patch766 -p1 +%patch767 -p1 +%patch768 -p1 +%patch769 -p1 +%patch770 -p1 +%patch771 -p1 +%patch772 -p1 +%patch773 -p1 +%patch774 -p1 +%patch775 -p1 +%patch776 -p1 +%patch777 -p1 +%patch778 -p1 +%patch779 -p1 +%patch780 -p1 +%patch781 -p1 +%patch782 -p1 +%patch783 -p1 +%patch784 -p1 +%patch785 -p1 +%patch786 -p1 +%patch787 -p1 +%patch788 -p1 +%patch789 -p1 +%patch790 -p1 +%patch791 -p1 +%patch792 -p1 +%patch793 -p1 +%patch794 -p1 +%patch795 -p1 +%patch796 -p1 +%patch797 -p1 +%patch798 -p1 +%patch799 -p1 +%patch800 -p1 +%patch801 -p1 +%patch802 -p1 +%patch803 -p1 +%patch804 -p1 +%patch805 -p1 +%patch806 -p1 +%patch807 -p1 +%patch808 -p1 +%patch809 -p1 +%patch810 -p1 +%patch811 -p1 +%patch812 -p1 +%patch813 -p1 +%patch814 -p1 +%patch815 -p1 +%patch816 -p1 +%patch817 -p1 +%patch818 -p1 +%patch819 -p1 +%patch820 -p1 +%patch821 -p1 +%patch822 -p1 +%patch823 -p1 +%patch824 -p1 +%patch825 -p1 +%patch826 -p1 +%patch827 -p1 +%patch828 -p1 +%patch829 -p1 +%patch830 -p1 +%patch831 -p1 +%patch832 -p1 +%patch833 -p1 +%patch834 -p1 +%patch835 -p1 +%patch836 -p1 +%patch837 -p1 +%patch838 -p1 +%patch839 -p1 +%patch840 -p1 +%patch841 -p1 +%patch842 -p1 +%patch843 -p1 +%patch844 -p1 +%patch845 -p1 +%patch846 -p1 +%patch847 -p1 +%patch848 -p1 +%patch849 -p1 +%patch850 -p1 +%patch851 -p1 +%patch852 -p1 +%patch853 -p1 +%patch854 -p1 +%patch855 -p1 +%patch856 -p1 +%patch857 -p1 +%patch858 -p1 +%patch859 -p1 +%patch860 -p1 +%patch861 -p1 +%patch862 -p1 +%patch863 -p1 +%patch864 -p1 +%patch865 -p1 +%patch866 -p1 +%patch867 -p1 +%patch868 -p1 +%patch869 -p1 +%patch870 -p1 +%patch871 -p1 +%patch872 -p1 +%patch873 -p1 +%patch874 -p1 +%patch875 -p1 +%patch876 -p1 +%patch877 -p1 +%patch878 -p1 +%patch879 -p1 +%patch880 -p1 +%patch881 -p1 +%patch882 -p1 +%patch883 -p1 +%patch884 -p1 +%patch885 -p1 +%patch886 -p1 +%patch887 -p1 +%patch888 -p1 +%patch889 -p1 +%patch890 -p1 +%patch891 -p1 +%patch892 -p1 +%patch893 -p1 +%patch894 -p1 +%patch895 -p1 +%patch896 -p1 +%patch897 -p1 +%patch898 -p1 +%patch899 -p1 +%patch900 -p1 +%patch901 -p1 +%patch902 -p1 +%patch903 -p1 +%patch904 -p1 +%patch905 -p1 +%patch906 -p1 +%patch907 -p1 +%patch908 -p1 +%patch909 -p1 +%patch910 -p1 +%patch911 -p1 +%patch912 -p1 +%patch913 -p1 +%patch914 -p1 +%patch915 -p1 +%patch916 -p1 +%patch917 -p1 +%patch918 -p1 +%patch919 -p1 +%patch920 -p1 +%patch921 -p1 +%patch922 -p1 +%patch923 -p1 +%patch924 -p1 +%patch925 -p1 +%patch926 -p1 +%patch927 -p1 +%patch928 -p1 +%patch929 -p1 +%patch930 -p1 +%patch931 -p1 +%patch932 -p1 +%patch933 -p1 +%patch934 -p1 +%patch935 -p1 +%patch936 -p1 +%patch937 -p1 +%patch938 -p1 +%patch939 -p1 +%patch940 -p1 +%patch941 -p1 +%patch942 -p1 +%patch943 -p1 +%patch944 -p1 +%patch945 -p1 +%patch946 -p1 +%patch947 -p1 +%patch948 -p1 +%patch949 -p1 +%patch950 -p1 +%patch951 -p1 +%patch952 -p1 +%patch953 -p1 +%patch954 -p1 +%patch955 -p1 +%patch956 -p1 +%patch957 -p1 +%patch958 -p1 +%patch959 -p1 +%patch960 -p1 +%patch961 -p1 +%patch962 -p1 +%patch963 -p1 +%patch964 -p1 +%patch965 -p1 +%patch966 -p1 +%patch967 -p1 +%patch968 -p1 +%patch969 -p1 +%patch970 -p1 +%patch971 -p1 +%patch972 -p1 +%patch973 -p1 +%patch974 -p1 +%patch975 -p1 +%patch976 -p1 +%patch977 -p1 +%patch978 -p1 +%patch979 -p1 +%patch980 -p1 +%patch981 -p1 +%patch982 -p1 +%patch983 -p1 +%patch984 -p1 +%patch985 -p1 +%patch986 -p1 +%patch987 -p1 +%patch988 -p1 +%patch989 -p1 +%patch990 -p1 +%patch991 -p1 +%patch992 -p1 +%patch993 -p1 +%patch994 -p1 +%patch995 -p1 +%patch996 -p1 +%patch997 -p1 +%patch998 -p1 +%patch999 -p1 +%patch1000 -p1 +%patch1001 -p1 +%patch1002 -p1 +%patch1003 -p1 +%patch1004 -p1 +%patch1005 -p1 +%patch1006 -p1 +%patch1007 -p1 +%patch1008 -p1 +%patch1009 -p1 +%patch1010 -p1 +%patch1011 -p1 +%patch1012 -p1 +%patch1013 -p1 +%patch1014 -p1 +%patch1015 -p1 +%patch1016 -p1 +%patch1017 -p1 +%patch1018 -p1 +%patch1019 -p1 +%patch1020 -p1 +%patch1021 -p1 +%patch1022 -p1 +%patch1023 -p1 +%patch1024 -p1 +%patch1025 -p1 +%patch1026 -p1 +%patch1027 -p1 +%patch1028 -p1 +%patch1029 -p1 +%patch1030 -p1 +%patch1031 -p1 +%patch1032 -p1 +%patch1033 -p1 +%patch1034 -p1 +%patch1035 -p1 +%patch1036 -p1 +%patch1037 -p1 +%patch1038 -p1 +%patch1039 -p1 +%patch1040 -p1 +%patch1041 -p1 +%patch1042 -p1 +%patch1043 -p1 +%patch1044 -p1 +%patch1045 -p1 +%patch1046 -p1 +%patch1047 -p1 +%patch1048 -p1 +%patch1049 -p1 +%patch1050 -p1 +%patch1051 -p1 +%patch1052 -p1 +%patch1053 -p1 +%patch1054 -p1 +%patch1055 -p1 +%patch1056 -p1 +%patch1057 -p1 +%patch1058 -p1 +%patch1059 -p1 +%patch1060 -p1 +%patch1061 -p1 +%patch1062 -p1 +%patch1063 -p1 +%patch1064 -p1 +%patch1065 -p1 +%patch1066 -p1 +%patch1067 -p1 +%patch1068 -p1 +%patch1069 -p1 +%patch1070 -p1 +%patch1071 -p1 +%patch1072 -p1 +%patch1073 -p1 +%patch1074 -p1 +%patch1075 -p1 +%patch1076 -p1 +%patch1077 -p1 +%patch1078 -p1 %build buildarch="%{kvm_target}-softmmu" @@ -1727,6 +3510,7 @@ dobuild() { --libexecdir=%{_libexecdir} \ --with-pkgversion=%{pkgname}-%{version}-%{release} \ --disable-strip \ + --disable-qom-cast-debug \ --extra-ldflags="$extraldflags -pie -Wl,-z,relro -Wl,-z,now" \ --extra-cflags="%{optflags} -fPIE -DPIE" \ --enable-trace-backend=dtrace \ @@ -1822,11 +3606,11 @@ dobuild --target-list="$buildarch" %define _udevdir %(pkg-config --variable=udevdir udev)/rules.d %if 0%{!?build_only_sub:1} - install -D -p -m 0644 %{SOURCE4} $RPM_BUILD_ROOT%{_libdir}/systemd/system/ksm.service + install -D -p -m 0644 %{SOURCE4} $RPM_BUILD_ROOT%{_unitdir}/ksm.service install -D -p -m 0644 %{SOURCE5} $RPM_BUILD_ROOT%{_sysconfdir}/sysconfig/ksm - install -D -p -m 0755 ksmctl $RPM_BUILD_ROOT%{_libdir}/systemd/ksmctl + install -D -p -m 0755 ksmctl $RPM_BUILD_ROOT%{_libexecdir}/ksmctl - install -D -p -m 0644 %{SOURCE7} $RPM_BUILD_ROOT%{_libdir}/systemd/system/ksmtuned.service + install -D -p -m 0644 %{SOURCE7} $RPM_BUILD_ROOT%{_unitdir}/ksmtuned.service install -D -p -m 0755 %{SOURCE8} $RPM_BUILD_ROOT%{_sbindir}/ksmtuned install -D -p -m 0644 %{SOURCE9} $RPM_BUILD_ROOT%{_sysconfdir}/ksmtuned.conf @@ -1849,6 +3633,7 @@ dobuild --target-list="$buildarch" install %{SOURCE15} $RPM_BUILD_ROOT%{_datadir}/%{pkgname}/ install %{SOURCE16} $RPM_BUILD_ROOT%{_datadir}/%{pkgname}/ install %{SOURCE17} $RPM_BUILD_ROOT%{_datadir}/%{pkgname}/ + install %{SOURCE20} $RPM_BUILD_ROOT%{_datadir}/%{pkgname}/ install -m 0755 qemu-kvm $RPM_BUILD_ROOT%{_libexecdir}/ install -m 0644 qemu-kvm.stp $RPM_BUILD_ROOT%{_datadir}/systemtap/tapset/ @@ -1857,7 +3642,7 @@ dobuild --target-list="$buildarch" rm $RPM_BUILD_ROOT%{_datadir}/systemtap/tapset/qemu-system-%{kvm_target}.stp mkdir -p $RPM_BUILD_ROOT%{qemudocdir} - install -p -m 0644 -t ${RPM_BUILD_ROOT}%{qemudocdir} Changelog README COPYING COPYING.LIB LICENSE + install -p -m 0644 -t ${RPM_BUILD_ROOT}%{qemudocdir} Changelog README COPYING COPYING.LIB LICENSE %{SOURCE19} mv ${RPM_BUILD_ROOT}%{_docdir}/qemu/qemu-doc.html $RPM_BUILD_ROOT%{qemudocdir} mv ${RPM_BUILD_ROOT}%{_docdir}/qemu/qemu-tech.html $RPM_BUILD_ROOT%{qemudocdir} mv ${RPM_BUILD_ROOT}%{_docdir}/qemu/qmp-commands.txt $RPM_BUILD_ROOT%{qemudocdir} @@ -1890,7 +3675,7 @@ dobuild --target-list="$buildarch" # Provided by package vgabios rm -rf ${RPM_BUILD_ROOT}%{_datadir}/%{pkgname}/vgabios*bin # Provided by package seabios - rm -rf ${RPM_BUILD_ROOT}%{_datadir}/%{pkgname}/bios.bin + rm -rf ${RPM_BUILD_ROOT}%{_datadir}/%{pkgname}/bios*.bin # Provided by package sgabios rm -rf ${RPM_BUILD_ROOT}%{_datadir}/%{pkgname}/sgabios.bin @@ -1917,6 +3702,7 @@ dobuild --target-list="$buildarch" rom_link ../seavgabios/vgabios-stdvga.bin vgabios-stdvga.bin rom_link ../seavgabios/vgabios-vmware.bin vgabios-vmware.bin rom_link ../seabios/bios.bin bios.bin + rom_link ../seabios/bios-256k.bin bios-256k.bin rom_link ../sgabios/sgabios.bin sgabios.bin %endif @@ -1953,13 +3739,11 @@ dobuild --target-list="$buildarch" %if 0%{!?build_only_sub:1} # Install rules to use the bridge helper with libvirt's virbr0 install -m 0644 %{SOURCE12} $RPM_BUILD_ROOT%{_sysconfdir}/%{pkgname} - chmod u+s $RPM_BUILD_ROOT%{_libexecdir}/qemu-bridge-helper %endif -%if !%{rhev} - make %{?_smp_mflags} $buildldflags DESTDIR=$RPM_BUILD_ROOT install-libcacard - find $RPM_BUILD_ROOT -name "libcacard.so*" -exec chmod +x \{\} \; -%endif +make %{?_smp_mflags} $buildldflags DESTDIR=$RPM_BUILD_ROOT install-libcacard +find $RPM_BUILD_ROOT -name "libcacard.so*" -exec chmod +x \{\} \; + find $RPM_BUILD_ROOT -name '*.la' -or -name '*.a' | xargs rm -f %if 0%{?build_only_sub} @@ -1977,19 +3761,6 @@ find $RPM_BUILD_ROOT -name '*.la' -or -name '*.a' | xargs rm -f chmod -x ${RPM_BUILD_ROOT}%{_mandir}/man8/* %endif -%if %{rhev} - # Remove files unpackacked for rhev build - rm -rf ${RPM_BUILD_ROOT}%{_includedir}/cacard - rm -rf ${RPM_BUILD_ROOT}%{_bindir}/qemu-img - rm -rf ${RPM_BUILD_ROOT}%{_bindir}/qemu-io - rm -rf ${RPM_BUILD_ROOT}%{_bindir}/qemu-nbd - rm -rf ${RPM_BUILD_ROOT}%{_mandir}/man1/qemu-img.1* - rm -rf ${RPM_BUILD_ROOT}%{_mandir}/man8/qemu-nbd.8* - rm -rf ${RPM_BUILD_ROOT}%{_bindir}/vscclient - rm -rf ${RPM_BUILD_ROOT}%{_libdir}/libcacard.so* - rm -rf ${RPM_BUILD_ROOT}%{_libdir}/pkgconfig/libcacard.pc - rm -rf ${RPM_BUILD_ROOT}%{_bindir}/kvm_stat -%endif %if 0%{!?build_only_sub:1} %check @@ -2040,15 +3811,16 @@ sh %{_sysconfdir}/sysconfig/modules/kvm.modules &> /dev/null || : %doc %{qemudocdir}/COPYING %doc %{qemudocdir}/COPYING.LIB %doc %{qemudocdir}/LICENSE + %doc %{qemudocdir}/README.rhel6-gpxe-source %dir %{_datadir}/%{pkgname}/ %{_datadir}/%{pkgname}/keymaps/ %{_mandir}/man1/%{pkgname}.1* %attr(4755, -, -) %{_libexecdir}/qemu-bridge-helper %config(noreplace) %{_sysconfdir}/sasl2/%{pkgname}.conf - %{_libdir}/systemd/system/ksm.service - %{_libdir}/systemd/ksmctl + %{_unitdir}/ksm.service + %{_libexecdir}/ksmctl %config(noreplace) %{_sysconfdir}/sysconfig/ksm - %{_libdir}/systemd/system/ksmtuned.service + %{_unitdir}/ksmtuned.service %{_sbindir}/ksmtuned %config(noreplace) %{_sysconfdir}/ksmtuned.conf %dir %{_sysconfdir}/%{pkgname} @@ -2074,6 +3846,7 @@ sh %{_sysconfdir}/sysconfig/modules/kvm.modules &> /dev/null || : %{_datadir}/%{pkgname}/acpi-dsdt.aml %{_datadir}/%{pkgname}/q35-acpi-dsdt.aml %{_datadir}/%{pkgname}/bios.bin + %{_datadir}/%{pkgname}/bios-256k.bin %{_datadir}/%{pkgname}/sgabios.bin %{_datadir}/%{pkgname}/linuxboot.bin %{_datadir}/%{pkgname}/multiboot.bin @@ -2093,42 +3866,1021 @@ sh %{_sysconfdir}/sysconfig/modules/kvm.modules &> /dev/null || : %{_datadir}/%{pkgname}/rhel6-pcnet.rom %{_datadir}/%{pkgname}/rhel6-rtl8139.rom %{_datadir}/%{pkgname}/rhel6-ne2k_pci.rom + %{_datadir}/%{pkgname}/rhel6-e1000.rom %config(noreplace) %{_sysconfdir}/%{pkgname}/target-x86_64.conf %{?kvm_files:} %{?qemu_kvm_files:} - %if !%{rhev} -%files tools - %defattr(-,root,root,-) - %{_bindir}/kvm_stat - %endif +%files -n qemu-kvm-tools%{?pkgsuffix} + %defattr(-,root,root,-) + %{_bindir}/kvm_stat %endif -%if !%{rhev} -%files -n qemu-img - %defattr(-,root,root) - %{_bindir}/qemu-img - %{_bindir}/qemu-io - %{_bindir}/qemu-nbd - %{_mandir}/man1/qemu-img.1* - %{_mandir}/man8/qemu-nbd.8* +%files -n qemu-img%{?pkgsuffix} +%defattr(-,root,root) +%{_bindir}/qemu-img +%{_bindir}/qemu-io +%{_bindir}/qemu-nbd +%{_mandir}/man1/qemu-img.1* +%{_mandir}/man8/qemu-nbd.8* -%files -n libcacard - %defattr(-,root,root,-) - %{_libdir}/libcacard.so.* +%files -n libcacard%{?pkgsuffix} +%defattr(-,root,root,-) +%{_libdir}/libcacard.so.* -%files -n libcacard-tools - %defattr(-,root,root,-) - %{_bindir}/vscclient +%files -n libcacard-tools%{?pkgsuffix} +%defattr(-,root,root,-) +%{_bindir}/vscclient -%files -n libcacard-devel - %defattr(-,root,root,-) - %{_includedir}/cacard - %{_libdir}/libcacard.so - %{_libdir}/pkgconfig/libcacard.pc -%endif +%files -n libcacard-devel%{?pkgsuffix} +%defattr(-,root,root,-) +%{_includedir}/cacard +%{_libdir}/libcacard.so +%{_libdir}/pkgconfig/libcacard.pc %changelog +* Wed Apr 02 2014 Miroslav Rezanina - 1.5.3-60.el7 +- kvm-qcow2-fix-dangling-refcount-table-entry.patch [bz#1081793] +- kvm-qcow2-link-all-L2-meta-updates-in-preallocate.patch [bz#1081393] +- Resolves: bz#1081393 + (qemu-img will prompt that 'leaked clusters were found' while creating images with '-o preallocation=metadata,cluster_size<=1024') +- Resolves: bz#1081793 + (qemu-img core dumped when creating a qcow2 image base on block device(iscsi or libiscsi)) + +* Wed Mar 26 2014 Miroslav Rezanina - 1.5.3-59.el7 +- kvm-qemu-iotests-add-.-check-cloop-support.patch [bz#1066691] +- kvm-qemu-iotests-add-cloop-input-validation-tests.patch [bz#1066691] +- kvm-block-cloop-validate-block_size-header-field-CVE-201.patch [bz#1079455] +- kvm-block-cloop-prevent-offsets_size-integer-overflow-CV.patch [bz#1079320] +- kvm-block-cloop-refuse-images-with-huge-offsets-arrays-C.patch [bz#1079455] +- kvm-block-cloop-refuse-images-with-bogus-offsets-CVE-201.patch [bz#1079455] +- kvm-size-off-by-one.patch [bz#1066691] +- kvm-qemu-iotests-Support-for-bochs-format.patch [bz#1066691] +- kvm-bochs-Unify-header-structs-and-make-them-QEMU_PACKED.patch [bz#1066691] +- kvm-bochs-Use-unsigned-variables-for-offsets-and-sizes-C.patch [bz#1079339] +- kvm-bochs-Check-catalog_size-header-field-CVE-2014-0143.patch [bz#1079320] +- kvm-bochs-Check-extent_size-header-field-CVE-2014-0142.patch [bz#1079315] +- kvm-bochs-Fix-bitmap-offset-calculation.patch [bz#1066691] +- kvm-vpc-vhd-add-bounds-check-for-max_table_entries-and-b.patch [bz#1079455] +- kvm-vpc-Validate-block-size-CVE-2014-0142.patch [bz#1079315] +- kvm-vdi-add-bounds-checks-for-blocks_in_image-and-disk_s.patch [bz#1079455] +- kvm-vhdx-Bounds-checking-for-block_size-and-logical_sect.patch [bz#1079346] +- kvm-curl-check-data-size-before-memcpy-to-local-buffer.-.patch [bz#1079455] +- kvm-qcow2-Check-header_length-CVE-2014-0144.patch [bz#1079455] +- kvm-qcow2-Check-backing_file_offset-CVE-2014-0144.patch [bz#1079455] +- kvm-qcow2-Check-refcount-table-size-CVE-2014-0144.patch [bz#1079455] +- kvm-qcow2-Validate-refcount-table-offset.patch [bz#1066691] +- kvm-qcow2-Validate-snapshot-table-offset-size-CVE-2014-0.patch [bz#1079455] +- kvm-qcow2-Validate-active-L1-table-offset-and-size-CVE-2.patch [bz#1079455] +- kvm-qcow2-Fix-backing-file-name-length-check.patch [bz#1066691] +- kvm-qcow2-Don-t-rely-on-free_cluster_index-in-alloc_refc.patch [bz#1079339] +- kvm-qcow2-Avoid-integer-overflow-in-get_refcount-CVE-201.patch [bz#1079320] +- kvm-qcow2-Check-new-refcount-table-size-on-growth.patch [bz#1066691] +- kvm-qcow2-Fix-types-in-qcow2_alloc_clusters-and-alloc_cl.patch [bz#1066691] +- kvm-qcow2-Protect-against-some-integer-overflows-in-bdrv.patch [bz#1066691] +- kvm-qcow2-Fix-new-L1-table-size-check-CVE-2014-0143.patch [bz#1079320] +- kvm-dmg-coding-style-and-indentation-cleanup.patch [bz#1066691] +- kvm-dmg-prevent-out-of-bounds-array-access-on-terminator.patch [bz#1066691] +- kvm-dmg-drop-broken-bdrv_pread-loop.patch [bz#1066691] +- kvm-dmg-use-appropriate-types-when-reading-chunks.patch [bz#1066691] +- kvm-dmg-sanitize-chunk-length-and-sectorcount-CVE-2014-0.patch [bz#1079325] +- kvm-dmg-use-uint64_t-consistently-for-sectors-and-length.patch [bz#1066691] +- kvm-dmg-prevent-chunk-buffer-overflow-CVE-2014-0145.patch [bz#1079325] +- kvm-block-vdi-bounds-check-qemu-io-tests.patch [bz#1066691] +- kvm-block-Limit-request-size-CVE-2014-0143.patch [bz#1079320] +- kvm-qcow2-Fix-copy_sectors-with-VM-state.patch [bz#1066691] +- kvm-qcow2-Fix-NULL-dereference-in-qcow2_open-error-path-.patch [bz#1079333] +- kvm-qcow2-Fix-L1-allocation-size-in-qcow2_snapshot_load_.patch [bz#1079325] +- kvm-qcow2-Check-maximum-L1-size-in-qcow2_snapshot_load_t.patch [bz#1079320] +- kvm-qcow2-Limit-snapshot-table-size.patch [bz#1066691] +- kvm-parallels-Fix-catalog-size-integer-overflow-CVE-2014.patch [bz#1079320] +- kvm-parallels-Sanity-check-for-s-tracks-CVE-2014-0142.patch [bz#1079315] +- kvm-fix-machine-check-propagation.patch [bz#740107] +- Resolves: bz#1066691 + (qemu-kvm: include leftover patches from block layer security audit) +- Resolves: bz#1079315 + (CVE-2014-0142 qemu-kvm: qemu: crash by possible division by zero [rhel-7.0]) +- Resolves: bz#1079320 + (CVE-2014-0143 qemu-kvm: Qemu: block: multiple integer overflow flaws [rhel-7.0]) +- Resolves: bz#1079325 + (CVE-2014-0145 qemu-kvm: Qemu: prevent possible buffer overflows [rhel-7.0]) +- Resolves: bz#1079333 + (CVE-2014-0146 qemu-kvm: Qemu: qcow2: NULL dereference in qcow2_open() error path [rhel-7.0]) +- Resolves: bz#1079339 + (CVE-2014-0147 qemu-kvm: Qemu: block: possible crash due signed types or logic error [rhel-7.0]) +- Resolves: bz#1079346 + (CVE-2014-0148 qemu-kvm: Qemu: vhdx: bounds checking for block_size and logical_sector_size [rhel-7.0]) +- Resolves: bz#1079455 + (CVE-2014-0144 qemu-kvm: Qemu: block: missing input validation [rhel-7.0]) +- Resolves: bz#740107 + ([Hitachi 7.0 FEAT] KVM: MCA Recovery for KVM guest OS memory) + +* Wed Mar 26 2014 Miroslav Rezanina - 1.5.3-58.el7 +- kvm-pc-Use-cpu64-rhel6-CPU-model-by-default-on-rhel6-mac.patch [bz#1080170] +- kvm-target-i386-Copy-cpu64-rhel6-definition-into-qemu64.patch [bz#1078607 bz#1080170] +- Resolves: bz#1080170 + (intel 82576 VF not work in windows 2008 x86 - Code 12 [TestOnly]) +- Resolves: bz#1080170 + (Default CPU model for rhel6.* machine-types is different from RHEL-6) + +* Fri Mar 21 2014 Miroslav Rezanina - 1.5.3-57.el7 +- kvm-virtio-net-fix-guest-triggerable-buffer-overrun.patch [bz#1078308] +- Resolves: bz#1078308 + (EMBARGOED CVE-2014-0150 qemu: virtio-net: fix guest-triggerable buffer overrun [rhel-7.0]) + +* Fri Mar 21 2014 Miroslav Rezanina - 1.5.3-56.el7 +- kvm-configure-Fix-bugs-preventing-Ceph-inclusion.patch [bz#1078809] +- Resolves: bz#1078809 + (can not boot qemu-kvm-rhev with rbd image) + +* Wed Mar 19 2014 Miroslav Rezanina - 1.5.3-55.el7 +- kvm-scsi-Change-scsi-sense-buf-size-to-252.patch [bz#1058173] +- kvm-scsi-Fix-migration-of-scsi-sense-data.patch [bz#1058173] +- Resolves: bz#1058173 + (qemu-kvm core dump booting guest with scsi-generic disk attached when using built-in iscsi driver) + +* Wed Mar 19 2014 Miroslav Rezanina - 1.5.3-54.el7 +- kvm-qdev-monitor-Set-properties-after-parent-is-assigned.patch [bz#1046248] +- kvm-block-Update-image-size-in-bdrv_invalidate_cache.patch [bz#1048575] +- kvm-qcow2-Keep-option-in-qcow2_invalidate_cache.patch [bz#1048575] +- kvm-qcow2-Check-bs-drv-in-copy_sectors.patch [bz#1048575] +- kvm-block-bs-drv-may-be-NULL-in-bdrv_debug_resume.patch [bz#1048575] +- kvm-iotests-Test-corruption-during-COW-request.patch [bz#1048575] +- Resolves: bz#1046248 + (qemu-kvm crash when send "info qtree" after hot plug a device with invalid addr) +- Resolves: bz#1048575 + (Segmentation fault occurs after migrate guest(use scsi disk and add stress) to des machine) + +* Wed Mar 12 2014 Miroslav Rezanina - 1.5.3-53.el7 +- kvm-dataplane-Fix-startup-race.patch [bz#1069541] +- kvm-QMP-Relax-__com.redhat_drive_add-parameter-checking.patch [bz#1057471] +- kvm-all-exit-in-case-max-vcpus-exceeded.patch [bz#993429] +- kvm-block-gluster-code-movements-state-storage-changes.patch [bz#1031526] +- kvm-block-gluster-add-reopen-support.patch [bz#1031526] +- kvm-virtio-net-add-feature-bit-for-any-header-s-g.patch [bz#990989] +- kvm-spec-Add-README.rhel6-gpxe-source.patch [bz#1073774] +- kvm-pc-Add-RHEL6-e1000-gPXE-image.patch [bz#1073774] +- kvm-loader-rename-in_ram-has_mr.patch [bz#1064018] +- kvm-pc-avoid-duplicate-names-for-ROM-MRs.patch [bz#1064018] +- kvm-qemu-img-convert-Fix-progress-output.patch [bz#1073728] +- kvm-qemu-iotests-Test-progress-output-for-conversion.patch [bz#1073728] +- kvm-iscsi-Use-bs-sg-for-everything-else-than-disks.patch [bz#1067784] +- kvm-block-Fix-bs-request_alignment-assertion-for-bs-sg-1.patch [bz#1067784] +- kvm-qemu_file-use-fwrite-correctly.patch [bz#1005103] +- kvm-qemu_file-Fix-mismerge-of-use-fwrite-correctly.patch [bz#1005103] +- Resolves: bz#1005103 + (Migration should fail when migrate guest offline to a file which is specified to a readonly directory.) +- Resolves: bz#1031526 + (Can not commit snapshot when disk is using glusterfs:native backend) +- Resolves: bz#1057471 + (fail to do hot-plug with "discard = on" with "Invalid parameter 'discard'" error) +- Resolves: bz#1064018 + (abort from conflicting genroms) +- Resolves: bz#1067784 + (qemu-kvm: block.c:850: bdrv_open_common: Assertion `bs->request_alignment != 0' failed. Aborted (core dumped)) +- Resolves: bz#1069541 + (Segmentation fault when boot guest with dataplane=on) +- Resolves: bz#1073728 + (progress bar doesn't display when converting with -p) +- Resolves: bz#1073774 + (e1000 ROM cause migrate fail from RHEL6.5 host to RHEL7.0 host) +- Resolves: bz#990989 + (backport inline header virtio-net optimization) +- Resolves: bz#993429 + (kvm: test maximum number of vcpus supported (rhel7)) + +* Wed Mar 05 2014 Miroslav Rezanina - 1.5.3-52.el7 +- kvm-target-i386-Move-hyperv_-static-globals-to-X86CPU.patch [bz#1004773] +- kvm-Fix-uninitialized-cpuid_data.patch [bz#1057173] +- kvm-fix-coexistence-of-KVM-and-Hyper-V-leaves.patch [bz#1004773] +- kvm-make-availability-of-Hyper-V-enlightenments-depe.patch [bz#1004773] +- kvm-make-hyperv-hypercall-and-guest-os-id-MSRs-migra.patch [bz#1004773] +- kvm-make-hyperv-vapic-assist-page-migratable.patch [bz#1004773] +- kvm-target-i386-Convert-hv_relaxed-to-static-property.patch [bz#1057173] +- kvm-target-i386-Convert-hv_vapic-to-static-property.patch [bz#1057173] +- kvm-target-i386-Convert-hv_spinlocks-to-static-property.patch [bz#1057173] +- kvm-target-i386-Convert-check-and-enforce-to-static-prop.patch [bz#1004773] +- kvm-target-i386-Cleanup-foo-feature-handling.patch [bz#1057173] +- kvm-add-support-for-hyper-v-timers.patch [bz#1057173] +- Resolves: bz#1004773 + (Hyper-V guest OS id and hypercall MSRs not migrated) +- Resolves: bz#1057173 + (KVM Hyper-V Enlightenment - New feature - hv-time (QEMU)) + +* Wed Mar 05 2014 Miroslav Rezanina - 1.5.3-51.el7 +- kvm-qmp-access-the-local-QemuOptsLists-for-drive-option.patch [bz#1026184] +- kvm-qxl-add-sanity-check.patch [bz#751937] +- kvm-Fix-two-XBZRLE-corruption-issues.patch [bz#1063417] +- kvm-qdev-monitor-set-DeviceState-opts-before-calling-rea.patch [bz#1037956] +- kvm-vfio-blacklist-loading-of-unstable-roms.patch [bz#1037956] +- kvm-block-Set-block-filename-sizes-to-PATH_MAX-instead-o.patch [bz#1072339] +- Resolves: bz#1026184 + (QMP: querying -drive option returns a NULL parameter list) +- Resolves: bz#1037956 + (bnx2x: boot one guest to do vfio-pci with all PFs assigned in same group meet QEMU segmentation fault (Broadcom BCM57810 card)) +- Resolves: bz#1063417 + (google stressapptest vs Migration) +- Resolves: bz#1072339 + (RHEV: Cannot start VMs that have more than 23 snapshots.) +- Resolves: bz#751937 + (qxl triggers assert during iofuzz test) + +* Wed Feb 26 2014 Miroslav Rezanina - 1.5.3-50.el7 +- kvm-mempath-prefault-fix-off-by-one-error.patch [bz#1069039] +- kvm-qemu-option-has_help_option-and-is_valid_option_list.patch [bz#1065873] +- kvm-qemu-img-create-Support-multiple-o-options.patch [bz#1065873] +- kvm-qemu-img-convert-Support-multiple-o-options.patch [bz#1065873] +- kvm-qemu-img-amend-Support-multiple-o-options.patch [bz#1065873] +- kvm-qemu-img-Allow-o-help-with-incomplete-argument-list.patch [bz#1065873] +- kvm-qemu-iotests-Check-qemu-img-command-line-parsing.patch [bz#1065873] +- Resolves: bz#1065873 + (qemu-img silently ignores options with multiple -o parameters) +- Resolves: bz#1069039 + (-mem-prealloc option behaviour is opposite to expected) + +* Wed Feb 19 2014 Miroslav Rezanina - 1.5.3-49.el7 +- kvm-xhci-add-support-for-suspend-resume.patch [bz#1012365] +- kvm-qcow2-remove-n_start-and-n_end-of-qcow2_alloc_cluste.patch [bz#1049176] +- kvm-qcow2-fix-offset-overflow-in-qcow2_alloc_clusters_at.patch [bz#1049176] +- kvm-qcow2-check-for-NULL-l2meta.patch [bz#1055848] +- kvm-qemu-iotests-add-test-for-qcow2-preallocation-with-d.patch [bz#1055848] +- Resolves: bz#1012365 + (xhci usb storage lost in guest after wakeup from S3) +- Resolves: bz#1049176 + (qemu-img core dump when using "-o preallocation=metadata,cluster_size=2048k" to create image of libiscsi lun) +- Resolves: bz#1055848 + (qemu-img core dumped when cluster size is larger than the default value with opreallocation=metadata specified) + +* Mon Feb 17 2014 Miroslav Rezanina - 1.5.3-48.el7 +- kvm-spec-disable-qom-cast-debug.patch [bz#1063942] +- kvm-fix-guest-physical-bits-to-match-host-to-go-beyond-1.patch [bz#989677] +- kvm-monitor-Cleanup-mon-outbuf-on-write-error.patch [bz#1065225] +- Resolves: bz#1063942 + (configure qemu-kvm with --disable-qom-cast-debug) +- Resolves: bz#1065225 + (QMP socket breaks on unexpected close) +- Resolves: bz#989677 + ([HP 7.0 FEAT]: Increase KVM guest supported memory to 4TiB) + +* Wed Feb 12 2014 Miroslav Rezanina - 1.5.3-47.el7 +- kvm-seccomp-add-mkdir-and-fchmod-to-the-whitelist.patch [bz#1026314] +- kvm-seccomp-add-some-basic-shared-memory-syscalls-to-the.patch [bz#1026314] +- kvm-scsi-Support-TEST-UNIT-READY-in-the-dummy-LUN0.patch [bz#1004143] +- kvm-usb-add-vendor-request-defines.patch [bz#1039530] +- kvm-usb-move-usb_-hi-lo-helpers-to-header-file.patch [bz#1039530] +- kvm-usb-add-support-for-microsoft-os-descriptors.patch [bz#1039530] +- kvm-usb-add-microsoft-os-descriptors-compat-property.patch [bz#1039530] +- kvm-usb-hid-add-microsoft-os-descriptor-support.patch [bz#1039530] +- kvm-configure-add-option-to-disable-fstack-protect.patch [bz#1044182] +- kvm-exec-always-use-MADV_DONTFORK.patch [bz#1004197] +- kvm-pc-Save-size-of-RAM-below-4GB.patch [bz#1048080] +- kvm-acpi-Fix-PCI-hole-handling-on-build_srat.patch [bz#1048080] +- kvm-Add-check-for-cache-size-smaller-than-page-size.patch [bz#1017096] +- kvm-XBZRLE-cache-size-should-not-be-larger-than-guest-me.patch [bz#1047448] +- kvm-Don-t-abort-on-out-of-memory-when-creating-page-cach.patch [bz#1047448] +- kvm-Don-t-abort-on-memory-allocation-error.patch [bz#1047448] +- kvm-Set-xbzrle-buffers-to-NULL-after-freeing-them-to-avo.patch [bz#1038540] +- kvm-migration-fix-free-XBZRLE-decoded_buf-wrong.patch [bz#1038540] +- kvm-block-resize-backing-file-image-during-offline-commi.patch [bz#1047254] +- kvm-block-resize-backing-image-during-active-layer-commi.patch [bz#1047254] +- kvm-block-update-block-commit-documentation-regarding-im.patch [bz#1047254] +- kvm-block-Fix-bdrv_commit-return-value.patch [bz#1047254] +- kvm-block-remove-QED-.bdrv_make_empty-implementation.patch [bz#1047254] +- kvm-block-remove-qcow2-.bdrv_make_empty-implementation.patch [bz#1047254] +- kvm-qemu-progress-Drop-unused-include.patch [bz#997878] +- kvm-qemu-progress-Fix-progress-printing-on-SIGUSR1.patch [bz#997878] +- kvm-Documentation-qemu-img-Mention-SIGUSR1-progress-repo.patch [bz#997878] +- Resolves: bz#1004143 + ("test unit ready failed" on LUN 0 delays boot when a virtio-scsi target does not have any disk on LUN 0) +- Resolves: bz#1004197 + (Cannot hot-plug nic in windows VM when the vmem is larger) +- Resolves: bz#1017096 + (Fail to migrate while the size of migrate-compcache less then 4096) +- Resolves: bz#1026314 + (qemu-kvm hang when use '-sandbox on'+'vnc'+'hda') +- Resolves: bz#1038540 + (qemu-kvm aborted while cancel migration then restart it (with page delta compression)) +- Resolves: bz#1039530 + (add support for microsoft os descriptors) +- Resolves: bz#1044182 + (Relax qemu-kvm stack protection to -fstack-protector-strong) +- Resolves: bz#1047254 + (qemu-img failed to commit image) +- Resolves: bz#1047448 + (qemu-kvm core dump in src host when do migration with "migrate_set_capability xbzrle on and migrate_set_cache_size 10000G") +- Resolves: bz#1048080 + (Qemu-kvm NUMA emulation failed) +- Resolves: bz#997878 + (Kill -SIGUSR1 `pidof qemu-img convert` can not get progress of qemu-img) + +* Wed Feb 12 2014 Miroslav Rezanina - 1.5.3-46.el7 +- kvm-block-fix-backing-file-segfault.patch [bz#748906] +- kvm-block-Move-initialisation-of-BlockLimits-to-bdrv_ref.patch [bz#748906] +- kvm-raw-Fix-BlockLimits-passthrough.patch [bz#748906] +- kvm-block-Inherit-opt_transfer_length.patch [bz#748906] +- kvm-block-Update-BlockLimits-when-they-might-have-change.patch [bz#748906] +- kvm-qemu_memalign-Allow-small-alignments.patch [bz#748906] +- kvm-block-Detect-unaligned-length-in-bdrv_qiov_is_aligne.patch [bz#748906] +- kvm-block-Don-t-use-guest-sector-size-for-qemu_blockalig.patch [bz#748906] +- kvm-block-rename-buffer_alignment-to-guest_block_size.patch [bz#748906] +- kvm-raw-Probe-required-direct-I-O-alignment.patch [bz#748906] +- kvm-block-Introduce-bdrv_aligned_preadv.patch [bz#748906] +- kvm-block-Introduce-bdrv_co_do_preadv.patch [bz#748906] +- kvm-block-Introduce-bdrv_aligned_pwritev.patch [bz#748906] +- kvm-block-write-Handle-COR-dependency-after-I-O-throttli.patch [bz#748906] +- kvm-block-Introduce-bdrv_co_do_pwritev.patch [bz#748906] +- kvm-block-Switch-BdrvTrackedRequest-to-byte-granularity.patch [bz#748906] +- kvm-block-Allow-waiting-for-overlapping-requests-between.patch [bz#748906] +- kvm-block-use-DIV_ROUND_UP-in-bdrv_co_do_readv.patch [bz#748906] +- kvm-block-Make-zero-after-EOF-work-with-larger-alignment.patch [bz#748906] +- kvm-block-Generalise-and-optimise-COR-serialisation.patch [bz#748906] +- kvm-block-Make-overlap-range-for-serialisation-dynamic.patch [bz#748906] +- kvm-block-Fix-32-bit-truncation-in-mark_request_serialis.patch [bz#748906] +- kvm-block-Allow-wait_serialising_requests-at-any-point.patch [bz#748906] +- kvm-block-Align-requests-in-bdrv_co_do_pwritev.patch [bz#748906] +- kvm-lock-Fix-memory-leaks-in-bdrv_co_do_pwritev.patch [bz#748906] +- kvm-block-Assert-serialisation-assumptions-in-pwritev.patch [bz#748906] +- kvm-block-Change-coroutine-wrapper-to-byte-granularity.patch [bz#748906] +- kvm-block-Make-bdrv_pread-a-bdrv_prwv_co-wrapper.patch [bz#748906] +- kvm-block-Make-bdrv_pwrite-a-bdrv_prwv_co-wrapper.patch [bz#748906] +- kvm-iscsi-Set-bs-request_alignment.patch [bz#748906] +- kvm-blkdebug-Make-required-alignment-configurable.patch [bz#748906] +- kvm-blkdebug-Don-t-leak-bs-file-on-failure.patch [bz#748906] +- kvm-qemu-io-New-command-sleep.patch [bz#748906] +- kvm-qemu-iotests-Filter-out-qemu-io-prompt.patch [bz#748906] +- kvm-qemu-iotests-Test-pwritev-RMW-logic.patch [bz#748906] +- kvm-block-bdrv_aligned_pwritev-Assert-overlap-range.patch [bz#748906] +- kvm-block-Don-t-call-ROUND_UP-with-negative-values.patch [bz#748906] +- Resolves: bz#748906 + (qemu fails on disk with 4k sectors and cache=off) + +* Wed Feb 05 2014 Miroslav Rezanina - 1.5.3-45.el7 +- kvm-vfio-pci-Fail-initfn-on-DMA-mapping-errors.patch [bz#1044815] +- kvm-vfio-Destroy-memory-regions.patch [bz#1052030] +- kvm-docs-qcow2-compat-1.1-is-now-the-default.patch [bz#1048092] +- kvm-hda-codec-disable-streams-on-reset.patch [bz#947812] +- kvm-QEMUBH-make-AioContext-s-bh-re-entrant.patch [bz#1009297] +- kvm-qxl-replace-pipe-signaling-with-bottom-half.patch [bz#1009297] +- Resolves: bz#1009297 + (RHEL7.0 guest gui can not be used in dest host after migration) +- Resolves: bz#1044815 + (vfio initfn succeeds even if IOMMU mappings fail) +- Resolves: bz#1048092 + (manpage of qemu-img contains error statement about compat option) +- Resolves: bz#1052030 + (src qemu-kvm core dump after hotplug/unhotplug GPU device and do local migration) +- Resolves: bz#947812 + (There's a shot voice after 'system_reset' during playing music inside rhel6 guest w/ intel-hda device) + +* Wed Jan 29 2014 Miroslav Rezanina - 1.5.3-44.el7 +- kvm-Partially-revert-rhel-Drop-cfi.pflash01-and-isa-ide-.patch [bz#1032346] +- kvm-Revert-pc-Disable-the-use-flash-device-for-BIOS-unle.patch [bz#1032346] +- kvm-memory-Replace-open-coded-memory_region_is_romd.patch [bz#1032346] +- kvm-memory-Rename-readable-flag-to-romd_mode.patch [bz#1032346] +- kvm-isapc-Fix-non-KVM-qemu-boot-read-write-memory-for-is.patch [bz#1032346] +- kvm-add-kvm_readonly_mem_enabled.patch [bz#1032346] +- kvm-support-using-KVM_MEM_READONLY-flag-for-regions.patch [bz#1032346] +- kvm-pc_sysfw-allow-flash-pflash-memory-to-be-used-with-K.patch [bz#1032346] +- kvm-fix-double-free-the-memslot-in-kvm_set_phys_mem.patch [bz#1032346] +- kvm-sysfw-remove-read-only-pc_sysfw_flash_vs_rom_bug_com.patch [bz#1032346] +- kvm-pc_sysfw-remove-the-rom_only-property.patch [bz#1032346] +- kvm-pc_sysfw-do-not-make-it-a-device-anymore.patch [bz#1032346] +- kvm-hw-i386-pc_sysfw-support-two-flash-drives.patch [bz#1032346] +- kvm-i440fx-test-qtest_start-should-be-paired-with-qtest_.patch [bz#1032346] +- kvm-i440fx-test-give-each-GTest-case-its-own-qtest.patch [bz#1032346] +- kvm-i440fx-test-generate-temporary-firmware-blob.patch [bz#1032346] +- kvm-i440fx-test-verify-firmware-under-4G-and-1M-both-bio.patch [bz#1032346] +- kvm-piix-fix-32bit-pci-hole.patch [bz#1032346] +- kvm-qapi-Add-backing-to-BlockStats.patch [bz#1041564] +- kvm-pc-Disable-RDTSCP-unconditionally-on-rhel6.-machine-.patch [bz#918907] +- kvm-pc-Disable-RDTSCP-on-AMD-CPU-models.patch [bz#1056428 bz#874400] +- kvm-block-add-.bdrv_reopen_prepare-stub-for-iscsi.patch [bz#1030301] +- Resolves: bz#1030301 + (qemu-img can not merge live snapshot to backing file(r/w backing file via libiscsi)) +- Resolves: bz#1032346 + (basic OVMF support (non-volatile UEFI variables in flash, and fixup for ACPI tables)) +- Resolves: bz#1041564 + ([NFR] qemu: Returning the watermark for all the images opened for writing) +- Resolves: bz#1056428 + ("rdtscp" flag defined on Opteron_G5 model and cann't be exposed to guest) +- Resolves: bz#874400 + ("rdtscp" flag defined on Opteron_G5 model and cann't be exposed to guest) +- Resolves: bz#918907 + (provide backwards-compatible RHEL specific machine types in QEMU - CPU features) + +* Mon Jan 27 2014 Miroslav Rezanina - 1.5.3-43.el7 +- kvm-piix-gigabyte-alignment-for-ram.patch [bz#1026548] +- kvm-pc_piix-document-gigabyte_align.patch [bz#1026548] +- kvm-q35-gigabyle-alignment-for-ram.patch [bz#1026548] +- kvm-virtio-bus-remove-vdev-field.patch [bz#983344] +- kvm-virtio-pci-remove-vdev-field.patch [bz#983344] +- kvm-virtio-bus-cleanup-plug-unplug-interface.patch [bz#983344] +- kvm-virtio-blk-switch-exit-callback-to-VirtioDeviceClass.patch [bz#983344] +- kvm-virtio-serial-switch-exit-callback-to-VirtioDeviceCl.patch [bz#983344] +- kvm-virtio-net-switch-exit-callback-to-VirtioDeviceClass.patch [bz#983344] +- kvm-virtio-scsi-switch-exit-callback-to-VirtioDeviceClas.patch [bz#983344] +- kvm-virtio-balloon-switch-exit-callback-to-VirtioDeviceC.patch [bz#983344] +- kvm-virtio-rng-switch-exit-callback-to-VirtioDeviceClass.patch [bz#983344] +- kvm-virtio-pci-add-device_unplugged-callback.patch [bz#983344] +- kvm-block-use-correct-filename-for-error-report.patch [bz#1051438] +- Resolves: bz#1026548 + (i386: pc: align gpa<->hpa on 1GB boundary) +- Resolves: bz#1051438 + (Error message contains garbled characters when unable to open image due to bad permissions (permission denied).) +- Resolves: bz#983344 + (QEMU core dump and host will reboot when do hot-unplug a virtio-blk disk which use the switch behind switch) + +* Fri Jan 24 2014 Daniel Mach - 10:1.5.3-42 +- Mass rebuild 2014-01-24 + +* Wed Jan 22 2014 Miroslav Rezanina - 1.5.3-41.el7 +- kvm-help-add-id-suboption-to-iscsi.patch [bz#1019221] +- kvm-scsi-disk-add-UNMAP-limits-to-block-limits-VPD-page.patch [bz#1037503] +- kvm-qdev-Fix-32-bit-compilation-in-print_size.patch [bz#1034876] +- kvm-qdev-Use-clz-in-print_size.patch [bz#1034876] +- Resolves: bz#1019221 + (Iscsi miss id sub-option in help output) +- Resolves: bz#1034876 + (export acpi tables to guests) +- Resolves: bz#1037503 + (fix thin provisioning support for block device backends) + +* Wed Jan 22 2014 Miroslav Rezanina - 1.5.3-40.el7 +- kvm-avoid-a-bogus-COMPLETED-CANCELLED-transition.patch [bz#1053699] +- kvm-introduce-MIG_STATE_CANCELLING-state.patch [bz#1053699] +- kvm-vvfat-use-bdrv_new-to-allocate-BlockDriverState.patch [bz#1041301] +- kvm-block-implement-reference-count-for-BlockDriverState.patch [bz#1041301] +- kvm-block-make-bdrv_delete-static.patch [bz#1041301] +- kvm-migration-omit-drive-ref-as-we-have-bdrv_ref-now.patch [bz#1041301] +- kvm-xen_disk-simplify-blk_disconnect-with-refcnt.patch [bz#1041301] +- kvm-nbd-use-BlockDriverState-refcnt.patch [bz#1041301] +- kvm-block-use-BDS-ref-for-block-jobs.patch [bz#1041301] +- kvm-block-Make-BlockJobTypes-const.patch [bz#1041301] +- kvm-blockjob-rename-BlockJobType-to-BlockJobDriver.patch [bz#1041301] +- kvm-qapi-Introduce-enum-BlockJobType.patch [bz#1041301] +- kvm-qapi-make-use-of-new-BlockJobType.patch [bz#1041301] +- kvm-mirror-Don-t-close-target.patch [bz#1041301] +- kvm-mirror-Move-base-to-MirrorBlockJob.patch [bz#1041301] +- kvm-block-Add-commit_active_start.patch [bz#1041301] +- kvm-commit-Support-commit-active-layer.patch [bz#1041301] +- kvm-qemu-iotests-prefill-some-data-to-test-image.patch [bz#1041301] +- kvm-qemu-iotests-Update-test-cases-for-commit-active.patch [bz#1041301] +- kvm-commit-Remove-unused-check.patch [bz#1041301] +- kvm-blockdev-use-bdrv_getlength-in-qmp_drive_mirror.patch [bz#921890] +- kvm-qemu-iotests-make-assert_no_active_block_jobs-common.patch [bz#921890] +- kvm-block-drive-mirror-Check-for-NULL-backing_hd.patch [bz#921890] +- kvm-qemu-iotests-Extend-041-for-unbacked-mirroring.patch [bz#921890] +- kvm-qapi-schema-Update-description-for-NewImageMode.patch [bz#921890] +- kvm-block-drive-mirror-Reuse-backing-HD-for-sync-none.patch [bz#921890] +- kvm-qemu-iotests-Fix-test-041.patch [bz#921890] +- kvm-scsi-bus-fix-transfer-length-and-direction-for-VERIF.patch [bz#1035644] +- kvm-scsi-disk-fix-VERIFY-emulation.patch [bz#1035644] +- kvm-block-ensure-bdrv_drain_all-works-during-bdrv_delete.patch [bz#1041301] +- kvm-use-recommended-max-vcpu-count.patch [bz#998708] +- kvm-pc-Create-pc_compat_rhel-functions.patch [bz#1049706] +- kvm-pc-Enable-x2apic-by-default-on-more-recent-CPU-model.patch [bz#1049706] +- kvm-Build-all-subpackages-for-RHEV.patch [bz#1007204] +- Resolves: bz#1007204 + (qemu-img-rhev qemu-kvm-rhev-tools are not built for qemu-kvm-1.5.3-3.el7) +- Resolves: bz#1035644 + (rhel7.0host + windows guest + virtio-win + 'chkdsk' in the guest gives qemu assertion in scsi_dma_complete) +- Resolves: bz#1041301 + (live snapshot merge (commit) of the active layer) +- Resolves: bz#1049706 + (MIss CPUID_EXT_X2APIC in Westmere cpu model) +- Resolves: bz#1053699 + (Backport Cancelled race condition fixes) +- Resolves: bz#921890 + (Core dump when block mirror with "sync" is "none" and mode is "absolute-paths") +- Resolves: bz#998708 + (qemu-kvm: maximum vcpu should be recommended maximum) + +* Tue Jan 21 2014 Miroslav Rezanina - 1.5.3-39.el7 +- kvm-Revert-qdev-monitor-Fix-crash-when-device_add-is-cal.patch [bz#669524] +- kvm-Revert-qdev-Do-not-let-the-user-try-to-device_add-wh.patch [bz#669524] +- kvm-qdev-monitor-Clean-up-qdev_device_add-variable-namin.patch [bz#669524] +- kvm-qdev-monitor-Fix-crash-when-device_add-is-called.2.patch.patch [bz#669524] +- kvm-qdev-monitor-Avoid-qdev-as-variable-name.patch [bz#669524] +- kvm-qdev-monitor-Inline-qdev_init-for-device_add.patch [bz#669524] +- kvm-qdev-Do-not-let-the-user-try-to-device_add-when-it.2.patch.patch [bz#669524] +- kvm-qdev-monitor-Avoid-device_add-crashing-on-non-device.patch [bz#669524] +- kvm-qdev-monitor-Improve-error-message-for-device-nonexi.patch [bz#669524] +- kvm-exec-change-well-known-physical-sections-to-macros.patch [bz#1003535] +- kvm-exec-separate-sections-and-nodes-per-address-space.patch [bz#1003535] +- Resolves: bz#1003535 + (qemu-kvm core dump when boot vm with more than 32 virtio disks/nics) +- Resolves: bz#669524 + (Confusing error message from -device ) + +* Fri Jan 17 2014 Miroslav Rezanina - 1.5.3-38.el7 +- kvm-intel-hda-fix-position-buffer.patch [bz#947785] +- kvm-The-calculation-of-bytes_xfer-in-qemu_put_buffer-is-.patch [bz#1003467] +- kvm-migration-Fix-rate-limit.patch [bz#1003467] +- kvm-audio-honor-QEMU_AUDIO_TIMER_PERIOD-instead-of-wakin.patch [bz#1017636] +- kvm-audio-Lower-default-wakeup-rate-to-100-times-second.patch [bz#1017636] +- kvm-audio-adjust-pulse-to-100Hz-wakeup-rate.patch [bz#1017636] +- kvm-pc-Fix-rhel6.-3dnow-3dnowext-compat-bits.patch [bz#918907] +- kvm-add-firmware-to-machine-options.patch [bz#1038603] +- kvm-switch-rhel7-machine-types-to-big-bios.patch [bz#1038603] +- kvm-add-bios-256k.bin-from-seabios-bin-1.7.2.2-10.el7.no.patch [bz#1038603] +- kvm-pci-fix-pci-bridge-fw-path.patch [bz#1034518] +- kvm-hw-cannot_instantiate_with_device_add_yet-due-to-poi.patch [bz#1031098] +- kvm-qdev-Document-that-pointer-properties-kill-device_ad.patch [bz#1031098] +- kvm-Add-back-no-hpet-but-ignore-it.patch [bz#1044742] +- Resolves: bz#1003467 + (Backport migration fixes from post qemu 1.6) +- Resolves: bz#1017636 + (PATCH: fix qemu using 50% host cpu when audio is playing) +- Resolves: bz#1031098 + (Disable device smbus-eeprom) +- Resolves: bz#1034518 + (boot order wrong with q35) +- Resolves: bz#1038603 + (make seabios 256k for rhel7 machine types) +- Resolves: bz#1044742 + (Cannot create guest on remote RHEL7 host using F20 virt-manager, libvirt's qemu -no-hpet detection is broken) +- Resolves: bz#918907 + (provide backwards-compatible RHEL specific machine types in QEMU - CPU features) +- Resolves: bz#947785 + (In rhel6.4 guest sound recorder doesn't work when playing audio) + +* Wed Jan 15 2014 Miroslav Rezanina - 1.5.3-37.el7 +- kvm-bitmap-use-long-as-index.patch [bz#997559] +- kvm-memory-cpu_physical_memory_set_dirty_flags-result-is.patch [bz#997559] +- kvm-memory-cpu_physical_memory_set_dirty_range-return-vo.patch [bz#997559] +- kvm-exec-use-accessor-function-to-know-if-memory-is-dirt.patch [bz#997559] +- kvm-memory-create-function-to-set-a-single-dirty-bit.patch [bz#997559] +- kvm-exec-drop-useless-if.patch [bz#997559] +- kvm-exec-create-function-to-get-a-single-dirty-bit.patch [bz#997559] +- kvm-memory-make-cpu_physical_memory_is_dirty-return-bool.patch [bz#997559] +- kvm-memory-all-users-of-cpu_physical_memory_get_dirty-us.patch [bz#997559] +- kvm-memory-set-single-dirty-flags-when-possible.patch [bz#997559] +- kvm-memory-cpu_physical_memory_set_dirty_range-always-di.patch [bz#997559] +- kvm-memory-cpu_physical_memory_mask_dirty_range-always-c.patch [bz#997559] +- kvm-memory-use-bit-2-for-migration.patch [bz#997559] +- kvm-memory-make-sure-that-client-is-always-inside-range.patch [bz#997559] +- kvm-memory-only-resize-dirty-bitmap-when-memory-size-inc.patch [bz#997559] +- kvm-memory-cpu_physical_memory_clear_dirty_flag-result-i.patch [bz#997559] +- kvm-bitmap-Add-bitmap_zero_extend-operation.patch [bz#997559] +- kvm-memory-split-dirty-bitmap-into-three.patch [bz#997559] +- kvm-memory-unfold-cpu_physical_memory_clear_dirty_flag-i.patch [bz#997559] +- kvm-memory-unfold-cpu_physical_memory_set_dirty-in-its-o.patch [bz#997559] +- kvm-memory-unfold-cpu_physical_memory_set_dirty_flag.patch [bz#997559] +- kvm-memory-make-cpu_physical_memory_get_dirty-the-main-f.patch [bz#997559] +- kvm-memory-cpu_physical_memory_get_dirty-is-used-as-retu.patch [bz#997559] +- kvm-memory-s-mask-clear-cpu_physical_memory_mask_dirty_r.patch [bz#997559] +- kvm-memory-use-find_next_bit-to-find-dirty-bits.patch [bz#997559] +- kvm-memory-cpu_physical_memory_set_dirty_range-now-uses-.patch [bz#997559] +- kvm-memory-cpu_physical_memory_clear_dirty_range-now-use.patch [bz#997559] +- kvm-memory-s-dirty-clean-in-cpu_physical_memory_is_dirty.patch [bz#997559] +- kvm-memory-make-cpu_physical_memory_reset_dirty-take-a-l.patch [bz#997559] +- kvm-exec-Remove-unused-global-variable-phys_ram_fd.patch [bz#997559] +- kvm-memory-cpu_physical_memory_set_dirty_tracking-should.patch [bz#997559] +- kvm-memory-move-private-types-to-exec.c.patch [bz#997559] +- kvm-memory-split-cpu_physical_memory_-functions-to-its-o.patch [bz#997559] +- kvm-memory-unfold-memory_region_test_and_clear.patch [bz#997559] +- kvm-use-directly-cpu_physical_memory_-api-for-tracki.patch [bz#997559] +- kvm-refactor-start-address-calculation.patch [bz#997559] +- kvm-memory-move-bitmap-synchronization-to-its-own-functi.patch [bz#997559] +- kvm-memory-syncronize-kvm-bitmap-using-bitmaps-operation.patch [bz#997559] +- kvm-ram-split-function-that-synchronizes-a-range.patch [bz#997559] +- kvm-migration-synchronize-memory-bitmap-64bits-at-a-time.patch [bz#997559] +- Resolves: bz#997559 + (Improve live migration bitmap handling) + +* Tue Jan 14 2014 Miroslav Rezanina - 1.5.3-36.el7 +- kvm-Add-support-statement-to-help-output.patch [bz#972773] +- kvm-__com.redhat_qxl_screendump-add-docs.patch [bz#903910] +- kvm-vl-Round-memory-sizes-below-2MiB-up-to-2MiB.patch [bz#999836] +- kvm-seccomp-exit-if-seccomp_init-fails.patch [bz#1044845] +- kvm-redhat-qemu-kvm.spec-require-python-for-build.patch [bz#1034876] +- kvm-redhat-qemu-kvm.spec-require-iasl.patch [bz#1034876] +- kvm-configure-make-iasl-option-actually-work.patch [bz#1034876] +- kvm-redhat-qemu-kvm.spec-add-cpp-as-build-dependency.patch [bz#1034876] +- kvm-acpi-build-disable-with-no-acpi.patch [bz#1045386] +- kvm-ehci-implement-port-wakeup.patch [bz#1039513] +- kvm-qdev-monitor-Fix-crash-when-device_add-is-called-wit.patch [bz#1026712 bz#1046007] +- kvm-block-vhdx-improve-error-message-and-.bdrv_check-imp.patch [bz#1035001] +- kvm-docs-updated-qemu-img-man-page-and-qemu-doc-to-refle.patch [bz#1017650] +- kvm-enable-pvticketlocks-by-default.patch [bz#1052340] +- kvm-fix-boot-strict-regressed-in-commit-6ef4716.patch [bz#997817] +- kvm-vl-make-boot_strict-variable-static-not-used-outside.patch [bz#997817] +- Resolves: bz#1017650 + (need to update qemu-img man pages on "VHDX" format) +- Resolves: bz#1026712 + (Qemu core dumpd when boot guest with driver name as "virtio-pci") +- Resolves: bz#1034876 + (export acpi tables to guests) +- Resolves: bz#1035001 + (VHDX: journal log should not be replayed by default, but rather via qemu-img check -r all) +- Resolves: bz#1039513 + (backport remote wakeup for ehci) +- Resolves: bz#1044845 + (QEMU seccomp sandbox - exit if seccomp_init() fails) +- Resolves: bz#1045386 + (qemu-kvm: hw/i386/acpi-build.c:135: acpi_get_pm_info: Assertion `obj' failed.) +- Resolves: bz#1046007 + (qemu-kvm aborted when hot plug PCI device to guest with romfile and rombar=0) +- Resolves: bz#1052340 + (pvticketlocks: default on) +- Resolves: bz#903910 + (RHEL7 does not have equivalent functionality for __com.redhat_qxl_screendump) +- Resolves: bz#972773 + (RHEL7: Clarify support statement in KVM help) +- Resolves: bz#997817 + (-boot order and -boot once regressed since RHEL-6) +- Resolves: bz#999836 + (-m 1 crashes) + +* Thu Jan 09 2014 Miroslav Rezanina - 1.5.3-35.el7 +- kvm-option-Add-assigned-flag-to-QEMUOptionParameter.patch [bz#1033490] +- kvm-qcow2-refcount-Snapshot-update-for-zero-clusters.patch [bz#1033490] +- kvm-qemu-iotests-Snapshotting-zero-clusters.patch [bz#1033490] +- kvm-block-Image-file-option-amendment.patch [bz#1033490] +- kvm-qcow2-cache-Empty-cache.patch [bz#1033490] +- kvm-qcow2-cluster-Expand-zero-clusters.patch [bz#1033490] +- kvm-qcow2-Save-refcount-order-in-BDRVQcowState.patch [bz#1033490] +- kvm-qcow2-Implement-bdrv_amend_options.patch [bz#1033490] +- kvm-qcow2-Correct-bitmap-size-in-zero-expansion.patch [bz#1033490] +- kvm-qcow2-Free-only-newly-allocated-clusters-on-error.patch [bz#1033490] +- kvm-qcow2-Add-missing-space-in-error-message.patch [bz#1033490] +- kvm-qemu-iotest-qcow2-image-option-amendment.patch [bz#1033490] +- kvm-qemu-iotests-New-test-case-in-061.patch [bz#1033490] +- kvm-qemu-iotests-Preallocated-zero-clusters-in-061.patch [bz#1033490] +- Resolves: bz#1033490 + (Cannot upgrade/downgrade qcow2 images) + +* Wed Jan 08 2014 Miroslav Rezanina - 1.5.3-34.el7 +- kvm-block-stream-Don-t-stream-unbacked-devices.patch [bz#965636] +- kvm-qemu-io-Let-open-pass-options-to-block-driver.patch [bz#1004347] +- kvm-qcow2.py-Subcommand-for-changing-header-fields.patch [bz#1004347] +- kvm-qemu-iotests-Remaining-error-propagation-adjustments.patch [bz#1004347] +- kvm-qemu-iotests-Add-test-for-inactive-L2-overlap.patch [bz#1004347] +- kvm-qemu-iotests-Adjust-test-result-039.patch [bz#1004347] +- kvm-virtio-net-don-t-update-mac_table-in-error-state.patch [bz#1048671] +- kvm-qcow2-Zero-initialise-first-cluster-for-new-images.patch [bz#1032904] +- Resolves: bz#1004347 + (Backport qcow2 corruption prevention patches) +- Resolves: bz#1032904 + (qemu-img can not create libiscsi qcow2_v3 image) +- Resolves: bz#1048671 + (virtio-net: mac_table change isn't recovered in error state) +- Resolves: bz#965636 + (streaming with no backing file should not do anything) + +* Wed Jan 08 2014 Miroslav Rezanina - 1.5.3-33.el7 +- kvm-block-qemu-iotests-for-vhdx-read-sample-dynamic-imag.patch [bz#879234] +- kvm-block-qemu-iotests-add-quotes-to-TEST_IMG-usage-io-p.patch [bz#879234] +- kvm-block-qemu-iotests-fix-_make_test_img-to-work-with-s.patch [bz#879234] +- kvm-block-qemu-iotests-add-quotes-to-TEST_IMG.base-usage.patch [bz#879234] +- kvm-block-qemu-iotests-add-quotes-to-TEST_IMG-usage-in-0.patch [bz#879234] +- kvm-block-qemu-iotests-removes-duplicate-double-quotes-i.patch [bz#879234] +- kvm-block-vhdx-minor-comments-and-typo-correction.patch [bz#879234] +- kvm-block-vhdx-add-header-update-capability.patch [bz#879234] +- kvm-block-vhdx-code-movement-VHDXMetadataEntries-and-BDR.patch [bz#879234] +- kvm-block-vhdx-log-support-struct-and-defines.patch [bz#879234] +- kvm-block-vhdx-break-endian-translation-functions-out.patch [bz#879234] +- kvm-block-vhdx-update-log-guid-in-header-and-first-write.patch [bz#879234] +- kvm-block-vhdx-code-movement-move-vhdx_close-above-vhdx_.patch [bz#879234] +- kvm-block-vhdx-log-parsing-replay-and-flush-support.patch [bz#879234] +- kvm-block-vhdx-add-region-overlap-detection-for-image-fi.patch [bz#879234] +- kvm-block-vhdx-add-log-write-support.patch [bz#879234] +- kvm-block-vhdx-write-support.patch [bz#879234] +- kvm-block-vhdx-remove-BAT-file-offset-bit-shifting.patch [bz#879234] +- kvm-block-vhdx-move-more-endian-translations-to-vhdx-end.patch [bz#879234] +- kvm-block-vhdx-break-out-code-operations-to-functions.patch [bz#879234] +- kvm-block-vhdx-fix-comment-typos-in-header-fix-incorrect.patch [bz#879234] +- kvm-block-vhdx-add-.bdrv_create-support.patch [bz#879234] +- kvm-block-vhdx-update-_make_test_img-to-filter-out-vhdx-.patch [bz#879234] +- kvm-block-qemu-iotests-for-vhdx-add-write-test-support.patch [bz#879234] +- kvm-block-vhdx-qemu-iotest-log-replay-of-data-sector.patch [bz#879234] +- Resolves: bz#879234 + ([RFE] qemu-img: Add/improve support for VHDX format) + +* Mon Jan 06 2014 Michal Novotny - 1.5.3-32.el7 +- kvm-block-change-default-of-.has_zero_init-to-0.patch.patch [bz#1007815] +- kvm-iscsi-factor-out-sector-conversions.patch.patch [bz#1007815] +- kvm-iscsi-add-logical-block-provisioning-information-to-.patch.patch [bz#1007815] +- kvm-iscsi-add-.bdrv_get_block_status.patch.patch.patch [bz#1007815] +- kvm-iscsi-split-discard-requests-in-multiple-parts.patch.patch.patch [bz#1007815] +- kvm-block-make-BdrvRequestFlags-public.patch.patch.patch [bz#1007815] +- kvm-block-add-flags-to-bdrv_-_write_zeroes.patch.patch.patch [bz#1007815] +- kvm-block-introduce-BDRV_REQ_MAY_UNMAP-request-flag.patch.patch.patch [bz#1007815] +- kvm-block-add-logical-block-provisioning-info-to-BlockDr.patch.patch.patch [bz#1007815] +- kvm-block-add-wrappers-for-logical-block-provisioning-in.patch.patch.patch [bz#1007815] +- kvm-block-iscsi-add-.bdrv_get_info.patch.patch [bz#1007815] +- kvm-block-add-BlockLimits-structure-to-BlockDriverState.patch.patch.patch [bz#1007815] +- kvm-block-raw-copy-BlockLimits-on-raw_open.patch.patch.patch [bz#1007815] +- kvm-block-honour-BlockLimits-in-bdrv_co_do_write_zeroes.patch.patch.patch [bz#1007815] +- kvm-block-honour-BlockLimits-in-bdrv_co_discard.patch.patch.patch [bz#1007815] +- kvm-iscsi-set-limits-in-BlockDriverState.patch.patch.patch [bz#1007815] +- kvm-iscsi-simplify-iscsi_co_discard.patch.patch.patch [bz#1007815] +- kvm-iscsi-add-bdrv_co_write_zeroes.patch.patch.patch [bz#1007815] +- kvm-block-introduce-bdrv_make_zero.patch.patch.patch [bz#1007815] +- kvm-block-get_block_status-fix-BDRV_BLOCK_ZERO-for-unall.patch.patch.patch [bz#1007815] +- kvm-qemu-img-add-support-for-fully-allocated-images.patch.patch.patch [bz#1007815] +- kvm-qemu-img-conditionally-zero-out-target-on-convert.patch.patch.patch [bz#1007815] +- kvm-block-generalize-BlockLimits-handling-to-cover-bdrv_.patch.patch.patch [bz#1007815] +- kvm-block-add-flags-to-BlockRequest.patch.patch.patch [bz#1007815] +- kvm-block-add-flags-argument-to-bdrv_co_write_zeroes-tra.patch.patch.patch [bz#1007815] +- kvm-block-add-bdrv_aio_write_zeroes.patch.patch.patch [bz#1007815] +- kvm-block-handle-ENOTSUP-from-discard-in-generic-code.patch.patch.patch [bz#1007815] +- kvm-block-make-bdrv_co_do_write_zeroes-stricter-in-produ.patch.patch.patch [bz#1007815] +- kvm-vpc-vhdx-add-get_info.patch.patch.patch [bz#1007815] +- kvm-block-drivers-add-discard-write_zeroes-properties-to.patch.patch.patch [bz#1007815] +- kvm-block-drivers-expose-requirement-for-write-same-alig.patch.patch.patch [bz#1007815] +- kvm-block-iscsi-remove-.bdrv_has_zero_init.patch.patch.patch [bz#1007815] +- kvm-block-iscsi-updated-copyright.patch.patch.patch [bz#1007815] +- kvm-block-iscsi-check-WRITE-SAME-support-differently-dep.patch.patch.patch [bz#1007815] +- kvm-scsi-disk-catch-write-protection-errors-in-UNMAP.patch.patch.patch [bz#1007815] +- kvm-scsi-disk-reject-ANCHOR-1-for-UNMAP-and-WRITE-SAME-c.patch.patch.patch [bz#1007815] +- kvm-scsi-disk-correctly-implement-WRITE-SAME.patch.patch.patch [bz#1007815] +- kvm-scsi-disk-fix-WRITE-SAME-with-large-non-zero-payload.patch.patch.patch [bz#1007815] +- kvm-raw-posix-implement-write_zeroes-with-MAY_UNMAP-for-.patch.patch.patch.patch [bz#1007815] +- kvm-raw-posix-implement-write_zeroes-with-MAY_UNMAP-for-.patch.patch.patch.patch.patch [bz#1007815] +- kvm-raw-posix-add-support-for-write_zeroes-on-XFS-and-bl.patch.patch [bz#1007815] +- kvm-qemu-iotests-033-is-fast.patch.patch [bz#1007815] +- kvm-qemu-img-add-support-for-skipping-zeroes-in-input-du.patch.patch [bz#1007815] +- kvm-qemu-img-fix-usage-instruction-for-qemu-img-convert.patch.patch [bz#1007815] +- kvm-block-iscsi-set-bdi-cluster_size.patch.patch [bz#1007815] +- kvm-block-add-opt_transfer_length-to-BlockLimits.patch.patch [bz#1039557] +- kvm-block-iscsi-set-bs-bl.opt_transfer_length.patch.patch [bz#1039557] +- kvm-qemu-img-dynamically-adjust-iobuffer-size-during-con.patch.patch [bz#1039557] +- kvm-qemu-img-round-down-request-length-to-an-aligned-sec.patch.patch [bz#1039557] +- kvm-qemu-img-decrease-progress-update-interval-on-conver.patch.patch [bz#1039557] +- Resolves: bz#1007815 + (fix WRITE SAME support) +- Resolves: bz#1039557 + (optimize qemu-img for thin provisioned images) + +* Fri Dec 27 2013 Daniel Mach - 10:1.5.3-31 +- Mass rebuild 2013-12-27 + +* Wed Dec 18 2013 Michal Novotny - 1.5.3-30.el7 +- kvm-Revert-HMP-Disable-drive_add-for-Red-Hat-Enterprise-2.patch.patch [bz#889051] +- Resolves: bz#889051 + (Commands "__com.redhat_drive_add/del" don' t exist in RHEL7.0) + +* Wed Dec 18 2013 Michal Novotny - 1.5.3-29.el7 +- kvm-QMP-Forward-port-__com.redhat_drive_del-from-RHEL-6.patch [bz#889051] +- kvm-QMP-Forward-port-__com.redhat_drive_add-from-RHEL-6.patch [bz#889051] +- kvm-HMP-Forward-port-__com.redhat_drive_add-from-RHEL-6.patch [bz#889051] +- kvm-QMP-Document-throttling-parameters-of-__com.redhat_d.patch [bz#889051] +- kvm-HMP-Disable-drive_add-for-Red-Hat-Enterprise-Linux.patch [bz#889051] +- Resolves: bz#889051 + (Commands "__com.redhat_drive_add/del" don' t exist in RHEL7.0) + +* Wed Dec 18 2013 Michal Novotny - 1.5.3-28.el7 +- kvm-virtio_pci-fix-level-interrupts-with-irqfd.patch [bz#1035132] +- Resolves: bz#1035132 + (fail to boot and call trace with x-data-plane=on specified for rhel6.5 guest) + +* Wed Dec 18 2013 Michal Novotny - 1.5.3-27.el7 +- Change systemd service location [bz#1025217] +- kvm-vmdk-Allow-read-only-open-of-VMDK-version-3.patch [bz#1007710 bz#1029852] +- Resolves: bz#1007710 + ([RFE] Enable qemu-img to support VMDK version 3) +- Resolves: bz#1025217 + (systemd can't control ksm.service and ksmtuned.service) +- Resolves: bz#1029852 + (qemu-img fails to convert vmdk image with "qemu-img: Could not open 'image.vmdk'") + +* Wed Dec 18 2013 Michal Novotny - 1.5.3-26.el7 +- Add BuildRequires to libRDMAcm-devel for RDMA support [bz#1011720] +- kvm-add-a-header-file-for-atomic-operations.patch [bz#1011720] +- kvm-savevm-Fix-potential-memory-leak.patch [bz#1011720] +- kvm-migration-Fail-migration-on-bdrv_flush_all-error.patch [bz#1011720] +- kvm-rdma-add-documentation.patch [bz#1011720] +- kvm-rdma-introduce-qemu_update_position.patch [bz#1011720] +- kvm-rdma-export-yield_until_fd_readable.patch [bz#1011720] +- kvm-rdma-export-throughput-w-MigrationStats-QMP.patch [bz#1011720] +- kvm-rdma-introduce-qemu_file_mode_is_not_valid.patch [bz#1011720] +- kvm-rdma-introduce-qemu_ram_foreach_block.patch [bz#1011720] +- kvm-rdma-new-QEMUFileOps-hooks.patch [bz#1011720] +- kvm-rdma-introduce-capability-x-rdma-pin-all.patch [bz#1011720] +- kvm-rdma-update-documentation-to-reflect-new-unpin-suppo.patch [bz#1011720]- kvm-rdma-bugfix-ram_control_save_page.patch [bz#1011720] +- kvm-rdma-introduce-ram_handle_compressed.patch [bz#1011720] +- kvm-rdma-core-logic.patch [bz#1011720] +- kvm-rdma-send-pc.ram.patch [bz#1011720] +- kvm-rdma-allow-state-transitions-between-other-states-be.patch [bz#1011720] +- kvm-rdma-introduce-MIG_STATE_NONE-and-change-MIG_STATE_S.patch [bz#1011720] +- kvm-rdma-account-for-the-time-spent-in-MIG_STATE_SETUP-t.patch [bz#1011720] +- kvm-rdma-bugfix-make-IPv6-support-work.patch [bz#1011720] +- kvm-rdma-forgot-to-turn-off-the-debugging-flag.patch [bz#1011720] +- kvm-rdma-correct-newlines-in-error-statements.patch [bz#1011720] +- kvm-rdma-don-t-use-negative-index-to-array.patch [bz#1011720] +- kvm-rdma-qemu_rdma_post_send_control-uses-wrongly-RDMA_W.patch [bz#1011720] +- kvm-rdma-use-DRMA_WRID_READY.patch [bz#1011720] +- kvm-rdma-memory-leak-RDMAContext-host.patch [bz#1011720] +- kvm-rdma-use-resp.len-after-validation-in-qemu_rdma_regi.patch [bz#1011720] +- kvm-rdma-validate-RDMAControlHeader-len.patch [bz#1011720] +- kvm-rdma-check-if-RDMAControlHeader-len-match-transferre.patch [bz#1011720] +- kvm-rdma-proper-getaddrinfo-handling.patch [bz#1011720] +- kvm-rdma-IPv6-over-Ethernet-RoCE-is-broken-in-linux-work.patch [bz#1011720] +- kvm-rdma-remaining-documentation-fixes.patch [bz#1011720] +- kvm-rdma-silly-ipv6-bugfix.patch [bz#1011720] +- kvm-savevm-fix-wrong-initialization-by-ram_control_load_.patch [bz#1011720] +- kvm-arch_init-right-return-for-ram_save_iterate.patch [bz#1011720] +- kvm-rdma-clean-up-of-qemu_rdma_cleanup.patch [bz#1011720] +- kvm-rdma-constify-ram_chunk_-index-start-end.patch [bz#1011720] +- kvm-migration-Fix-debug-print-type.patch [bz#1011720] +- kvm-arch_init-make-is_zero_page-accept-size.patch [bz#1011720] +- kvm-migration-ram_handle_compressed.patch [bz#1011720] +- kvm-migration-fix-spice-migration.patch [bz#1011720] +- kvm-pci-assign-cap-number-of-devices-that-can-be-assigne.patch [bz#678368] +- kvm-vfio-cap-number-of-devices-that-can-be-assigned.patch [bz#678368] +- kvm-Revert-usb-tablet-Don-t-claim-wakeup-capability-for-.patch [bz#1039513] +- kvm-mempath-prefault-pages-manually-v4.patch [bz#1026554] +- Resolves: bz#1011720 + ([HP 7.0 Feat]: Backport RDMA based live guest migration changes from upstream to RHEL7.0 KVM) +- Resolves: bz#1026554 + (qemu: mempath: prefault pages manually) +- Resolves: bz#1039513 + (backport remote wakeup for ehci) +- Resolves: bz#678368 + (RFE: Support more than 8 assigned devices) + +* Wed Dec 18 2013 Michal Novotny - 1.5.3-25.el7 +- kvm-Change-package-description.patch [bz#1017696] +- kvm-seccomp-add-kill-to-the-syscall-whitelist.patch [bz#1026314] +- kvm-json-parser-fix-handling-of-large-whole-number-value.patch [bz#997915] +- kvm-qapi-add-QMP-input-test-for-large-integers.patch [bz#997915] +- kvm-qapi-fix-visitor-serialization-tests-for-numbers-dou.patch [bz#997915] +- kvm-qapi-add-native-list-coverage-for-visitor-serializat.patch [bz#997915] +- kvm-qapi-add-native-list-coverage-for-QMP-output-visitor.patch [bz#997915] +- kvm-qapi-add-native-list-coverage-for-QMP-input-visitor-.patch [bz#997915] +- kvm-qapi-lack-of-two-commas-in-dict.patch [bz#997915] +- kvm-tests-QAPI-schema-parser-tests.patch [bz#997915] +- kvm-tests-Use-qapi-schema-test.json-as-schema-parser-tes.patch [bz#997915] +- kvm-qapi.py-Restructure-lexer-and-parser.patch [bz#997915] +- kvm-qapi.py-Decent-syntax-error-reporting.patch [bz#997915] +- kvm-qapi.py-Reject-invalid-characters-in-schema-file.patch [bz#997915] +- kvm-qapi.py-Fix-schema-parser-to-check-syntax-systematic.patch [bz#997915] +- kvm-qapi.py-Fix-diagnosing-non-objects-at-a-schema-s-top.patch [bz#997915] +- kvm-qapi.py-Rename-expr_eval-to-expr-in-parse_schema.patch [bz#997915] +- kvm-qapi.py-Permit-comments-starting-anywhere-on-the-lin.patch [bz#997915] +- kvm-scripts-qapi.py-Avoid-syntax-not-supported-by-Python.patch [bz#997915] +- kvm-tests-Fix-schema-parser-test-for-in-tree-build.patch [bz#997915] +- Resolves: bz#1017696 + ([branding] remove references to dynamic translation and user-mode emulation) +- Resolves: bz#1026314 + (qemu-kvm hang when use '-sandbox on'+'vnc'+'hda') +- Resolves: bz#997915 + (Backport new QAPI parser proactively to help developers and avoid silly conflicts) + +* Tue Dec 17 2013 Michal Novotny - 1.5.3-24.el7 +- kvm-range-add-Range-structure.patch [bz#1034876] +- kvm-range-add-Range-to-typedefs.patch [bz#1034876] +- kvm-range-add-min-max-operations-on-ranges.patch [bz#1034876] +- kvm-qdev-Add-SIZE-type-to-qdev-properties.patch [bz#1034876] +- kvm-qapi-make-visit_type_size-fallback-to-type_int.patch [bz#1034876] +- kvm-pc-move-IO_APIC_DEFAULT_ADDRESS-to-include-hw-i386-i.patch [bz#1034876] +- kvm-pci-add-helper-to-retrieve-the-64-bit-range.patch [bz#1034876] +- kvm-pci-fix-up-w64-size-calculation-helper.patch [bz#1034876] +- kvm-refer-to-FWCfgState-explicitly.patch [bz#1034876] +- kvm-fw_cfg-move-typedef-to-qemu-typedefs.h.patch [bz#1034876] +- kvm-arch_init-align-MR-size-to-target-page-size.patch [bz#1034876] +- kvm-loader-store-FW-CFG-ROM-files-in-RAM.patch [bz#1034876] +- kvm-pci-store-PCI-hole-ranges-in-guestinfo-structure.patch [bz#1034876] +- kvm-pc-pass-PCI-hole-ranges-to-Guests.patch [bz#1034876] +- kvm-pc-replace-i440fx_common_init-with-i440fx_init.patch [bz#1034876] +- kvm-pc-don-t-access-fw-cfg-if-NULL.patch [bz#1034876] +- kvm-pc-add-I440FX-QOM-cast-macro.patch [bz#1034876] +- kvm-pc-limit-64-bit-hole-to-2G-by-default.patch [bz#1034876] +- kvm-q35-make-pci-window-address-size-match-guest-cfg.patch [bz#1034876] +- kvm-q35-use-64-bit-window-programmed-by-guest.patch [bz#1034876] +- kvm-piix-use-64-bit-window-programmed-by-guest.patch [bz#1034876] +- kvm-pc-fix-regression-for-64-bit-PCI-memory.patch [bz#1034876] +- kvm-cleanup-object.h-include-error.h-directly.patch [bz#1034876] +- kvm-qom-cleanup-struct-Error-references.patch [bz#1034876] +- kvm-qom-add-pointer-to-int-property-helpers.patch [bz#1034876] +- kvm-fw_cfg-interface-to-trigger-callback-on-read.patch [bz#1034876] +- kvm-loader-support-for-unmapped-ROM-blobs.patch [bz#1034876] +- kvm-pcie_host-expose-UNMAPPED-macro.patch [bz#1034876] +- kvm-pcie_host-expose-address-format.patch [bz#1034876] +- kvm-q35-use-macro-for-MCFG-property-name.patch [bz#1034876] +- kvm-q35-expose-mmcfg-size-as-a-property.patch [bz#1034876] +- kvm-i386-add-ACPI-table-files-from-seabios.patch [bz#1034876] +- kvm-acpi-add-rules-to-compile-ASL-source.patch [bz#1034876] +- kvm-acpi-pre-compiled-ASL-files.patch [bz#1034876] +- kvm-acpi-ssdt-pcihp-updat-generated-file.patch [bz#1034876] +- kvm-loader-use-file-path-size-from-fw_cfg.h.patch [bz#1034876] +- kvm-i386-add-bios-linker-loader.patch [bz#1034876] +- kvm-loader-allow-adding-ROMs-in-done-callbacks.patch [bz#1034876] +- kvm-i386-define-pc-guest-info.patch [bz#1034876] +- kvm-acpi-piix-add-macros-for-acpi-property-names.patch [bz#1034876] +- kvm-piix-APIs-for-pc-guest-info.patch [bz#1034876] +- kvm-ich9-APIs-for-pc-guest-info.patch [bz#1034876] +- kvm-pvpanic-add-API-to-access-io-port.patch [bz#1034876] +- kvm-hpet-add-API-to-find-it.patch [bz#1034876] +- kvm-hpet-fix-build-with-CONFIG_HPET-off.patch [bz#1034876] +- kvm-acpi-add-interface-to-access-user-installed-tables.patch [bz#1034876] +- kvm-pc-use-new-api-to-add-builtin-tables.patch [bz#1034876] +- kvm-i386-ACPI-table-generation-code-from-seabios.patch [bz#1034876] +- kvm-ssdt-fix-PBLK-length.patch [bz#1034876] +- kvm-ssdt-proc-update-generated-file.patch [bz#1034876] +- kvm-pc-disable-pci-info.patch [bz#1034876] +- kvm-acpi-build-fix-build-on-glib-2.22.patch [bz#1034876] +- kvm-acpi-build-fix-build-on-glib-2.14.patch [bz#1034876] +- kvm-acpi-build-fix-support-for-glib-2.22.patch [bz#1034876] +- kvm-acpi-build-Fix-compiler-warning-missing-gnu_printf-f.patch [bz#1034876] +- kvm-exec-Fix-prototype-of-phys_mem_set_alloc-and-related.patch [bz#1034876] +- Resolves: bz#1034876 + (export acpi tables to guests) + +* Tue Dec 17 2013 Michal Novotny - 1.5.3-23.el7 +- kvm-qdev-monitor-Unref-device-when-device_add-fails.patch [bz#1003773] +- kvm-qdev-Drop-misleading-qdev_free-function.patch [bz#1003773] +- kvm-blockdev-fix-drive_init-opts-and-bs_opts-leaks.patch [bz#1003773] +- kvm-libqtest-rename-qmp-to-qmp_discard_response.patch [bz#1003773] +- kvm-libqtest-add-qmp-fmt-.-QDict-function.patch [bz#1003773] +- kvm-blockdev-test-add-test-case-for-drive_add-duplicate-.patch [bz#1003773] +- kvm-qdev-monitor-test-add-device_add-leak-test-cases.patch [bz#1003773] +- kvm-qtest-Use-display-none-by-default.patch [bz#1003773] +- Resolves: bz#1003773 + (When virtio-blk-pci device with dataplane is failed to be added, the drive cannot be released.) + +* Tue Dec 17 2013 Michal Novotny - 1.5.3-22.el7 +- Fix ksmtuned with set_process_name=1 [bz#1027420] +- Fix committed memory when no qemu-kvm running [bz#1027418] +- kvm-virtio-net-fix-the-memory-leak-in-rxfilter_notify.patch [bz#1033810] +- kvm-qom-Fix-memory-leak-in-object_property_set_link.patch [bz#1033810] +- kvm-fix-intel-hda-live-migration.patch [bz#1036537] +- kvm-vfio-pci-Release-all-MSI-X-vectors-when-disabled.patch [bz#1029743] +- kvm-Query-KVM-for-available-memory-slots.patch [bz#921490] +- kvm-block-Dont-ignore-previously-set-bdrv_flags.patch [bz#1039501] +- kvm-cleanup-trace-events.pl-New.patch [bz#997832] +- kvm-slavio_misc-Fix-slavio_led_mem_readw-_writew-tracepo.patch [bz#997832] +- kvm-milkymist-minimac2-Fix-minimac2_read-_write-tracepoi.patch [bz#997832] +- kvm-trace-events-Drop-unused-events.patch [bz#997832] +- kvm-trace-events-Fix-up-source-file-comments.patch [bz#997832] +- kvm-trace-events-Clean-up-with-scripts-cleanup-trace-eve.patch [bz#997832] +- kvm-trace-events-Clean-up-after-removal-of-old-usb-host-.patch [bz#997832] +- kvm-net-Update-netdev-peer-on-link-change.patch [bz#1027571] +- Resolves: bz#1027418 + (ksmtuned committed_memory() still returns "", not 0, when no qemu running) +- Resolves: bz#1027420 + (ksmtuned can’t handle libvirt WITH set_process_name=1) +- Resolves: bz#1027571 + ([virtio-win]win8.1 guest network can not resume automatically after do "set_link tap1 on") +- Resolves: bz#1029743 + (qemu-kvm core dump after hot plug/unplug 82576 PF about 100 times) +- Resolves: bz#1033810 + (memory leak in using object_get_canonical_path()) +- Resolves: bz#1036537 + (Cross version migration from RHEL6.5 host to RHEL7.0 host with sound device failed.) +- Resolves: bz#1039501 + ([provisioning] discard=on broken) +- Resolves: bz#921490 + (qemu-kvm core dumped after hot plugging more than 11 VF through vfio-pci) +- Resolves: bz#997832 + (Backport trace fixes proactively to avoid confusion and silly conflicts) + +* Tue Dec 03 2013 Miroslav Rezanina - 1.5.3-21.el7 +- kvm-scsi-Allocate-SCSITargetReq-r-buf-dynamically-CVE-20.patch [bz#1007334] +- Resolves: bz#1007334 + (CVE-2013-4344 qemu-kvm: qemu: buffer overflow in scsi_target_emulate_report_luns [rhel-7.0]) + +* Thu Nov 28 2013 Miroslav Rezanina - 1.5.3-20.el7 +- kvm-pc-drop-virtio-balloon-pci-event_idx-compat-property.patch [bz#1029539] +- kvm-virtio-net-only-delete-bh-that-existed.patch [bz#922463] +- kvm-virtio-net-broken-RX-filtering-logic-fixed.patch [bz#1029370] +- kvm-block-Avoid-unecessary-drv-bdrv_getlength-calls.patch [bz#1025138] +- kvm-block-Round-up-total_sectors.patch [bz#1025138] +- kvm-doc-fix-hardcoded-helper-path.patch [bz#1016952] +- kvm-introduce-RFQDN_REDHAT-RHEL-6-7-fwd.patch [bz#971933] +- kvm-error-reason-in-BLOCK_IO_ERROR-BLOCK_JOB_ERROR-event.patch [bz#971938] +- kvm-improve-debuggability-of-BLOCK_IO_ERROR-BLOCK_JOB_ER.patch [bz#895041] +- kvm-vfio-pci-Fix-multifunction-on.patch [bz#1029275] +- kvm-qcow2-Change-default-for-new-images-to-compat-1.1.patch [bz#1026739] +- kvm-qcow2-change-default-for-new-images-to-compat-1.1-pa.patch [bz#1026739] +- kvm-rng-egd-offset-the-point-when-repeatedly-read-from-t.patch [bz#1032862] +- kvm-Fix-rhel-rhev-conflict-for-qemu-kvm-common.patch [bz#1033463] +- Resolves: bz#1016952 + (qemu-kvm man page guide wrong path for qemu-bridge-helper) +- Resolves: bz#1025138 + (Read/Randread/Randrw performance regression) +- Resolves: bz#1026739 + (qcow2: Switch to compat=1.1 default for new images) +- Resolves: bz#1029275 + (Guest only find one 82576 VF(function 0) while use multifunction) +- Resolves: bz#1029370 + ([whql][netkvm][wlk] Virtio-net device handles RX multicast filtering improperly) +- Resolves: bz#1029539 + (Machine type rhel6.1.0 and balloon device cause migration fail from RHEL6.5 host to RHEL7.0 host) +- Resolves: bz#1032862 + (virtio-rng-egd: repeatedly read same random data-block w/o considering the buffer offset) +- Resolves: bz#1033463 + (can not upgrade qemu-kvm-common to qemu-kvm-common-rhev due to conflicts) +- Resolves: bz#895041 + (QMP: forward port I/O error debug messages) +- Resolves: bz#922463 + (qemu-kvm core dump when virtio-net multi queue guest hot-unpluging vNIC) +- Resolves: bz#971933 + (QMP: add RHEL's vendor extension prefix) +- Resolves: bz#971938 + (QMP: Add error reason to BLOCK_IO_ERROR event) + * Mon Nov 11 2013 Miroslav Rezanina - 1.5.3-19.el7 - kvm-qapi-qapi-visit.py-fix-list-handling-for-union-types.patch [bz#848203] - kvm-qapi-qapi-visit.py-native-list-support.patch [bz#848203]